Пример #1
0
 async def test_serialized_parse_dict_required_fields(self):
     full_scheduled_job = {
         **self.required_fields_scheduled_job,
         "command": None,
         "arguments": None,
         "concurrent": True,
         "disk": 0,
         "container": {
             **self.container_spec,
             "parameters": None,
             "privileged": False,
             "pull_image": True,
             "volumes": None,
             "ports": None,
             "type": "DOCKER",
         },
         "schedule": {
             **self.schedule_spec
         },
         "env": None,
         "constraints": None,
         "fetch": None,
         "shell": False,
         "retries": 5,
         "enabled": True,
     }
     self.assertEqual(full_scheduled_job,
                      ScheduledJob(**full_scheduled_job).dict())
Пример #2
0
    def to_asgard_model(cls, other: ChronosJob) -> ScheduledJob:
        env_dict = None
        fetch_list = None
        constraints_list = None
        if other.environmentVariables:
            env_dict = ChronosEnvSpecConverter.to_asgard_model(
                other.environmentVariables)

        if other.fetch:
            fetch_list = ChronosFetchURLSpecConverter.to_asgard_model(
                other.fetch)

        if other.constraints:
            constraints_list = ChronosConstraintSpecConverter.to_asgard_model(
                other.constraints)
        return ScheduledJob(
            id=other.name,
            description=other.description,
            command=other.command,
            arguments=other.arguments,
            cpus=other.cpus,
            mem=other.mem,
            disk=other.disk,
            pull_image=other.container.forcePullImage,
            enabled=not other.disabled,
            shell=other.shell,
            container=ChronosContainerSpecConverter.to_asgard_model(
                other.container),
            schedule=ScheduleSpec(value=other.schedule,
                                  tz=other.scheduleTimeZone),
            env=env_dict,
            fetch=fetch_list,
            constraints=constraints_list,
        )
Пример #3
0
 async def test_valid_job_name(self):
     """
     O nome de cada job so poderá ter [a-z0-9-]
     """
     self.required_fields_scheduled_job["id"] = "a-valid-name-2"
     job = ScheduledJob(**self.required_fields_scheduled_job)
     self.assertEqual(self.required_fields_scheduled_job["id"], job.id)
Пример #4
0
    async def test_remove_account_namespace_app_id_does_not_have_namespace(
            self):
        app = ScheduledJob(**self.required_fields_scheduled_job)
        account = Account(**ACCOUNT_DEV_DICT)
        self.assertEqual(self.required_fields_scheduled_job["id"], app.id)

        app.remove_namespace(account)
        self.assertEqual(self.required_fields_scheduled_job["id"], app.id)
Пример #5
0
    async def test_remove_namespace_only_once(self):
        account = Account(**ACCOUNT_DEV_DICT)
        self.required_fields_scheduled_job[
            "id"] = f"{account.namespace}-{account.namespace}-my-app-with-ns"
        app = ScheduledJob(**self.required_fields_scheduled_job)

        app.remove_namespace(account)
        expected_app_id = f"{account.namespace}-my-app-with-ns"
        self.assertEqual(expected_app_id, app.id)
Пример #6
0
    async def test_add_account_namespace_to_name(self):
        app = ScheduledJob(**self.required_fields_scheduled_job)
        account = Account(**ACCOUNT_DEV_DICT)
        self.assertEqual(self.required_fields_scheduled_job["id"], app.id)

        app.add_namespace(account)
        expected_app_id = (
            f"{account.namespace}-{self.required_fields_scheduled_job['id'] }")
        self.assertEqual(expected_app_id, app.id)
Пример #7
0
    async def test_remove_namepace_returns_self(self):

        account = Account(**ACCOUNT_DEV_DICT)
        self.required_fields_scheduled_job[
            "id"] = f"my-app-with-{account.namespace}-ns"
        app = ScheduledJob(**self.required_fields_scheduled_job)

        returned_app = app.remove_namespace(account)
        self.assertTrue(app is returned_app)
Пример #8
0
    async def test_add_namespace_app_id_has_namespace_in_the_middle(self):
        account = Account(**ACCOUNT_DEV_DICT)
        self.required_fields_scheduled_job[
            "id"] = f"my-app-with-{account.namespace}-ns"
        app = ScheduledJob(**self.required_fields_scheduled_job)

        app.add_namespace(account)
        expected_app_id = (
            f"{account.namespace}-{self.required_fields_scheduled_job['id'] }")
        self.assertEqual(expected_app_id, app.id)
