def _create_fake_core_v1_with_pods(self):
        fake_core_v1 = MagicMock()

        fake_pods = MagicMock()
        fake_pods.items = [
            utils.create_pod(self._POD_1_NAME),
            utils.create_pod(self._POD_2_NAME),
        ]
        fake_core_v1.list_namespaced_pod.return_value = fake_pods

        return fake_core_v1
예제 #2
0
 def test_set_annotations(self):
     name = "yopod-{0}".format(str(uuid.uuid4()))
     pod = utils.create_pod(name=name)
     anns_in = {'key': 'value'}
     pod.set_annotations(anns_in)
     anns_out = pod.get_annotations()
     self.assertEqual(anns_in, anns_out)
예제 #3
0
    def test_get_label_doesnt_exist(self):
        name = "yopod-{0}".format(str(uuid.uuid4()))
        pod = utils.create_pod(name=name)

        k = "yonotexists"
        l = pod.get_label(k)
        self.assertIsNone(l)
예제 #4
0
    def test_get_annotation_doesnt_exist(self):
        name = "yopod-{0}".format(str(uuid.uuid4()))
        pod = utils.create_pod(name=name)

        k = "yonotexists"
        ann = pod.get_annotation(k)
        self.assertIsNone(ann)
예제 #5
0
 def test_del_label_none_arg(self):
     name = "yopod-{0}".format(str(uuid.uuid4()))
     pod = utils.create_pod(name=name)
     try:
         pod.del_label()
     except Exception as err:
         self.assertIsInstance(err, SyntaxError)
예제 #6
0
 def test_set_labels(self):
     name = "yopod-{0}".format(str(uuid.uuid4()))
     pod = utils.create_pod(name=name)
     labels_in = {'key': 'value'}
     pod.set_labels(labels_in)
     labels_out = pod.get_labels()
     self.assertEqual(labels_in, labels_out)
예제 #7
0
 def test_del_label_none_yet(self):
     name = "yopod-{0}".format(str(uuid.uuid4()))
     pod = utils.create_pod(name=name)
     k = "yokey"
     self.assertNotIn(k, pod.model.metadata.labels)
     pod.del_label(k)
     self.assertNotIn(k, pod.model.metadata.labels)
 def test_pod_set_termination_grace_period(self):
     name = "yoname"
     obj = utils.create_pod(name=name)
     secs_in = 1234
     obj.set_termination_grace_period(secs_in)
     secs_out = obj.get_termination_grace_period()
     self.assertEqual(secs_in, secs_out)
예제 #9
0
 def test_list_nonexistent(self):
     name = "yopod-{0}".format(str(uuid.uuid4()))
     pod = utils.create_pod(name=name)
     if utils.is_reachable(pod.config.api_host):
         p = pod.list()
         self.assertIsInstance(p, list)
         self.assertEqual(0, len(p))
예제 #10
0
 def test_struct_k8spod(self):
     name = "yomama"
     pod = utils.create_pod(name=name)
     self.assertIsNotNone(pod)
     self.assertIsInstance(pod, K8sPod)
     self.assertIsNotNone(pod.model)
     self.assertIsInstance(pod.model, Pod)
예제 #11
0
 def test_init_with_config_and_pull_secrets(self):
     ps = "yomama"
     name = "sofat"
     cfg = K8sConfig(kubeconfig=utils.kubeconfig_fallback, pull_secret=ps)
     pod = utils.create_pod(config=cfg, name=name)
     self.assertIsNotNone(pod.config)
     self.assertEqual(ps, pod.config.pull_secret)
예제 #12
0
 def test_get_node_selector(self):
     name = "yoname"
     s_in = {"disktype": "ssd"}
     pod = utils.create_pod(name=name)
     pod.node_selector = s_in
     s_out = pod.node_selector
     self.assertEqual(s_in, s_out)
