Beispiel #1
0
    def test_positive_update_interval(self):
        """Create a sync plan and update its interval.

        :id: cf2eddf8-b4db-430e-a9b0-83c626b45068

        :expectedresults: A sync plan is created and its interval can be
            updated with the specified interval.

        :CaseImportance: Critical
        """
        for interval in valid_sync_interval():
            sync_plan = entities.SyncPlan(description=gen_string('alpha'),
                                          organization=self.org,
                                          interval=interval)
            if interval == SYNC_INTERVAL['custom']:
                sync_plan.cron_expression = gen_choice(
                    valid_cron_expressions())
            sync_plan = sync_plan.create()

            valid_intervals = valid_sync_interval()
            self.assertIn(interval, valid_intervals)
            valid_intervals.remove(interval)
            new_interval = gen_choice(valid_intervals)
            sync_plan.interval = new_interval
            if new_interval == SYNC_INTERVAL['custom']:
                sync_plan.cron_expression = gen_choice(
                    valid_cron_expressions())
                sync_plan = sync_plan.update(['interval', 'cron_expression'])
            else:
                sync_plan = sync_plan.update(['interval'])
            self.assertEqual(sync_plan.interval, new_interval)
Beispiel #2
0
def test_positive_CRUD(default_os):
    """Create a new Architecture with several attributes, update the name
    and delete the Architecture itself.

    :id: 80bca2c0-a6a1-4676-a036-bd918812d600

    :expectedresults: Architecture should be created, modified and deleted successfully
        with given attributes.

    :CaseImportance: Critical
    """

    # Create
    name = gen_choice(list(valid_data_list().values()))
    arch = entities.Architecture(name=name,
                                 operatingsystem=[default_os]).create()
    assert {default_os.id} == {os.id for os in arch.operatingsystem}
    assert name == arch.name

    # Update
    name = gen_choice(list(valid_data_list().values()))
    arch = entities.Architecture(id=arch.id, name=name).update(['name'])
    assert name == arch.name

    # Delete
    arch.delete()
    with pytest.raises(HTTPError):
        arch.read()
Beispiel #3
0
def generate_system_facts(name=None):
    """Generate random system facts for registration.

    :param str name: A valid FQDN for a system. If one is not
        provided, then a random value will be generated.
    :return: A dictionary with random system facts
    :rtype: dict
    """
    if name is None:
        name = f'{gen_alpha().lower()}.example.net'

    # Make a copy of the system facts 'template'
    new_facts = copy.deepcopy(SYSTEM_FACTS)
    # Select a random RHEL version...
    distro = gen_choice(DISTRO_IDS)

    # ...and update our facts
    new_facts['distribution.id'] = distro['id']
    new_facts['distribution.version'] = distro['version']
    new_facts['dmi.bios.relase_date'] = _bios_date().strftime('%m/%d/%Y')
    new_facts['dmi.memory.maximum_capacity'] = gen_choice(MEMORY_CAPACITY)
    new_facts['dmi.memory.size'] = gen_choice(MEMORY_SIZE)
    new_facts['dmi.system.uuid'] = gen_uuid()
    new_facts['dmi.system.version'] = 'RHEL'
    new_facts['lscpu.architecture'] = distro['architecture']
    new_facts['net.interface.eth1.hwaddr'] = gen_mac(multicast=False)
    new_facts['net.interface.eth1.ipaddr'] = gen_ipaddr()
    new_facts['network.hostname'] = name
    new_facts['network.ipaddr'] = new_facts['net.interface.eth1.ipaddr']
    new_facts['uname.machine'] = distro['architecture']
    new_facts['uname.nodename'] = name
    new_facts['uname.release'] = distro['kernel']
    new_facts['virt.uuid'] = new_facts['dmi.system.uuid']

    return new_facts
Beispiel #4
0
def test_positive_update_interval(module_org, interval):
    """Create a sync plan and update its interval.

    :id: cf2eddf8-b4db-430e-a9b0-83c626b45068

    :parametrized: yes

    :expectedresults: A sync plan is created and its interval can be
        updated with the specified interval.

    :CaseImportance: Critical
    """
    sync_plan = entities.SyncPlan(description=gen_string('alpha'),
                                  organization=module_org,
                                  interval=interval)
    if interval == SYNC_INTERVAL['custom']:
        sync_plan.cron_expression = gen_choice(valid_cron_expressions())
    sync_plan = sync_plan.create()
    # get another random interval and workaround issue #7231
    new_interval = gen_choice(valid_sync_interval())
    while new_interval == interval:
        new_interval = gen_choice(valid_sync_interval())
    sync_plan.interval = new_interval
    if new_interval == SYNC_INTERVAL['custom']:
        sync_plan.cron_expression = gen_choice(valid_cron_expressions())
        sync_plan = sync_plan.update(['interval', 'cron_expression'])
    else:
        sync_plan = sync_plan.update(['interval'])
    sync_plan = sync_plan.read()
    assert sync_plan.interval == new_interval
Beispiel #5
0
    def test_positive_update_interval(self):
        """Create a sync plan and update its interval.

        :id: cf2eddf8-b4db-430e-a9b0-83c626b45068

        :expectedresults: A sync plan is created and its interval can be
            updated with the specified interval.

        :CaseImportance: Critical
        """
        for interval in valid_sync_interval():
            sync_plan = entities.SyncPlan(
                description=gen_string('alpha'),
                organization=self.org,
                interval=interval
            )
            if interval == SYNC_INTERVAL['custom']:
                sync_plan.cron_expression = gen_choice(valid_cron_expressions())
            sync_plan = sync_plan.create()

            valid_intervals = valid_sync_interval()
            valid_intervals.remove(interval)
            new_interval = gen_choice(valid_intervals)
            sync_plan.interval = new_interval
            if new_interval == SYNC_INTERVAL['custom']:
                sync_plan.cron_expression = gen_choice(valid_cron_expressions())
                sync_plan = sync_plan.update(['interval', 'cron_expression'])
            else:
                sync_plan = sync_plan.update(['interval'])
            self.assertEqual(sync_plan.interval, new_interval)
Beispiel #6
0
def test_positive_update_interval(module_org, interval):
    """Create a sync plan and update its interval.

    :id: cf2eddf8-b4db-430e-a9b0-83c626b45068

    :parametrized: yes

    :expectedresults: A sync plan is created and its interval can be
        updated with the specified interval.

    :CaseImportance: Critical
    """
    sync_plan = entities.SyncPlan(description=gen_string('alpha'),
                                  organization=module_org,
                                  interval=interval)
    if interval == SYNC_INTERVAL['custom']:
        sync_plan.cron_expression = gen_choice(valid_cron_expressions())
    sync_plan = sync_plan.create()
    # ensure "new interval" not equal to "interval"
    new_interval = 'hourly' if interval != 'hourly' else 'daily'
    sync_plan.interval = new_interval
    if new_interval == SYNC_INTERVAL['custom']:
        sync_plan.cron_expression = gen_choice(valid_cron_expressions())
        sync_plan = sync_plan.update(['interval', 'cron_expression'])
    else:
        sync_plan = sync_plan.update(['interval'])
    sync_plan = sync_plan.read()
    assert sync_plan.interval == new_interval
