def test_positive_synchronize_custom_product_daily_recurrence(self):
"""Create a daily sync plan with current datetime as a sync date,
add a custom product and verify the product gets synchronized on
the next sync occurrence
:id: d60e33a0-f75c-498e-9e6f-0a2025295a9d
:expectedresults: Product is synchronized successfully.
:CaseLevel: System
"""
delay = 4 * 60
start_date = datetime.utcnow() - timedelta(days=1)\
+ timedelta(seconds=delay)
product = entities.Product(organization=self.org).create()
repo = entities.Repository(product=product).create()
# Create and Associate sync plan with product
sync_plan = entities.SyncPlan(
organization=self.org,
enabled=True,
interval=u'daily',
sync_date=start_date,
).create()
sync_plan.add_products(data={'product_ids': [product.id]})
# Verify product is not synced and doesn't have any content
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, ['erratum', 'package', 'package_group'], 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
start_date = datetime.utcnow() - timedelta(days=1)\
+ timedelta(seconds=delay)
sync_plan.sync_date = start_date
sync_plan.update(['sync_date'])
# Verify product was synced successfully
self.validate_task_status(repo.id,
repo_backend_id=repo.backend_identifier
)
self.validate_repo_content(
repo, ['erratum', 'package', 'package_group'])
def test_positive_create_with_interval(self):
"""Create a sync plan with a random interval.
:id: d160ed1c-b698-42dc-be0b-67ac693c7840
:expectedresults: A sync plan is created with the specified interval.
:CaseImportance: Critical
"""
for interval in valid_sync_interval():
sync_plan = entities.SyncPlan(
description=gen_string('alpha'), organization=self.org, interval=interval
)
if interval == SYNC_INTERVAL['custom']:
sync_plan.cron_expression = gen_choice((valid_cron_expressions()))
sync_plan = sync_plan.create()
self.assertEqual(sync_plan.interval, interval)
def test_positive_update_description(module_org, description):
"""Create a sync plan and update its description.
:id: 4769fe9c-9eec-40c8-b015-1e3d7e570bec
:parametrized: yes
:expectedresults: A sync plan is created and its description can be
updated with the specified description.
"""
sync_plan = entities.SyncPlan(
description=gen_string('alpha'), organization=module_org
).create()
sync_plan.description = description
sync_plan.update(['description'])
sync_plan = sync_plan.read()
assert sync_plan.description == description
def test_negative_create_with_invalid_name(self):
"""Create a sync plan with an invalid name.
:id: a3a0f844-2f81-4f87-9f68-c25506c29ce2
:expectedresults: A sync plan can not be created with the specified
name.
:CaseImportance: Critical
"""
for name in invalid_values_list():
with self.subTest(name):
with self.assertRaises(HTTPError):
entities.SyncPlan(
name=name,
organization=self.org
).create()
def test_positive_repeatedly_add_remove(self):
"""Repeatedly add and remove a product from a sync plan.
@id: b67536ba-3a36-4bb7-a405-0e12081d5a7e
@Assert: A task is returned which can be used to monitor the additions
and removals.
@CaseLevel: Integration
"""
syncplan = entities.SyncPlan(organization=self.org).create()
product = entities.Product(organization=self.org).create()
for _ in range(5):
syncplan.add_products(data={'product_ids': [product.id]})
self.assertEqual(len(syncplan.read().product), 1)
syncplan.remove_products(data={'product_ids': [product.id]})
self.assertEqual(len(syncplan.read().product), 0)
def test_positive_remove_products(self):
"""Create a sync plan with two products and then remove both
products from it.
:id: eed8c239-8ba3-4dbd-aa6b-c289cd4efd47
:expectedresults: A sync plan can be created and both products can be
removed from it.
:CaseLevel: Integration
"""
syncplan = entities.SyncPlan(organization=self.org).create()
products = [entities.Product(organization=self.org).create() for _ in range(2)]
syncplan.add_products(data={'product_ids': [product.id for product in products]})
self.assertEqual(len(syncplan.read().product), 2)
syncplan.remove_products(data={'product_ids': [product.id for product in products]})
self.assertEqual(len(syncplan.read().product), 0)
def test_positive_update_name(module_org, name):
"""Create a sync plan and update its name.
:id: dbfadf4f-50af-4aa8-8d7d-43988dc4528f
:parametrized: yes
:expectedresults: A sync plan is created and its name can be updated
with the specified name.
:CaseImportance: Critical
"""
sync_plan = entities.SyncPlan(organization=module_org).create()
sync_plan.name = name
sync_plan.update(['name'])
sync_plan = sync_plan.read()
assert sync_plan.name == name
def test_positive_create_enabled_disabled(self):
"""Create sync plan with different 'enabled' field values.
:id: df5837e7-3d0f-464a-bd67-86b423c16eb4
:expectedresults: A sync plan is created, 'enabled' field has correct
value.
:CaseImportance: Critical
"""
for enabled in (False, True):
with self.subTest(enabled):
sync_plan = entities.SyncPlan(
enabled=enabled,
organization=self.org,
).create()
self.assertEqual(sync_plan.enabled, enabled)
def test_positive_delete(self):
"""Delete an existing Sync plan
@id: 81beec05-e38c-48bc-8f01-10cb1e10a3f6
@Assert: Sync Plan is deleted successfully
"""
with Session(self.browser) as session:
for plan_name in generate_strings_list():
with self.subTest(plan_name):
entities.SyncPlan(
name=plan_name,
interval=SYNC_INTERVAL['day'],
organization=self.organization,
).create()
session.nav.go_to_select_org(self.organization.name)
self.syncplan.delete(plan_name)
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: b70a0c50-7335-4285-b24c-edfc1187f034
:expectedresults: Product is synchronized successfully.
:CaseLevel: System
:BZ: 1655595, 1695733
"""
delay = 2 * 60 # delay for sync date in seconds
product = entities.Product(organization=module_org).create()
repo = entities.Repository(product=product).create()
# 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, ['erratum', 'package', 'package_group'],
after_sync=False)
# Create and Associate sync plan with product
# BZ:1695733 is closed WONTFIX so apply this workaround
logger.info('Need to set seconds to zero because BZ#1695733')
sync_date = datetime.utcnow().replace(second=0) + timedelta(seconds=delay)
sync_plan = entities.SyncPlan(organization=module_org,
enabled=True,
sync_date=sync_date).create()
sync_plan.add_products(data={'product_ids': [product.id]})
# Wait quarter of expected time
logger.info(
f'Waiting {delay / 4} seconds to check product {product.name} was not synced'
)
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, ['erratum', 'package', 'package_group'],
after_sync=False)
# Wait the rest of expected time
logger.info(
f'Waiting {delay * 3 / 4} seconds to check product {product.name} was synced'
)
sleep(delay * 3 / 4)
# Verify product was synced successfully
validate_task_status(repo.id, repo_backend_id=repo.backend_identifier)
validate_repo_content(repo, ['erratum', 'package', 'package_group'])
def test_positive_create_with_sync_date(self):
"""Create a sync plan and update its sync date.
:id: bdb6e0a9-0d3b-4811-83e2-2140b7bb62e3
:expectedresults: A sync plan can be created with a random sync date.
:CaseImportance: Critical
"""
for syncdate in valid_sync_dates():
with self.subTest(syncdate):
sync_plan = entities.SyncPlan(
organization=self.org,
sync_date=syncdate,
).create()
self.assertEqual(syncdate.strftime('%Y-%m-%d %H:%M:%S UTC'),
sync_plan.sync_date)
def test_positive_update_description(self):
"""Create a sync plan and update its description.
@id: 4769fe9c-9eec-40c8-b015-1e3d7e570bec
@Assert: A sync plan is created and its description can be updated with
the specified description.
"""
sync_plan = entities.SyncPlan(
description=gen_string('alpha'),
organization=self.org,
).create()
for description in valid_data_list():
with self.subTest(description):
sync_plan.description = description
self.assertEqual(
sync_plan.update(['description']).description, description)
def test_negative_create_with_invalid_interval(self):
"""Create a sync plan with invalid interval specified.
:id: f5844526-9f58-4be3-8a96-3849a465fc02
:expectedresults: A sync plan can not be created with invalid interval
specified
:CaseImportance: Critical
"""
for interval in invalid_values_list():
with self.subTest(interval):
with self.assertRaises(HTTPError):
entities.SyncPlan(
interval=interval,
organization=self.org,
).create()
def test_positive_create_with_description(self):
"""Create a sync plan with a random description.
:id: 3e5745e8-838d-44a5-ad61-7e56829ad47c
:expectedresults: A sync plan is created with the specified
description.
:CaseImportance: Critical
"""
for description in valid_data_list():
with self.subTest(description):
sync_plan = entities.SyncPlan(
description=description,
organization=self.org,
).create()
self.assertEqual(sync_plan.description, description)
def test_positive_update_enabled(module_org, enabled):
"""Create sync plan and update it with opposite 'enabled' value.
:id: 325c0ef5-c0e8-4cb9-b85e-87eb7f42c2f8
:parametrized: yes
:expectedresults: Sync plan is updated with different 'enabled' value.
:CaseImportance: Critical
"""
sync_plan = entities.SyncPlan(enabled=not enabled,
organization=module_org).create()
sync_plan.enabled = enabled
sync_plan.update(['enabled'])
sync_plan = sync_plan.read()
assert sync_plan.enabled == enabled
def test_positive_synchronize_custom_product_past_sync_date(self):
"""Create a sync plan with past datetime as a sync date, add a
custom product and verify the product gets synchronized on the next
sync occurrence
:id: 0495cb39-2f15-4b6e-9828-1e9517c5c826
:expectedresults: Product is synchronized successfully.
:BZ: 1279539
:CaseLevel: System
"""
interval = 60 * 60 # 'hourly' sync interval in seconds
delay = 4 * 60
product = entities.Product(organization=self.org).create()
repo = entities.Repository(product=product).create()
# Create and Associate sync plan with product
sync_plan = entities.SyncPlan(
organization=self.org,
enabled=True,
interval=u'hourly',
sync_date=datetime.utcnow() - timedelta(seconds=interval - delay),
).create()
sync_plan.add_products(data={'product_ids': [product.id]})
# Verify product is not synced and doesn't have any content
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,
['erratum', 'package', 'package_group'],
after_sync=False)
# Wait until the next recurrence
self.logger.info('Waiting {0} seconds to check product {1}'
' was synced'.format(delay, product.name))
sleep(delay * 3 / 4)
# Update with the current UTC time
sync_plan.sync_date = datetime.utcnow() + timedelta(seconds=delay)
sync_plan.update(['sync_date'])
# Verify product was synced successfully
self.validate_task_status(repo.id,
repo_backend_id=repo.backend_identifier)
self.validate_repo_content(repo,
['erratum', 'package', 'package_group'])
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: ef52dd8e-756e-429c-8c30-b3e7db2b6d61
:expectedresults: Product is synchronized successfully.
:BZ: 1396647
:CaseLevel: System
"""
delay = 4 * 60
start_date = datetime.utcnow().replace(second=0) - timedelta(weeks=1)\
+ timedelta(seconds=delay)
product = entities.Product(organization=self.org).create()
repo = entities.Repository(product=product).create()
# Create and Associate sync plan with product
sync_plan = entities.SyncPlan(
organization=self.org,
enabled=True,
interval=u'weekly',
sync_date=start_date,
).create()
sync_plan.add_products(data={'product_ids': [product.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 is not synced and doesn't have any content
with self.assertRaises(AssertionError):
self.validate_task_status(repo.id, max_tries=2)
self.validate_repo_content(repo,
['erratum', 'package', 'package_group'],
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)
# Verify product was synced successfully
self.validate_task_status(repo.id,
repo_backend_id=repo.backend_identifier)
self.validate_repo_content(repo,
['erratum', 'package', 'package_group'])
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: e646196e-3951-4297-8c3c-1494d9895347
:expectedresults: Products are synchronized successfully.
:CaseLevel: System
:BZ: 1695733
"""
delay = 2 * 60 # delay for sync date in seconds
products = [entities.Product(organization=self.org).create() for _ in range(3)]
repos = [
entities.Repository(product=product).create() 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)
# Create and Associate sync plan with products
if is_open('BZ:1695733'):
self.logger.info('Need to set seconds to zero because BZ#1695733')
sync_date = datetime.utcnow().replace(second=0) + timedelta(seconds=delay)
else:
sync_date = datetime.utcnow() + timedelta(seconds=delay)
sync_plan = entities.SyncPlan(
organization=self.org, enabled=True, sync_date=sync_date
).create()
sync_plan.add_products(data={'product_ids': [product.id for product in products]})
# Wait quarter of expected time
self.logger.info('Waiting {0} seconds to check products were not synced'.format(delay / 4))
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=1)
# Wait the rest of expected time
self.logger.info('Waiting {0} seconds to check products were synced'.format(delay * 3 / 4))
sleep(delay * 3 / 4)
# Verify product was synced successfully
for repo in repos:
self.validate_task_status(repo.id, repo_backend_id=repo.backend_identifier)
self.validate_repo_content(repo, ['erratum', 'package', 'package_group'])
def test_positive_delete_synced_product(module_org):
"""Create a sync plan with one synced product and delete it.
:id: 195d8fec-1fa0-42ab-84a5-32dd81a285ca
:expectedresults: A sync plan is created with one synced product and
sync plan can be deleted.
:CaseLevel: Integration
"""
sync_plan = entities.SyncPlan(organization=module_org).create()
product = entities.Product(organization=module_org).create()
entities.Repository(product=product).create()
sync_plan.add_products(data={'product_ids': [product.id]})
product.sync()
sync_plan.delete()
with pytest.raises(HTTPError):
sync_plan.read()
def test_positive_delete_products(self):
"""Create a sync plan with two products and delete them.
@Assert: A sync plan is created with one product and sync plan can be
deleted.
@Feature: SyncPlan
"""
sync_plan = entities.SyncPlan(organization=self.org).create()
products = [
entities.Product(organization=self.org).create() for _ in range(2)
]
sync_plan.add_products(data={
'product_ids': [product.id for product in products],
})
sync_plan.delete()
with self.assertRaises(HTTPError):
sync_plan.read()
def test_positive_update_enabled(self):
"""Create sync plan and update it with opposite 'enabled' value.
:id: 325c0ef5-c0e8-4cb9-b85e-87eb7f42c2f8
:expectedresults: Sync plan is updated with different 'enabled' value.
:CaseImportance: Critical
"""
for enabled in (False, True):
with self.subTest(enabled):
sync_plan = entities.SyncPlan(
enabled=not enabled,
organization=self.org,
).create()
sync_plan.enabled = enabled
self.assertEqual(
sync_plan.update(['enabled']).enabled, enabled)
def test_positive_delete_synced_product(self):
"""Create a sync plan with one synced product and delete it.
@id: 195d8fec-1fa0-42ab-84a5-32dd81a285ca
@Assert: A sync plan is created with one synced product and sync plan
can be deleted.
@CaseLevel: Integration
"""
sync_plan = entities.SyncPlan(organization=self.org).create()
product = entities.Product(organization=self.org).create()
entities.Repository(product=product).create()
sync_plan.add_products(data={'product_ids': [product.id]})
product.sync()
sync_plan.delete()
with self.assertRaises(HTTPError):
sync_plan.read()
def test_positive_update_sync_date(self):
"""Updated sync plan's sync date.
:id: fad472c7-01b4-453b-ae33-0845c9e0dfd4
:expectedresults: Sync date is updated with the specified sync date.
:CaseImportance: Critical
"""
sync_plan = entities.SyncPlan(
organization=self.org,
sync_date=datetime.now() + timedelta(days=10),
).create()
for syncdate in valid_sync_dates():
with self.subTest(syncdate):
sync_plan.sync_date = syncdate
self.assertEqual(syncdate.strftime('%Y-%m-%d %H:%M:%S UTC'),
sync_plan.update(['sync_date']).sync_date)
def test_positive_update_interval(self):
"""Create a sync plan and update its interval.
@id: cf2eddf8-b4db-430e-a9b0-83c626b45068
@Assert: A sync plan is created and its interval can be updated with
the specified interval.
"""
for interval in valid_sync_interval():
with self.subTest(interval):
sync_plan = entities.SyncPlan(organization=self.org)
result = sync_plan.get_fields()['interval']
sync_plan.interval = sample(
set(result.choices) - set([interval]), 1)[0]
sync_plan = sync_plan.create()
sync_plan.interval = interval
self.assertEqual(
sync_plan.update(['interval']).interval, interval)
def test_positive_add_product(module_org):
"""Create a sync plan and add one product to it.
:id: 036dea02-f73d-4fc1-9c41-5515b6659c79
:expectedresults: A sync plan can be created and one product can be
added to it.
:CaseLevel: Integration
:CaseImportance: Critical
"""
syncplan = entities.SyncPlan(organization=module_org).create()
product = entities.Product(organization=module_org).create()
syncplan.add_products(data={'product_ids': [product.id]})
syncplan = syncplan.read()
assert len(syncplan.product) == 1
assert syncplan.product[0].id == product.id
def test_positive_update_sync_date(module_org, syncdate):
"""Updated sync plan's sync date.
:id: fad472c7-01b4-453b-ae33-0845c9e0dfd4
:parametrized: yes
:expectedresults: Sync date is updated with the specified sync date.
:CaseImportance: Critical
"""
sync_plan = entities.SyncPlan(organization=module_org,
sync_date=datetime.now() +
timedelta(days=10)).create()
sync_plan.sync_date = syncdate
sync_plan.update(['sync_date'])
sync_plan = sync_plan.read()
assert syncdate.strftime('%Y-%m-%d %H:%M:%S UTC') == sync_plan.sync_date
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: b70a0c50-7335-4285-b24c-edfc1187f034
:expectedresults: Product is synchronized successfully.
:CaseLevel: System
"""
delay = 4 * 60 # delay for sync date in seconds
sync_plan = entities.SyncPlan(
organization=self.org,
enabled=True,
sync_date=datetime.utcnow() + timedelta(seconds=delay),
).create()
product = entities.Product(organization=self.org).create()
repo = entities.Repository(product=product).create()
# Verify product is not synced and doesn't have any content
with self.assertRaises(AssertionError):
self.validate_task_status(repo.id, max_tries=2)
self.validate_repo_content(repo,
['erratum', 'package', 'package_group'],
after_sync=False)
# Associate sync plan with product
sync_plan.add_products(data={'product_ids': [product.id]})
# Wait half 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=2)
self.validate_repo_content(repo,
['erratum', 'package', 'package_group'],
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)
# Verify product was synced successfully
self.validate_task_status(repo.id)
self.validate_repo_content(repo,
['erratum', 'package', 'package_group'])
def test_positive_synchronize_custom_product_past_sync_date(module_org):
"""Create a sync plan with past datetime as a sync date, add a
custom product and verify the product gets synchronized on the next
sync occurrence
:id: 0495cb39-2f15-4b6e-9828-1e9517c5c826
:expectedresults: Product is synchronized successfully.
:BZ: 1279539
:CaseLevel: System
"""
interval = 60 * 60 # 'hourly' sync interval in seconds
delay = 2 * 60
product = entities.Product(organization=module_org).create()
repo = entities.Repository(product=product).create()
# Create and Associate sync plan with product
sync_plan = entities.SyncPlan(
organization=module_org,
enabled=True,
interval='hourly',
sync_date=datetime.utcnow().replace(second=0) - timedelta(seconds=interval - delay),
).create()
sync_plan.add_products(data={'product_ids': [product.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 is not synced and doesn't have any content
with pytest.raises(AssertionError):
validate_task_status(repo.id, module_org.id, max_tries=1)
validate_repo_content(repo, ['erratum', 'package', 'package_group'], after_sync=False)
# Wait until the next 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, ['erratum', 'package', 'package_group'])
def test_positive_repeatedly_add_remove(module_org):
"""Repeatedly add and remove a product from a sync plan.
:id: b67536ba-3a36-4bb7-a405-0e12081d5a7e
:expectedresults: A task is returned which can be used to monitor the
additions and removals.
:CaseLevel: Integration
:BZ: 1199150
"""
syncplan = entities.SyncPlan(organization=module_org).create()
product = entities.Product(organization=module_org).create()
for _ in range(5):
syncplan.add_products(data={'product_ids': [product.id]})
assert len(syncplan.read().product) == 1
syncplan.remove_products(data={'product_ids': [product.id]})
assert len(syncplan.read().product) == 0
def test_positive_create_with_interval(module_org, interval):
"""Create a sync plan with a random interval.
:id: d160ed1c-b698-42dc-be0b-67ac693c7840
:parametrized: yes
:expectedresults: A sync plan is created with the specified interval.
:CaseImportance: Critical
"""
sync_plan = entities.SyncPlan(description=gen_string('alpha'),
organization=module_org,
interval=interval)
if interval == SYNC_INTERVAL['custom']:
sync_plan.cron_expression = gen_choice(valid_cron_expressions())
sync_plan = sync_plan.create()
sync_plan = sync_plan.read()
assert sync_plan.interval == interval
