Exemple #1
0
def test_product_list_with_default_settings(module_org, default_sat):
    """Listing product of an organization apart from default organization using hammer
     does not return output if a defaults settings are applied on org.

    :id: d5c5edac-b19c-4277-92fe-28d9b9fa43ef

    :BZ: 1745575

    :customerscenario: true

    :expectedresults: product/reporsitory list should work as expected.

    """
    org_id = str(module_org.id)
    default_product_name = gen_string('alpha')
    non_default_product_name = gen_string('alpha')
    non_default_org = make_org()
    default_product = make_product({
        'name': default_product_name,
        'organization-id': org_id
    })
    non_default_product = make_product({
        'name': non_default_product_name,
        'organization-id': non_default_org['id']
    })
    for product in default_product, non_default_product:
        make_repository(
            {
                'organization-id': org_id,
                'product-id': product['id'],
                'url': settings.repos.yum_0.url,
            }, )

    Defaults.add({'param-name': 'organization_id', 'param-value': org_id})
    result = default_sat.cli.Defaults.list(per_page=False)
    assert any([
        res['value'] == org_id for res in result
        if res['parameter'] == 'organization_id'
    ])

    try:
        # Verify --organization-id is not required to pass if defaults are set
        result = default_sat.cli.Product.list()
        assert any([res['name'] == default_product_name for res in result])
        result = default_sat.cli.Repository.list()
        assert any([res['product'] == default_product_name for res in result])

        # verify that defaults setting should not affect other entities
        product_list = Product.list({'organization-id': non_default_org['id']})
        assert non_default_product_name == product_list[0]['name']
        repository_list = Repository.list(
            {'organization-id': non_default_org['id']})
        assert non_default_product_name == repository_list[0]['product']

    finally:
        Defaults.delete({'param-name': 'organization_id'})
        result = default_sat.cli.Defaults.list(per_page=False)
        assert not [
            res for res in result if res['parameter'] == 'organization_id'
        ]
Exemple #2
0
 def setupScenario(self):
     """ Create yum, puppet repositories and synchronize them.
     """
     self.org = make_org({'name': self.org_name})
     self.product = make_product({
         'name': self.product_name,
         'organization-id': self.org['id']
     })
     self.yum_repo1 = make_repository({
         'name': self.yum_repo1_name,
         'product-id': self.product['id'],
         'content-type': 'yum',
         'url': FAKE_1_YUM_REPO
     })
     Repository.synchronize({'id': self.yum_repo1['id']})
     self.module = {'name': self.puppet_module_name, 'version': '3.3.3'}
     self.puppet_repo = make_repository({
         'name': self.puppet_repo_name,
         'content-type': 'puppet',
         'product-id': self.product['id'],
         'url': CUSTOM_PUPPET_REPO,
     })
     Repository.synchronize({'id': self.puppet_repo['id']})
     self.puppet_module = PuppetModule.list({
         'search':
         'name={name} and version={version}'.format(**self.module)
     })[0]
Exemple #3
0
    def test_product_synchronize_by_label(self):
        """@Test: Check if product can be synchronized.
        Searches for organization by its label

        @Feature: Product

        @Assert: Product was synchronized

        """
        try:
            org = make_org()
            product = make_product({'organization-id': org['id']})
            make_repository({'product-id': product['id']})
        except CLIFactoryError as err:
            self.fail(err)

        result = Product.synchronize({
            'id': product['id'],
            'organization-label': org['label'],
        })
        self.assertEqual(result.return_code, 0)

        result = Product.info({
            'id': product['id'],
            'organization-id': org['id'],
        })
        self.assertEqual(result.return_code, 0)
        self.assertEqual(u'Syncing Complete.', result.stdout['sync-state'])
Exemple #4
0
def test_positive_product_sync_state(module_org):
    """hammer product info shows correct sync state.

    :id: 58af6239-85d7-4b8b-bd2d-ab4cd4f29840

    :BZ: 1803207,1999541

    :customerscenario: true

    :Steps:
        1. Sync a custom repository that fails.
        2. Run `hammer product info --product-id <id>`.
        3. Successfully sync another repository under the same product.
        4. Run `hammer product info --product-id <id>` again.


    :expectedresults: hammer should show 'Sync Incomplete' in both cases.
    """
    product = make_product({'organization-id': module_org.id})
    repo_a1 = make_repository({
        'organization-id':
        module_org.id,
        'product-id':
        product['id'],
        'name':
        gen_string('alpha'),
        'url':
        f'{gen_url(scheme="https")}:{gen_integer(min_value=10, max_value=9999)}',
    })

    with pytest.raises(CLIReturnCodeError):
        Repository.synchronize({'id': repo_a1['id']})

    product_info = Product.info({
        'id': product['id'],
        'organization-id': module_org.id
    })
    product_list = Product.list({'organization-id': module_org.id})
    assert product_info['sync-state-(last)'] in [
        p.get('sync-state') for p in product_list
    ]

    repo_a2 = make_repository(
        {
            'organization-id': module_org.id,
            'product-id': product['id'],
            'name': gen_string('alpha'),
            'url': settings.repos.yum_0.url,
        }, )

    Repository.synchronize({'id': repo_a2['id']})
    product_info = Product.info({
        'id': product['id'],
        'organization-id': module_org.id
    })
    product_list = Product.list({'organization-id': module_org.id})
    assert product_info['sync-state-(last)'] in [
        p.get('sync-state') for p in product_list
    ]
Exemple #5
0
    def test_product_list_with_default_settings(self):
        """Listing product of an organization apart from default organization using hammer
         does not return output if a defaults settings are applied on org.

        :id: d5c5edac-b19c-4277-92fe-28d9b9fa43ef

        :BZ: 1745575

        :expectedresults: product/reporsitory list should work as expected.

        """
        default_product_name = gen_string('alpha')
        non_default_product_name = gen_string('alpha')
        default_org = self.org
        non_default_org = make_org()
        default_product = make_product({
            'name': default_product_name,
            'organization-id': default_org['id']
        })
        non_default_product = make_product({
            'name':
            non_default_product_name,
            'organization-id':
            non_default_org['id']
        })
        for product in (default_product, non_default_product):
            make_repository({
                'product-id': product['id'],
                'url': FAKE_0_YUM_REPO
            })

        Defaults.add({
            'param-name': 'organization_id',
            'param-value': default_org['id']
        })
        result = ssh.command('hammer defaults list')
        self.assertTrue(default_org['id'] in "".join(result.stdout))
        try:
            # Verify --organization-id is not required to pass if defaults are set
            result = ssh.command('hammer product list')
            self.assertTrue(default_product_name in "".join(result.stdout))
            result = ssh.command('hammer repository list')
            self.assertTrue(default_product_name in "".join(result.stdout))

            # verify that defaults setting should not affect other entities
            product_list = Product.list(
                {'organization-id': non_default_org['id']})
            self.assertEquals(non_default_product_name,
                              product_list[0]['name'])
            repository_list = Repository.list(
                {'organization-id': non_default_org['id']})
            self.assertEquals(non_default_product_name,
                              repository_list[0]['product'])

        finally:
            Defaults.delete({'param-name': 'organization_id'})
            result = ssh.command('hammer defaults list')
            self.assertTrue(default_org['id'] not in "".join(result.stdout))