def test_positive_end_to_end_crud(module_org, module_location,
                                  module_hostgroup):
    """Create a new discovery rule with several attributes, update them
    and delete the rule itself.

    :id: 25366930-b7f4-4db8-a9c3-a470fe4f3583

    :expectedresults: Rule should be created, modified and deleted successfully
        with given attributes.

    :CaseImportance: Critical
    """
    # Create discovery rule
    searches = [
        'CPU_Count = 1',
        'disk_count < 5',
        'memory > 500',
        'model = KVM',
        'Organization = Default_Organization',
    ]
    name = gen_choice(list(valid_data_list().values()))
    search = gen_choice(searches)
    hostname = 'myhost-<%= rand(99999) %>'
    discovery_rule = entities.DiscoveryRule(
        name=name,
        search_=search,
        hostname=hostname,
        organization=[module_org],
        location=[module_location],
        hostgroup=module_hostgroup,
    ).create()
    assert name == discovery_rule.name
    assert hostname == discovery_rule.hostname
    assert search == discovery_rule.search_
    assert module_org.name == discovery_rule.organization[0].read().name
    assert module_location.name == discovery_rule.location[0].read().name
    assert discovery_rule.enabled is True

    # Update discovery rule
    name = gen_choice(list(valid_data_list().values()))
    search = 'Location = Default_Location'
    max_count = gen_integer(1, 100)
    enabled = False
    discovery_rule.name = name
    discovery_rule.search_ = search
    discovery_rule.max_count = max_count
    discovery_rule.enabled = enabled
    discovery_rule = discovery_rule.update(
        ['name', 'search_', 'max_count', 'enabled'])
    assert name == discovery_rule.name
    assert search == discovery_rule.search_
    assert max_count == discovery_rule.max_count
    assert enabled == discovery_rule.enabled

    # Delete discovery rule
    discovery_rule.delete()
    with pytest.raises(HTTPError):
        discovery_rule.read()
    def test_gen_choice_13(self):
        """
        @Test: Cannot use None for Choice generator
        @Feature: Choice Generator
        @Assert: ValueError is raised
        """

        choices = None

        with self.assertRaises(ValueError):
            gen_choice(choices)
    def test_gen_choice_10(self):
        """
        @Test: Select a random value from single dictionary
        @Feature: Choice Generator
        @Assert: No choice from single dictionary
        """

        choices = {'Name': 'Bob', 'Age': 39}

        with self.assertRaises(ValueError):
            gen_choice(choices)
Beispiel #10
0
    def test_gen_choice_13(self):
        """
        @Test: Cannot use None for Choice generator
        @Feature: Choice Generator
        @Assert: ValueError is raised
        """

        choices = None

        with self.assertRaises(ValueError):
            gen_choice(choices)
    def test_gen_choice_8(self):
        """
        @Test: Select a random value from empty tuple
        @Feature: Choice Generator
        @Assert: No choice from empty tuple
        """

        choices = ()

        with self.assertRaises(ValueError):
            gen_choice(choices)
Beispiel #12
0
    def test_gen_choice_10(self):
        """
        @Test: Select a random value from single dictionary
        @Feature: Choice Generator
        @Assert: No choice from single dictionary
        """

        choices = {'Name': 'Bob', 'Age': 39}

        with self.assertRaises(ValueError):
            gen_choice(choices)
Beispiel #13
0
    def test_gen_choice_8(self):
        """
        @Test: Select a random value from empty tuple
        @Feature: Choice Generator
        @Assert: No choice from empty tuple
        """

        choices = ()

        with self.assertRaises(ValueError):
            gen_choice(choices)
Beispiel #14
0
    def test_gen_choice_9(self):
        """
        @Test: Select a random value from empty dictionary
        @Feature: Choice Generator
        @Assert: No choice from empty dictionary
        """

        choices = {}

        with self.assertRaises(ValueError):
            gen_choice(choices)
    def test_gen_choice_9(self):
        """
        @Test: Select a random value from empty dictionary
        @Feature: Choice Generator
        @Assert: No choice from empty dictionary
        """

        choices = {}

        with self.assertRaises(ValueError):
            gen_choice(choices)
Beispiel #16
0
    def test_gen_choice_11(self):
        """
        @Test: Select a random value from dictionary list
        @Feature: Choice Generator
        @Assert: Selects a value from a list of dictionaries
        """

        choices = [
            {
                'Name': 'Bob',
                'Age': 39
            },
            {
                'Name': 'Alice',
                'Age': 23
            },
            {
                'Name': 'Pete',
                'Age': 79
            },
        ]

        for turn in range(10):
            result = gen_choice(choices)
            self.assertIn(
                result, choices,
                "An invalid value was selected from available choices.")
    def test_create_cvf_with_different_names(self, name):
        """Test: Create new content view filter and assign it to existing
        content view by id. Use different value types as a name and random
        filter content type as a parameter for this filter

        @Feature: Content View Filter

        @Assert: Content view filter created successfully and has correct and
        expected parameters

        """
        filter_content_type = gen_choice(['rpm', 'package_group', 'erratum'])
        result = ContentView.filter_create({
            'content-view-id': self.content_view['id'],
            'type': filter_content_type,
            'name': name,
        })
        self.assertEqual(result.return_code, 0)
        self.assertEqual(len(result.stderr), 0)

        result = ContentView.filter_info({
            u'content-view-id': self.content_view['id'],
            u'name': name
        })
        self.assertEqual(result.return_code, 0)
        self.assertEqual(result.stdout['name'], name)
        self.assertEqual(result.stdout['type'], filter_content_type)
def test_post_sync_plan_migration(pre_upgrade_data):
    """Post-upgrade scenario that tests existing sync plans are working as
    expected after satellite upgrade with migrating from pulp to katello

    :id: 61f65f5d-351c-4aa4-83dc-71afae5dc1e0

    :steps:
        1. Verify sync plan exists and works as earlier

    :expectedresults: Post Upgrade, Sync plans exists and works as earlier.

     """
    org = entities.Organization(id=pre_upgrade_data.get('org_id'))
    product = entities.Product(id=pre_upgrade_data.get("product_id")).read()
    sync_plan = entities.SyncPlan(id=pre_upgrade_data.get("sync_plan_id"),
                                  organization=org).read()
    assert product.sync_plan.id == sync_plan.id
    assert sync_plan.name == pre_upgrade_data.get("sync_plan_name")
    assert sync_plan.interval == pre_upgrade_data.get("interval")
    assert sync_plan.sync_date == pre_upgrade_data.get("sync_date")
    # checking sync plan update on upgraded satellite
    sync_plan.interval = SYNC_INTERVAL['custom']
    sync_plan.cron_expression = gen_choice(valid_cron_expressions())
    assert (sync_plan.update(['interval', 'cron_expression'
                              ]).interval == SYNC_INTERVAL['custom'])
    # checking sync plan delete on upgraded satellite
    sync_plan.delete()
    product = product.read()
    assert product.sync_plan is None
    with raises(HTTPError):
        sync_plan.read()
Beispiel #19
0
def test_post_sync_plan_migration(pre_upgrade_data):
    """Post-upgrade scenario that tests existing sync plans are working as
    expected after satellite upgrade with migrating from pulp to katello

    :id: 61f65f5d-351c-4aa4-83dc-71afae5dc1e0

    :steps:
        1. Verify sync plan exists and works as earlier

    :expectedresults: Post Upgrade, Sync plans exists and works as earlier.

     """
    org = entities.Organization(id=pre_upgrade_data.get('org_id'))
    product = entities.Product(id=pre_upgrade_data.get("product_id")).read()
    sync_plan = entities.SyncPlan(id=pre_upgrade_data.get("sync_plan_id"),
                                  organization=org).read()
    assert product.sync_plan.id == sync_plan.id
    assert sync_plan.name == pre_upgrade_data.get("sync_plan_name")
    assert sync_plan.interval == pre_upgrade_data.get("interval")
    assert sync_plan.sync_date == pre_upgrade_data.get("sync_date")
    # checking sync plan update on upgraded satellite
    sync_plan.interval = SYNC_INTERVAL['custom']
    sync_plan.cron_expression = gen_choice(valid_cron_expressions())
    assert (sync_plan.update(['interval', 'cron_expression']).interval
            == SYNC_INTERVAL['custom'])
    # checking sync plan delete on upgraded satellite
    sync_plan.delete()
    product = product.read()
    assert product.sync_plan is None
    with raises(HTTPError):
        sync_plan.read()
