Exemple #1
0
    def test_get_types(self):
        # Setup
        type_def_1 = TypeDefinition('type-1', 'Type 1', 'Type 1', [], [], [])
        type_def_2 = TypeDefinition('type-2', 'Type 2', 'Type 2', [], [], [])

        types_db._create_or_update_type(type_def_1)
        types_db._create_or_update_type(type_def_2)

        # Test
        status, body = self.get('/v2/plugins/types/')

        # Verify
        self.assertEqual(200, status)

        self.assertEqual(2, len(body))
        # the order isn't guaranteed, so we adjust here if necessary
        if body[0]['id'] == 'type-2':
            body.reverse()

        self.assertEqual(body[0]['_href'], '/v2/plugins/types/type-1/')
        self.assertEqual(body[0]['id'], 'type-1')
        self.assertEqual(body[0]['display_name'], 'Type 1')

        self.assertEqual(body[1]['_href'], '/v2/plugins/types/type-2/')
        self.assertEqual(body[1]['id'], 'type-2')
        self.assertEqual(body[1]['display_name'], 'Type 2')
Exemple #2
0
    def test_drop_indexes(self):
        """
        Tests updating indexes on an existing collection with different indexes correctly changes them.
        """

        # Setup
        old_key = ['compound_1', 'compound_2']

        type_def = TypeDefinition('rpm', 'RPM', 'RPM Packages', old_key, None,
                                  [])
        types_db._update_unit_key(type_def)

        # Test
        new_key = ['new_1']
        type_def.unit_key = new_key

        types_db._drop_indexes(type_def)
        types_db._update_unit_key(type_def)

        # Verify
        collection_name = types_db.unit_collection_name(type_def.id)
        collection = pulp_db.get_collection(collection_name)

        index_dict = collection.index_information()

        self.assertEqual(2, len(index_dict))  # default (_id) + new one
Exemple #3
0
    def test_create_or_update_existing_type_collection(self):
        """
        Tests calling create_or_update with a change to an existing type
        collection is successful.
        """

        # Setup
        type_def = TypeDefinition('rpm', 'RPM', 'RPM Packages', ['name'], ['name'], [])
        types_db._create_or_update_type(type_def)

        # Test
        type_def.display_name = 'new-name'
        type_def.description = 'new-description'
        type_def.unit_key = 'new-key'
        type_def.search_indexes = None
        types_db._create_or_update_type(type_def)

        # Verify

        #   Present in types collection
        all_types = list(ContentType.get_collection().find())
        self.assertEqual(1, len(all_types))

        found = all_types[0]
        self.assertEqual(type_def.id, found['id'])
        self.assertEqual(type_def.display_name, found['display_name'])
        self.assertEqual(type_def.description, found['description'])
        self.assertEqual(type_def.unit_key, found['unit_key'])
        self.assertEqual(type_def.search_indexes, found['search_indexes'])

        #   Type collection exists
        collection_name = types_db.unit_collection_name(type_def.id)
        self.assertTrue(collection_name in pulp_db.get_database().collection_names())
Exemple #4
0
    def test_types(self):
        """
        Tests retrieving all types in the database.
        """

        # Setup
        type_def_1 = TypeDefinition('type-1', 'Type 1', 'Type 1', [], [], [])
        type_def_2 = TypeDefinition('type-2', 'Type 2', 'Type 2', [], [], [])

        types_db._create_or_update_type(type_def_1)
        types_db._create_or_update_type(type_def_2)

        # Test
        found_defs = self.manager.types()

        # Verify
        self.assertEqual(2, len(found_defs))

        for type_def in [type_def_1, type_def_2]:
            found_def = [t for t in found_defs if t['id'] == type_def.id][0]

            self.assertEqual(found_def['id'], type_def.id)
            self.assertEqual(found_def['display_name'], type_def.display_name)
            self.assertEqual(found_def['description'], type_def.description)
            self.assertEqual(found_def['unit_key'], type_def.unit_key)
            self.assertEqual(found_def['search_indexes'],
                             type_def.search_indexes)
            self.assertEqual(found_def['referenced_types'],
                             type_def.referenced_types)
