def test_rc_get_pod_node_name(self):
name = "yorc"
obj = utils.create_rc(name=name)
nodename = "yonodename"
obj.set_pod_node_name(name=nodename)
name = obj.get_pod_node_name()
self.assertEqual(name, nodename)
def test_rc_set_service_account(self):
name = "yorc"
obj = utils.create_rc(name=name)
name_in = "yoservice"
obj.set_service_account(name_in)
name_out = obj.get_service_account()
self.assertEqual(name_in, name_out)
def test_rc_hostpath(self):
container_name = "nginx"
container_image = "nginx:1.7.9"
container_nginx = utils.create_container(name=container_name,
image=container_image)
container_name = "redis"
container_image = "redis:3.0.7"
container_redis = utils.create_container(name=container_name,
image=container_image)
vol_name = "hostpath"
vol_type = "hostPath"
hostpath = "/var/lib/docker"
volume = utils.create_volume(name=vol_name, type=vol_type)
volume.path = hostpath
mount_name = vol_name
mount_path = '/test-hostpath'
mount = K8sVolumeMount(name=mount_name, mount_path=mount_path)
container_nginx.add_volume_mount(mount)
container_redis.add_volume_mount(mount)
rc_name = "app"
rc = utils.create_rc(name=rc_name)
rc.add_volume(volume)
rc.add_container(container_nginx)
rc.add_container(container_redis)
rc.desired_replicas = 1
if utils.is_reachable(rc.config.api_host):
rc.create()
volnames = [x.name for x in rc.volumes]
self.assertIn(vol_name, volnames)
def test_rc_set_termination_grace_period(self):
name = "yorc"
obj = utils.create_rc(name=name)
secs_in = 1234
obj.set_termination_grace_period(secs_in)
secs_out = obj.get_termination_grace_period()
self.assertEqual(secs_in, secs_out)
def test_myweb_start(self):
# create a myweb service
svc = utils.create_service(name="myweb")
self.assertIsInstance(svc, K8sService)
svc.selector = {'name': 'myweb'}
svc.type = 'NodePort'
svc.add_port(
name="tcp31030",
port=31030,
target_port="tcp31030",
protocol="tcp",
node_port=8030
)
# create a myweb replication controller
container = utils.create_container(name="myweb", image="nginx:latest")
container.add_port(
container_port=80,
host_port=31030,
name="tcp31030",
protocol="tcp"
)
rc = utils.create_rc(name="myweb", replicas=2)
rc.add_container(container)
# create the API resources
if utils.is_reachable(rc.config.api_host):
svc.create()
rc.create()
pass
def test_rc_get_pod_restart_policy(self):
name = "yorc"
obj = utils.create_rc(name=name)
p_in = "OnFailure"
obj.set_pod_restart_policy(p_in)
p_out = obj.get_pod_restart_policy()
self.assertEqual(p_in, p_out)
def test_rc_set_pod_restart_policy(self):
name = "yorc"
obj = utils.create_rc(name=name)
policy = "Always"
obj.set_pod_restart_policy(policy=policy)
p = obj.get_pod_restart_policy()
self.assertEqual(policy, p)
def test_rc_get_pod_node_selector(self):
name = "yorc"
obj = utils.create_rc(name=name)
s_in = {"disktype": "ssd"}
obj.set_pod_node_selector(selector=s_in)
s_out = obj.get_pod_node_selector()
self.assertEqual(s_in, s_out)
def test_rc_set_pod_node_selector_invalid_arg(self):
name = "yorc"
obj = utils.create_rc(name=name)
s_in = "yoselector"
try:
obj.set_pod_node_selector(selector=s_in)
except Exception as err:
self.assertIsInstance(err, SyntaxError)
def test_init_object_type_rc(self):
ot = "ReplicationController"
name = "yorc"
obj = utils.create_rc(name=name)
self.assertIsNotNone(obj)
self.assertIsInstance(obj, K8sPodBasedObject)
self.assertEqual(ot, obj.obj_type)
self.assertEqual(name, obj.name)
def test_init_with_model_rc(self):
name = "yoname"
obj = utils.create_rc(name=name)
self.assertIsInstance(obj.model, ReplicationController)
self.assertIsInstance(obj.model.model, dict)
self.assertIsInstance(obj.model.pod_metadata, ObjectMeta)
self.assertIsInstance(obj.model.pod_spec, PodSpec)
self.assertIsNone(obj.model.pod_status)
def test_rc_set_pod_node_name_invalid_arg(self):
name = "yorc"
obj = utils.create_rc(name=name)
nodename = 666
try:
obj.set_pod_node_name(name=nodename)
except Exception as err:
self.assertIsInstance(err, SyntaxError)
def test_rc_set_active_deadline_invalid_arg(self):
name = "yorc"
obj = utils.create_rc(name=name)
d = "yodeadline"
try:
obj.set_active_deadline(d)
except Exception as err:
self.assertIsInstance(err, SyntaxError)
def test_rc_set_service_account_none_arg(self):
name = "yorc"
obj = utils.create_rc(name=name)
try:
obj.set_service_account()
self.fail("Should not fail.")
except Exception as err:
self.assertIsInstance(err, SyntaxError)
def test_rc_set_termination_grace_period_none_arg(self):
name = "yorc"
obj = utils.create_rc(name=name)
try:
obj.set_termination_grace_period()
self.fail("Should not fail.")
except Exception as err:
self.assertIsInstance(err, SyntaxError)
def test_rc_add_image_pull_secrets_invalid_arg(self):
name = "yorc"
obj = utils.create_rc(name=name)
secretname = 666
try:
obj.add_image_pull_secrets(name=secretname)
self.fail("Should not fail.")
except Exception as err:
self.assertIsInstance(err, SyntaxError)
def test_rc_add_container_invalid(self):
name = "yorc"
obj = utils.create_rc(name=name)
c = object()
try:
obj.add_container(c)
self.fail("Should not fail.")
except Exception as err:
self.assertIsInstance(err, AssertionError)
def test_rc_set_pod_restart_policy_invalid_arg(self):
name = "yorc"
obj = utils.create_rc(name=name)
policy = "yopolicy"
try:
obj.set_pod_restart_policy(policy=policy)
self.fail("Should not fail.")
except Exception as err:
self.assertIsInstance(err, SyntaxError)
def test_rc_add_image_pull_secrets(self):
name = "yorc"
obj = utils.create_rc(name=name)
secretname = "yosecret"
obj.add_image_pull_secrets(name=secretname)
podspec = obj.model.model["spec"]["template"]["spec"]
self.assertIn("imagePullSecrets", podspec)
self.assertEqual(1, len(podspec["imagePullSecrets"]))
self.assertEqual(secretname, podspec["imagePullSecrets"][0]["name"])
podspec = obj.model.pod_spec
self.assertIn("imagePullSecrets", podspec.model)
self.assertEqual(1, len(podspec.model["imagePullSecrets"]))
self.assertEqual(secretname, podspec.model["imagePullSecrets"][0]["name"])
def test_rc_set_pod_node_name(self):
name = "yorc"
obj = utils.create_rc(name=name)
nodename = "yonodename"
obj.set_pod_node_name(name=nodename)
podspec = obj.model.model["spec"]["template"]["spec"]
self.assertIn("nodeName", podspec)
self.assertIsInstance(podspec["nodeName"], str)
self.assertEqual(nodename, podspec["nodeName"])
podspec = obj.model.pod_spec
self.assertIn("nodeName", podspec.model)
self.assertIsInstance(podspec.model["nodeName"], str)
self.assertEqual(nodename, podspec.model["nodeName"])
def test_rc_get_pod_containers(self):
name = "yorc"
obj = utils.create_rc(name=name)
count = 3
for i in range(0, 3):
name = "yocontainer_{0}".format(i)
image = "redis"
c = K8sContainer(name=name, image=image)
obj.add_container(c)
containers = obj.get_pod_containers()
self.assertIsNotNone(containers)
self.assertEqual(count, len(containers))
[self.assertIsInstance(x, dict) for x in containers]
def test_rc_set_pod_node_selector(self):
name = "yorc"
obj = utils.create_rc(name=name)
s = {"disktype": "ssd"}
obj.set_pod_node_selector(selector=s)
podspec = obj.model.model["spec"]["template"]["spec"]
self.assertIn("nodeSelector", podspec)
self.assertIsInstance(podspec["nodeSelector"], dict)
self.assertEqual(s, podspec["nodeSelector"])
podspec = obj.model.pod_spec
self.assertIn("nodeSelector", podspec.model)
self.assertIsInstance(podspec.model["nodeSelector"], dict)
self.assertEqual(s, podspec.model["nodeSelector"])
def test_rc_set_active_deadline(self):
name = "yorc"
obj = utils.create_rc(name=name)
d = 600
obj.set_active_deadline(d)
podspec = obj.model.model["spec"]["template"]["spec"]
self.assertIn("activeDeadlineSeconds", podspec)
self.assertIsInstance(podspec["activeDeadlineSeconds"], int)
self.assertEqual(d, podspec["activeDeadlineSeconds"])
podspec = obj.model.pod_spec
self.assertNotIn("nodeName", podspec.model)
self.assertIn("activeDeadlineSeconds", podspec.model)
self.assertIsInstance(podspec.model["activeDeadlineSeconds"], int)
self.assertEqual(d, podspec.model["activeDeadlineSeconds"])
def test_struct_with_model_rc_check_rcmeta(self):
name = "yorc"
obj = utils.create_rc(name=name)
meta = obj.model.rc_metadata
self.assertIsNotNone(meta)
self.assertIsInstance(meta, ObjectMeta)
self.assertIsInstance(meta.model, dict)
self.assertEqual(len(meta.model), 3)
self.assertIn("labels", meta.model)
self.assertIsInstance(meta.model["labels"], dict)
self.assertIn("name", meta.model["labels"])
self.assertEqual(meta.model["labels"]["name"], name)
self.assertIn("name", meta.model)
self.assertIsInstance(meta.model["name"], str)
self.assertEqual(meta.model["name"], name)
self.assertIn("namespace", meta.model)
self.assertIsInstance(meta.model["namespace"], str)
def test_struct_with_model_rc_check_podspec(self):
name = "yorc"
obj = utils.create_rc(name=name)
spec = obj.model.pod_spec
self.assertIsNotNone(spec)
self.assertIsInstance(spec, PodSpec)
self.assertIsInstance(spec.containers, list)
self.assertEqual(0, len(spec.containers))
self.assertIsInstance(spec.model, dict)
self.assertEqual(len(spec.model), 4)
self.assertIn("containers", spec.model)
self.assertIsInstance(spec.model["containers"], list)
self.assertIn("dnsPolicy", spec.model)
self.assertIsInstance(spec.model["dnsPolicy"], str)
self.assertIn("restartPolicy", spec.model)
self.assertIsInstance(spec.model["restartPolicy"], str)
self.assertIn("volumes", spec.model)
self.assertIsInstance(spec.model["volumes"], list)
def test_rc_gce_pd(self):
# http://kubernetes.io/docs/user-guide/volumes/#gcepersistentdisk
# - the nodes on which pods are running must be GCE VMs
# - those VMs need to be in the same GCE project and zone as the PD
# Pod creation will timeout waiting for readiness if not on GCE; unschedulable.
container_name = "nginx"
container_image = "nginx:1.7.9"
container_nginx = utils.create_container(name=container_name,
image=container_image)
container_name = "redis"
container_image = "redis:3.0.7"
container_redis = utils.create_container(name=container_name,
image=container_image)
pd_name = "mnubo-disk1"
vol_name = "persistent"
vol_type = "gcePersistentDisk"
volume = utils.create_volume(name=vol_name, type=vol_type)
volume.pd_name = pd_name
volume.read_only = True # HTTP 422: GCE PD can only be mounted on multiple machines if it is read-only
mount_name = vol_name
mount_path = '/test-gce'
mount = K8sVolumeMount(name=mount_name, mount_path=mount_path)
container_nginx.add_volume_mount(mount)
container_redis.add_volume_mount(mount)
rc_name = "nginx-{0}".format(str(uuid.uuid4()))
rc = utils.create_rc(name=rc_name)
rc.add_volume(volume)
rc.add_container(container_nginx)
rc.add_container(container_redis)
rc.desired_replicas = 3
if utils.is_reachable(rc.config.api_host):
try:
rc.create()
volnames = [x.name for x in rc.volumes]
self.assertIn(vol_name, volnames)
except Exception as err:
self.assertIsInstance(err, TimedOutException)
def test_rc_aws_ebs(self):
# http://kubernetes.io/docs/user-guide/volumes/#awselasticblockstore
# - the nodes on which pods are running must be AWS EC2 instances
# - those instances need to be in the same region and availability-zone as the EBS volume
# - EBS only supports a single EC2 instance mounting a volume
# Pod creation will timeout waiting for readiness if not on AWS; unschedulable.
container_name = "nginx"
container_image = "nginx:1.7.9"
container_nginx = utils.create_container(name=container_name,
image=container_image)
container_name = "redis"
container_image = "redis:3.0.7"
container_redis = 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_nginx.add_volume_mount(mount)
container_redis.add_volume_mount(mount)
rc_name = "nginx-{0}".format(str(uuid.uuid4()))
rc = utils.create_rc(name=rc_name)
rc.add_volume(volume)
rc.add_container(container_nginx)
rc.add_container(container_redis)
rc.desired_replicas = 3
if utils.is_reachable(rc.config.api_host):
try:
rc.create()
volnames = [x.name for x in rc.volumes]
self.assertIn(vol_name, volnames)
except Exception as err:
self.assertIsInstance(err, TimedOutException)
def test_rc_add_container(self):
name = "yoname"
obj = utils.create_rc(name=name)
podspec = obj.model.model["spec"]["template"]["spec"]
self.assertEqual(0, len(podspec["containers"]))
podspec = obj.model.pod_spec
self.assertEqual(0, len(podspec.containers))
self.assertEqual(0, len(podspec.model["containers"]))
name = "yopod"
image = "redis"
c = K8sContainer(name=name, image=image)
obj.add_container(c)
podspec = obj.model.model["spec"]["template"]["spec"]
self.assertEqual(1, len(podspec["containers"]))
podspec = obj.model.pod_spec
self.assertEqual(1, len(podspec.containers))
self.assertEqual(1, len(podspec.model["containers"]))
def test_rc_hostpath_list(self):
volumes = [{
'hostPath': {
'path': '/root/.dockercfg'
},
'name': 'dockercred'
}, {
'hostPath': {
'path': '/usr/bin/docker'
},
'name': 'dockerbin'
}, {
'hostPath': {
'path': '/var/run/docker.sock'
},
'name': 'dockersock'
}, {
'hostPath': {
'path': '/root/.docker'
},
'name': 'dockerconfig'
}]
rc = utils.create_rc(name="admintool")
for vol in volumes:
keys = list(filter(lambda x: x != 'name', vol.keys()))
v = K8sVolume(
name=vol['name'],
type=keys[0],
)
dico = vol[keys[0]]
if dico is not None:
v.path = dico['path']
rc.add_volume(v)
self.assertEqual(len(volumes), len(rc.volumes))
for i in range(0, len(volumes)):
self.assertEqual(volumes[i]['name'], rc.volumes[i].name)
self.assertEqual(volumes[i]['hostPath']['path'],
rc.volumes[i].hostPath.path)
def test_rc_secret(self):
container_name = "nginx"
container_image = "nginx:1.7.9"
container_nginx = utils.create_container(name=container_name,
image=container_image)
container_name = "redis"
container_image = "redis:3.0.7"
container_redis = 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_nginx.add_volume_mount(mount)
container_redis.add_volume_mount(mount)
rc_name = "app"
rc = utils.create_rc(name=rc_name)
rc.add_volume(volume)
rc.add_container(container_nginx)
rc.add_container(container_redis)
rc.desired_replicas = 1
if utils.is_reachable(rc.config.api_host):
secret.create()
rc.create()
volnames = [x.name for x in rc.volumes]
self.assertIn(vol_name, volnames)
def test_rc_nfs(self):
container_name = "nginx"
container_image = "nginx:1.7.9"
container_nginx = utils.create_container(name=container_name,
image=container_image)
container_name = "redis"
container_image = "redis:3.0.7"
container_redis = utils.create_container(name=container_name,
image=container_image)
vol_name = "nfs"
vol_type = "nfs"
server = "howard.mtl.mnubo.com"
path = "/fs1/test-nfs"
volume = utils.create_volume(name=vol_name, type=vol_type)
volume.nfs_server = server
volume.nfs_path = path
mount_name = vol_name
mount_path = '/test-nfs'
mount = K8sVolumeMount(name=mount_name, mount_path=mount_path)
container_nginx.add_volume_mount(mount)
container_redis.add_volume_mount(mount)
rc_name = "nginx-{0}".format(str(uuid.uuid4()))
rc = utils.create_rc(name=rc_name)
rc.add_volume(volume)
rc.add_container(container_nginx)
rc.add_container(container_redis)
rc.desired_replicas = 3
if utils.is_reachable(rc.config.api_host):
try:
rc.create()
volnames = [x.name for x in rc.volumes]
self.assertIn(vol_name, volnames)
except Exception as err:
self.assertIsInstance(err, TimedOutException)
def test_rc_git_repo(self):
container_name = "nginx"
container_image = "nginx:1.7.9"
container_nginx = utils.create_container(name=container_name,
image=container_image)
container_name = "redis"
container_image = "redis:3.0.7"
container_redis = 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_nginx.add_volume_mount(mount)
container_redis.add_volume_mount(mount)
rc_name = "nginx-{0}".format(str(uuid.uuid4()))
rc = utils.create_rc(name=rc_name)
rc.add_volume(volume)
rc.add_container(container_nginx)
rc.add_container(container_redis)
rc.desired_replicas = 3
if utils.is_reachable(rc.config.api_host):
try:
rc.create()
volnames = [x.name for x in rc.volumes]
self.assertIn(vol_name, volnames)
except Exception as err:
self.assertIsInstance(err, TimedOutException)
def test_rc_get_pod_containers_empty(self):
name = "yorc"
obj = utils.create_rc(name=name)
containers = obj.get_pod_containers()
self.assertIsNotNone(containers)
self.assertEqual(0, len(containers))
def test_rc_get_pod_node_name_none(self):
name = "yorc"
obj = utils.create_rc(name=name)
name = obj.get_pod_node_name()
self.assertIsNone(name)
def test_rc_get_pod_restart_policy_none(self):
name = "yorc"
obj = utils.create_rc(name=name)
rp = obj.get_pod_restart_policy()
self.assertEqual("Always", rp) # set to 'Always' by default
def test_rc_get_service_account_none(self):
name = "yorc"
obj = utils.create_rc(name=name)
acct = obj.get_service_account()
self.assertIsNone(acct)
def test_rc_get_pod_node_selector_none(self):
name = "yorc"
obj = utils.create_rc(name=name)
s = obj.get_pod_node_selector()
self.assertIsNone(s)
def test_init_with_invalid_name(self):
name = object()
with self.assertRaises(SyntaxError):
utils.create_rc(name=name)