aboutsummaryrefslogtreecommitdiffstats
path: root/src/k8splugin/plugins/deployment
diff options
context:
space:
mode:
Diffstat (limited to 'src/k8splugin/plugins/deployment')
-rw-r--r--src/k8splugin/plugins/deployment/plugin.go75
-rw-r--r--src/k8splugin/plugins/deployment/plugin_test.go199
2 files changed, 227 insertions, 47 deletions
diff --git a/src/k8splugin/plugins/deployment/plugin.go b/src/k8splugin/plugins/deployment/plugin.go
index 2b4c7cb7..97330b5b 100644
--- a/src/k8splugin/plugins/deployment/plugin.go
+++ b/src/k8splugin/plugins/deployment/plugin.go
@@ -14,55 +14,36 @@ limitations under the License.
package main
import (
- "io/ioutil"
"log"
- "os"
-
- "k8s.io/client-go/kubernetes"
pkgerrors "github.com/pkg/errors"
appsV1 "k8s.io/api/apps/v1"
metaV1 "k8s.io/apimachinery/pkg/apis/meta/v1"
- "k8s.io/client-go/kubernetes/scheme"
+ "k8s.io/client-go/kubernetes"
"k8splugin/krd"
)
-// CreateResource object in a specific Kubernetes Deployment
-func CreateResource(kubedata *krd.GenericKubeResourceData, kubeclient *kubernetes.Clientset) (string, error) {
- if kubedata.Namespace == "" {
- kubedata.Namespace = "default"
- }
-
- if _, err := os.Stat(kubedata.YamlFilePath); err != nil {
- return "", pkgerrors.New("File " + kubedata.YamlFilePath + " not found")
- }
-
- log.Println("Reading deployment YAML")
- rawBytes, err := ioutil.ReadFile(kubedata.YamlFilePath)
- if err != nil {
- return "", pkgerrors.Wrap(err, "Deployment YAML file read error")
+// Create deployment object in a specific Kubernetes cluster
+func Create(data *krd.ResourceData, client kubernetes.Interface) (string, error) {
+ namespace := data.Namespace
+ if namespace == "" {
+ namespace = "default"
}
-
- log.Println("Decoding deployment YAML")
- decode := scheme.Codecs.UniversalDeserializer().Decode
- obj, _, err := decode(rawBytes, nil, nil)
+ obj, err := krd.DecodeYAML(data.YamlFilePath)
if err != nil {
- return "", pkgerrors.Wrap(err, "Deserialize deployment error")
+ return "", pkgerrors.Wrap(err, "Decode deployment object error")
}
- switch o := obj.(type) {
- case *appsV1.Deployment:
- kubedata.DeploymentData = o
- default:
- return "", pkgerrors.New(kubedata.YamlFilePath + " contains another resource different than Deployment")
+ deployment, ok := obj.(*appsV1.Deployment)
+ if !ok {
+ return "", pkgerrors.New("Decoded object contains another resource different than Deployment")
}
+ deployment.Namespace = namespace
+ deployment.Name = data.VnfId + "-" + deployment.Name
- kubedata.DeploymentData.Namespace = kubedata.Namespace
- kubedata.DeploymentData.Name = kubedata.InternalVNFID + "-" + kubedata.DeploymentData.Name
-
- result, err := kubeclient.AppsV1().Deployments(kubedata.Namespace).Create(kubedata.DeploymentData)
+ result, err := client.AppsV1().Deployments(namespace).Create(deployment)
if err != nil {
return "", pkgerrors.Wrap(err, "Create Deployment error")
}
@@ -70,14 +51,14 @@ func CreateResource(kubedata *krd.GenericKubeResourceData, kubeclient *kubernete
return result.GetObjectMeta().GetName(), nil
}
-// ListResources of existing deployments hosted in a specific Kubernetes Deployment
-func ListResources(limit int64, namespace string, kubeclient *kubernetes.Clientset) (*[]string, error) {
+// List of existing deployments hosted in a specific Kubernetes cluster
+func List(namespace string, kubeclient kubernetes.Interface) ([]string, error) {
if namespace == "" {
namespace = "default"
}
opts := metaV1.ListOptions{
- Limit: limit,
+ Limit: krd.ResourcesListLimit,
}
opts.APIVersion = "apps/v1"
opts.Kind = "Deployment"
@@ -87,38 +68,38 @@ func ListResources(limit int64, namespace string, kubeclient *kubernetes.Clients
return nil, pkgerrors.Wrap(err, "Get Deployment list error")
}
- result := make([]string, 0, limit)
+ result := make([]string, 0, krd.ResourcesListLimit)
if list != nil {
for _, deployment := range list.Items {
+ log.Printf("%v", deployment.Name)
result = append(result, deployment.Name)
}
}
- return &result, nil
+ return result, nil
}
-// DeleteResource existing deployments hosting in a specific Kubernetes Deployment
-func DeleteResource(name string, namespace string, kubeclient *kubernetes.Clientset) error {
+// Delete an existing deployment hosted in a specific Kubernetes cluster
+func Delete(name string, namespace string, kubeclient kubernetes.Interface) error {
if namespace == "" {
namespace = "default"
}
- log.Println("Deleting deployment: " + name)
-
deletePolicy := metaV1.DeletePropagationForeground
- err := kubeclient.AppsV1().Deployments(namespace).Delete(name, &metaV1.DeleteOptions{
+ opts := &metaV1.DeleteOptions{
PropagationPolicy: &deletePolicy,
- })
+ }
- if err != nil {
+ log.Println("Deleting deployment: " + name)
+ if err := kubeclient.AppsV1().Deployments(namespace).Delete(name, opts); err != nil {
return pkgerrors.Wrap(err, "Delete Deployment error")
}
return nil
}
-// GetResource existing deployment hosting in a specific Kubernetes Deployment
-func GetResource(name string, namespace string, kubeclient *kubernetes.Clientset) (string, error) {
+// Get an existing deployment hosted in a specific Kubernetes cluster
+func Get(name string, namespace string, kubeclient kubernetes.Interface) (string, error) {
if namespace == "" {
namespace = "default"
}
diff --git a/src/k8splugin/plugins/deployment/plugin_test.go b/src/k8splugin/plugins/deployment/plugin_test.go
new file mode 100644
index 00000000..636629a9
--- /dev/null
+++ b/src/k8splugin/plugins/deployment/plugin_test.go
@@ -0,0 +1,199 @@
+// +build unit
+
+/*
+Copyright 2018 Intel Corporation.
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+ http://www.apache.org/licenses/LICENSE-2.0
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package main
+
+import (
+ "reflect"
+ "strings"
+ "testing"
+
+ "k8splugin/krd"
+
+ appsV1 "k8s.io/api/apps/v1"
+ metaV1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+ testclient "k8s.io/client-go/kubernetes/fake"
+)
+
+func TestCreateDeployment(t *testing.T) {
+ namespace := "test1"
+ name := "mock-deployment"
+ internalVNFID := "1"
+ testCases := []struct {
+ label string
+ input *krd.ResourceData
+ clientOutput *appsV1.Deployment
+ expectedResult string
+ expectedError string
+ }{
+ {
+ label: "Fail to create a deployment with non-existing file",
+ input: &krd.ResourceData{
+ YamlFilePath: "non-existing_test_file.yaml",
+ },
+ clientOutput: &appsV1.Deployment{},
+ expectedError: "not found",
+ },
+ {
+ label: "Fail to create a deployment with invalid type",
+ input: &krd.ResourceData{
+ YamlFilePath: "../../mock_files/mock_yamls/service.yaml",
+ },
+ clientOutput: &appsV1.Deployment{},
+ expectedError: "contains another resource different than Deployment",
+ },
+ {
+ label: "Successfully create a deployment",
+ input: &krd.ResourceData{
+ VnfId: internalVNFID,
+ YamlFilePath: "../../mock_files/mock_yamls/deployment.yaml",
+ },
+ clientOutput: &appsV1.Deployment{
+ ObjectMeta: metaV1.ObjectMeta{
+ Name: name,
+ Namespace: namespace,
+ },
+ },
+ expectedResult: internalVNFID + "-" + name,
+ },
+ }
+
+ for _, testCase := range testCases {
+ client := testclient.NewSimpleClientset(testCase.clientOutput)
+ t.Run(testCase.label, func(t *testing.T) {
+ result, err := Create(testCase.input, client)
+ if err != nil {
+ if !strings.Contains(string(err.Error()), testCase.expectedError) {
+ t.Fatalf("Create method returned an error (%s)", err)
+ }
+ }
+ if !reflect.DeepEqual(testCase.expectedResult, result) {
+ t.Fatalf("Create method returned %v and it was expected (%v)", result, testCase.expectedResult)
+ }
+ })
+ }
+}
+
+func TestListDeployment(t *testing.T) {
+ namespace := "test1"
+ testCases := []struct {
+ label string
+ input string
+ clientOutput *appsV1.DeploymentList
+ expectedResult []string
+ }{
+ {
+ label: "Sucessfully display an empty deployment list",
+ input: namespace,
+ clientOutput: &appsV1.DeploymentList{},
+ expectedResult: []string{},
+ },
+ {
+ label: "Sucessfully display a list of existing deployments",
+ input: namespace,
+ clientOutput: &appsV1.DeploymentList{
+ Items: []appsV1.Deployment{
+ appsV1.Deployment{
+ ObjectMeta: metaV1.ObjectMeta{
+ Name: "test",
+ Namespace: namespace,
+ },
+ },
+ },
+ },
+ expectedResult: []string{"test"},
+ },
+ }
+
+ for _, testCase := range testCases {
+ client := testclient.NewSimpleClientset(testCase.clientOutput)
+ t.Run(testCase.label, func(t *testing.T) {
+ result, err := List(testCase.input, client)
+ if err != nil {
+ t.Fatalf("List method returned an error (%s)", err)
+ }
+ if !reflect.DeepEqual(testCase.expectedResult, result) {
+ t.Fatalf("List method returned %v and it was expected (%v)", result, testCase.expectedResult)
+ }
+ })
+ }
+}
+
+func TestDeleteDeployment(t *testing.T) {
+ namespace := "test1"
+ name := "mock-deployment"
+ testCases := []struct {
+ label string
+ input string
+ clientOutput *appsV1.Deployment
+ }{
+ {
+ label: "Sucessfully delete an existing deployment",
+ input: name,
+ clientOutput: &appsV1.Deployment{
+ ObjectMeta: metaV1.ObjectMeta{
+ Name: name,
+ Namespace: namespace,
+ },
+ },
+ },
+ }
+
+ for _, testCase := range testCases {
+ client := testclient.NewSimpleClientset(testCase.clientOutput)
+ t.Run(testCase.label, func(t *testing.T) {
+ err := Delete(testCase.input, namespace, client)
+ if err != nil {
+ t.Fatalf("Delete method returned an error (%s)", err)
+ }
+ })
+ }
+}
+
+func TestGetDeployment(t *testing.T) {
+ namespace := "test1"
+ name := "mock-deployment"
+ testCases := []struct {
+ label string
+ input string
+ clientOutput *appsV1.Deployment
+ expectedResult string
+ }{
+ {
+ label: "Sucessfully get an existing deployment",
+ input: name,
+ clientOutput: &appsV1.Deployment{
+ ObjectMeta: metaV1.ObjectMeta{
+ Name: name,
+ Namespace: namespace,
+ },
+ },
+ expectedResult: name,
+ },
+ }
+
+ for _, testCase := range testCases {
+ client := testclient.NewSimpleClientset(testCase.clientOutput)
+ t.Run(testCase.label, func(t *testing.T) {
+ result, err := Get(testCase.input, namespace, client)
+ if err != nil {
+ t.Fatalf("Get method returned an error (%s)", err)
+ }
+ if !reflect.DeepEqual(testCase.expectedResult, result) {
+ t.Fatalf("Get method returned %v and it was expected (%v)", result, testCase.expectedResult)
+ }
+ })
+ }
+}