Exemple #5
0
    def test_create_or_update_existing_type_collection(self):
        """
        Tests calling create_or_update with a change to an existing type
        collection is successful.
        """

        # Setup
        type_def = TypeDefinition("rpm", "RPM", "RPM Packages", ["name"], ["name"], [])
        types_db._create_or_update_type(type_def)

        # Test
        type_def.display_name = "new-name"
        type_def.description = "new-description"
        type_def.unit_key = "new-key"
        type_def.search_indexes = None
        types_db._create_or_update_type(type_def)

        # Verify

        #   Present in types collection
        all_types = list(ContentType.get_collection().find())
        self.assertEqual(1, len(all_types))

        found = all_types[0]
        self.assertEqual(type_def.id, found["id"])
        self.assertEqual(type_def.display_name, found["display_name"])
        self.assertEqual(type_def.description, found["description"])
        self.assertEqual(type_def.unit_key, found["unit_key"])
        self.assertEqual(type_def.search_indexes, found["search_indexes"])

        #   Type collection exists
        collection_name = types_db.unit_collection_name(type_def.id)
        self.assertTrue(collection_name in pulp_db.get_database().collection_names())
Exemple #6
0
    def test_drop_indexes(self):
        """
        Tests updating indexes on an existing collection with different indexes correctly changes them.
        """

        # Setup
        old_key = ['compound_1', 'compound_2']

        type_def = TypeDefinition('rpm', 'RPM', 'RPM Packages', old_key, None, [])
        types_db._update_unit_key(type_def)

        # Test
        new_key = ['new_1']
        type_def.unit_key = new_key

        types_db._drop_indexes(type_def)
        types_db._update_unit_key(type_def)

        # Verify
        collection_name = types_db.unit_collection_name(type_def.id)
        collection = pulp_db.get_collection(collection_name)

        index_dict = collection.index_information()

        self.assertEqual(2, len(index_dict)) # default (_id) + new one
Exemple #7
0
    def test_update_unit_key_multiple_fields(self):
        """
        Tests that a multiple field unit key is built as a single, compound index
        """

        # Setup
        unit_key = ['compound_1', 'compound_2']
        type_def = TypeDefinition('rpm', 'RPM', 'RPM Packages', unit_key, None,
                                  [])

        # Test
        types_db._update_unit_key(type_def)

        # Verify
        collection_name = types_db.unit_collection_name(type_def.id)
        collection = pulp_db.get_collection(collection_name)

        index_dict = collection.index_information()

        self.assertEqual(2, len(index_dict))  # default (_id) + unit key

        index = index_dict['compound_1_1_compound_2_1']
        self.assertTrue(index['unique'])

        keys = index['key']
        self.assertEqual(2, len(keys))
        self.assertEqual('compound_1', keys[0][0])
        self.assertEqual(types_db.ASCENDING, keys[0][1])
        self.assertEqual('compound_2', keys[1][0])
        self.assertEqual(types_db.ASCENDING, keys[1][1])
Exemple #8
0
    def test_all_type_ids(self):
        """
        Tests listing all type IDs.
        """

        # Setup
        types_db._create_or_update_type(TypeDefinition('a', 'A', 'A', [], [], []))
        types_db._create_or_update_type(TypeDefinition('b', 'B', 'B', [], [], []))

        # Test
        type_ids = types_db.all_type_ids()

        # Verify
        self.assertEqual(2, len(type_ids))
        self.assertTrue('a' in type_ids)
        self.assertTrue('b' in type_ids)
Exemple #9
0
    def test_create_or_update_type_collection(self):
        """
        Tests the call to create a new type collection works.
        """

        # Setup
        type_def = TypeDefinition('rpm', 'RPM', 'RPM Packages', ['name'],
                                  ['name'], [])

        # Test
        types_db._create_or_update_type(type_def)

        # Verify

        #   Present in types collection
        all_types = list(ContentType.get_collection().find())
        self.assertEqual(1, len(all_types))

        found = all_types[0]
        self.assertEqual(type_def.id, found['id'])
        self.assertEqual(type_def.display_name, found['display_name'])
        self.assertEqual(type_def.description, found['description'])
        self.assertEqual(type_def.unit_key, found['unit_key'])
        self.assertEqual(type_def.search_indexes, found['search_indexes'])

        #   Type collection exists
        collection_name = types_db.unit_collection_name(type_def.id)
        self.assertTrue(
            collection_name in pulp_db.database().collection_names())
