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_api_create_hostpath_minikube(self):
cfg = _utils.create_config()
if _utils.is_reachable(cfg):
pv = K8sPersistentVolume(
name="pv-mysql",
type="hostPath")
try:
pv.get()
except NotFoundException:
pv.capacity = {"storage": "512Mi"}
pv.access_modes = ["ReadWriteOnce"]
pv.reclaim_policy = "Delete"
pv.path = "/tmp/mysql/data"
pv.storage_class_name = "manual"
pv.add_label('type', 'local')
print("** creating mysql persistent volume...")
pv.create()
pvc = K8sPersistentVolumeClaim(
config=cfg,
name="pvc-mysql")
try:
pvc.get()
except NotFoundException:
pvc.storage_class_name = "manual"
pvc.access_modes = ['ReadWriteOnce']
pvc.resources = {'requests': {'storage': '512Mi'}}
print("** creating mysql persistent volume claim...")
pvc.create()
self.assertIsInstance(pv, K8sPersistentVolume)
self.assertIsInstance(pvc, K8sPersistentVolumeClaim)
def test_warnings(self):
cfg = _utils.create_config()
if _utils.is_reachable(cfg):
objs = K8sEvent(config=cfg, name="yo").warnings()
for x in objs:
self.assertIsInstance(x, K8sEvent)
def test_get(self):
name = "scheduler"
c = _utils.create_component_status(name=name)
if _utils.is_reachable(c.config):
from_get = c.get()
self.assertIsInstance(from_get, K8sComponentStatus)
self.assertEqual(c, from_get)
def test_delete_nonexistent(self):
name = "yo-{0}".format(str(uuid.uuid4().hex[:16]))
svc = _utils.create_service(name=name)
svc.add_port(name="redis", port=5432, target_port=5432, protocol="tcp")
if _utils.is_reachable(svc.config):
with self.assertRaises(NotFoundException):
svc.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_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_create_already_exists(self):
name = "yo-{0}".format(str(uuid.uuid4().hex[:16]))
node = _utils.create_node(name=name)
if _utils.is_reachable(node.config):
node.create()
with self.assertRaises(AlreadyExistsException):
node.create()
def test_node_affinity_with_required_and_preferred(self):
model = _constants.pod_with_node_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'})
node.labels.update({'another-node-label-key': 'another-node-label-value'})
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()
nodes = K8sNode(config=config, name="yo").list()
for node in nodes:
self.assertIn('kubernetes.io/e2e-az-name', node.labels)
# create the pod
k8s.create()
# untag the nodes
for node in nodes:
node.labels.pop('kubernetes.io/e2e-az-name', None)
node.labels.pop('another-node-label-key', None)
node.update()
pass
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_create(self):
name = "yosecret-{0}".format(str(uuid.uuid4()))
secret = _utils.create_secret(name=name)
if _utils.is_reachable(secret.config):
secret.create()
_list = secret.list()
self.assertEqual(2, len(_list)) # service-account-token + 1
def test_create(self):
name = "mnubo.com-sa-{0}".format(str(uuid.uuid4().hex[:5]))
acct = _utils.create_service_account(name=name)
if _utils.is_reachable(acct.config):
acct.create()
from_get = acct.get()
self.assertEqual(acct, from_get)
def test_update_container_image_keep_env_vars(self):
name = "yodep-{0}".format(str(uuid.uuid4()))
dep = _utils.create_deployment(name=name)
cont_name = "nginx"
cont_image = "nginx:1.7.9"
new_image = "nginx:1.10.3"
env_var_name = "YoVariable"
cont = _utils.create_container(name=cont_name, image=cont_image)
cont.add_env(name=env_var_name, value=name)
dep.add_container(container=cont)
dep.desired_replicas = 1
if _utils.is_reachable(dep.config):
dep.create()
with self.assertRaises(AlreadyExistsException):
dep.create()
# Change the container image
dep.container_image = (cont_name, new_image)
# Update the deployment
dep.update()
# Refresh
dep.get()
for c in dep.containers:
self.assertIsInstance(c, K8sContainer)
if c.name == cont_name:
self.assertEqual(c.image, new_image)
self.assertEqual(c.env[0].name, env_var_name)
self.assertEqual(c.env[0].value, name)
def test_create_no_args(self):
name = "yodep-{0}".format(str(uuid.uuid4()))
dep = _utils.create_deployment(name=name)
if _utils.is_reachable(dep.config):
with self.assertRaises(UnprocessableEntityException):
dep.create()
def test_delete_nonexistent(self):
name = "yorc-{0}".format(str(uuid.uuid4()))
dep = _utils.create_deployment(name=name)
if _utils.is_reachable(dep.config):
with self.assertRaises(NotFoundException):
dep.delete()
def test_object_delete_not_found(self):
ot = "Pod"
name = "yomama-{}".format(str(uuid.uuid4()))
obj = _utils.create_object(name=name, obj_type=ot)
if _utils.is_reachable(obj.config):
with self.assertRaises(NotFoundException):
obj.delete()
def test_rollback_no_args(self):
name = "nginx"
image1 = "nginx:1.7.9"
image2 = "nginx:1.9.1"
container = _utils.create_container(name=name, image=image1)
dep_name = "yodep-{0}".format(str(uuid.uuid4()))
dep = _utils.create_deployment(name=dep_name)
dep.add_container(container)
dep.desired_replicas = 3
if _utils.is_reachable(dep.config):
dep.create()
self.assertEqual(image1, dep.containers[0].image)
dep.container_image = (name, image2)
dep.update()
self.assertIn('deployment.kubernetes.io/revision', dep.annotations)
rev_before = dep.get_annotation('deployment.kubernetes.io/revision')
self.assertNotEqual(image1, dep.containers[0].image)
self.assertEqual(image2, dep.containers[0].image)
dep.rollback()
self.assertIn('deployment.kubernetes.io/revision', dep.annotations)
rev_after = dep.get_annotation('deployment.kubernetes.io/revision')
self.assertNotEqual(rev_before, rev_after)
self.assertGreater(rev_after, rev_before)
self.assertEqual(image1, dep.containers[0].image)
self.assertNotEqual(image2, dep.containers[0].image)
def test_create(self):
name = "yo-{0}".format(str(uuid.uuid4().hex[:16]))
node = _utils.create_node(name=name)
if _utils.is_reachable(node.config):
node.create()
from_get = node.get()
self.assertEqual(node, from_get)
def test_object_secret_update(self):
config = K8sConfig(kubeconfig=_utils.kubeconfig_fallback)
ot = "Secret"
name = "yomama-{}".format(str(uuid.uuid4()))
obj = _utils.create_object(config=config, name=name, obj_type=ot)
if config is not None and _utils.is_reachable(config):
obj.create()
obj.update()
def test_get_by_name_nonexistent(self):
name = "yodep-{0}".format(str(uuid.uuid4()))
dep = _utils.create_deployment(name=name)
if _utils.is_reachable(dep.config):
result = K8sDeployment.get_by_name(config=dep.config, name=name)
self.assertIsInstance(result, list)
self.assertEqual(0, len(result))
def test_object_service_delete_not_found(self):
config = K8sConfig(kubeconfig=_utils.kubeconfig_fallback)
ot = "Service"
name = "yomama-{}".format(str(uuid.uuid4()))
if config is not None and _utils.is_reachable(config):
obj = _utils.create_object(config=config, name=name, obj_type=ot)
with self.assertRaises(NotFoundException):
obj.delete()
def test_object_service_create_unprocessable(self):
config = K8sConfig(kubeconfig=_utils.kubeconfig_fallback)
if config is not None and _utils.is_reachable(config):
ot = "Service"
name = "yomama-{}".format(str(uuid.uuid4()))
obj = _utils.create_object(config=config, name=name, obj_type=ot)
with self.assertRaises(UnprocessableEntityException):
obj.create()
def test_object_secret_create(self):
config = K8sConfig(kubeconfig=_utils.kubeconfig_fallback)
if config is not None and _utils.is_reachable(config):
ot = "Secret"
name = "yomama-{}".format(str(uuid.uuid4()))
obj = _utils.create_object(config=config, name=name, obj_type=ot)
obj.create()
self.assertIsInstance(obj, K8sObject)
def test_object_secret_get_model_doesnt_exist(self):
config = K8sConfig(kubeconfig=_utils.kubeconfig_fallback)
if config is not None and _utils.is_reachable(config):
ot = "Secret"
name = "yomama-{}".format(str(uuid.uuid4()))
obj = _utils.create_object(config=config, name=name, obj_type=ot)
with self.assertRaises(NotFoundException):
obj.get_model()
def test_taint_no_args(self):
config = _utils.create_config()
if _utils.is_reachable(config):
nodes = K8sNode(config=config, name="yo").list()
for node in nodes:
with self.assertRaises(SyntaxError):
node.taint()
def test_list(self):
name = "mnubo.com-sa-{0}".format(str(uuid.uuid4().hex[:5]))
acct = _utils.create_service_account(name=name)
if _utils.is_reachable(acct.config):
acct.create()
_list = acct.list()
for x in _list:
self.assertIsInstance(x, K8sServiceAccount)
def test_list_without_create(self):
name = "yosecret-{0}".format(str(uuid.uuid4()))
secret = _utils.create_secret(name=name)
if _utils.is_reachable(secret.config):
_list = secret.list()
self.assertGreaterEqual(1, len(_list)) # service-account-token on GCE
for x in _list:
self.assertIsInstance(x, K8sSecret)
def test_add_api_token(self):
name = "mnubo.com-sa-{0}".format(str(uuid.uuid4().hex[:5]))
acct = _utils.create_service_account(name=name)
if _utils.is_reachable(acct.config):
acct.create()
acct.add_api_token()
secrets = K8sSecret.api_tokens_for_service_account(config=acct.config, name=acct.name)
self.assertEqual(2, len(secrets))
def test_get(self):
name = "yo-{0}".format(str(uuid.uuid4().hex[:16]))
n = _utils.create_node(name=name)
if _utils.is_reachable(n.config):
n.create()
from_get = n.get()
self.assertIsInstance(from_get, K8sNode)
self.assertEqual(n, from_get)
def test_api_create(self):
name = "testcfgmap-{}".format(uuid.uuid4())
config_map = ConfigMap(_constants.configmap())
k8s_configmap = _utils.create_configmap(name=name)
k8s_configmap.model = config_map
if _utils.is_reachable(k8s_configmap.config):
k8s_configmap.create()
self.assertIsInstance(k8s_configmap, K8sConfigMap)
def test_list_without_create(self):
name = "yosecret-{0}".format(str(uuid.uuid4()))
secret = _utils.create_secret(name=name)
if _utils.is_reachable(secret.config):
_list = secret.list()
self.assertGreaterEqual(1,
len(_list)) # service-account-token on GCE
for x in _list:
self.assertIsInstance(x, K8sSecret)
def test_delete_nonexistent(self):
name = "yosecret-{0}".format(str(uuid.uuid4()))
secret = _utils.create_secret(name=name)
if _utils.is_reachable(secret.config):
try:
secret.delete()
self.fail("Should not fail.")
except Exception as err:
self.assertIsInstance(err, NotFoundException)
def test_get(self):
name = "yo-{0}".format(str(uuid.uuid4().hex[:16]))
svc = _utils.create_service(name=name)
svc.add_port(name="redis", port=5432, target_port=5432, protocol="tcp")
if _utils.is_reachable(svc.config):
svc.create()
from_get = svc.get()
self.assertIsInstance(from_get, K8sService)
self.assertEqual(svc, from_get)
def test_list(self):
name = "yo-{0}".format(str(uuid.uuid4().hex[:16]))
ns = _utils.create_namespace(name=name)
if _utils.is_reachable(ns.config):
ns.create()
_list = ns.list()
for x in _list:
self.assertIsInstance(x, K8sNamespace)
self.assertIsInstance(_list, list)
def test_add_api_token(self):
name = "mnubo.com-sa-{0}".format(str(uuid.uuid4().hex[:5]))
acct = _utils.create_service_account(name=name)
if _utils.is_reachable(acct.config):
acct.create()
acct.add_api_token()
secrets = K8sSecret.api_tokens_for_service_account(
config=acct.config, name=acct.name)
self.assertEqual(2, len(secrets))
def test_create_without_selector(self):
k8s_container = _utils.create_container(name="nginx",
image="nginx:latest")
k8s_ds = _utils.create_daemonset(name="yo")
k8s_ds.add_container(k8s_container)
if _utils.is_reachable(k8s_ds.config):
k8s_ds.create()
self.assertIsInstance(k8s_ds, K8sDaemonSet)
self.assertEqual(k8s_ds.name, "yo")
def test_server_version_no_kubeconfig(self):
api_host = "127.0.0.1:8001"
cfg = K8sConfig(kubeconfig=None, api_host=api_host)
if _utils.is_reachable(cfg.api_host):
container = _utils.create_container(name="nginx", image="nginx:latest")
cj = _utils.create_cronjob(config=cfg, name="test")
cj.add_container(container)
cj.create()
self.assertIsInstance(cj, K8sCronJob)
def test_get_doesnt_exist(self):
name = "yosecret"
secret = _utils.create_secret(name=name)
if _utils.is_reachable(secret.config):
try:
secret.get()
self.fail("Should not fail.")
except Exception as err:
self.assertIsInstance(err, NotFoundException)
def test_delete(self):
name = "yoname"
rs = _utils.create_rs(name=name)
config = _utils.create_config()
if _utils.is_reachable(config):
_utils.cleanup_rs()
result = rs.list()
self.assertIsInstance(result, list)
self.assertEqual(0, len(result))
def test_object_rc_list_from_scratch(self):
config = K8sConfig(kubeconfig=_utils.kubeconfig_fallback)
if config is not None and _utils.is_reachable(config):
ot = "ReplicationController"
name = "yomama-{}".format(str(uuid.uuid4()))
obj = _utils.create_object(config=config, name=name, obj_type=ot)
r = obj.list()
self.assertIsNotNone(r)
self.assertEqual(0, len(r))
def test_update_set_cluster_ip_fails(self):
name = "yo-{0}".format(str(uuid.uuid4().hex[:16]))
svc = _utils.create_service(name=name)
svc.add_port(name="redis", port=5432, target_port=5432, protocol="tcp")
if _utils.is_reachable(svc.config):
svc.create()
svc.cluster_ip = "192.168.123.123"
with self.assertRaises(UnprocessableEntityException):
svc.update()
def test_create_service_account_api_token(self):
sa = _utils.create_service_account(name='build-robot')
if _utils.is_reachable(sa.config):
sa.create()
secret = K8sSecret.create_service_account_api_token(
config=sa.config, name=sa.name)
self.assertIsInstance(secret, K8sSecret)
secrets = K8sSecret.api_tokens_for_service_account(
config=sa.config, name=sa.name)
self.assertEqual(2, len(secrets))
def test_api_list(self):
name = "job-{}".format(uuid.uuid4())
job = Job(_constants.job())
k8s_job = _utils.create_job(name=name)
k8s_job.model = job
if _utils.is_reachable(k8s_job.config):
k8s_job.create()
_list = k8s_job.list()
for x in _list:
self.assertIsInstance(x, K8sJob)
def test_api_scale(self):
name = "job-{}".format(uuid.uuid4())
job = Job(_constants.job())
k8s_job = _utils.create_job(name=name)
k8s_job.model = job
k8s_job.completions = 30
if _utils.is_reachable(k8s_job.config.api_host):
k8s_job.create()
k8s_job.scale(10)
self.assertEqual(k8s_job.parallelism, 10)
def test_create_already_exists(self):
name = "yosecret-{0}".format(str(uuid.uuid4()))
secret = _utils.create_secret(name=name)
if _utils.is_reachable(secret.config):
secret.create()
try:
secret.create()
self.fail("Should not fail.")
except Exception as err:
self.assertIsInstance(err, AlreadyExistsException)
def test_add_image_pull_secret(self):
name = "mnubo.com-sa-{0}".format(str(uuid.uuid4().hex[:5]))
acct = _utils.create_service_account(name=name)
data = {"auths": {"repo:port": {"auth": "authstring", "email": "*****@*****.**"}}}
if _utils.is_reachable(acct.config):
acct.create()
secret = K8sSecret.create_image_pull_secret(config=acct.config, name=acct.name, data=data)
acct.add_image_pull_secret(secret)
secrets = K8sSecret.list_image_pull_secrets()
self.assertEqual(1, len(secrets))
def test_untaint(self):
config = _utils.create_config()
key = "key"
value = "value"
if _utils.is_reachable(config):
nodes = K8sNode(config=config, name="yo").list()
for node in nodes:
node.untaint(key=key, value=value)
self.assertEqual(0, len(node.taints))
def test_stateful_nginx(self):
svc = Service(headless_service())
sset = StatefulSet(stateful_set())
k8s_svc = K8sService(name='headless')
k8s_sset = K8sStatefulSet(name='sset')
k8s_svc.model = svc
k8s_sset.model = sset
if _utils.is_reachable(k8s_svc.config):
k8s_svc.create()
k8s_sset.create()
def test_update_set_external_ips(self):
name = "yo-{0}".format(str(uuid.uuid4().hex[:16]))
svc = _utils.create_service(name=name)
svc.add_port(name="redis", port=5432, target_port=5432, protocol="tcp")
ip = "192.168.123.123"
if _utils.is_reachable(svc.config):
svc.create()
svc.external_ips = [ip]
svc.update()
self.assertIn(ip, svc.external_ips)
def test_set_cluster_ip_invalid_ip_address(self):
name = "yoservice"
svc = _utils.create_service(name=name)
svc.add_port("http", 80, 80, "TCP")
if _utils.is_reachable(svc.config):
svc.create()
ip = "192.168.00000.1234345"
svc.cluster_ip = ip
with self.assertRaises(UnprocessableEntityException):
svc.update()
def test_list(self):
ds = DaemonSet(_constants.fluentd_daemonset())
k8s_ds = _utils.create_daemonset(name=ds.name)
k8s_ds.model = ds
if _utils.is_reachable(k8s_ds.config):
k8s_ds.create()
_list = k8s_ds.list()
for x in _list:
self.assertIsInstance(x, K8sDaemonSet)
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_issue_64(self):
name = "yosecret-{0}".format(str(uuid.uuid4()))
secret_data = {"test": "test"}
secret = _utils.create_secret(name=name)
secret.data = secret_data
if _utils.is_reachable(secret.config):
secret.create()
secret.get()
self.assertIsInstance(secret, K8sSecret)
self.assertEqual(secret.data, secret_data)
def test_object_get_with_params_nonexistent(self):
config = K8sConfig(kubeconfig=_utils.kubeconfig_fallback)
if config is not None and _utils.is_reachable(config):
ot = "Pod"
name = "yomama-{}".format(str(uuid.uuid4()))
obj = _utils.create_object(config=config, name=name, obj_type=ot)
data = {"yokey": "yovalue"}
r = obj.get_with_params(data)
self.assertIsNotNone(r)
self.assertEqual(0, len(r))
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_taint_invalid_effect(self):
config = _utils.create_config()
key = "key"
value = "value"
effect = "AvadaKedavra"
if _utils.is_reachable(config):
nodes = K8sNode(config=config, name="yo").list()
for node in nodes:
with self.assertRaises(SyntaxError):
node.taint(key=key, value=value, effect=effect)
def test_get_pod_logs(self):
cname = "yocontainer"
container = _utils.create_container(name=cname)
name = "yopod-{0}".format(str(uuid.uuid4()))
pod = _utils.create_pod(name=name)
pod.add_container(container)
if _utils.is_reachable(pod.config):
with self.assertRaises(NotFoundException):
pod.get_log()
pod.get_log(container=cname)
def test_pods(self):
cfg = _utils.create_config()
if _utils.is_reachable(cfg):
nodes = K8sNode(config=cfg, name="yo").list()
for node in nodes:
pods = node.pods
self.assertIsInstance(pods, list)
for pod in pods:
self.assertIsInstance(pod, K8sPod)
def test_delete(self):
name = "yo-{0}".format(str(uuid.uuid4().hex[:16]))
ns = _utils.create_namespace(name=name)
if _utils.is_reachable(ns.config):
ns.create()
from_get = K8sNamespace.get_by_name(ns.config, ns.name)
self.assertIsInstance(from_get, K8sNamespace)
self.assertEqual(name, from_get.name)
ns.delete()
from_get = K8sNamespace.get_by_name(ns.config, ns.name)
self.assertIsNone(from_get)
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))
