Exemplo n.º 1
0
 def test_filtered_datapoint_True(self):
     """Tests if run_one_datapoint=false returns all data points"""
     settings.run_one_datapoint = False
     self.assertEqual(len(generate_strings_list()), 7)
     self.assertEqual(len(invalid_emails_list()), 8)
     self.assertEqual(len(invalid_id_list()), 4)
     self.assertEqual(len(invalid_interfaces_list()), 8)
     self.assertEqual(len(invalid_names_list()), 7)
     self.assertEqual(len(invalid_values_list()), 10)
     self.assertEqual(len(invalid_usernames_list()), 4)
     self.assertEqual(len(valid_labels_list()), 2)
     self.assertEqual(len(valid_data_list()), 7)
     self.assertEqual(len(valid_emails_list()), 8)
     self.assertEqual(len(valid_environments_list()), 4)
     self.assertEqual(len(valid_hosts_list()), 3)
     self.assertEqual(len(valid_hostgroups_list()), 7)
     self.assertEqual(len(valid_interfaces_list()), 3)
     self.assertEqual(len(valid_names_list()), 15)
     self.assertEqual(len(valid_org_names_list()), 7)
     self.assertEqual(len(valid_usernames_list()), 6)
     self.assertEqual(len((valid_cron_expressions())), 4)
     with mock.patch('robottelo.datafactory.bz_bug_is_open',
                     return_value=True):
         self.assertEqual(len(valid_docker_repository_names()), 6)
     with mock.patch('robottelo.datafactory.bz_bug_is_open',
                     return_value=False):
         self.assertEqual(len(valid_docker_repository_names()), 7)
Exemplo n.º 2
0
    def test_return_type(self):
        """This test validates return types for functions:

        1. :meth:`robottelo.datafactory.generate_strings_list`
        2. :meth:`robottelo.datafactory.invalid_emails_list`
        3. :meth:`robottelo.datafactory.invalid_names_list`
        4. :meth:`robottelo.datafactory.valid_data_list`
        5. :meth:`robottelo.datafactory.valid_emails_list`
        6. :meth:`robottelo.datafactory.valid_environments_list`
        7. :meth:`robottelo.datafactory.valid_labels_list`
        8. :meth:`robottelo.datafactory.valid_names_list`
        9. :meth:`robottelo.datafactory.valid_usernames_list`
        10. :meth:`robottelo.datafactory.invalid_id_list`

        """
        for item in itertools.chain(
                generate_strings_list(),
                invalid_emails_list(),
                invalid_names_list(),
                valid_data_list(),
                valid_emails_list(),
                valid_environments_list(),
                valid_labels_list(),
                valid_names_list(),
                valid_usernames_list(),):
            self.assertIsInstance(item, six.text_type)
        for item in invalid_id_list():
            if not (isinstance(item, (six.text_type, int)) or item is None):
                self.fail('Unexpected data type')
Exemplo n.º 3
0
 def test_filtered_datapoint_True(self):
     """Tests if run_one_datapoint=false returns all data points"""
     settings.run_one_datapoint = False
     self.assertEqual(len(generate_strings_list()), 7)
     self.assertEqual(len(invalid_emails_list()), 8)
     self.assertEqual(len(invalid_id_list()), 4)
     self.assertEqual(len(invalid_interfaces_list()), 8)
     self.assertEqual(len(invalid_names_list()), 7)
     self.assertEqual(len(invalid_values_list()), 10)
     self.assertEqual(len(invalid_usernames_list()), 4)
     self.assertEqual(len(valid_labels_list()), 2)
     self.assertEqual(len(valid_data_list()), 7)
     self.assertEqual(len(valid_emails_list()), 8)
     self.assertEqual(len(valid_environments_list()), 4)
     self.assertEqual(len(valid_hosts_list()), 3)
     self.assertEqual(len(valid_hostgroups_list()), 7)
     self.assertEqual(len(valid_interfaces_list()), 3)
     self.assertEqual(len(valid_names_list()), 15)
     self.assertEqual(len(valid_org_names_list()), 7)
     self.assertEqual(len(valid_usernames_list()), 6)
     with mock.patch('robottelo.datafactory.bz_bug_is_open',
                     return_value=True):
         self.assertEqual(len(valid_docker_repository_names()), 6)
     with mock.patch('robottelo.datafactory.bz_bug_is_open',
                     return_value=False):
         self.assertEqual(len(valid_docker_repository_names()), 7)
