From ea3300de1269c1c2e1fe76f6a6dec534936cc303 Mon Sep 17 00:00:00 2001 From: Wojtek Kosior Date: Mon, 10 Oct 2022 10:05:10 +0200 Subject: [builder][server] fix old tests --- tests/test_item_infos.py | 317 +++++++++++++++++++++++++---------------------- 1 file changed, 168 insertions(+), 149 deletions(-) (limited to 'tests/test_item_infos.py') diff --git a/tests/test_item_infos.py b/tests/test_item_infos.py index 9de3c96..85809d6 100644 --- a/tests/test_item_infos.py +++ b/tests/test_item_infos.py @@ -14,59 +14,62 @@ from immutables import Map from hydrilla import item_infos, versions, json_instances from hydrilla.exceptions import HaketiloException -def test_make_item_refs_seq_empty(): +def test_make_item_specifiers_seq_empty(): """....""" - assert item_infos.make_item_refs_seq([]) == () + assert item_infos.make_item_specifiers_seq([]) == () -def test_get_item_refs_seq_nonempty(): +def test_get_item_specifiers_seq_nonempty(): """....""" ref_objs = [{'identifier': 'abc'}, {'identifier': 'def'}] - result = item_infos.make_item_refs_seq(ref_objs) + result = item_infos.make_item_specifiers_seq(ref_objs) assert type(result) is tuple assert [ref.identifier for ref in result] == ['abc', 'def'] @pytest.fixture -def mock_make_item_refs_seq(monkeypatch): +def mock_make_item_specifiers_seq(monkeypatch): """....""" - def mocked_make_item_refs_seq(ref_objs): + def mocked_make_item_specifiers_seq(ref_objs): """....""" assert ref_objs == getattr( - mocked_make_item_refs_seq, + mocked_make_item_specifiers_seq, 'expected', [{'identifier': 'abc'}, {'identifier': 'def'}] ) - return (item_infos.ItemRef('abc'), item_infos.ItemRef('def')) + return ( + item_infos.ItemSpecifier('abc'), + item_infos.ItemSpecifier('def') + ) - monkeypatch.setattr(item_infos, 'make_item_refs_seq', - mocked_make_item_refs_seq) + monkeypatch.setattr(item_infos, 'make_item_specifiers_seq', + mocked_make_item_specifiers_seq) - return mocked_make_item_refs_seq + return mocked_make_item_specifiers_seq def test_make_required_mappings_compat_too_low(): """....""" assert item_infos.make_required_mappings('whatever', 1) == () -@pytest.mark.usefixtures('mock_make_item_refs_seq') +@pytest.mark.usefixtures('mock_make_item_specifiers_seq') def test_make_required_mappings_compat_ok(): """....""" ref_objs = [{'identifier': 'abc'}, {'identifier': 'def'}] assert item_infos.make_required_mappings(ref_objs, 2) == \ - (item_infos.ItemRef('abc'), item_infos.ItemRef('def')) + (item_infos.ItemSpecifier('abc'), item_infos.ItemSpecifier('def')) -def test_make_file_refs_seq_empty(): +def test_make_file_specifiers_seq_empty(): """....""" - assert item_infos.make_file_refs_seq([]) == () + assert item_infos.make_file_specifiers_seq([]) == () -def test_make_file_refs_seq_nonempty(): +def test_make_file_specifiers_seq_nonempty(): """....""" ref_objs = [{'file': 'abc', 'sha256': 'dummy_hash1'}, {'file': 'def', 'sha256': 'dummy_hash2'}] - result = item_infos.make_file_refs_seq(ref_objs) + result = item_infos.make_file_specifiers_seq(ref_objs) assert type(result) is tuple assert [ref.name for ref in result] == ['abc', 'def'] @@ -99,7 +102,7 @@ def test_load_item_info(monkeypatch): def mocked_validate_instance(instance, schema_fmt): """....""" assert instance == 'dummy_instance' - assert schema_fmt == 'api_exotictype_description-{}.schema.json' + assert schema_fmt == 'api_resource_description-{}.schema.json' return 7 monkeypatch.setattr(json_instances, 'validate_instance', @@ -107,19 +110,21 @@ def test_load_item_info(monkeypatch): class MockedLoadedType: """....""" - def make(instance, schema_compat, repository): + def make(instance, schema_compat, repo, repo_iteration): """....""" - assert instance == 'dummy_instance' - assert schema_compat == 7 - assert repository == 'somerepo' + assert instance == 'dummy_instance' + assert schema_compat == 7 + assert repo == 'somerepo' + assert repo_iteration == 1 return 'dummy_item_info' - type_name = 'exotictype' + type = item_infos.ItemType.RESOURCE assert item_infos._load_item_info( MockedLoadedType, 'dummy_path', - 'somerepo' + 'somerepo', + 1 ) == 'dummy_item_info' def test_make_payloads(monkeypatch): @@ -136,8 +141,8 @@ def test_make_payloads(monkeypatch): monkeypatch.setattr(item_infos, 'parse_pattern', mocked_parse_pattern) assert item_infos.make_payloads(payloads_obj) == Map({ - 'dummy_parsed_pattern_1': item_infos.ItemRef('someresource'), - 'dummy_parsed_pattern_2': item_infos.ItemRef('someresource') + 'dummy_parsed_pattern_1': item_infos.ItemSpecifier('someresource'), + 'dummy_parsed_pattern_2': item_infos.ItemSpecifier('someresource') }) @pytest.mark.parametrize('info_mod, in_mod', [ @@ -146,7 +151,7 @@ def test_make_payloads(monkeypatch): ({}, {'uuid': 'dummy_uuid'}), ({'uuid': 'dummy_uuid'}, {'uuid': 'dummy_uuid'}), ({}, {'identifier': 'abc', '_initialized': True}), - ({}, {'_by_version': Map({(1, 2): 'dummy_old_info'})}) + ({}, {'items': Map({(1, 2): 'dummy_old_info'})}) ]) def test_versioned_item_info_register(info_mod, in_mod): """....""" @@ -162,14 +167,14 @@ def test_versioned_item_info_register(info_mod, in_mod): in_fields = { 'uuid': None, 'identifier': '', - '_by_version': Map(), + 'items': Map(), '_initialized': False, **in_mod } out_fields = { 'uuid': DummyInfo.uuid or in_mod.get('uuid'), 'identifier': DummyInfo.identifier, - '_by_version': Map({(1, 2): DummyInfo}), + 'items': Map({(1, 2): DummyInfo}), '_initialized': True } @@ -195,20 +200,6 @@ def test_versioned_item_info_register_bad_uuid(): with pytest.raises(HaketiloException, match='^uuid_mismatch_abc$'): versioned.register(DummyInfo) -@pytest.mark.parametrize('previous_registrations', [ - Map(), - Map({(1, 2): 'dummy_info'}) -]) -def test_versioned_item_info_unregister(previous_registrations): - """....""" - versioned = item_infos.VersionedItemInfo( - identifier = 'abc', - _by_version = previous_registrations - ) - - assert versioned.unregister((1, 2)) == \ - dc.replace(versioned, _by_version=Map()) - @pytest.mark.parametrize('registrations, out', [ (Map(), True), (Map({(1, 2): 'dummy_info'}), False) @@ -217,7 +208,7 @@ def test_versioned_item_info_is_empty(registrations, out): """....""" versioned = item_infos.VersionedItemInfo( identifier = 'abc', - _by_version = registrations + items = registrations ) assert versioned.is_empty() == out @@ -229,29 +220,32 @@ def test_versioned_item_info_is_empty(registrations, out): def test_versioned_item_info_newest_version(versions, out): """....""" versioned = item_infos.VersionedItemInfo( - identifier = 'abc', - _by_version = Map((ver, 'dummy_info') for ver in versions) + identifier = 'abc', + items = Map((ver, 'dummy_info') for ver in versions) ) - assert versioned.newest_version() == out + assert versioned.newest_version == out def test_versioned_item_info_newest_version_bad(monkeypatch): """....""" - monkeypatch.setattr(item_infos.VersionedItemInfo, 'newest_version', - lambda self: 'dummy_ver1') + monkeypatch.setattr( + item_infos.VersionedItemInfo, + 'newest_version', + 'dummy_ver1' + ) versioned = item_infos.VersionedItemInfo( - identifier = 'abc', - _by_version = Map(dummy_ver1='dummy_info1', dummy_ver2='dummy_info2') + identifier = 'abc', + items = Map(dummy_ver1='dummy_info1', dummy_ver2='dummy_info2') ) - assert versioned.get_newest() == 'dummy_info1' + assert versioned.newest_info == 'dummy_info1' def test_versioned_item_info_get_by_ver(): """....""" versioned = item_infos.VersionedItemInfo( - identifier = 'abc', - _by_version = Map({(1, 2): 'dummy_info1', (3, 4, 5): 'dummy_info2'}) + identifier = 'abc', + items = Map({(1, 2): 'dummy_info1', (3, 4, 5): 'dummy_info2'}) ) assert versioned.get_by_ver(range(1, 3)) == 'dummy_info1' @@ -263,24 +257,27 @@ def test_versioned_item_info_get_by_ver(): def test_versioned_item_get_all(versions, out): """....""" versioned = item_infos.VersionedItemInfo( - identifier = 'abc', - _by_version = Map((ver, str(ver)) for ver in versions) + identifier = 'abc', + items = Map((ver, str(ver)) for ver in versions) ) assert [*versioned.get_all()] == out sample_resource_obj = { - 'source_name': 'somesource', - 'source_copyright': [{'file': 'ABC', 'sha256': 'dummy_sha256'}], - 'version': [1, 2, 3, 0], - 'identifier': 'someid', - 'uuid': None, - 'long_name': 'Some Thing', - 'required_mappings': [{'identifier': 'required1'}], - 'generated_by': {'name': 'sometool', 'version': '1.1.1'}, - 'revision': 4, - 'dependencies': [{'identifier': 'abc'}, {'identifier': 'def'}], - 'scripts': [{'file': 'ABC', 'sha256': 'dummy_sha256'}] + 'source_name': 'somesource', + 'source_copyright': [{'file': 'ABC', 'sha256': 'dummy_sha256'}], + 'version': [1, 2, 3, 0], + 'identifier': 'someid', + 'uuid': None, + 'long_name': 'Some Thing', + 'description': 'Do something somewhere', + 'permissions': {'eval': True, 'cors_bypass': False}, + 'max_haketilo_version': [10], + 'required_mappings': [{'identifier': 'required1'}], + 'generated_by': {'name': 'sometool', 'version': '1.1.1'}, + 'revision': 4, + 'dependencies': [{'identifier': 'abc'}, {'identifier': 'def'}], + 'scripts': [{'file': 'ABC', 'sha256': 'dummy_sha256'}] } sample_mapping_obj = { @@ -297,118 +294,113 @@ del sample_mapping_obj['scripts'] def sample_resource_info(): """....""" return item_infos.ResourceInfo( - repository = 'somerepo', - source_name = 'somesource', - source_copyright = (item_infos.FileRef('ABC', 'dummy_sha256'),), - version = (1, 2, 3), - identifier = 'someid', - uuid = None, - long_name = 'Some Thing', - required_mappings = (item_infos.ItemRef('required1'),), - generated_by = item_infos.GeneratedBy('sometool', '1.1.1'), - revision = 4, - dependencies = (item_infos.ItemRef('abc'), - item_infos.ItemRef('def')), - scripts = (item_infos.FileRef('ABC', 'dummy_sha256'),) + repo = 'somerepo', + repo_iteration = 2, + source_name = 'somesource', + source_copyright = (item_infos.FileSpecifier('ABC', 'dummy_sha256'),), + version = (1, 2, 3), + identifier = 'someid', + uuid = None, + long_name = 'Some Thing', + description = 'Do something somewhere', + allows_eval = True, + allows_cors_bypass = False, + min_haketilo_ver = versions.normalize([1]), + max_haketilo_ver = versions.normalize([10]), + required_mappings = (item_infos.ItemSpecifier('required1'),), + generated_by = item_infos.GeneratedBy('sometool', '1.1.1'), + revision = 4, + dependencies = (item_infos.ItemSpecifier('abc'), + item_infos.ItemSpecifier('def')), + scripts = (item_infos.FileSpecifier('ABC', 'dummy_sha256'),) ) @pytest.fixture(scope='session') def sample_mapping_info(): """....""" - payloads = Map({'https://example.com/': item_infos.ItemRef('someresource')}) + payloads = Map({ + 'https://example.com/': item_infos.ItemSpecifier('someresource') + }) return item_infos.MappingInfo( - repository = 'somerepo', - source_name = 'somesource', - source_copyright = (item_infos.FileRef('ABC', 'dummy_sha256'),), - version = (1, 2, 3), - identifier = 'someid', - uuid = None, - long_name = 'Some Thing', - required_mappings = (item_infos.ItemRef('required1'),), - generated_by = item_infos.GeneratedBy('sometool', '1.1.1'), - payloads = payloads + repo = 'somerepo', + repo_iteration = 2, + source_name = 'somesource', + source_copyright = (item_infos.FileSpecifier('ABC', 'dummy_sha256'),), + version = (1, 2, 3), + identifier = 'someid', + uuid = None, + long_name = 'Some Thing', + description = 'Do something somewhere', + allows_eval = True, + allows_cors_bypass = False, + min_haketilo_ver = versions.normalize([2]), + max_haketilo_ver = versions.normalize([10]), + required_mappings = (item_infos.ItemSpecifier('required1'),), + generated_by = item_infos.GeneratedBy('sometool', '1.1.1'), + payloads = payloads ) @pytest.fixture(scope='session') def sample_info_base_init_kwargs(sample_resource_info): kwargs = {} - for field_name in item_infos.ItemInfoBase.__annotations__.keys(): - kwargs[field_name] = getattr(sample_resource_info, field_name) + for datclass_type in (item_infos.ItemInfoBase, item_infos.ItemIdentity): + for field_name in datclass_type.__annotations__.keys(): + kwargs[field_name] = getattr(sample_resource_info, field_name) return Map(kwargs) -@pytest.fixture -def mock_version_string(monkeypatch): - """....""" - def mocked_version_string(version, revision=None): - """....""" - assert version == (1, 2, 3) - assert revision in (None, 4) - return '1.2.3' if revision is None else '1.2.3-4' - - monkeypatch.setattr(versions, 'version_string', mocked_version_string) - -@pytest.mark.usefixtures('mock_version_string') -def test_item_info_path(sample_resource_info): - """....""" - assert sample_resource_info.path_relative_to_type() == 'someid/1.2.3' - assert sample_resource_info.path() == 'resource/someid/1.2.3' - -@pytest.mark.usefixtures('mock_version_string') -def test_resource_info_versioned_identifier(sample_resource_info, monkeypatch): +def test_resource_info_versioned_identifier(sample_resource_info): """....""" - monkeypatch.setattr(item_infos.ItemInfoBase, 'versioned_identifier', - lambda self: '') + assert sample_resource_info.versioned_identifier == 'someid-1.2.3-4' - assert sample_resource_info.versioned_identifier == '-4' - -@pytest.mark.usefixtures('mock_version_string') def test_mapping_info_versioned_identifier(sample_mapping_info): - """....""" assert sample_mapping_info.versioned_identifier == 'someid-1.2.3' @pytest.fixture -def mock_make_file_refs_seq(monkeypatch): +def mock_make_file_specifiers_seq(monkeypatch): """....""" - def mocked_make_file_refs_seq(ref_objs): + def mocked_make_file_specifiers_seq(ref_objs): """....""" assert ref_objs == getattr( - mocked_make_file_refs_seq, + mocked_make_file_specifiers_seq, 'expected', [{'file': 'ABC', 'sha256': 'dummy_sha256'}] ) - return (item_infos.FileRef(name='ABC', sha256='dummy_sha256'),) + return (item_infos.FileSpecifier(name='ABC', sha256='dummy_sha256'),) - monkeypatch.setattr(item_infos, 'make_file_refs_seq', - mocked_make_file_refs_seq) + monkeypatch.setattr(item_infos, 'make_file_specifiers_seq', + mocked_make_file_specifiers_seq) - return mocked_make_file_refs_seq + return mocked_make_file_specifiers_seq @pytest.mark.parametrize('missing_prop', [ 'required_mappings', 'generated_by', 'uuid' ]) -@pytest.mark.usefixtures('mock_make_item_refs_seq', 'mock_make_file_refs_seq') +@pytest.mark.usefixtures( + 'mock_make_item_specifiers_seq', + 'mock_make_file_specifiers_seq' +) def test_item_info_get_base_init_kwargs( missing_prop, monkeypatch, sample_resource_info, sample_info_base_init_kwargs, - mock_make_file_refs_seq + mock_make_file_specifiers_seq ): """....""" monkeypatch.delitem(sample_resource_obj, missing_prop) def mocked_normalize_version(version): - """....""" - assert version == [1, 2, 3, 0] - - return (1, 2, 3) + return { + (1, 2, 3, 0): (1, 2, 3), + (10,): (10,) + }[tuple(version)] - monkeypatch.setattr(versions, 'normalize_version', mocked_normalize_version) + monkeypatch.setattr(versions, 'normalize', mocked_normalize_version) def mocked_make_required_mappings(ref_objs, schema_compat): """....""" @@ -419,7 +411,7 @@ def test_item_info_get_base_init_kwargs( assert schema_compat == 2 - return (item_infos.ItemRef('required1'),) + return (item_infos.ItemSpecifier('required1'),) monkeypatch.setattr(item_infos, 'make_required_mappings', mocked_make_required_mappings) @@ -441,17 +433,23 @@ def test_item_info_get_base_init_kwargs( expected = expected.set('uuid', None) Base = item_infos.ItemInfoBase - assert Base._get_base_init_kwargs(sample_resource_obj, 2, 'somerepo') == \ - expected + assert Base._get_base_init_kwargs(sample_resource_obj, 2, 'somerepo', 2) \ + == expected @pytest.fixture def mock_get_base_init_kwargs(monkeypatch, sample_info_base_init_kwargs): """....""" - def mocked_get_base_init_kwargs(item_obj, schema_compat, repository): + def mocked_get_base_init_kwargs( + item_obj, + schema_compat, + repo, + repo_iteration + ): """....""" assert schema_compat == 2 assert item_obj['identifier'] == 'someid' - assert repository == 'somerepo' + assert repo == 'somerepo' + assert repo_iteration == 2 return sample_info_base_init_kwargs @@ -464,23 +462,26 @@ def test_resource_info_make( missing_prop, monkeypatch, sample_resource_info, - mock_make_item_refs_seq, - mock_make_file_refs_seq + mock_make_item_specifiers_seq, + mock_make_file_specifiers_seq ): """....""" _in = sample_resource_obj monkeypatch.delitem(_in, missing_prop) if missing_prop == 'dependencies': - mock_make_item_refs_seq.expected = [] + mock_make_item_specifiers_seq.expected = [] elif missing_prop == 'scripts': - mock_make_file_refs_seq.expected = [] + mock_make_file_specifiers_seq.expected = [] - assert item_infos.ResourceInfo.make(_in, 2, 'somerepo') == \ + assert item_infos.ResourceInfo.make(_in, 2, 'somerepo', 2) == \ sample_resource_info @pytest.mark.parametrize('missing_payloads', [True, False]) -@pytest.mark.usefixtures('mock_get_base_init_kwargs', 'mock_make_item_refs_seq') +@pytest.mark.usefixtures( + 'mock_get_base_init_kwargs', + 'mock_make_item_specifiers_seq' +) def test_mapping_info_make(missing_payloads, monkeypatch, sample_mapping_info): """....""" _in = sample_mapping_obj @@ -495,28 +496,46 @@ def test_mapping_info_make(missing_payloads, monkeypatch, sample_mapping_info): assert payloads_obj == \ {'https://example.com/': {'identifier': 'someresource'}} - return Map({'https://example.com/': item_infos.ItemRef('someresource')}) + return Map({ + 'https://example.com/': item_infos.ItemSpecifier('someresource') + }) monkeypatch.setattr(item_infos, 'make_payloads', mocked_make_payloads) - assert item_infos.MappingInfo.make(_in, 2, 'somerepo') == \ + assert item_infos.MappingInfo.make(_in, 2, 'somerepo', 2) == \ sample_mapping_info @pytest.mark.parametrize('type_name', ['ResourceInfo', 'MappingInfo']) -def test_make_item_info(type_name, monkeypatch): +@pytest.mark.parametrize('repo_iter_arg', [10, 'default']) +def test_make_item_info(type_name, repo_iter_arg, monkeypatch): """....""" info_type = getattr(item_infos, type_name) - def mocked_load_item_info(_info_type, instance_or_path, repository): + def mocked_load_item_info( + _info_type, + instance_or_path, + repo, + repo_iteration + ): """....""" assert _info_type == info_type assert instance_or_path == 'dummy_path' - assert repository == 'somerepo' + assert repo == 'somerepo' + if repo_iter_arg == 'default': + assert repo_iteration == -1 + else: + assert repo_iteration == 10 + return 'dummy_info' monkeypatch.setattr(item_infos, '_load_item_info', mocked_load_item_info) - assert info_type.load('dummy_path', 'somerepo') == 'dummy_info' + extra_args = {} + if repo_iter_arg != 'default': + extra_args['repo_iteration'] = repo_iter_arg + + assert info_type.load('dummy_path', 'somerepo', **extra_args) \ + == 'dummy_info' def test_resource_info_hash(sample_resource_info): """....""" -- cgit v1.2.3