Esempio n. 1
0
def master_mixins():
    mixins = load_schema('encoded:schemas/mixins.json')
    mixin_keys = [
        'schema_version',
        'uuid',
        'accession',
        'aliases',
        'status',
        'submitted',
        'release_dates',
        'modified',
        'references',
        'attribution',
        'notes',
        'documents',
        'attachment',
        'dbxrefs',
        'library',
        'antibody_info',
        'spikein_info',
        'sop_mapping',
        'tags',
        'badges',
        'facets_common'
    ]
    for key in mixin_keys:
        assert(mixins[key])
Esempio n. 2
0
def test_biosample_upgrade_starting_amount_unknown(testapp, biosample_1):
    from snovault.schema_utils import load_schema
    schema = load_schema('encoded:schemas/biosample.json')
    biosample_1['starting_amount'] = 'unknown'
    biosample_1['starting_amount_units'] = 'g'
    res = testapp.post_json('/biosample?validate=false&render=uuid',
                            biosample_1)
    location = res.location

    # The properties are stored un-upgraded.
    res = testapp.get(location + '?frame=raw&upgrade=false').maybe_follow()
    assert res.json['schema_version'] == '1'

    # When the item is fetched, it is upgraded automatically.
    res = testapp.get(location).maybe_follow()
    assert res.json['schema_version'] == schema['properties'][
        'schema_version']['default']

    res = testapp.patch_json(location, {})

    # The stored properties are now upgraded.
    res = testapp.get(location + '?frame=raw&upgrade=false').maybe_follow()
    assert res.json['schema_version'] == schema['properties'][
        'schema_version']['default']

    assert 'starting_amount' not in res.json
    assert 'starting_amount_units' not in res.json
Esempio n. 3
0
def test_fourfront_crawl_schemas(testapp, registry):
    from snovault import TYPES
    from snovault.schema_utils import load_schema
    schema = load_schema('encoded:schemas/experiment_hi_c.json')
    field_path = 'files.extra_files.file_size'
    field_schema = crawl_schema(registry[TYPES], field_path, schema)
    assert isinstance(field_schema, dict)
    assert field_schema['title'] == 'File Size'
Esempio n. 4
0
def test_biosample_upgrade_inline_unknown(testapp, biosample_1):
    from snovault.schema_utils import load_schema
    schema = load_schema('encoded:schemas/biosample.json')
    biosample_1['starting_amount'] = 'Unknown'
    res = testapp.post_json('/biosample?validate=false&render=uuid', biosample_1)
    location = res.location
    res = testapp.patch_json(location, {})
    res = testapp.get(location + '?frame=raw&upgrade=false').maybe_follow()
    assert res.json['schema_version'] == schema['properties']['schema_version']['default']
    assert 'starting_amount' not in res.json
Esempio n. 5
0
def compute_master_mixins():
    mixins = load_schema('encoded:schemas/mixins.json')
    mixin_keys = [
        'schema_version', 'uuid', 'accession', 'aliases', 'status',
        'submitted', 'modified', 'attribution', 'notes', 'documents',
        'attachment', 'dbxrefs', 'alternative_ids', 'static_embeds', 'tags',
        'facets_common', 'supplementary_files'
    ]
    for key in mixin_keys:
        assert (mixins[key])
Esempio n. 6
0
def test_biosample_upgrade_inline_unknown(testapp, biosample_1):
    from snovault.schema_utils import load_schema
    schema = load_schema('encoded:schemas/biosample.json')
    biosample_1['starting_amount'] = 'Unknown'
    res = testapp.post_json('/biosample?validate=false&render=uuid',
                            biosample_1)
    location = res.location
    res = testapp.patch_json(location, {})
    res = testapp.get(location + '?frame=raw&upgrade=false').maybe_follow()
    assert res.json['schema_version'] == schema['properties'][
        'schema_version']['default']
    assert 'starting_amount' not in res.json
def test_biosample_upgrade_inline(testapp, biosample_1, heart):
    from snovault.schema_utils import load_schema
    schema = load_schema('encoded:schemas/biosample.json')
    res = testapp.post_json('/biosample?validate=false&render=uuid', biosample_1)
    location = res.location

    # The properties are stored un-upgraded.
    res = testapp.get(location + '?frame=raw&upgrade=false').maybe_follow()
    assert res.json['schema_version'] == '1'

    # When the item is fetched, it is upgraded automatically.
    res = testapp.get(location).maybe_follow()
    assert res.json['schema_version'] == schema['properties']['schema_version']['default']

    res = testapp.patch_json(location, {})

    # The stored properties are now upgraded.
    res = testapp.get(location + '?frame=raw&upgrade=false').maybe_follow()
    assert res.json['schema_version'] == schema['properties']['schema_version']['default']
