def test_add_namespace_create_new_app(self):
"""
Para novas apps, sempre vamos adicionar o prefixo.
"""
modified_app = self.filter.write(self.user, self.request_app,
AsgardApp())
self.assertEqual("/dev/foo", modified_app.id)
def split(self) -> Apps:
if self.is_read_request():
response_content = json.loads(self.response.data)
if self.is_list_apps_request():
for app in response_content['apps']:
response_app = AsgardApp.from_json(app)
app = self.marathon_client.get_app(self.object_id
or response_app.id)
yield response_app, app
return
elif self.is_group_request():
response_group = AsgardAppGroup(
MarathonGroup.from_json(response_content))
for current_group in response_group.iterate_groups():
group_id = current_group.id
group_id_without_namespace = self._remove_namespace_if_exists(
self.request.user.current_account.namespace, group_id)
original_group = self._get_original_group(
self.request.user, group_id_without_namespace)
yield current_group, original_group
return
elif self.is_tasks_request():
for task in response_content['tasks']:
response_task = MarathonTask.from_json(task)
yield response_task, response_task
return
elif self.is_deployment():
content = response_content
deployments = (MarathonDeployment.from_json(deploy)
for deploy in content)
for deployment in deployments:
yield deployment, deployment
return
elif self.is_queue_request():
queue_data = response_content
queued_apps = (MarathonQueueItem.from_json(queue_item)
for queue_item in queue_data['queue'])
for queued_app in queued_apps:
yield queued_app, queued_app
return
else:
response_app = AsgardApp.from_json(
response_content.get('app') or response_content)
app = self.marathon_client.get_app(self.object_id)
yield response_app, app
return
if self.is_write_request():
response_content = json.loads(self.response.data)
if 'tasks' in response_content:
for task in response_content['tasks']:
response_task = MarathonTask.from_json(task)
yield response_task, response_task
return
return
yield AsgardApp(), self.marathon_client.get_app(self.app_id)
def split(self) -> Apps:
if self.is_read_request():
response_content = json.loads(self.response.data)
if self.is_list_apps_request():
all_apps = list(
AsgardAppGroup.from_json(response_content).iterate_apps()
)
for response_app in all_apps:
yield response_app, response_app
return
elif self.is_group_request():
response_group = AsgardAppGroup(
MarathonGroup.from_json(response_content)
)
for current_group in response_group.iterate_groups():
yield current_group, current_group
return
elif self.is_tasks_request():
for task in response_content["tasks"]:
response_task = MarathonTask.from_json(task)
yield response_task, response_task
return
elif self.is_deployment():
content = response_content
deployments = (
MarathonDeployment.from_json(deploy) for deploy in content
)
for deployment in deployments:
yield deployment, deployment
return
elif self.is_queue_request():
queue_data = response_content
queued_apps = (
MarathonQueueItem.from_json(queue_item)
for queue_item in queue_data["queue"]
)
for queued_app in queued_apps:
yield queued_app, queued_app
return
else:
response_app = AsgardApp.from_json(
response_content.get("app") or response_content
)
app = self.marathon_client.get_app(self.object_id)
yield response_app, app
return
if self.is_write_request():
response_content = json.loads(self.response.data)
if "tasks" in response_content:
for task in response_content["tasks"]:
response_task = MarathonTask.from_json(task)
yield response_task, response_task
return
return
yield AsgardApp(), self.marathon_client.get_app(self.app_id)
def test_create_app_with_zero_instances(self):
self.request_app.instances = 0
self.assertTrue(self.request_app.labels["traefik.enable"])
filtered_app = self.filter.write(self.user, self.request_app,
AsgardApp())
self.assertEqual("false", filtered_app.labels["traefik.enable"])
def test_create_app_with_zero_instances(self):
self.request_app.instances = 0
filtered_app = self.filter.write(self.user, self.request_app,
AsgardApp())
self.assertTrue(
"hollowman.default_scale" not in filtered_app.labels.keys(),
"Não deveria ter adicionado label default_scale",
)
def test_shouldnt_modify_app_if_instances_fields_is_not_present(self):
self.request_app.instances = None
self.original_app = AsgardApp()
self.request_app.labels["traefik.enable"] = "true"
self.filter.write(self.user, self.request_app, self.original_app)
self.assertEqual("true", self.request_app.labels["traefik.enable"])
def test_update_suspended_app_set_instances_to_zero(self):
self.request_app = AsgardApp.from_json({"env": {"ENV_A": "VALUE"}})
self.original_app.instances = 10
filtered_app = self.filter.write(self.user, self.request_app,
AsgardApp())
self.assertIsNone(filtered_app.labels.get("traefik.enable"))
def test_should_not_modify_non_http_apps(self):
self.request_app.instances = 0
del self.request_app.labels["traefik.enable"]
filtered_app = self.filter.write(self.user, self.request_app,
AsgardApp())
self.assertTrue("traefik.enable" not in filtered_app.labels)
def test_create_app_add_constraint_app_with_other_constraints(self):
filtered_app = self.filter.write(self.user, self.request_app,
AsgardApp())
owner_constraint = filtered_app.get_constraints_by_name("owner")
self.assertEqual(2, len(filtered_app.constraints))
self.assertEqual(1, len(owner_constraint))
self.assertEqual(self.account_dev.owner, owner_constraint[0].value)
def test_create_app_do_not_add_uri_if_exist(self):
self.single_full_app_fixture["uris"] = copy(
self.base_uris) + [self.docker_auth_uri]
self.request_app = AsgardApp.from_json(self.single_full_app_fixture)
filtered_app = self.filter.write(None, self.request_app, AsgardApp())
self.assertEqual(3, len(filtered_app.uris))
self.assertEqual(self.base_uris + [self.docker_auth_uri],
filtered_app.uris)
def test_create_app_add_uri_with_other_existing_uris(self):
"""
Mesmo se a app já tiver utras uris, temos que adicionar a nossa
"""
self.single_full_app_fixture['uris'] = copy(self.base_uris)
self.request_app = AsgardApp.from_json(self.single_full_app_fixture)
filtered_app = self.filter.write(None, self.request_app, AsgardApp())
self.assertEqual(3, len(filtered_app.uris))
self.assertEqual(self.base_uris + [self.docker_auth_uri], filtered_app.uris)
def test_create_app_constraint_exist_with_wrong_value(self):
self.request_app.constraints.append(
MarathonConstraint(field="owner",
operator="LIKE",
value="other-owner"))
filtered_app = self.filter.write(self.user, self.request_app,
AsgardApp())
owner_constraint = filtered_app.get_constraints_by_name("owner")
self.assertEqual(2, len(filtered_app.constraints))
self.assertEqual(1, len(owner_constraint))
self.assertEqual(self.account_dev.owner, owner_constraint[0].value)
def join(self, apps: Apps) -> FlaskResponse:
body = json.loads(self.response.data)
if self.is_list_apps_request():
apps_json_repr = [
response_app.json_repr(minimal=True) for response_app, _ in apps
]
body = {"apps": apps_json_repr}
elif self.is_read_request() and self.is_app_request():
# TODO: Retornar 404 nesse caso. Pensar em como fazer.
# No caso de ser um acesso a uma app específica, e ainda sim recebermos apps = [],
# deveríamos retornar 404. Chegar uma lista vazia qui significa que a app foi removida
# do response, ou seja, quem fez o request não pode visualizar esses dados, portanto, 404.
response_app = apps[0][0] if apps else AsgardApp()
body = {"app": response_app.json_repr(minimal=True)}
if "/versions/" in self.request.path:
body = body["app"]
elif self.is_read_request() and self.is_group_request():
response_group = apps[0][0] if apps else MarathonGroup()
body = response_group.json_repr(minimal=False)
elif self.is_read_request() and self.is_deployment():
deployments_json_repr = [
response_deployment.json_repr(minimal=True)
for response_deployment, _ in apps
]
body = deployments_json_repr
elif self.is_read_request() and self.is_queue_request():
queue_json_repr = [
queue.json_repr(minimal=True) for queue, _ in apps
]
body = {"queue": queue_json_repr}
elif self.is_tasks_request():
original_response_data = json.loads(self.response.data)
all_tasks = []
for task, _ in apps:
all_tasks.append(task.json_repr(minimal=False))
body = {"tasks": all_tasks}
try:
original_response_data["tasks"]
except KeyError:
body = original_response_data
return FlaskResponse(
response=json.dumps(body, cls=self.json_encoder),
status=self.response.status,
headers=self.response.headers,
)
def test_create_app_add_uri_if_not_exist(self):
self.request_app = AsgardApp.from_json(self.single_full_app_fixture)
filtered_app = self.filter.write(None, self.request_app, AsgardApp())
self.assertEqual(1, len(filtered_app.uris))
self.assertEqual([self.docker_auth_uri], filtered_app.uris)
def test_update_app_remove_traefik_backend_label_do_not_exist(self):
filtered_app = self.filter.write(None, self.request_app, AsgardApp())
self.assertFalse('traefik.backend' in filtered_app.labels.keys())
def test_create_app_remove_traefik_backend_label_exists(self):
self.request_app.labels['traefik.backend'] = 'my-app-backend'
filtered_app = self.filter.write(None, self.request_app, AsgardApp())
self.assertFalse('traefik.backend' in filtered_app.labels.keys())
def test_update_app_remove_traefik_backend_label_exists(self):
self.request_app.labels["traefik.backend"] = "my-app-backend"
filtered_app = self.filter.write(None, self.request_app, AsgardApp())
self.assertFalse("traefik.backend" in filtered_app.labels.keys())
def test_label_update_non_existent_label(self):
app = AsgardApp(labels={"label1": "value1"})
app.update_label("label2", "value2")
self.assertEqual(2, len(app.labels.keys()))
self.assertEqual("value2", app.labels["label2"])
def test_label_update_existing_label(self):
app = AsgardApp(labels={"label1": "value1"})
app.update_label("label1", "new-value")
self.assertEqual(1, len(app.labels.keys()))
self.assertEqual("new-value", app.labels["label1"])