예제 #13
0
 def test_add_annotation_none_args(self):
     name = "yopod-{0}".format(str(uuid.uuid4()))
     pod = utils.create_pod(name=name)
     try:
         pod.add_annotation()
     except Exception as err:
         self.assertIsInstance(err, SyntaxError)
예제 #14
0
 def test_pod_add_image_pull_secrets(self):
     name = "yoname"
     pod = utils.create_pod(name=name)
     secret = [{'name': 'yosecret'}]
     pod.add_image_pull_secrets(secret)
     self.assertEqual(1, len(pod.model.spec.image_pull_secrets))
     self.assertEqual(secret, pod.model.spec.image_pull_secrets)
예제 #15
0
 def test_add_label_invalid_args(self):
     name = "yopod-{0}".format(str(uuid.uuid4()))
     pod = utils.create_pod(name=name)
     k = object()
     v = object()
     with self.assertRaises(SyntaxError):
         pod.add_label(k, v)
예제 #16
0
 def test_struct_pod(self):
     name = "yomama"
     pod = utils.create_pod(name=name)
     self.assertIsInstance(pod.model, Pod)
     self.assertIsInstance(pod.model.metadata, ObjectMeta)
     self.assertIsInstance(pod.model.spec, PodSpec)
     self.assertIsInstance(pod.model.status, PodStatus)
예제 #17
0
 def test_pod_set_service_account(self):
     name = "yoname"
     obj = utils.create_pod(name=name)
     name_in = "yoservice"
     obj.set_service_account(name_in)
     name_out = obj.get_service_account()
     self.assertEqual(name_in, name_out)
예제 #18
0
 def test_pod_set_pod_restart_policy(self):
     name = "yoname"
     obj = utils.create_pod(name=name)
     policy = "Always"
     obj.set_pod_restart_policy(policy=policy)
     p = obj.get_pod_restart_policy()
     self.assertEqual(policy, p)
예제 #19
0
    def test_api_create_aws_ebs(self):
        pvname = "yopv"
        pvcname = "yopvc"
        volname = "yovolume"
        podname = "yopod"
        contname = "yocontainer"

        pvtype = "awsElasticBlockStore"
        pv = utils.create_pv(name=pvname, type=pvtype)
        pv.volume_id = "vol-0e3056a2"
        pv.fs_type = "xfs"

        pvc = utils.create_pvc(name=pvcname)

        vol = utils.create_volume(name=volname, type='persistentVolumeClaim')
        vol.claim_name = pvcname

        container = utils.create_container(name=contname, image="nginx:latest")
        volmount = utils.create_volume_mount(name=volname,
                                             mount_path='/test-persistent')
        container.add_volume_mount(volmount)

        pod = utils.create_pod(name=podname)
        pod.add_volume(vol)
        pod.add_container(container)

        if utils.is_reachable(pvc.config.api_host):
            try:
                pv.create()
                pvc.create()
                pod.create()
                self.assertIsInstance(pv, K8sPersistentVolume)
                self.assertIsInstance(pvc, K8sPersistentVolumeClaim)
            except Exception as err:
                self.assertIsInstance(err, TimedOutException)
예제 #20
0
    def test_api_create_nfs(self):
        pvname = "yopv"
        pvcname = "yopvc"
        volname = "yovolume"
        podname = "yopod"
        contname = "yocontainer"

        pvtype = "nfs"
        pv = utils.create_pv(name=pvname, type=pvtype)
        pv.nfs_server = "nfs.company.com"
        pv.nfs_path = "/fs1/test-nfs"

        pvc = utils.create_pvc(name=pvcname)

        vol = utils.create_volume(name=volname, type='persistentVolumeClaim')
        vol.claim_name = pvcname

        container = utils.create_container(name=contname, image="nginx:latest")
        volmount = utils.create_volume_mount(name=volname,
                                             mount_path='/test-persistent')
        container.add_volume_mount(volmount)

        pod = utils.create_pod(name=podname)
        pod.add_volume(vol)
        pod.add_container(container)

        if utils.is_reachable(pvc.config.api_host):
            try:
                pv.create()
                pvc.create()
                pod.create()
                self.assertIsInstance(pv, K8sPersistentVolume)
                self.assertIsInstance(pvc, K8sPersistentVolumeClaim)
            except Exception as err:
                self.assertIsInstance(err, TimedOutException)
