lsst.obs.base.mapper_tests.MapperTests Class Reference

Inheritance diagram for lsst.obs.base.mapper_tests.MapperTests:

Public Member Functions
def	setUp_mapper (self, output=None, path_to_raw=None, keys=None, query_format=None, queryMetadata=None, metadata_output_path=None, map_python_type=None, map_python_std_type=None, map_cpp_type=None, map_storage_name=None, raw_filename=None, default_level=None, raw_levels=None, test_config_metadata=True)
def	test_map_config_data (self)
def	test_map_metadata_data (self)
def	test_keys (self)
def	test_get_dataset_types (self)
def	test_get_keys_raw (self)
def	test_get_default_level (self)
def	test_map (self)
def	test_query_metadata (self)
def	test_can_standardize (self)
def	test_validate (self)

Public Attributes
	mapper_data

Detailed Description

Generic tests of obs_* package mapper functionality.

In the subclasses's setUp():
    * Call setUp_mapper() to fill in required parameters.

Definition at line 35 of file mapper_tests.py.

Member Function Documentation

setUp_mapper()

def lsst.obs.base.mapper_tests.MapperTests.setUp_mapper	(		self,
			output = None,
			path_to_raw = None,
			keys = None,
			query_format = None,
			queryMetadata = None,
			metadata_output_path = None,
			map_python_type = None,
			map_python_std_type = None,
			map_cpp_type = None,
			map_storage_name = None,
			raw_filename = None,
			default_level = None,
			raw_levels = None,
			test_config_metadata = True
	)

Set up the necessary variables for mapper tests.

Parameters
----------

output : `str`
    full path to output repository (can be the same as data_dir input
    repository)
path_to_raw : `str`
    full path to the raw file referenced by dataIds['raw']
keys : `set`
    dictionary keys that this mapper should contain
query_format : `list`
    format list for the results portion of queryMetadata
queryMetadata : `tuple` of (`dict`, `tuple`)
    dataIds and the results of calling them in queryMetadata
metadata_output_path : `str`
    path to metadata output associated with dataIds['raw']
map_python_type : `type`
    full python type specification returned by the mapper for
    dataIds['raw']
map_python_std_type : `type`
    full python type specification returned by the mapper for
    dataIds['raw'] after standardization
map_cpp_type : `str`
    C++ type specification returned by the mapper for dataIds['raw']
map_storage_name : `str`
    butler name for the storage type dataIds['raw']
raw_filename : `str`
    Name of the raw files returned by the mapper for dataIds['raw']
default_level : `str`
    value returned from mapper.getDefaultLevel
raw_levels : `tuple` of (`str`, `set` of `str`)
    (level, expect) level and expected mapper return for
    mapper.getKeys('raw', level)
test_config_metadata : `bool`
    Test persisted config and metadata?  These tests may not be
    appropriate for test stand data. Defaults to True.