Exemplo n.º 4
0
 def test_filtered_datapoint(self, run_one_datapoint):
     """Tests if run_one_datapoint=false returns all data points"""
     if run_one_datapoint:
         assert len(datafactory.generate_strings_list()) == 1
         assert len(datafactory.invalid_emails_list()) == 1
         assert len(datafactory.invalid_environments_list()) == 1
         assert len(datafactory.invalid_id_list()) == 1
         assert len(datafactory.invalid_interfaces_list()) == 1
         assert len(datafactory.invalid_names_list()) == 1
         assert len(datafactory.invalid_values_list()) == 1
         assert len(datafactory.valid_data_list()) == 1
         assert len(datafactory.valid_docker_repository_names()) == 1
         assert len(datafactory.valid_emails_list()) == 1
         assert len(datafactory.valid_environments_list()) == 1
         assert len(datafactory.valid_hosts_list()) == 1
         assert len(datafactory.valid_hostgroups_list()) == 1
         assert len(datafactory.valid_interfaces_list()) == 1
         assert len(datafactory.valid_labels_list()) == 1
         assert len(datafactory.valid_names_list()) == 1
         assert len(datafactory.valid_org_names_list()) == 1
         assert len(datafactory.valid_usernames_list()) == 1
         assert len(datafactory.valid_cron_expressions()) == 1
     else:
         assert len(datafactory.generate_strings_list()) == 7
         assert len(datafactory.invalid_emails_list()) == 8
         assert len(datafactory.invalid_environments_list()) == 4
         assert len(datafactory.invalid_id_list()) == 4
         assert len(datafactory.invalid_interfaces_list()) == 8
         assert len(datafactory.invalid_names_list()) == 7
         assert len(datafactory.invalid_values_list()) == 10
         assert len(datafactory.invalid_usernames_list()) == 4
         assert len(datafactory.valid_labels_list()) == 2
         assert len(datafactory.valid_data_list()) == 7
         assert len(datafactory.valid_emails_list()) == 8
         assert len(datafactory.valid_environments_list()) == 4
         assert len(datafactory.valid_hosts_list()) == 3
         assert len(datafactory.valid_hostgroups_list()) == 7
         assert len(datafactory.valid_interfaces_list()) == 3
         assert len(datafactory.valid_names_list()) == 15
         assert len(datafactory.valid_org_names_list()) == 7
         assert len(datafactory.valid_usernames_list()) == 6
         assert len(datafactory.valid_cron_expressions()) == 4
         assert len(datafactory.valid_docker_repository_names()) == 7
Exemplo n.º 5
0
    def test_positive_create_with_label(self):
        """Create a repository providing label which is different from its name

        @Assert: A repository is created with expected label.

        @Feature: Repository
        """
        for label in valid_labels_list():
            with self.subTest(label):
                repo = entities.Repository(product=self.product, label=label).create()
                self.assertEqual(repo.label, label)
                self.assertNotEqual(repo.name, label)
Exemplo n.º 6
0
    def test_positive_create_with_label(self):
        """Create a repository providing label which is different from its name

        @id: 3be1b3fa-0e17-416f-97f0-858709e6b1da

        @Assert: A repository is created with expected label.
        """
        for label in valid_labels_list():
            with self.subTest(label):
                repo = entities.Repository(
                    product=self.product, label=label).create()
                self.assertEqual(repo.label, label)
                self.assertNotEqual(repo.name, label)