예제 #21
0
    def test_pod_nfs(self):
        container_name = "nginx"
        container_image = "nginx:1.7.9"
        container = utils.create_container(name=container_name,
                                           image=container_image)

        vol_name = "nfs"
        vol_type = "nfs"
        server = "howard.mtl.mnubo.com"
        nfs_path = "/fs1/test-nfs"
        volume = utils.create_volume(name=vol_name, type=vol_type)
        volume.nfs_server = server
        volume.nfs_path = nfs_path

        mount_name = vol_name
        mount_path = '/test-nfs'
        mount = K8sVolumeMount(name=mount_name, mount_path=mount_path)
        container.add_volume_mount(mount)

        pod_name = "nginx-{0}".format(str(uuid.uuid4()))
        pod = utils.create_pod(name=pod_name)
        pod.add_volume(volume)
        pod.add_container(container)

        if utils.is_reachable(pod.config.api_host):
            try:
                pod.create()
                volnames = [x.name for x in pod.volumes]
                self.assertIn(vol_name, volnames)
            except Exception as err:
                self.assertIsInstance(err, TimedOutException)
예제 #22
0
    def test_pod_git_repo(self):
        container_name = "nginx"
        container_image = "nginx:1.7.9"
        container = utils.create_container(name=container_name,
                                           image=container_image)

        vol_name = "git-repo"
        vol_type = "gitRepo"
        repo = "https://*****:*****@somewhere/repo.git"
        revision = "e42d3dca1541ba085f34ce282feda1109a707c7b"
        volume = utils.create_volume(name=vol_name, type=vol_type)
        volume.git_repository = repo
        volume.git_revision = revision

        mount_name = vol_name
        mount_path = '/test-git'
        mount = K8sVolumeMount(name=mount_name, mount_path=mount_path)
        container.add_volume_mount(mount)

        pod_name = "nginx-{0}".format(str(uuid.uuid4()))
        pod = utils.create_pod(name=pod_name)
        pod.add_volume(volume)
        pod.add_container(container)

        if utils.is_reachable(pod.config.api_host):
            try:
                pod.create()
                volnames = [x.name for x in pod.volumes]
                self.assertIn(vol_name, volnames)
            except Exception as err:
                self.assertIsInstance(err, TimedOutException)
예제 #23
0
    def test_pod_aws_ebs(self):
        container_name = "nginx"
        container_image = "nginx:1.7.9"
        container = utils.create_container(name=container_name,
                                           image=container_image)

        volume_id = "vol-0e3056a2"
        vol_name = "ebs"
        vol_type = "awsElasticBlockStore"
        volume = utils.create_volume(name=vol_name, type=vol_type)
        volume.volume_id = volume_id

        mount_name = vol_name
        mount_path = '/test-aws'
        mount = K8sVolumeMount(name=mount_name, mount_path=mount_path)
        container.add_volume_mount(mount)

        pod_name = "nginx-{0}".format(str(uuid.uuid4()))
        pod = utils.create_pod(name=pod_name)
        pod.add_volume(volume)
        pod.add_container(container)

        if utils.is_reachable(pod.config.api_host):
            try:
                pod.create()
                volnames = [x.name for x in pod.volumes]
                self.assertIn(vol_name, volnames)
            except Exception as err:
                self.assertIsInstance(err, TimedOutException)