Definition at line 43 of file mapper_tests.py.

                     ):
        """
        Set up the necessary variables for mapper tests.
 
        Parameters
        ----------
 
        output : `str`
            full path to output repository (can be the same as data_dir input
            repository)
        path_to_raw : `str`
            full path to the raw file referenced by dataIds['raw']
        keys : `set`
            dictionary keys that this mapper should contain
        query_format : `list`
            format list for the results portion of queryMetadata
        queryMetadata : `tuple` of (`dict`, `tuple`)
            dataIds and the results of calling them in queryMetadata
        metadata_output_path : `str`
            path to metadata output associated with dataIds['raw']
        map_python_type : `type`
            full python type specification returned by the mapper for
            dataIds['raw']
        map_python_std_type : `type`
            full python type specification returned by the mapper for
            dataIds['raw'] after standardization
        map_cpp_type : `str`
            C++ type specification returned by the mapper for dataIds['raw']
        map_storage_name : `str`
            butler name for the storage type dataIds['raw']
        raw_filename : `str`
            Name of the raw files returned by the mapper for dataIds['raw']
        default_level : `str`
            value returned from mapper.getDefaultLevel
        raw_levels : `tuple` of (`str`, `set` of `str`)
            (level, expect) level and expected mapper return for
            mapper.getKeys('raw', level)
        test_config_metadata : `bool`
            Test persisted config and metadata?  These tests may not be
            appropriate for test stand data. Defaults to True.
        """
        fields = ['output',
                  'path_to_raw',
                  'keys',
                  'query_format',
                  'queryMetadata',
                  'metadata_output_path',
                  'map_python_type',
                  'map_python_std_type',
                  'map_cpp_type',
                  'map_storage_name',
                  'raw_filename',
                  'default_level',
                  'raw_levels',
                  'test_config_metadata',
                  ]
        MapperData = collections.namedtuple("MapperData", fields)
        self.mapper_data = MapperData(output=output,
                                      path_to_raw=path_to_raw,
                                      keys=keys,
                                      query_format=query_format,
                                      queryMetadata=queryMetadata,
                                      metadata_output_path=metadata_output_path,
                                      map_python_type=map_python_type,
                                      map_python_std_type=map_python_std_type,
                                      map_cpp_type=map_cpp_type,
                                      map_storage_name=map_storage_name,
                                      raw_filename=raw_filename,
                                      default_level=default_level,
                                      raw_levels=raw_levels,
                                      test_config_metadata=test_config_metadata,
                                      )
 

test_can_standardize()

def lsst.obs.base.mapper_tests.MapperTests.test_can_standardize

(

self

)

Definition at line 215 of file mapper_tests.py.

    def test_can_standardize(self):
        self.assertTrue(self.mapper.canStandardize("raw"))
        self.assertFalse(self.mapper.canStandardize("camera"))
        if not self.mapper_data.test_config_metadata:
            self.assertFalse(self.mapper.canStandardize("processCcd_config"))
            self.assertFalse(self.mapper.canStandardize("processCcd_metadata"))
 

test_get_dataset_types()

def lsst.obs.base.mapper_tests.MapperTests.test_get_dataset_types

(

self

)

Definition at line 162 of file mapper_tests.py.

    def test_get_dataset_types(self):
        if not self.mapper_data.test_config_metadata:
            self.skipTest('Skipping %s as requested' % (inspect.currentframe().f_code.co_name))
        someKeys = set(['raw', 'processCcd_config', 'processCcd_metadata'])
        self.assertTrue(set(self.mapper.getDatasetTypes()).issuperset(someKeys))
 

test_get_default_level()

def lsst.obs.base.mapper_tests.MapperTests.test_get_default_level

(

self

)

Definition at line 173 of file mapper_tests.py.

    def test_get_default_level(self):
        self.assertEqual(self.mapper.getDefaultLevel(), self.mapper_data.default_level)
 

test_get_keys_raw()

def lsst.obs.base.mapper_tests.MapperTests.test_get_keys_raw

(

self

)

Definition at line 168 of file mapper_tests.py.

    def test_get_keys_raw(self):
        for level, expect in self.mapper_data.raw_levels:
            result = self.mapper.getKeys("raw", level)
            self.assertEqual(set(result), expect, msg='Failed for level={}'.format(level))
 

test_keys()

def lsst.obs.base.mapper_tests.MapperTests.test_keys

(

self

)

Definition at line 159 of file mapper_tests.py.

    def test_keys(self):
        self.assertEqual(set(self.mapper.keys()), self.mapper_data.keys)
 

test_map()

def lsst.obs.base.mapper_tests.MapperTests.test_map

(

self

)

Definition at line 188 of file mapper_tests.py.

    def test_map(self):
        dataId = self.dataIds['raw']
        location = self.mapper.map_raw(dataId)
        if not isinstance(location, lsst.daf.persistence.butlerLocation.ButlerComposite):
            self._test_map(location, dataId)
        else:
            self.log.warn("""ButlerComposite datasets are not tested for mapper functions.  Though
ButlerComposites duck type as ButlerLocations in some ways, they do not
share enough methods to be usefully tested by the same function.  Note
there are tests of the objects in the package in which they are implemented.""")
        #  This should be the same as above.  Testing that both the generic
        # and specific interface work for mapping the raw.
        location = self.mapper.map("raw", dataId)
        if not isinstance(location, lsst.daf.persistence.butlerLocation.ButlerComposite):
            self._test_map(location, dataId)
 