Exemple #6
0
def test_product_list_with_default_settings(module_org):
    """Listing product of an organization apart from default organization using hammer
     does not return output if a defaults settings are applied on org.

    :id: d5c5edac-b19c-4277-92fe-28d9b9fa43ef

    :BZ: 1745575

    :customerscenario: true

    :expectedresults: product/reporsitory list should work as expected.

    """
    org_id = str(module_org.id)
    default_product_name = gen_string('alpha')
    non_default_product_name = gen_string('alpha')
    non_default_org = make_org()
    default_product = make_product({
        'name': default_product_name,
        'organization-id': org_id
    })
    non_default_product = make_product({
        'name': non_default_product_name,
        'organization-id': non_default_org['id']
    })
    for product in default_product, non_default_product:
        make_repository(
            {
                'organization-id': org_id,
                'product-id': product['id'],
                'url': FAKE_0_YUM_REPO,
            }, )

    Defaults.add({'param-name': 'organization_id', 'param-value': org_id})
    result = ssh.command('hammer defaults list')
    assert org_id in "".join(result.stdout)
    try:
        # Verify --organization-id is not required to pass if defaults are set
        result = ssh.command('hammer product list')
        assert default_product_name in "".join(result.stdout)
        result = ssh.command('hammer repository list')
        assert default_product_name in "".join(result.stdout)

        # verify that defaults setting should not affect other entities
        product_list = Product.list({'organization-id': non_default_org['id']})
        assert non_default_product_name == product_list[0]['name']
        repository_list = Repository.list(
            {'organization-id': non_default_org['id']})
        assert non_default_product_name == repository_list[0]['product']

    finally:
        Defaults.delete({'param-name': 'organization_id'})
        result = ssh.command('hammer defaults list')
        assert org_id not in "".join(result.stdout)
Exemple #7
0
    def test_product_sync_by_label(self):
        """@Test: Check if product can be synchronized.
        Searches for organization by its label

        @Feature: Product

        @Assert: Product was synchronized
        """
        org = make_org()
        product = make_product({"organization-id": org["id"]})
        make_repository({"product-id": product["id"]})
        Product.synchronize({"id": product["id"], "organization-label": org["label"]})
        product = Product.info({"id": product["id"], "organization-id": org["id"]})
        self.assertEqual(u"Syncing Complete.", product["sync-state"])
Exemple #8
0
    def test_positive_package_count(self):
        """Check that packages count is correctly filtered by product id

        :id: 151f60a3-0b94-4658-8b0d-0d022f4f1d8f

        :expectedresults: Packages only from synced product returned

        :BZ: 1422552

        :CaseLevel: Integration
        """
        org = make_org()
        for _ in range(3):
            product = make_product({'organization-id': org['id']})
            repo = make_repository({
                'product-id': product['id'],
                'url': FAKE_0_YUM_REPO,
            })
            Product.synchronize({
                'id': product['id'],
                'organization-id': org['id'],
            })
            packages = Package.list({'product-id': product['id']})
            repo = Repository.info({'id': repo['id']})
            self.assertEqual(
                int(repo['content-counts']['packages']),
                len(packages)
            )
            self.assertEqual(len(packages), FAKE_0_YUM_REPO_PACKAGES_COUNT)
    def test_positive_list_multiple_repos(self):
        """Verify that puppet-modules list for specific repo is correct
        and does not affected by other repositories.

        :id: f36d25b3-2495-4e89-a1cf-e39d52762d95

        :expectedresults: Number of modules has no changed after a second repo
            was synced.

        :CaseImportance: Critical
        """
        # Verify that number of synced modules is correct
        repo1 = Repository.info({'id': self.repo['id']})
        repo_content_count = repo1['content-counts']['puppet-modules']
        modules_num = len(PuppetModule.list({'repository-id': repo1['id']}))
        self.assertEqual(repo_content_count, str(modules_num))
        # Create and sync second repo
        repo2 = make_repository({
            u'organization-id': self.org['id'],
            u'product-id': self.product['id'],
            u'content-type': u'puppet',
            u'url': FAKE_1_PUPPET_REPO,
        })
        Repository.synchronize({'id': repo2['id']})
        # Verify that number of modules from the first repo has not changed
        self.assertEqual(
            modules_num, len(PuppetModule.list({'repository-id':
                                                repo1['id']})))
Exemple #10
0
def test_negative_synchronize_custom_product_past_sync_date(module_org):
    """Verify product won't get synced immediately after adding association
    with a sync plan which has already been started

    :id: c80f5c0c-3863-47da-8d7b-7d65c73664b0

    :expectedresults: Repository was not synchronized

    :BZ: 1279539

    :CaseLevel: System
    """
    sync_plan = make_sync_plan({
        'enabled':
        'true',
        'organization-id':
        module_org.id,
        'sync-date':
        datetime.utcnow().strftime(SYNC_DATE_FMT),
    })
    product = make_product({'organization-id': module_org.id})
    repo = make_repository({'product-id': product['id']})
    Product.set_sync_plan({
        'id': product['id'],
        'sync-plan-id': sync_plan['id']
    })
    with pytest.raises(AssertionError):
        validate_task_status(repo['id'], max_tries=2)
Exemple #11
0
    def test_negative_synchronize_custom_product_current_sync_date(self):
        """Verify product won't get synced immediately after adding association
        with a sync plan which has already been started

        :id: c80f5c0c-3863-47da-8d7b-7d65c73664b0

        :expectedresults: Repository was not synchronized

        :BZ: 1279539

        :CaseLevel: System
        """
        sync_plan = self._make_sync_plan({
            'enabled': 'true',
            'organization-id': self.org['id'],
            'sync-date': datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S"),
        })
        product = make_product({'organization-id': self.org['id']})
        repo = make_repository({'product-id': product['id']})
        Product.set_sync_plan({
            'id': product['id'],
            'sync-plan-id': sync_plan['id'],
        })
        with self.assertRaises(AssertionError):
            self.validate_repo_content(
                repo,
                ['errata', 'package-groups', 'packages'],
                max_attempts=5,
            )
