def test_create(self):
name = "yosecret-{0}".format(str(uuid.uuid4()))
secret = utils.create_secret(name=name)
if utils.is_reachable(secret.config.api_host):
secret.create()
_list = secret.list()
self.assertEqual(2, len(_list)) # service-account-token + 1
def test_api_create(self):
ds = DaemonSet(utils.fluentd_daemonset())
k8s_ds = utils.create_daemonset(name=ds.name)
k8s_ds.model = ds
if utils.is_reachable(k8s_ds.config.api_host):
k8s_ds.create()
self.assertIsInstance(k8s_ds, K8sDaemonSet)
def test_get_by_labels_nonexistent(self):
name = "yopod-{0}".format(str(uuid.uuid4()))
config = K8sConfig(kubeconfig=utils.kubeconfig_fallback)
if utils.is_reachable(config.api_host):
pods = K8sPod.get_by_labels(config=config, labels={'name': name})
self.assertIsInstance(pods, list)
self.assertEqual(0, len(pods))
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.api_host):
acct.create()
from_get = acct.get()
self.assertEqual(acct, from_get)
def test_create(self):
name = "yosecret-{0}".format(str(uuid.uuid4()))
secret = utils.create_secret(name=name)
if utils.is_reachable(secret.config.api_host):
secret.create()
_list = secret.list()
self.assertEqual(2, len(_list)) # service-account-token + 1
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.api_host):
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]))
ns = utils.create_namespace(name=name)
if utils.is_reachable(ns.config.api_host):
ns.create()
from_get = ns.get()
self.assertEqual(ns, from_get)
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))
def test_get_nonexistent(self):
name = "yoservice"
svc = utils.create_service(name=name)
if utils.is_reachable(svc.config.api_host):
try:
svc.get()
except Exception as err:
self.assertIsInstance(err, NotFoundException)
def test_update_nothing_changed(self):
name = "yo-{0}".format(unicode(uuid.uuid4().get_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.api_host):
from_create = svc.create()
from_update = svc.update()
self.assertEqual(from_create, from_update)
def test_get_by_name_nonexistent(self):
name = "yo-{0}".format(unicode(uuid.uuid4().get_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.api_host):
_list = K8sService.get_by_name(config=svc.config, name=name)
self.assertIsInstance(_list, list)
self.assertEqual(0, len(_list))
def test_get(self):
name = "yo-{0}".format(unicode(uuid.uuid4().get_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.api_host):
svc.create()
from_get = svc.get()
self.assertIsInstance(from_get, K8sService)
self.assertEqual(svc, from_get)
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.api_host):
try:
pod.create()
self.fail("Should not fail.")
except Exception as err:
self.assertIsInstance(err, UnprocessableEntityException)
def test_delete_nonexistent(self):
name = "yo-{0}".format(unicode(uuid.uuid4().get_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.api_host):
try:
svc.delete()
except Exception as err:
self.assertIsInstance(err, NotFoundException)
def test_list_without_create(self):
name = "yo-{0}".format(unicode(uuid.uuid4().get_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.api_host):
_list = svc.list()
self.assertIsInstance(_list, list)
self.assertEqual(1, len(_list)) # api server exists already
self.assertIsInstance(_list[0], dict)
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())
def test_get_pod_status_nonexistent(self):
name = "yopod-{0}".format(str(uuid.uuid4()))
config = K8sConfig(kubeconfig=utils.kubeconfig_fallback)
pod = utils.create_pod(name=name)
if utils.is_reachable(pod.config.api_host):
try:
pod.get_status()
except Exception as err:
self.assertIsInstance(err, NotFoundException)
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()
def test_get_doesnt_exist(self):
name = "yosecret"
secret = utils.create_secret(name=name)
if utils.is_reachable(secret.config.api_host):
try:
secret.get()
self.fail("Should not fail.")
except Exception as err:
self.assertIsInstance(err, NotFoundException)
def test_delete_nonexistent(self):
name = "yosecret-{0}".format(str(uuid.uuid4()))
secret = utils.create_secret(name=name)
if utils.is_reachable(secret.config.api_host):
try:
secret.delete()
self.fail("Should not fail.")
except Exception as err:
self.assertIsInstance(err, NotFoundException)
def test_update_nonexistent(self):
name = "yopod-{0}".format(str(uuid.uuid4()))
pod = utils.create_pod(name=name)
if utils.is_reachable(pod.config.api_host):
try:
pod.update()
self.fail("Should not fail.")
except Exception as err:
self.assertIsInstance(err, NotFoundException)
def test_object_rc_list_from_scratch(self):
config = K8sConfig(kubeconfig=utils.kubeconfig_fallback)
if config.api_host is not None and utils.is_reachable(config.api_host):
ot = "ReplicationController"
name = "yomama"
obj = utils.create_object(config=config, name=name, obj_type=ot)
r = obj.list()
self.assertIsNotNone(r)
self.assertEqual(0, len(r))
def test_object_service_delete_not_found(self):
config = K8sConfig(kubeconfig=utils.kubeconfig_fallback)
if config.api_host is not None and utils.is_reachable(config.api_host):
ot = "Service"
name = "yomama"
obj = utils.create_object(config=config, name=name, obj_type=ot)
try:
obj.delete()
except Exception as err:
self.assertIsInstance(err, NotFoundException)
def test_object_secret_update_bad_request(self):
config = K8sConfig(kubeconfig=utils.kubeconfig_fallback)
if config.api_host is not None and utils.is_reachable(config.api_host):
ot = "Secret"
name = "yomama"
obj = utils.create_object(config=config, name=name, obj_type=ot)
try:
obj.update()
except Exception as err:
self.assertIsInstance(err, BadRequestException)
def test_object_rc_create_unprocessable(self):
config = K8sConfig(kubeconfig=utils.kubeconfig_fallback)
if config.api_host is not None and utils.is_reachable(config.api_host):
ot = "ReplicationController"
name = "yomama"
obj = utils.create_object(config=config, name=name, obj_type=ot)
try:
obj.create()
except Exception as err:
self.assertIsInstance(err, UnprocessableEntityException)
def test_object_get_with_params_nonexistent(self):
config = K8sConfig(kubeconfig=utils.kubeconfig_fallback)
if config.api_host is not None and utils.is_reachable(config.api_host):
ot = "Pod"
name = "yomama"
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_object_secret_get_model_doesnt_exist(self):
config = K8sConfig(kubeconfig=utils.kubeconfig_fallback)
if config.api_host is not None and utils.is_reachable(config.api_host):
ot = "Secret"
name = "yomama"
obj = utils.create_object(config=config, name=name, obj_type=ot)
try:
obj.get_model()
except Exception as err:
self.assertIsInstance(err, NotFoundException)
def test_update_set_external_ips(self):
name = "yo-{0}".format(unicode(uuid.uuid4().get_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.api_host):
svc.create()
svc.set_external_ips([ip])
svc.update()
self.assertIn(ip, svc.model.model['spec']['externalIPs'])
def test_create_name_too_long(self):
name = "yo-{0}".format(str(uuid.uuid4()))
svc = utils.create_service(name=name)
svc.add_port(name="redis", port=5432, target_port=5432, protocol="tcp")
if utils.is_reachable(svc.config.api_host):
try:
svc.create()
self.fail("Should not fail.")
except Exception as err:
self.assertIsInstance(err, UnprocessableEntityException)
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.api_host):
secret.create()
try:
secret.create()
self.fail("Should not fail.")
except Exception as err:
self.assertIsInstance(err, AlreadyExistsException)
def test_get_by_labels(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_labels(config=pod.config, labels={'name': name})
self.assertIsInstance(pods, list)
self.assertEqual(1, len(pods))
def test_list(self):
count = 10
config = utils.create_config()
if utils.is_reachable(config.api_host):
for i in range(0, count):
name = "yosecret-{0}".format(str(uuid.uuid4()))
secret = utils.create_secret(name=name)
secret.create()
secret = utils.create_secret(name="yosecret")
_list = secret.list()
self.assertEqual(count + 1, len(_list)) # including service-account-token
def test_create_already_exists(self):
name = "yo-{0}".format(unicode(uuid.uuid4().get_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.api_host):
svc.create()
try:
svc.create()
self.fail("Should not fail.")
except Exception as err:
self.assertIsInstance(err, UnprocessableEntityException)
def test_get(self):
name = "yosecret-{0}".format(str(uuid.uuid4()))
secret = utils.create_secret(name=name)
if utils.is_reachable(secret.config.api_host):
from_create = secret.create()
self.assertIsInstance(from_create, K8sSecret)
self.assertEqual(from_create.name, name)
from_get = secret.get()
self.assertIsInstance(from_get, K8sSecret)
self.assertEqual(from_get.name, name)
self.assertEqual(from_create, from_get)
def test_update_dockercfg_json_secret_fails(self):
name = "yosecret-{0}".format(str(uuid.uuid4()))
secret = utils.create_secret(name=name)
v = "yovalue"
if utils.is_reachable(secret.config.api_host):
secret.create()
secret.set_dockercfg_json_secret(data=v)
try:
secret.update()
self.fail("Should not fail.")
except Exception as err:
self.assertIsInstance(err, UnprocessableEntityException)