Beispiel #20
0
    def create_missing(self):
        """Automagically populate all required instance attributes.

        Iterate through the set of all required class
        :class:`nailgun.entity_fields.Field` defined on ``type(self)`` and
        create a corresponding instance attribute if none exists. Subclasses
        should override this method if there is some relationship between two
        required fields.

        :return: Nothing. This method relies on side-effects.

        """
        for field_name, field in self.get_fields().items():
            if field.required and not hasattr(self, field_name):
                # Most `gen_value` methods return a value such as an integer,
                # string or dictionary, but OneTo{One,Many}Field.gen_value
                # returns the referenced class.
                if hasattr(field, 'default'):
                    value = field.default
                elif hasattr(field, 'choices'):
                    value = gen_choice(field.choices)
                elif isinstance(field, OneToOneField):
                    value = field.gen_value()(self._server_config).create(True)
                elif isinstance(field, OneToManyField):
                    value = [
                        field.gen_value()(self._server_config).create(True)
                    ]
                else:
                    value = field.gen_value()
                setattr(self, field_name, value)
    def test_positive_create_with_name_by_cv_id(self):
        """Create new content view filter and assign it to existing content
        view by id. Use different value types as a name and random filter
        content type as a parameter for this filter

        :id: 2cfdf72e-179d-4bba-8aab-288594cac836

        :expectedresults: Content view filter created successfully and has
            correct and expected parameters


        :CaseImportance: Critical
        """
        for name in valid_data_list():
            with self.subTest(name):
                filter_content_type = gen_choice([
                    'rpm',
                    'package_group',
                    'erratum',
                ])
                ContentView.filter.create({
                    'content-view-id': self.content_view['id'],
                    'name': name,
                    'organization-id': self.org['id'],
                    'type': filter_content_type,
                })
                cvf = ContentView.filter.info({
                    u'content-view-id': self.content_view['id'],
                    u'name': name,
                })
                self.assertEqual(cvf['name'], name)
                self.assertEqual(cvf['type'], filter_content_type)
    def test_positive_create_with_name_by_cv_id(self):
        """Test: Create new content view filter and assign it to existing
        content view by id. Use different value types as a name and random
        filter content type as a parameter for this filter

        @Feature: Content View Filter

        @Assert: Content view filter created successfully and has correct and
        expected parameters

        """
        for name in valid_data_list():
            with self.subTest(name):
                filter_content_type = gen_choice([
                    'rpm',
                    'package_group',
                    'erratum',
                ])
                ContentView.filter_create({
                    'content-view-id': self.content_view['id'],
                    'name': name,
                    'type': filter_content_type,
                })
                cvf = ContentView.filter_info({
                    u'content-view-id': self.content_view['id'],
                    u'name': name,
                })
                self.assertEqual(cvf['name'], name)
                self.assertEqual(cvf['type'], filter_content_type)
Beispiel #23
0
    def create_missing(self, auth=None):
        """Automagically populate all required instance attributes.

        Iterate through the set of all required class ``Field`` defined on
        ``type(self)`` and create a corresponding instance attribute if none
        exists. Subclasses should override this method if there is some
        relationship between two required fields.

        :param tuple auth: Same as :meth:`create_raw`.
        :return: Nothing. This method relies on side-effects.

        """
        for field_name, field in self.get_fields().items():
            if field.required and field_name not in vars(self):
                # Most `gen_value` methods return a value such as an integer,
                # string or dictionary, but OneTo{One,Many}Field.gen_value
                # returns an instance of the referenced class.
                if hasattr(field, 'default'):
                    value = field.default
                elif hasattr(field, 'choices'):
                    value = gen_choice(field.choices)
                elif isinstance(field, OneToOneField):
                    value = field.gen_value().create_json(auth=auth)['id']
                elif isinstance(field, OneToManyField):
                    value = [field.gen_value().create_json(auth=auth)['id']]
                else:
                    value = field.gen_value()
                setattr(self, field_name, value)
    def test_post_sync_plan_migration(self):
        """Post-upgrade scenario that tests existing sync plans are working as
        expected after satellite upgrade with migrating from pulp to katello

        :id: badaeec2-d42f-41d5-bd85-4b23d6d5a724

        :steps:
            1. Verify sync plan exists and works as earlier

        :expectedresults: Post Upgrade, Sync plans exists and works as earlier.

         """
        entity_data = get_entity_data(self.__class__.__name__)
        org = entities.Organization(id=entity_data.get('org_id'))
        product = entities.Product(id=entity_data.get("product_id")).read()
        sync_plan = entities.SyncPlan(id=entity_data.get("sync_plan_id"),
                                      organization=org).read()
        self.assertEqual(product.sync_plan.id, sync_plan.id)
        self.assertEqual(sync_plan.name, entity_data.get("sync_plan_name"))
        self.assertEqual(sync_plan.interval, entity_data.get("interval"))
        self.assertEqual(sync_plan.sync_date, entity_data.get("sync_date"))
        # checking sync plan update on upgraded satellite
        sync_plan.interval = SYNC_INTERVAL['custom']
        sync_plan.cron_expression = gen_choice(valid_cron_expressions())
        self.assertEqual(
            sync_plan.update(['interval', 'cron_expression']).interval,
            SYNC_INTERVAL['custom']
        )
        # checking sync plan delete on upgraded satellite
        sync_plan.delete()
        product = product.read()
        self.assertIsNone(product.sync_plan)
        with self.assertRaises(HTTPError):
            sync_plan.read()
    def test_positive_update_interval(self):
        """Create a sync plan and update its interval.

        :id: cf2eddf8-b4db-430e-a9b0-83c626b45068

        :expectedresults: A sync plan is created and its interval can be
            updated with the specified interval.

        :CaseImportance: Critical
        """
        for interval in valid_sync_interval():
            with self.subTest(interval):
                sync_plan = entities.SyncPlan(organization=self.org)
                result = sync_plan.get_fields()['interval']
                sync_plan.interval = sample(
                    set(result.choices) - set([interval]),
                    1
                )[0]
                sync_plan = sync_plan.create()
                sync_plan.interval = interval
                if (interval == 'custom cron'):
                    sync_plan.cron_expression = gen_choice(valid_cron_expressions())
                    sync_plan = sync_plan.update(['interval', 'cron_expression'])
                else:
                    sync_plan = sync_plan.update(['interval'])
                self.assertEqual(sync_plan.interval, interval)
Beispiel #26
0
    def _make_discoveryrule(self, options=None):
        """Makes a new discovery rule and asserts its success"""
        if options is None:
            options = {}

        searches = [
            'cpu_count = 1',
            'disk_count < 5',
            'memory > 500',
            'model = KVM',
            'Organization = Default_Organization',
            'last_report = Today',
            'subnet =  192.168.100.0',
            'facts.architecture != x86_64',
        ]

        if not any(
                options.get(key)
                for key in ['organizations', 'organization-ids']):
            options[u'organization-ids'] = self.org['id']
        if not any(options.get(key) for key in ['locations', 'locations-ids']):
            options[u'location-ids'] = self.loc['id']
        if not any(options.get(key) for key in ['hostgroup', 'hostgroup-ids']):
            options[u'hostgroup-id'] = self.hostgroup['id']
        if options.get('search') is None:
            options[u'search'] = gen_choice(searches)

        return make_discoveryrule(options)