Esempio n. 8
0
def test_facets_and_columns_orders(schema, testapp):
    '''This tests depends on Python 3.6's ordered dicts'''

    loaded_schema = load_schema('encoded:schemas/%s' % schema)

    if "properties" in loaded_schema and ("columns" in loaded_schema
                                          or "facets" in loaded_schema):
        loaded_schema_copy = deepcopy(loaded_schema)
        loaded_schema_copy = order_schema_columns_and_facets(
            loaded_schema_copy)
        failed = False

        if "columns" in loaded_schema:
            failed = json.dumps(loaded_schema["columns"]) != json.dumps(
                loaded_schema_copy["columns"])

        if not failed and "facets" in loaded_schema:
            # Avoid running if already failed.
            failed = json.dumps(loaded_schema["facets"]) != json.dumps(
                loaded_schema_copy["facets"])

        assert not failed, '''
Order of facets or columns in %s file does not match the ordering based on "order" values. \
Please run `poetry run order-schema-columns-and-facets`. \

If you don't want this test to fail ever again, please consider adding the follow as "pre-commit" \
file in your .git/hooks directory in order to automatically amend your commits with proper order when \
schemas change.

>    #!/bin/sh
>
>    CHANGED=`git diff HEAD@{0} --stat -- $GIT_DIR/../src/encoded/schemas/ | wc -l`
>    if [ $CHANGED -gt 0 ];
>    then
>        echo "Schemas have changed! Sorting columns and facets..."
>        python3 $GIT_DIR/../src/encoded/commands/order_schema_columns_and_facets.py
>        git add $GIT_DIR/../src/encoded/schemas/
>    fi

        ''' % schema
Esempio n. 9
0
def test_biosample_upgrade_starting_amount_explicit_patch(testapp, biosample_1):
    from snovault.schema_utils import load_schema
    schema = load_schema('encoded:schemas/biosample.json')
    biosample_1['starting_amount'] = 0.632
    biosample_1['starting_amount_units'] = 'g'
    res = testapp.post_json('/biosample?validate=false&render=uuid', biosample_1)
    location = res.location

    # The properties are stored un-upgraded.
    res = testapp.get(location + '?frame=raw&upgrade=false').maybe_follow()
    assert res.json['schema_version'] == '1'

    # When the item is fetched, it is upgraded automatically.
    res = testapp.get(location).maybe_follow()
    assert res.json['schema_version'] == schema['properties']['schema_version']['default']

    res = testapp.patch_json(location, {'starting_amount': 0.263})

    # The stored properties are now upgraded.
    res = testapp.get(location + '?frame=raw&upgrade=false').maybe_follow()
    assert res.json['schema_version'] == schema['properties']['schema_version']['default']

    assert res.json['starting_amount'] == 0.263
    assert res.json['starting_amount_units'] == 'g'
Esempio n. 10
0
def test_mixinProperties():
    from snovault.schema_utils import load_schema
    schema = load_schema('snowflakes:schemas/access_key.json')
    assert schema['properties']['uuid']['type'] == 'string'
Esempio n. 11
0
def test_load_schema(schema):
    from snovault.schema_utils import load_schema
    assert load_schema('snowflakes:schemas/%s' % schema)
