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):
pod.create()
volnames = [x.name for x in pod.volumes]
self.assertIn(vol_name, volnames)
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)
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)
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)
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_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)
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)
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)
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)
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_delete_nonexistent(self):
name = "yopod-{0}".format(str(uuid.uuid4()))
pod = _utils.create_pod(name=name)
if _utils.is_reachable(pod.config):
with self.assertRaises(NotFoundException):
pod.delete()
def test_create_without_containers(self):
name = "yopod-{0}".format(str(uuid.uuid4()))
pod = _utils.create_pod(name=name)
if _utils.is_reachable(pod.config):
with self.assertRaises(UnprocessableEntityException):
pod.create()
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):
try:
pv.create()
pvc.create()
pod.create()
self.assertIsInstance(pv, K8sPersistentVolume)
self.assertIsInstance(pvc, K8sPersistentVolumeClaim)
except Exception as err:
self.assertIsInstance(err, TimedOutException)
def test_get_pod_status_nonexistent(self):
name = "yopod-{0}".format(str(uuid.uuid4()))
pod = _utils.create_pod(name=name)
if _utils.is_reachable(pod.config):
with self.assertRaises(NotFoundException):
s = pod.status
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)
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)
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)
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)
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):
secret.create()
pod.create()
volnames = [x.name for x in pod.volumes]
self.assertIn(vol_name, volnames)
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):
try:
pod.create()
volnames = [x.name for x in pod.volumes]
self.assertIn(vol_name, volnames)
except Exception as err:
self.assertIsInstance(err, TimedOutException)
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):
try:
pod.create()
volnames = [x.name for x in pod.volumes]
self.assertIn(vol_name, volnames)
except Exception as err:
self.assertIsInstance(err, TimedOutException)
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)
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):
try:
pod.create()
volnames = [x.name for x in pod.volumes]
self.assertIn(vol_name, volnames)
except Exception as err:
self.assertIsInstance(err, TimedOutException)
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):
try:
pv.create()
pvc.create()
pod.create()
self.assertIsInstance(pv, K8sPersistentVolume)
self.assertIsInstance(pvc, K8sPersistentVolumeClaim)
except Exception as err:
self.assertIsInstance(err, TimedOutException)
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)
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)
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)
def test_create_without_containers(self):
name = "yopod-{0}".format(str(uuid.uuid4()))
pod = _utils.create_pod(name=name)
if _utils.is_reachable(pod.config):
with self.assertRaises(UnprocessableEntityException):
pod.create()
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)
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)
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)
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)
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):
try:
pod.create()
volnames = [x.name for x in pod.volumes]
self.assertIn(vol_name, volnames)
except Exception as err:
self.assertIsInstance(err, TimedOutException)
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)
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):
with self.assertRaises(NotFoundException):
pod.is_ready()
self.fail("Should not fail.")
def test_api_create_gce_pd(self):
pvname = "yopv"
pvcname = "yopvc"
volname = "yovolume"
podname = "yopod"
contname = "yocontainer"
pvtype = "gcePersistentDisk"
pv = _utils.create_pv(name=pvname, type=pvtype)
pv.pd_name = "mnubo-disk1"
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):
try:
pv.create()
pvc.create()
pod.create()
self.assertIsInstance(pv, K8sPersistentVolume)
self.assertIsInstance(pvc, K8sPersistentVolumeClaim)
except Exception as err:
self.assertIsInstance(err, TimedOutException)
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)
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):
with self.assertRaises(NotFoundException):
pod.is_ready()
self.fail("Should not fail.")
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)
def test_pod_affinities(self):
config = _utils.create_config()
container = _utils.create_container(name="nginx", image="nginx:latest")
pod_s1 = _utils.create_pod(config=config, name="s1")
pod_s1.labels.update({'security': 'S1'})
pod_s1.node_selector = {'kubernetes.io/e2e-az-name': 'e2e-az1'}
pod_s1.add_container(container)
pod_s2 = _utils.create_pod(config=config, name="s2")
pod_s2.labels.update({'security': 'S2'})
pod_s2.node_selector = {'kubernetes.io/e2e-az-name': 'e2e-az2'}
pod_s2.add_container(container)
model = _constants.pod_with_pod_affinity()
pod = Pod(model)
config = _utils.create_config()
k8s = K8sPod(config=config, name="yo")
k8s.model = pod
if _utils.is_reachable(config):
# ensure we have enough nodes
nodes = K8sNode(config=config, name="yo").list()
if len(nodes) < 3:
self.skipTest(reason='Not enough nodes to perform test.')
else:
self.assertGreaterEqual(len(nodes), 3)
# tag the nodes
for i in range(len(nodes)):
node = nodes[i]
if i == 0:
node.labels.update(
{'kubernetes.io/e2e-az-name': 'e2e-az1'})
if i == 1:
node.labels.update(
{'kubernetes.io/e2e-az-name': 'e2e-az2'})
if i == 2:
node.labels.update(
{'kubernetes.io/e2e-az-name': 'e2e-az3'})
node.update()
# create the pods for affinity lookup
pod_s1.create()
pod_s2.create()
# create the pod with affinities
k8s.create()
pass
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])
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)
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)
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):
p = pod.create()
self.assertTrue(p.is_ready())
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])
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):
pod.create()
_list = pod.list()
for x in _list:
self.assertIsInstance(x, K8sPod)
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])
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])
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):
p = pod.create()
self.assertTrue(p.is_ready())
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)
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):
pod.create()
_list = pod.list()
for x in _list:
self.assertIsInstance(x, K8sPod)
def test_tolerations_default(self):
config = _utils.create_config()
container = _utils.create_container(name="nginx", image="nginx:latest")
pod = _utils.create_pod(config=config, name="yo")
pod.add_container(container)
if _utils.is_reachable(config):
pod.create()
pod.get()
# default 'NoExecute' tolerations
# 'node.alpha.kubernetes.io/notReady' && 'node.alpha.kubernetes.io/unreachable'
self.assertEqual(2, len(pod.tolerations))
def test_del_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.assertTrue(hasattr(pod.model.metadata, 'annotations'))
self.assertIn(k, pod.model.metadata.annotations)
self.assertEqual(v, pod.model.metadata.annotations[k])
pod.del_annotation(k)
self.assertTrue(hasattr(pod.model.metadata, 'annotations'))
self.assertNotIn(k, pod.model.metadata.annotations)
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):
pod.create()
pods = K8sPod.get_by_name(config=pod.config, name=name)
self.assertIsInstance(pods, list)
self.assertEqual(1, len(pods))
def test_pod_affinities(self):
config = _utils.create_config()
container = _utils.create_container(name="nginx", image="nginx:latest")
pod_s1 = _utils.create_pod(config=config, name="s1")
pod_s1.labels.update({'security': 'S1'})
pod_s1.node_selector = {'kubernetes.io/e2e-az-name': 'e2e-az1'}
pod_s1.add_container(container)
pod_s2 = _utils.create_pod(config=config, name="s2")
pod_s2.labels.update({'security': 'S2'})
pod_s2.node_selector = {'kubernetes.io/e2e-az-name': 'e2e-az2'}
pod_s2.add_container(container)
model = _constants.pod_with_pod_affinity()
pod = Pod(model)
config = _utils.create_config()
k8s = K8sPod(config=config, name="yo")
k8s.model = pod
if _utils.is_reachable(config):
# ensure we have enough nodes
nodes = K8sNode(config=config, name="yo").list()
self.assertGreaterEqual(len(nodes), 3)
# tag the nodes
for i in range(len(nodes)):
node = nodes[i]
if i == 0:
node.labels.update({'kubernetes.io/e2e-az-name': 'e2e-az1'})
if i == 1:
node.labels.update({'kubernetes.io/e2e-az-name': 'e2e-az2'})
if i == 2:
node.labels.update({'kubernetes.io/e2e-az-name': 'e2e-az3'})
node.update()
# create the pods for affinity lookup
pod_s1.create()
pod_s2.create()
# create the pod with affinities
k8s.create()
pass
def test_get_pod_status(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):
p = pod.create()
result = p.status
self.assertIsInstance(result, PodStatus)
for i in ['conditions', 'container_statuses', 'host_ip', 'phase', 'pod_ip', 'reason', 'start_time']:
self.assertTrue(hasattr(result, i))
def test_get(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):
from_create = pod.create()
from_get = pod.get()
self.assertIsInstance(from_create, K8sPod)
self.assertIsInstance(from_get, K8sPod)
self.assertEqual(from_create, from_get)
def test_create_already_exists(self):
name = "yocontainer"
c = _utils.create_container(name=name)
name = "yopod-{0}".format(str(uuid.uuid4()))
pod = _utils.create_pod(name=name)
pod.add_container(c)
if _utils.is_reachable(pod.config):
with self.assertRaises(AlreadyExistsException):
result = pod.create()
self.assertIsInstance(result, K8sPod)
self.assertEqual(pod, result)
pod.create()