Пример #9
0
    async def test_remove_namespace_app_id_contains_namespace(self):
        """
        Se o namepspace está no meio do nome, não deve ser removido
        """
        account = Account(**ACCOUNT_DEV_DICT)
        self.required_fields_scheduled_job[
            "id"] = f"my-app-with-{account.namespace}-ns"
        app = ScheduledJob(**self.required_fields_scheduled_job)

        app.remove_namespace(account)
        self.assertEqual(self.required_fields_scheduled_job["id"], app.id)
Пример #10
0
    async def test_add_namespace_app_id_begins_with_namespace(self):
        """
        Adicionamos o namespace independente da app já ter o nome com
        exatamente o namespace no começo.
        """
        app = ScheduledJob(**self.required_fields_scheduled_job)
        account = Account(**ACCOUNT_DEV_DICT)
        self.assertEqual(self.required_fields_scheduled_job["id"], app.id)

        app.add_namespace(account)
        app.add_namespace(account)
        expected_app_id = f"{account.namespace}-{account.namespace }-{self.required_fields_scheduled_job['id']}"
        self.assertEqual(expected_app_id, app.id)
    async def test_to_client_model_required_fields(self, chronos_job_fixture):
        asgard_job_dict = ChronosScheduledJobConverter.to_asgard_model(
            ChronosJob(**chronos_job_fixture)).dict()

        del asgard_job_dict["env"]
        del asgard_job_dict["fetch"]
        del asgard_job_dict["constraints"]
        chronos_job = ChronosScheduledJobConverter.to_client_model(
            ScheduledJob(**asgard_job_dict))

        chronos_converted = ChronosScheduledJobConverter.to_client_model(
            ChronosScheduledJobConverter.to_asgard_model(chronos_job))

        self.assertEqual(chronos_converted.dict(), chronos_job.dict())
Пример #12
0
    async def _wrapper(request: web.Request):
        try:
            req_body = await request.json()
        except JSONDecodeError as e:
            return web.json_response(
                ErrorResource(errors=[ErrorDetail(msg=str(e))]).dict(),
                status=HTTPStatus.BAD_REQUEST,
            )

        try:
            job = ScheduledJob(**req_body)
        except ValidationError as e:
            return web.json_response(
                ErrorResource(errors=[ErrorDetail(msg=str(e))]).dict(),
                status=HTTPStatus.UNPROCESSABLE_ENTITY,
            )

        request["types_registry"].set(job)
        return await call_http_handler(request, handler)
    async def test_to_client_model_env_field(self):

        asgard_dict_with_env_data = {
            "id": "my-app",
            "cpus": 1,
            "mem": 32,
            "description": "Example",
            "schedule": {
                "value": "2019"
            },
            "container": {
                "image": "alpine",
                "network": "BRIDGE"
            },
            "env": {
                "SERVICE_A_ADDRESS": "https://a.service.local",
                "SERVICE_B_ADDRESS": "https://b.service.local",
            },
        }
        asgard_scheduled_job = ScheduledJob(**asgard_dict_with_env_data)
        chronos_job = ChronosScheduledJobConverter.to_client_model(
            asgard_scheduled_job)
        self.assertEqual(
            [
                {
                    "name": "SERVICE_A_ADDRESS",
                    "value": "https://a.service.local",
                },
                {
                    "name": "SERVICE_B_ADDRESS",
                    "value": "https://b.service.local",
                },
            ],
            [
                chronos_job.environmentVariables[0].dict(),
                chronos_job.environmentVariables[1].dict(),
            ],
        )
Пример #14
0
 async def test_invalid_job_name_with_slash(self):
     with self.assertRaises(ValidationError):
         self.required_fields_scheduled_job["id"] = "my/app"
         ScheduledJob(**self.required_fields_scheduled_job)
Пример #15
0
 async def test_invalid_job_name(self):
     with self.assertRaises(ValidationError):
         self.required_fields_scheduled_job["id"] = "InvalidJobName"
         ScheduledJob(**self.required_fields_scheduled_job)