예제 #24
0
    def test_pod_gce_pd(self):
        container_name = "nginx"
        container_image = "nginx:1.7.9"
        container = utils.create_container(name=container_name,
                                           image=container_image)

        pd_name = "kubernetes-py-test-pd"
        vol_name = "persistent"
        vol_type = "gcePersistentDisk"
        volume = utils.create_volume(name=vol_name, type=vol_type)
        volume.pd_name = pd_name

        mount_name = vol_name
        mount_path = '/test-gce'
        mount = K8sVolumeMount(name=mount_name, mount_path=mount_path)
        container.add_volume_mount(mount)

        pod_name = "nginx-{0}".format(str(uuid.uuid4()))
        pod = utils.create_pod(name=pod_name)
        pod.add_volume(volume)
        pod.add_container(container)

        if utils.is_reachable(pod.config.api_host):
            try:
                pod.create()
                volnames = [x.name for x in pod.volumes]
                self.assertIn(vol_name, volnames)
            except Exception as err:
                self.assertIsInstance(err, TimedOutException)
예제 #25
0
    def test_pod_secret(self):
        container_name = "nginx"
        container_image = "nginx:1.7.9"
        container = utils.create_container(name=container_name,
                                           image=container_image)

        secret_name = "yosecret"
        secret = utils.create_secret(name=secret_name)
        k = ".secret-file"
        v = "dmFsdWUtMg0KDQo="
        secret.data = {k: v}

        vol_name = "secret"
        vol_type = "secret"
        volume = utils.create_volume(name=vol_name, type=vol_type)
        volume.secret_name = secret_name

        mount_name = vol_name
        mount_path = '/test-secret'
        mount = K8sVolumeMount(name=mount_name, mount_path=mount_path)
        container.add_volume_mount(mount)

        pod_name = "nginx"
        pod = utils.create_pod(name=pod_name)
        pod.add_volume(volume)
        pod.add_container(container)

        if utils.is_reachable(pod.config.api_host):
            secret.create()
            pod.create()
            volnames = [x.name for x in pod.volumes]
            self.assertIn(vol_name, volnames)
예제 #26
0
    def test_pod_hostpath(self):
        container_name = "nginx"
        container_image = "nginx:1.7.9"
        container = utils.create_container(name=container_name,
                                           image=container_image)

        vol_name = "hostpath"
        vol_type = "hostPath"
        host_path = "/var/lib/docker"
        volume = utils.create_volume(name=vol_name, type=vol_type)
        volume.path = host_path

        mount_name = vol_name
        mount_path = '/test-hostpath'
        mount = K8sVolumeMount(name=mount_name, mount_path=mount_path)
        container.add_volume_mount(mount)

        pod_name = "nginx"
        pod = utils.create_pod(name=pod_name)
        pod.add_volume(volume)
        pod.add_container(container)

        if utils.is_reachable(pod.config.api_host):
            pod.create()
            volnames = [x.name for x in pod.volumes]
            self.assertIn(vol_name, volnames)
예제 #27
0
 def test_list_nonexistent(self):
     name = "yopod-{0}".format(str(uuid.uuid4()))
     pod = utils.create_pod(name=name)
     if utils.is_reachable(pod.config.api_host):
         p = pod.list()
         self.assertIsInstance(p, list)
         self.assertEqual(0, len(p))
예제 #28
0
 def test_del_annotation_none_yet(self):
     name = "yopod-{0}".format(str(uuid.uuid4()))
     pod = utils.create_pod(name=name)
     k = "yokey"
     self.assertEqual({}, pod.annotations)
     pod.del_annotation(k)
     self.assertEqual({}, pod.annotations)
예제 #29
0
 def test_pod_get_pod_restart_policy(self):
     name = "yoname"
     obj = utils.create_pod(name=name)
     p_in = "OnFailure"
     obj.set_pod_restart_policy(p_in)
     p_out = obj.get_pod_restart_policy()
     self.assertEqual(p_in, p_out)
예제 #30
0
 def test_add_annotation_none_args(self):
     name = "yopod-{0}".format(str(uuid.uuid4()))
     pod = utils.create_pod(name=name)
     try:
         pod.add_annotation()
     except Exception as err:
         self.assertIsInstance(err, SyntaxError)