Exemple #10
0
    def test_update_unit_key_single_field(self):
        """
        Tests a single field unit key is handled correctly.
        """

        # Setup
        unit_key = 'individual_1',
        type_def = TypeDefinition('rpm', 'RPM', 'RPM Packages', unit_key, None,
                                  [])

        # Test
        types_db._update_unit_key(type_def)

        # Verify
        collection_name = types_db.unit_collection_name(type_def.id)
        collection = pulp_db.get_collection(collection_name)

        index_dict = collection.index_information()

        self.assertEqual(2, len(index_dict))  # default (_id) + unit key

        index = index_dict['individual_1_1']
        self.assertTrue(index['unique'])

        keys = index['key']
        self.assertEqual(1, len(keys))
        self.assertEqual('individual_1', keys[0][0])
        self.assertEqual(types_db.ASCENDING, keys[0][1])
Exemple #11
0
    def test_create_or_update_existing_type_collection(self):
        """
        Tests calling create_or_update with a change to an existing type
        collection is successful.
        """

        # Setup
        type_def = TypeDefinition('rpm', 'RPM', 'RPM Packages', ['name'],
                                  ['name'], [])
        types_db._create_or_update_type(type_def)

        # Test
        type_def.display_name = 'new-name'
        type_def.description = 'new-description'
        type_def.unit_key = 'new-key'
        type_def.search_indexes = None
        types_db._create_or_update_type(type_def)

        # Verify

        #   Present in types collection
        all_types = list(ContentType.get_collection().find())
        self.assertEqual(1, len(all_types))

        found = all_types[0]
        self.assertEqual(type_def.id, found['id'])
        self.assertEqual(type_def.display_name, found['display_name'])
        self.assertEqual(type_def.description, found['description'])
        self.assertEqual(type_def.unit_key, found['unit_key'])
        self.assertEqual(type_def.search_indexes, found['search_indexes'])

        #   Type collection exists
        collection_name = types_db.unit_collection_name(type_def.id)
        self.assertTrue(
            collection_name in pulp_db.database().collection_names())
Exemple #12
0
    def test_get_type(self):
        # Setup
        type_def_1 = TypeDefinition('type-1', 'Type 1', 'Type 1', [], [], [])
        types_db._create_or_update_type(type_def_1)

        # Test
        status, body = self.get('/v2/plugins/types/type-1/')

        # Verify
        self.assertEqual(200, status)

        self.assertEqual(body['_href'], '/v2/plugins/types/type-1/')
        self.assertEqual(body['id'], 'type-1')
        self.assertEqual(body['display_name'], 'Type 1')
Exemple #13
0
    def test_type_units_unit_key(self):
        """
        Tests the syntactic sugar method for retrieving unit key on a type.
        """

        # Setup
        type_def = TypeDefinition('rpm', 'RPM', 'RPM Packages', ['unique_1', 'unique_2'], ['name'], [])
        types_db._create_or_update_type(type_def)

        # Test
        unit_key = types_db.type_units_unit_key('rpm')

        # Verify
        self.assertEqual(type_def.unit_key, unit_key)
Exemple #14
0
    def test_all_type_collection_names(self):
        """
        Tests listing all type collections.
        """

        # Setup
        type_def = TypeDefinition('rpm', 'RPM', 'RPM Packages', ['name'], ['name'], [])
        types_db._create_or_update_type(type_def)

        # Test
        all_names = types_db.all_type_collection_names()

        # Verify
        self.assertEqual(1, len(all_names))
        self.assertEqual(types_db.unit_collection_name(type_def.id), all_names[0])
Exemple #15
0
    def test_update_failed_create(self):
        """
        Simulates a failure to create a collection by passing in a bad ID for
        the definition.
        """

        # Setup
        busted = TypeDefinition('!@#$%^&*()', 'Busted', 'Busted', None, None, [])
        defs = [DEF_1, busted]

        # Tests
        try:
            types_db.update_database(defs)
            self.fail('Update with a failed create did not raise exception')
        except types_db.UpdateFailed, e:
            self.assertEqual(1, len(e.type_definitions))
            self.assertEqual(busted, e.type_definitions[0])
            print(e)