Exemple #12
0
def test_positive_add_repo_from_product_with_repo(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
    one repository

    :id: da568a0e-69b1-498e-a747-6881aac7409e

    :expectedresults: gpg key is associated with the repository but not
        with the product

    :CaseLevel: Integration
    """
    product = make_product({'organization-id': module_org.id})
    repo = make_repository({'product-id': product['id']})
    gpg_key = make_content_credential({'organization-id': module_org.id})
    Repository.update({
        'gpg-key-id': gpg_key['id'],
        'id': repo['id'],
        'organization-id': module_org.id
    })
    product = Product.info({
        'id': product['id'],
        'organization-id': module_org.id
    })
    repo = Repository.info({'id': repo['id']})
    assert repo['gpg-key']['id'] == gpg_key['id']
    assert product['gpg'].get('gpg-key-id') != gpg_key['id']
 def setUpClass(cls):
     """Init single organization, product and repository for all tests"""
     super(TestContentViewFilter, cls).setUpClass()
     cls.org = make_org()
     cls.product = make_product({u'organization-id': cls.org['id']})
     cls.repo = make_repository({u'product-id': cls.product['id']})
     Repository.synchronize({u'id': cls.repo['id']})
Exemple #14
0
def test_positive_synchronize_custom_products_future_sync_date(module_org):
    """Create a sync plan with sync date in a future and sync multiple
    custom products with multiple repos automatically.

    :id: dd262cf3-b836-422c-baca-b3adbc532478

    :expectedresults: Products are synchronized successfully.

    :CaseLevel: System

    :BZ: 1655595
    """
    delay = 4 * 60  # delay for sync date in seconds
    products = [
        make_product({'organization-id': module_org.id}) for _ in range(3)
    ]
    repos = [
        make_repository({'product-id': product['id']}) for product in products
        for _ in range(2)
    ]
    sync_plan = make_sync_plan({
        'enabled':
        'true',
        'organization-id':
        module_org.id,
        'sync-date': (datetime.utcnow().replace(second=0) +
                      timedelta(seconds=delay)).strftime(SYNC_DATE_FMT),
        'cron-expression': ["*/4 * * * *"],
    })
    # Verify products have not been synced yet
    logger.info(
        f"Check products {products[0]['name']} and {products[1]['name']}"
        f" were not synced before sync plan created in org {module_org.label}")
    for repo in repos:
        with pytest.raises(AssertionError):
            validate_task_status(repo['id'], module_org.id, max_tries=1)
    # Associate sync plan with products
    for product in products:
        Product.set_sync_plan({
            'id': product['id'],
            'sync-plan-id': sync_plan['id']
        })
    # Wait quarter of expected time
    logger.info(
        f"Waiting {(delay / 4)} seconds to check products {products[0]['name']}"
        f" and {products[1]['name']} were not synced by {sync_plan['name']} ")
    sleep(delay / 4)
    # Verify products have not been synced yet
    for repo in repos:
        with pytest.raises(AssertionError):
            validate_task_status(repo['id'], module_org.id, max_tries=1)
    # Wait the rest of expected time
    logger.info(
        f"Waiting {(delay * 3 / 4)} seconds to check product {products[0]['name']}"
        f" and {products[1]['name']} were synced by {sync_plan['name']}")
    sleep(delay * 3 / 4)
    # Verify products were synced successfully
    for repo in repos:
        validate_task_status(repo['id'], module_org.id)
        validate_repo_content(repo, ['errata', 'package-groups', 'packages'])
    def test_positive_list_multiple_repos(self):
        """Verify that puppet-modules list for specific repo is correct
        and does not affected by other repositories.

        @id: f36d25b3-2495-4e89-a1cf-e39d52762d95

        @Assert: Number of modules has no changed after a second repo
        was synced.
        """
        # Verify that number of synced modules is correct
        repo1 = Repository.info({'id': self.repo['id']})
        repo_content_count = repo1['content-counts']['puppet-modules']
        modules_num = len(
            PuppetModule.list({'repository-id': repo1['id']}))
        self.assertEqual(repo_content_count, str(modules_num))
        # Create and sync second repo
        repo2 = make_repository({
            u'organization-id': self.org['id'],
            u'product-id': self.product['id'],
            u'content-type': u'puppet',
            u'url': FAKE_1_PUPPET_REPO,
        })
        Repository.synchronize({'id': repo2['id']})
        # Verify that number of modules from the first repo has not changed
        self.assertEqual(
            modules_num,
            len(PuppetModule.list({'repository-id': repo1['id']}))
        )
Exemple #16
0
def test_positive_check_errata_dates(module_org):
    """Check for errata dates in `hammer erratum list`

    :id: b19286ae-bdb4-4319-87d0-5d3ff06c5f38

    :expectedresults: Display errata date when using hammer erratum list

    :CaseImportance: High

    :BZ: 1695163
    """
    product = entities.Product(organization=module_org).create()
    repo = make_repository({
        'content-type': 'yum',
        'product-id': product.id,
        'url': REPO_WITH_ERRATA['url']
    })
    # Synchronize custom repository
    Repository.synchronize({'id': repo['id']})
    result = Erratum.list(options={'per-page': '5', 'fields': 'Issued'})
    assert 'issued' in result[0]

    # Verify any errata ISSUED date from stdout
    validate_issued_date = datetime.strptime(result[0]['issued'],
                                             '%Y-%m-%d').date()
    assert isinstance(validate_issued_date, date)

    result = Erratum.list(options={'per-page': '5', 'fields': 'Updated'})
    assert 'updated' in result[0]

    # Verify any errata UPDATED date from stdout
    validate_updated_date = datetime.strptime(result[0]['updated'],
                                              '%Y-%m-%d').date()
    assert isinstance(validate_updated_date, date)
Exemple #17
0
    def _make_repository(self, options=None):
        """Makes a new repository and asserts its success"""

        if options is None:
            options = {}

        if not options.get('product-id', None):
            options[u'product-id'] = self.product['id']

        new_repo = make_repository(options)

        # Fetch it
        result = Repository.info(
            {
                u'id': new_repo['id']
            }
        )

        self.assertEqual(
            result.return_code,
            0,
            "Repository was not found")
        self.assertEqual(
            len(result.stderr), 0, "No error was expected")

        # Return the repository dictionary
        return new_repo
Exemple #18
0
    def test_positive_package_count(self):
        """Check that packages count is correctly filtered by product id

        :id: 151f60a3-0b94-4658-8b0d-0d022f4f1d8f

        :expectedresults: Packages only from synced product returned

        :BZ: 1422552

        :CaseLevel: Integration
        """
        org = make_org()
        for _ in range(3):
            product = make_product({'organization-id': org['id']})
            repo = make_repository({
                'product-id': product['id'],
                'url': FAKE_0_YUM_REPO,
            })
            Product.synchronize({
                'id': product['id'],
                'organization-id': org['id'],
            })
            packages = Package.list({'product-id': product['id']})
            repo = Repository.info({'id': repo['id']})
            self.assertEqual(int(repo['content-counts']['packages']),
                             len(packages))
            self.assertEqual(len(packages), FAKE_0_YUM_REPO_PACKAGES_COUNT)
Exemple #19
0
    def test_positive_sync_publish_cv(self):
        """Synchronize repository with DRPMs, add repository to content view
        and publish content view

        @id: 014bfc80-4622-422e-a0ec-755b1d9f845e

        @Assert: drpms can be listed in content view
        """
        repo = make_repository({
            'product-id': self.product['id'],
            'url': FAKE_YUM_DRPM_REPO,
        })
        Repository.synchronize({'id': repo['id']})
        cv = make_content_view({'organization-id': self.org['id']})
        ContentView.add_repository({
            'id': cv['id'],
            'repository-id': repo['id'],
        })
        ContentView.publish({'id': cv['id']})
        result = ssh.command(
            'ls /var/lib/pulp/published/yum/https/repos/{}/content_views/{}'
            '/1.0/custom/{}/{}/drpms/ | grep .drpm'.format(
                self.org['label'],
                cv['label'],
                self.product['label'],
                repo['label'],
            ))
        self.assertEqual(result.return_code, 0)
        self.assertGreaterEqual(len(result.stdout), 1)
Exemple #20
0
    def test_positive_sync_publish_cv(self):
        """Synchronize repository with SRPMs, add repository to content view
        and publish content view

        @id: 78cd6345-9c6c-490a-a44d-2ad64b7e959b

        @Assert: srpms can be listed in content view
        """
        repo = make_repository({
            'product-id': self.product['id'],
            'url': FAKE_YUM_SRPM_REPO,
        })
        Repository.synchronize({'id': repo['id']})
        cv = make_content_view({'organization-id': self.org['id']})
        ContentView.add_repository({
            'id': cv['id'],
            'repository-id': repo['id'],
        })
        ContentView.publish({'id': cv['id']})
        result = ssh.command(
            'ls /var/lib/pulp/published/yum/https/repos/{}/content_views/{}'
            '/1.0/custom/{}/{}/ | grep .src.rpm'.format(
                self.org['label'],
                cv['label'],
                self.product['label'],
                repo['label'],
            ))
        self.assertEqual(result.return_code, 0)
        self.assertGreaterEqual(len(result.stdout), 1)
    def test_update_cvf_with_new_repo_negative(self):
        """Test: Try to update filter and assign repository which does not
        belong to filter content view

        @Feature: Content View Filter

        @Assert: Content view filter is not updated

        """
        result = ContentView.filter_create({
            'content-view-id': self.content_view['id'],
            'type': 'rpm',
            'name': self.cvf_name,
            'repository-ids': self.repo['id'],
        })
        self.assertEqual(result.return_code, 0)

        new_repo = make_repository({u'product-id': self.product['id']})

        result = ContentView.filter_update({
            'content-view-id': self.content_view['id'],
            'name': self.cvf_name,
            'repository-ids': new_repo['id'],
        })
        self.assertNotEqual(result.return_code, 0)
        self.assertNotEqual(len(result.stderr), 0)
Exemple #22
0
    def test_positive_add_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

        :id: b05c5223-44d5-4a48-9d99-18ca351c84a5

        :expectedresults: gpg key is associated with product as well as with
            the repositories

        :CaseLevel: Integration
        """
        product = make_product({'organization-id': self.org['id']})
        repos = [
            make_repository({'product-id': product['id']})
            for _ in range(gen_integer(2, 5))
        ]
        gpg_key = make_gpg_key({'organization-id': self.org['id']})
        Product.update({
            'gpg-key': gpg_key['name'],
            'id': product['id'],
            'organization-id': self.org['id'],
        })
        product = Product.info({
            'id': product['id'],
            'organization-id': self.org['id'],
        })
        self.assertEqual(product['gpg']['gpg-key-id'], gpg_key['id'])
        for repo in repos:
            repo = Repository.info({'id': repo['id']})
            self.assertEqual(repo['gpg-key']['id'], gpg_key['id'])
Exemple #23
0
    def test_positive_synchronize_custom_product_future_sync_date(self):
        """Create a sync plan with sync date in a future and sync one custom
        product with it automatically.

        @Assert: Product is synchronized successfully.

        @Feature: SyncPlan
        """
        delay = 10 * 60  # delay for sync date in seconds
        sync_plan = self._make_sync_plan({
            'enabled': 'true',
            'organization-id': self.org['id'],
            'sync-date': (datetime.utcnow() + timedelta(seconds=delay))
                        .strftime("%Y-%m-%d %H:%M:%S"),
        })
        product = make_product({'organization-id': self.org['id']})
        repo = make_repository({'product-id': product['id']})
        # Verify product is not synced and doesn't have any content
        self.validate_repo_content(
            repo, ['errata', 'packages'], after_sync=False)
        # Associate sync plan with product
        Product.set_sync_plan({
            'id': product['id'],
            'sync-plan-id': sync_plan['id'],
        })
        # Wait half of expected time
        sleep(delay/2)
        # Verify product has not been synced yet
        self.validate_repo_content(
            repo, ['errata', 'packages'], after_sync=False)
        # Wait the rest of expected time
        sleep(delay/2)
        # Verify product was synced successfully
        self.validate_repo_content(
            repo, ['errata', 'package-groups', 'packages'])
    def test_positive_sync_publish_promote_cv(self):
        """Synchronize repository with DRPMs, add repository to content view,
        publish and promote content view to lifecycle environment

        @id: a01cb12b-d388-4902-8532-714f4e28ec56

        @Assert: drpms can be listed in content view in proper lifecycle
        environment
        """
        lce = make_lifecycle_environment({"organization-id": self.org["id"]})
        repo = make_repository({"product-id": self.product["id"], "url": FAKE_YUM_DRPM_REPO})
        Repository.synchronize({"id": repo["id"]})
        cv = make_content_view({"organization-id": self.org["id"]})
        ContentView.add_repository({"id": cv["id"], "repository-id": repo["id"]})
        ContentView.publish({"id": cv["id"]})
        content_view = ContentView.info({"id": cv["id"]})
        cvv = content_view["versions"][0]
        ContentView.version_promote({"id": cvv["id"], "to-lifecycle-environment-id": lce["id"]})
        result = ssh.command(
            "ls /var/lib/pulp/published/yum/https/repos/{}/{}/{}/custom/{}/{}"
            "/drpms/ | grep .drpm".format(
                self.org["label"], lce["label"], cv["label"], self.product["label"], repo["label"]
            )
        )
        self.assertEqual(result.return_code, 0)
        self.assertGreaterEqual(len(result.stdout), 1)
    def test_negative_update_with_invalid_repo_id(self):
        """Try to update filter and assign repository which does not belong to
        filter content view

        :id: aa550619-c436-4184-bb29-2becadf69e5b

        :expectedresults: Content view filter is not updated


        :CaseImportance: Critical
        """
        cvf_name = gen_string('utf8')
        ContentView.filter.create({
            'content-view-id': self.content_view['id'],
            'name': cvf_name,
            'repository-ids': self.repo['id'],
            'type': 'rpm',
        })
        new_repo = make_repository({u'product-id': self.product['id']})
        with self.assertRaises(CLIReturnCodeError):
            ContentView.filter.update({
                'content-view-id': self.content_view['id'],
                'name': cvf_name,
                'repository-ids': new_repo['id'],
            })
Exemple #26
0
    def test_positive_synchronize_custom_product_current_sync_date(self):
        """Create a sync plan with current datetime as a sync date, add a
        custom product and verify the product gets synchronized on the next
        sync occurrence

        @Assert: Product is synchronized successfully.

        @Feature: SyncPlan

        @BZ: 1279539
        """
        interval = 60 * 60  # 'hourly' sync interval in seconds
        sync_plan = self._make_sync_plan({
            'enabled': 'true',
            'interval': 'hourly',
            'organization-id': self.org['id'],
            'sync-date': datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S"),
        })
        product = make_product({'organization-id': self.org['id']})
        repo = make_repository({'product-id': product['id']})
        # Associate sync plan with product
        Product.set_sync_plan({
            'id': product['id'],
            'sync-plan-id': sync_plan['id'],
        })
        # Wait half of expected time
        sleep(interval / 2)
        # Verify product has not been synced yet
        self.validate_repo_content(
            repo, ['errata', 'packages'], after_sync=False)
        # Wait the rest of expected time
        sleep(interval / 2)
        # Verify product was synced successfully
        self.validate_repo_content(
            repo, ['errata', 'package-groups', 'packages'])
Exemple #27
0
def test_positive_add_product_with_repo(module_org):
    """Create gpg key with valid name and valid gpg key via file
    import then associate it with custom product that has one repository

    :id: f315eadd-e65b-4952-912f-f640867ad656

    :expectedresults: gpg key is associated with product as well as with
        the repository

    :CaseLevel: Integration
    """
    product = make_product({'organization-id': module_org.id})
    repo = make_repository({'product-id': product['id']})
    gpg_key = make_content_credential({'organization-id': module_org.id})
    Product.update({
        'gpg-key': gpg_key['name'],
        'id': product['id'],
        'organization-id': module_org.id
    })
    product = Product.info({
        'id': product['id'],
        'organization-id': module_org.id
    })
    repo = Repository.info({'id': repo['id']})
    assert product['gpg']['gpg-key-id'] == gpg_key['id']
    assert repo['gpg-key']['id'] == gpg_key['id']
Exemple #28
0
    def test_positive_add_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

        :id: b05c5223-44d5-4a48-9d99-18ca351c84a5

        :expectedresults: gpg key is associated with product as well as with
            the repositories

        :CaseLevel: Integration
        """
        product = make_product({'organization-id': self.org['id']})
        repos = [
            make_repository({'product-id': product['id']})
            for _ in range(gen_integer(2, 5))
        ]
        gpg_key = make_gpg_key({'organization-id': self.org['id']})
        Product.update({
            'gpg-key': gpg_key['name'],
            'id': product['id'],
            'organization-id': self.org['id'],
        })
        product = Product.info({
            'id': product['id'],
            'organization-id': self.org['id'],
        })
        self.assertEqual(product['gpg']['gpg-key-id'], gpg_key['id'])
        for repo in repos:
            repo = Repository.info({'id': repo['id']})
            self.assertEqual(repo['gpg-key']['id'], gpg_key['id'])
Exemple #29
0
def test_positive_add_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

    :id: 76683f3e-7705-4719-996e-c026839053bb

    :expectedresults: gpg key is associated with product as well as with
        the repositories

    :CaseLevel: Integration
    """
    product = make_product({'organization-id': module_org.id})
    repos = [
        make_repository({'product-id': product['id']})
        for _ in range(gen_integer(2, 5))
    ]
    gpg_key = make_content_credential({'organization-id': module_org.id})
    Product.update({
        'gpg-key': gpg_key['name'],
        'id': product['id'],
        'organization-id': module_org.id
    })
    product = Product.info({
        'id': product['id'],
        'organization-id': module_org.id
    })
    assert product['gpg']['gpg-key-id'] == gpg_key['id']
    for repo in repos:
        repo = Repository.info({'id': repo['id']})
        assert repo['gpg-key']['id'] == gpg_key['id']
Exemple #30
0
    def make_file_repository_upload_contents(self, options=None):
        """Makes a new File repository, Upload File/Multiple Files
        and asserts its success.
        """
        if options is None:
            options = {
                'name': self.file_repo_name,
                'product-id': self.product['id'],
                'content-type': 'file',
            }
        if not options.get('content-type'):
            raise CLIFactoryError('Please provide a valid Content Type.')
        file_repo = make_repository(options)
        remote_path = "/tmp/{0}".format(RPM_TO_UPLOAD)
        if 'multi_upload' not in options or not options['multi_upload']:
            ssh.upload_file(local_file=get_data_file(RPM_TO_UPLOAD), remote_file=remote_path)
        else:
            remote_path = "/tmp/{}/".format(gen_string('alpha'))
            ssh.upload_files(local_dir=os.getcwd() + "/../data/", remote_dir=remote_path)

        result = Repository.upload_content(
            {
                'name': file_repo['name'],
                'organization': file_repo['organization'],
                'path': remote_path,
                'product-id': file_repo['product']['id'],
            }
        )
        self.assertIn(
            "Successfully uploaded file '{0}'".format(RPM_TO_UPLOAD), result[0]['message']
        )
        file_repo = Repository.info({'id': file_repo['id']})
        self.assertGreater(int(file_repo['content-counts']['files']), 0)
        return file_repo
Exemple #31
0
    def test_negative_update_with_invalid_repo_id(self):
        """Try to update filter and assign repository which does not belong to
        filter content view

        :id: aa550619-c436-4184-bb29-2becadf69e5b

        :expectedresults: Content view filter is not updated


        :CaseImportance: Critical
        """
        cvf_name = gen_string('utf8')
        ContentView.filter.create({
            'content-view-id': self.content_view['id'],
            'name': cvf_name,
            'repository-ids': self.repo['id'],
            'type': 'rpm',
        })
        new_repo = make_repository({u'product-id': self.product['id']})
        with self.assertRaises(CLIReturnCodeError):
            ContentView.filter.update({
                'content-view-id':
                self.content_view['id'],
                'name':
                cvf_name,
                'repository-ids':
                new_repo['id'],
            })
Exemple #32
0
    def test_positive_add_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

        :id: 5529a852-9ef6-48f8-b2bc-2bbf463657dd

        :expectedresults: gpg key is associated with product as well as with
            the repository

        :CaseLevel: Integration
        """
        product = make_product({'organization-id': self.org['id']})
        repo = make_repository({'product-id': product['id']})
        gpg_key = make_gpg_key({'organization-id': self.org['id']})
        Product.update({
            'gpg-key': gpg_key['name'],
            'id': product['id'],
            'organization-id': self.org['id'],
        })
        product = Product.info({
            'id': product['id'],
            'organization-id': self.org['id'],
        })
        repo = Repository.info({'id': repo['id']})
        self.assertEqual(product['gpg']['gpg-key-id'], gpg_key['id'])
        self.assertEqual(repo['gpg-key']['id'], gpg_key['id'])
    def test_update_cvf_repo(self):
        """Test: Create new content view filter and apply it to existing
        content view that has repository assigned to it. Try to update that
        filter and change affected repository on another one.

        @Feature: Content View Filter

        @Assert: Content view filter updated successfully and has new
        repository affected

        """
        cvf_name = gen_string("utf8")
        ContentView.filter_create(
            {
                "content-view-id": self.content_view["id"],
                "name": cvf_name,
                "repository-ids": self.repo["id"],
                "type": "rpm",
            }
        )
        cvf = ContentView.filter_info({u"content-view-id": self.content_view["id"], u"name": cvf_name})
        self.assertEqual(len(cvf["repositories"]), 1)
        self.assertEqual(cvf["repositories"][0]["name"], self.repo["name"])

        new_repo = make_repository({u"product-id": self.product["id"]})
        ContentView.add_repository({u"id": self.content_view["id"], u"repository-id": new_repo["id"]})

        ContentView.filter_update(
            {"content-view-id": self.content_view["id"], "name": cvf_name, "repository-ids": new_repo["id"]}
        )

        cvf = ContentView.filter_info({u"content-view-id": self.content_view["id"], u"name": cvf_name})
        self.assertEqual(len(cvf["repositories"]), 1)
        self.assertNotEqual(cvf["repositories"][0]["name"], self.repo["name"])
        self.assertEqual(cvf["repositories"][0]["name"], new_repo["name"])
Exemple #34
0
    def test_negative_update_with_invalid_repo_id(self):
        """Try to update filter and assign repository which does not belong to
        filter content view

        @Feature: Content View Filter

        @Assert: Content view filter is not updated

        """
        cvf_name = gen_string('utf8')
        ContentView.filter_create({
            'content-view-id': self.content_view['id'],
            'name': cvf_name,
            'repository-ids': self.repo['id'],
            'type': 'rpm',
        })
        new_repo = make_repository({u'product-id': self.product['id']})
        with self.assertRaises(CLIReturnCodeError):
            ContentView.filter_update({
                'content-view-id':
                self.content_view['id'],
                'name':
                cvf_name,
                'repository-ids':
                new_repo['id'],
            })
Exemple #35
0
    def test_positive_add_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

        :id: 1427f145-9faf-41ef-ae42-dc91d61ce1f6

        :expectedresults: gpg key is associated with the repository but not
            with the product

        :CaseLevel: Integration
        """
        product = make_product({'organization-id': self.org['id']})
        repo = make_repository({'product-id': product['id']})
        gpg_key = make_gpg_key({'organization-id': self.org['id']})
        Repository.update({
            'gpg-key-id': gpg_key['id'],
            'id': repo['id'],
            'organization-id': self.org['id'],
        })
        product = Product.info({
            'id': product['id'],
            'organization-id': self.org['id'],
        })
        repo = Repository.info({'id': repo['id']})
        self.assertEqual(repo['gpg-key']['id'], gpg_key['id'])
        self.assertNotEqual(product['gpg'].get('gpg-key-id'), gpg_key['id'])
 def setUpClass(cls):
     """Create Directory for all CV Sync Tests in /tmp"""
     super(ContentViewSync, cls).setUpClass()
     cls.exporting_org = make_org()
     cls.exporting_prod = gen_string('alpha')
     product = make_product({
         'organization-id': cls.exporting_org['id'],
         'name': cls.exporting_prod
     })
     cls.exporting_repo = gen_string('alpha')
     repo = make_repository({
         'name': cls.exporting_repo,
         'download-policy': 'immediate',
         'product-id': product['id']
     })
     Repository.synchronize({'id': repo['id']})
     cls.exporting_cv = gen_string('alpha')
     content_view = make_content_view({
         'name': cls.exporting_cv,
         'organization-id': cls.exporting_org['id']
     })
     ContentView.add_repository({
         'id': content_view['id'],
         'organization-id': cls.exporting_org['id'],
         'repository-id': repo['id']
     })
     ContentView.publish({u'id': content_view['id']})
     content_view = ContentView.info({u'id': content_view['id']})
     cls.exporting_cvv_id = content_view['versions'][0]['id']
    def set_importing_org(self, product, repo, cv):
        """Sets same CV, product and repository in importing organization as
        exporting organization

        :param str product: The product name same as exporting product
        :param str repo: The repo name same as exporting repo
        :param str cv: The cv name same as exporting cv
        """
        self.importing_org = make_org()
        importing_prod = make_product({
            'organization-id': self.importing_org['id'],
            'name': product
        })
        importing_repo = make_repository({
            'name': repo,
            'download-policy': 'immediate',
            'product-id': importing_prod['id']
        })
        self.importing_cv = make_content_view({
            'name': cv,
            'organization-id': self.importing_org['id']
        })
        ContentView.add_repository({
            'id': self.importing_cv['id'],
            'organization-id': self.importing_org['id'],
            'repository-id': importing_repo['id']
        })
Exemple #38
0
    def test_positive_add_repo_from_product_with_repo(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
        one repository

        @feature: GPG Keys

        @assert: gpg key is associated with the repository but not with
        the product
        """
        product = make_product({'organization-id': self.org['id']})
        repo = make_repository({'product-id': product['id']})
        gpg_key = make_gpg_key({'organization-id': self.org['id']})
        Repository.update({
            'gpg-key-id': gpg_key['id'],
            'id': repo['id'],
            'organization-id': self.org['id'],
        })
        product = Product.info({
            'id': product['id'],
            'organization-id': self.org['id'],
        })
        repo = Repository.info({'id': repo['id']})
        self.assertEqual(repo['gpg-key']['id'], gpg_key['id'])
        self.assertNotEqual(product['gpg'].get('gpg-key-id'), gpg_key['id'])
Exemple #39
0
    def test_positive_add_product_with_repos(self):
        """@test: 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

        @feature: GPG Keys

        @assert: gpg key is associated with product as well as with
        the repositories
        """
        product = make_product({'organization-id': self.org['id']})
        repos = [
            make_repository({'product-id': product['id']})
            for _ in range(gen_integer(2, 5))
        ]
        gpg_key = make_gpg_key({'organization-id': self.org['id']})
        Product.update({
            'gpg-key': gpg_key['name'],
            'id': product['id'],
            'organization-id': self.org['id'],
        })
        product = Product.info({
            'id': product['id'],
            'organization-id': self.org['id'],
        })
        self.assertEqual(product['gpg']['gpg-key-id'], gpg_key['id'])
        for repo in repos:
            repo = Repository.info({'id': repo['id']})
            self.assertEqual(repo['gpg-key']['id'], gpg_key['id'])
Exemple #40
0
    def test_positive_add_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

        @id: 1427f145-9faf-41ef-ae42-dc91d61ce1f6

        @assert: gpg key is associated with the repository but not with
        the product

        @CaseLevel: Integration
        """
        product = make_product({'organization-id': self.org['id']})
        repo = make_repository({'product-id': product['id']})
        gpg_key = make_gpg_key({'organization-id': self.org['id']})
        Repository.update({
            'gpg-key-id': gpg_key['id'],
            'id': repo['id'],
            'organization-id': self.org['id'],
        })
        product = Product.info({
            'id': product['id'],
            'organization-id': self.org['id'],
        })
        repo = Repository.info({'id': repo['id']})
        self.assertEqual(repo['gpg-key']['id'], gpg_key['id'])
        self.assertNotEqual(product['gpg'].get('gpg-key-id'), gpg_key['id'])
Exemple #41
0
    def test_positive_add_repo_from_product_with_repos(self):
        """@test: Create gpg key via file import and associate with custom repo

        GPGKey should contain valid name and valid key and should be associated
        to one repository from custom product. Make sure custom product should
        have more than one repository.

        @feature: GPG Keys

        @assert: gpg key is associated with the repository
        """
        product = make_product({'organization-id': self.org['id']})
        repos = [
            make_repository({'product-id': product['id']})
            for _ in range(gen_integer(2, 5))
        ]
        gpg_key = make_gpg_key({'organization-id': self.org['id']})
        Repository.update({
            'gpg-key': gpg_key['name'],
            'id': repos[0]['id'],
            'organization-id': self.org['id'],
        })
        product = Product.info({
            'id': product['id'],
            'organization-id': self.org['id'],
        })
        self.assertNotEqual(product['gpg'].get('gpg-key-id'), gpg_key['id'])
        # First repo should have a valid gpg key assigned
        repo = Repository.info({'id': repos.pop(0)['id']})
        self.assertEqual(repo['gpg-key']['id'], gpg_key['id'])
        # The rest of repos should not
        for repo in repos:
            repo = Repository.info({'id': repo['id']})
            self.assertNotEqual(repo['gpg-key'].get('id'), gpg_key['id'])
Exemple #42
0
    def test_positive_add_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

        @id: 5529a852-9ef6-48f8-b2bc-2bbf463657dd

        @assert: gpg key is associated with product as well as with
        the repository

        @CaseLevel: Integration
        """
        product = make_product({'organization-id': self.org['id']})
        repo = make_repository({'product-id': product['id']})
        gpg_key = make_gpg_key({'organization-id': self.org['id']})
        Product.update({
            'gpg-key': gpg_key['name'],
            'id': product['id'],
            'organization-id': self.org['id'],
        })
        product = Product.info({
            'id': product['id'],
            'organization-id': self.org['id'],
        })
        repo = Repository.info({'id': repo['id']})
        self.assertEqual(product['gpg']['gpg-key-id'], gpg_key['id'])
        self.assertEqual(repo['gpg-key']['id'], gpg_key['id'])
Exemple #43
0
def setup_content(request):
    """Pytest fixture for setting up an organization, manifest, content-view,
    lifecycle environment, and activation key with subscriptions"""
    org = make_org()
    with manifests.clone() as manifest:
        upload_file(manifest.content, manifest.filename)
    new_product = make_product({'organization-id': org['id']})
    new_repo = make_repository({'product-id': new_product['id']})
    Repository.synchronize({'id': new_repo['id']})
    content_view = make_content_view({'organization-id': org['id']})
    ContentView.add_repository(
        {'id': content_view['id'], 'organization-id': org['id'], 'repository-id': new_repo['id']}
    )
    ContentView.publish({'id': content_view['id']})
    env = make_lifecycle_environment({'organization-id': org['id']})
    cvv = ContentView.info({'id': content_view['id']})['versions'][0]
    ContentView.version_promote({'id': cvv['id'], 'to-lifecycle-environment-id': env['id']})
    new_ak = make_activation_key(
        {
            'lifecycle-environment-id': env['id'],
            'content-view': content_view['name'],
            'organization-id': org['id'],
            'auto-attach': False,
        }
    )
    subs_id = Subscription.list({'organization-id': org['id']}, per_page=False)
    ActivationKey.add_subscription({'id': new_ak['id'], 'subscription-id': subs_id[0]['id']})
    request.cls.setup_org = org
    request.cls.setup_new_ak = new_ak
    request.cls.setup_subs_id = subs_id
    request.cls.setup_env = env
    request.cls.setup_content_view = content_view
    def test_negative_update_with_invalid_repo_id(self, module_org,
                                                  module_product, sync_repo,
                                                  content_view):
        """Try to update filter and assign repository which does not belong to
        filter content view

        :id: aa550619-c436-4184-bb29-2becadf69e5b

        :expectedresults: Content view filter is not updated

        :CaseImportance: Critical
        """
        cvf_name = gen_string('utf8')
        ContentView.filter.create(
            {
                'content-view-id': content_view['id'],
                'name': cvf_name,
                'repository-ids': sync_repo['id'],
                'type': 'rpm',
            }, )
        new_repo = make_repository(
            {
                'organization-id': module_org.id,
                'product-id': module_product.id
            }, )
        with pytest.raises(CLIReturnCodeError):
            ContentView.filter.update({
                'content-view-id': content_view['id'],
                'name': cvf_name,
                'repository-ids': new_repo['id'],
            })
def sync_repo(module_org, module_product):
    repo = make_repository({
        'organization-id': module_org.id,
        'product-id': module_product.id
    })
    Repository.synchronize({'id': repo['id']})
    return repo
Exemple #46
0
    def test_positive_synchronize_custom_products_future_sync_date(self):
        """Create a sync plan with sync date in a future and sync multiple
        custom products with multiple repos automatically.

        :id: dd262cf3-b836-422c-baca-b3adbc532478

        :expectedresults: Products are synchronized successfully.

        :CaseLevel: System
        """
        delay = 6 * 60  # delay for sync date in seconds
        sync_plan = self._make_sync_plan({
            'enabled': 'true',
            'organization-id': self.org['id'],
            'sync-date': (datetime.utcnow() + timedelta(seconds=delay))
                        .strftime("%Y-%m-%d %H:%M:%S"),
        })
        products = [
            make_product({'organization-id': self.org['id']})
            for _ in range(3)
        ]
        repos = [
            make_repository({'product-id': product['id']})
            for product in products
            for _ in range(2)
        ]
        # Verify products have not been synced yet
        for repo in repos:
            with self.assertRaises(AssertionError):
                self.validate_task_status(repo['id'], max_tries=2)
        # Associate sync plan with products
        for product in products:
            Product.set_sync_plan({
                'id': product['id'],
                'sync-plan-id': sync_plan['id'],
            })
        # Wait half of expected time
        self.logger.info('Waiting {0} seconds to check products'
                         ' were not synced'.format(delay/2))
        sleep(delay/4)
        # Verify products has not been synced yet
        for repo in repos:
            with self.assertRaises(AssertionError):
                self.validate_task_status(repo['id'], max_tries=2)
        # Wait the rest of expected time
        self.logger.info('Waiting {0} seconds to check products'
                         ' were synced'.format(delay/2))
        sleep(delay * 3/4)
        # Re-calculate and Update with the current UTC time
        SyncPlan.update({
            u'id': sync_plan['id'],
            u'sync-date': (datetime.utcnow() + timedelta(seconds=delay))
                .strftime("%Y-%m-%d %H:%M:%S"),
        })
        # Verify product was synced successfully
        for repo in repos:
            self.validate_task_status(repo['id'], repo_name=repo['name'])
            self.validate_repo_content(
                repo, ['errata', 'package-groups', 'packages'])
    def test_positive_synchronize_custom_products_future_sync_date(self):
        """Create a sync plan with sync date in a future and sync multiple
        custom products with multiple repos automatically.

        :id: dd262cf3-b836-422c-baca-b3adbc532478

        :expectedresults: Products are synchronized successfully.

        :CaseLevel: System
        """
        delay = 6 * 60  # delay for sync date in seconds
        sync_plan = self._make_sync_plan({
            'enabled': 'true',
            'organization-id': self.org['id'],
            'sync-date': (datetime.utcnow() + timedelta(seconds=delay))
                        .strftime("%Y-%m-%d %H:%M:%S"),
        })
        products = [
            make_product({'organization-id': self.org['id']})
            for _ in range(3)
        ]
        repos = [
            make_repository({'product-id': product['id']})
            for product in products
            for _ in range(2)
        ]
        # Verify products have not been synced yet
        for repo in repos:
            with self.assertRaises(AssertionError):
                self.validate_task_status(repo['id'], max_tries=2)
        # Associate sync plan with products
        for product in products:
            Product.set_sync_plan({
                'id': product['id'],
                'sync-plan-id': sync_plan['id'],
            })
        # Wait half of expected time
        self.logger.info('Waiting {0} seconds to check products'
                         ' were not synced'.format(delay/2))
        sleep(delay/4)
        # Verify products has not been synced yet
        for repo in repos:
            with self.assertRaises(AssertionError):
                self.validate_task_status(repo['id'], max_tries=2)
        # Wait the rest of expected time
        self.logger.info('Waiting {0} seconds to check products'
                         ' were synced'.format(delay/2))
        sleep(delay * 3/4)
        # Re-calculate and Update with the current UTC time
        SyncPlan.update({
            u'id': sync_plan['id'],
            u'sync-date': (datetime.utcnow() + timedelta(seconds=delay))
                .strftime("%Y-%m-%d %H:%M:%S"),
        })
        # Verify product was synced successfully
        for repo in repos:
            self.validate_task_status(repo['id'], repo_name=repo['name'])
            self.validate_repo_content(
                repo, ['errata', 'package-groups', 'packages'])
Exemple #48
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
Exemple #49
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)
Exemple #50
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)
 def setUpClass(cls):
     """Init single organization, product and repository for all tests"""
     super(TestContentViewFilter, cls).setUpClass()
     cls.org = make_org()
     cls.product = make_product({u"organization-id": cls.org["id"]})
     cls.repo = make_repository({u"product-id": cls.product["id"]})
     Repository.synchronize({u"id": cls.repo["id"]})
     cls.content_view = make_content_view({u"organization-id": cls.org["id"]})
     ContentView.add_repository({u"id": cls.content_view["id"], u"repository-id": cls.repo["id"]})
Exemple #52
0
    def _make_repository(self, options=None):
        """Makes a new repository and asserts its success"""
        if options is None:
            options = {}

        if options.get('product-id') is None:
            options[u'product-id'] = self.product['id']

        return make_repository(options)
Exemple #53
0
    def test_positive_synchronize_custom_product_past_sync_date(self):
        """Create a sync plan with a past datetime as a sync date, add a
        custom product and verify the product gets synchronized on the next
        sync occurrence

        :id: 21efdd08-698c-443c-a681-edce19a4c83a

        :expectedresults: Product is synchronized successfully.

        :BZ: 1279539

        :CaseLevel: System
        """
        interval = 60 * 60  # 'hourly' sync interval in seconds
        delay = 2 * 60
        product = make_product({'organization-id': self.org['id']})
        repo = make_repository({'product-id': product['id']})
        sync_plan = self._make_sync_plan({
            'enabled':
            'true',
            'interval':
            'hourly',
            'organization-id':
            self.org['id'],
            'sync-date':
            (datetime.utcnow() - timedelta(seconds=interval - delay)
             ).strftime("%Y-%m-%d %H:%M:%S"),
        })
        # Associate sync plan with product
        Product.set_sync_plan({
            'id': product['id'],
            'sync-plan-id': sync_plan['id'],
        })
        # Verify product has not been synced yet
        self.logger.info('Waiting {0} seconds to check product {1}'
                         ' was not synced'.format(delay / 4, product['name']))
        sleep(delay / 4)
        with self.assertRaises(AssertionError):
            self.validate_task_status(repo['id'], max_tries=2)
        self.validate_repo_content(repo, ['errata', 'packages'],
                                   after_sync=False)
        # Wait until the first recurrence
        self.logger.info('Waiting {0} seconds to check product {1}'
                         ' was synced'.format(delay, product['name']))
        sleep(delay * 3 / 4)
        # Re-calculate and Update with the current UTC time
        SyncPlan.update({
            u'id':
            sync_plan['id'],
            u'sync-date':
            (datetime.utcnow() - timedelta(seconds=interval - delay)
             ).strftime("%Y-%m-%d %H:%M:%S"),
        })
        # Verify product was synced successfully
        self.validate_task_status(repo['id'], repo_name=repo['name'])
        self.validate_repo_content(repo,
                                   ['errata', 'package-groups', 'packages'])
Exemple #54
0
    def _make_repository(self, options=None):
        """Makes a new repository and asserts its success"""
        if options is None:
            options = {}

        if options.get('product-id') is None:
            options[u'product-id'] = self.product['id']

        return make_repository(options)
Exemple #55
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)
Exemple #56
0
    def test_positive_delete_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 delete it

        @id: f92d4643-1892-4f95-ae6b-fcea8e726946

        @assert: gpg key is associated with product and its repositories
        during creation but removed from the product and the repositories after
        deletion

        @CaseLevel: Integration
        """
        # Create product, repositories and gpg key
        product = make_product({'organization-id': self.org['id']})
        repos = [
            make_repository({'product-id': product['id']})
            for _ in range(gen_integer(2, 5))
        ]
        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 with product and its repositories
        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'])
        # Delete the gpg key
        GPGKey.delete({
            'name': gpg_key['name'],
            'organization-id': self.org['id'],
        })
        # Verify gpg key was actually deleted
        with self.assertRaises(CLIReturnCodeError):
            GPGKey.info({
                'id': gpg_key['id'],
                'organization-id': self.org['id'],
            })
        # Verify gpg key was disassociated from the product and its
        # repositories
        product = Product.info({
            'id': product['id'],
            'organization-id': self.org['id'],
        })
        self.assertNotEqual(product['gpg']['gpg-key'], gpg_key['name'])
        for repo in repos:
            repo = Repository.info({'id': repo['id']})
            self.assertNotEqual(repo['gpg-key'].get('name'), gpg_key['name'])
Exemple #57
0
    def test_positive_sync_by_label(self):
        """@Test: Check if product can be synchronized by its label.

        @Feature: Product

        @Assert: Product is synchronized
        """
        org = make_org()
        product = make_product({'organization-id': org['id']})
        make_repository({'product-id': product['id']})
        Product.synchronize({
            'id': product['id'],
            'organization-label': org['label'],
        })
        product = Product.info({
            'id': product['id'],
            'organization-id': org['id'],
        })
        self.assertEqual(u'Syncing Complete.', product['sync-state'])
Exemple #58
0
 def create(self, organization_id, product_id, download_policy=None, synchronize=True):
     repo_info = make_repository({
         'product-id': product_id,
         'content-type': self.content_type,
         'url': self.url,
         'docker-upstream-name': self.upstream_name,
     })
     self._repo_info = repo_info
     if synchronize:
         self.synchronize()
     return repo_info
Exemple #59
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'])