Beispiel #27
0
def test_positive_delete_synced_product_custom_cron(module_org):
    """Create a sync plan with custom cron with one synced
    product and delete it.

    :id: f13936f5-7522-43b8-a986-26795637cde9

    :expectedresults: A sync plan is created with one synced product and
        sync plan can be deleted.

    :CaseLevel: Integration
    """
    sync_plan = entities.SyncPlan(
        organization=module_org,
        interval='custom cron',
        cron_expression=gen_choice(valid_cron_expressions()),
    ).create()
    product = entities.Product(organization=module_org).create()
    entities.Repository(product=product).create()
    sync_plan.add_products(data={'product_ids': [product.id]})
    product.sync()
    product = product.read()
    assert product.sync_plan.id == sync_plan.id
    sync_plan.delete()
    product = product.read()
    assert product.sync_plan is None
    with pytest.raises(HTTPError):
        sync_plan.read()
    def test_positive_add_remove_products_custom_cron(self):
        """Create a sync plan with two products having custom_cron interval
         and then remove both products from it.

         :id: 5ce34eaa-3574-49ba-ab02-aa25515394aa

         :expectedresults: A sync plan can be created and both products can be
            removed from it.
         :CaseLevel: Integration
        """
        cron_expression = gen_choice(valid_cron_expressions())

        syncplan = entities.SyncPlan(organization=self.org,
                                     interval='custom cron',
                                     cron_expression=cron_expression
                                     ).create()
        products = [
            entities.Product(organization=self.org).create() for _ in range(2)
        ]
        syncplan.add_products(data={
            'product_ids': [product.id for product in products],
        })
        self.assertEqual(len(syncplan.read().product), 2)
        syncplan.remove_products(data={
            'product_ids': [product.id for product in products],
        })
        self.assertEqual(len(syncplan.read().product), 0)
Beispiel #29
0
    def test_positive_create_with_name_by_cv_id(self):
        """Create new content view filter and assign it to existing content
        view by id. Use different value types as a name and random filter
        content type as a parameter for this filter

        @Feature: Content View Filter

        @Assert: Content view filter created successfully and has correct and
        expected parameters

        """
        for name in valid_data_list():
            with self.subTest(name):
                filter_content_type = gen_choice([
                    'rpm',
                    'package_group',
                    'erratum',
                ])
                ContentView.filter_create({
                    'content-view-id':
                    self.content_view['id'],
                    'name':
                    name,
                    'type':
                    filter_content_type,
                })
                cvf = ContentView.filter_info({
                    u'content-view-id':
                    self.content_view['id'],
                    u'name':
                    name,
                })
                self.assertEqual(cvf['name'], name)
                self.assertEqual(cvf['type'], filter_content_type)
    def _make_discoveryrule(self, options=None):
        """Makes a new discovery rule and asserts its success"""
        if options is None:
            options = {}

        searches = [
            'cpu_count = 1',
            'disk_count < 5',
            'memory > 500',
            'model = KVM',
            'Organization = Default_Organization',
            'last_report = Today',
            'subnet =  192.168.100.0',
            'facts.architecture != x86_64',
        ]

        if not any(options.get(key) for key in [
            'organizations', 'organization-ids'
        ]):
            options[u'organization-ids'] = self.org['id']
        if not any(options.get(key) for key in ['locations', 'locations-ids']):
            options[u'location-ids'] = self.loc['id']
        if not any(options.get(key) for key in ['hostgroup', 'hostgroup-ids']):
            options[u'hostgroup-id'] = self.hostgroup['id']
        if options.get('search') is None:
            options[u'search'] = gen_choice(searches)

        return make_discoveryrule(options)
    def test_positive_delete_synced_product_custom_cron(self):
        """Create a sync plan with custom cron with one synced
        product and delete it.

        :id: f13936f5-7522-43b8-a986-26795637cde9

        :expectedresults: A sync plan is created with one synced product and
            sync plan can be deleted.

        :CaseLevel: Integration
        """
        sync_plan = entities.SyncPlan(
            organization=self.org,
            interval='custom cron',
            cron_expression=gen_choice((valid_cron_expressions()))).create()
        product = entities.Product(organization=self.org).create()
        entities.Repository(product=product).create()
        sync_plan.add_products(data={'product_ids': [product.id]})
        product.sync()
        product = product.read()
        self.assertEqual(product.sync_plan.id, sync_plan.id)
        sync_plan.delete()
        product = product.read()
        self.assertIsNone(product.sync_plan)
        with self.assertRaises(HTTPError):
            sync_plan.read()
def test_positive_upload_facts():
    """Upload fake facts to create a discovered host

    :id: c1f40204-bbb0-46d0-9b60-e42f00ad1649

    :BZ: 1349364, 1392919

    :Steps:

        1. POST /api/v2/discovered_hosts/facts
        2. Read the created discovered host

    :expectedresults: Host should be created successfully

    :CaseImportance: High

    :CaseLevel: Integration

    :BZ: 1731112
    """
    name = gen_choice(list(valid_data_list().values()))
    result = _create_discovered_host(name)
    discovered_host = entities.DiscoveredHost(id=result['id']).read_json()
    host_name = 'mac{}'.format(discovered_host['mac'].replace(':', ''))
    assert discovered_host['name'] == host_name
Beispiel #33
0
    def create_missing(self, auth=None):
        """Automagically populate all required instance attributes.

        Iterate through the set of all required :class:`Field` defined on
        ``type(self)`` and create a corresponding instance attribute if none
        exists. Subclasses should override this method if there is some
        relationship between two required fields.

        :param tuple auth: Same as :meth:`create_raw`.
        :return: Nothing. This method relies on side-effects.

        """
        for field_name, field in self.get_fields().items():
            if field.required and field_name not in vars(self):
                # Most `get_value` methods return a value such as an integer,
                # string or dictionary, but OneTo{One,Many}Field.get_value
                # returns an instance of the referenced class.
                if hasattr(field, 'default'):
                    value = field.default
                elif hasattr(field, 'choices'):
                    value = gen_choice(field.choices)
                elif isinstance(field, OneToOneField):
                    value = field.get_value().create_json(auth=auth)['id']
                elif isinstance(field, OneToManyField):
                    value = [field.get_value().create_json(auth=auth)['id']]
                else:
                    value = field.get_value()
                setattr(self, field_name, value)
Beispiel #34
0
        def _create_discoveryrule(org, loc, hostgroup, options=None):
            """Makes a new discovery rule and asserts its success"""
            options = options or {}

            searches = [
                'cpu_count = 1',
                'disk_count < 5',
                'memory > 500',
                'model = KVM',
                'Organization = Default_Organization',
                'last_report = Today',
                'subnet =  192.168.100.0',
                'facts.architecture != x86_64',
            ]

            if not any(
                    options.get(key)
                    for key in ['organizations', 'organization-ids']):
                options['organization-ids'] = org.id
            if not any(
                    options.get(key)
                    for key in ['locations', 'locations-ids']):
                options['location-ids'] = loc.id
            if not any(
                    options.get(key)
                    for key in ['hostgroup', 'hostgroup-ids']):
                options['hostgroup-id'] = hostgroup.id
            if options.get('search') is None:
                options['search'] = gen_choice(searches)

            # create a simple object from the dictionary that the CLI factory provides
            # This allows for consistent attributized access of all fixture entities in the tests
            return AttrDict(make_discoveryrule(options))
Beispiel #35
0
    def test_post_sync_plan_migration(self):
        """Post-upgrade scenario that tests existing sync plans are working as
        expected after satellite upgrade with migrating from pulp to katello

        :id: badaeec2-d42f-41d5-bd85-4b23d6d5a724

        :steps:
            1. Verify sync plan exists and works as earlier

        :expectedresults: Post Upgrade, Sync plans exists and works as earlier.

         """
        entity_data = get_entity_data(self.__class__.__name__)
        org = entities.Organization(id=entity_data.get('org_id'))
        product = entities.Product(id=entity_data.get("product_id")).read()
        sync_plan = entities.SyncPlan(id=entity_data.get("sync_plan_id"),
                                      organization=org).read()
        self.assertEqual(product.sync_plan.id, sync_plan.id)
        self.assertEqual(sync_plan.name, entity_data.get("sync_plan_name"))
        self.assertEqual(sync_plan.interval, entity_data.get("interval"))
        self.assertEqual(sync_plan.sync_date, entity_data.get("sync_date"))
        # checking sync plan update on upgraded satellite
        sync_plan.interval = SYNC_INTERVAL['custom']
        sync_plan.cron_expression = gen_choice(valid_cron_expressions())
        self.assertEqual(
            sync_plan.update(['interval', 'cron_expression']).interval,
            SYNC_INTERVAL['custom'])
        # checking sync plan delete on upgraded satellite
        sync_plan.delete()
        product = product.read()
        self.assertIsNone(product.sync_plan)
        with self.assertRaises(HTTPError):
            sync_plan.read()