Exemplo n.º 7
0
    def test_positive_create_2(self):
        """@Test: Check if product can be created with random labels

        @Feature: Product

        @Assert: Product is created and has random label
        """
        for label in valid_labels_list():
            with self.subTest(label):
                product_name = gen_alphanumeric()
                product = make_product({u"label": label, u"name": product_name, u"organization-id": self.org["id"]})
                self.assertEqual(product["name"], product_name)
                self.assertEqual(product["label"], label)
Exemplo n.º 8
0
    def test_positive_create_with_label(self):
        """Create a repository providing label which is different from its name

        @Assert: A repository is created with expected label.

        @Feature: Repository
        """
        for label in valid_labels_list():
            with self.subTest(label):
                repo = entities.Repository(product=self.product,
                                           label=label).create()
                self.assertEqual(repo.label, label)
                self.assertNotEqual(repo.name, label)
Exemplo n.º 9
0
    def test_positive_create_with_label(self):
        """Create a repository providing label which is different from its name

        @id: 3be1b3fa-0e17-416f-97f0-858709e6b1da

        @Assert: A repository is created with expected label.
        """
        for label in valid_labels_list():
            with self.subTest(label):
                repo = entities.Repository(
                    product=self.product, label=label).create()
                self.assertEqual(repo.label, label)
                self.assertNotEqual(repo.name, label)
Exemplo n.º 10
0
 def test_datacheck_True(self):
     """Tests if run_one_datapoint=false returns all data points"""
     settings.run_one_datapoint = False
     self.assertEqual(len(generate_strings_list()), 7)
     self.assertEqual(len(invalid_id_list()), 4)
     self.assertEqual(len(invalid_emails_list()), 10)
     self.assertEqual(len(invalid_names_list()), 7)
     self.assertEqual(len(invalid_values_list()), 10)
     self.assertEqual(len(valid_labels_list()), 2)
     self.assertEqual(len(valid_data_list()), 7)
     self.assertEqual(len(valid_emails_list()), 8)
     self.assertEqual(len(valid_environments_list()), 3)
     self.assertEqual(len(valid_names_list()), 15)
     self.assertEqual(len(valid_usernames_list()), 4)
Exemplo n.º 11
0
 def test_datacheck_False(self):
     """Tests if run_one_datapoint=True returns one data point"""
     settings.run_one_datapoint = True
     self.assertEqual(len(generate_strings_list()), 1)
     self.assertEqual(len(invalid_emails_list()), 1)
     self.assertEqual(len(invalid_id_list()), 1)
     self.assertEqual(len(invalid_names_list()), 1)
     self.assertEqual(len(invalid_values_list()), 1)
     self.assertEqual(len(valid_data_list()), 1)
     self.assertEqual(len(valid_emails_list()), 1)
     self.assertEqual(len(valid_environments_list()), 1)
     self.assertEqual(len(valid_labels_list()), 1)
     self.assertEqual(len(valid_names_list()), 1)
     self.assertEqual(len(valid_usernames_list()), 1)