예제 #31
0
 def test_struct_k8spod(self):
     name = "yomama"
     pod = utils.create_pod(name=name)
     self.assertIsNotNone(pod)
     self.assertIsInstance(pod, K8sPod)
     self.assertIsNotNone(pod.model)
     self.assertIsInstance(pod.model, Pod)
예제 #32
0
 def test_is_ready_nonexistent(self):
     name = "yopod-{0}".format(str(uuid.uuid4()))
     pod = utils.create_pod(name=name)
     if utils.is_reachable(pod.config.api_host):
         with self.assertRaises(NotFoundException):
             pod.is_ready()
             self.fail("Should not fail.")
예제 #33
0
 def test_pod_get_pod_node_name(self):
     name = "yoname"
     obj = utils.create_pod(name=name)
     nodename = "yonodename"
     obj.set_pod_node_name(name=nodename)
     name = obj.get_pod_node_name()
     self.assertEqual(name, nodename)
예제 #34
0
 def test_init_with_config_and_pull_secrets(self):
     ps = [{'name': 'yomama'}]
     name = "sofat"
     cfg = K8sConfig(kubeconfig=utils.kubeconfig_fallback, pull_secret=ps)
     pod = utils.create_pod(config=cfg, name=name)
     self.assertIsNotNone(pod.config)
     self.assertEqual(ps, pod.config.pull_secret)
예제 #35
0
 def test_pod_get_service_account(self):
     name = "yoname"
     pod = utils.create_pod(name=name)
     name_in = "yoservice"
     pod.service_account_name = name_in
     name_out = pod.service_account_name
     self.assertEqual(name_in, name_out)
예제 #36
0
 def test_struct_pod_model(self):
     name = "yomama"
     pod = utils.create_pod(name=name)
     model = pod.model.model
     self.assertIsNotNone(model)
     self.assertIsInstance(model, dict)
     self.assertIn('apiVersion', model)
     self.assertIsInstance(model['apiVersion'], str)
     self.assertIn('kind', model)
     self.assertIsInstance(model['kind'], str)
     self.assertIn('metadata', model)
     self.assertIsInstance(model['metadata'], dict)
     self.assertIn('labels', model['metadata'])
     self.assertIsInstance(model['metadata']['labels'], dict)
     self.assertIn('name', model['metadata']['labels'])
     self.assertEqual(model['metadata']['labels']['name'], name)
     self.assertIn('name', model['metadata'])
     self.assertIsInstance(model['metadata']['name'], str)
     self.assertEqual(model['metadata']['name'], name)
     self.assertIn('namespace', model['metadata'])
     self.assertIsInstance(model['metadata']['namespace'], str)
     self.assertIn('spec', model)
     self.assertIsInstance(model['spec'], dict)
     self.assertIn('containers', model['spec'])
     self.assertIsInstance(model['spec']['containers'], list)
     self.assertIn('dnsPolicy', model['spec'])
     self.assertIsInstance(model['spec']['dnsPolicy'], str)
     self.assertIn('restartPolicy', model['spec'])
     self.assertIsInstance(model['spec']['restartPolicy'], str)
     self.assertIn('volumes', model['spec'])
     self.assertIsInstance(model['spec']['volumes'], list)
예제 #37
0
 def test_set_namespace(self):
     name = "yopod-{0}".format(str(uuid.uuid4()))
     pod = utils.create_pod(name=name)
     nspace_in = "yonamespace"
     pod.set_namespace(nspace_in)
     nspace_out = pod.get_namespace()
     self.assertEqual(nspace_in, nspace_out)
예제 #38
0
 def test_get_node_name(self):
     name = "yoname"
     nodename = "yonodename"
     pod = utils.create_pod(name=name)
     pod.node_name = nodename
     self.assertEqual(nodename, pod.node_name)
     self.assertEqual(nodename, pod.model.spec.node_name)
예제 #39
0
 def test_pod_get_pod_node_selector(self):
     name = "yoname"
     obj = utils.create_pod(name=name)
     s_in = {"disktype": "ssd"}
     obj.set_pod_node_selector(selector=s_in)
     s_out = obj.get_pod_node_selector()
     self.assertEqual(s_in, s_out)
