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'])
def test_positive_remove_sync_plan_by_id(self): """Check if a sync plan can be removed from a product :id: 0df2005c-158a-48cb-8a16-9a63923699fc :expectedresults: Product has sync plan :CaseLevel: Integration """ product = make_product({u'organization-id': self.org['id']}) sync_plan = make_sync_plan({'organization-id': self.org['id']}) Product.set_sync_plan({ 'id': product['id'], 'sync-plan-id': sync_plan['id'], }) product = Product.info({ 'id': product['id'], 'organization-id': self.org['id'], }) self.assertEqual(product['sync-plan-id'], sync_plan['id']) 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)
def test_positive_info_with_assigned_product(module_org): """Verify that sync plan info command returns list of products which are assigned to that sync plan :id: 7a7e5e40-7776-4d26-9173-73f00de6e8e9 :customerscenario: true :expectedresults: Expected product information is returned in info command :BZ: 1390545 :CaseImportance: Critical :CaseLevel: Integration """ prod1 = gen_string('alpha') prod2 = gen_string('alpha') sync_plan = make_sync_plan( { 'enabled': 'false', 'organization-id': module_org.id, 'sync-date': datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S"), } ) for prod_name in [prod1, prod2]: product = make_product({'organization-id': module_org.id, 'name': prod_name}) Product.set_sync_plan({'id': product['id'], 'sync-plan-id': sync_plan['id']}) updated_plan = SyncPlan.info({'id': sync_plan['id']}) assert len(updated_plan['products']) == 2 assert {prod['name'] for prod in updated_plan['products']} == {prod1, prod2}
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_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)
def test_positive_synchronize_rh_product_future_sync_date(self): """Create a sync plan with sync date in a future and sync one RH product with it automatically. :id: 6ce2f777-f230-4bb8-9822-2cf3580c21aa :expectedresults: Product is synchronized successfully. :CaseLevel: System """ delay = 10 * 60 # delay for sync date in seconds org = make_org() with manifests.clone() as manifest: upload_file(manifest.content, manifest.filename) Subscription.upload({ 'file': manifest.filename, 'organization-id': org['id'], }) sync_plan = self._make_sync_plan({ 'enabled': 'true', 'organization-id': org['id'], 'sync-date': (datetime.utcnow() + timedelta(seconds=delay)).strftime("%Y-%m-%d %H:%M:%S"), }) RepositorySet.enable({ 'name': REPOSET['rhva6'], 'organization-id': org['id'], 'product': PRDS['rhel'], 'releasever': '6Server', 'basearch': 'x86_64', }) product = Product.info({ 'name': PRDS['rhel'], 'organization-id': org['id'], }) repo = Repository.info({ 'name': REPOS['rhva6']['name'], 'product': product['name'], 'organization-id': org['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', 'packages'])
def test_positive_info_with_assigned_product(self): """Verify that sync plan info command returns list of products which are assigned to that sync plan :id: 7a7e5e40-7776-4d26-9173-73f00de6e8e9 :customerscenario: true :expectedresults: Expected product information is returned in info command :BZ: 1390545 """ prod1 = gen_string('alpha') prod2 = gen_string('alpha') sync_plan = self._make_sync_plan({ 'enabled': 'false', 'organization-id': self.org['id'], 'sync-date': datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S"), }) for prod_name in [prod1, prod2]: product = make_product({ 'organization-id': self.org['id'], 'name': prod_name, }) Product.set_sync_plan({ 'id': product['id'], 'sync-plan-id': sync_plan['id'], }) updated_plan = SyncPlan.info({'id': sync_plan['id']}) self.assertEqual(len(updated_plan['products']), 2) self.assertEqual( set(prod['name'] for prod in updated_plan['products']), set([prod1, prod2]) )
def test_positive_info_with_assigned_product(self): """Verify that sync plan info command returns list of products which are assigned to that sync plan :id: 7a7e5e40-7776-4d26-9173-73f00de6e8e9 :expectedresults: Expected product information is returned in info command :BZ: 1390545 """ prod1 = gen_string('alpha') prod2 = gen_string('alpha') sync_plan = self._make_sync_plan({ 'enabled': 'false', 'organization-id': self.org['id'], 'sync-date': datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S"), }) for prod_name in [prod1, prod2]: product = make_product({ 'organization-id': self.org['id'], 'name': prod_name, }) Product.set_sync_plan({ 'id': product['id'], 'sync-plan-id': sync_plan['id'], }) updated_plan = SyncPlan.info({'id': sync_plan['id']}) self.assertEqual(len(updated_plan['products']), 2) self.assertEqual( set(prod['name'] for prod in updated_plan['products']), set([prod1, prod2]) )
def test_positive_remove_sync_plan_by_id(self): """Check if a sync plan can be removed from a product @id: 0df2005c-158a-48cb-8a16-9a63923699fc @Assert: Product has sync plan @CaseLevel: Integration """ product = make_product({u'organization-id': self.org['id']}) sync_plan = make_sync_plan({'organization-id': self.org['id']}) Product.set_sync_plan({ 'id': product['id'], 'sync-plan-id': sync_plan['id'], }) product = Product.info({ 'id': product['id'], 'organization-id': self.org['id'], }) self.assertEqual(product['sync-plan-id'], sync_plan['id']) 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)
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, )
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_remove_syncplan_1(self): """@Test: Check if product can be assigned a syncplan @Feature: Product @Assert: Product has syncplan """ product = make_product({u'organization-id': self.org['id']}) sync_plan = make_sync_plan({'organization-id': self.org['id']}) Product.set_sync_plan({ 'id': product['id'], 'sync-plan-id': sync_plan['id'], }) product = Product.info({ 'id': product['id'], 'organization-id': self.org['id'], }) self.assertEqual(product['sync-plan-id'], sync_plan['id']) 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)
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_rh_product_past_sync_date(self): """Create a sync plan with past datetime as a sync date, add a RH product and verify the product gets synchronized on the next sync occurrence :id: 47280ef4-3936-4dbc-8ed0-1076aa8d40df :expectedresults: Product is synchronized successfully. :BZ: 1279539 :CaseLevel: System """ interval = 60 * 60 # 'hourly' sync interval in seconds delay = 80 org = make_org() with manifests.clone() as manifest: upload_file(manifest.content, manifest.filename) Subscription.upload({ 'file': manifest.filename, 'organization-id': org['id'], }) sync_plan = self._make_sync_plan({ 'enabled': 'true', 'interval': 'hourly', 'organization-id': org['id'], 'sync-date': ( datetime.utcnow() - timedelta(interval - delay/2) ).strftime("%Y-%m-%d %H:%M:%S"), }) RepositorySet.enable({ 'name': REPOSET['rhva6'], 'organization-id': org['id'], 'product': PRDS['rhel'], 'releasever': '6Server', 'basearch': 'x86_64', }) product = Product.info({ 'name': PRDS['rhel'], 'organization-id': org['id'], }) repo = Repository.info({ 'name': REPOS['rhva6']['name'], 'product': product['name'], 'organization-id': org['id'], }) # 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 sleep(delay/4) self.validate_repo_content( repo, ['errata', 'packages'], after_sync=False) # Wait the rest of expected time sleep(delay) # Verify product was synced successfully self.validate_repo_content(repo, ['errata', 'packages'])
def test_positive_synchronize_rh_product_current_sync_date(self): """Create a sync plan with current datetime as a sync date, add a RH 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 org = make_org() with manifests.clone() as manifest: upload_file(manifest.content, manifest.filename) Subscription.upload({ 'file': manifest.filename, 'organization-id': org['id'], }) sync_plan = self._make_sync_plan({ 'enabled': 'true', 'interval': 'hourly', 'organization-id': org['id'], 'sync-date': datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S"), }) RepositorySet.enable({ 'name': REPOSET['rhva6'], 'organization-id': org['id'], 'product': PRDS['rhel'], 'releasever': '6Server', 'basearch': 'x86_64', }) product = Product.info({ 'name': PRDS['rhel'], 'organization-id': org['id'], }) repo = Repository.info({ 'name': REPOS['rhva6']['name'], 'product': product['name'], 'organization-id': org['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', 'packages'])
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'])
def test_positive_synchronize_rh_product_future_sync_date(self): """Create a sync plan with sync date in a future and sync one RH product with it automatically. :id: 6ce2f777-f230-4bb8-9822-2cf3580c21aa :expectedresults: Product is synchronized successfully. :CaseLevel: System """ delay = 10 * 60 # delay for sync date in seconds org = make_org() with manifests.clone() as manifest: upload_file(manifest.content, manifest.filename) Subscription.upload({ 'file': manifest.filename, 'organization-id': org['id'], }) sync_plan = self._make_sync_plan({ 'enabled': 'true', 'organization-id': org['id'], 'sync-date': (datetime.utcnow() + timedelta(seconds=delay)) .strftime("%Y-%m-%d %H:%M:%S"), }) RepositorySet.enable({ 'name': REPOSET['rhva6'], 'organization-id': org['id'], 'product': PRDS['rhel'], 'releasever': '6Server', 'basearch': 'x86_64', }) product = Product.info({ 'name': PRDS['rhel'], 'organization-id': org['id'], }) repo = Repository.info({ 'name': REPOS['rhva6']['name'], 'product': product['name'], 'organization-id': org['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', 'packages'])
def test_positive_synchronize_custom_product_weekly_recurrence(self): """Create a weekly 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: 1079a66d-7c23-44f6-a4a0-47f4c74d92a4 :expectedresults: Product is synchronized successfully. :BZ: 1396647 :CaseLevel: System """ delay = 5 * 60 product = make_product({'organization-id': self.org['id']}) repo = make_repository({'product-id': product['id']}) start_date = datetime.utcnow() - timedelta(weeks=1)\ + timedelta(seconds=delay) sync_plan = self._make_sync_plan({ 'enabled': 'true', 'interval': 'weekly', 'organization-id': self.org['id'], 'sync-date': start_date.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 start_date = datetime.utcnow() - timedelta(weeks=1)\ + timedelta(seconds=delay) SyncPlan.update({ u'id': sync_plan['id'], u'sync-date': start_date.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'])
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. :id: 635bffe2-df98-4971-8950-40edc89e479e :expectedresults: Product is synchronized successfully. :CaseLevel: System """ delay = 5 * 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 self.logger.info('Waiting {0} seconds to check product {1}' ' was not synced'.format(delay / 2, product['name'])) sleep(delay / 4) # Verify product has not been synced yet with self.assertRaises(AssertionError): self.validate_task_status(repo['id'], max_tries=2) self.validate_repo_content(repo, ['errata', 'packages'], after_sync=False) # Wait the rest of expected time self.logger.info('Waiting {0} seconds to check product {1}' ' was synced'.format(delay / 2, 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=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'])
def test_positive_synchronize_rh_product_current_sync_date(self): """Create a sync plan with current datetime as a sync date, add a RH 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 org = make_org() with manifests.clone() as manifest: upload_file(manifest.content, manifest.filename) Subscription.upload({ 'file': manifest.filename, 'organization-id': org['id'], }) sync_plan = self._make_sync_plan({ 'enabled': 'true', 'interval': 'hourly', 'organization-id': org['id'], 'sync-date': datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S"), }) RepositorySet.enable({ 'name': REPOSET['rhva6'], 'organization-id': org['id'], 'product': PRDS['rhel'], 'releasever': '6Server', 'basearch': 'x86_64', }) product = Product.info({ 'name': PRDS['rhel'], 'organization-id': org['id'], }) repo = Repository.info({ 'name': REPOS['rhva6']['name'], 'product': product['name'], 'organization-id': org['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', 'packages'])
def test_positive_synchronize_custom_product_future_sync_date(module_org): """Create a sync plan with sync date in a future and sync one custom product with it automatically. :id: 635bffe2-df98-4971-8950-40edc89e479e :expectedresults: Product is synchronized successfully. :CaseLevel: System :BZ: 1655595 """ cron_multiple = 5 # sync event is on every multiple of this value, starting from 00 mins delay = (cron_multiple) * 60 # delay for sync date in seconds guardtime = 180 # do not start test less than 3 mins before the next sync event product = make_product({'organization-id': module_org.id}) repo = make_repository({'product-id': product['id']}) # if < 3 mins before the target event rather wait 3 mins for the next test window if int(datetime.utcnow().strftime('%M')) % (cron_multiple) > int( guardtime / 60): sleep(guardtime) 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': [f'*/{cron_multiple} * * * *'], }) # Verify product is not synced and doesn't have any content 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 quarter of expected time logger.info( f"Waiting {(delay / 4)} seconds to check product {product['name']}" f" was not synced by {sync_plan['name']}") sleep(delay / 4) # Verify product has not been synced yet with pytest.raises(AssertionError): validate_task_status(repo['id'], module_org.id, max_tries=1) validate_repo_content(repo, ['errata', 'packages'], after_sync=False) # Wait the rest of expected time logger.info( f"Waiting {(delay * 3 / 4)} seconds to check product {product['name']}" f" was synced by {sync_plan['name']}") sleep(delay * 3 / 4) # Verify product was synced successfully validate_task_status(repo['id'], module_org.id) validate_repo_content(repo, ['errata', 'package-groups', 'packages'])
def test_add_syncplan_1(self): """@Test: Check if product can be assigned a syncplan @Feature: Product @Assert: Product has syncplan """ new_product = make_product({u"organization-id": self.org["id"]}) sync_plan = make_sync_plan({"organization-id": self.org["id"]}) Product.set_sync_plan({"id": new_product["id"], "sync-plan-id": sync_plan["id"]}) new_product = Product.info({"id": new_product["id"], "organization-id": self.org["id"]}) self.assertEqual(new_product["sync-plan-id"], sync_plan["id"])
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'])
def test_positive_synchronize_custom_product_weekly_recurrence(self): """Create a weekly 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: 1079a66d-7c23-44f6-a4a0-47f4c74d92a4 :expectedresults: Product is synchronized successfully. :BZ: 1396647 :CaseLevel: System """ delay = 5 * 60 product = make_product({'organization-id': self.org['id']}) repo = make_repository({'product-id': product['id']}) start_date = datetime.utcnow() - timedelta(weeks=1)\ + timedelta(seconds=delay) sync_plan = self._make_sync_plan({ 'enabled': 'true', 'interval': 'weekly', 'organization-id': self.org['id'], 'sync-date': start_date.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 start_date = datetime.utcnow() - timedelta(weeks=1)\ + timedelta(seconds=delay) SyncPlan.update({ u'id': sync_plan['id'], u'sync-date': start_date.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'])
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 = 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"), }) products = [ make_product({'organization-id': self.org['id']}) for _ in range(randint(3, 5)) ] repos = [ make_repository({'product-id': product['id']}) for product in products for _ in range(randint(2, 3)) ] # Verify products have not been synced yet for repo in repos: self.validate_repo_content(repo, ['errata', 'packages'], after_sync=False) # 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 sleep(delay / 2) # Verify products has not been synced yet for repo in repos: self.validate_repo_content(repo, ['errata', 'packages'], after_sync=False) # Wait the rest of expected time sleep(delay / 2) # Verify product was synced successfully for repo in repos: self.validate_repo_content( repo, ['errata', 'package-groups', 'packages'])
def test_positive_synchronize_custom_product_past_sync_date(module_org): """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': module_org.id}) repo = make_repository({'product-id': product['id']}) sync_plan = make_sync_plan({ 'enabled': 'true', 'interval': 'hourly', 'organization-id': module_org.id, 'sync-date': (datetime.utcnow() - timedelta(seconds=interval - delay)).strftime(SYNC_DATE_FMT), }) # Associate sync plan with product 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 product {product['name']}" f" was not synced by {sync_plan['name']}") sleep(delay / 4) # Verify product has not been synced yet with pytest.raises(AssertionError): validate_task_status(repo['id'], module_org.id, max_tries=1) validate_repo_content(repo, ['errata', 'packages'], after_sync=False) # Wait until the first recurrence logger.info( f"Waiting {(delay * 3 / 4)} seconds to check product {product['name']}" f" was synced by {sync_plan['name']}") sleep(delay * 3 / 4) # Verify product was synced successfully validate_task_status(repo['id'], module_org.id) validate_repo_content(repo, ['errata', 'package-groups', 'packages'])
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. :id: 635bffe2-df98-4971-8950-40edc89e479e :expectedresults: Product is synchronized successfully. :CaseLevel: System """ delay = 5 * 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 self.logger.info('Waiting {0} seconds to check product {1}' ' was not synced'.format(delay/2, product['name'])) sleep(delay/4) # Verify product has not been synced yet with self.assertRaises(AssertionError): self.validate_task_status(repo['id'], max_tries=2) self.validate_repo_content( repo, ['errata', 'packages'], after_sync=False) # Wait the rest of expected time self.logger.info('Waiting {0} seconds to check product {1}' ' was synced'.format(delay/2, 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=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'])
def test_positive_synchronize_custom_product_daily_recurrence(self): """Create a daily 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: 8d882e8b-b5c1-4449-81c6-0efd31ad75a7 :expectedresults: Product is synchronized successfully. :CaseLevel: System """ delay = 2 * 60 product = make_product({'organization-id': self.org['id']}) repo = make_repository({'product-id': product['id']}) start_date = datetime.utcnow() - timedelta(days=1) + timedelta( seconds=delay) sync_plan = self._make_sync_plan({ 'enabled': 'true', 'interval': 'daily', 'organization-id': self.org['id'], 'sync-date': start_date.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'] }) # Wait quarter of expected time self.logger.info('Waiting {0} seconds to check product {1}' ' was not synced'.format(delay / 4, product['name'])) sleep(delay / 4) # Verify product has not been synced yet with self.assertRaises(AssertionError): self.validate_task_status(repo['id'], max_tries=1) 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 * 3 / 4), product['name'])) sleep(delay * 3 / 4) # Verify product was synced successfully 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 = 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"), }) products = [ make_product({'organization-id': self.org['id']}) for _ in range(randint(3, 5)) ] repos = [ make_repository({'product-id': product['id']}) for product in products for _ in range(randint(2, 3)) ] # Verify products have not been synced yet for repo in repos: self.validate_repo_content( repo, ['errata', 'packages'], after_sync=False) # 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 sleep(delay/2) # Verify products has not been synced yet for repo in repos: self.validate_repo_content( repo, ['errata', 'packages'], after_sync=False) # Wait the rest of expected time sleep(delay/2) # Verify product was synced successfully for repo in repos: self.validate_repo_content( repo, ['errata', 'package-groups', 'packages'])
def test_positive_synchronize_custom_product_future_sync_date(module_org): """Create a sync plan with sync date in a future and sync one custom product with it automatically. :id: 635bffe2-df98-4971-8950-40edc89e479e :expectedresults: Product is synchronized successfully. :CaseLevel: System :BZ: 1655595 """ delay = 2 * 60 # delay for sync date in seconds product = make_product({'organization-id': module_org.id}) repo = make_repository({'product-id': product['id']}) sync_plan = make_sync_plan( { 'enabled': 'true', 'organization-id': module_org.id, 'sync-date': (datetime.utcnow().replace(second=0) + timedelta(seconds=delay)).strftime( "%Y-%m-%d %H:%M:%S" ), 'cron-expression': ["*/4 * * * *"], } ) # Verify product is not synced and doesn't have any content 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 quarter of expected time logger.info( 'Waiting {} seconds to check product {}' ' was not synced'.format(delay / 4, product['name']) ) sleep(delay / 4) # Verify product has not been synced yet with pytest.raises(AssertionError): validate_task_status(repo['id'], max_tries=1) validate_repo_content(repo, ['errata', 'packages'], after_sync=False) # Wait the rest of expected time logger.info( 'Waiting {} seconds to check product {}' ' was synced'.format((delay * 3 / 4), product['name']) ) sleep(delay * 3 / 4) # Verify product was synced successfully validate_task_status(repo['id'], repo_name=repo['name']) validate_repo_content(repo, ['errata', 'package-groups', 'packages'])
def test_add_syncplan_1(self): """@Test: Check if product can be assigned a syncplan @Feature: Product @Assert: Product has syncplan """ try: new_product = make_product({ u'organization-id': self.org['id'] }) sync_plan = make_sync_plan({'organization-id': self.org['id']}) except CLIFactoryError as err: self.fail(err) result = Product.set_sync_plan({ 'sync-plan-id': sync_plan['id'], 'id': new_product['id'], }) self.assertEqual(result.return_code, 0) self.assertEqual(len(result.stderr), 0) result = Product.info({ 'id': new_product['id'], 'organization-id': self.org['id'], }) self.assertEqual(result.return_code, 0) self.assertEqual(len(result.stderr), 0) self.assertEqual(result.stdout['sync-plan-id'], sync_plan['id'])
def test_positive_synchronize_custom_product_weekly_recurrence(module_org): """Create a weekly 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: 1079a66d-7c23-44f6-a4a0-47f4c74d92a4 :expectedresults: Product is synchronized successfully. :BZ: 1396647 :CaseLevel: System """ delay = 2 * 60 product = make_product({'organization-id': module_org.id}) repo = make_repository({'product-id': product['id']}) start_date = datetime.utcnow() - timedelta(weeks=1) + timedelta( seconds=delay) sync_plan = make_sync_plan({ 'enabled': 'true', 'interval': 'weekly', 'organization-id': module_org.id, 'sync-date': start_date.strftime(SYNC_DATE_FMT), }) # Associate sync plan with product 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 product {product['name']}" f" was not synced by {sync_plan['name']}") sleep(delay / 4) # Verify product has not been synced yet with pytest.raises(AssertionError): validate_task_status(repo['id'], module_org.id, max_tries=1) validate_repo_content(repo, ['errata', 'packages'], after_sync=False) # Wait until the first recurrence logger.info( f"Waiting {(delay * 3 / 4)} seconds to check product {product['name']}" f" was synced by {sync_plan['name']}") sleep(delay * 3 / 4) # Verify product was synced successfully validate_task_status(repo['id'], module_org.id) validate_repo_content(repo, ['errata', 'package-groups', 'packages'])
def test_positive_add_sync_plan_by_id(self): """@Test: Check if a sync plan can be added to a product @Feature: Product @Assert: Product has sync plan """ new_product = make_product({u'organization-id': self.org['id']}) sync_plan = make_sync_plan({'organization-id': self.org['id']}) Product.set_sync_plan({ 'id': new_product['id'], 'sync-plan-id': sync_plan['id'], }) new_product = Product.info({ 'id': new_product['id'], 'organization-id': self.org['id'], }) self.assertEqual(new_product['sync-plan-id'], sync_plan['id'])
def test_positive_add_sync_plan_by_id(self): """Check if a sync plan can be added to a product @Feature: Product @Assert: Product has sync plan """ new_product = make_product({u'organization-id': self.org['id']}) sync_plan = make_sync_plan({'organization-id': self.org['id']}) Product.set_sync_plan({ 'id': new_product['id'], 'sync-plan-id': sync_plan['id'], }) new_product = Product.info({ 'id': new_product['id'], 'organization-id': self.org['id'], }) self.assertEqual(new_product['sync-plan-id'], sync_plan['id'])
def test_positive_synchronize_custom_product_weekly_recurrence(self): """Create a weekly 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: 1079a66d-7c23-44f6-a4a0-47f4c74d92a4 :expectedresults: Product is synchronized successfully. :BZ: 1396647 :CaseLevel: System """ delay = 300 product = make_product({'organization-id': self.org['id']}) repo = make_repository({'product-id': product['id']}) start_date = datetime.utcnow() - timedelta(weeks=1)\ + timedelta(seconds=delay/2) sync_plan = self._make_sync_plan({ 'enabled': 'true', 'interval': 'weekly', 'organization-id': self.org['id'], 'sync-date': start_date.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 sleep(delay / 4) self.validate_repo_content(repo, ['errata', 'packages'], after_sync=False) # Wait until the first recurrence sleep(delay) # Verify product was synced successfully self.validate_repo_content(repo, ['errata', 'package-groups', 'packages'])
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 = 80 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(interval - delay / 2)).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 sleep(delay / 4) self.validate_repo_content(repo, ['errata', 'packages'], after_sync=False) # Wait until the first recurrence sleep(delay) # Verify product was synced successfully self.validate_repo_content(repo, ['errata', 'package-groups', 'packages'])
def test_positive_add_sync_plan_by_id(self): """Check if a sync plan can be added to a product @id: 1517bc4b-5474-41c1-bc96-6e2130a2c2f4 @Assert: Product has sync plan @CaseLevel: Integration """ new_product = make_product({u'organization-id': self.org['id']}) sync_plan = make_sync_plan({'organization-id': self.org['id']}) Product.set_sync_plan({ 'id': new_product['id'], 'sync-plan-id': sync_plan['id'], }) new_product = Product.info({ 'id': new_product['id'], 'organization-id': self.org['id'], }) self.assertEqual(new_product['sync-plan-id'], sync_plan['id'])
def test_positive_add_sync_plan_by_id(self): """Check if a sync plan can be added to a product :id: 1517bc4b-5474-41c1-bc96-6e2130a2c2f4 :expectedresults: Product has sync plan :CaseLevel: Integration """ new_product = make_product({u'organization-id': self.org['id']}) sync_plan = make_sync_plan({'organization-id': self.org['id']}) Product.set_sync_plan({ 'id': new_product['id'], 'sync-plan-id': sync_plan['id'], }) new_product = Product.info({ 'id': new_product['id'], 'organization-id': self.org['id'], }) self.assertEqual(new_product['sync-plan-id'], sync_plan['id'])
def test_remove_syncplan_1(self): """@Test: Check if product can be assigned a syncplan @Feature: Product @Assert: Product has syncplan @BZ: 1121136 """ try: new_product = make_product( { u'organization-id': self.org['id'] } ) s = make_sync_plan({'organization-id': self.org['id']}) s_result = Product.set_sync_plan( { 'sync-plan-id': s['id'], 'id': new_product['id'] } ) except CLIFactoryError as err: self.fail(err) self.assertEqual( s_result.stderr, [], "Running set_sync_plan should cause no errors.") i_result = Product.info({'id': new_product['id'], 'organization-id': self.org['id']}) self.assertEqual( i_result.stderr, [], "Running product info should cause no errors.") self.assertEqual( i_result.stdout['sync-plan-id'], s['id'], "Info should have consistent sync ids.") r_result = Product.remove_sync_plan( { 'sync-plan-id': s['id'], 'id': new_product['id'] } ) self.assertEqual( r_result.stderr, [], "Running product remove_sync_plan should cause no errors.") i_result = Product.info({'id': new_product['id'], 'organization-id': self.org['id']}) self.assertEqual( i_result.stderr, [], "Running product info should cause no errors.") self.assertEqual( len(i_result.stdout['sync-plan-id']), 0, "Info should have no sync ids.")
def test_remove_syncplan_1(self): """@Test: Check if product can be assigned a syncplan @Feature: Product @Assert: Product has syncplan """ try: product = make_product({u'organization-id': self.org['id']}) sync_plan = make_sync_plan({'organization-id': self.org['id']}) result = Product.set_sync_plan({ 'sync-plan-id': sync_plan['id'], 'id': product['id'], }) except CLIFactoryError as err: self.fail(err) self.assertEqual( result.stderr, [], 'Running set_sync_plan should cause no errors.' ) result = Product.info({ 'id': product['id'], 'organization-id': self.org['id'], }) self.assertEqual( result.stderr, [], 'Running product info should cause no errors.' ) self.assertEqual( result.stdout['sync-plan-id'], sync_plan['id'], 'Info should have consistent sync ids.' ) r_result = Product.remove_sync_plan({ 'id': product['id'], }) self.assertEqual( r_result.stderr, [], 'Running product remove_sync_plan should cause no errors.' ) result = Product.info({ 'id': product['id'], 'organization-id': self.org['id'], }) self.assertEqual( result.stderr, [], 'Running product info should cause no errors.' ) self.assertEqual( len(result.stdout['sync-plan-id']), 0, 'Info should have no sync id.' )
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. :id: 635bffe2-df98-4971-8950-40edc89e479e :expectedresults: Product is synchronized successfully. :CaseLevel: System """ 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_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 = 80 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(interval - delay/2) ).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 sleep(delay/4) self.validate_repo_content( repo, ['errata', 'packages'], after_sync=False) # Wait until the first recurrence sleep(delay) # Verify product was synced successfully self.validate_repo_content( repo, ['errata', 'package-groups', 'packages'])
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'])
def test_positive_synchronize_custom_product_weekly_recurrence(self): """Create a weekly 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: 1079a66d-7c23-44f6-a4a0-47f4c74d92a4 :expectedresults: Product is synchronized successfully. :BZ: 1396647 :CaseLevel: System """ delay = 300 product = make_product({'organization-id': self.org['id']}) repo = make_repository({'product-id': product['id']}) start_date = datetime.utcnow() - timedelta(weeks=1)\ + timedelta(seconds=delay/2) sync_plan = self._make_sync_plan({ 'enabled': 'true', 'interval': 'weekly', 'organization-id': self.org['id'], 'sync-date': start_date.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 sleep(delay/4) self.validate_repo_content( repo, ['errata', 'packages'], after_sync=False) # Wait until the first recurrence sleep(delay) # Verify product was synced successfully self.validate_repo_content( repo, ['errata', 'package-groups', 'packages'])
def test_positive_remove_sync_plan_by_id(self): """Check if a sync plan can be removed from a product @Feature: Product @Assert: Product has sync plan """ product = make_product({u'organization-id': self.org['id']}) sync_plan = make_sync_plan({'organization-id': self.org['id']}) Product.set_sync_plan({ 'id': product['id'], 'sync-plan-id': sync_plan['id'], }) product = Product.info({ 'id': product['id'], 'organization-id': self.org['id'], }) self.assertEqual(product['sync-plan-id'], sync_plan['id']) 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)
def test_positive_remove_sync_plan_by_id(self): """@Test: Check if a sync plan can be removed from a product @Feature: Product @Assert: Product has sync plan """ product = make_product({u'organization-id': self.org['id']}) sync_plan = make_sync_plan({'organization-id': self.org['id']}) Product.set_sync_plan({ 'id': product['id'], 'sync-plan-id': sync_plan['id'], }) product = Product.info({ 'id': product['id'], 'organization-id': self.org['id'], }) self.assertEqual(product['sync-plan-id'], sync_plan['id']) 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)
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 """ cron_multiple = 5 # sync event is on every multiple of this value, starting from 00 mins delay = (cron_multiple) * 60 # delay for sync date in seconds guardtime = 210 # do not start test less than 3.5 mins before the next sync event products = [ make_product({'organization-id': module_org.id}) for _ in range(2) ] repos = [ make_repository({'product-id': product['id']}) for product in products for _ in range(2) ] # if < 3 mins before the target event rather wait 3 mins for the next test window if int(datetime.utcnow().strftime('%M')) % (cron_multiple) > int( guardtime / 60): sleep(guardtime) 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': [f'*/{cron_multiple} * * * *'], }) # 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 fifth of expected time logger.info( f"Waiting {(delay / 5)} seconds to check products {products[0]['name']}" f" and {products[1]['name']} were not synced by {sync_plan['name']} ") sleep(delay / 5) # 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 * 4 / 5)} seconds to check product {products[0]['name']}" f" and {products[1]['name']} were synced by {sync_plan['name']}") sleep(delay * 4 / 5) # 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_synchronize_rh_product_future_sync_date(module_org): """Create a sync plan with sync date in a future and sync one RH product with it automatically. :id: 6ce2f777-f230-4bb8-9822-2cf3580c21aa :expectedresults: Product is synchronized successfully. :CaseLevel: System :BZ: 1655595 """ delay = 2 * 60 # delay for sync date in seconds org = make_org() with manifests.clone() as manifest: upload_file(manifest.content, manifest.filename) Subscription.upload({ 'file': manifest.filename, 'organization-id': org['id'] }) RepositorySet.enable({ 'name': REPOSET['rhva6'], 'organization-id': org['id'], 'product': PRDS['rhel'], 'releasever': '6Server', 'basearch': 'x86_64', }) product = Product.info({ 'name': PRDS['rhel'], 'organization-id': org['id'] }) repo = Repository.info({ 'name': REPOS['rhva6']['name'], 'product': product['name'], 'organization-id': org['id'] }) 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 product is not synced and doesn't have any content with pytest.raises(AssertionError): validate_task_status(repo['id'], max_tries=1) 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 quarter of expected time logger.info('Waiting {} seconds to check product {}' ' was not synced'.format(delay / 4, product['name'])) sleep(delay / 4) # Verify product has not been synced yet with pytest.raises(AssertionError): validate_task_status(repo['id'], max_tries=1) validate_repo_content(repo, ['errata', 'packages'], after_sync=False) # Wait the rest of expected time logger.info('Waiting {} seconds to check product {}' ' was synced'.format((delay * 3 / 4), product['name'])) sleep(delay * 3 / 4) # Verify product was synced successfully validate_task_status(repo['id'], repo_name=repo['name']) validate_repo_content(repo, ['errata', 'packages'])
def test_positive_synchronize_rh_product_past_sync_date(module_org): """Create a sync plan with past datetime as a sync date, add a RH product and verify the product gets synchronized on the next sync occurrence :id: 47280ef4-3936-4dbc-8ed0-1076aa8d40df :expectedresults: Product is synchronized successfully. :BZ: 1279539 :CaseLevel: System """ interval = 60 * 60 # 'hourly' sync interval in seconds delay = 2 * 60 org = make_org() with manifests.clone() as manifest: upload_file(manifest.content, manifest.filename) Subscription.upload({ 'file': manifest.filename, 'organization-id': org['id'] }) RepositorySet.enable({ 'name': REPOSET['rhva6'], 'organization-id': org['id'], 'product': PRDS['rhel'], 'releasever': '6Server', 'basearch': 'x86_64', }) product = Product.info({ 'name': PRDS['rhel'], 'organization-id': org['id'] }) repo = Repository.info({ 'name': REPOS['rhva6']['name'], 'product': product['name'], 'organization-id': org['id'] }) sync_plan = make_sync_plan({ 'enabled': 'true', 'interval': 'hourly', 'organization-id': module_org.id, 'sync-date': (datetime.utcnow() - timedelta(seconds=interval - delay)).strftime(SYNC_DATE_FMT), }) # Associate sync plan with product Product.set_sync_plan({ 'id': product['id'], 'sync-plan-id': sync_plan['id'] }) # Wait quarter of expected time logger.info('Waiting {} seconds to check product {}' ' was not synced'.format(delay / 4, product['name'])) sleep(delay / 4) # Verify product has not been synced yet with pytest.raises(AssertionError): validate_task_status(repo['id'], max_tries=1) validate_repo_content(repo, ['errata', 'packages'], after_sync=False) # Wait the rest of expected time logger.info('Waiting {} seconds to check product {}' ' was synced'.format((delay * 3 / 4), product['name'])) sleep(delay * 3 / 4) # Verify product was synced successfully validate_task_status(repo['id'], repo_name=repo['name']) validate_repo_content(repo, ['errata', 'packages'])
def test_positive_synchronize_rh_product_past_sync_date(self): """Create a sync plan with past datetime as a sync date, add a RH product and verify the product gets synchronized on the next sync occurrence :id: 47280ef4-3936-4dbc-8ed0-1076aa8d40df :expectedresults: Product is synchronized successfully. :BZ: 1279539 :CaseLevel: System """ interval = 60 * 60 # 'hourly' sync interval in seconds delay = 3 * 60 org = make_org() with manifests.clone() as manifest: upload_file(manifest.content, manifest.filename) Subscription.upload({ 'file': manifest.filename, 'organization-id': org['id'], }) sync_plan = self._make_sync_plan({ 'enabled': 'true', 'interval': 'hourly', 'organization-id': org['id'], 'sync-date': ( datetime.utcnow() - timedelta(seconds=interval - delay) ).strftime("%Y-%m-%d %H:%M:%S"), }) RepositorySet.enable({ 'name': REPOSET['rhva6'], 'organization-id': org['id'], 'product': PRDS['rhel'], 'releasever': '6Server', 'basearch': 'x86_64', }) product = Product.info({ 'name': PRDS['rhel'], 'organization-id': org['id'], }) repo = Repository.info({ 'name': REPOS['rhva6']['name'], 'product': product['name'], 'organization-id': org['id'], }) # 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 the rest of expected time 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', 'packages'])
def test_positive_synchronize_rh_product_future_sync_date(target_sat): """Create a sync plan with sync date in a future and sync one RH product with it automatically. :id: 6ce2f777-f230-4bb8-9822-2cf3580c21aa :expectedresults: Product is synchronized successfully. :CaseLevel: System :BZ: 1655595 """ cron_multiple = 5 # sync event is on every multiple of this value, starting from 00 mins delay = (cron_multiple) * 60 # delay for sync date in seconds guardtime = 180 # do not start test less than 2 mins before the next sync event org = make_org() with manifests.clone() as manifest: target_sat.put(manifest, manifest.filename) Subscription.upload({ 'file': manifest.filename, 'organization-id': org['id'] }) RepositorySet.enable({ 'name': REPOSET['rhva6'], 'organization-id': org['id'], 'product': PRDS['rhel'], 'releasever': '6Server', 'basearch': 'x86_64', }) product = Product.info({ 'name': PRDS['rhel'], 'organization-id': org['id'] }) repo = Repository.info({ 'name': REPOS['rhva6']['name'], 'product': product['name'], 'organization-id': org['id'] }) # if < 3 mins before the target event rather wait 3 mins for the next test window if int(datetime.utcnow().strftime('%M')) % (cron_multiple) > int( guardtime / 60): sleep(guardtime) sync_plan = make_sync_plan({ 'enabled': 'true', 'organization-id': org['id'], 'sync-date': (datetime.utcnow().replace(second=0) + timedelta(seconds=delay)).strftime(SYNC_DATE_FMT), 'cron-expression': [f'*/{cron_multiple} * * * *'], }) # Verify product is not synced and doesn't have any content with pytest.raises(AssertionError): validate_task_status(repo['id'], org['id'], max_tries=1) 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 fifth of expected time logger.info( f"Waiting {(delay / 5)} seconds to check product {product['name']}" f" was not synced by {sync_plan['name']}") sleep(delay / 5) # Verify product has not been synced yet with pytest.raises(AssertionError): validate_task_status(repo['id'], org['id'], max_tries=1) validate_repo_content(repo, ['errata', 'packages'], after_sync=False) # Wait the rest of expected time logger.info( f"Waiting {(delay * 4 / 5)} seconds to check product {product['name']}" f" was synced by {sync_plan['name']}") sleep(delay * 4 / 5) # Verify product was synced successfully validate_task_status(repo['id'], org['id']) validate_repo_content(repo, ['errata', 'packages'])