Beispiel #36
0
    def test_negative_end_to_end(self, module_host):
        """Attempt to create and update an interface with different invalid entries as names
        (>255 chars, unsupported string types), at the end attempt to remove primary interface

        :id: 6fae26d8-8f62-41ba-a1cc-0185137ef70f

        :expectedresults: An interface is not created, not updated
            and primary interface is not deleted

        :CaseImportance: Critical
        """
        name = gen_choice(invalid_interfaces_list())
        with pytest.raises(HTTPError) as error:
            entities.Interface(host=module_host, name=name).create()
        assert str(422) in str(error)
        interface = entities.Interface(host=module_host).create()
        interface.name = name
        with pytest.raises(HTTPError) as error:
            interface.update(['name'])
        assert interface.read().name != name
        assert str(422) in str(error)

        primary_interface = next(
            interface for interface in module_host.interface if interface.read().primary
        )
        with pytest.raises(HTTPError):
            primary_interface.delete()
        try:
            primary_interface.read()
        except HTTPError:
            pytest.fail("HTTPError 404 raised unexpectedly!")
Beispiel #37
0
def test_positive_add_remove_products_custom_cron(module_org):
    """Create a sync plan with two products having custom cron interval
    and then remove both products from it.

    :id: 5ce34eaa-3574-49ba-ab02-aa25515394aa

    :expectedresults: A sync plan can be created and both products can be
        removed from it.

    :CaseLevel: Integration
    """
    cron_expression = gen_choice(valid_cron_expressions())

    syncplan = entities.SyncPlan(organization=module_org,
                                 interval='custom cron',
                                 cron_expression=cron_expression).create()
    products = [
        entities.Product(organization=module_org).create() for _ in range(2)
    ]
    syncplan.add_products(
        data={'product_ids': [product.id for product in products]})
    assert len(syncplan.read().product) == 2
    syncplan.remove_products(
        data={'product_ids': [product.id for product in products]})
    assert len(syncplan.read().product) == 0
Beispiel #38
0
    def test_positive_create_with_name_by_cv_id(self):
        """Create new content view filter and assign it to existing content
        view by id. Use different value types as a name and random filter
        content type as a parameter for this filter

        :id: 2cfdf72e-179d-4bba-8aab-288594cac836

        :expectedresults: Content view filter created successfully and has
            correct and expected parameters

        :CaseImportance: Critical
        """
        for name in valid_data_list():
            with self.subTest(name):
                filter_content_type = gen_choice([
                    'rpm',
                    'package_group',
                    'erratum',
                ])
                ContentView.filter.create({
                    'content-view-id': self.content_view['id'],
                    'name': name,
                    'organization-id': self.org['id'],
                    'type': filter_content_type,
                })
                cvf = ContentView.filter.info({
                    u'content-view-id': self.content_view['id'],
                    u'name': name,
                })
                self.assertEqual(cvf['name'], name)
                self.assertEqual(cvf['type'], filter_content_type)
Beispiel #39
0
    def create_missing(self):
        """Automagically populate all required instance attributes.

        Iterate through the set of all required class
        :class:`nailgun.entity_fields.Field` defined on ``type(self)`` and
        create a corresponding instance attribute if none exists. Subclasses
        should override this method if there is some relationship between two
        required fields.

        :return: Nothing. This method relies on side-effects.

        """
        for field_name, field in self.get_fields().items():
            if field.required and not hasattr(self, field_name):
                # Most `gen_value` methods return a value such as an integer,
                # string or dictionary, but OneTo{One,Many}Field.gen_value
                # returns the referenced class.
                if hasattr(field, 'default'):
                    value = field.default
                elif hasattr(field, 'choices'):
                    value = gen_choice(field.choices)
                elif isinstance(field, OneToOneField):
                    value = field.gen_value()(self._server_config).create(True)
                elif isinstance(field, OneToManyField):
                    value = [
                        field.gen_value()(self._server_config).create(True)
                    ]
                else:
                    value = field.gen_value()
                setattr(self, field_name, value)
Beispiel #40
0
def test_positive_create_and_update_with_name():
    """Create and update a host with different names and minimal input parameters

    :id: a7c0e8ec-3816-4092-88b1-0324cb271752

    :expectedresults: A host is created and updated with expected name

    :CaseImportance: Critical
    """
    name = gen_choice(valid_hosts_list())
    host = entities.Host(name=name).create()
    assert host.name == f'{name}.{host.domain.read().name}'
    new_name = gen_choice(valid_hosts_list())
    host.name = new_name
    host = host.update(['name'])
    assert host.name == f'{new_name}.{host.domain.read().name}'
Beispiel #41
0
def test_positive_create_and_update_with_comment():
    """Create and update a host with a comment

    :id: 9b78663f-139c-4d0b-9115-180624b0d41b

    :expectedresults: A host is created and updated with expected comment

    :CaseImportance: Critical
    """
    comment = gen_choice(list(valid_data_list().values()))
    host = entities.Host(comment=comment).create()
    assert host.comment == comment
    new_comment = gen_choice(list(valid_data_list().values()))
    host.comment = new_comment
    host = host.update(['comment'])
    assert host.comment == new_comment
Beispiel #42
0
def test_positive_update_key_for_product_with_repos(module_org):
    """Create gpg key with valid name and valid gpg key via file
    import then associate it with custom product that has more than one
    repository then update the key

    :id: 8aa3dc75-6257-48ae-b3f9-c617e323b47a

    :expectedresults: gpg key is associated with product before/after
        update as well as with the repositories

    :CaseLevel: Integration
    """
    # Create a product and a gpg key
    product = make_product({'organization-id': module_org.id})
    gpg_key = make_content_credential({'organization-id': module_org.id})
    # Create repositories and assign them to the product
    repos = [
        make_repository({'product-id': product['id']})
        for _ in range(gen_integer(2, 5))
    ]
    # Associate gpg key with a product
    Product.update({
        'gpg-key': gpg_key['name'],
        'id': product['id'],
        'organization-id': module_org.id
    })
    # Verify gpg key was associated
    product = Product.info({
        'id': product['id'],
        'organization-id': module_org.id
    })
    assert product['gpg']['gpg-key'] == gpg_key['name']
    for repo in repos:
        repo = Repository.info({'id': repo['id']})
        assert repo['gpg-key'].get('name') == gpg_key['name']
    # Update the gpg key
    new_name = gen_choice(list(valid_data_list().values()))
    ContentCredential.update({
        'name': gpg_key['name'],
        'new-name': new_name,
        'organization-id': module_org.id
    })
    # Verify changes are reflected in the gpg key
    gpg_key = ContentCredential.info({
        'id': gpg_key['id'],
        'organization-id': module_org.id
    })
    assert gpg_key['name'] == new_name
    # Verify changes are reflected in the product
    product = Product.info({
        'id': product['id'],
        'organization-id': module_org.id
    })
    assert product['gpg']['gpg-key'] == new_name
    # Verify changes are reflected in the repositories
    for repo in repos:
        repo = Repository.info({'id': repo['id']})
        assert repo['gpg-key'].get('name') == new_name