Exemple #16
0
    def test_check_content_definitions_nothing_old(self, mock_type_definition, mock_parser):
        """
        Test that when the content type from the database matches the TypeDefinition,
        an empty list is returned.
        """
        fake_type = {
            'id': 'steve_holt',
            'display_name': 'STEVE HOLT!',
            'description': 'STEVE HOLT!',
            'unit_key': ['STEVE HOLT!'],
            'search_indexes': ['STEVE HOLT!'],
            'referenced_types': ['STEVE HOLT!'],
        }
        mock_type_definition.return_value = fake_type
        type_definition = TypeDefinition('steve_holt', 'STEVE HOLT!', 'STEVE HOLT!', 'STEVE HOLT!',
                                         'STEVE HOLT!', 'STEVE HOLT!')

        result = api._check_content_definitions([type_definition])
        self.assertEquals(0, len(result))
Exemple #17
0
    def test_update_search_indexes(self):
        """
        Tests that the unique index creation on a new collection is successful.
        This will test both single key and compound indexes to ensure mongo
        handles them successfully.
        """

        # Setup
        search_indexes = [
            ['compound_1', 'compound_2'],
            'individual_1'
        ]
        type_def = TypeDefinition('rpm', 'RPM', 'RPM Packages', None, search_indexes, [])

        # Test
        types_db._update_search_indexes(type_def)

        # Verify
        collection_name = types_db.unit_collection_name(type_def.id)
        collection = pulp_db.get_collection(collection_name)

        index_dict = collection.index_information()

        self.assertEqual(3, len(index_dict)) # default (_id) + definition ones

        #   Verify individual index
        index = index_dict['individual_1_1']

        keys = index['key']
        self.assertEqual(1, len(keys))
        self.assertEqual('individual_1', keys[0][0])
        self.assertEqual(types_db.ASCENDING, keys[0][1])

        #   Verify compound index
        index = index_dict['compound_1_1_compound_2_1']

        keys = index['key']
        self.assertEqual(2, len(keys))
        self.assertEqual('compound_1', keys[0][0])
        self.assertEqual(types_db.ASCENDING, keys[0][1])
        self.assertEqual('compound_2', keys[1][0])
        self.assertEqual(types_db.ASCENDING, keys[1][1])
Exemple #18
0
def _generate_plugin_definitions():
    """
    Use entry points to get the information about available content unit types

    :return: A list of content unit types
    :rtype:  list of TypeDefinition
    """
    definitions = []
    plugin_manager = PluginManager()
    for unit_type, model_class in plugin_manager.unit_models.items():
        content_type_id = unit_type
        display_name = getattr(model_class, 'unit_display_name', unit_type)
        description = getattr(model_class, 'unit_description', '')
        referenced_types = getattr(model_class, 'unit_referenced_types', [])
        unit_key = list(getattr(model_class, 'unit_key_fields', []))
        search_indexes = list(model_class._meta.get('indexes', []))
        definition = TypeDefinition(content_type_id, display_name, description,
                                    unit_key, search_indexes, referenced_types)
        definitions.append(definition)
    return definitions
Exemple #19
0
    def test_check_content_definitions_old(self, mock_type_definition):
        """
        Test that when the content type from the database doesn't match the TypeDefinition,
        the list contains that content type.
        """
        fake_type = {
            'id': 'gob',
            'display_name': 'Trickster',
            'description': 'Trickster',
            'unit_key': ['Trickster'],
            'search_indexes': ['Trickster'],
            'referenced_types': ['Trickster'],
        }
        mock_type_definition.return_value = fake_type
        type_definition = TypeDefinition('gob', 'STEVE HOLT!', 'STEVE HOLT!', 'STEVE HOLT!',
                                         'STEVE HOLT!', 'STEVE HOLT!')

        result = api._check_content_definitions([type_definition])
        self.assertEquals(1, len(result))
        self.assertEquals(result[0], type_definition)
Exemple #20
0
import mock

from pulp.plugins.types import database as types_db
from pulp.plugins.types.model import TypeDefinition
from pulp.server.db import model
from pulp.server.db.connection import get_collection
from pulp.server.db.model.repository import RepoContentUnit
from pulp.server.db.migrate.models import _import_all_the_way
from pulp.server.managers import factory

from pulp_rpm.common import ids
from pulp_rpm.devel import rpm_support_base
from pulp.plugins.loader import api

