def __init__(self, name, dependencies, dependency_types, conditions=None, versions=None): self.name = name self.spec = None self.dependencies = ordereddict_backport.OrderedDict() assert len(dependencies) == len(dependency_types) for dep, dtype in zip(dependencies, dependency_types): d = Dependency(self, Spec(dep.name), type=dtype) if not conditions or dep.name not in conditions: self.dependencies[dep.name] = {Spec(name): d} else: dep_conditions = conditions[dep.name] dep_conditions = dict( (Spec(x), Dependency(self, Spec(y), type=dtype)) for x, y in dep_conditions.items()) self.dependencies[dep.name] = dep_conditions if versions: self.versions = versions else: versions = list(Version(x) for x in [1, 2, 3]) self.versions = dict((x, {'preferred': False}) for x in versions) self.variants = {} self.provided = {} self.conflicts = {} self.patches = {}
def config(tmpdir): """Mocks the configuration scope.""" spack.config.clear_config_caches() real_scope = spack.config.config_scopes spack.config.config_scopes = ordereddict_backport.OrderedDict() for priority in ['low', 'high']: spack.config.ConfigScope(priority, str(tmpdir.join(priority))) Config = collections.namedtuple('Config', ['real', 'mock']) yield Config(real=real_scope, mock=spack.config.config_scopes) spack.config.config_scopes = real_scope spack.config.clear_config_caches()
def config(configuration_dir): """Hooks the mock configuration files into spack.config""" # Set up a mock config scope spack.config.clear_config_caches() real_scope = spack.config.config_scopes spack.config.config_scopes = ordereddict_backport.OrderedDict() spack.config.ConfigScope('site', str(configuration_dir.join('site'))) spack.config.ConfigScope('user', str(configuration_dir.join('user'))) Config = collections.namedtuple('Config', ['real', 'mock']) yield Config(real=real_scope, mock=spack.config.config_scopes) spack.config.config_scopes = real_scope spack.config.clear_config_caches()
def test_get_header(): headers = { 'Content-type': 'text/plain' } # looking up headers should just work like a plain dict # lookup when there is an entry with the right key assert(spack.util.web.get_header(headers, 'Content-type') == 'text/plain') # looking up headers should still work if there is a fuzzy match assert(spack.util.web.get_header(headers, 'contentType') == 'text/plain') # ...unless there is an exact match for the "fuzzy" spelling. headers['contentType'] = 'text/html' assert(spack.util.web.get_header(headers, 'contentType') == 'text/html') # If lookup has to fallback to fuzzy matching and there are more than one # fuzzy match, the result depends on the internal ordering of the given # mapping headers = ordereddict_backport.OrderedDict() headers['Content-type'] = 'text/plain' headers['contentType'] = 'text/html' assert(spack.util.web.get_header(headers, 'CONTENT_TYPE') == 'text/plain') del headers['Content-type'] assert(spack.util.web.get_header(headers, 'CONTENT_TYPE') == 'text/html') # Same as above, but different ordering headers = ordereddict_backport.OrderedDict() headers['contentType'] = 'text/html' headers['Content-type'] = 'text/plain' assert(spack.util.web.get_header(headers, 'CONTENT_TYPE') == 'text/html') del headers['contentType'] assert(spack.util.web.get_header(headers, 'CONTENT_TYPE') == 'text/plain') # If there isn't even a fuzzy match, raise KeyError with pytest.raises(KeyError): spack.util.web.get_header(headers, 'ContentLength')
def add_package(self, name, dependencies=None, dependency_types=None, conditions=None): """Factory method for creating mock packages. This creates a new subclass of ``MockPackageBase``, ensures that its ``name`` and ``__name__`` properties are set up correctly, and returns a new instance. We use a factory function here because many functions and properties of packages need to be class functions. Args: name (str): name of the new package dependencies (list): list of mock packages to be dependencies for this new package (optional; no deps if not provided) dependency_type (list): list of deptypes for each dependency (optional; will be default_deptype if not provided) conditions (list): condition specs for each dependency (optional) """ if not dependencies: dependencies = [] if not dependency_types: dependency_types = [spack.dependency.default_deptype ] * len(dependencies) assert len(dependencies) == len(dependency_types) # new class for the mock package class MockPackage(MockPackageBase): pass MockPackage.__name__ = spack.util.naming.mod_to_class(name) MockPackage.name = name MockPackage._repo = self # set up dependencies MockPackage.dependencies = ordereddict_backport.OrderedDict() for dep, dtype in zip(dependencies, dependency_types): d = Dependency(MockPackage, Spec(dep.name), type=dtype) if not conditions or dep.name not in conditions: MockPackage.dependencies[dep.name] = {Spec(name): d} else: dep_conditions = conditions[dep.name] dep_conditions = dict( (Spec(x), Dependency(MockPackage, Spec(y), type=dtype)) for x, y in dep_conditions.items()) MockPackage.dependencies[dep.name] = dep_conditions # each package has some fake versions versions = list(Version(x) for x in [1, 2, 3]) MockPackage.versions = dict((x, { 'preferred': False }) for x in versions) MockPackage.variants = {} MockPackage.provided = {} MockPackage.conflicts = {} MockPackage.patches = {} mock_package = MockPackage(dependencies, dependency_types, conditions, versions) self.spec_to_pkg[name] = mock_package self.spec_to_pkg["mockrepo." + name] = mock_package return mock_package