Exemplo n.º 12
0
    def test_return_type(self):
        """This test validates return types for functions:

        1. :meth:`robottelo.datafactory.generate_strings_list`
        2. :meth:`robottelo.datafactory.invalid_emails_list`
        3. :meth:`robottelo.datafactory.invalid_names_list`
        4. :meth:`robottelo.datafactory.valid_data_list`
        5. :meth:`robottelo.datafactory.valid_docker_repository_names`
        6. :meth:`robottelo.datafactory.valid_emails_list`
        7. :meth:`robottelo.datafactory.valid_environments_list`
        8. :meth:`robottelo.datafactory.valid_hosts_list`
        9. :meth:`robottelo.datafactory.valid_hostgroups_list`
        10. :meth:`robottelo.datafactory.valid_labels_list`
        11. :meth:`robottelo.datafactory.valid_names_list`
        12. :meth:`robottelo.datafactory.valid_org_names_list`
        13. :meth:`robottelo.datafactory.valid_usernames_list`
        14. :meth:`robottelo.datafactory.invalid_id_list`
        15. :meth:`robottelo.datafactory.invalid_interfaces_list`
        16. :meth:`robottelo.datafactory.valid_interfaces_list`
        17. :meth:`robottelo.datafactory.valid_cron_expressions`

        """
        with mock.patch('robottelo.datafactory.bz_bug_is_open',
                        return_value=False):
            for item in itertools.chain(
                    generate_strings_list(),
                    invalid_emails_list(),
                    invalid_interfaces_list(),
                    invalid_names_list(),
                    valid_data_list(),
                    valid_docker_repository_names(),
                    valid_emails_list(),
                    valid_environments_list(),
                    valid_hosts_list(),
                    valid_hostgroups_list(),
                    valid_interfaces_list(),
                    valid_labels_list(),
                    valid_names_list(),
                    valid_org_names_list(),
                    valid_cron_expressions(),
                    valid_usernames_list()):
                self.assertIsInstance(item, six.text_type)
            for item in invalid_id_list():
                if not (
                        isinstance(item, (six.text_type, int)) or item is None
                        ):
                    self.fail('Unexpected data type')
Exemplo n.º 13
0
    def test_positive_create_with_label(self):
        """Check if product can be created with random labels

        @id: 07ff96b2-cc55-4d07-86a2-f20b77cc9b14

        @Assert: Product is created and has random label
        """
        for label in valid_labels_list():
            with self.subTest(label):
                product_name = gen_alphanumeric()
                product = make_product({
                    u'label': label,
                    u'name': product_name,
                    u'organization-id': self.org['id'],
                })
                self.assertEqual(product['name'], product_name)
                self.assertEqual(product['label'], label)
Exemplo n.º 14
0
    def test_return_type(self):
        """This test validates return types for functions:

        1. :meth:`robottelo.datafactory.generate_strings_list`
        2. :meth:`robottelo.datafactory.invalid_emails_list`
        3. :meth:`robottelo.datafactory.invalid_environments_list`
        4. :meth:`robottelo.datafactory.invalid_names_list`
        5. :meth:`robottelo.datafactory.valid_data_list`
        6. :meth:`robottelo.datafactory.valid_docker_repository_names`
        7. :meth:`robottelo.datafactory.valid_emails_list`
        8. :meth:`robottelo.datafactory.valid_environments_list`
        9. :meth:`robottelo.datafactory.valid_hosts_list`
        10. :meth:`robottelo.datafactory.valid_hostgroups_list`
        11. :meth:`robottelo.datafactory.valid_labels_list`
        12. :meth:`robottelo.datafactory.valid_names_list`
        13. :meth:`robottelo.datafactory.valid_org_names_list`
        14. :meth:`robottelo.datafactory.valid_usernames_list`
        15. :meth:`robottelo.datafactory.invalid_id_list`
        16. :meth:`robottelo.datafactory.invalid_interfaces_list`
        17. :meth:`robottelo.datafactory.valid_interfaces_list`
        18. :meth:`robottelo.datafactory.valid_cron_expressions`

        """
        for item in itertools.chain(
                datafactory.generate_strings_list(),
                datafactory.invalid_emails_list(),
                datafactory.invalid_environments_list(),
                datafactory.invalid_interfaces_list(),
                datafactory.invalid_names_list(),
                datafactory.valid_data_list(),
                datafactory.valid_docker_repository_names(),
                datafactory.valid_emails_list(),
                datafactory.valid_environments_list(),
                datafactory.valid_hosts_list(),
                datafactory.valid_hostgroups_list(),
                datafactory.valid_interfaces_list(),
                datafactory.valid_labels_list(),
                datafactory.valid_names_list(),
                datafactory.valid_org_names_list(),
                datafactory.valid_cron_expressions(),
                datafactory.valid_usernames_list(),
        ):
            assert isinstance(item, str)
        for item in datafactory.invalid_id_list():
            if not (isinstance(item, (str, int)) or item is None):
                pytest.fail('Unexpected data type')
