From 37410582425ea9b215eeabfc0c5b36c49476942b Mon Sep 17 00:00:00 2001 From: Bert Blommers Date: Fri, 16 Jun 2023 10:42:07 +0000 Subject: [PATCH] Techdebt: Replace sure with regular asserts in Batch (#6413) --- tests/test_batch/test_batch.py | 2 +- tests/test_batch/test_batch_cloudformation.py | 32 ++- tests/test_batch/test_batch_compute_envs.py | 75 ++++--- tests/test_batch/test_batch_job_queue.py | 46 ++-- tests/test_batch/test_batch_jobs.py | 209 +++++++++--------- .../test_batch_scheduling_policy.py | 57 ++--- .../test_batch_tags_job_definition.py | 7 +- tests/test_batch/test_batch_tags_job_queue.py | 17 +- .../test_batch_tags_scheduling_policy.py | 2 +- .../test_batch/test_batch_task_definition.py | 107 +++++---- tests/test_batch/test_server.py | 4 +- .../test_batch_cloudformation.py | 36 ++- .../test_batch_compute_envs.py | 15 +- 13 files changed, 287 insertions(+), 322 deletions(-) diff --git a/tests/test_batch/test_batch.py b/tests/test_batch/test_batch.py index f9fc064e4..a1793ab92 100644 --- a/tests/test_batch/test_batch.py +++ b/tests/test_batch/test_batch.py @@ -9,4 +9,4 @@ from moto import mock_batch def test_batch_regions(region): client = boto3.client("batch", region_name=region) resp = client.describe_jobs(jobs=[""]) - resp["ResponseMetadata"]["HTTPStatusCode"].should.equal(200) + assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200 diff --git a/tests/test_batch/test_batch_cloudformation.py b/tests/test_batch/test_batch_cloudformation.py index 131660930..f20f16c11 100644 --- a/tests/test_batch/test_batch_cloudformation.py +++ b/tests/test_batch/test_batch_cloudformation.py @@ -1,5 +1,4 @@ import boto3 -import sure # noqa # pylint: disable=unused-import from moto import mock_batch, mock_iam, mock_ec2, mock_ecs, mock_cloudformation import json from uuid import uuid4 @@ -86,17 +85,12 @@ def test_create_env_cf(): ] stack_resources = cf_conn.list_stack_resources(StackName=stack_id) + summary = stack_resources["StackResourceSummaries"][0] - stack_resources["StackResourceSummaries"][0]["ResourceStatus"].should.equal( - "CREATE_COMPLETE" - ) + assert summary["ResourceStatus"] == "CREATE_COMPLETE" # Spot checks on the ARN - stack_resources["StackResourceSummaries"][0]["PhysicalResourceId"].startswith( - "arn:aws:batch:" - ) - stack_resources["StackResourceSummaries"][0]["PhysicalResourceId"].should.contain( - stack_name - ) + assert "arn:aws:batch:" in summary["PhysicalResourceId"] + assert stack_name in summary["PhysicalResourceId"] @mock_cloudformation() @@ -150,7 +144,7 @@ def test_create_job_queue_cf(): ] stack_resources = cf_conn.list_stack_resources(StackName=stack_id) - len(stack_resources["StackResourceSummaries"]).should.equal(2) + assert len(stack_resources["StackResourceSummaries"]) == 2 job_queue_resource = list( filter( @@ -159,11 +153,11 @@ def test_create_job_queue_cf(): ) )[0] - job_queue_resource["ResourceStatus"].should.equal("CREATE_COMPLETE") + assert job_queue_resource["ResourceStatus"] == "CREATE_COMPLETE" # Spot checks on the ARN job_queue_resource["PhysicalResourceId"].startswith("arn:aws:batch:") - job_queue_resource["PhysicalResourceId"].should.contain(stack_name) - job_queue_resource["PhysicalResourceId"].should.contain("job-queue/") + assert stack_name in job_queue_resource["PhysicalResourceId"] + assert "job-queue/" in job_queue_resource["PhysicalResourceId"] @mock_cloudformation() @@ -242,7 +236,7 @@ def test_create_job_def_cf(): ] stack_resources = cf_conn.list_stack_resources(StackName=stack_id) - len(stack_resources["StackResourceSummaries"]).should.equal(3) + assert len(stack_resources["StackResourceSummaries"]) == 3 job_def_resource = list( filter( @@ -251,11 +245,11 @@ def test_create_job_def_cf(): ) )[0] - job_def_resource["ResourceStatus"].should.equal("CREATE_COMPLETE") + assert job_def_resource["ResourceStatus"] == "CREATE_COMPLETE" # Spot checks on the ARN job_def_resource["PhysicalResourceId"].startswith("arn:aws:batch:") - job_def_resource["PhysicalResourceId"].should.contain(f"{stack_name}-JobDef") - job_def_resource["PhysicalResourceId"].should.contain("job-definition/") + assert f"{stack_name}-JobDef" in job_def_resource["PhysicalResourceId"] + assert "job-definition/" in job_def_resource["PhysicalResourceId"] # Test the linux parameter device host path # This ensures that batch is parsing the parameter dictionaries @@ -269,4 +263,4 @@ def test_create_job_def_cf(): "containerProperties" ]["linuxParameters"]["devices"][0]["hostPath"] - job_def_linux_device_host_path.should.equal("test-path") + assert job_def_linux_device_host_path == "test-path" diff --git a/tests/test_batch/test_batch_compute_envs.py b/tests/test_batch/test_batch_compute_envs.py index adce73f9c..e493d7754 100644 --- a/tests/test_batch/test_batch_compute_envs.py +++ b/tests/test_batch/test_batch_compute_envs.py @@ -1,6 +1,5 @@ from . import _get_clients, _setup import pytest -import sure # noqa # pylint: disable=unused-import from botocore.exceptions import ClientError from moto import mock_batch, mock_iam, mock_ec2, mock_ecs, settings from uuid import uuid4 @@ -37,8 +36,8 @@ def test_create_managed_compute_environment(): }, serviceRole=iam_arn, ) - resp.should.contain("computeEnvironmentArn") - resp["computeEnvironmentName"].should.equal(compute_name) + assert "computeEnvironmentArn" in resp + assert resp["computeEnvironmentName"] == compute_name our_env = batch_client.describe_compute_environments( computeEnvironments=[compute_name] @@ -48,12 +47,12 @@ def test_create_managed_compute_environment(): if not settings.TEST_SERVER_MODE: # Can't verify this in ServerMode, as other tests may have created instances resp = ec2_client.describe_instances() - resp.should.contain("Reservations") - len(resp["Reservations"]).should.equal(3) + assert "Reservations" in resp + assert len(resp["Reservations"]) == 3 # Should have created 1 ECS cluster all_clusters = ecs_client.list_clusters()["clusterArns"] - all_clusters.should.contain(our_env["ecsClusterArn"]) + assert our_env["ecsClusterArn"] in all_clusters @mock_ec2 @@ -97,7 +96,7 @@ def test_create_managed_compute_environment_with_instance_family(): our_env = batch_client.describe_compute_environments( computeEnvironments=[compute_name] )["computeEnvironments"][0] - our_env["computeResources"]["instanceTypes"].should.equal(["t2"]) + assert our_env["computeResources"]["instanceTypes"] == ["t2"] @mock_ec2 @@ -139,8 +138,8 @@ def test_create_managed_compute_environment_with_unknown_instance_type(): serviceRole=iam_arn, ) err = exc.value.response["Error"] - err["Code"].should.equal("InvalidParameterValue") - err["Message"].should.equal("Instance type unknown does not exist") + assert err["Code"] == "InvalidParameterValue" + assert err["Message"] == "Instance type unknown does not exist" @mock_ec2 @@ -158,24 +157,24 @@ def test_create_unmanaged_compute_environment(): state="ENABLED", serviceRole=iam_arn, ) - resp.should.contain("computeEnvironmentArn") - resp["computeEnvironmentName"].should.equal(compute_name) + assert "computeEnvironmentArn" in resp + assert resp["computeEnvironmentName"] == compute_name our_env = batch_client.describe_compute_environments( computeEnvironments=[compute_name] )["computeEnvironments"][0] - our_env.should.have.key("ecsClusterArn") + assert "ecsClusterArn" in our_env # Its unmanaged so no instances should be created if not settings.TEST_SERVER_MODE: # Can't verify this in ServerMode, as other tests may have created instances resp = ec2_client.describe_instances() - resp.should.contain("Reservations") - len(resp["Reservations"]).should.equal(0) + assert "Reservations" in resp + assert len(resp["Reservations"]) == 0 # Should have created 1 ECS cluster all_clusters = ecs_client.list_clusters()["clusterArns"] - all_clusters.should.contain(our_env["ecsClusterArn"]) + assert our_env["ecsClusterArn"] in all_clusters # TODO create 1000s of tests to test complex option combinations of create environment @@ -202,16 +201,16 @@ def test_describe_compute_environment(): all_envs = batch_client.describe_compute_environments()["computeEnvironments"] our_envs = [e for e in all_envs if e["computeEnvironmentName"] == compute_name] - our_envs.should.have.length_of(1) - our_envs[0]["computeEnvironmentName"].should.equal(compute_name) - our_envs[0]["computeEnvironmentArn"].should.equal(compute_arn) - our_envs[0].should.have.key("ecsClusterArn") - our_envs[0].should.have.key("state").equal("ENABLED") - our_envs[0].should.have.key("status").equal("VALID") + assert len(our_envs) == 1 + assert our_envs[0]["computeEnvironmentName"] == compute_name + assert our_envs[0]["computeEnvironmentArn"] == compute_arn + assert "ecsClusterArn" in our_envs[0] + assert our_envs[0]["state"] == "ENABLED" + assert our_envs[0]["status"] == "VALID" # Test filtering resp = batch_client.describe_compute_environments(computeEnvironments=["test1"]) - len(resp["computeEnvironments"]).should.equal(0) + assert len(resp["computeEnvironments"]) == 0 @mock_ec2 @@ -238,12 +237,12 @@ def test_delete_unmanaged_compute_environment(): all_envs = batch_client.describe_compute_environments()["computeEnvironments"] all_names = [e["computeEnvironmentName"] for e in all_envs] - all_names.shouldnt.contain(compute_name) + assert compute_name not in all_names cluster = ecs_client.describe_clusters(clusters=[our_env["ecsClusterArn"]])[ "clusters" ][0] - cluster.should.have.key("status").equals("INACTIVE") + assert cluster["status"] == "INACTIVE" @mock_ec2 @@ -285,20 +284,20 @@ def test_delete_managed_compute_environment(): all_envs = batch_client.describe_compute_environments()["computeEnvironments"] all_names = [e["computeEnvironmentName"] for e in all_envs] - all_names.shouldnt.contain(compute_name) + assert compute_name not in all_names if not settings.TEST_SERVER_MODE: # Too many instances to know which one is ours in ServerMode resp = ec2_client.describe_instances() - resp.should.contain("Reservations") - len(resp["Reservations"]).should.equal(3) + assert "Reservations" in resp + assert len(resp["Reservations"]) == 3 for reservation in resp["Reservations"]: - reservation["Instances"][0]["State"]["Name"].should.equal("terminated") + assert reservation["Instances"][0]["State"]["Name"] == "terminated" cluster = ecs_client.describe_clusters(clusters=[our_env["ecsClusterArn"]])[ "clusters" ][0] - cluster.should.have.key("status").equals("INACTIVE") + assert cluster["status"] == "INACTIVE" @mock_ec2 @@ -323,8 +322,8 @@ def test_update_unmanaged_compute_environment_state(): all_envs = batch_client.describe_compute_environments()["computeEnvironments"] our_envs = [e for e in all_envs if e["computeEnvironmentName"] == compute_name] - our_envs.should.have.length_of(1) - our_envs[0]["state"].should.equal("DISABLED") + assert len(our_envs) == 1 + assert our_envs[0]["state"] == "DISABLED" @mock_ec2 @@ -352,15 +351,15 @@ def test_update_iam_role(): all_envs = batch_client.describe_compute_environments()["computeEnvironments"] our_envs = [e for e in all_envs if e["computeEnvironmentName"] == compute_name] - our_envs.should.have.length_of(1) - our_envs[0]["serviceRole"].should.equal(iam_arn2) + assert len(our_envs) == 1 + assert our_envs[0]["serviceRole"] == iam_arn2 with pytest.raises(ClientError) as exc: batch_client.update_compute_environment( computeEnvironment=compute_name, serviceRole="unknown" ) err = exc.value.response["Error"] - err["Code"].should.equal("InvalidParameterValue") + assert err["Code"] == "InvalidParameterValue" @pytest.mark.parametrize("compute_env_type", ["FARGATE", "FARGATE_SPOT"]) @@ -385,14 +384,14 @@ def test_create_fargate_managed_compute_environment(compute_env_type): }, serviceRole=iam_arn, ) - resp.should.contain("computeEnvironmentArn") - resp["computeEnvironmentName"].should.equal(compute_name) + assert "computeEnvironmentArn" in resp + assert resp["computeEnvironmentName"] == compute_name our_env = batch_client.describe_compute_environments( computeEnvironments=[compute_name] )["computeEnvironments"][0] - our_env["computeResources"]["type"].should.equal(compute_env_type) + assert our_env["computeResources"]["type"] == compute_env_type # Should have created 1 ECS cluster all_clusters = ecs_client.list_clusters()["clusterArns"] - all_clusters.should.contain(our_env["ecsClusterArn"]) + assert our_env["ecsClusterArn"] in all_clusters diff --git a/tests/test_batch/test_batch_job_queue.py b/tests/test_batch/test_batch_job_queue.py index 890b61d0e..7f38ca409 100644 --- a/tests/test_batch/test_batch_job_queue.py +++ b/tests/test_batch/test_batch_job_queue.py @@ -1,8 +1,7 @@ from . import _get_clients, _setup - -from botocore.exceptions import ClientError +import boto3 import pytest -import sure # noqa # pylint: disable=unused-import +from botocore.exceptions import ClientError from moto import mock_batch, mock_iam, mock_ec2, mock_ecs from uuid import uuid4 @@ -32,26 +31,23 @@ def test_create_job_queue(): computeEnvironmentOrder=[{"order": 123, "computeEnvironment": arn}], schedulingPolicyArn="policy_arn", ) - resp.should.contain("jobQueueArn") - resp.should.contain("jobQueueName") + assert "jobQueueArn" in resp + assert "jobQueueName" in resp queue_arn = resp["jobQueueArn"] all_queues = batch_client.describe_job_queues()["jobQueues"] our_queues = [q for q in all_queues if q["jobQueueName"] == jq_name] - our_queues.should.have.length_of(1) - our_queues[0]["jobQueueArn"].should.equal(queue_arn) - our_queues[0]["schedulingPolicyArn"].should.equal("policy_arn") + assert len(our_queues) == 1 + assert our_queues[0]["jobQueueArn"] == queue_arn + assert our_queues[0]["schedulingPolicyArn"] == "policy_arn" -@mock_ec2 -@mock_ecs -@mock_iam @mock_batch def test_describe_job_queue_unknown_value(): - _, _, _, _, batch_client = _get_clients() + batch_client = boto3.client("batch", "us-east-1") resp = batch_client.describe_job_queues(jobQueues=["test_invalid_queue"]) - resp.should.have.key("jobQueues").being.length_of(0) + assert len(resp["jobQueues"]) == 0 @mock_ec2 @@ -89,8 +85,8 @@ def test_create_job_queue_twice(): ) err = ex.value.response["Error"] - err["Code"].should.equal("ClientException") - err["Message"].should.equal(f"Job queue {jq_name} already exists") + assert err["Code"] == "ClientException" + assert err["Message"] == f"Job queue {jq_name} already exists" @mock_ec2 @@ -108,8 +104,8 @@ def test_create_job_queue_incorrect_state(): computeEnvironmentOrder=[], ) err = ex.value.response["Error"] - err["Code"].should.equal("ClientException") - err["Message"].should.equal("state JUNK must be one of ENABLED | DISABLED") + assert err["Code"] == "ClientException" + assert err["Message"] == "state JUNK must be one of ENABLED | DISABLED" @mock_ec2 @@ -127,8 +123,8 @@ def test_create_job_queue_without_compute_environment(): computeEnvironmentOrder=[], ) err = ex.value.response["Error"] - err["Code"].should.equal("ClientException") - err["Message"].should.equal("At least 1 compute environment must be provided") + assert err["Code"] == "ClientException" + assert err["Message"] == "At least 1 compute environment must be provided" @mock_ec2 @@ -158,8 +154,8 @@ def test_job_queue_bad_arn(): ], ) err = ex.value.response["Error"] - err["Code"].should.equal("ClientException") - err["Message"].should.equal("computeEnvironmentOrder is malformed") + assert err["Code"] == "ClientException" + assert err["Message"] == "computeEnvironmentOrder is malformed" @mock_ec2 @@ -192,14 +188,14 @@ def test_update_job_queue(): all_queues = batch_client.describe_job_queues()["jobQueues"] our_queues = [q for q in all_queues if q["jobQueueName"] == jq_name] - our_queues[0]["priority"].should.equal(5) + assert our_queues[0]["priority"] == 5 batch_client.update_job_queue(jobQueue=jq_name, priority=15) all_queues = batch_client.describe_job_queues()["jobQueues"] our_queues = [q for q in all_queues if q["jobQueueName"] == jq_name] - our_queues.should.have.length_of(1) - our_queues[0]["priority"].should.equal(15) + assert len(our_queues) == 1 + assert our_queues[0]["priority"] == 15 @mock_ec2 @@ -231,4 +227,4 @@ def test_delete_job_queue(): batch_client.delete_job_queue(jobQueue=queue_arn) all_queues = batch_client.describe_job_queues()["jobQueues"] - [q["jobQueueName"] for q in all_queues].shouldnt.contain(jq_name) + assert jq_name not in [q["jobQueueName"] for q in all_queues] diff --git a/tests/test_batch/test_batch_jobs.py b/tests/test_batch/test_batch_jobs.py index 8248aeb99..01d2d51a1 100644 --- a/tests/test_batch/test_batch_jobs.py +++ b/tests/test_batch/test_batch_jobs.py @@ -1,7 +1,6 @@ from . import _get_clients, _setup import datetime -import sure # noqa # pylint: disable=unused-import from moto import mock_batch, mock_iam, mock_ec2, mock_ecs, mock_logs import botocore.exceptions import pytest @@ -74,17 +73,17 @@ def test_submit_job_by_name(): resp = batch_client.submit_job( jobName="test1", jobQueue=queue_arn, jobDefinition=job_definition_name ) - resp["ResponseMetadata"].should.have.key("RequestId") + assert "RequestId" in resp["ResponseMetadata"] job_id = resp["jobId"] resp_jobs = batch_client.describe_jobs(jobs=[job_id]) - resp_jobs["ResponseMetadata"].should.have.key("RequestId") + assert "RequestId" in resp_jobs["ResponseMetadata"] - len(resp_jobs["jobs"]).should.equal(1) - resp_jobs["jobs"][0]["jobId"].should.equal(job_id) - resp_jobs["jobs"][0]["jobQueue"].should.equal(queue_arn) - resp_jobs["jobs"][0]["jobDefinition"].should.equal(job_definition_arn) + assert len(resp_jobs["jobs"]) == 1 + assert resp_jobs["jobs"][0]["jobId"] == job_id + assert resp_jobs["jobs"][0]["jobQueue"] == queue_arn + assert resp_jobs["jobs"][0]["jobDefinition"] == job_definition_arn # SLOW TESTS @@ -115,20 +114,20 @@ def test_submit_job(): # github.com/getmoto/moto/issues/4364 resp = batch_client.describe_jobs(jobs=[job_id]) created_at = resp["jobs"][0]["createdAt"] - created_at.should.be.greater_than(start_time_milliseconds) + assert created_at > start_time_milliseconds _wait_for_job_status(batch_client, job_id, "SUCCEEDED") resp = logs_client.describe_log_streams( logGroupName="/aws/batch/job", logStreamNamePrefix=job_def_name ) - resp["logStreams"].should.have.length_of(1) + assert len(resp["logStreams"]) == 1 ls_name = resp["logStreams"][0]["logStreamName"] resp = logs_client.get_log_events( logGroupName="/aws/batch/job", logStreamName=ls_name ) - [event["message"] for event in resp["events"]].should.equal(["hello"]) + assert [event["message"] for event in resp["events"]] == ["hello"] # Test that describe_jobs() returns timestamps in milliseconds # github.com/getmoto/moto/issues/4364 @@ -137,22 +136,20 @@ def test_submit_job(): started_at = job["startedAt"] stopped_at = job["stoppedAt"] - created_at.should.be.greater_than(start_time_milliseconds) - started_at.should.be.greater_than(start_time_milliseconds) - stopped_at.should.be.greater_than(start_time_milliseconds) + assert created_at > start_time_milliseconds + assert started_at > start_time_milliseconds + assert stopped_at > start_time_milliseconds # Verify we track attempts - job.should.have.key("attempts").length_of(1) + assert len(job["attempts"]) == 1 attempt = job["attempts"][0] - attempt.should.have.key("container") - attempt["container"].should.have.key("containerInstanceArn") - attempt["container"].should.have.key("logStreamName").equals( - job["container"]["logStreamName"] - ) - attempt["container"].should.have.key("networkInterfaces") - attempt["container"].should.have.key("taskArn") - attempt.should.have.key("startedAt").equals(started_at) - attempt.should.have.key("stoppedAt").equals(stopped_at) + assert "container" in attempt + assert "containerInstanceArn" in attempt["container"] + assert attempt["container"]["logStreamName"] == job["container"]["logStreamName"] + assert "networkInterfaces" in attempt["container"] + assert "taskArn" in attempt["container"] + assert attempt["startedAt"] == started_at + assert attempt["stoppedAt"] == stopped_at @mock_logs @@ -182,20 +179,20 @@ def test_submit_job_multinode(): # github.com/getmoto/moto/issues/4364 resp = batch_client.describe_jobs(jobs=[job_id]) created_at = resp["jobs"][0]["createdAt"] - created_at.should.be.greater_than(start_time_milliseconds) + assert created_at > start_time_milliseconds _wait_for_job_status(batch_client, job_id, "SUCCEEDED") resp = logs_client.describe_log_streams( logGroupName="/aws/batch/job", logStreamNamePrefix=job_def_name ) - resp["logStreams"].should.have.length_of(1) + assert len(resp["logStreams"]) == 1 ls_name = resp["logStreams"][0]["logStreamName"] resp = logs_client.get_log_events( logGroupName="/aws/batch/job", logStreamName=ls_name ) - [event["message"] for event in resp["events"]].should.equal(["hello", "hello"]) + assert [event["message"] for event in resp["events"]] == ["hello", "hello"] # Test that describe_jobs() returns timestamps in milliseconds # github.com/getmoto/moto/issues/4364 @@ -204,22 +201,20 @@ def test_submit_job_multinode(): started_at = job["startedAt"] stopped_at = job["stoppedAt"] - created_at.should.be.greater_than(start_time_milliseconds) - started_at.should.be.greater_than(start_time_milliseconds) - stopped_at.should.be.greater_than(start_time_milliseconds) + assert created_at > start_time_milliseconds + assert started_at > start_time_milliseconds + assert stopped_at > start_time_milliseconds # Verify we track attempts - job.should.have.key("attempts").length_of(1) + assert len(job["attempts"]) == 1 attempt = job["attempts"][0] - attempt.should.have.key("container") - attempt["container"].should.have.key("containerInstanceArn") - attempt["container"].should.have.key("logStreamName").equals( - job["container"]["logStreamName"] - ) - attempt["container"].should.have.key("networkInterfaces") - attempt["container"].should.have.key("taskArn") - attempt.should.have.key("startedAt").equals(started_at) - attempt.should.have.key("stoppedAt").equals(stopped_at) + assert "container" in attempt + assert "containerInstanceArn" in attempt["container"] + assert attempt["container"]["logStreamName"] == job["container"]["logStreamName"] + assert "networkInterfaces" in attempt["container"] + assert "taskArn" in attempt["container"] + assert attempt["startedAt"] == started_at + assert attempt["stoppedAt"] == stopped_at @mock_logs @@ -247,19 +242,22 @@ def test_list_jobs(): job_id2 = resp["jobId"] all_jobs = batch_client.list_jobs(jobQueue=queue_arn)["jobSummaryList"] - all_jobs.should.have.length_of(2) + assert len(all_jobs) == 2 for job in all_jobs: - job.should.have.key("createdAt") - job.should.have.key("jobDefinition") - job.should.have.key("jobName") + assert "createdAt" in job + assert "jobDefinition" in job + assert "jobName" in job # This is async, so we can't be sure where we are in the process - job.should.have.key("status").within( - ["SUBMITTED", "PENDING", "STARTING", "RUNNABLE", "RUNNING"] - ) + assert job["status"] in [ + "SUBMITTED", + "PENDING", + "STARTING", + "RUNNABLE", + "RUNNING", + ] - batch_client.list_jobs(jobQueue=queue_arn, jobStatus="SUCCEEDED")[ - "jobSummaryList" - ].should.have.length_of(0) + resp = batch_client.list_jobs(jobQueue=queue_arn, jobStatus="SUCCEEDED") + assert len(resp["jobSummaryList"]) == 0 # Wait only as long as it takes to run the jobs for job_id in [job_id1, job_id2]: @@ -268,14 +266,14 @@ def test_list_jobs(): succeeded_jobs = batch_client.list_jobs(jobQueue=queue_arn, jobStatus="SUCCEEDED")[ "jobSummaryList" ] - succeeded_jobs.should.have.length_of(2) + assert len(succeeded_jobs) == 2 for job in succeeded_jobs: - job.should.have.key("createdAt") - job.should.have.key("jobDefinition") - job.should.have.key("jobName") - job.should.have.key("status").equals("SUCCEEDED") - job.should.have.key("stoppedAt") - job.should.have.key("container").should.have.key("exitCode").equals(0) + assert "createdAt" in job + assert "jobDefinition" in job + assert "jobName" in job + assert job["status"] == "SUCCEEDED" + assert "stoppedAt" in job + assert job["container"]["exitCode"] == 0 filtered_jobs = batch_client.list_jobs( jobQueue=queue_arn, @@ -286,8 +284,8 @@ def test_list_jobs(): } ], )["jobSummaryList"] - filtered_jobs.should.have.length_of(1) - filtered_jobs[0]["jobName"].should.equal("test2") + assert len(filtered_jobs) == 1 + assert filtered_jobs[0]["jobName"] == "test2" @mock_logs @@ -316,10 +314,10 @@ def test_terminate_job(): _wait_for_job_status(batch_client, job_id, "FAILED", seconds_to_wait=120) resp = batch_client.describe_jobs(jobs=[job_id]) - resp["jobs"][0]["jobName"].should.equal("test1") - resp["jobs"][0]["status"].should.equal("FAILED") - resp["jobs"][0]["statusReason"].should.equal("test_terminate") - resp["jobs"][0]["container"].should.have.key("logStreamName") + assert resp["jobs"][0]["jobName"] == "test1" + assert resp["jobs"][0]["status"] == "FAILED" + assert resp["jobs"][0]["statusReason"] == "test_terminate" + assert "logStreamName" in resp["jobs"][0]["container"] ls_name = f"{job_def_name}/default/{job_id}" @@ -328,8 +326,8 @@ def test_terminate_job(): ) # Events should only contain 'start' because we interrupted # the job before 'stop' was written to the logs. - resp["events"].should.have.length_of(1) - resp["events"][0]["message"].should.equal("start") + assert len(resp["events"]) == 1 + assert resp["events"][0]["message"] == "start" @mock_batch @@ -341,7 +339,7 @@ def test_terminate_nonexisting_job(): resp = batch_client.terminate_job( jobId="nonexisting_job", reason="test_terminate_nonexisting_job" ) - resp["ResponseMetadata"]["HTTPStatusCode"].should.equal(200) + assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200 @mock_batch @@ -392,9 +390,9 @@ def test_cancel_pending_job(): _wait_for_job_status(batch_client, job_id, "FAILED", seconds_to_wait=30) resp = batch_client.describe_jobs(jobs=[job_id]) - resp["jobs"][0]["jobName"].should.equal("test_job_name") - resp["jobs"][0]["statusReason"].should.equal("test_cancel") - resp["jobs"][0]["container"].shouldnt.have.key("logStreamName") + assert resp["jobs"][0]["jobName"] == "test_job_name" + assert resp["jobs"][0]["statusReason"] == "test_cancel" + assert "logStreamName" not in resp["jobs"][0]["container"] @mock_logs @@ -427,9 +425,9 @@ def test_cancel_running_job(): _wait_for_job_status(batch_client, job_id, "SUCCEEDED", seconds_to_wait=30) resp = batch_client.describe_jobs(jobs=[job_id]) - resp["jobs"][0]["jobName"].should.equal("test_job_name") - resp["jobs"][0].shouldnt.have.key("statusReason") - resp["jobs"][0]["container"].should.have.key("logStreamName") + assert resp["jobs"][0]["jobName"] == "test_job_name" + assert "statusReason" not in resp["jobs"][0] + assert "logStreamName" in resp["jobs"][0]["container"] @mock_batch @@ -441,7 +439,7 @@ def test_cancel_nonexisting_job(): resp = batch_client.cancel_job( jobId="nonexisting_job", reason="test_cancel_nonexisting_job" ) - resp["ResponseMetadata"]["HTTPStatusCode"].should.equal(200) + assert resp["ResponseMetadata"]["HTTPStatusCode"] == 200 @mock_batch @@ -503,7 +501,7 @@ def test_failed_job(): resp = batch_client.describe_jobs(jobs=[job_id]) if resp["jobs"][0]["status"] == "FAILED": - resp["jobs"][0]["container"].should.have.key("logStreamName") + assert "logStreamName" in resp["jobs"][0]["container"] break if resp["jobs"][0]["status"] == "SUCCEEDED": raise RuntimeError("Batch job succeeded even though it had exit code 1") @@ -580,10 +578,10 @@ def test_dependencies(): resp = logs_client.get_log_events( logGroupName=log_stream_name, logStreamName=ls_name ) - [event["message"] for event in resp["events"]].should.equal(["hello"]) + assert [event["message"] for event in resp["events"]] == ["hello"] nr_logstreams_found = nr_logstreams_found + 1 - nr_logstreams_found.should.equal(3) + assert nr_logstreams_found == 3 def retrieve_all_streams(log_stream_name, logs_client): @@ -685,11 +683,11 @@ def test_failed_dependencies(): assert resp["jobs"][1]["status"] != "SUCCEEDED", "Job 3 cannot succeed" if resp["jobs"][1]["status"] == "FAILED": - assert resp["jobs"][0]["container"].should.have.key( - "logStreamName" + assert ( + "logStreamName" in resp["jobs"][0]["container"] ), "Job 2 should have logStreamName because it FAILED but was in RUNNING state" - assert resp["jobs"][1]["container"].shouldnt.have.key( - "logStreamName" + assert ( + "logStreamName" not in resp["jobs"][1]["container"] ), "Job 3 shouldn't have logStreamName because it was never in RUNNING state" break @@ -803,32 +801,25 @@ def test_container_overrides(): key, value = tuple(event["message"].split("=")) env_var.append({"name": key, "value": value}) - len(resp_jobs["jobs"]).should.equal(1) - resp_jobs["jobs"][0]["jobId"].should.equal(job_id) - resp_jobs["jobs"][0]["jobQueue"].should.equal(queue_arn) - resp_jobs["jobs"][0]["jobDefinition"].should.equal(job_definition_arn) - resp_jobs["jobs"][0]["container"]["vcpus"].should.equal(2) - resp_jobs["jobs"][0]["container"]["memory"].should.equal(1024) - resp_jobs["jobs"][0]["container"]["command"].should.equal(["printenv"]) + assert len(resp_jobs["jobs"]) == 1 + assert resp_jobs["jobs"][0]["jobId"] == job_id + assert resp_jobs["jobs"][0]["jobQueue"] == queue_arn + assert resp_jobs["jobs"][0]["jobDefinition"] == job_definition_arn + assert resp_jobs["jobs"][0]["container"]["vcpus"] == 2 + assert resp_jobs["jobs"][0]["container"]["memory"] == 1024 + assert resp_jobs["jobs"][0]["container"]["command"] == ["printenv"] - sure.expect(resp_jobs["jobs"][0]["container"]["environment"]).to.contain( - {"name": "TEST0", "value": "from job"} - ) - sure.expect(resp_jobs["jobs"][0]["container"]["environment"]).to.contain( - {"name": "TEST1", "value": "from job definition"} - ) - sure.expect(resp_jobs["jobs"][0]["container"]["environment"]).to.contain( - {"name": "TEST2", "value": "from job"} - ) - sure.expect(resp_jobs["jobs"][0]["container"]["environment"]).to.contain( - {"name": "AWS_BATCH_JOB_ID", "value": job_id} - ) + env = resp_jobs["jobs"][0]["container"]["environment"] + assert {"name": "TEST0", "value": "from job"} in env + assert {"name": "TEST1", "value": "from job definition"} in env + assert {"name": "TEST2", "value": "from job"} in env + assert {"name": "AWS_BATCH_JOB_ID", "value": job_id} in env - sure.expect(env_var).to.contain({"name": "TEST0", "value": "from job"}) - sure.expect(env_var).to.contain({"name": "TEST1", "value": "from job definition"}) - sure.expect(env_var).to.contain({"name": "TEST2", "value": "from job"}) + assert {"name": "TEST0", "value": "from job"} in env_var + assert {"name": "TEST1", "value": "from job definition"} in env_var + assert {"name": "TEST2", "value": "from job"} in env_var - sure.expect(env_var).to.contain({"name": "AWS_BATCH_JOB_ID", "value": job_id}) + assert {"name": "AWS_BATCH_JOB_ID", "value": job_id} in env_var def prepare_job(batch_client, commands, iam_arn, job_def_name): @@ -943,14 +934,14 @@ def test_update_job_definition(): job_defs = batch_client.describe_job_definitions(jobDefinitionName=job_def_name)[ "jobDefinitions" ] - job_defs.should.have.length_of(2) + assert len(job_defs) == 2 - job_defs[0]["containerProperties"]["memory"].should.equal(1024) - job_defs[0]["tags"].should.equal(tags[0]) - job_defs[0].shouldnt.have.key("timeout") + assert job_defs[0]["containerProperties"]["memory"] == 1024 + assert job_defs[0]["tags"] == tags[0] + assert "timeout" not in job_defs[0] - job_defs[1]["containerProperties"]["memory"].should.equal(2048) - job_defs[1]["tags"].should.equal(tags[1]) + assert job_defs[1]["containerProperties"]["memory"] == 2048 + assert job_defs[1]["tags"] == tags[1] @mock_batch @@ -974,7 +965,7 @@ def test_register_job_definition_with_timeout(): resp = batch_client.describe_job_definitions(jobDefinitionName=job_def_name) job_def = resp["jobDefinitions"][0] - job_def.should.have.key("timeout").equals({"attemptDurationSeconds": 3}) + assert job_def["timeout"] == {"attemptDurationSeconds": 3} @mock_batch diff --git a/tests/test_batch/test_batch_scheduling_policy.py b/tests/test_batch/test_batch_scheduling_policy.py index 406d37e9e..c20866131 100644 --- a/tests/test_batch/test_batch_scheduling_policy.py +++ b/tests/test_batch/test_batch_scheduling_policy.py @@ -8,9 +8,10 @@ from tests import DEFAULT_ACCOUNT_ID def test_create_scheduling_policy(): client = boto3.client("batch", "us-east-2") resp = client.create_scheduling_policy(name="test") - resp.should.have.key("name").equals("test") - resp.should.have.key("arn").equals( - f"arn:aws:batch:us-east-2:{DEFAULT_ACCOUNT_ID}:scheduling-policy/test" + assert resp["name"] == "test" + assert ( + resp["arn"] + == f"arn:aws:batch:us-east-2:{DEFAULT_ACCOUNT_ID}:scheduling-policy/test" ) @@ -20,14 +21,16 @@ def test_describe_default_scheduling_policy(): arn = client.create_scheduling_policy(name="test")["arn"] resp = client.describe_scheduling_policies(arns=[arn]) - resp.should.have.key("schedulingPolicies").length_of(1) + assert len(resp["schedulingPolicies"]) == 1 policy = resp["schedulingPolicies"][0] - policy["arn"].should.equal(arn) - policy["fairsharePolicy"].should.equal( - {"computeReservation": 0, "shareDecaySeconds": 0, "shareDistribution": []} - ) - policy["tags"].should.equal({}) + assert policy["arn"] == arn + assert policy["fairsharePolicy"] == { + "computeReservation": 0, + "shareDecaySeconds": 0, + "shareDistribution": [], + } + assert policy["tags"] == {} @mock_batch @@ -43,23 +46,21 @@ def test_describe_scheduling_policy(): )["arn"] resp = client.list_scheduling_policies() - resp.should.have.key("schedulingPolicies") + assert "schedulingPolicies" in resp arns = [a["arn"] for a in resp["schedulingPolicies"]] - arns.should.contain(arn) + assert arn in arns resp = client.describe_scheduling_policies(arns=[arn]) - resp.should.have.key("schedulingPolicies").length_of(1) + assert len(resp["schedulingPolicies"]) == 1 policy = resp["schedulingPolicies"][0] - policy["arn"].should.equal(arn) - policy["fairsharePolicy"].should.equal( - { - "computeReservation": 2, - "shareDecaySeconds": 1, - "shareDistribution": [{"shareIdentifier": "A", "weightFactor": 0.1}], - } - ) - policy["tags"].should.equal({}) + assert policy["arn"] == arn + assert policy["fairsharePolicy"] == { + "computeReservation": 2, + "shareDecaySeconds": 1, + "shareDistribution": [{"shareIdentifier": "A", "weightFactor": 0.1}], + } + assert policy["tags"] == {} @mock_batch @@ -70,7 +71,7 @@ def test_delete_scheduling_policy(): client.delete_scheduling_policy(arn=arn) resp = client.describe_scheduling_policies(arns=[arn]) - resp.should.have.key("schedulingPolicies").length_of(0) + assert len(resp["schedulingPolicies"]) == 0 @mock_batch @@ -88,10 +89,12 @@ def test_update_scheduling_policy(): ) resp = client.describe_scheduling_policies(arns=[arn]) - resp.should.have.key("schedulingPolicies").length_of(1) + assert len(resp["schedulingPolicies"]) == 1 policy = resp["schedulingPolicies"][0] - policy["arn"].should.equal(arn) - policy["fairsharePolicy"].should.equal( - {"computeReservation": 5, "shareDecaySeconds": 10, "shareDistribution": []} - ) + assert policy["arn"] == arn + assert policy["fairsharePolicy"] == { + "computeReservation": 5, + "shareDecaySeconds": 10, + "shareDistribution": [], + } diff --git a/tests/test_batch/test_batch_tags_job_definition.py b/tests/test_batch/test_batch_tags_job_definition.py index b82d58c67..3fccfca2c 100644 --- a/tests/test_batch/test_batch_tags_job_definition.py +++ b/tests/test_batch/test_batch_tags_job_definition.py @@ -1,6 +1,5 @@ from . import _get_clients -import sure # noqa # pylint: disable=unused-import from moto import mock_batch from uuid import uuid4 @@ -26,7 +25,7 @@ def test_list_tags_with_job_definition(): )["jobDefinitionArn"] my_queue = batch_client.list_tags_for_resource(resourceArn=job_def_arn) - my_queue.should.have.key("tags").equals({"foo": "123", "bar": "456"}) + assert my_queue["tags"] == {"foo": "123", "bar": "456"} @mock_batch @@ -44,7 +43,7 @@ def test_tag_job_definition(): batch_client.tag_resource(resourceArn=job_def_arn, tags={"k1": "v1", "k2": "v2"}) my_queue = batch_client.list_tags_for_resource(resourceArn=job_def_arn) - my_queue.should.have.key("tags").equals({"k1": "v1", "k2": "v2"}) + assert my_queue["tags"] == {"k1": "v1", "k2": "v2"} @mock_batch @@ -64,4 +63,4 @@ def test_untag_job_queue(): batch_client.untag_resource(resourceArn=job_def_arn, tagKeys=["k2"]) my_queue = batch_client.list_tags_for_resource(resourceArn=job_def_arn) - my_queue.should.have.key("tags").equals({"k1": "v1", "k3": "v3"}) + assert my_queue["tags"] == {"k1": "v1", "k3": "v3"} diff --git a/tests/test_batch/test_batch_tags_job_queue.py b/tests/test_batch/test_batch_tags_job_queue.py index d720ec6fd..335c26fee 100644 --- a/tests/test_batch/test_batch_tags_job_queue.py +++ b/tests/test_batch/test_batch_tags_job_queue.py @@ -1,6 +1,5 @@ from . import _get_clients, _setup -import sure # noqa # pylint: disable=unused-import from moto import mock_batch, mock_iam, mock_ec2, mock_ecs from uuid import uuid4 @@ -30,12 +29,12 @@ def test_create_job_queue_with_tags(): computeEnvironmentOrder=[{"order": 123, "computeEnvironment": arn}], tags={"k1": "v1", "k2": "v2"}, ) - resp.should.contain("jobQueueArn") - resp.should.contain("jobQueueName") + assert "jobQueueArn" in resp + assert "jobQueueName" in resp queue_arn = resp["jobQueueArn"] my_queue = batch_client.describe_job_queues(jobQueues=[queue_arn])["jobQueues"][0] - my_queue.should.have.key("tags").equals({"k1": "v1", "k2": "v2"}) + assert my_queue["tags"] == {"k1": "v1", "k2": "v2"} @mock_ec2 @@ -63,12 +62,12 @@ def test_list_tags(): computeEnvironmentOrder=[{"order": 123, "computeEnvironment": arn}], tags={"k1": "v1", "k2": "v2"}, ) - resp.should.contain("jobQueueArn") - resp.should.contain("jobQueueName") + assert "jobQueueArn" in resp + assert "jobQueueName" in resp queue_arn = resp["jobQueueArn"] my_queue = batch_client.list_tags_for_resource(resourceArn=queue_arn) - my_queue.should.have.key("tags").equals({"k1": "v1", "k2": "v2"}) + assert my_queue["tags"] == {"k1": "v1", "k2": "v2"} @mock_ec2 @@ -100,7 +99,7 @@ def test_tag_job_queue(): batch_client.tag_resource(resourceArn=queue_arn, tags={"k1": "v1", "k2": "v2"}) my_queue = batch_client.list_tags_for_resource(resourceArn=queue_arn) - my_queue.should.have.key("tags").equals({"k1": "v1", "k2": "v2"}) + assert my_queue["tags"] == {"k1": "v1", "k2": "v2"} @mock_ec2 @@ -134,4 +133,4 @@ def test_untag_job_queue(): batch_client.untag_resource(resourceArn=queue_arn, tagKeys=["k2"]) my_queue = batch_client.list_tags_for_resource(resourceArn=queue_arn) - my_queue.should.have.key("tags").equals({"k1": "v1", "k3": "v3"}) + assert my_queue["tags"] == {"k1": "v1", "k3": "v3"} diff --git a/tests/test_batch/test_batch_tags_scheduling_policy.py b/tests/test_batch/test_batch_tags_scheduling_policy.py index ea83c994e..b1b540598 100644 --- a/tests/test_batch/test_batch_tags_scheduling_policy.py +++ b/tests/test_batch/test_batch_tags_scheduling_policy.py @@ -11,4 +11,4 @@ def test_create_with_tags(): resp = client.describe_scheduling_policies(arns=[arn]) policy = resp["schedulingPolicies"][0] - policy["tags"].should.equal({"key": "val"}) + assert policy["tags"] == {"key": "val"} diff --git a/tests/test_batch/test_batch_task_definition.py b/tests/test_batch/test_batch_task_definition.py index a3235f750..633ed4cda 100644 --- a/tests/test_batch/test_batch_task_definition.py +++ b/tests/test_batch/test_batch_task_definition.py @@ -1,7 +1,6 @@ from . import _get_clients import random import pytest -import sure # noqa # pylint: disable=unused-import from moto import mock_batch from uuid import uuid4 @@ -13,13 +12,11 @@ def test_register_task_definition(use_resource_reqs): resp = register_job_def(batch_client, use_resource_reqs=use_resource_reqs) - resp.should.contain("jobDefinitionArn") - resp.should.contain("jobDefinitionName") - resp.should.contain("revision") + assert "jobDefinitionArn" in resp + assert "jobDefinitionName" in resp + assert "revision" in resp - assert resp["jobDefinitionArn"].endswith( - f"{resp['jobDefinitionName']}:{resp['revision']}" - ) + assert f"{resp['jobDefinitionName']}:{resp['revision']}" in resp["jobDefinitionArn"] @mock_batch @@ -33,9 +30,9 @@ def test_register_task_definition_with_tags(propagate_tags): resp = batch_client.describe_job_definitions(jobDefinitionName=job_def_name) job_def = resp["jobDefinitions"][0] if propagate_tags is None: - job_def.shouldnt.have.key("propagateTags") + assert "propagateTags" not in job_def else: - job_def.should.have.key("propagateTags").equals(propagate_tags) + assert job_def["propagateTags"] == propagate_tags @mock_batch @@ -57,9 +54,7 @@ def test_register_task_definition_with_platform_capability(platform_capability): ) resp = batch_client.describe_job_definitions(jobDefinitionName=def_name) - resp["jobDefinitions"][0].should.have.key("platformCapabilities").equals( - [platform_capability] - ) + assert resp["jobDefinitions"][0]["platformCapabilities"] == [platform_capability] @mock_batch @@ -86,15 +81,13 @@ def test_register_task_definition_with_retry_strategies(): ) resp = batch_client.describe_job_definitions(jobDefinitionName=def_name) - resp["jobDefinitions"][0].should.have.key("retryStrategy").equals( - { - "attempts": 4, - "evaluateOnExit": [ - {"onStatusReason": "osr", "action": "retry"}, - {"onStatusReason": "osr2", "action": "exit"}, - ], - } - ) + assert resp["jobDefinitions"][0]["retryStrategy"] == { + "attempts": 4, + "evaluateOnExit": [ + {"onStatusReason": "osr", "action": "retry"}, + {"onStatusReason": "osr2", "action": "exit"}, + ], + } @mock_batch @@ -108,38 +101,38 @@ def test_reregister_task_definition(use_resource_reqs): batch_client, definition_name=job_def_name, use_resource_reqs=use_resource_reqs ) - resp1.should.contain("jobDefinitionArn") - resp1.should.have.key("jobDefinitionName").equals(job_def_name) - resp1.should.contain("revision") + assert "jobDefinitionArn" in resp1 + assert resp1["jobDefinitionName"] == job_def_name + assert "revision" in resp1 assert resp1["jobDefinitionArn"].endswith( f"{resp1['jobDefinitionName']}:{resp1['revision']}" ) - resp1["revision"].should.equal(1) + assert resp1["revision"] == 1 resp2 = register_job_def( batch_client, definition_name=job_def_name, use_resource_reqs=use_resource_reqs ) - resp2["revision"].should.equal(2) + assert resp2["revision"] == 2 - resp2["jobDefinitionArn"].should_not.equal(resp1["jobDefinitionArn"]) + assert resp2["jobDefinitionArn"] != resp1["jobDefinitionArn"] resp3 = register_job_def( batch_client, definition_name=job_def_name, use_resource_reqs=use_resource_reqs ) - resp3["revision"].should.equal(3) + assert resp3["revision"] == 3 - resp3["jobDefinitionArn"].should_not.equal(resp1["jobDefinitionArn"]) - resp3["jobDefinitionArn"].should_not.equal(resp2["jobDefinitionArn"]) + assert resp3["jobDefinitionArn"] != resp1["jobDefinitionArn"] + assert resp3["jobDefinitionArn"] != resp2["jobDefinitionArn"] resp4 = register_job_def( batch_client, definition_name=job_def_name, use_resource_reqs=use_resource_reqs ) - resp4["revision"].should.equal(4) + assert resp4["revision"] == 4 - resp4["jobDefinitionArn"].should_not.equal(resp1["jobDefinitionArn"]) - resp4["jobDefinitionArn"].should_not.equal(resp2["jobDefinitionArn"]) - resp4["jobDefinitionArn"].should_not.equal(resp3["jobDefinitionArn"]) + assert resp4["jobDefinitionArn"] != resp1["jobDefinitionArn"] + assert resp4["jobDefinitionArn"] != resp2["jobDefinitionArn"] + assert resp4["jobDefinitionArn"] != resp3["jobDefinitionArn"] @mock_batch @@ -165,9 +158,9 @@ def test_reregister_task_definition_should_not_reuse_parameters_from_inactive_de definitions = batch_client.describe_job_definitions(jobDefinitionName=job_def_name)[ "jobDefinitions" ] - definitions.should.have.length_of(1) + assert len(definitions) == 1 - definitions[0].should.have.key("parameters").equals({"param1": "val1"}) + assert definitions[0]["parameters"] == {"param1": "val1"} # Deactivate the definition batch_client.deregister_job_definition(jobDefinition=job_def_arn) @@ -187,12 +180,12 @@ def test_reregister_task_definition_should_not_reuse_parameters_from_inactive_de definitions = batch_client.describe_job_definitions(jobDefinitionName=job_def_name)[ "jobDefinitions" ] - definitions.should.have.length_of(2) + assert len(definitions) == 2 # Only the inactive definition should have the parameters actual = [(d["revision"], d["status"], d.get("parameters")) for d in definitions] - actual.should.contain((1, "INACTIVE", {"param1": "val1"})) - actual.should.contain((2, "ACTIVE", {})) + assert (1, "INACTIVE", {"param1": "val1"}) in actual + assert (2, "ACTIVE", {}) in actual @mock_batch @@ -208,15 +201,15 @@ def test_delete_task_definition(use_resource_reqs): batch_client.deregister_job_definition(jobDefinition=resp["jobDefinitionArn"]) all_defs = batch_client.describe_job_definitions()["jobDefinitions"] - [jobdef["jobDefinitionName"] for jobdef in all_defs].should.contain(name) + assert name in [jobdef["jobDefinitionName"] for jobdef in all_defs] definitions = batch_client.describe_job_definitions(jobDefinitionName=name)[ "jobDefinitions" ] - definitions.should.have.length_of(1) + assert len(definitions) == 1 - definitions[0].should.have.key("revision").equals(1) - definitions[0].should.have.key("status").equals("INACTIVE") + assert definitions[0]["revision"] == 1 + assert definitions[0]["status"] == "INACTIVE" @mock_batch @@ -233,7 +226,7 @@ def test_delete_task_definition_by_name(use_resource_reqs): all_defs = batch_client.describe_job_definitions()["jobDefinitions"] # We should still see our job definition as INACTIVE, as it is kept for 180 days - [jobdef["jobDefinitionName"] for jobdef in all_defs].should.contain(name) + assert name in [jobdef["jobDefinitionName"] for jobdef in all_defs] # Registering the job definition again should up the revision number register_job_def( @@ -243,14 +236,14 @@ def test_delete_task_definition_by_name(use_resource_reqs): definitions = batch_client.describe_job_definitions(jobDefinitionName=name)[ "jobDefinitions" ] - definitions.should.have.length_of(2) + assert len(definitions) == 2 revision_status = [ {"revision": d["revision"], "status": d["status"]} for d in definitions ] - revision_status.should.contain({"revision": 1, "status": "INACTIVE"}) - revision_status.should.contain({"revision": 2, "status": "ACTIVE"}) + assert {"revision": 1, "status": "INACTIVE"} in revision_status + assert {"revision": 2, "status": "ACTIVE"} in revision_status @mock_batch @@ -277,27 +270,27 @@ def test_describe_task_definition(use_resource_reqs): register_job_def_with_tags(batch_client, definition_name=tagged_name) resp = batch_client.describe_job_definitions(jobDefinitionName=sleep_def_name) - len(resp["jobDefinitions"]).should.equal(2) + assert len(resp["jobDefinitions"]) == 2 job_defs = batch_client.describe_job_definitions()["jobDefinitions"] all_names = [jd["jobDefinitionName"] for jd in job_defs] - all_names.should.contain(sleep_def_name) - all_names.should.contain(other_name) - all_names.should.contain(tagged_name) + assert sleep_def_name in all_names + assert other_name in all_names + assert tagged_name in all_names resp = batch_client.describe_job_definitions( jobDefinitions=[sleep_def_name, other_name] ) - len(resp["jobDefinitions"]).should.equal(3) - resp["jobDefinitions"][0]["tags"].should.equal({}) + assert len(resp["jobDefinitions"]) == 3 + assert resp["jobDefinitions"][0]["tags"] == {} resp = batch_client.describe_job_definitions(jobDefinitionName=tagged_name) - resp["jobDefinitions"][0]["tags"].should.equal({"foo": "123", "bar": "456"}) + assert resp["jobDefinitions"][0]["tags"] == {"foo": "123", "bar": "456"} for job_definition in resp["jobDefinitions"]: - job_definition["status"].should.equal("ACTIVE") - job_definition.shouldnt.have.key("platformCapabilities") - job_definition.shouldnt.have.key("retryStrategy") + assert job_definition["status"] == "ACTIVE" + assert "platformCapabilities" not in job_definition + assert "retryStrategy" not in job_definition def register_job_def(batch_client, definition_name="sleep10", use_resource_reqs=True): diff --git a/tests/test_batch/test_server.py b/tests/test_batch/test_server.py index 09970ac13..969cf5115 100644 --- a/tests/test_batch/test_server.py +++ b/tests/test_batch/test_server.py @@ -1,5 +1,3 @@ -import sure # noqa # pylint: disable=unused-import - import moto.server as server from moto import mock_batch @@ -14,4 +12,4 @@ def test_batch_list(): test_client = backend.test_client() res = test_client.get("/v1/describecomputeenvironments") - res.status_code.should.equal(200) + assert res.status_code == 200 diff --git a/tests/test_batch_simple/test_batch_cloudformation.py b/tests/test_batch_simple/test_batch_cloudformation.py index 9e11e0922..40878a357 100644 --- a/tests/test_batch_simple/test_batch_cloudformation.py +++ b/tests/test_batch_simple/test_batch_cloudformation.py @@ -1,6 +1,5 @@ import boto3 import json -import sure # noqa # pylint: disable=unused-import from moto import mock_iam, mock_ec2, mock_ecs, mock_cloudformation from moto import mock_batch_simple as mock_batch_without_docker from uuid import uuid4 @@ -92,17 +91,12 @@ def test_create_env_cf(): ] stack_resources = cf_conn.list_stack_resources(StackName=stack_id) + summary = stack_resources["StackResourceSummaries"][0] - stack_resources["StackResourceSummaries"][0]["ResourceStatus"].should.equal( - "CREATE_COMPLETE" - ) + assert summary["ResourceStatus"] == "CREATE_COMPLETE" # Spot checks on the ARN - stack_resources["StackResourceSummaries"][0]["PhysicalResourceId"].startswith( - "arn:aws:batch:" - ) - stack_resources["StackResourceSummaries"][0]["PhysicalResourceId"].should.contain( - stack_name - ) + assert "arn:aws:batch:" in summary["PhysicalResourceId"] + assert stack_name in summary["PhysicalResourceId"] @mock_cloudformation() @@ -156,7 +150,7 @@ def test_create_job_queue_cf(): ] stack_resources = cf_conn.list_stack_resources(StackName=stack_id) - len(stack_resources["StackResourceSummaries"]).should.equal(2) + assert len(stack_resources["StackResourceSummaries"]) == 2 job_queue_resource = list( filter( @@ -165,11 +159,11 @@ def test_create_job_queue_cf(): ) )[0] - job_queue_resource["ResourceStatus"].should.equal("CREATE_COMPLETE") + assert job_queue_resource["ResourceStatus"] == "CREATE_COMPLETE" # Spot checks on the ARN - job_queue_resource["PhysicalResourceId"].startswith("arn:aws:batch:") - job_queue_resource["PhysicalResourceId"].should.contain(stack_name) - job_queue_resource["PhysicalResourceId"].should.contain("job-queue/") + assert job_queue_resource["PhysicalResourceId"].startswith("arn:aws:batch:") + assert stack_name in job_queue_resource["PhysicalResourceId"] + assert "job-queue/" in job_queue_resource["PhysicalResourceId"] @mock_cloudformation @@ -248,7 +242,7 @@ def test_create_job_def_cf(): ] stack_resources = cf_conn.list_stack_resources(StackName=stack_id) - len(stack_resources["StackResourceSummaries"]).should.equal(3) + assert len(stack_resources["StackResourceSummaries"]) == 3 job_def_resource = list( filter( @@ -257,11 +251,11 @@ def test_create_job_def_cf(): ) )[0] - job_def_resource["ResourceStatus"].should.equal("CREATE_COMPLETE") + assert job_def_resource["ResourceStatus"] == "CREATE_COMPLETE" # Spot checks on the ARN - job_def_resource["PhysicalResourceId"].startswith("arn:aws:batch:") - job_def_resource["PhysicalResourceId"].should.contain(f"{stack_name}-JobDef") - job_def_resource["PhysicalResourceId"].should.contain("job-definition/") + assert job_def_resource["PhysicalResourceId"].startswith("arn:aws:batch:") + assert f"{stack_name}-JobDef" in job_def_resource["PhysicalResourceId"] + assert "job-definition/" in job_def_resource["PhysicalResourceId"] # Test the linux parameter device host path # This ensures that batch is parsing the parameter dictionaries @@ -275,4 +269,4 @@ def test_create_job_def_cf(): "containerProperties" ]["linuxParameters"]["devices"][0]["hostPath"] - job_def_linux_device_host_path.should.equal("test-path") + assert job_def_linux_device_host_path == "test-path" diff --git a/tests/test_batch_simple/test_batch_compute_envs.py b/tests/test_batch_simple/test_batch_compute_envs.py index 8fa19fe68..a9439062b 100644 --- a/tests/test_batch_simple/test_batch_compute_envs.py +++ b/tests/test_batch_simple/test_batch_compute_envs.py @@ -1,10 +1,9 @@ from ..test_batch import _get_clients, _setup -import sure # noqa # pylint: disable=unused-import from moto import mock_batch_simple, mock_iam, mock_ec2, mock_ecs, settings from uuid import uuid4 -# Copy of test_batch/test_batch_cloudformation +# Copy of test_batch/test_batch_compute_envs # Except that we verify this behaviour still works without docker @@ -38,8 +37,8 @@ def test_create_managed_compute_environment(): }, serviceRole=iam_arn, ) - resp.should.contain("computeEnvironmentArn") - resp["computeEnvironmentName"].should.equal(compute_name) + assert "computeEnvironmentArn" in resp + assert resp["computeEnvironmentName"] == compute_name our_env = batch_client.describe_compute_environments( computeEnvironments=[compute_name] @@ -49,12 +48,12 @@ def test_create_managed_compute_environment(): if not settings.TEST_SERVER_MODE: # Can't verify this in ServerMode, as other tests may have created instances resp = ec2_client.describe_instances() - resp.should.contain("Reservations") - len(resp["Reservations"]).should.equal(3) + assert "Reservations" in resp + assert len(resp["Reservations"]) == 3 # Should have created 1 ECS cluster all_clusters = ecs_client.list_clusters()["clusterArns"] - all_clusters.should.contain(our_env["ecsClusterArn"]) + assert our_env["ecsClusterArn"] in all_clusters @mock_ec2 @@ -98,4 +97,4 @@ def test_create_managed_compute_environment_with_instance_family(): our_env = batch_client.describe_compute_environments( computeEnvironments=[compute_name] )["computeEnvironments"][0] - our_env["computeResources"]["instanceTypes"].should.equal(["t2"]) + assert our_env["computeResources"]["instanceTypes"] == ["t2"]