async def test_jobs_get_by_id_job_exist(self, chronos_job_fixture):
chronos_job_fixture["name"] = f"{self.account.namespace}-my-job"
async with http_client as client:
await client.post(
f"{settings.SCHEDULED_JOBS_SERVICE_ADDRESS}/v1/scheduler/iso8601",
json=chronos_job_fixture,
)
# Para dar tempo do chronos registra e responder no request log abaixo
await asyncio.sleep(1)
asgard_job = ChronosScheduledJobConverter.to_asgard_model(
ChronosJob(**chronos_job_fixture))
# A busca deve ser feita sempre *sem* o namespace
asgard_job.remove_namespace(self.account)
resp = await self.client.get(
f"/jobs/{asgard_job.id}",
headers={
"Authorization":
f"Token {USER_WITH_MULTIPLE_ACCOUNTS_AUTH_KEY}"
},
)
self.assertEqual(HTTPStatus.OK, resp.status)
resp_data = await resp.json()
self.assertEqual(
ScheduledJobResource(job=asgard_job).dict(), resp_data)
async def test_delete_job_job_exist(self, dev_job_fixture):
await _load_jobs_into_chronos(dev_job_fixture)
asgard_job = ChronosScheduledJobConverter.to_asgard_model(
ChronosJob(**dev_job_fixture)).remove_namespace(self.account)
resp = await self.client.delete(
f"/jobs/{asgard_job.id}",
headers={
"Authorization":
f"Token {USER_WITH_MULTIPLE_ACCOUNTS_AUTH_KEY}"
},
)
self.assertEqual(HTTPStatus.OK, resp.status)
resp_data = await resp.json()
self.assertEqual(
ScheduledJobResource(job=asgard_job).dict(), resp_data)
resp = await self.client.get(
f"/jobs/{asgard_job.id}",
headers={
"Authorization":
f"Token {USER_WITH_MULTIPLE_ACCOUNTS_AUTH_KEY}"
},
)
self.assertEqual(HTTPStatus.NOT_FOUND, resp.status)
async def index_jobs(job_id: str, user: User, account: Account):
scheduled_job = await ScheduledJobsService.get_job_by_id(
job_id, user, account, ChronosScheduledJobsBackend())
status_code = HTTPStatus.OK if scheduled_job else HTTPStatus.NOT_FOUND
return json_response(ScheduledJobResource(job=scheduled_job).dict(),
status=status_code)
async def index_jobs(request: web.Request):
user = await User.from_alchemy_obj(request["user"])
account = await Account.from_alchemy_obj(request["user"].current_account)
job_id = request.match_info["job_id"]
scheduled_job = await ScheduledJobsService.get_job_by_id(
job_id, user, account, ChronosScheduledJobsBackend())
status_code = HTTPStatus.OK if scheduled_job else HTTPStatus.NOT_FOUND
return web.json_response(ScheduledJobResource(job=scheduled_job).dict(),
status=status_code)
async def index_jobs(request: web.Request, user: User, account: Account):
job_id = request.match_info["job_id"]
scheduled_job = await ScheduledJobsService.get_job_by_id(
job_id, user, account, ChronosScheduledJobsBackend()
)
status_code = HTTPStatus.OK if scheduled_job else HTTPStatus.NOT_FOUND
return web.json_response(
ScheduledJobResource(job=scheduled_job).dict(), status=status_code
)
async def test_jobs_get_by_by_id_jobs_does_not_exist(self):
resp = await self.client.get(
"/jobs/job-does-not-exist",
headers={
"Authorization":
f"Token {USER_WITH_MULTIPLE_ACCOUNTS_AUTH_KEY}"
},
)
self.assertEqual(HTTPStatus.NOT_FOUND, resp.status)
resp_data = await resp.json()
self.assertEqual(ScheduledJobResource().dict(), resp_data)
async def test_create_job_add_internal_field_values(self, dev_job_fixture):
"""
Conferimos que quando um job é criado adicionamos os valores obrigatórios
de alguns campos
"""
await _cleanup_chronos()
account = Account(**ACCOUNT_DEV_DICT)
asgard_job_no_namespace = ChronosScheduledJobConverter.to_asgard_model(
ChronosJob(**dev_job_fixture)).remove_namespace(account)
resp = await self.client.post(
"/jobs",
headers={
"Authorization":
f"Token {USER_WITH_MULTIPLE_ACCOUNTS_AUTH_KEY}"
},
json=asgard_job_no_namespace.dict(),
)
self.assertEqual(HTTPStatus.CREATED, resp.status)
resp_data = await resp.json()
self.assertEqual(
f"{asgard_job_no_namespace.id}",
CreateScheduledJobResource(**resp_data).job.id,
)
await asyncio.sleep(0.5)
resp_created_job = await self.client.get(
f"/jobs/{asgard_job_no_namespace.id}",
headers={
"Authorization":
f"Token {USER_WITH_MULTIPLE_ACCOUNTS_AUTH_KEY}"
},
)
created_job_resource = ScheduledJobResource(
**await resp_created_job.json())
self.assertEqual(HTTPStatus.OK, resp_created_job.status)
expected_constraints = asgard_job_no_namespace.constraints + [
f"owner:LIKE:{account.owner}"
]
self.assertEqual(created_job_resource.job.constraints,
expected_constraints)
expected_fetch_uris = asgard_job_no_namespace.fetch + [
FetchURLSpec(
uri=settings.SCHEDULED_JOBS_DEFAULT_FETCH_URIS[0].uri),
FetchURLSpec(
uri=settings.SCHEDULED_JOBS_DEFAULT_FETCH_URIS[1].uri),
]
self.assertEqual(created_job_resource.job.fetch, expected_fetch_uris)
async def test_jobs_get_by_id_job_exist(self, chronos_job_fixture):
await _load_jobs_into_chronos(chronos_job_fixture)
asgard_job = ChronosScheduledJobConverter.to_asgard_model(
ChronosJob(**chronos_job_fixture))
# A busca deve ser feita sempre *sem* o namespace
asgard_job.remove_namespace(self.account)
resp = await self.client.get(
f"/jobs/{asgard_job.id}",
headers={
"Authorization":
f"Token {USER_WITH_MULTIPLE_ACCOUNTS_AUTH_KEY}"
},
)
self.assertEqual(HTTPStatus.OK, resp.status)
resp_data = await resp.json()
self.assertEqual(
ScheduledJobResource(job=asgard_job).dict(), resp_data)