def _instantiate_type_definitions(descriptors):
"""
Once the descriptors have been validated, this call creates objects
to represent each type definition.
@param descriptors: descriptors containing type definitions
@type descriptors: list of L{TypeDescriptor}
@return: list of all type definitions across all descriptors
@rtype: list of L{TypeDefinition}
"""
all_type_dicts = _all_types(descriptors)
all_types = []
for type_dict in all_type_dicts:
# Handle optional values
search_indexes = type_dict.get('search_indexes', [])
referenced_types = type_dict.get('referenced_types', [])
type_def = model.TypeDefinition(type_dict['id'],
type_dict['display_name'],
type_dict['description'],
type_dict['unit_key'], search_indexes,
referenced_types)
all_types.append(type_def)
return all_types
import base
import mock
from pulp.common import dateutils
from pulp.plugins.types import database, model
from pulp.server.db.model.criteria import Criteria, UnitAssociationCriteria
from pulp.server.db.model.repository import RepoContentUnit
import pulp.server.managers.repo.unit_association as association_manager
from pulp.server.managers.repo.unit_association import OWNER_TYPE_USER, OWNER_TYPE_IMPORTER
import pulp.server.managers.repo.unit_association_query as association_query_manager
import pulp.server.managers.content.cud as content_cud_manager
import pulp.server.managers.factory as manager_factory
# -- constants ----------------------------------------------------------------
TYPE_DEF_ALPHA = model.TypeDefinition('alpha', 'Alpha', 'Test Type Alpha',
['key_1'], ['search_1'], [])
TYPE_DEF_BETA = model.TypeDefinition('beta', 'Beta', 'Test Type Beta',
['key_1'], [], [])
TYPE_DEF_GAMMA = model.TypeDefinition('gamma', 'Gamma', 'Test Type Gamma',
['key_1'], [], [])
TYPE_DEF_DELTA = model.TypeDefinition('delta', 'Delta', 'Test Type Delta',
['key_1'], [], [])
TYPE_DEF_EPSILON = model.TypeDefinition('epsilon', 'Epsilon', 'Test Type Epsilon',
['key_1'], [], [])
_QUERY_TYPES = [TYPE_DEF_ALPHA, TYPE_DEF_BETA, TYPE_DEF_GAMMA, TYPE_DEF_DELTA, TYPE_DEF_EPSILON]
class UnitAssociationQueryTests(base.PulpServerTests):
def clean(self):
super(UnitAssociationQueryTests, self).clean()
from ... import base
from pulp.devel import mock_plugins
from pulp.plugins.conduits.mixins import ImporterConduitException
from pulp.plugins.conduits.repo_sync import RepoSyncConduit
from pulp.plugins.model import SyncReport
from pulp.server.db import model
from pulp.server.db.model.repository import RepoContentUnit
import pulp.plugins.types.database as types_database
import pulp.plugins.types.model as types_model
import pulp.server.managers.content.cud as content_manager
import pulp.server.managers.content.query as query_manager
import pulp.server.managers.repo.importer as importer_manager
import pulp.server.managers.repo.unit_association as association_manager
import pulp.server.managers.repo.unit_association_query as association_query_manager
TYPE_1_DEF = types_model.TypeDefinition('type_1', 'Type 1', 'One', ['key-1'],
['search-1'], ['type_2'])
TYPE_2_DEF = types_model.TypeDefinition('type_2', 'Type 2', 'Two',
['key-2a', 'key-2b'], [], ['type_1'])
class RepoSyncConduitTests(base.PulpServerTests):
def clean(self):
super(RepoSyncConduitTests, self).clean()
model.Repository.drop_collection()
RepoContentUnit.get_collection().remove()
@mock.patch('pulp.server.managers.repo.importer.model.Repository.objects')
def setUp(self, mock_repo_qs):
super(RepoSyncConduitTests, self).setUp()
mock_plugins.install()
types_database.update_database([TYPE_1_DEF, TYPE_2_DEF])
import mock
from .... import base
from pulp.common.compat import unittest
from pulp.devel import mock_plugins
from pulp.plugins.types import database, model
from pulp.server.controllers import importer as importer_controller
from pulp.server.db import model as me_model
from pulp.server.db.model.criteria import UnitAssociationCriteria
from pulp.server.db.model.repository import RepoContentUnit
import pulp.server.exceptions as exceptions
import pulp.server.managers.content.cud as content_cud_manager
import pulp.server.managers.factory as manager_factory
import pulp.server.managers.repo.unit_association as association_manager
TYPE_1_DEF = model.TypeDefinition('type-1', 'Type 1', 'Test Definition One',
['key-1'], ['search-1'], [])
TYPE_2_DEF = model.TypeDefinition('type-2', 'Type 2', 'Test Definition Two',
['key-2a', 'key-2b'], [], ['type-1'])
MOCK_TYPE_DEF = model.TypeDefinition('mock-type', 'Mock Type',
'Used by the mock importer', ['key-1'],
[], [])
@mock.patch('pulp.server.controllers.repository.find_repo_content_units',
spec_set=True)
class TestUnitsFromCriteria(unittest.TestCase):
def setUp(self):
super(TestUnitsFromCriteria, self).setUp()
self.manager = association_manager.RepoUnitAssociationManager()
from .... import base
from pulp.plugins.types import database, model
from pulp.server.managers.content.cud import ContentManager
from pulp.server.managers.content.query import ContentQueryManager
TYPE_1_DEF = model.TypeDefinition('type-1', 'Type 1', 'Test Definition One',
['key-1'], ['search-1'], [])
TYPE_2_DEF = model.TypeDefinition('type-2', 'Type 2', 'Test Definition Two',
['key-2a', 'key-2b'], [], ['type-1'])
TYPE_1_UNITS = [{
'key-1': 'A',
'search-1': 'one'
}, {
'key-1': 'B',
'search-1': 'one'
}, {
'key-1': 'C',
'search-1': 'two'
}]
TYPE_2_UNITS = [{
'key-2a': 'A',
'key-2b': 'A'
}, {
'key-2a': 'A',
'key-2b': 'B'
}, {
'key-2a': 'B',
'key-2b': 'A'
from .... import base
from pulp.devel import mock_plugins
from pulp.plugins.conduits.dependency import DependencyResolutionConduit
from pulp.plugins.config import PluginCallConfiguration
from pulp.plugins.types import database, model
from pulp.server.db.model.criteria import UnitAssociationCriteria
from pulp.server.db.model.repository import Repo, RepoImporter, RepoContentUnit
from pulp.server.exceptions import MissingResource
from pulp.server.managers import factory as manager_factory
TYPE_1_DEF = model.TypeDefinition('type-1', 'Type 1', 'Test Definition One',
['key-1'], ['search-1'], [])
class DependencyManagerTests(base.PulpServerTests):
def setUp(self):
super(DependencyManagerTests, self).setUp()
mock_plugins.install()
database.update_database([TYPE_1_DEF])
self.repo_id = 'dep-repo'
self.manager = manager_factory.dependency_manager()
manager_factory.repo_manager().create_repo(self.repo_id)
manager_factory.repo_importer_manager().set_importer(
self.repo_id, 'mock-importer', {})
def tearDown(self):
super(DependencyManagerTests, self).tearDown()
