def test_micro_service_can_set_rolling_update(): def _run_dsl(args): fs: MockFileSystem = args['file_system'] cluster_name = 'prod-us-east1' project_id = 'project1' service_account_b64 = b64encode( json.dumps({ 'key': 'someKey' }).encode('utf-8')) _, result = run_in_cluster( conn=gke_conn(cluster_name, project_id, service_account_b64), templates=[ micro_service( 'test', "test-service:1.0.0", 3000).with_rolling_update( max_surge='20%', max_unavailable='20%').with_empty_volume( 'my-volume', '/var/data/my-data').with_sidecar( container( 'my-sidecar', 'my-sidecar:1.0.0').with_volume_mount( 'my-volume', 'var/data/sidecar-data')) ]) deployment = find_write_template_calls(fs)[1] assert deployment['spec']['strategy'] == { 'rollingUpdate': { 'maxSurge': '20%', 'maxUnavailable': '20%' }, 'type': 'RollingUpdate' } mock_krogon_dsl(_run_dsl)
def test_micro_service_can_ensure_cpu_scale_up_threshold(): def _run_dsl(args): fs: MockFileSystem = args['file_system'] cluster_name = 'prod-us-east1' project_id = 'project1' service_account_b64 = b64encode( json.dumps({ 'key': 'someKey' }).encode('utf-8')) _, result = run_in_cluster( conn=gke_conn(cluster_name, project_id, service_account_b64), templates=[ micro_service( 'test', "test-service:1.0.0", 3000).with_replicas( min=5, max=10, cpu_threshold_percentage=80).with_empty_volume( 'my-volume', '/var/data/my-data').with_sidecar( container( 'my-sidecar', 'my-sidecar:1.0.0').with_volume_mount( 'my-volume', 'var/data/sidecar-data')) ]) deployment = find_write_template_calls(fs)[1] assert deployment['spec']['replicas'] == 5 hpa = find_write_template_calls(fs)[2] assert hpa['spec']['minReplicas'] == 5 assert hpa['spec']['maxReplicas'] == 10 assert hpa['spec']['targetCPUUtilizationPercentage'] == 80 mock_krogon_dsl(_run_dsl)
def test_micro_service_can_ensure_one_pod_at_a_time(): def _run_dsl(args): fs: MockFileSystem = args['file_system'] cluster_name = 'prod-us-east1' project_id = 'project1' service_account_b64 = b64encode( json.dumps({ 'key': 'someKey' }).encode('utf-8')) _, result = run_in_cluster( conn=gke_conn(cluster_name, project_id, service_account_b64), templates=[ micro_service( 'test', "test-service:1.0.0", 3000).with_ensure_only_one().with_empty_volume( 'my-volume', '/var/data/my-data').with_sidecar( container('my-sidecar', 'my-sidecar:1.0.0').with_volume_mount( 'my-volume', 'var/data/sidecar-data')) ]) deployment = find_write_template_calls(fs)[1] assert deployment['spec']['replicas'] == 1 assert deployment['spec']['strategy'] == {'type': 'Recreate'} hpa = find_write_template_calls(fs)[2] assert hpa['spec']['minReplicas'] == 1 assert hpa['spec']['maxReplicas'] == 1 mock_krogon_dsl(_run_dsl)
def test_micro_service_pick_clusters_using_regex(): def _run_dsl(args): fs: MockFileSystem = args['file_system'] os: MockOsSystem = args["os_system"] os.mock_clusters_list([ 'prod-us-east1-api-cluster', 'prod-10-api-cluster', 'stage-10-api-cluster' ]) cluster_name = 'prod-.*-api-cluster' project_id = 'project1' service_account_b64 = b64encode( json.dumps({ 'key': 'someKey' }).encode('utf-8')) _, result = run_in_cluster( conn=gke_conn(cluster_name, project_id, service_account_b64), templates=[ micro_service( 'test', "test-service:1.0.0", 3000).with_empty_volume( 'my-volume', '/var/data/my-data').with_sidecar( container('my-sidecar', 'my-sidecar:1.0.0').with_volume_mount( 'my-volume', 'var/data/sidecar-data')) ]) assert 'prod-us-east1-api-cluster' in find_cluster_templates(fs) assert 'prod-10-api-cluster' in find_cluster_templates(fs) assert 'stage-10-api-cluster' not in find_cluster_templates(fs) mock_krogon_dsl(_run_dsl)
def test_micro_service_can_set_annotations(): def _run_dsl(args): fs: MockFileSystem = args['file_system'] cluster_name = 'prod-us-east1' project_id = 'project1' service_account_b64 = b64encode( json.dumps({ 'key': 'someKey' }).encode('utf-8')) _, result = run_in_cluster( conn=gke_conn(cluster_name, project_id, service_account_b64), templates=[ micro_service( 'test', "test-service:1.0.0", 3000).with_annotations({ 'some': 'thing' }).with_empty_volume( 'my-volume', '/var/data/my-data').with_sidecar( container('my-sidecar', 'my-sidecar:1.0.0').with_volume_mount( 'my-volume', 'var/data/sidecar-data')) ]) deployment = find_write_template_calls(fs)[1] assert deployment['spec']['template']['metadata']['annotations'] == { 'some': 'thing' } mock_krogon_dsl(_run_dsl)
def test_deployment_can_set_rolling_update(): def _run_dsl(args): os: MockOsSystem = args["os_system"] fs: MockFileSystem = args["file_system"] project_id = "project1" app_name = 'test-service' cluster_name = 'prod-us-east1' kubectl_version = "v1.15.3" service_account_b64 = b64encode(json.dumps({'key': 'someKey'}).encode('utf-8')) os.mock_clusters_list([cluster_name]) os.mock_kubernetes_release(E.success(kubectl_version)) os.mock_download_install_kubectl(kubectl_version, E.success()) os.mock_create_kube_config(cluster_name, E.success()) os.mock_kubectl_apply_temp_file(cluster_name, E.success()) _, result = run_in_cluster( conn=gke_conn(cluster_name, project_id, service_account_b64), templates=[ deployment(app_name) .with_rolling_update(max_surge='20%', max_unavailable='20%') .with_empty_volume(name='test-volume') .with_container(container('test', 'test:100')) .with_container(container('test-2', 'test-2:100')) ] ) deployment_yaml = find_write_template_calls(fs)[0] assert deployment_yaml['spec']['strategy'] == {'rollingUpdate': {'maxSurge': '20%', 'maxUnavailable': '20%'}, 'type': 'RollingUpdate'} mock_krogon_dsl(_run_dsl)
def test_micro_service_can_set_cpu_request(): def _run_dsl(args): fs: MockFileSystem = args["file_system"] service_type = 'NodePort' cluster_name = 'prod-us-east1' project_id = 'project1' service_account_b64 = b64encode( json.dumps({ 'key': 'someKey' }).encode('utf-8')) _, result = run_in_cluster( conn=gke_conn(cluster_name, project_id, service_account_b64), templates=[ micro_service( 'test', "test-service:1.0.0", 3000).with_service_type(service_type).with_resources( cpu_request="1") ]) yamls = find_write_template_calls(fs) assert yamls[1]['kind'] == 'Deployment' container = yamls[1]['spec']['template']['spec']['containers'][0] assert container['resources'] == {'requests': {'cpu': '1'}} mock_krogon_dsl(_run_dsl)
def test_micro_service_can_set_env_var_from_context_on_sidecar(): def _run_dsl(args): fs: MockFileSystem = args['file_system'] cluster_name = 'prod-us-east1' project_id = 'project1' service_account_b64 = b64encode( json.dumps({ 'key': 'someKey' }).encode('utf-8')) _, result = run_in_cluster( conn=gke_conn(cluster_name, project_id, service_account_b64), templates=[ micro_service('test', "test-service:1.0.0", 3000).with_sidecar( container('my-sidecar', 'my-sidecar:1.0.0').with_volume_mount( 'my-volume', 'var/data/sidecar-data'). with_environment_from_context('ENV', lambda c: c('cluster_name'))) ]) deployment = find_write_template_calls(fs)[1] microservice = deployment['spec']['template']['spec']['containers'][1] assert microservice['env'][1]['name'] == 'ENV' assert microservice['env'][1]['value'] == 'prod-us-east1' mock_krogon_dsl(_run_dsl)
def test_will_fail_if_neither_istio_or_ambassador_configured_in_cluster(): def _run_dsl(args): os: MockOsSystem = args["os_system"] project_id = "project1" cluster_name = 'prod-us-east1' kubectl_version = "v1.15.3" service_account_b64 = b64encode( json.dumps({ 'key': 'someKey' }).encode('utf-8')) os.mock_clusters_list([cluster_name]) os.mock_kubernetes_release(E.success(kubectl_version)) os.mock_download_install_kubectl(kubectl_version, E.success()) os.mock_create_kube_config(cluster_name, E.success()) os.mock_kubectl(cluster_name, 'get mappings', E.failure('No such resource')) os.mock_kubectl(cluster_name, 'get virtualservices', E.failure('No such resource')) with patch.object(sys, "exit") as mock_exit: _, error = run_in_cluster(conn=gke_conn(cluster_name, project_id, service_account_b64), templates=[ gateway_mapping( 'api', 'api.com', 'api.default.svc.cluster.local') ]) assert mock_exit.call_args[0][0] == 1 assert str(error.caught_error) == 'Unsupported gateway' mock_krogon_dsl(_run_dsl)
def test_can_generate_cron_job_template(): def _run_dsl(args): os: MockOsSystem = args["os_system"] fs: MockFileSystem = args['file_system'] project_id = "project1" job_name = 'test-service' cluster_name = 'prod-us-east1' kubectl_version = "v1.15.3" image_url = "test-service:1.0.0" service_account_b64 = b64encode( json.dumps({ 'key': 'someKey' }).encode('utf-8')) os.mock_clusters_list([cluster_name]) os.mock_kubernetes_release(E.success(kubectl_version)) os.mock_download_install_kubectl(kubectl_version, E.success()) os.mock_create_kube_config(cluster_name, E.success()) os.mock_kubectl_apply_temp_file(cluster_name, E.success()) _, result = run_in_cluster(conn=gke_conn(cluster_name, project_id, service_account_b64), templates=[cron_job(job_name, image_url)]) yamls = find_write_template_calls(fs) assert yamls[0]['kind'] == 'CronJob' assert yamls[0]['metadata']['name'] == job_name container = yamls[0]['spec']['jobTemplate']['spec']['template'][ 'spec']['containers'][0] assert container['name'] == job_name assert container['image'] == image_url mock_krogon_dsl(_run_dsl)
def test_deployment_can_set_multiple_containers(): def _run_dsl(args): os: MockOsSystem = args["os_system"] fs: MockFileSystem = args["file_system"] project_id = "project1" app_name = 'test-service' cluster_name = 'prod-us-east1' kubectl_version = "v1.15.3" service_account_b64 = b64encode(json.dumps({'key': 'someKey'}).encode('utf-8')) container_1 = container(name='myservice', image='busybox:1.0') container_2 = container(name='myservice-2', image='busybox:2.0') os.mock_clusters_list([cluster_name]) os.mock_kubernetes_release(E.success(kubectl_version)) os.mock_download_install_kubectl(kubectl_version, E.success()) os.mock_create_kube_config(cluster_name, E.success()) os.mock_kubectl_apply_temp_file(cluster_name, E.success()) _, result = run_in_cluster( conn=gke_conn(cluster_name, project_id, service_account_b64), templates=[ deployment(app_name) .with_containers([container_1, container_2]) ] ) deployment_yaml = find_write_template_calls(fs)[0] containers = deployment_yaml['spec']['template']['spec']['containers'] assert containers[0]['name'] == 'myservice-app' assert containers[0]['image'] == 'busybox:1.0' assert containers[1]['name'] == 'myservice-2-app' assert containers[1]['image'] == 'busybox:2.0' mock_krogon_dsl(_run_dsl)
def test_deployment_can_set_env_var_from_context(): def _run_dsl(args): os: MockOsSystem = args["os_system"] fs: MockFileSystem = args["file_system"] project_id = "project1" app_name = 'test-service' cluster_name = 'prod-us-east1' kubectl_version = "v1.15.3" service_account_b64 = b64encode(json.dumps({'key': 'someKey'}).encode('utf-8')) os.mock_clusters_list([cluster_name]) os.mock_kubernetes_release(E.success(kubectl_version)) os.mock_download_install_kubectl(kubectl_version, E.success()) os.mock_create_kube_config(cluster_name, E.success()) os.mock_kubectl_apply_temp_file(cluster_name, E.success()) _, result = run_in_cluster( conn=gke_conn(cluster_name, project_id, service_account_b64), templates=[ deployment(app_name) .with_rolling_update(max_surge='20%', max_unavailable='20%') .with_volume_claim(name='test-volume', claim_name='some-claim-name') .with_container(container('test', 'test:100') .with_volume_mount('test-volume', '/var/data/my-data') .with_environment_from_context('ENV', lambda c: c('cluster_name'))) ] ) deployment_yaml = find_write_template_calls(fs)[0] assert deployment_yaml['spec']['template']['spec']['containers'][0]['env'][1]['name'] == 'ENV' assert deployment_yaml['spec']['template']['spec']['containers'][0]['env'][1]['value'] == cluster_name mock_krogon_dsl(_run_dsl)
def test_micro_service_can_generate_micro_service_template(): def _run_dsl(args): os: MockOsSystem = args["os_system"] fs: MockFileSystem = args["file_system"] project_id = "project1" service_name = 'test-service' cluster_name = 'prod-us-east1' kubectl_version = "v1.15.3" image_url = "test-service:1.0.0" app_port = 3000 service_port = 80 service_account_b64 = b64encode( json.dumps({ 'key': 'someKey' }).encode('utf-8')) os.mock_clusters_list([cluster_name]) os.mock_kubernetes_release(E.success(kubectl_version)) os.mock_download_install_kubectl(kubectl_version, E.success()) os.mock_create_kube_config(cluster_name, E.success()) os.mock_kubectl_apply_temp_file(cluster_name, E.success()) _, result = run_in_cluster( conn=gke_conn(cluster_name, project_id, service_account_b64), templates=[micro_service(service_name, image_url, app_port)]) yamls = find_write_template_calls(fs) assert yamls[0]['kind'] == 'Service' assert yamls[0]['metadata']['name'] == service_name assert yamls[0]['spec']['selector']['app'] == service_name + '-app' assert yamls[0]['spec']['ports'][0]['targetPort'] == app_port assert yamls[0]['spec']['ports'][0]['port'] == service_port assert yamls[1]['kind'] == 'Deployment' mock_krogon_dsl(_run_dsl)
def test_micro_service_can_set_init_containers(): init_container_1 = {'name': 'init-myservice', 'image': 'busybox:1.0'} init_container_2 = {'name': 'init-myservice-2', 'image': 'busybox:2.0'} cluster_name = 'prod-us-east1' project_id = "project1" service_account_b64 = b64encode( json.dumps({ 'key': 'someKey' }).encode('utf-8')) def _run_dsl(args): fs: MockFileSystem = args['file_system'] _, result = run_in_cluster( conn=gke_conn(cluster_name, project_id, service_account_b64), templates=[ micro_service('test', "test-service:1.0.0", 3000).with_init_containers( [init_container_1, init_container_2]) ]) deployment = find_write_template_calls(fs)[1] init_containers = deployment['spec']['template']['spec'][ 'initContainers'] assert init_containers[0]['name'] == 'init-myservice' assert init_containers[0]['image'] == 'busybox:1.0' assert init_containers[1]['name'] == 'init-myservice-2' assert init_containers[1]['image'] == 'busybox:2.0' mock_krogon_dsl(_run_dsl)
def test_deployment_can_gen_template(): def _run_dsl(args): os: MockOsSystem = args["os_system"] fs: MockFileSystem = args["file_system"] app_name = 'test-service' cluster_name = 'prod-us-east1' kubectl_version = "v1.15.3" container_1 = container(name='myservice', image='busybox:1.0') container_2 = container(name='myservice-2', image='busybox:2.0') os.mock_clusters_list([cluster_name]) os.mock_kubernetes_release(E.success(kubectl_version)) os.mock_download_install_kubectl(kubectl_version, E.success()) os.mock_create_kube_config(cluster_name, E.success()) os.mock_kubectl_apply_temp_file(cluster_name, E.success()) _, result = gen_template([ deployment(app_name) .with_containers([container_1, container_2]) ]) deployment_yaml = find_write_template_calls(fs)[0] containers = deployment_yaml['spec']['template']['spec']['containers'] assert containers[0]['name'] == 'myservice-app' assert containers[0]['image'] == 'busybox:1.0' assert containers[1]['name'] == 'myservice-2-app' assert containers[1]['image'] == 'busybox:2.0' mock_krogon_dsl(_run_dsl)
def test_can_generate_secret_template(): def _run_dsl(args): fs: MockFileSystem = args['file_system'] os: MockOsSystem = args["os_system"] project_id = "project1" secret_name = 'test-secret' cluster_name = 'prod-us-east1' kubectl_version = "v1.15.3" service_account_b64 = b64encode(json.dumps({'key': 'someKey'}).encode('utf-8')) os.mock_clusters_list([cluster_name]) os.mock_kubernetes_release(E.success(kubectl_version)) os.mock_download_install_kubectl(kubectl_version, E.success()) os.mock_create_kube_config(cluster_name, E.success()) os.mock_kubectl_apply_temp_file(cluster_name, E.success()) _, result = run_in_cluster( conn=gke_conn(cluster_name, project_id, service_account_b64), templates=[ secret(secret_name, data={'key1': 'someValue'}) ] ) yamls = find_write_template_calls(fs) assert yamls[0]['kind'] == 'Secret' assert yamls[0]['metadata']['name'] == secret_name assert b64decode(yamls[0]['data']['key1'].encode('utf-8')).decode('utf-8') == 'someValue' mock_krogon_dsl(_run_dsl)
def test_can_create_istio_virtual_service(): def _run_dsl(args): os: MockOsSystem = args["os_system"] fs: MockFileSystem = args['file_system'] project_id = "project1" cluster_name = 'prod-us-east1' kubectl_version = "v1.15.3" service_account_b64 = b64encode( json.dumps({ 'key': 'someKey' }).encode('utf-8')) os.mock_clusters_list([cluster_name]) os.mock_kubernetes_release(E.success(kubectl_version)) os.mock_download_install_kubectl(kubectl_version, E.success()) os.mock_create_kube_config(cluster_name, E.success()) os.mock_kubectl(cluster_name, 'get mappings', E.failure('No such resource')) os.mock_kubectl(cluster_name, 'get virtualservices', E.success()) _, result = run_in_cluster(conn=gke_conn(cluster_name, project_id, service_account_b64), templates=[ gateway_mapping( 'api', 'api.com', 'api.default.svc.cluster.local') ]) yamls = find_write_template_calls(fs) output_yaml = yamls[0] assert output_yaml == { 'apiVersion': 'networking.istio.io/v1alpha3', 'kind': 'VirtualService', 'metadata': { 'name': 'api-vs' }, 'spec': { 'hosts': ['api.com'], 'gateways': ['cluster-gateway'], 'http': [{ 'route': [{ 'destination': { 'host': 'api.default.svc.cluster.local' } }] }] } } mock_krogon_dsl(_run_dsl)
def test_gke_conn_can_get_project_id_if_exits(): def _run_dsl(_args): project_id = "someId" service_account_key = {"key": "someKey"} service_account_b64 = b64encode( json.dumps(service_account_key).encode('utf-8')).decode('utf-8') conf = config() k_ctl = gke_conn(cluster_regex='.*', project_id=project_id, service_account_b64=service_account_b64)(conf) provider: GKEProvider = k_ctl.get_provider() assert provider.get_project_id() == project_id mock_krogon_dsl(_run_dsl)
def test_gke_conn_can_raise_error_if_service_account_missing(): def _run_dsl(_args): project_id = "someProjectId" conf = config() with patch('sys.exit', return_value=b64encode('{"error": "RaisedError"}'.encode( 'utf-8')).decode('utf-8')): k_ctl = gke_conn(cluster_regex='.*', project_id=project_id)(conf) provider: GKEProvider = k_ctl.get_provider() assert provider.get_service_account_info( )['error'] == 'RaisedError' mock_krogon_dsl(_run_dsl)
def test_gke_conn_can_raise_error_if_project_id_missing(): def _run_dsl(_args): project_id = None service_account_key = {"key": "someKey"} service_account_b64 = b64encode( json.dumps(service_account_key).encode('utf-8')).decode('utf-8') conf = config() with patch('sys.exit', return_value="RaisedError"): k_ctl = gke_conn(cluster_regex='.*', project_id=project_id, service_account_b64=service_account_b64)(conf) provider: GKEProvider = k_ctl.get_provider() assert provider.get_project_id() == "RaisedError" mock_krogon_dsl(_run_dsl)
def test_micro_service_can_gen_template(): def _run_dsl(args): fs: MockFileSystem = args['file_system'] _, result = gen_template([ micro_service('test', "test-service:1.0.0", 3000).with_replicas(min=5, max=10, cpu_threshold_percentage=80) ]) deployment = find_write_template_calls(fs)[1] assert deployment['spec']['replicas'] == 5 hpa = find_write_template_calls(fs)[2] assert hpa['spec']['minReplicas'] == 5 assert hpa['spec']['maxReplicas'] == 10 mock_krogon_dsl(_run_dsl)
def test_can_exec_yaml_as_dict(): def _run_dsl(args): mock_fs: MockFileSystem = args['file_system'] project_id = "project1" service_account_b64 = b64encode(json.dumps({'key': 'someKey'}).encode('utf-8')) cluster_name = 'prod-us-east1' _, result = run_in_cluster( conn=gke_conn(cluster_name, project_id, service_account_b64), templates=[ from_dicts([{"kind": "Service"}]) ] ) yamls = find_write_template_calls(mock_fs) assert yamls[0]['kind'] == 'Service' mock_krogon_dsl(_run_dsl)
def test_gke_conn_can_get_project_id_if_exits_as_env_variable(): def _run_dsl(args): os: MockOsSystem = args['os_system'] project_id = "someId" os.mock_get_env('KG_PROJECT_ID', return_values=[project_id]) os.mock_get_env('KG_DELETE', return_values=["true"]) os.mock_get_env('KG_TEMPLATE', return_values=["false"]) service_account_key = {'key': 'someKey'} service_account_b64 = b64encode( json.dumps(service_account_key).encode('utf-8')).decode('utf-8') conf = config() k_ctl = gke_conn(cluster_regex='.*', project_id=project_id, service_account_b64=service_account_b64)(conf) provider: GKEProvider = k_ctl.get_provider() assert provider.get_project_id() == project_id mock_krogon_dsl(_run_dsl)
def test_can_set_persistent_volume_claim_size_template(): def _run_dsl(args): os: MockOsSystem = args["os_system"] fs: MockFileSystem = args['file_system'] project_id = "project1" claim_name = 'test-volume' cluster_name = 'prod-us-east1' kubectl_version = "v1.15.3" service_account_b64 = b64encode( json.dumps({ 'key': 'someKey' }).encode('utf-8')) os.mock_clusters_list([cluster_name]) os.mock_kubernetes_release(E.success(kubectl_version)) os.mock_download_install_kubectl(kubectl_version, E.success()) os.mock_create_kube_config(cluster_name, E.success()) os.mock_kubectl_apply_temp_file(cluster_name, E.success()) _, result = run_in_cluster( conn=gke_conn(cluster_name, project_id, service_account_b64), templates=[volume_claim(claim_name).with_size('5Gi')]) yamls = find_write_template_calls(fs) assert yamls[0] == { 'apiVersion': 'v1', 'kind': 'PersistentVolumeClaim', 'metadata': { 'name': 'test-volume' }, 'spec': { 'accessModes': ['ReadWriteOnce'], 'resources': { 'requests': { 'storage': '5Gi' } }, 'volumeMode': 'Filesystem' } } mock_krogon_dsl(_run_dsl)
def test_gke_conn_can_get_service_account_if_exits_as_env_variable(): def _run_dsl(args): os: MockOsSystem = args['os_system'] project_id = "someId" service_account_key = {"key": "someKey"} service_account_b64 = b64encode( json.dumps(service_account_key).encode('utf-8')).decode('utf-8') os.mock_get_env('KG_SERVICE_ACCOUNT_B64', return_values=[service_account_b64]) os.mock_get_env('KG_DELETE', return_values=["true"]) os.mock_get_env('KG_TEMPLATE', return_values=["false"]) conf = config() k_ctl = gke_conn(cluster_regex='.*', project_id=project_id)(conf) provider: GKEProvider = k_ctl.get_provider() assert_same_dict(provider.get_service_account_info(), service_account_key) mock_krogon_dsl(_run_dsl)
def test_micro_service_can_setup_volume_claims(): def _run_dsl(args): fs: MockFileSystem = args['file_system'] cluster_name = 'prod-us-east1' project_id = 'project1' service_account_b64 = b64encode( json.dumps({ 'key': 'someKey' }).encode('utf-8')) _, result = run_in_cluster( conn=gke_conn(cluster_name, project_id, service_account_b64), templates=[ micro_service( 'test', "test-service:1.0.0", 3000).with_volume_claim( 'my-volume', 'some-volume-claim', '/var/data/my-data').with_sidecar( container('my-sidecar', 'my-sidecar:1.0.0').with_volume_mount( 'my-volume', 'var/data/sidecar-data')) ]) deployment = find_write_template_calls(fs)[1] assert deployment['spec']['template']['spec']['volumes'][0] == { 'name': 'my-volume', 'persistentVolumeClaim': { 'claimName': 'some-volume-claim' } } microservice = deployment['spec']['template']['spec']['containers'][0] assert microservice['volumeMounts'][0] == { 'name': 'my-volume', 'mountPath': '/var/data/my-data' } sidecar = deployment['spec']['template']['spec']['containers'][1] assert sidecar['volumeMounts'][0] == { 'name': 'my-volume', 'mountPath': 'var/data/sidecar-data' } mock_krogon_dsl(_run_dsl)
def test_can_create_ambassador_catch_all_mapping(): def _run_dsl(args): fs: MockFileSystem = args['file_system'] os: MockOsSystem = args["os_system"] project_id = "project1" cluster_name = 'prod-us-east1' kubectl_version = "v1.15.3" service_account_b64 = b64encode( json.dumps({ 'key': 'someKey' }).encode('utf-8')) os.mock_clusters_list([cluster_name]) os.mock_kubernetes_release(E.success(kubectl_version)) os.mock_download_install_kubectl(kubectl_version, E.success()) os.mock_create_kube_config(cluster_name, E.success()) os.mock_kubectl(cluster_name, 'get mappings', E.success()) os.mock_kubectl(cluster_name, 'get virtualservices', E.failure('No such resource')) _, result = run_in_cluster( conn=gke_conn(cluster_name, project_id, service_account_b64), templates=[ gateway_mapping('api', '*', 'api.default.svc.cluster.local') ]) yamls = find_write_template_calls(fs) output_yaml = yamls[0] assert output_yaml == { 'apiVersion': 'getambassador.io/v1', 'kind': 'Mapping', 'metadata': { 'name': 'api-mapping' }, 'spec': { 'prefix': '/', 'service': 'api.default.svc.cluster.local' } } mock_krogon_dsl(_run_dsl)
def test_micro_service_can_change_service_type(): def _run_dsl(args): fs: MockFileSystem = args["file_system"] service_type = 'NodePort' cluster_name = 'prod-us-east1' project_id = 'project1' service_account_b64 = b64encode( json.dumps({ 'key': 'someKey' }).encode('utf-8')) _, result = run_in_cluster( conn=gke_conn(cluster_name, project_id, service_account_b64), templates=[ micro_service('test', "test-service:1.0.0", 3000).with_service_type(service_type) ]) yamls = find_write_template_calls(fs) assert yamls[0]['kind'] == 'Service' assert yamls[0]['spec']['type'] == 'NodePort' mock_krogon_dsl(_run_dsl)
def test_deployment_can_generate_deployment_template(): def _run_dsl(args): os: MockOsSystem = args["os_system"] fs: MockFileSystem = args["file_system"] project_id = "project1" app_name = 'test-service' cluster_name = 'prod-us-east1' kubectl_version = "v1.15.3" service_account_b64 = b64encode(json.dumps({'key': 'someKey'}).encode('utf-8')) os.mock_clusters_list([cluster_name]) os.mock_kubernetes_release(E.success(kubectl_version)) os.mock_download_install_kubectl(kubectl_version, E.success()) os.mock_create_kube_config(cluster_name, E.success()) os.mock_kubectl_apply_temp_file(cluster_name, E.success()) _, result = run_in_cluster( conn=gke_conn(cluster_name, project_id, service_account_b64), templates=[ deployment(app_name) .with_empty_volume(name='test-volume') .with_container(container('test', 'test:100')) .with_container(container('test-2', 'test-2:100')) ] ) deployment_yaml = find_write_template_calls(fs)[0] assert deployment_yaml['kind'] == 'Deployment' assert deployment_yaml['metadata']['name'] == app_name+'-dp' assert deployment_yaml['spec']['selector']['matchLabels']['app'] == app_name+'-app' assert deployment_yaml['spec']['template']['spec']['volumes'][0]['name'] == 'test-volume' container1 = deployment_yaml['spec']['template']['spec']['containers'][0] container2 = deployment_yaml['spec']['template']['spec']['containers'][1] assert container1['name'] == 'test-app' assert container1['image'] == 'test:100' assert container2['name'] == 'test-2-app' assert container2['image'] == 'test-2:100' mock_krogon_dsl(_run_dsl)
def test_micro_service_can_set_secret(): def _run_dsl(args): os: MockOsSystem = args["os_system"] fs: MockFileSystem = args["file_system"] project_id = "project1" service_name = 'test-service' cluster_name = 'prod-us-east1' kubectl_version = "v1.15.3" image_url = "test-service:1.0.0" app_port = 3000 service_account_b64 = b64encode( json.dumps({ 'key': 'someKey' }).encode('utf-8')) os.mock_clusters_list([cluster_name]) os.mock_kubernetes_release(E.success(kubectl_version)) os.mock_download_install_kubectl(kubectl_version, E.success()) os.mock_create_kube_config(cluster_name, E.success()) os.mock_kubectl_apply_temp_file(cluster_name, E.success()) _, result = run_in_cluster( conn=gke_conn(cluster_name, project_id, service_account_b64), templates=[ micro_service(service_name, image_url, app_port).with_environment_secret( 'coolSecret', {'ENV_NAME': 'secretkey'}) ]) yamls = find_write_template_calls(fs) assert yamls[1]['kind'] == 'Deployment' container = yamls[1]['spec']['template']['spec']['containers'][0] assert container['env'][0]['name'] == 'ENV_NAME' assert container['env'][0]['valueFrom']['secretKeyRef'][ 'name'] == 'coolSecret' assert container['env'][0]['valueFrom']['secretKeyRef'][ 'key'] == 'secretkey' mock_krogon_dsl(_run_dsl)