# Trimmed down versions of the type defs
TYPE_DEF_GROUP = TypeDefinition('package_group', '', '', ['id', 'repo_id'], [],
                                [])
TYPE_DEF_CATEGORY = TypeDefinition('package_category', '', '',
                                   ['id', 'repo_id'], [], [])


class Migration0004Tests(rpm_support_base.PulpRPMTests):
    def setUp(self):
        super(Migration0004Tests, self).setUp()

        # Special way to import modules that start with a number
        self.migration = _import_all_the_way(
            'pulp_rpm.plugins.migrations.0004_pkg_group_category_repoid')

        factory.initialize()
        api.initialize(False)
        types_db.update_database([TYPE_DEF_GROUP, TYPE_DEF_CATEGORY])
Exemple #21
0
import tempfile
import traceback
from pprint import pformat

import base

from pulp.server import exceptions as pulp_exceptions
from pulp.plugins.types import database as content_type_db
from pulp.plugins.types.model import TypeDefinition
from pulp.server.db.model.repository import RepoContentUnit
from pulp.server.managers import factory as manager_factory
from pulp.server.managers.content.orphan import OrphanManager

# globals and constants --------------------------------------------------------

PHONY_TYPE_1 = TypeDefinition('phony_type_1', 'Phony Type 1', None, 'name', [],
                              [])
PHONY_TYPE_2 = TypeDefinition('phony_type_2', 'Phony Type 2', None, 'name', [],
                              [])

PHONY_REPO_ID = 'phony_repo'
PHONY_USER_ID = 'orphan_manager_unittests'

# content generation -----------------------------------------------------------


def gen_content_unit(content_type_id, content_root, name=None):
    name = name or ''.join(random.sample(string.ascii_letters, 5))
    path = os.path.join(content_root, name)
    file = open(path, mode='w')
    file.write('')
    file.close()