Beispiel #43
0
    def test_positive_update_key_for_product_with_repos(self):
        """Create gpg key with valid name and valid gpg key via file
        import then associate it with custom product that has more than one
        repository then update the key

        :id: a95eb51b-4b6b-4c04-bb4d-cbe600431850

        :expectedresults: gpg key is associated with product before/after
            update as well as with the repositories

        :CaseLevel: Integration
        """
        # Create a product and a gpg key
        product = make_product({'organization-id': self.org['id']})
        gpg_key = make_gpg_key({'organization-id': self.org['id']})
        # Create repositories and assign them to the product
        repos = [
            make_repository({'product-id': product['id']})
            for _ in range(gen_integer(2, 5))
        ]
        # Associate gpg key with a product
        Product.update({
            'gpg-key': gpg_key['name'],
            'id': product['id'],
            'organization-id': self.org['id'],
        })
        # Verify gpg key was associated
        product = Product.info({
            'id': product['id'],
            'organization-id': self.org['id'],
        })
        self.assertEqual(product['gpg']['gpg-key'], gpg_key['name'])
        for repo in repos:
            repo = Repository.info({'id': repo['id']})
            self.assertEqual(repo['gpg-key'].get('name'), gpg_key['name'])
        # Update the gpg key
        new_name = gen_choice(valid_data_list())
        GPGKey.update({
            'name': gpg_key['name'],
            'new-name': new_name,
            'organization-id': self.org['id'],
        })
        # Verify changes are reflected in the gpg key
        gpg_key = GPGKey.info({
            'id': gpg_key['id'],
            'organization-id': self.org['id'],
        })
        self.assertEqual(gpg_key['name'], new_name)
        # Verify changes are reflected in the product
        product = Product.info({
            'id': product['id'],
            'organization-id': self.org['id'],
        })
        self.assertEqual(product['gpg']['gpg-key'], new_name)
        # Verify changes are reflected in the repositories
        for repo in repos:
            repo = Repository.info({'id': repo['id']})
            self.assertEqual(repo['gpg-key'].get('name'), new_name)
Beispiel #44
0
    def test_positive_update_key_for_product_with_repos(self):
        """Create gpg key with valid name and valid gpg key via file
        import then associate it with custom product that has more than one
        repository then update the key

        @id: a95eb51b-4b6b-4c04-bb4d-cbe600431850

        @assert: gpg key is associated with product before/after update as well
        as with the repositories

        @CaseLevel: Integration
        """
        # Create a product and a gpg key
        product = make_product({'organization-id': self.org['id']})
        gpg_key = make_gpg_key({'organization-id': self.org['id']})
        # Create repositories and assign them to the product
        repos = [
            make_repository({'product-id': product['id']})
            for _ in range(gen_integer(2, 5))
        ]
        # Associate gpg key with a product
        Product.update({
            'gpg-key': gpg_key['name'],
            'id': product['id'],
            'organization-id': self.org['id'],
        })
        # Verify gpg key was associated
        product = Product.info({
            'id': product['id'],
            'organization-id': self.org['id'],
        })
        self.assertEqual(product['gpg']['gpg-key'], gpg_key['name'])
        for repo in repos:
            repo = Repository.info({'id': repo['id']})
            self.assertEqual(repo['gpg-key'].get('name'), gpg_key['name'])
        # Update the gpg key
        new_name = gen_choice(valid_data_list())
        GPGKey.update({
            'name': gpg_key['name'],
            'new-name': new_name,
            'organization-id': self.org['id'],
        })
        # Verify changes are reflected in the gpg key
        gpg_key = GPGKey.info({
            'id': gpg_key['id'],
            'organization-id': self.org['id'],
        })
        self.assertEqual(gpg_key['name'], new_name)
        # Verify changes are reflected in the product
        product = Product.info({
            'id': product['id'],
            'organization-id': self.org['id'],
        })
        self.assertEqual(product['gpg']['gpg-key'], new_name)
        # Verify changes are reflected in the repositories
        for repo in repos:
            repo = Repository.info({'id': repo['id']})
            self.assertEqual(repo['gpg-key'].get('name'), new_name)
Beispiel #45
0
def test_positive_update_key_for_repo_from_product_with_repos(module_org):
    """Create gpg key with valid name and valid gpg key via file
    import then associate it to repository from custom product that has
    more than one repository then update the key

    :id: c548ed4f-7f2d-456f-a644-7597644f6457

    :expectedresults: gpg key is associated with a single repository
        before/after update and not associated with product or other
        repositories

    :CaseLevel: Integration
    """
    # Create a product and a gpg key
    product = make_product({'organization-id': module_org.id})
    gpg_key = make_content_credential({'organization-id': module_org.id})
    # Create repositories and assign them to the product
    repos = [
        make_repository({'product-id': product['id']})
        for _ in range(gen_integer(2, 5))
    ]
    # Associate gpg key with a single repository
    Repository.update({
        'gpg-key': gpg_key['name'],
        'id': repos[0]['id'],
        'organization-id': module_org.id
    })
    # Verify gpg key was associated
    repos[0] = Repository.info({'id': repos[0]['id']})
    assert repos[0]['gpg-key']['name'] == gpg_key['name']
    # Update the gpg key
    new_name = gen_choice(list(valid_data_list().values()))
    ContentCredential.update({
        'name': gpg_key['name'],
        'new-name': new_name,
        'organization-id': module_org.id
    })
    # Verify changes are reflected in the gpg key
    gpg_key = ContentCredential.info({
        'id': gpg_key['id'],
        'organization-id': module_org.id
    })
    assert gpg_key['name'] == new_name
    # Verify changes are reflected in the associated repository
    repos[0] = Repository.info({'id': repos[0]['id']})
    assert repos[0]['gpg-key'].get('name') == new_name
    # Verify changes are not reflected in the product
    product = Product.info({
        'id': product['id'],
        'organization-id': module_org.id
    })
    assert product['gpg']['gpg-key'] != new_name
    # Verify changes are not reflected in the rest of repositories
    for repo in repos[1:]:
        repo = Repository.info({'id': repo['id']})
        assert repo['gpg-key'].get('name') != new_name
Beispiel #46
0
    def test_positive_update_key_for_repo_from_product_with_repos(self):
        """Create gpg key with valid name and valid gpg key via file
        import then associate it to repository from custom product that has
        more than one repository then update the key

        :id: 773a9141-9f04-40ba-b3df-4b6d80db25a6

        :expectedresults: gpg key is associated with a single repository
            before/after update and not associated with product or other
            repositories

        :CaseLevel: Integration
        """
        # Create a product and a gpg key
        product = make_product({'organization-id': self.org['id']})
        gpg_key = make_gpg_key({'organization-id': self.org['id']})
        # Create repositories and assign them to the product
        repos = [
            make_repository({'product-id': product['id']})
            for _ in range(gen_integer(2, 5))
        ]
        # Associate gpg key with a single repository
        Repository.update({
            'gpg-key': gpg_key['name'],
            'id': repos[0]['id'],
            'organization-id': self.org['id'],
        })
        # Verify gpg key was associated
        repos[0] = Repository.info({'id': repos[0]['id']})
        self.assertEqual(repos[0]['gpg-key']['name'], gpg_key['name'])
        # Update the gpg key
        new_name = gen_choice(valid_data_list())
        GPGKey.update({
            'name': gpg_key['name'],
            'new-name': new_name,
            'organization-id': self.org['id'],
        })
        # Verify changes are reflected in the gpg key
        gpg_key = GPGKey.info({
            'id': gpg_key['id'],
            'organization-id': self.org['id'],
        })
        self.assertEqual(gpg_key['name'], new_name)
        # Verify changes are reflected in the associated repository
        repos[0] = Repository.info({'id': repos[0]['id']})
        self.assertEqual(repos[0]['gpg-key'].get('name'), new_name)
        # Verify changes are not reflected in the product
        product = Product.info({
            'id': product['id'],
            'organization-id': self.org['id'],
        })
        self.assertNotEqual(product['gpg']['gpg-key'], new_name)
        # Verify changes are not reflected in the rest of repositories
        for repo in repos[1:]:
            repo = Repository.info({'id': repo['id']})
            self.assertNotEqual(repo['gpg-key'].get('name'), new_name)
