def test_init_with_invalid_name(self):
name = object()
try:
utils.create_service(name=name)
self.fail("Should not fail.")
except Exception as err:
self.assertIsInstance(err, SyntaxError)
def test_set_service_type(self):
name = "yoservice"
svc = utils.create_service(name=name)
for i in ['ClusterIP', 'NodePort', 'LoadBalancer']:
svc.set_service_type(i)
self.assertIn('type', svc.model.model['spec'])
self.assertEqual(i, svc.model.model['spec']['type'])
def test_get_meta_creation_timestamp(self):
name = "yoservice"
svc = utils.create_service(name=name)
tstamp_in = "yotimestamp"
svc.set_meta_creation_timestamp(tstamp_in)
tstamp_out = svc.get_meta_creation_timestamp()
self.assertEqual(tstamp_in, tstamp_out)
def test_set_session_affinity(self):
name = "yoservice"
svc = utils.create_service(name=name)
for i in ['None', 'ClientIP']:
svc.set_session_affinity(i)
self.assertIn('sessionAffinity', svc.model.model['spec'])
self.assertEqual(i, svc.model.model['spec']['sessionAffinity'])
def test_add_selector(self):
name = "yoservice"
svc = utils.create_service(name=name)
sel = {'abc': 'def'}
svc.add_selector(selector=sel)
self.assertIn('selector', svc.model.model['spec'])
self.assertEqual(sel, svc.model.model['spec']['selector'])
def test_get_meta_generation(self):
name = "yoservice"
svc = utils.create_service(name=name)
gen_in = 2
svc.set_meta_generation(gen_in)
gen_out = svc.get_meta_generation()
self.assertEqual(gen_in, gen_out)
def test_struct_service_model(self):
name = "yoname"
svc = utils.create_service(name=name)
model = svc.model.model
self.assertIsInstance(model, dict)
self.assertEqual(4, len(model))
for i in ['apiVersion', 'kind', 'metadata', 'spec']:
self.assertIn(i, model)
for i in ['apiVersion', 'kind']:
self.assertIsInstance(model[i], str)
for i in ['metadata', 'spec']:
self.assertIsInstance(model[i], dict)
self.assertEqual(3, len(model['metadata']))
for i in ['labels', 'name', 'namespace']:
self.assertIn(i, model['metadata'])
self.assertIsInstance(model['metadata']['labels'], dict)
for i in ['name', 'namespace']:
self.assertIsInstance(model['metadata'][i], str)
self.assertEqual(4, len(model['spec']))
for i in ['ports', 'selector', 'sessionAffinity', 'type']:
self.assertIn(i, model['spec'])
self.assertIsInstance(model['spec']['ports'], list)
self.assertIsInstance(model['spec']['selector'], dict)
for i in ['sessionAffinity', 'type']:
self.assertIsInstance(model['spec'][i], str)
def test_get_meta_self_link(self):
name = "yoservice"
svc = utils.create_service(name=name)
slink_in = "yoselflink"
svc.set_meta_self_link(slink_in)
slink_out = svc.get_meta_self_link()
self.assertEqual(slink_in, slink_out)
def test_get_meta_resource_version(self):
name = "yoservice"
svc = utils.create_service(name=name)
ver_in = "yoversion"
svc.set_meta_resource_version(ver_in)
ver_out = svc.get_meta_resource_version()
self.assertEqual(ver_in, ver_out)
def test_get_external_ips(self):
name = "yoservice"
svc = utils.create_service(name=name)
eips_in = ["192.168.99.100"]
svc.set_external_ips(eips_in)
eips_out = svc.get_external_ips()
self.assertEqual(eips_in, eips_out)
def test_get_cluster_ip(self):
name = "yoservice"
svc = utils.create_service(name=name)
cip_in = "192.168.99.100"
svc.set_cluster_ip(cip_in)
cip_out = svc.get_cluster_ip()
self.assertEqual(cip_in, cip_out)
def test_struct_service(self):
name = "yoname"
svc = utils.create_service(name=name)
self.assertIsInstance(svc, K8sService)
self.assertIsInstance(svc.model, Service)
self.assertIsInstance(svc.model.model, dict)
self.assertIsInstance(svc.model.svc_metadata, ObjectMeta)
def test_get_meta_uid(self):
name = "yoservice"
svc = utils.create_service(name=name)
uid_in = "yoselflink"
svc.set_meta_uid(uid_in)
uid_out = svc.get_meta_uid()
self.assertEqual(uid_in, uid_out)
def test_set_labels(self):
name = "yoservice"
svc = utils.create_service(name=name)
labels = {'yokey': 'yovalue'}
svc.set_labels(labels)
self.assertIn('labels', svc.model.model['metadata'])
self.assertEqual(labels, svc.model.model['metadata']['labels'])
def test_set_external_ip(self):
name = "yoservice"
svc = utils.create_service(name=name)
eips = ["192.168.99.100"]
svc.set_external_ips(eips)
self.assertIn('externalIPs', svc.model.model['spec'])
self.assertEqual(eips, svc.model.model['spec']['externalIPs'])
def test_set_annotations(self):
name = "yoservice"
svc = utils.create_service(name=name)
anns = {'yokey': 'yovalue'}
svc.set_annotations(anns)
self.assertIn('annotations', svc.model.model['metadata'])
self.assertEqual(anns, svc.model.model['metadata']['annotations'])
def test_set_cluster_ip(self):
name = "yoservice"
svc = utils.create_service(name=name)
cip = "192.168.99.100"
svc.set_cluster_ip(cip)
self.assertIn('clusterIP', svc.model.model['spec'])
self.assertEqual(cip, svc.model.model['spec']['clusterIP'])
def test_set_load_balancer_ip(self):
name = "yoservice"
svc = utils.create_service(name=name)
lbip = "192.168.99.100"
svc.set_load_balancer_ip(lbip)
self.assertIn('loadBalancerIP', svc.model.model['spec'])
self.assertEqual(lbip, svc.model.model['spec']['loadBalancerIP'])
def test_get_labels(self):
name = "yoservice"
svc = utils.create_service(name=name)
labels_in = {'yokey': 'yovalue'}
svc.set_labels(labels_in)
labels_out = svc.get_labels()
self.assertEqual(labels_in, labels_out)
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_set_load_balancer_ip_none_arg(self):
name = "yoservice"
svc = utils.create_service(name=name)
try:
svc.set_load_balancer_ip()
self.fail("Should not fail.")
except Exception as err:
self.assertIsInstance(err, SyntaxError)
def test_set_labels_none_arg(self):
name = "yoservice"
svc = utils.create_service(name=name)
try:
svc.set_labels()
self.fail('Should not fail.')
except Exception as err:
self.assertIsInstance(err, SyntaxError)
def test_init_with_name(self):
name = "yoname"
svc = utils.create_service(name=name)
self.assertIsNotNone(svc)
self.assertIsInstance(svc, K8sService)
self.assertEqual('Service', svc.obj_type)
self.assertEqual(svc.name, name)
self.assertIsInstance(svc.config, K8sConfig)
def test_add_selector_none_arg(self):
name = "yoservice"
svc = utils.create_service(name=name)
try:
svc.add_selector()
self.fail("Should not fail.")
except Exception as err:
self.assertIsInstance(err, SyntaxError)
def test_set_meta_resource_version_none_arg(self):
name = "yoservice"
svc = utils.create_service(name=name)
try:
svc.set_meta_resource_version()
self.fail("Should not fail.")
except Exception as err:
self.assertIsInstance(err, SyntaxError)
def test_add_label(self):
name = "yoservice"
svc = utils.create_service(name=name)
k = "yokey"
v = "yovalue"
svc.add_label(k, v)
self.assertIn(k, svc.labels)
self.assertEqual(v, svc.labels[k])
def test_get_label(self):
name = "yoservice"
svc = utils.create_service(name=name)
k = "yokey"
v_in = "yovalue"
svc.add_label(k, v_in)
v_out = svc.get_label(k)
self.assertEqual(v_in, v_out)
def test_del_server_generated_meta_doesnt_exist(self):
name = "yoservice"
svc = utils.create_service(name=name)
svc.del_server_generated_meta_attr()
for i in ['generation', 'resourceVersion', 'creationTimestamp',
'deletionTimestamp', 'deletionGracePeriodSeconds', 'status', 'selfLink', 'uid']:
self.assertNotIn(i, svc.model.model['metadata'])
self.assertNotIn(i, svc.model.svc_metadata.model)
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_add_annotation(self):
name = "yoservice"
svc = utils.create_service(name=name)
k = "yokey"
v = "yovalue"
svc.add_annotation(k, v)
self.assertIn(k, svc.annotations)
self.assertEqual(v, svc.annotations[k])
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_set_session_affinity_invalid_string(self):
name = "yoservice"
svc = utils.create_service(name=name)
aff = 'yoaffinity'
try:
svc.set_session_affinity(aff)
except Exception as err:
self.assertIsInstance(err, SyntaxError)
def test_get_by_name_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.api_host):
_list = K8sService.get_by_name(config=svc.config, name=name)
self.assertIsInstance(_list, list)
self.assertEqual(0, len(_list))
def test_get_annotation(self):
name = "yoservice"
svc = utils.create_service(name=name)
k = "yokey"
v_in = "yovalue"
svc.add_annotation(k, v_in)
v_out = svc.get_annotation(k)
self.assertEqual(v_in, v_out)
def test_init_with_name(self):
name = "yoname"
svc = utils.create_service(name=name)
self.assertIsNotNone(svc)
self.assertIsInstance(svc, K8sService)
self.assertEqual('Service', svc.obj_type)
self.assertEqual(svc.name, name)
self.assertIsInstance(svc.config, K8sConfig)
def test_list_without_create(self):
name = "yo-{0}".format(str(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_update_set_cluster_ip_fails(self):
name = "yo-{0}".format(str(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()
svc.cluster_ip = "192.168.123.123"
with self.assertRaises(UnprocessableEntityException):
svc.update()
def test_get(self):
name = "yo-{0}".format(str(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_struct_k8s_service(self):
name = "yoname"
svc = utils.create_service(name=name)
self.assertIsInstance(svc, K8sService)
self.assertIsInstance(svc.base_url, str)
self.assertIsInstance(svc.config, K8sConfig)
self.assertIsInstance(svc.model, Service)
self.assertIsInstance(svc.name, str)
self.assertIsInstance(svc.obj_type, str)
def test_update_set_external_ips(self):
name = "yo-{0}".format(str(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.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.api_host):
svc.create()
ip = "192.168.00000.1234345"
svc.cluster_ip = ip
with self.assertRaises(UnprocessableEntityException):
svc.update()
def test_add_annotation_invalid_args(self):
name = "yoservice"
svc = utils.create_service(name=name)
k = object()
v = object()
try:
svc.add_annotation(k, v)
self.fail("Should not fail.")
except Exception as err:
self.assertIsInstance(err, SyntaxError)
def test_init_with_name_and_config(self):
nspace = "yonamespace"
config = K8sConfig(kubeconfig=utils.kubeconfig_fallback, namespace=nspace)
name = "yoname"
svc = utils.create_service(config=config, name=name)
self.assertIsNotNone(svc)
self.assertIsInstance(svc, K8sService)
self.assertEqual(svc.name, name)
self.assertEqual('Service', svc.obj_type)
self.assertIsInstance(svc.config, K8sConfig)
self.assertEqual(nspace, svc.config.namespace)
def test_get_by_name(self):
name = "yo-{0}".format(str(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()
_list = K8sService.get_by_name(config=svc.config, name=name)
self.assertIsInstance(_list, list)
self.assertEqual(1, len(_list))
from_get = _list[0]
self.assertIsInstance(from_get, K8sService)
self.assertEqual(from_get, svc)
def test_list(self):
name = "yo-{0}".format(str(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()
_list = svc.list()
self.assertIsInstance(_list, list)
self.assertEqual(2, len(_list)) # api server exists already
from_query = _list[1]
self.assertIsInstance(from_query, dict)
self.assertEqual(name, from_query['metadata']['name'])
def test_delete(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.api_host):
svc.create()
from_get = K8sService.get_by_name(svc.config, svc.name)
self.assertIsInstance(from_get, list)
self.assertIn(svc, from_get)
svc.delete()
from_get = K8sService.get_by_name(svc.config, svc.name)
self.assertNotIn(svc, from_get)
def test_get_annotations(self):
name = "yoservice"
svc = utils.create_service(name=name)
count = 4
for i in range(0, count):
k = "yokey_{0}".format(i)
v = "yovalue_{0}".format(i)
svc.add_annotation(k, v)
self.assertEqual(count, len(svc.annotations))
for i in range(0, count):
k = "yokey_{0}".format(i)
v = "yovalue_{0}".format(i)
self.assertIn(k, svc.annotations)
self.assertEqual(v, svc.annotations[k])
def test_update_with_full_model(self):
data = {
"kind": "Service",
"apiVersion": "v1",
"metadata": {
"name": "frontend",
"namespace": "default",
"labels": {
"name": "frontend"
}
},
"spec": {
"ports": [
{
"protocol": "TCP",
"port": 8082,
"targetPort": "feport",
"nodePort": 8082
}
],
"selector": {
"name": "frontend"
},
"clusterIP": "10.250.1.27",
"type": "NodePort",
"sessionAffinity": "None"
},
"status": {
"loadBalancer": {}
}
}
svc = Service(data)
k8s_service = utils.create_service(name=svc.name)
k8s_service.model = svc
k8s_service.add_port(
name="frontend",
port=8082,
target_port="feport",
node_port=8082,
protocol='tcp'
)
self.assertEqual(1, len(k8s_service.ports))
def test_add_port_with_all_args(self):
svc_name = "yoservice"
svc = utils.create_service(name=svc_name)
port = 666
port_name = "yoport"
target_port = 666
protocol = 'TCP'
node_port = 666
svc.add_port(port=port,
name=port_name,
target_port=target_port,
protocol=protocol,
node_port=node_port)
self.assertEqual(1, len(svc.ports))
self.assertEqual(port_name, svc.ports[0].name)
self.assertEqual(port, svc.ports[0].port)
self.assertEqual(target_port, svc.ports[0].target_port)
self.assertEqual(protocol, svc.ports[0].protocol)
self.assertEqual(node_port, svc.ports[0].node_port)
def test_system_service(self):
config = utils.create_config()
config.namespace = 'kube-system'
service = utils.create_service(config, name="kubernetes-dashboard")
service.type = 'ClusterIP'
service.add_port(port=80,
target_port="k8s-dashport",
name="kubernetes-dashboard",
protocol="TCP")
service.selector = {'k8s-app': "kubernetes-dashboard"}
service.labels = {
'k8s-app': "kubernetes-dashboard",
'kubernetes.io/cluster-service': 'true'
}
if utils.is_reachable(service.config.api_host):
with self.assertRaises(AlreadyExistsException):
service.create()
service.get()
service.update()
def test_set_session_affinity_none_arg(self):
name = "yoservice"
svc = utils.create_service(name=name)
with self.assertRaises(SyntaxError):
svc.session_affinity = None
def test_set_load_balancer_ip(self):
name = "yoservice"
svc = utils.create_service(name=name)
ip = "192.168.99.100"
svc.load_balancer_ip = ip
self.assertEqual(ip, svc.load_balancer_ip)
def test_set_load_balancer_ip_invalid_ip_address(self):
name = "yoservice"
svc = utils.create_service(name=name)
ip = "192.168.00000.1234345"
with self.assertRaises(SyntaxError):
svc.load_balancer_ip = ip
def test_set_namespace(self):
name = "yoservice"
svc = utils.create_service(name=name)
nspace = "yonamespace"
svc.namespace = nspace
self.assertEqual(nspace, svc.namespace)
def test_set_namespace_invalid_arg(self):
name = "yoservice"
svc = utils.create_service(name=name)
nspace = object()
with self.assertRaises(SyntaxError):
svc.namespace = nspace
def test_set_session_affinity_invalid_string(self):
name = "yoservice"
svc = utils.create_service(name=name)
aff = 'yoaffinity'
with self.assertRaises(SyntaxError):
svc.session_affinity = aff
def test_set_service_type(self):
name = "yoservice"
svc = utils.create_service(name=name)
for i in ['ClusterIP', 'NodePort', 'LoadBalancer']:
svc.type = i
self.assertEqual(i, svc.type)
def test_set_service_type_invalid_string(self):
name = "yoservice"
svc = utils.create_service(name=name)
stype = "yoservicetype"
with self.assertRaises(SyntaxError):
svc.type = stype
def test_set_session_affinity(self):
name = "yoservice"
svc = utils.create_service(name=name)
for i in ['None', 'ClientIP']:
svc.session_affinity = i
self.assertEqual(i, svc.session_affinity)
def test_set_service_type_none_arg(self):
name = "yoservice"
svc = utils.create_service(name=name)
with self.assertRaises(SyntaxError):
svc.type = None