Exemple #22
0
class BaseProfilerConduitTests(base.PulpServerTests):

    CONSUMER_ID = 'test-consumer'
    REPO_ID = 'test-repo'
    DISTRIBUTOR_ID = 'test-distributor'
    NOTIFY_AGENT = True
    BINDING_CONFIG = {'x': 'x'}
    TYPE_1_DEF = TypeDefinition('type-1', 'Type 1', 'One', ['key-1'], [], [])
    TYPE_2_DEF = TypeDefinition('type-2', 'Type 2', 'Two', ['key-2'], [], [])
    PROFILE = {'name': 'zsh', 'version': '1.0'}
    UNIT_ID = 0

    def setUp(self):
        super(BaseProfilerConduitTests, self).setUp()
        Consumer.get_collection().remove()
        Repo.get_collection().remove()
        RepoDistributor.get_collection().remove()
        Bind.get_collection().remove()
        RepoContentUnit.get_collection().remove()
        UnitProfile.get_collection().remove()
        plugin_api._create_manager()
        typedb.update_database([self.TYPE_1_DEF, self.TYPE_2_DEF])
        mock_plugins.install()

    def tearDown(self):
        super(BaseProfilerConduitTests, self).tearDown()
        Consumer.get_collection().remove()
        Repo.get_collection().remove()
        RepoDistributor.get_collection().remove()
        Bind.get_collection().remove()
        RepoContentUnit.get_collection().remove()
        UnitProfile.get_collection().remove()
        typedb.clean()
        factory.reset()
        mock_plugins.reset()

    def populate(self, additional_key=None):
        self.populate_consumer()
        self.populate_repository()
        self.populate_bindings()
        self.populate_units('key-1', self.TYPE_1_DEF, additional_key)
        self.populate_units('key-2', self.TYPE_2_DEF, additional_key)
        self.populate_profile()

    def populate_consumer(self):
        manager = factory.consumer_manager()
        manager.register(self.CONSUMER_ID)

    def populate_repository(self):
        config = {'key1': 'value1', 'key2': None}
        manager = factory.repo_manager()
        manager.create_repo(self.REPO_ID)
        manager = factory.repo_distributor_manager()
        manager.add_distributor(self.REPO_ID,
                                'mock-distributor',
                                config,
                                True,
                                distributor_id=self.DISTRIBUTOR_ID)

    def populate_bindings(self):
        manager = factory.consumer_bind_manager()
        manager.bind(self.CONSUMER_ID, self.REPO_ID, self.DISTRIBUTOR_ID,
                     self.NOTIFY_AGENT, self.BINDING_CONFIG)

    def populate_units(self, key, typedef, additional_key=None):
        for i in range(1, 10):
            unit_id = 'unit-%s' % self.UNIT_ID
            md = {key: str(i)}
            if additional_key:
                md[additional_key] = str(i)
            manager = factory.content_manager()
            manager.add_content_unit(typedef.id, unit_id, md)
            manager = factory.repo_unit_association_manager()
            manager.associate_unit_by_id(self.REPO_ID, typedef.id, unit_id)
            self.UNIT_ID += 1

    def populate_profile(self):
        manager = factory.consumer_profile_manager()
        manager.update(self.CONSUMER_ID, self.TYPE_1_DEF.id, self.PROFILE)

    def test_get_bindings(self):
        # Setup
        self.populate()
        # Test
        conduit = ProfilerConduit()
        binds = conduit.get_bindings(self.CONSUMER_ID)
        # Verify
        self.assertEquals(1, len(binds))
        self.assertTrue(binds[0], self.REPO_ID)

    def test_get_units(self):
        # Setup
        self.populate()
        # Test
        conduit = ProfilerConduit()
        criteria = UnitAssociationCriteria(type_ids=[self.TYPE_1_DEF.id])
        units = conduit.get_units(self.REPO_ID, criteria)
        # Verify
        self.assertEquals(len(units), 9)

    def test_get_repo_units(self):
        # Setup
        self.populate()
        # Test
        conduit = ProfilerConduit()
        units1 = conduit.get_repo_units(self.REPO_ID,
                                        content_type_id=self.TYPE_1_DEF.id,
                                        additional_unit_fields=[])
        units2 = conduit.get_repo_units(self.REPO_ID,
                                        content_type_id=self.TYPE_2_DEF.id,
                                        additional_unit_fields=[])

        # Verify that all the units in the repo with given type are returned along with unit_key
        self.assertEquals(len(units1), 9)
        for u in units1:
            self.assertTrue('key-1' in u.unit_key)
            self.assertFalse('key-2' in u.unit_key)
        self.assertEquals(len(units2), 9)
        for u in units2:
            self.assertTrue('key-2' in u.unit_key)
            self.assertFalse('key-1' in u.unit_key)

    def test_get_repo_units_additional_field(self):
        # Setup
        self.populate(additional_key='extra_field')
        # Test
        conduit = ProfilerConduit()
        units = conduit.get_repo_units(self.REPO_ID,
                                       content_type_id=self.TYPE_1_DEF.id,
                                       additional_unit_fields=['extra_field'])

        # Verify that all the units in the repo with given type are returned along with unit_key and
        # extra field
        self.assertEquals(len(units), 9)
        for u in units:
            self.assertTrue('key-1' in u.unit_key)
            self.assertTrue('extra_field' in u.metadata)
Exemple #23
0
# There is NO WARRANTY for this software, express or implied,
# including the implied warranties of MERCHANTABILITY,
# NON-INFRINGEMENT, or FITNESS FOR A PARTICULAR PURPOSE. You should
# have received a copy of GPLv2 along with this software; if not, see
# http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.

import base

import pulp.plugins.types.database as types_db
from pulp.plugins.types.model import TypeDefinition
from pulp.server.db.model.content import ContentType
import pulp.server.db.connection as pulp_db

# -- constants -----------------------------------------------------------------

DEF_1 = TypeDefinition('def_1', 'Definition 1', 'Test definition', 'single_1',
                       ['search_1'], [])
DEF_2 = TypeDefinition('def_2', 'Definition 2', 'Test definition',
                       ['single_1'], ['search_1'], [])
DEF_3 = TypeDefinition('def_3', 'Definition 3', 'Test definition',
                       ['compound_1', 'compound_2'], ['search_1'], [])
DEF_4 = TypeDefinition('def_4', 'Definition 4', 'Test definition', 'single_1',
                       ['search_1'], [])

# -- test cases ----------------------------------------------------------------


class TypesDatabaseTests(base.PulpServerTests):
    def clean(self):
        super(TypesDatabaseTests, self).clean()
        types_db.clean()