예제 #40
0
 def test_get_label(self):
     name = "yopod-{0}".format(str(uuid.uuid4()))
     pod = utils.create_pod(name=name)
     k = "yokey"
     v_in = "yovalue"
     pod.add_label(k, v_in)
     v_out = pod.get_label(k)
     self.assertEqual(v_in, v_out)
예제 #41
0
 def test_add_label(self):
     name = "yopod-{0}".format(str(uuid.uuid4()))
     pod = utils.create_pod(name=name)
     k = "yokey"
     v_in = "yovalue"
     pod.add_label(k, v_in)
     v_out = pod.get_label(k)
     self.assertEqual(v_in, v_out)
예제 #42
0
 def test_set_namespace_none_args(self):
     name = "yopod-{0}".format(str(uuid.uuid4()))
     pod = utils.create_pod(name=name)
     try:
         pod.set_namespace()
         self.fail("Should not fail.")
     except Exception as err:
         self.assertIsInstance(err, SyntaxError)
예제 #43
0
 def test_del_annotation_invalid_arg(self):
     name = "yopod-{0}".format(str(uuid.uuid4()))
     pod = utils.create_pod(name=name)
     k = object()
     try:
         pod.del_annotation(k)
     except Exception as err:
         self.assertIsInstance(err, SyntaxError)
예제 #44
0
 def test_pod_set_pod_node_name_invalid_arg(self):
     name = "yoname"
     obj = utils.create_pod(name=name)
     nodename = 666
     try:
         obj.set_pod_node_name(name=nodename)
     except Exception as err:
         self.assertIsInstance(err, SyntaxError)
예제 #45
0
 def test_struct_pod(self):
     name = "yomama"
     pod = utils.create_pod(name=name)
     model = pod.model
     self.assertIsInstance(model.model, dict)
     self.assertIsInstance(model.pod_metadata, ObjectMeta)
     self.assertIsInstance(model.pod_spec, PodSpec)
     self.assertIsNone(model.pod_status)
예제 #46
0
 def test_pod_set_termination_grace_period_none_arg(self):
     name = "yoname"
     obj = utils.create_pod(name=name)
     try:
         obj.set_termination_grace_period()
         self.fail("Should not fail.")
     except Exception as err:
         self.assertIsInstance(err, SyntaxError)
예제 #47
0
 def test_pod_set_service_account_none_arg(self):
     name = "yoname"
     obj = utils.create_pod(name=name)
     try:
         obj.set_service_account()
         self.fail("Should not fail.")
     except Exception as err:
         self.assertIsInstance(err, SyntaxError)
예제 #48
0
 def test_pod_set_pod_node_selector_invalid_arg(self):
     name = "yoname"
     obj = utils.create_pod(name=name)
     s_in = "yoselector"
     try:
         obj.set_pod_node_selector(selector=s_in)
     except Exception as err:
         self.assertIsInstance(err, SyntaxError)
예제 #49
0
 def test_init_with_model_pod(self):
     name = "yoname"
     obj = utils.create_pod(name=name)
     self.assertIsInstance(obj.model, Pod)
     self.assertIsInstance(obj.model.model, dict)
     self.assertIsInstance(obj.model.pod_metadata, ObjectMeta)
     self.assertIsInstance(obj.model.pod_spec, PodSpec)
     self.assertIsNone(obj.model.pod_status)
예제 #50
0
 def test_pod_set_active_deadline_invalid_arg(self):
     name = "yoname"
     obj = utils.create_pod(name=name)
     d = "yodeadline"
     try:
         obj.set_active_deadline(d)
     except Exception as err:
         self.assertIsInstance(err, SyntaxError)
예제 #51
0
 def test_init_object_type_pod(self):
     ot = "Pod"
     name = "yopod"
     obj = utils.create_pod(name=name)
     self.assertIsNotNone(obj)
     self.assertIsInstance(obj, K8sPodBasedObject)
     self.assertEqual(ot, obj.obj_type)
     self.assertEqual(name, obj.name)