Beispiel #47
0
    def test_positive_update_key_for_repo_from_product_with_repos(self):
        """Create gpg key with valid name and valid gpg key via file
        import then associate it to repository from custom product that has
        more than one repository then update the key

        :id: 773a9141-9f04-40ba-b3df-4b6d80db25a6

        :expectedresults: gpg key is associated with a single repository
            before/after update and not associated with product or other
            repositories

        :CaseLevel: Integration
        """
        # Create a product and a gpg key
        product = make_product({'organization-id': self.org['id']})
        gpg_key = make_gpg_key({'organization-id': self.org['id']})
        # Create repositories and assign them to the product
        repos = [
            make_repository({'product-id': product['id']})
            for _ in range(gen_integer(2, 5))
        ]
        # Associate gpg key with a single repository
        Repository.update({
            'gpg-key': gpg_key['name'],
            'id': repos[0]['id'],
            'organization-id': self.org['id'],
        })
        # Verify gpg key was associated
        repos[0] = Repository.info({'id': repos[0]['id']})
        self.assertEqual(repos[0]['gpg-key']['name'], gpg_key['name'])
        # Update the gpg key
        new_name = gen_choice(valid_data_list())
        GPGKey.update({
            'name': gpg_key['name'],
            'new-name': new_name,
            'organization-id': self.org['id'],
        })
        # Verify changes are reflected in the gpg key
        gpg_key = GPGKey.info({
            'id': gpg_key['id'],
            'organization-id': self.org['id'],
        })
        self.assertEqual(gpg_key['name'], new_name)
        # Verify changes are reflected in the associated repository
        repos[0] = Repository.info({'id': repos[0]['id']})
        self.assertEqual(repos[0]['gpg-key'].get('name'), new_name)
        # Verify changes are not reflected in the product
        product = Product.info({
            'id': product['id'],
            'organization-id': self.org['id'],
        })
        self.assertNotEqual(product['gpg']['gpg-key'], new_name)
        # Verify changes are not reflected in the rest of repositories
        for repo in repos[1:]:
            repo = Repository.info({'id': repo['id']})
            self.assertNotEqual(repo['gpg-key'].get('name'), new_name)
Beispiel #48
0
def test_gen_choice_11(item):
    """Select a random value from dictionary list."""
    choices = [
        {'Name': 'Bob', 'Age': 39},
        {'Name': 'Alice', 'Age': 23},
        {'Name': 'Pete', 'Age': 79},
    ]

    result = gen_choice(choices)
    assert result in choices
Beispiel #49
0
    def test_key_associate_13(self):
        """@test: Create gpg key with valid name and valid gpg key via file
        import then associate it to repository from custom product that has
        more than one repository then update the key

        @feature: GPG Keys

        @assert: gpg key is associated with a single repository before/after
        update and not associated with product or other repositories
        """
        # Create a product and a gpg key
        product = make_product({'organization-id': self.org['id']})
        gpg_key = make_gpg_key({'organization-id': self.org['id']})
        # Create repositories and assign them to the product
        repos = [
            make_repository({'product-id': product['id']})
            for _ in range(gen_integer(2, 5))
        ]
        # Associate gpg key with a single repository
        Repository.update({
            'gpg-key': gpg_key['name'],
            'id': repos[0]['id'],
            'organization-id': self.org['id'],
        })
        # Verify gpg key was associated
        repos[0] = Repository.info({'id': repos[0]['id']})
        self.assertEqual(repos[0]['gpg-key']['name'], gpg_key['name'])
        # Update the gpg key
        new_name = gen_choice(valid_data_list())
        GPGKey.update({
            'name': gpg_key['name'],
            'new-name': new_name,
            'organization-id': self.org['id'],
        })
        # Verify changes are reflected in the gpg key
        gpg_key = GPGKey.info({
            'id': gpg_key['id'],
            'organization-id': self.org['id'],
        })
        self.assertEqual(gpg_key['name'], new_name)
        # Verify changes are reflected in the associated repository
        repos[0] = Repository.info({'id': repos[0]['id']})
        self.assertEqual(repos[0]['gpg-key'].get('name'), new_name)
        # Verify changes are not reflected in the product
        product = Product.info({
            'id': product['id'],
            'organization-id': self.org['id'],
        })
        self.assertNotEqual(product['gpg']['gpg-key'], new_name)
        # Verify changes are not reflected in the rest of repositories
        for repo in repos[1:]:
            repo = Repository.info({'id': repo['id']})
            self.assertNotEqual(repo['gpg-key'].get('name'), new_name)
Beispiel #50
0
    def test_positive_update_key_for_product_with_repo(self):
        """Create gpg key with valid name and valid gpg key via file
        import then associate it with custom product that has one repository
        then update the key

        @id: 3fb550a7-507e-4988-beb6-35bdfc2e99a8

        @assert: gpg key is associated with product before/after update as well
        as with the repository

        @CaseLevel: Integration
        """
        # Create a product and a gpg key
        product = make_product({'organization-id': self.org['id']})
        gpg_key = make_gpg_key({'organization-id': self.org['id']})
        # Create a repository and assign it to the product
        repo = make_repository({'product-id': product['id']})
        # Associate gpg key with a product
        Product.update({
            'gpg-key': gpg_key['name'],
            'id': product['id'],
            'organization-id': self.org['id'],
        })
        # Verify gpg key was associated
        product = Product.info({
            'id': product['id'],
            'organization-id': self.org['id'],
        })
        repo = Repository.info({'id': repo['id']})
        self.assertEqual(product['gpg']['gpg-key'], gpg_key['name'])
        self.assertEqual(repo['gpg-key'].get('name'), gpg_key['name'])
        # Update the gpg key
        new_name = gen_choice(valid_data_list())
        GPGKey.update({
            'name': gpg_key['name'],
            'new-name': new_name,
            'organization-id': self.org['id'],
        })
        # Verify changes are reflected in the gpg key
        gpg_key = GPGKey.info({
            'id': gpg_key['id'],
            'organization-id': self.org['id'],
        })
        self.assertEqual(gpg_key['name'], new_name)
        # Verify changes are reflected in the product
        product = Product.info({
            'id': product['id'],
            'organization-id': self.org['id'],
        })
        self.assertEqual(product['gpg']['gpg-key'], new_name)
        # Verify changes are reflected in the repository
        repo = Repository.info({'id': repo['id']})
        self.assertEqual(repo['gpg-key'].get('id'), gpg_key['id'])