Exemplo n.º 15
0
 def test_filtered_datapoint_False(self):
     """Tests if run_one_datapoint=True returns one data point"""
     settings.run_one_datapoint = True
     self.assertEqual(len(generate_strings_list()), 1)
     self.assertEqual(len(invalid_emails_list()), 1)
     self.assertEqual(len(invalid_id_list()), 1)
     self.assertEqual(len(invalid_names_list()), 1)
     self.assertEqual(len(invalid_values_list()), 1)
     self.assertEqual(len(valid_data_list()), 1)
     self.assertEqual(len(valid_emails_list()), 1)
     self.assertEqual(len(valid_environments_list()), 1)
     self.assertEqual(len(valid_hosts_list()), 1)
     self.assertEqual(len(valid_hostgroups_list()), 1)
     self.assertEqual(len(valid_labels_list()), 1)
     self.assertEqual(len(valid_names_list()), 1)
     self.assertEqual(len(valid_org_names_list()), 1)
     self.assertEqual(len(valid_usernames_list()), 1)
Exemplo n.º 16
0
    def test_positive_create_with_label(self):
        """Check if product can be created with random labels

        @id: 07ff96b2-cc55-4d07-86a2-f20b77cc9b14

        @Assert: Product is created and has random label
        """
        for label in valid_labels_list():
            with self.subTest(label):
                product_name = gen_alphanumeric()
                product = make_product({
                    u'label': label,
                    u'name': product_name,
                    u'organization-id': self.org['id'],
                })
                self.assertEqual(product['name'], product_name)
                self.assertEqual(product['label'], label)
Exemplo n.º 17
0
 def test_filtered_datapoint_True(self):
     """Tests if run_one_datapoint=false returns all data points"""
     settings.run_one_datapoint = False
     self.assertEqual(len(generate_strings_list()), 7)
     self.assertEqual(len(invalid_id_list()), 4)
     self.assertEqual(len(invalid_emails_list()), 10)
     self.assertEqual(len(invalid_names_list()), 7)
     self.assertEqual(len(invalid_values_list()), 10)
     self.assertEqual(len(invalid_usernames_list()), 4)
     self.assertEqual(len(valid_labels_list()), 2)
     self.assertEqual(len(valid_data_list()), 7)
     self.assertEqual(len(valid_emails_list()), 8)
     self.assertEqual(len(valid_environments_list()), 3)
     self.assertEqual(len(valid_hosts_list()), 3)
     self.assertEqual(len(valid_hostgroups_list()), 7)
     self.assertEqual(len(valid_names_list()), 15)
     self.assertEqual(len(valid_org_names_list()), 7)
     self.assertEqual(len(valid_usernames_list()), 6)
Exemplo n.º 18
0
 def test_filtered_datapoint_False(self):
     """Tests if run_one_datapoint=True returns one data point"""
     settings.run_one_datapoint = True
     self.assertEqual(len(generate_strings_list()), 1)
     self.assertEqual(len(invalid_emails_list()), 1)
     self.assertEqual(len(invalid_id_list()), 1)
     self.assertEqual(len(invalid_interfaces_list()), 1)
     self.assertEqual(len(invalid_names_list()), 1)
     self.assertEqual(len(invalid_values_list()), 1)
     self.assertEqual(len(valid_data_list()), 1)
     self.assertEqual(len(valid_docker_repository_names()), 1)
     self.assertEqual(len(valid_emails_list()), 1)
     self.assertEqual(len(valid_environments_list()), 1)
     self.assertEqual(len(valid_hosts_list()), 1)
     self.assertEqual(len(valid_hostgroups_list()), 1)
     self.assertEqual(len(valid_interfaces_list()), 1)
     self.assertEqual(len(valid_labels_list()), 1)
     self.assertEqual(len(valid_names_list()), 1)
     self.assertEqual(len(valid_org_names_list()), 1)
     self.assertEqual(len(valid_usernames_list()), 1)
