def test_failure():
try:
with soft_assertions():
assert_that('foo').is_length(4)
assert_that('foo').is_empty()
assert_that('foo').is_false()
assert_that('foo').is_digit()
assert_that('123').is_alpha()
assert_that('foo').is_upper()
assert_that('FOO').is_lower()
assert_that('foo').is_equal_to('bar')
assert_that('foo').is_not_equal_to('foo')
assert_that('foo').is_equal_to_ignoring_case('BAR')
assert_that({'a': 1}).has_a(2)
assert_that({'a': 1}).has_foo(1)
fail('should have raised error')
except AssertionError as e:
out = str(e)
assert_that(out).contains('Expected <foo> to be of length <4>, but was <3>.')
assert_that(out).contains('Expected <foo> to be empty string, but was not.')
assert_that(out).contains('Expected <False>, but was not.')
assert_that(out).contains('Expected <foo> to contain only digits, but did not.')
assert_that(out).contains('Expected <123> to contain only alphabetic chars, but did not.')
assert_that(out).contains('Expected <foo> to contain only uppercase chars, but did not.')
assert_that(out).contains('Expected <FOO> to contain only lowercase chars, but did not.')
assert_that(out).contains('Expected <foo> to be equal to <bar>, but was not.')
assert_that(out).contains('Expected <foo> to be not equal to <foo>, but was.')
assert_that(out).contains('Expected <foo> to be case-insensitive equal to <BAR>, but was not.')
assert_that(out).contains('Expected <1> to be equal to <2> on key <a>, but was not.')
assert_that(out).contains('Expected key <foo>, but val has no key <foo>.')
def test_soft_assertions(self):
try:
with soft_assertions():
assert_that('foo').is_length(4)
assert_that('foo').is_empty()
assert_that('foo').is_false()
assert_that('foo').is_digit()
assert_that('123').is_alpha()
assert_that('foo').is_upper()
assert_that('FOO').is_lower()
assert_that('foo').is_equal_to('bar')
assert_that('foo').is_not_equal_to('foo')
assert_that('foo').is_equal_to_ignoring_case('BAR')
fail('should have raised error')
except AssertionError as e:
assert_that(str(e)).contains('1. Expected <foo> to be of length <4>, but was <3>.')
assert_that(str(e)).contains('2. Expected <foo> to be empty string, but was not.')
assert_that(str(e)).contains('3. Expected <False>, but was not.')
assert_that(str(e)).contains('4. Expected <foo> to contain only digits, but did not.')
assert_that(str(e)).contains('5. Expected <123> to contain only alphabetic chars, but did not.')
assert_that(str(e)).contains('6. Expected <foo> to contain only uppercase chars, but did not.')
assert_that(str(e)).contains('7. Expected <FOO> to contain only lowercase chars, but did not.')
assert_that(str(e)).contains('8. Expected <foo> to be equal to <bar>, but was not.')
assert_that(str(e)).contains('9. Expected <foo> to be not equal to <foo>, but was.')
assert_that(str(e)).contains('10. Expected <foo> to be case-insensitive equal to <BAR>, but was not.')
def test_fail_with_msg():
try:
with soft_assertions():
fail('foobar')
fail('should have raised error')
except AssertionError as e:
out = str(e)
assert_that(out).is_equal_to('Fail: foobar!')
def test_soft_fail_with_msg():
try:
with soft_assertions():
soft_fail('foobar')
fail('should have raised error')
except AssertionError as e:
out = str(e)
assert_that(out).contains('Fail: foobar!')
assert_that(out).does_not_contain('should have raised error')
def test_expected_exception_failure():
try:
with soft_assertions():
assert_that(func_err).raises(RuntimeError).when_called_with('foo').is_equal_to('bar')
assert_that(func_ok).raises(RuntimeError).when_called_with('baz')
fail('should have raised error')
except AssertionError as e:
out = str(e)
assert_that(out).contains('Expected <err> to be equal to <bar>, but was not.')
assert_that(out).contains("Expected <func_ok> to raise <RuntimeError> when called with ('baz').")
def test_double_soft_fail():
try:
with soft_assertions():
soft_fail()
soft_fail('foobar')
fail('should have raised error')
except AssertionError as e:
out = str(e)
assert_that(out).contains('Fail!')
assert_that(out).contains('Fail: foobar!')
assert_that(out).does_not_contain('should have raised error')
def test_describe_of_image_already_available(self, client, mocker):
mocker.patch(
"pcluster.aws.ec2.Ec2Client.describe_image_by_id_tag",
return_value=_create_image_info("image1"),
)
mocker.patch("pcluster.aws.cfn.CfnClient.describe_stack_resource",
return_value=None)
mocker.patch(
"pcluster.api.controllers.image_operations_controller._presigned_config_url",
return_value="https://parallelcluster.aws.com/bucket/key",
)
expected_response = {
"creationTime": to_iso_timestr(datetime(2021, 4, 12)),
"ec2AmiInfo": {
"amiId":
"image1",
"amiName":
"image1",
"architecture":
"x86_64",
"state":
Ec2AmiState.AVAILABLE,
"description":
"description",
"tags": [
{
"key": "parallelcluster:image_id",
"value": "image1"
},
{
"key": "parallelcluster:version",
"value": "3.0.0"
},
{
"key": "parallelcluster:build_config",
"value": "s3://bucket/key"
},
],
},
"imageBuildStatus": ImageBuildStatus.BUILD_COMPLETE,
"imageConfiguration": {
"url": "https://parallelcluster.aws.com/bucket/key"
},
"imageId": "image1",
"region": "us-east-1",
"version": "3.0.0",
}
response = self._send_test_request(client, "image1")
with soft_assertions():
assert_that(response.status_code).is_equal_to(200)
assert_that(response.get_json()).is_equal_to(expected_response)
def test_ingest_path_dict(self, mock_params: List[Dict[str, Any]]):
for param in mock_params:
spb = SignatureParameterBuilder(params=param)
with soft_assertions():
members = [
spb.name, spb.required, spb.param_in, spb.param_type
]
for member in members:
assert_that(member).is_not_none()
assert_that(spb.param_format).is_none()
assert_that(spb.name).does_not_contain("-")
def test_success():
with soft_assertions():
assert_that('foo').is_length(3)
assert_that('foo').is_not_empty()
assert_that('foo').is_true()
assert_that('foo').is_alpha()
assert_that('123').is_digit()
assert_that('foo').is_lower()
assert_that('FOO').is_upper()
assert_that('foo').is_equal_to('foo')
assert_that('foo').is_not_equal_to('bar')
assert_that('foo').is_equal_to_ignoring_case('FOO')
def test_get_a_single_post(service_obj):
# requesting a random post no in each test run
requested_post_id = random.randint(1, 100)
res = service_obj.get_post_with_id(requested_post_id)
with soft_assertions():
assert_that(
res.status_code).described_as('Response code').is_equal_to(200)
assert_that(
res.json()).described_as('Response').contains_only(*post_keys)
assert_that(res.json()).described_as('Id in response').has_id(
requested_post_id)
def step_impl(context):
context.identifier = context.project_request.project.identifier
with soft_assertions():
assert context.project_request.status_code == Constants.StatusCode.CREATED.value
project_request = ApiRequests.get_project_by_id(context.project_request.project.id)
project = project_request.project
assert_that(project).has_id(context.project_request.project.id)
assert_that(project).has_name(context.project_request.project.name)
assert_that(project).has_identifier(context.project_request.project.identifier)
assert_that(project).has_description(context.project_request.project.description)
assert_that(project).has_is_public(context.project_request.project.is_public)
assert_that(project).has_home_page(context.project_request.project.home_page)
def test_success():
with soft_assertions():
assert_that('foo').is_length(3)
assert_that('foo').is_not_empty()
assert_that('foo').is_true()
assert_that('foo').is_alpha()
assert_that('123').is_digit()
assert_that('foo').is_lower()
assert_that('FOO').is_upper()
assert_that('foo').is_equal_to('foo')
assert_that('foo').is_not_equal_to('bar')
assert_that('foo').is_equal_to_ignoring_case('FOO')
def test_that_other_errors_are_converted(self, client, mocker):
image = _create_image_info("image1")
mocker.patch("pcluster.aws.ec2.Ec2Client.describe_image_by_id_tag",
return_value=image)
mocker.patch("pcluster.models.imagebuilder.ImageBuilder.delete",
side_effect=Exception("test error"))
expected_error = {"message": "test error"}
response = self._send_test_request(client, "image1")
with soft_assertions():
assert_that(response.status_code).is_equal_to(500)
assert_that(response.get_json()).is_equal_to(expected_error)
def test_gsfCopyRecords_success(gsf_test_data_03_06):
"""
Open the test GSF file, read a record, then copy the contents to
a new gsfRecords structure.
"""
# Arrange
file_handle = c_int(0)
data_id = c_gsfDataID()
source_records = c_gsfRecords()
target_records = c_gsfRecords()
# Act
return_value = gsfpy.bindings.gsfOpen(
os.fsencode(str(gsf_test_data_03_06.path)),
FileMode.GSF_READONLY,
byref(file_handle),
)
assert_that(return_value).is_zero()
bytes_read = gsfpy.bindings.gsfRead(
file_handle,
RecordType.GSF_RECORD_COMMENT,
byref(data_id),
byref(source_records),
)
assert_that(bytes_read).is_equal_to(156)
return_value = gsfpy.bindings.gsfCopyRecords(
pointer(target_records), pointer(source_records)
)
assert_that(return_value).is_zero()
return_value = gsfpy.bindings.gsfClose(file_handle)
assert_that(return_value).is_zero()
# Assert
with soft_assertions():
assert_that(target_records.comment.comment_time.tv_sec).is_equal_to(
source_records.comment.comment_time.tv_sec
)
assert_that(target_records.comment.comment_time.tv_nsec).is_equal_to(
source_records.comment.comment_time.tv_nsec
)
assert_that(target_records.comment.comment_length).is_equal_to(
source_records.comment.comment_length
)
assert_that(addressof(target_records.comment.comment)).is_not_equal_to(
addressof(source_records.comment.comment)
)
assert_that(string_at(target_records.comment.comment)).is_equal_to(
string_at(source_records.comment.comment)
)
def test_unknown_status_on_unstable_stack(self, mocker, client, scheduler,
stack_status):
"""When stack is in unstable status, the status should be UNKNOWN."""
mocker.patch(
"pcluster.aws.cfn.CfnClient.describe_stack",
return_value=cfn_describe_stack_mock_response(
scheduler, stack_status),
)
response = self._send_test_request(client)
with soft_assertions():
assert_that(response.status_code).is_equal_to(200)
expected_response = {"status": "UNKNOWN"}
assert_that(response.get_json()).is_equal_to(expected_response)
def check_projects(response):
r_json = response.json()
projects = r_json.get('projects')
with soft_assertions():
assert_that(len(projects)).is_less_than_or_equal_to(25)
for project in projects:
assert_that(project.get('id')).described_as('id').is_not_none().is_type_of(int)
assert_that(project.get('name')).described_as('name').is_not_none().is_type_of(str)
assert_that(project.get('identifier')).described_as('identifier').is_not_none().is_type_of(str)
if project.get('description', False):
assert_that(project.get('description')).described_as('description').is_not_none().is_type_of(str)
assert_that(project.get('status')).described_as('status').is_not_none().is_type_of(int)
assert_that(project.get('is_public')).described_as('is_public').is_not_none().is_type_of(bool)
def test_bad_request_on_unstable_stack(self, mocker, client, stack_status,
scheduler, request_body,
expected_response):
mocker.patch(
"pcluster.aws.cfn.CfnClient.describe_stack",
return_value=cfn_describe_stack_mock_response(
scheduler, stack_status),
)
config_mock = mocker.patch("pcluster.models.cluster.Cluster.config")
config_mock.scheduling.scheduler = scheduler
response = self._send_test_request(client, request_body=request_body)
with soft_assertions():
assert_that(response.status_code).is_equal_to(400)
assert_that(response.get_json()).is_equal_to(expected_response)
def test_stack_not_exist_request(self, mocker, client):
mocker.patch(
"pcluster.aws.cfn.CfnClient.describe_stack",
side_effect=StackNotFoundError(function_name="describestack",
stack_name="stack_name"),
)
response = self._send_test_request(client)
with soft_assertions():
assert_that(response.status_code).is_equal_to(404)
assert_that(response.get_json()).is_equal_to({
"message":
"Cluster 'clustername' does not exist or belongs to an "
"incompatible ParallelCluster major version."
})
def assert_result(case_name, *args):
# 判断是否传入step_name
if len(args) > 0:
case_data = get_case_data(case_name, args[0])
else:
case_data = get_case_data(case_name)
actual_result = case_data['actual_result']
expected_result = case_data['expected_result']
# 判断是否需要断言
if len(expected_result) == 0:
pass
else:
with soft_assertions():
assert_that(actual_result).contains_entry(expected_result)
def test_expected_exception_failure():
try:
with soft_assertions():
assert_that(func_err).raises(RuntimeError).when_called_with(
'foo').is_equal_to('bar')
assert_that(func_ok).raises(RuntimeError).when_called_with('baz')
fail('should have raised error')
except AssertionError as e:
out = str(e)
assert_that(out).contains(
'Expected <err> to be equal to <bar>, but was not.')
assert_that(out).contains(
"Expected <func_ok> to raise <RuntimeError> when called with ('baz')."
)
def test_nested():
try:
with soft_assertions():
assert_that('a').is_equal_to('A')
with soft_assertions():
assert_that('b').is_equal_to('B')
with soft_assertions():
assert_that('c').is_equal_to('C')
assert_that('b').is_equal_to('B2')
assert_that('a').is_equal_to('A2')
fail('should have raised error')
except AssertionError as e:
out = str(e)
assert_that(out).contains(
'1. Expected <a> to be equal to <A>, but was not.')
assert_that(out).contains(
'2. Expected <b> to be equal to <B>, but was not.')
assert_that(out).contains(
'3. Expected <c> to be equal to <C>, but was not.')
assert_that(out).contains(
'4. Expected <b> to be equal to <B2>, but was not.')
assert_that(out).contains(
'5. Expected <a> to be equal to <A2>, but was not.')
def test_config_object_initialization(config, expected_result,
expected_error_message):
if expected_error_message:
with pytest.raises(BadRequest, match=expected_error_message):
_ = ImageBuilder(config=config).config
elif config is None:
result = ImageBuilder(config=config).config
assert_that(result).is_none()
else:
result = ImageBuilder(config=config).config
with soft_assertions():
assert_that(result.build.instance_type).is_equal_to(
expected_result.build.instance_type)
assert_that(result.build.parent_image).is_equal_to(
expected_result.build.parent_image)
def test_read_swagger(self, download_test_swagger):
parsed_swagger = read_swagger(
package=config, signature_parser_builder=SignatureParameterBuilder)
with soft_assertions():
for sp in parsed_swagger:
assert_that(sp).is_not_empty()
assert_that(sp).is_type_of(ParsedSwagger)
assert_that(sp.path).is_not_none()
assert_that(sp.signature).is_type_of(str)
assert_that(sp.signature).is_not_none()
if sp.sort:
assert_that(sp.sort).is_type_of(tuple)
assert_that(sp.sort).is_not_empty()
def test_gsfInitializeMBParams_success(gsf_test_data_03_06):
"""
Create a gsfMBParams structure and initialize all fields.
"""
# Arrange
mbparams = c_gsfMBParams()
# Act
gsfpy.bindings.gsfInitializeMBParams(byref(mbparams))
# Assert two of the fields here to check they are set to the unknown
# value.
with soft_assertions():
assert_that(mbparams.horizontal_datum).is_equal_to(-99)
assert_that(mbparams.vessel_type).is_equal_to(-99)
def test_successful_request(self, mocker, client, instances, params,
next_token):
describe_instances_response = []
for instance in instances:
describe_instances_response.append(
cfn_describe_instances_mock_response(**instance))
expected_response = describe_cluster_instances_mock_response(instances)
if next_token:
expected_response["nextToken"] = next_token
mocker.patch("pcluster.aws.ec2.Ec2Client.describe_instances",
return_value=(describe_instances_response, next_token))
response = self._send_test_request(client, **params)
with soft_assertions():
assert_that(response.status_code).is_equal_to(200)
assert_that(response.get_json()).is_equal_to(expected_response)
def test_that_errors_are_converted(self, client, mocker, error,
status_code):
mocker.patch("pcluster.aws.ec2.Ec2Client.get_images",
side_effect=error(function_name="get_images",
message="test error"))
expected_error = {"message": "test error"}
if error == BadRequestError:
expected_error[
"message"] = "Bad Request: " + expected_error["message"]
response = self._send_test_request(
client, ImageStatusFilteringOption.AVAILABLE)
with soft_assertions():
assert_that(response.status_code).is_equal_to(status_code)
assert_that(response.get_json()).is_equal_to(expected_error)
def test_dryrun(self, client, mocker, validation_errors, error_code,
expected_response):
if validation_errors:
mocker.patch(
"pcluster.models.imagebuilder.ImageBuilder.validate_create_request",
side_effect=validation_errors)
else:
mocker.patch(
"pcluster.models.imagebuilder.ImageBuilder.validate_create_request",
return_value=None)
response = self._send_test_request(client, dryrun=True)
with soft_assertions():
assert_that(response.status_code).is_equal_to(error_code)
assert_that(response.get_json()).is_equal_to(expected_response)
def test_failure_chain():
try:
with soft_assertions():
assert_that('foo').is_length(4).is_empty().is_false().is_digit().is_upper()\
.is_equal_to('bar').is_not_equal_to('foo').is_equal_to_ignoring_case('BAR')
fail('should have raised error')
except AssertionError as e:
out = str(e)
assert_that(out).contains('Expected <foo> to be of length <4>, but was <3>.')
assert_that(out).contains('Expected <foo> to be empty string, but was not.')
assert_that(out).contains('Expected <False>, but was not.')
assert_that(out).contains('Expected <foo> to contain only digits, but did not.')
assert_that(out).contains('Expected <foo> to contain only uppercase chars, but did not.')
assert_that(out).contains('Expected <foo> to be equal to <bar>, but was not.')
assert_that(out).contains('Expected <foo> to be not equal to <foo>, but was.')
assert_that(out).contains('Expected <foo> to be case-insensitive equal to <BAR>, but was not.')
def test_last_level_doesnt_reset_progress(self):
game = start_game()
game["Game"].load_level(5)
game["Player"].move_to_object(game["Level"].exit, offset=-2)
time.sleep(1.5) # слишком быстро проходит и не видно результата :)
game["LevelCompleteMenu"].avoid_close_me_menu()
game["LevelCompleteMenu"].next_button.tap()
time.sleep(1.5) # см. выше
game["Unity"].stop()
game["Appium"].quit()
time.sleep(3)
new_game = start_game()
with soft_assertions():
assert_that(new_game["Level"].level_name).contains("Map5")
new_game["Unity"].stop()
new_game["Appium"].quit()
def test_fail_with_soft_failing_asserts():
try:
with soft_assertions():
assert_that('foo').is_length(4)
assert_that('foo').is_empty()
fail('foobar')
assert_that('foo').is_not_equal_to('foo')
assert_that('foo').is_equal_to_ignoring_case('BAR')
fail('should have raised error')
except AssertionError as e:
out = str(e)
assert_that(out).is_equal_to('Fail: foobar!')
assert_that(out).does_not_contain('Expected <foo> to be of length <4>, but was <3>.')
assert_that(out).does_not_contain('Expected <foo> to be empty string, but was not.')
assert_that(out).does_not_contain('Expected <foo> to be not equal to <foo>, but was.')
assert_that(out).does_not_contain('Expected <foo> to be case-insensitive equal to <BAR>, but was not.')
def test_gsfSetDefaultScaleFactor_success(gsf_test_data_03_06):
"""
Set estimated scale factors for a gsfSwathBathyPing structure.
"""
# Arrange
file_handle = c_int(0)
records = c_gsfRecords()
data_id = c_gsfDataID()
# Act
return_value = gsfpy.bindings.gsfOpen(
os.fsencode(str(gsf_test_data_03_06.path)),
FileMode.GSF_READONLY,
byref(file_handle),
)
assert_that(return_value).is_zero()
bytes_read = gsfpy.bindings.gsfRead(
file_handle,
RecordType.GSF_RECORD_SWATH_BATHYMETRY_PING,
byref(data_id),
byref(records),
)
assert_that(bytes_read).is_equal_to(6116)
# Set multibeam ping scale factors to be empty
records.mb_ping.scaleFactors = c_gsfScaleFactors()
return_value = gsfpy.bindings.gsfSetDefaultScaleFactor(byref(records.mb_ping))
assert_that(return_value).is_zero()
return_value = gsfpy.bindings.gsfClose(file_handle)
assert_that(return_value).is_zero()
# Assert
with soft_assertions():
index = 2
assert_that(
records.mb_ping.scaleFactors.scaleTable[index].compressionFlag
).is_equal_to(0x00)
assert_that(
records.mb_ping.scaleFactors.scaleTable[index].multiplier
).is_equal_to(25)
assert_that(records.mb_ping.scaleFactors.scaleTable[index].offset).is_equal_to(
0
)
def test_delete_image_with_no_available_image_or_stack_throws_not_found_exception(
self, mocker, client):
mocker.patch(
"pcluster.aws.ec2.Ec2Client.describe_image_by_id_tag",
side_effect=ImageNotFoundError("describe_image_by_id_tag"),
)
mocker.patch("pcluster.aws.cfn.CfnClient.describe_stack",
side_effect=StackNotFoundError("describe_stack",
"stack_name"))
response = self._send_test_request(client, "nonExistentImage")
with soft_assertions():
assert_that(response.status_code).is_equal_to(404)
assert_that(response.get_json()).is_equal_to({
"message":
"No image or stack associated with ParallelCluster image id: nonExistentImage."
})
def test_soft_fail_with_soft_failing_asserts():
try:
with soft_assertions():
assert_that('foo').is_length(4)
assert_that('foo').is_empty()
soft_fail('foobar')
assert_that('foo').is_not_equal_to('foo')
assert_that('foo').is_equal_to_ignoring_case('BAR')
fail('should have raised error')
except AssertionError as e:
out = str(e)
assert_that(out).contains('Expected <foo> to be of length <4>, but was <3>.')
assert_that(out).contains('Expected <foo> to be empty string, but was not.')
assert_that(out).contains('Fail: foobar!')
assert_that(out).contains('Expected <foo> to be not equal to <foo>, but was.')
assert_that(out).contains('Expected <foo> to be case-insensitive equal to <BAR>, but was not.')
assert_that(out).does_not_contain('should have raised error')
def test_gsfGetScaleFactor_success(gsf_test_data_03_06):
"""
Read a GSF record and get the beam array field size, compression flag,
multiplier and DC offset applied to it.
"""
# Arrange
file_handle = c_int(0)
records = c_gsfRecords()
data_id = c_gsfDataID()
subrecord_id = (
ScaledSwathBathySubRecord.GSF_SWATH_BATHY_SUBRECORD_MEAN_CAL_AMPLITUDE_ARRAY
)
c_flag = c_ubyte()
multiplier = c_double()
offset = c_double()
# Act
return_value = gsfpy.bindings.gsfOpen(
os.fsencode(str(gsf_test_data_03_06.path)),
FileMode.GSF_READONLY,
byref(file_handle),
)
assert_that(return_value).is_zero()
bytes_read = gsfpy.bindings.gsfRead(
file_handle,
RecordType.GSF_RECORD_SWATH_BATHYMETRY_PING,
byref(data_id),
byref(records),
)
assert_that(bytes_read).is_equal_to(6116)
return_value = gsfpy.bindings.gsfGetScaleFactor(
file_handle, subrecord_id, byref(c_flag), byref(multiplier), byref(offset)
)
assert_that(return_value).is_zero()
return_value = gsfpy.bindings.gsfClose(file_handle)
assert_that(return_value).is_zero()
# Assert
with soft_assertions():
assert_that(c_flag.value).is_equal_to(0)
assert_that(multiplier.value).is_equal_to(2)
assert_that(offset.value).is_equal_to(0)
def test_slurm_dynamo_table_not_exist(self, mocker, client):
"""When stack exists but the dynamodb table to store the status does not exist, the status should be UNKNOWN."""
mocker.patch("pcluster.aws.cfn.CfnClient.describe_stack",
return_value=cfn_describe_stack_mock_response("slurm"))
mocker.patch(
"pcluster.aws.dynamo.DynamoResource.get_item",
side_effect=AWSClientError(
function_name="get_item",
message="An error occurred (ResourceNotFoundException) when"
" calling the GetItem operation: Requested resource not found",
),
)
response = self._send_test_request(client)
with soft_assertions():
assert_that(response.status_code).is_equal_to(200)
expected_response = {"status": "UNKNOWN"}
assert_that(response.get_json()).is_equal_to(expected_response)
def test_delete_using_shared_image(self, client, mocker, instance_using,
image_is_shared, expected_response):
image = _create_image_info("image1")
mocker.patch("pcluster.aws.ec2.Ec2Client.describe_image_by_id_tag",
return_value=image)
instances = ["id1"] if instance_using else []
mocker.patch("pcluster.aws.ec2.Ec2Client.get_instance_ids_by_ami_id",
return_value=instances)
accounts = ["acct_1"] if image_is_shared else []
mocker.patch("pcluster.aws.ec2.Ec2Client.get_image_shared_account_ids",
return_value=accounts)
response = self._send_test_request(client, "image1", force=False)
with soft_assertions():
assert_that(response.status_code).is_equal_to(400)
assert_that(response.get_json()).contains("message")
assert_that(
response.get_json()["message"]).matches(expected_response)
def test_successful_request(self, mocker, client, stack_exists, force):
if stack_exists:
mocker.patch("pcluster.aws.cfn.CfnClient.describe_stack",
return_value=cfn_describe_stack_mock_response())
else:
mocker.patch(
"pcluster.aws.cfn.CfnClient.describe_stack",
side_effect=StackNotFoundError(function_name="describestack",
stack_name="stack_name"),
)
instance_ids = ["fakeinstanceid1", "fakeinstanceid2"]
mocker.patch("pcluster.aws.ec2.Ec2Client.list_instance_ids",
return_value=instance_ids)
terminate_instance_mock = mocker.patch(
"pcluster.aws.ec2.Ec2Client.terminate_instances")
response = self._send_test_request(client, force=force)
with soft_assertions():
assert_that(response.status_code).is_equal_to(202)
terminate_instance_mock.assert_called_with(tuple(instance_ids))
def test_list_of_dictionaries_does_not_duplicate_by_some_key_value():
"""
1. create new dict with global keys by some key value which could repeat in list of dictionaries
and append to this key a list of dictionaries, where this value figure
2. assert that dictionaries does not duplicate by some key's value
"""
new_some_view = defaultdict(list)
for some in SOMETHING:
new_some_view[some['key']].append(some['id'])
with soft_assertions():
for key in new_some_view:
assert_that(len(new_some_view[key])).described_as(
f'key "{key}"" has duplicates "{new_some_view[key]}"'
).is_less_than_or_equal_to(1)
def test_expected_exception_success():
with soft_assertions():
assert_that(func_err).raises(RuntimeError).when_called_with('foo').is_equal_to('err')