def generate_system_facts(name=None):
    """Generate random system facts for registration.

    :param str name: A valid FQDN for a system. If one is not
        provided, then a random value will be generated.
    :return: A dictionary with random system facts
    :rtype: dict
    """
    if name is None:
        name = u'{0}.example.net'.format(
            gen_alpha().lower())

    # Make a copy of the system facts 'template'
    new_facts = copy.deepcopy(SYSTEM_FACTS)
    # Select a random RHEL version...
    distro = gen_choice(DISTRO_IDS)

    # ...and update our facts
    new_facts['distribution.id'] = distro['id']
    new_facts['distribution.version'] = distro['version']
    new_facts['dmi.bios.relase_date'] = _bios_date().strftime('%m/%d/%Y')
    new_facts['dmi.memory.maximum_capacity'] = gen_choice(
        MEMORY_CAPACITY)
    new_facts['dmi.memory.size'] = gen_choice(MEMORY_SIZE)
    new_facts['dmi.system.uuid'] = gen_uuid()
    new_facts['dmi.system.version'] = u'RHEL'
    new_facts['lscpu.architecture'] = distro['architecture']
    new_facts['net.interface.eth1.hwaddr'] = gen_mac()
    new_facts['net.interface.eth1.ipaddr'] = gen_ipaddr()
    new_facts['network.hostname'] = name
    new_facts['network.ipaddr'] = new_facts['net.interface.eth1.ipaddr']
    new_facts['uname.machine'] = distro['architecture']
    new_facts['uname.nodename'] = name
    new_facts['uname.release'] = distro['kernel']
    new_facts['virt.uuid'] = new_facts['dmi.system.uuid']

    return new_facts
    def test_gen_choice_6(self):
        """
        @Test: Select a random value from longer tuple
        @Feature: Choice Generator
        @Assert: Selects a random choice from longer tuple
        """

        choices = (1, 2, 3, 9, 10, 11, 100, 101, 102, )

        for turn in range(10):
            result = gen_choice(choices)
            self.assertIn(
                result,
                choices,
                "An invalid value was selected from available choices.")
    def test_gen_choice_1(self):
        """
        @Test: Select a random value from integer values
        @Feature: Choice Generator
        @Assert: Selects a random choice from options
        """

        choices = range(5)

        for turn in range(10):
            result = gen_choice(choices)
            self.assertIn(
                result,
                choices,
                "An invalid value was selected from available choices.")
    def test_gen_choice_12(self):
        """
        @Test: Select a random value from words list
        @Feature: Choice Generator
        @Assert: Selects a random choice from list
        """

        choices = ['green', 'yellow', 'blue' 'white']

        for turn in range(10):
            result = gen_choice(choices)
            self.assertIn(
                result,
                choices,
                "An invalid value was selected from available choices.")
    def test_gen_choice_5(self):
        """
        @Test: Select a random value from short tuple
        @Feature: Choice Generator
        @Assert: Selects a random choice from short tuple
        """

        choices = (1, )

        for turn in range(10):
            result = gen_choice(choices)
            self.assertEqual(
                result,
                choices[0],
                "An invalid value was selected from available choices.")
    def test_gen_choice_2(self):
        """
        @Test: Select a random value from alphanumeric values
        @Feature: Choice Generator
        @Assert: Selects a random choice from alphanumeric options
        """

        choices = string.ascii_letters + string.digits

        for turn in range(10):
            result = gen_choice(choices)
            self.assertIn(
                result,
                choices,
                "An invalid value was selected from available choices.")
Beispiel #57
0
    def test_positive_update_key_for_empty_product(self):
        """Create gpg key with valid name and valid gpg key via file
        import then associate it with empty (no repos) custom product then
        update the key

        :id: c0c84c45-21fc-4940-9d52-00babb807ec7

        :expectedresults: gpg key is associated with product before/after
            update

        :CaseLevel: Integration
        """
        # Create a product and a gpg key
        product = make_product({'organization-id': self.org['id']})
        gpg_key = make_gpg_key({'organization-id': self.org['id']})
        # Associate gpg key with a product
        Product.update({
            'gpg-key': gpg_key['name'],
            'id': product['id'],
            'organization-id': self.org['id'],
        })
        # Verify gpg key was associated
        product = Product.info({
            'id': product['id'],
            'organization-id': self.org['id'],
        })
        self.assertEqual(product['gpg']['gpg-key'], gpg_key['name'])
        # Update the gpg key
        new_name = gen_choice(valid_data_list())
        GPGKey.update({
            'name': gpg_key['name'],
            'new-name': new_name,
            'organization-id': self.org['id'],
        })
        # Verify changes are reflected in the gpg key
        gpg_key = GPGKey.info({
            'id': gpg_key['id'],
            'organization-id': self.org['id'],
        })
        self.assertEqual(gpg_key['name'], new_name)
        # Verify changes are reflected in the product
        product = Product.info({
            'id': product['id'],
            'organization-id': self.org['id'],
        })
        self.assertEqual(product['gpg']['gpg-key'], new_name)
Beispiel #58
0
def _make_docker_repo(product_id, name=None, upstream_name=None):
    """Creates a Docker-based repository.

    :param product_id: ID of the ``Product``.
    :param str name: Name for the repository. If ``None`` then a random
        value will be generated.
    :param str upstream_name: A valid name for an existing Docker image.
        If ``None`` then defaults to ``busybox``.
    :return: A ``Repository`` object.

    """
    return make_repository({
        'content-type': REPO_CONTENT_TYPE,
        'docker-upstream-name': upstream_name or REPO_UPSTREAM_NAME,
        'name': name or gen_string(gen_choice(STRING_TYPES), 15),
        'product-id': product_id,
        'url': DOCKER_REGISTRY_HUB,
    })
Beispiel #59
0
def test_positive_product_create_with_create_sync_plan(session, module_org):
    """Perform Sync Plan Create from Product Create Page

    :id: 4a87b533-12b6-4d4e-8a99-4bb95efc4321

    :expectedresults: Ensure sync get created and assigned to Product.

    :CaseLevel: Integration

    :CaseImportance: medium
    """
    product_name = gen_string('alpha')
    product_description = gen_string('alpha')
    gpg_key = entities.GPGKey(
        content=read_data_file(VALID_GPG_KEY_FILE),
        organization=module_org
    ).create()
    plan_name = gen_string('alpha')
    description = gen_string('alpha')
    cron_expression = gen_choice(valid_cron_expressions())
    with session:
        startdate = (
                session.browser.get_client_datetime() + timedelta(minutes=10))
        sync_plan_values = {
            'name': plan_name,
            'interval': SYNC_INTERVAL['custom'],
            'description': description,
            'cron_expression': cron_expression,
            'date_time.start_date': startdate.strftime("%Y-%m-%d"),
            'date_time.hours': startdate.strftime('%H'),
            'date_time.minutes': startdate.strftime('%M'),
        }
        session.product.create({
            'name': product_name,
            'gpg_key': gpg_key.name,
            'description': product_description,
        }, sync_plan_values=sync_plan_values)
        assert session.product.search(product_name)[0]['Name'] == product_name
        product_values = session.product.read(product_name)
        assert product_values['details']['name'] == product_name
        assert product_values['details']['sync_plan'] == plan_name
        # Delete product
        session.product.delete(product_name)
        assert not session.product.search(product_name)
Beispiel #60
0
    def test_positive_update_key_for_repo_from_product_with_repo(self):
        """Create gpg key with valid name and valid gpg key via file
        import then associate it to repository from custom product that has
        one repository then update the key

        @id: 549e2e1e-fd10-4487-a3a5-fdee9b8cfc48

        @assert: gpg key is associated with the repository before/after update,
        but not with the product

        @CaseLevel: Integration
        """
        # Create a product and a gpg key
        product = make_product({'organization-id': self.org['id']})
        gpg_key = make_gpg_key({'organization-id': self.org['id']})
        # Create repository, assign product and gpg-key
        repo = make_repository({
            'gpg-key-id': gpg_key['id'],
            'product-id': product['id'],
        })
        # Verify gpg key was associated
        self.assertEqual(repo['gpg-key'].get('name'), gpg_key['name'])
        # Update the gpg key
        new_name = gen_choice(valid_data_list())
        GPGKey.update({
            'name': gpg_key['name'],
            'new-name': new_name,
            'organization-id': self.org['id'],
        })
        # Verify changes are reflected in the gpg key
        gpg_key = GPGKey.info({
            'id': gpg_key['id'],
            'organization-id': self.org['id'],
        })
        self.assertEqual(gpg_key['name'], new_name)
        # Verify changes are reflected in the repositories
        repo = Repository.info({'id': repo['id']})
        self.assertEqual(repo['gpg-key'].get('name'), new_name)
        # Verify gpg key wasn't added to the product
        product = Product.info({
            'id': product['id'],
            'organization-id': self.org['id'],
        })
        self.assertNotEqual(product['gpg']['gpg-key'], new_name)