Exemplo n.º 19
0
    def test_return_type(self):
        """This test validates return types for functions:

        1. :meth:`robottelo.datafactory.generate_strings_list`
        2. :meth:`robottelo.datafactory.invalid_emails_list`
        3. :meth:`robottelo.datafactory.invalid_names_list`
        4. :meth:`robottelo.datafactory.valid_data_list`
        5. :meth:`robottelo.datafactory.valid_emails_list`
        6. :meth:`robottelo.datafactory.valid_environments_list`
        7. :meth:`robottelo.datafactory.valid_hosts_list`
        8. :meth:`robottelo.datafactory.valid_hostgroups_list`
        9. :meth:`robottelo.datafactory.valid_labels_list`
        10. :meth:`robottelo.datafactory.valid_names_list`
        11. :meth:`robottelo.datafactory.valid_org_names_list`
        12. :meth:`robottelo.datafactory.valid_usernames_list`
        13. :meth:`robottelo.datafactory.invalid_id_list`
        14. :meth:`robottelo.datafactory.invalid_interfaces_list`
        15. :meth:`robottelo.datafactory.valid_interfaces_list`

        """
        for item in itertools.chain(generate_strings_list(),
                                    invalid_emails_list(),
                                    invalid_interfaces_list(),
                                    invalid_names_list(), valid_data_list(),
                                    valid_emails_list(),
                                    valid_environments_list(),
                                    valid_hosts_list(),
                                    valid_hostgroups_list(),
                                    valid_interfaces_list(),
                                    valid_labels_list(), valid_names_list(),
                                    valid_org_names_list(),
                                    valid_usernames_list()):
            self.assertIsInstance(item, six.text_type)
        for item in invalid_id_list():
            if not (isinstance(item, (six.text_type, int)) or item is None):
                self.fail('Unexpected data type')