예제 #52
0
 def test_add_annotation(self):
     name = "yopod-{0}".format(str(uuid.uuid4()))
     pod = utils.create_pod(name=name)
     k = "yokey"
     v = "yovalue"
     pod.add_annotation(k, v)
     self.assertEqual(1, len(pod.model.metadata.annotations))
     self.assertIn(k, pod.model.metadata.annotations)
     self.assertEqual(v, pod.model.metadata.annotations[k])
예제 #53
0
 def test_pod_set_pod_restart_policy_invalid_arg(self):
     name = "yoname"
     obj = utils.create_pod(name=name)
     policy = "yopolicy"
     try:
         obj.set_pod_restart_policy(policy=policy)
         self.fail("Should not fail.")
     except Exception as err:
         self.assertIsInstance(err, SyntaxError)
예제 #54
0
 def test_pod_add_image_pull_secrets_invalid_arg(self):
     name = "yoname"
     obj = utils.create_pod(name=name)
     secretname = 666
     try:
         obj.add_image_pull_secrets(secretname)
         self.fail("Should not fail.")
     except Exception as err:
         self.assertIsInstance(err, SyntaxError)
예제 #55
0
 def test_is_ready(self):
     name = "yocontainer"
     container = utils.create_container(name=name)
     name = "yopod-{0}".format(str(uuid.uuid4()))
     pod = utils.create_pod(name=name)
     pod.add_container(container)
     if utils.is_reachable(pod.config.api_host):
         p = pod.create()
         self.assertTrue(p.is_ready())
예제 #56
0
 def test_pod_add_volume_hostpath_no_path_specified(self):
     name = "yoname"
     obj = utils.create_pod(name=name)
     config = utils.create_config()
     vol = K8sVolume(config=config, name=name, mount_path="/var/test", type="hostPath")
     if utils.is_reachable(config.api_host):
         with self.assertRaises(UnprocessableEntityException):
             obj.add_volume(vol)
             obj.create()
예제 #57
0
 def test_list(self):
     name = "yopod-{0}".format(str(uuid.uuid4()))
     pod = utils.create_pod(name=name)
     container = utils.create_container(name=name)
     pod.add_container(container)
     if utils.is_reachable(pod.config.api_host):
         pod.create()
         _list = pod.list()
         for x in _list:
             self.assertIsInstance(x, K8sPod)
예제 #58
0
 def test_pod_add_container(self):
     name = "yoname"
     pod = utils.create_pod(name=name)
     self.assertEqual(0, len(pod.model.spec.containers))
     name = "yopod"
     image = "redis"
     c = K8sContainer(name=name, image=image)
     pod.add_container(c)
     self.assertEqual(1, len(pod.model.spec.containers))
     self.assertEqual(c.model, pod.model.spec.containers[0])
예제 #59
0
 def test_get_by_name(self):
     name = "yocontainer"
     container = utils.create_container(name=name)
     name = "yopod-{0}".format(str(uuid.uuid4()))
     pod = utils.create_pod(name=name)
     pod.add_container(container)
     if utils.is_reachable(pod.config.api_host):
         pod.create()
         pods = K8sPod.get_by_name(config=pod.config, name=name)
         self.assertIsInstance(pods, list)
         self.assertEqual(1, len(pods))
예제 #60
0
 def test_del_label(self):
     name = "yopod-{0}".format(str(uuid.uuid4()))
     pod = utils.create_pod(name=name)
     k = "yokey"
     v = "yovalue"
     pod.add_label(k, v)
     self.assertTrue(hasattr(pod.model.metadata, 'labels'))
     self.assertIn(k, pod.model.metadata.labels)
     pod.del_label(k)
     self.assertTrue(hasattr(pod.model.metadata, 'labels'))
     self.assertNotIn(k, pod.model.metadata.labels)