test_map_config_data()

def lsst.obs.base.mapper_tests.MapperTests.test_map_config_data

(

self

)

Definition at line 131 of file mapper_tests.py.

    def test_map_config_data(self):
        if not self.mapper_data.test_config_metadata:
            self.skipTest('Skipping %s as requested' % (inspect.currentframe().f_code.co_name))
        dataId = self.dataIds['raw']
        butlerLocation = self.mapper.map("processCcd_config_filename", dataId)
        self.assertEqual(butlerLocation.getPythonType(), "lsst.pipe.tasks.processCcd.ProcessCcdConfig")
        self.assertEqual(butlerLocation.getCppType(), "Config")
        self.assertEqual(butlerLocation.getStorageName(), "ConfigStorage")
        processCcd_path = os.path.join("config", "processCcd.py")
        self.assertEqual(self.mapper.root, butlerLocation.getStorage().root)
        self.assertEqual(butlerLocation.getLocations(), [processCcd_path])
        for k, v in dataId.items():
            self.assertEqual(butlerLocation.getAdditionalData().getScalar(k), v,
                             msg="Failed for key={}".format(k))
 

test_map_metadata_data()

def lsst.obs.base.mapper_tests.MapperTests.test_map_metadata_data

(

self

)

Definition at line 146 of file mapper_tests.py.

    def test_map_metadata_data(self):
        if not self.mapper_data.test_config_metadata:
            self.skipTest('Skipping %s as requested' % (inspect.currentframe().f_code.co_name))
        dataId = self.dataIds['raw']
        butlerLocation = self.mapper.map_processCcd_metadata(dataId)
        self.assertEqual(butlerLocation.getPythonType(), "lsst.daf.base.PropertySet")
        self.assertEqual(butlerLocation.getCppType(), "PropertySet")
        self.assertEqual(butlerLocation.getStorageName(), "YamlStorage")
        self.assertEqual(butlerLocation.getLocations(), [self.mapper_data.metadata_output_path])
        for k, v in dataId.items():
            self.assertEqual(butlerLocation.getAdditionalData().getScalar(k), v,
                             msg="Failed for key={}".format(k))
 

test_query_metadata()

def lsst.obs.base.mapper_tests.MapperTests.test_query_metadata

(

self

)

Test expansion of incomplete information of the available data in this
obs package's testdata repo.

Definition at line 204 of file mapper_tests.py.

    def test_query_metadata(self):
        """
        Test expansion of incomplete information of the available data in this
        obs package's testdata repo.
        """
        for query, expect in self.mapper_data.queryMetadata:
            # queryMetadata returns tuples of available items of the 2nd
            # parameter.
            result = self.mapper.queryMetadata("raw", self.mapper_data.query_format, query)
            self.assertEqual(sorted(result), sorted(expect), msg="Failed for query={}".format(query))
 

test_validate()

def lsst.obs.base.mapper_tests.MapperTests.test_validate

(

self

)

Definition at line 225 of file mapper_tests.py.

    def test_validate(self):
        self._test_validate({'visit': 1, 'filter': 'g'})
        self._test_validate({'visit': 2, 'filter': 'r'})
        self._test_validate({'visit': 3, 'filter': 'g', 'tract': 4})
        # NOTE: when DM-7909 is completed, add assertRaises test here.
        # visit must be an integers

Member Data Documentation

mapper_data

lsst.obs.base.mapper_tests.MapperTests.mapper_data

Definition at line 115 of file mapper_tests.py.

---

The documentation for this class was generated from the following file:

• /j/snowflake/release/lsstsw/stack/0.2.1/Linux64/obs_base/21.0.0-27-gbbd0d29+ae871e0f33/python/lsst/obs/base/mapper_tests.py