def test_bad_field_definition():
    def doc(s):
        return yaml.safe_load(dedent(s))

    with pytest.raises(ValueError):
        parse_search_field(doc('''
        type: bad_type
        offset: [a]
        '''))

    with pytest.raises(ValueError):
        parse_search_field(doc('''
        type: badtype-range
        offset: [a]
        '''))

    with pytest.raises(ValueError):
        parse_search_field(doc('''
        type: double
        description: missing offset
        '''))

    with pytest.raises(ValueError):
        parse_search_field(doc('''
        type: double-range
        description: missing min_offset
        max_offset: [[a]]
        '''))

    with pytest.raises(ValueError):
        parse_search_field(doc('''
        type: double-range
        description: missing max_offset
        min_offset: [[a]]
        '''))
Exemple #2
0
def mk_sample_product(name,
                      description='Sample',
                      measurements=('red', 'green', 'blue'),
                      with_grid_spec=False,
                      storage=None):

    if storage is None and with_grid_spec is True:
        storage = {
            'crs': 'EPSG:3577',
            'resolution': {
                'x': 25,
                'y': -25
            },
            'tile_size': {
                'x': 100000.0,
                'y': 100000.0
            }
        }

    eo_type = MetadataType(
        {
            'name':
            'eo',
            'description':
            'Sample',
            'dataset':
            dict(
                id=['id'],
                label=['ga_label'],
                creation_time=['creation_dt'],
                measurements=['image', 'bands'],
                sources=['lineage', 'source_datasets'],
                format=['format', 'name'],
                grid_spatial=['grid_spatial', 'projection'],
            )
        },
        dataset_search_fields={
            'time':
            parse_search_field({
                'type': 'datetime-range',
                'min_offset': [['time']],
                'max_offset': [['time']],
            }),
        })

    common = dict(dtype='int16', nodata=-999, units='1', aliases=[])

    def mk_measurement(m):
        if isinstance(m, str):
            return dict(name=m, **common)
        elif isinstance(m, tuple):
            name, dtype, nodata = m
            m = common.copy()
            m.update(name=name, dtype=dtype, nodata=nodata)
            return m
        elif isinstance(m, dict):
            m_merged = common.copy()
            m_merged.update(m)
            return m_merged
        else:
            raise ValueError('Only support str|dict|(name, dtype, nodata)')

    measurements = [mk_measurement(m) for m in measurements]

    definition = dict(name=name,
                      description=description,
                      metadata_type='eo',
                      metadata={},
                      measurements=measurements)

    if storage is not None:
        definition['storage'] = storage

    return DatasetType(eo_type, definition)