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_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_observe_active_deadline_seconds(self):
cfg = _utils.create_config()
cj = CronJob(_constants.cronjob_exit_1())
k8s = K8sCronJob(config=cfg, name="yo")
k8s.model = cj
if _utils.is_reachable(cfg):
k8s.create()
self.assertIsInstance(k8s, K8sCronJob)
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_add_image_pull_secrets(self):
cfg = _utils.create_config()
cfg.pull_secret = [
{'name': 'secret-name'},
{'name': 'other-secret-name'},
{'name': 'secret-name'} # duplicate
]
cj = _utils.create_cronjob(config=cfg, name="yo")
self.assertEqual(2, len(cj.image_pull_secrets)) # duplicate not present
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_active_deadline_seconds(self):
ads = 50
cfg = _utils.create_config()
cj = CronJob(_constants.cronjob())
k8s = K8sCronJob(config=cfg, name="yo")
k8s.model = cj
self.assertIsNone(k8s.active_deadline_seconds)
k8s.active_deadline_seconds = ads
self.assertIsNotNone(k8s.active_deadline_seconds)
self.assertEqual(k8s.active_deadline_seconds, ads)
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_data(self):
cfg = _utils.create_config()
k8s = K8sConfigMap(config=cfg, name="yo")
fake_data = {
"test_key": "test_value"
}
k8s.data = fake_data
parsed_data = k8s.data
self.assertIsInstance(parsed_data, dict)
self.assertEqual(fake_data, parsed_data)
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_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_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_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_add_image_pull_secrets(self):
cfg = _utils.create_config()
cfg.pull_secret = [{
"name": "secret-name"
}, {
"name": "other-secret-name"
}, {
"name": "secret-name"
}] # duplicate
cj = _utils.create_cronjob(config=cfg, name="yo")
self.assertEqual(2,
len(cj.image_pull_secrets)) # duplicate not present
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_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_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_list(self):
count = 10
config = _utils.create_config()
if _utils.is_reachable(config):
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()
for x in _list:
self.assertIsInstance(x, K8sSecret)
self.assertGreaterEqual(count + 1, len(_list)) # including service-account-token on GCE
def test_taint_invalid_key_value(self):
config = _utils.create_config()
key1 = 34567
key2 = "34567"
value = 45678
effect = "NoSchedule"
if _utils.is_reachable(config):
nodes = K8sNode(config=config, name="yo").list()
for node in nodes:
with self.assertRaises(SyntaxError):
node.taint(key=key1, value=value, effect=effect)
with self.assertRaises(SyntaxError):
node.taint(key=key2, value=value, effect=effect)
def test_taint_invalid_key_value(self):
config = _utils.create_config()
key1 = 34567
key2 = "34567"
value = 45678
effect = "NoSchedule"
if _utils.is_reachable(config):
nodes = K8sNode(config=config, name="yo").list()
for node in nodes:
with self.assertRaises(SyntaxError):
node.taint(key=key1, value=value, effect=effect)
with self.assertRaises(SyntaxError):
node.taint(key=key2, value=value, effect=effect)
def test_data_wrong_keys(self):
cfg = _utils.create_config()
k8s = K8sConfigMap(config=cfg, name="yo")
fake_data = {
"@": "test_value"
}
with self.assertRaises(SyntaxError):
k8s.data = fake_data
fake_data = {
"abc@123": "test_value"
}
with self.assertRaises(SyntaxError):
k8s.data = fake_data
def test_list(self):
count = 10
config = _utils.create_config()
if _utils.is_reachable(config):
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()
for x in _list:
self.assertIsInstance(x, K8sSecret)
self.assertGreaterEqual(
count + 1,
len(_list)) # including service-account-token on GCE
def test_pod_affinity_no_good_nodes(self):
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):
nodes = K8sNode(config=config, name="yo").list()
# untag all nodes
for node in nodes:
node.labels.pop('kubernetes.io/e2e-az-name', None)
node.update()
with self.assertRaises(TimedOutException):
# timeout because of required
k8s.create()
def test_pod_affinity_no_good_nodes(self):
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):
nodes = K8sNode(config=config, name="yo").list()
# untag all nodes
for node in nodes:
node.labels.pop("kubernetes.io/e2e-az-name", None)
node.update()
with self.assertRaises(TimedOutException):
# timeout because of required
k8s.create()
def test_set_system_dockerconfigjson(self):
name = "docker-registry"
config = _utils.create_config()
config.namespace = 'kube-system'
secret = _utils.create_secret(config=config, name=name)
data = {"auths": {"repo:port": {"auth": "authstring", "email": "*****@*****.**"}}}
secret.dockerconfigjson = data
self.assertEqual('kubernetes.io/dockerconfigjson', secret.type)
self.assertIn('.dockerconfigjson', secret.data)
self.assertEqual(data, secret.dockerconfigjson)
if _utils.is_reachable(secret.config):
try:
secret.delete()
except NotFoundException:
pass
s = secret.create()
self.assertIsInstance(s, K8sSecret)
def test_drain_vanilla(self):
cfg = _utils.create_config()
if _utils.is_reachable(cfg):
nodes = K8sNode(config=cfg, name="yo").list()
try:
for node in nodes:
node.drain()
self.assertEqual(True, node.unschedulable)
except Exception as err:
self.assertIsInstance(err, DrainNodeException)
finally:
for node in nodes:
node.uncordon()
def test_drain_vanilla(self):
cfg = _utils.create_config()
if _utils.is_reachable(cfg):
nodes = K8sNode(config=cfg, name="yo").list()
try:
for node in nodes:
node.drain()
self.assertEqual(True, node.unschedulable)
except Exception as err:
self.assertIsInstance(err, DrainNodeException)
finally:
for node in nodes:
node.uncordon()
def test_tolerations_timeout(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)
key = "key"
value = "value"
effect = "NoSchedule"
if _utils.is_reachable(config):
nodes = K8sNode(config=config, name="yo").list()
for node in nodes:
node.taint(key=key, value=value, effect=effect)
with self.assertRaises(TimedOutException):
pod.create()
for node in nodes:
node.untaint(key=key, value=value)
def test_tolerations_timeout(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)
key = "key"
value = "value"
effect = "NoSchedule"
if _utils.is_reachable(config):
nodes = K8sNode(config=config, name="yo").list()
for node in nodes:
node.taint(key=key, value=value, effect=effect)
with self.assertRaises(TimedOutException):
pod.create()
for node in nodes:
node.untaint(key=key, value=value)
def test_drain_ignore_daemonsets(self):
cfg = _utils.create_config()
if _utils.is_reachable(cfg):
nodes = K8sNode(config=cfg, name="yo").list()
try:
for node in nodes:
node.drain(ignore_daemonsets=True)
self.assertTrue(node.unschedulable)
node.uncordon()
self.assertFalse(node.unschedulable)
except Exception as err:
self.assertIsInstance(err, DrainNodeException)
finally:
for node in nodes:
node.uncordon()
def test_tolerations_noschedule(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)
key = "key"
value = "value"
effect = "NoSchedule"
if _utils.is_reachable(config):
nodes = K8sNode(config=config, name="yo").list()
for node in nodes:
node.taint(key=key, value=value, effect=effect)
pod.add_toleration(key=key, value=value, effect=effect)
pod.create()
self.assertEqual(3, len(pod.tolerations))
for node in nodes:
node.untaint(key=key, value=value)
def test_taint_untaint(self):
config = _utils.create_config()
key = "key"
value = "value"
effect = "NoSchedule"
if _utils.is_reachable(config):
nodes = K8sNode(config=config, name="yo").list()
for node in nodes:
node.taint(key=key, value=value, effect=effect)
node.get()
self.assertEqual(1, len(node.taints))
self.assertEqual(node.taints[0].key, key)
self.assertEqual(node.taints[0].value, value)
self.assertEqual(node.taints[0].effect, effect)
for node in nodes:
node.untaint(key=key, value=value)
node.get()
self.assertEqual(0, len(node.taints))
def test_drain_ignore_daemonsets(self):
cfg = _utils.create_config()
if _utils.is_reachable(cfg):
nodes = K8sNode(config=cfg, name="yo").list()
try:
for node in nodes:
node.drain(ignore_daemonsets=True)
self.assertTrue(node.unschedulable)
node.uncordon()
self.assertFalse(node.unschedulable)
except Exception as err:
self.assertIsInstance(err, DrainNodeException)
finally:
for node in nodes:
node.uncordon()
def test_tolerations_noschedule(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)
key = "key"
value = "value"
effect = "NoSchedule"
if _utils.is_reachable(config):
nodes = K8sNode(config=config, name="yo").list()
for node in nodes:
node.taint(key=key, value=value, effect=effect)
pod.add_toleration(key=key, value=value, effect=effect)
pod.create()
self.assertEqual(3, len(pod.tolerations))
for node in nodes:
node.untaint(key=key, value=value)
def test_taint_untaint(self):
config = _utils.create_config()
key = "key"
value = "value"
effect = "NoSchedule"
if _utils.is_reachable(config):
nodes = K8sNode(config=config, name="yo").list()
for node in nodes:
node.taint(key=key, value=value, effect=effect)
node.get()
self.assertEqual(1, len(node.taints))
self.assertEqual(node.taints[0].key, key)
self.assertEqual(node.taints[0].value, value)
self.assertEqual(node.taints[0].effect, effect)
for node in nodes:
node.untaint(key=key, value=value)
node.get()
self.assertEqual(0, len(node.taints))
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):
with self.assertRaises(AlreadyExistsException):
service.create()
service.get()
service.update()
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()
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'})
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_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):
with self.assertRaises(AlreadyExistsException):
service.create()
service.get()
service.update()
def test_set_system_dockerconfigjson(self):
name = "docker-registry"
config = _utils.create_config()
config.namespace = 'kube-system'
secret = _utils.create_secret(config=config, name=name)
data = {
"auths": {
"repo:port": {
"auth": "authstring",
"email": "*****@*****.**"
}
}
}
secret.dockerconfigjson = data
self.assertEqual('kubernetes.io/.dockerconfigjson', secret.type)
self.assertIn('.dockerconfigjson', secret.data)
self.assertEqual(data, secret.dockerconfigjson)
if _utils.is_reachable(secret.config):
try:
secret.delete()
except NotFoundException:
pass
s = secret.create()
self.assertIsInstance(s, K8sSecret)
def test_system_service(self):
config = _utils.create_config()
config.namespace = "kube-system"
service = _utils.create_service(config, name="my-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"
}
service2 = _utils.create_service(config,
name="my-kubernetes-dashboard")
service2.type = "ClusterIP"
service2.add_port(port=80,
target_port="k8s-dashport",
name="kubernetes-dashboard",
protocol="TCP")
service2.selector = {"k8s-app": "kubernetes-dashboard"}
service2.labels = {
"k8s-app": "kubernetes-dashboard",
"kubernetes.io/cluster-service": "true"
}
if _utils.is_reachable(service.config):
service.create()
time.sleep(0.2)
with self.assertRaises(AlreadyExistsException):
service2.create()
service.update()
service.delete()
def test_init_invalid_type(self):
name = "yoname"
_type = object()
config = _utils.create_config()
with self.assertRaises(SyntaxError):
K8sPersistentVolume(config=config, name=name, type=_type)
def test_init_no_args(self):
config = _utils.create_config()
with self.assertRaises(SyntaxError):
K8sPersistentVolume(config=config)
def should_skip():
config = _utils.create_config()
return _utils.assert_server_version(api_host=config.api_host, major=1, minor=4)
def test_get_by_labels_invalid_args(self):
name = object()
config = _utils.create_config()
with self.assertRaises(SyntaxError):
K8sPod.get_by_labels(config=config, labels=name)
def test_get_by_labels_none_args(self):
config = _utils.create_config()
with self.assertRaises(SyntaxError):
K8sPod.get_by_labels(config=config)
def should_skip():
config = _utils.create_config()
return _utils.assert_server_version(
api_host=config.api_host,
major=1, minor=4
)
def test_get_by_labels_invalid_args(self):
name = object()
config = _utils.create_config()
with self.assertRaises(SyntaxError):
K8sPod.get_by_labels(config=config, labels=name)
def test_init_invalid_name(self):
name = object()
config = _utils.create_config()
with self.assertRaises(SyntaxError):
K8sPersistentVolumeClaim(config=config, name=name)