Esempio n. 12
0
def test_load_schema(schema, master_mixins, registry, pattern_fields, testapp):

    abstract = [
        'file.json', 'individual.json', 'quality_metric.json', 'note.json',
        'workflow_run.json', 'user_content.json', 'evidence.json',
        'higlass_view_config.json'
    ]

    loaded_schema = load_schema('encoded:schemas/%s' % schema)
    assert (loaded_schema)

    typename = schema.replace('.json', '')
    collection_names = [camel_case(typename), pluralize(typename)]

    # see if there is a pattern field and if so test the regex (uses fixture)
    schema_props = loaded_schema.get('properties')
    for field, test_values in pattern_fields.items():
        if schema_props and field in schema_props:
            pattern = schema_props.get(field).get(
                'pattern')  # will sometimes be None if mixed in from elsewhere
            if pattern is None:
                continue
            if not test_values:
                continue
            regex = re.compile(pattern)
            good_vals = test_values.get('good', [])
            bad_vals = test_values.get('bad', [])
            assert all([regex.search(tv) for tv in good_vals if good_vals])
            assert not any([regex.search(bv) for bv in bad_vals if bad_vals])

    # check the mixin properties for each schema
    if not schema == ('mixins.json'):
        verify_mixins(loaded_schema, master_mixins)

    if schema not in ['namespaces.json', 'mixins.json']:
        # check that schema.id is same as /profiles/schema
        idtag = loaded_schema['id']
        idtag = idtag.replace('/profiles/', '')
        # special case for access_key.json
        if schema == 'access_key.json':
            idtag = idtag.replace('_admin', '')
        assert schema == idtag

        # check for pluralized and camel cased in collection_names
        val = None
        for name in collection_names:
            assert name in registry[COLLECTIONS]
            if val is not None:
                assert registry[COLLECTIONS][name] == val
            else:
                val = registry[COLLECTIONS][name]

        if schema not in abstract:
            # check schema w/o json extension is in registry[TYPES]
            assert typename in registry[TYPES].by_item_type
            assert typename in registry[COLLECTIONS]
            assert registry[COLLECTIONS][typename] == val

            shared_properties = [
                'uuid', 'schema_version', 'aliases', 'date_created',
                'submitted_by', 'last_modified', 'status'
            ]
            no_alias_or_attribution = [
                'user.json', 'project.json', 'institution.json',
                'organism.json', 'page.json', 'static_section.json',
                'badge.json', 'tracking_item.json', 'file_format.json',
                'experiment_type.json'
            ]
            for prop in shared_properties:
                if schema == 'experiment.json':
                    # currently experiment is abstract and has no mixin properties
                    continue
                if schema == 'access_key.json' and prop not in [
                        'uuid', 'schema_version'
                ]:
                    continue
                if schema in no_alias_or_attribution and prop in [
                        'aliases', 'institution', 'project'
                ]:
                    continue
                verify_property(loaded_schema, prop)
Esempio n. 13
0
def test_load_schema(schema):
    from snovault.schema_utils import load_schema
    assert load_schema('encoded:schemas/%s' % schema)
Esempio n. 14
0
def test_mixinProperties():
    schema = load_schema('encoded:schemas/access_key.json')
    assert schema['properties']['uuid']['type'] == 'string'
Esempio n. 15
0
def test_mixinProperties():
    from snovault.schema_utils import load_schema
    schema = load_schema('snowflakes:schemas/access_key.json')
    assert schema['properties']['uuid']['type'] == 'string'
Esempio n. 16
0
def test_load_schema(schema):
    from snovault.schema_utils import load_schema
    assert load_schema('snowflakes:schemas/%s' % schema)
Esempio n. 17
0
def test_load_schema(schema, master_mixins, registry):
    from snovault import TYPES
    from snovault import COLLECTIONS

    abstract = [
        'microscope_setting.json',
        'experiment.json',
        'file.json',
        'individual.json',
        'quality_metric.json',
        'treatment.json',
        'workflow_run.json',
        'user_content.json'
    ]

    loaded_schema = load_schema('encoded:schemas/%s' % schema)
    assert(loaded_schema)

    typename = schema.replace('.json', '')
    collection_names = [camel_case(typename), pluralize(typename)]

    # check the mixin properties for each schema
    if not schema == ('mixins.json'):
        verify_mixins(loaded_schema, master_mixins)

    if schema not in ['namespaces.json', 'mixins.json']:
        # check that schema.id is same as /profiles/schema
        idtag = loaded_schema['id']
        idtag = idtag.replace('/profiles/', '')
        # special case for access_key.json
        if schema == 'access_key.json':
            idtag = idtag.replace('_admin', '')
        assert schema == idtag

        # check for pluralized and camel cased in collection_names
        val = None
        for name in collection_names:
            assert name in registry[COLLECTIONS]
            if val is not None:
                assert registry[COLLECTIONS][name] == val
            else:
                val = registry[COLLECTIONS][name]

        if schema not in abstract:
            # check schema w/o json extension is in registry[TYPES]
            assert typename in registry[TYPES].by_item_type
            assert typename in registry[COLLECTIONS]
            assert registry[COLLECTIONS][typename] == val

            shared_properties = [
                'uuid',
                'schema_version',
                'aliases',
                'lab',
                'award',
                'date_created',
                'submitted_by',
                'last_modified',
                'status'
            ]
            no_alias_or_attribution = [
                'user.json', 'award.json', 'lab.json', 'organism.json',
                'ontology.json', 'ontology_term.json', 'sysinfo.json', 'page.json',
                'static_section.json', 'badge.json', 'tracking_item.json',
                'file_format.json', 'experiment_type.json', 'higlass_view_config.json'
            ]
            for prop in shared_properties:
                if schema == 'experiment.json':
                    # currently experiment is abstract and has no mixin properties
                    continue
                if schema == 'access_key.json' and prop not in ['uuid', 'schema_version']:
                    continue
                if schema in no_alias_or_attribution and prop in ['aliases', 'lab', 'award']:
                    continue
                verify_property(loaded_schema, prop)