Exemplo n.º 20
0
    def test_positive_CRUD(self):
        """Check if product can be created, updated, synchronized and deleted

        :id: 9d7b5ec8-59d0-4371-b5d2-d43145e4e2db

        :expectedresults: Product is created, updated, synchronized and deleted

        :BZ: 1422552

        :CaseImportance: Critical
        """
        desc = list(valid_data_list().values())[0]
        gpg_key = make_gpg_key({'organization-id': self.org['id']})
        name = list(valid_data_list().values())[0]
        label = valid_labels_list()[0]
        sync_plan = make_sync_plan({'organization-id': self.org['id']})
        product = make_product({
            'description': desc,
            'gpg-key-id': gpg_key['id'],
            'label': label,
            'name': name,
            'organization-id': self.org['id'],
            'sync-plan-id': sync_plan['id'],
        })
        self.assertEqual(product['name'], name)
        self.assertGreater(len(product['label']), 0)
        self.assertEqual(product['label'], label)
        self.assertEqual(product['description'], desc)
        self.assertEqual(product['gpg']['gpg-key-id'], gpg_key['id'])
        self.assertEqual(product['sync-plan-id'], sync_plan['id'])

        # update
        desc = list(valid_data_list().values())[0]
        new_gpg_key = make_gpg_key({'organization-id': self.org['id']})
        new_sync_plan = make_sync_plan({'organization-id': self.org['id']})
        new_prod_name = gen_string('alpha', 8)
        Product.update({
            'description': desc,
            'id': product['id'],
            'gpg-key-id': new_gpg_key['id'],
            'sync-plan-id': new_sync_plan['id'],
            'name': new_prod_name,
        })
        product = Product.info({
            'id': product['id'],
            'organization-id': self.org['id']
        })
        self.assertEqual(product['name'], new_prod_name)
        self.assertEqual(product['description'], desc)
        self.assertEqual(product['gpg']['gpg-key-id'], new_gpg_key['id'])
        self.assertNotEqual(product['gpg']['gpg-key-id'], gpg_key['id'])
        self.assertEqual(product['sync-plan-id'], new_sync_plan['id'])
        self.assertNotEqual(product['sync-plan-id'], sync_plan['id'])

        # synchronize
        repo = make_repository({
            'product-id': product['id'],
            'url': FAKE_0_YUM_REPO
        })
        Product.synchronize({
            'id': product['id'],
            'organization-id': self.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)

        # delete
        Product.remove_sync_plan({'id': product['id']})
        product = Product.info({
            'id': product['id'],
            'organization-id': self.org['id']
        })
        self.assertEqual(len(product['sync-plan-id']), 0)
        Product.delete({'id': product['id']})
        wait_for_tasks(
            search_query='label = Actions::Katello::Product::Destroy'
            ' and resource_id = {}'.format(product['id']),
            max_tries=10,
        )
        with self.assertRaises(CLIReturnCodeError):
            Product.info({
                'id': product['id'],
                'organization-id': self.org['id']
            })
Exemplo n.º 21
0
def test_positive_CRUD(module_org):
    """Check if product can be created, updated, synchronized and deleted

    :id: 9d7b5ec8-59d0-4371-b5d2-d43145e4e2db

    :expectedresults: Product is created, updated, synchronized and deleted

    :BZ: 1422552

    :CaseImportance: Critical
    """
    desc = list(valid_data_list().values())[0]
    gpg_key = make_content_credential({'organization-id': module_org.id})
    name = list(valid_data_list().values())[0]
    label = valid_labels_list()[0]
    sync_plan = make_sync_plan({'organization-id': module_org.id})
    product = make_product(
        {
            'description': desc,
            'gpg-key-id': gpg_key['id'],
            'label': label,
            'name': name,
            'organization-id': module_org.id,
            'sync-plan-id': sync_plan['id'],
        },
    )
    assert product['name'] == name
    assert len(product['label']) > 0
    assert product['label'] == label
    assert product['description'] == desc
    assert product['gpg']['gpg-key-id'] == gpg_key['id']
    assert product['sync-plan-id'] == sync_plan['id']

    # update
    desc = list(valid_data_list().values())[0]
    new_gpg_key = make_content_credential({'organization-id': module_org.id})
    new_sync_plan = make_sync_plan({'organization-id': module_org.id})
    new_prod_name = gen_string('alpha', 8)
    Product.update(
        {
            'description': desc,
            'id': product['id'],
            'gpg-key-id': new_gpg_key['id'],
            'sync-plan-id': new_sync_plan['id'],
            'name': new_prod_name,
        }
    )
    product = Product.info({'id': product['id'], 'organization-id': module_org.id})
    assert product['name'] == new_prod_name
    assert product['description'] == desc
    assert product['gpg']['gpg-key-id'] == new_gpg_key['id']
    assert product['gpg']['gpg-key-id'] != gpg_key['id']
    assert product['sync-plan-id'] == new_sync_plan['id']
    assert product['sync-plan-id'] != sync_plan['id']

    # synchronize
    repo = make_repository(
        {
            'organization-id': module_org.id,
            'product-id': product['id'],
            'url': settings.repos.yum_0.url,
        },
    )
    Product.synchronize({'id': product['id'], 'organization-id': module_org.id})
    packages = Package.list({'product-id': product['id']})
    repo = Repository.info({'id': repo['id']})
    assert int(repo['content-counts']['packages']) == len(packages)
    assert len(packages) == FAKE_0_YUM_REPO_PACKAGES_COUNT

    # delete
    Product.remove_sync_plan({'id': product['id']})
    product = Product.info({'id': product['id'], 'organization-id': module_org.id})
    assert len(product['sync-plan-id']) == 0
    Product.delete({'id': product['id']})
    wait_for_tasks(
        search_query="label = Actions::Katello::Product::Destroy"
        f" and resource_id = {product['id']}",
        max_tries=10,
    )
    with pytest.raises(CLIReturnCodeError):
        Product.info({'id': product['id'], 'organization-id': module_org.id})