def test_positive_update_gpg(self):
"""Create a product and update its GPGKey
@id: 3b08f155-a0d6-4987-b281-dc02e8d5a03e
@Assert: The updated product points to a new GPG key.
@CaseLevel: Integration
"""
# Create a product and make it point to a GPG key.
gpg_key_1 = entities.GPGKey(
content=read_data_file(VALID_GPG_KEY_FILE),
organization=self.org,
).create()
product = entities.Product(
gpg_key=gpg_key_1, organization=self.org).create()
# Update the product and make it point to a new GPG key.
gpg_key_2 = entities.GPGKey(
content=read_data_file(VALID_GPG_KEY_BETA_FILE),
organization=self.org,
).create()
product.gpg_key = gpg_key_2
product = product.update()
self.assertEqual(product.gpg_key.id, gpg_key_2.id)
def test_positive_update_gpg(self):
"""Create a repository and update its GPGKey
@Assert: The updated repository points to a new GPG key.
@Feature: Repository
"""
# Create a repo and make it point to a GPG key.
gpg_key_1 = entities.GPGKey(
content=read_data_file(VALID_GPG_KEY_FILE),
organization=self.org,
).create()
repo = entities.Repository(
gpg_key=gpg_key_1,
product=self.product,
).create()
# Update the repo and make it point to a new GPG key.
gpg_key_2 = entities.GPGKey(
content=read_data_file(VALID_GPG_KEY_BETA_FILE),
organization=self.org,
).create()
repo.gpg_key = gpg_key_2
repo = repo.update()
self.assertEqual(repo.gpg_key.id, gpg_key_2.id)
def test_positive_update_gpg(self):
"""Create a repository and update its GPGKey
@id: 0e9319dc-c922-4ecf-9f83-d221cfdf54c2
@Assert: The updated repository points to a new GPG key.
@CaseLevel: Integration
"""
# Create a repo and make it point to a GPG key.
gpg_key_1 = entities.GPGKey(
content=read_data_file(VALID_GPG_KEY_FILE),
organization=self.org,
).create()
repo = entities.Repository(
gpg_key=gpg_key_1,
product=self.product,
).create()
# Update the repo and make it point to a new GPG key.
gpg_key_2 = entities.GPGKey(
content=read_data_file(VALID_GPG_KEY_BETA_FILE),
organization=self.org,
).create()
repo.gpg_key = gpg_key_2
repo = repo.update()
self.assertEqual(repo.gpg_key.id, gpg_key_2.id)
def test_positive_update_gpg(self):
"""Create a repository and update its GPGKey
@id: 0e9319dc-c922-4ecf-9f83-d221cfdf54c2
@Assert: The updated repository points to a new GPG key.
@CaseLevel: Integration
"""
# Create a repo and make it point to a GPG key.
gpg_key_1 = entities.GPGKey(
content=read_data_file(VALID_GPG_KEY_FILE),
organization=self.org,
).create()
repo = entities.Repository(
gpg_key=gpg_key_1,
product=self.product,
).create()
# Update the repo and make it point to a new GPG key.
gpg_key_2 = entities.GPGKey(
content=read_data_file(VALID_GPG_KEY_BETA_FILE),
organization=self.org,
).create()
repo.gpg_key = gpg_key_2
repo = repo.update()
self.assertEqual(repo.gpg_key.id, gpg_key_2.id)
def test_positive_update_gpg(self):
"""Create a product and update its GPGKey
:id: 3b08f155-a0d6-4987-b281-dc02e8d5a03e
:expectedresults: The updated product points to a new GPG key.
:CaseLevel: Integration
"""
# Create a product and make it point to a GPG key.
gpg_key_1 = entities.GPGKey(
content=read_data_file(VALID_GPG_KEY_FILE),
organization=self.org,
).create()
product = entities.Product(gpg_key=gpg_key_1,
organization=self.org).create()
# Update the product and make it point to a new GPG key.
gpg_key_2 = entities.GPGKey(
content=read_data_file(VALID_GPG_KEY_BETA_FILE),
organization=self.org,
).create()
product.gpg_key = gpg_key_2
product = product.update()
self.assertEqual(product.gpg_key.id, gpg_key_2.id)
def test_positive_update_gpg(self):
"""Create a repository and update its GPGKey
@Assert: The updated repository points to a new GPG key.
@Feature: Repository
"""
# Create a repo and make it point to a GPG key.
gpg_key_1 = entities.GPGKey(
content=read_data_file(VALID_GPG_KEY_FILE),
organization=self.org,
).create()
repo = entities.Repository(
gpg_key=gpg_key_1,
product=self.product,
).create()
# Update the repo and make it point to a new GPG key.
gpg_key_2 = entities.GPGKey(
content=read_data_file(VALID_GPG_KEY_BETA_FILE),
organization=self.org,
).create()
repo.gpg_key = gpg_key_2
repo = repo.update()
self.assertEqual(repo.gpg_key.id, gpg_key_2.id)
def test_positive_end_to_end_custom_yum_crud(session, module_org, module_prod):
"""Perform end to end testing for custom yum repository
:id: 8baf11c9-019e-4625-a549-ec4cd9312f75
:expectedresults: All expected CRUD actions finished successfully
:CaseLevel: Integration
:CaseImportance: High
"""
repo_name = gen_string('alpha')
checksum_type = 'sha256'
new_repo_name = gen_string('alphanumeric')
new_checksum_type = 'sha1'
gpg_key = entities.GPGKey(
content=read_data_file(VALID_GPG_KEY_FILE), organization=module_org
).create()
new_gpg_key = entities.GPGKey(
content=read_data_file(VALID_GPG_KEY_BETA_FILE), organization=module_org
).create()
with session:
session.repository.create(
module_prod.name,
{
'name': repo_name,
'repo_type': REPO_TYPE['yum'],
'repo_content.upstream_url': settings.repos.yum_1.url,
'repo_content.checksum_type': checksum_type,
'repo_content.gpg_key': gpg_key.name,
'repo_content.download_policy': DOWNLOAD_POLICIES['immediate'],
},
)
assert session.repository.search(module_prod.name, repo_name)[0]['Name'] == repo_name
repo_values = session.repository.read(module_prod.name, repo_name)
assert repo_values['repo_content']['upstream_url'] == settings.repos.yum_1.url
assert repo_values['repo_content']['metadata_type'] == checksum_type
assert repo_values['repo_content']['gpg_key'] == gpg_key.name
assert repo_values['repo_content']['download_policy'] == DOWNLOAD_POLICIES['immediate']
session.repository.update(
module_prod.name,
repo_name,
{
'name': new_repo_name,
'repo_content.upstream_url': settings.repos.yum_2.url,
'repo_content.metadata_type': new_checksum_type,
'repo_content.gpg_key': new_gpg_key.name,
'repo_content.download_policy': DOWNLOAD_POLICIES['immediate'],
},
)
assert not session.repository.search(module_prod.name, repo_name)
repo_values = session.repository.read(module_prod.name, new_repo_name)
assert repo_values['name'] == new_repo_name
assert repo_values['repo_content']['upstream_url'] == settings.repos.yum_2.url
assert repo_values['repo_content']['metadata_type'] == new_checksum_type
assert repo_values['repo_content']['gpg_key'] == new_gpg_key.name
assert repo_values['repo_content']['download_policy'] == DOWNLOAD_POLICIES['immediate']
session.repository.delete(module_prod.name, new_repo_name)
assert not session.repository.search(module_prod.name, new_repo_name)
def test_update_partition_table(self):
"""@Test: Update partition table with its name, layout and OS family
@Feature: Partition table - Positive Update
@Assert: Partition table is updated
"""
name = gen_string('alphanumeric')
with Session(self.browser) as session:
make_partitiontable(
session,
name=name,
layout='test layout',
os_family='Debian',
)
self.assertIsNotNone(self.partitiontable.search(name))
for test_data in valid_partition_table_update_names():
with self.subTest(test_data):
bug_id = test_data.pop('bugzilla', None)
if bug_id is not None and bz_bug_is_open(bug_id):
self.skipTest(
'Bugzilla bug {0} is open for html '
'data.'.format(bug_id)
)
self.partitiontable.update(
name,
test_data['new_name'],
read_data_file(PARTITION_SCRIPT_DATA_FILE),
'Red Hat',
)
self.assertIsNotNone(self.partitiontable.search(
test_data['new_name']))
name = test_data['new_name'] # for next iteration
def test_update_partition_table(self, test_data):
"""@Test: Update partition table with its name, layout and OS family
@Feature: Partition table - Positive Update
@Assert: Partition table is updated
"""
bug_id = test_data.pop('bugzilla', None)
if bug_id is not None and bz_bug_is_open(bug_id):
self.skipTest(
'Bugzilla bug {0} is open for html data.'.format(bug_id)
)
with Session(self.browser) as session:
make_partitiontable(
session,
name=test_data['name'],
layout='test layout',
os_family='Debian',
)
self.assertIsNotNone(self.partitiontable.search(test_data['name']))
self.partitiontable.update(
test_data['name'],
test_data['new_name'],
read_data_file(PARTITION_SCRIPT_DATA_FILE),
'Red Hat',
)
self.assertIsNotNone(self.partitiontable.search
(test_data['new_name']))
def test_positive_update_gpg(self):
"""Create a product and update its GPGKey
@Assert: The updated product points to a new GPG key.
@Feature: Product
"""
# Create a product and make it point to a GPG key.
gpg_key_1 = entities.GPGKey(content=read_data_file(VALID_GPG_KEY_FILE), organization=self.org).create()
product = entities.Product(gpg_key=gpg_key_1, organization=self.org).create()
# Update the product and make it point to a new GPG key.
gpg_key_2 = entities.GPGKey(content=read_data_file(VALID_GPG_KEY_BETA_FILE), organization=self.org).create()
product.gpg_key = gpg_key_2
product = product.update()
self.assertEqual(product.gpg_key.id, gpg_key_2.id)
def test_positive_end_to_end(session, module_org):
"""Perform end to end testing for product component
:id: d0e1f0d1-2380-4508-b270-62c1d8b3e2ff
:expectedresults: All expected CRUD actions finished successfully
:CaseLevel: Integration
:CaseImportance: Critical
"""
product_name = gen_string('alpha')
new_product_name = gen_string('alpha')
product_label = gen_string('alpha')
product_description = gen_string('alpha')
gpg_key = entities.GPGKey(content=read_data_file(VALID_GPG_KEY_FILE),
organization=module_org).create()
sync_plan = entities.SyncPlan(organization=module_org).create()
with session:
# Create new product using different parameters
session.product.create({
'name': product_name,
'label': product_label,
'gpg_key': gpg_key.name,
'sync_plan': sync_plan.name,
'description': product_description,
})
assert session.product.search(product_name)[0]['Name'] == product_name
# Verify that created entity has expected parameters
product_values = session.product.read(product_name)
assert product_values['details']['name'] == product_name
assert product_values['details']['label'] == product_label
assert product_values['details']['gpg_key'] == gpg_key.name
assert product_values['details']['description'] == product_description
assert product_values['details']['sync_plan'] == sync_plan.name
# Update a product with a different name
session.product.update(product_name,
{'details.name': new_product_name})
assert session.product.search(product_name)[0]['Name'] != product_name
assert session.product.search(
new_product_name)[0]['Name'] == new_product_name
# Add a repo to product
session.repository.create(
new_product_name,
{
'name': gen_string('alpha'),
'repo_type': REPO_TYPE['yum'],
'repo_content.upstream_url': FAKE_1_YUM_REPO,
},
)
# Synchronize the product
result = session.product.synchronize(new_product_name)
assert result['result'] == 'success'
product_values = session.product.read(new_product_name)
assert product_values['details']['repos_count'] == '1'
assert product_values['details']['sync_state'] == 'Syncing Complete.'
# Delete product
session.product.delete(new_product_name)
assert session.product.search(
new_product_name)[0]['Name'] != new_product_name
def test_positive_create_with_gpg(self):
"""Create a repository and provide a GPG key ID.
@Assert: A repository is created with the given GPG key ID.
@Feature: Repository
"""
gpg_key = entities.GPGKey(content=read_data_file(VALID_GPG_KEY_FILE), organization=self.org).create()
repo = entities.Repository(gpg_key=gpg_key, product=self.product).create()
# Verify that the given GPG key ID is used.
self.assertEqual(gpg_key.id, repo.gpg_key.id)
def test_positive_update_GPG(self, repo_name):
"""@Test: Update content repository with new gpg-key
@Feature: Content Repo - Positive Update
@Assert: Repo is updated with new gpg key
"""
key_1_content = read_data_file(VALID_GPG_KEY_FILE)
key_2_content = read_data_file(VALID_GPG_KEY_BETA_FILE)
# Create two new GPGKey's
gpgkey_1 = entities.GPGKey(
content=key_1_content,
organization=self.organization,
).create()
gpgkey_2 = entities.GPGKey(
content=key_2_content,
organization=self.organization,
).create()
product = entities.Product(organization=self.organization).create()
with Session(self.browser) as session:
make_repository(
session,
org=self.organization.name,
name=repo_name,
product=product.name,
url=FAKE_1_YUM_REPO,
gpg_key=gpgkey_1.name,
)
self.assertIsNotNone(self.repository.search(repo_name))
self.assertTrue(self.repository.validate_field(
repo_name, 'gpgkey', gpgkey_1.name))
self.navigator.go_to_products()
self.products.search(product.name).click()
self.repository.update(repo_name, new_gpg_key=gpgkey_2.name)
self.navigator.go_to_products()
self.products.search(product.name).click()
self.assertTrue(self.repository.validate_field(
repo_name, 'gpgkey', gpgkey_2.name))
def test_positive_update_gpg(self):
"""Update content repository with new gpg-key
@Feature: Content Repo - Positive Update
@Assert: Repository is updated with new gpg key
"""
repo_name = gen_string('alphanumeric')
key_1_content = read_data_file(VALID_GPG_KEY_FILE)
key_2_content = read_data_file(VALID_GPG_KEY_BETA_FILE)
# Create two new GPGKey's
gpgkey_1 = entities.GPGKey(
content=key_1_content,
organization=self.organization,
).create()
gpgkey_2 = entities.GPGKey(
content=key_2_content,
organization=self.organization,
).create()
product = entities.Product(organization=self.organization).create()
with Session(self.browser) as session:
set_context(session, org=self.organization.name)
self.products.search(product.name).click()
make_repository(
session,
name=repo_name,
url=FAKE_1_YUM_REPO,
gpg_key=gpgkey_1.name,
)
self.assertIsNotNone(self.repository.search(repo_name))
self.assertTrue(
self.repository.validate_field(repo_name, 'gpgkey',
gpgkey_1.name))
self.products.search(product.name).click()
self.repository.update(repo_name, new_gpg_key=gpgkey_2.name)
self.products.search(product.name).click()
self.assertTrue(
self.repository.validate_field(repo_name, 'gpgkey',
gpgkey_2.name))
def test_positive_update_gpg(self):
"""Create a product and update its GPGKey
@Assert: The updated product points to a new GPG key.
@Feature: Product
"""
# Create a product and make it point to a GPG key.
gpg_key_1 = entities.GPGKey(
content=read_data_file(VALID_GPG_KEY_FILE),
organization=self.org,
).create()
product = entities.Product(
gpg_key=gpg_key_1, organization=self.org).create()
# Update the product and make it point to a new GPG key.
gpg_key_2 = entities.GPGKey(
content=read_data_file(VALID_GPG_KEY_BETA_FILE),
organization=self.org,
).create()
product.gpg_key = gpg_key_2
product = product.update()
self.assertEqual(product.gpg_key.id, gpg_key_2.id)
def test_positive_create_with_gpg(self):
"""Create a product and provide a GPG key.
@Assert: A product is created with the specified GPG key.
@Feature: Product
"""
# Create an organization, GPG key and product.
#
# product -----------↘
# `-→ gpg_key → organization
gpg_key = entities.GPGKey(content=read_data_file(VALID_GPG_KEY_FILE), organization=self.org).create()
product = entities.Product(gpg_key=gpg_key, organization=self.org).create()
self.assertEqual(product.gpg_key.id, gpg_key.id)
def test_positive_update_content(self):
"""Update GPG key content text to another valid one.
@Assert: The GPG key content text can be updated.
@Feature: GPGKey
"""
gpg_key = entities.GPGKey(
organization=self.org,
content=read_data_file(VALID_GPG_KEY_BETA_FILE),
).create()
gpg_key.content = self.key_content
gpg_key = gpg_key.update(['content'])
self.assertEqual(self.key_content, gpg_key.content)
def test_positive_create_with_gpg(module_org):
"""Create a product and provide a GPG key.
:id: 57331c1f-15dd-4c9f-b8fc-3010847b2975
:expectedresults: A product is created with the specified GPG key.
:CaseLevel: Integration
"""
gpg_key = entities.GPGKey(content=read_data_file(VALID_GPG_KEY_FILE),
organization=module_org).create()
product = entities.Product(gpg_key=gpg_key,
organization=module_org).create()
assert product.gpg_key.id == gpg_key.id
def test_positive_update_content(self):
"""Update GPG key content text to another valid one.
@id: 62fdaf55-c931-4be6-9857-68cc816046ad
@Assert: The GPG key content text can be updated.
"""
gpg_key = entities.GPGKey(
organization=self.org,
content=read_data_file(VALID_GPG_KEY_BETA_FILE),
).create()
gpg_key.content = self.key_content
gpg_key = gpg_key.update(['content'])
self.assertEqual(self.key_content, gpg_key.content)
def test_positive_update_content(self):
"""Update GPG key content text to another valid one.
@id: 62fdaf55-c931-4be6-9857-68cc816046ad
@Assert: The GPG key content text can be updated.
"""
gpg_key = entities.GPGKey(
organization=self.org,
content=read_data_file(VALID_GPG_KEY_BETA_FILE),
).create()
gpg_key.content = self.key_content
gpg_key = gpg_key.update(['content'])
self.assertEqual(self.key_content, gpg_key.content)
def test_positive_update_gpg(self):
"""Update content repository with new gpg-key
@id: 51da6572-02d0-43d7-96cc-895b5bebfadb
@Assert: Repository is updated with new gpg key
"""
repo_name = gen_string('alphanumeric')
key_1_content = read_data_file(VALID_GPG_KEY_FILE)
key_2_content = read_data_file(VALID_GPG_KEY_BETA_FILE)
# Create two new GPGKey's
gpgkey_1 = entities.GPGKey(
content=key_1_content,
organization=self.organization,
).create()
gpgkey_2 = entities.GPGKey(
content=key_2_content,
organization=self.organization,
).create()
product = entities.Product(organization=self.organization).create()
with Session(self.browser) as session:
set_context(session, org=self.organization.name)
self.products.search(product.name).click()
make_repository(
session,
name=repo_name,
url=FAKE_1_YUM_REPO,
gpg_key=gpgkey_1.name,
)
self.assertIsNotNone(self.repository.search(repo_name))
self.assertTrue(self.repository.validate_field(
repo_name, 'gpgkey', gpgkey_1.name))
self.products.search(product.name).click()
self.repository.update(repo_name, new_gpg_key=gpgkey_2.name)
self.products.search(product.name).click()
self.assertTrue(self.repository.validate_field(
repo_name, 'gpgkey', gpgkey_2.name))
def test_positive_delete(self):
"""Create content view and publish it. After that try to
disassociate content view from 'Library' environment through
'delete_from_environment' command and delete content view version from
that content view. Add repository and gpg key to initial content view
for better coverage
:id: 066dec47-c942-4c01-8956-359c8b23a6d4
:expectedresults: Content version deleted successfully
:CaseLevel: Integration
:CaseImportance: Critical
"""
key_content = read_data_file(ZOO_CUSTOM_GPG_KEY)
org = entities.Organization().create()
gpgkey = entities.GPGKey(
content=key_content,
organization=org,
).create()
# Creates new product without selecting GPGkey
product = entities.Product(organization=org).create()
# Creates new repository with GPGKey
repo = entities.Repository(
gpg_key=gpgkey,
product=product,
url=FAKE_1_YUM_REPO,
).create()
# sync repository
repo.sync()
# Create content view
content_view = entities.ContentView(organization=org).create()
# Associate repository to new content view
content_view.repository = [repo]
content_view = content_view.update(['repository'])
# Publish content view
content_view.publish()
content_view = content_view.read()
# Get published content-view version id
self.assertEqual(len(content_view.version), 1)
cvv = content_view.version[0].read()
self.assertEqual(len(cvv.environment), 1)
# Delete the content-view version from selected env
content_view.delete_from_environment(cvv.environment[0].id)
# Delete the version
content_view.version[0].delete()
# Make sure that content view version is really removed
self.assertEqual(len(content_view.read().version), 0)
def test_positive_update_content(module_org):
"""Update GPG key content text to another valid one.
:id: 62fdaf55-c931-4be6-9857-68cc816046ad
:expectedresults: The GPG key content text can be updated.
:CaseImportance: Critical
"""
gpg_key = entities.GPGKey(
organization=module_org,
content=read_data_file(VALID_GPG_KEY_BETA_FILE)).create()
gpg_key.content = key_content
gpg_key = gpg_key.update(['content'])
assert key_content == gpg_key.content
def test_positive_create_partition_table(self, name):
"""@Test: Create a new partition table
@Feature: Partition table - Positive Create
@Assert: Partition table is created
"""
with Session(self.browser) as session:
make_partitiontable(
session,
name=name,
layout=read_data_file(PARTITION_SCRIPT_DATA_FILE),
os_family='Red Hat'
)
self.assertIsNotNone(self.partitiontable.search(name))
def test_positive_delete(self):
"""Create content view and publish it. After that try to
disassociate content view from 'Library' environment through
'delete_from_environment' command and delete content view version from
that content view. Add repository and gpg key to initial content view
for better coverage
:id: 066dec47-c942-4c01-8956-359c8b23a6d4
:expectedresults: Content version deleted successfully
:CaseLevel: Integration
"""
key_content = read_data_file(ZOO_CUSTOM_GPG_KEY)
org = entities.Organization().create()
gpgkey = entities.GPGKey(
content=key_content,
organization=org,
).create()
# Creates new product without selecting GPGkey
product = entities.Product(organization=org).create()
# Creates new repository with GPGKey
repo = entities.Repository(
gpg_key=gpgkey,
product=product,
url=FAKE_1_YUM_REPO,
).create()
# sync repository
repo.sync()
# Create content view
content_view = entities.ContentView(organization=org).create()
# Associate repository to new content view
content_view.repository = [repo]
content_view = content_view.update(['repository'])
# Publish content view
content_view.publish()
content_view = content_view.read()
# Get published content-view version id
self.assertEqual(len(content_view.version), 1)
cvv = content_view.version[0].read()
self.assertEqual(len(cvv.environment), 1)
# Delete the content-view version from selected env
content_view.delete_from_environment(cvv.environment[0].id)
# Delete the version
content_view.version[0].delete()
# Make sure that content view version is really removed
self.assertEqual(len(content_view.read().version), 0)
def test_positive_product_create_with_create_sync_plan(session, module_org):
"""Perform Sync Plan Create from Product Create Page
:id: 4a87b533-12b6-4d4e-8a99-4bb95efc4321
:expectedresults: Ensure sync get created and assigned to Product.
:CaseLevel: Integration
:CaseImportance: Medium
"""
product_name = gen_string('alpha')
product_description = gen_string('alpha')
gpg_key = entities.GPGKey(content=read_data_file(VALID_GPG_KEY_FILE),
organization=module_org).create()
plan_name = gen_string('alpha')
description = gen_string('alpha')
cron_expression = gen_choice(valid_cron_expressions())
with session:
session.organization.select(module_org.name)
startdate = session.browser.get_client_datetime() + timedelta(
minutes=10)
sync_plan_values = {
'name': plan_name,
'interval': SYNC_INTERVAL['custom'],
'description': description,
'cron_expression': cron_expression,
'date_time.start_date': startdate.strftime("%Y-%m-%d"),
'date_time.hours': startdate.strftime('%H'),
'date_time.minutes': startdate.strftime('%M'),
}
session.product.create(
{
'name': product_name,
'gpg_key': gpg_key.name,
'description': product_description
},
sync_plan_values=sync_plan_values,
)
assert session.product.search(product_name)[0]['Name'] == product_name
product_values = session.product.read(product_name,
widget_names='details')
assert product_values['details']['name'] == product_name
assert product_values['details']['sync_plan'] == plan_name
# Delete product
session.product.delete(product_name)
assert session.product.search(product_name)[0]['Name'] != product_name
def test_positive_create_with_name(self):
"""@Test: Create a new partition table
@Feature: Partition table - Positive Create
@Assert: Partition table is created
"""
with Session(self.browser) as session:
for name in generate_strings_list(length=10):
with self.subTest(name):
make_partitiontable(
session,
name=name,
layout=read_data_file(PARTITION_SCRIPT_DATA_FILE),
os_family='Red Hat'
)
self.assertIsNotNone(self.partitiontable.search(name))
def test_negative_create_partition_table_with_empty_name(self, name):
"""@Test: Create partition table with blank and whitespace in name
@Feature: Partition table - Negative Create
@Assert: Partition table is not created
"""
with Session(self.browser) as session:
make_partitiontable(
session,
name=name,
layout=read_data_file(PARTITION_SCRIPT_DATA_FILE),
os_family='Red Hat'
)
self.assertIsNotNone(self.partitiontable.wait_until_element
(common_locators['name_haserror']))
def test_positive_create_with_gpg(self):
"""Create a repository and provide a GPG key ID.
@Assert: A repository is created with the given GPG key ID.
@Feature: Repository
"""
gpg_key = entities.GPGKey(
content=read_data_file(VALID_GPG_KEY_FILE),
organization=self.org,
).create()
repo = entities.Repository(
gpg_key=gpg_key,
product=self.product,
).create()
# Verify that the given GPG key ID is used.
self.assertEqual(gpg_key.id, repo.gpg_key.id)
def test_positive_create_with_gpg(self):
"""Create a product and provide a GPG key.
:id: 57331c1f-15dd-4c9f-b8fc-3010847b2975
:expectedresults: A product is created with the specified GPG key.
:CaseLevel: Integration
"""
# Create an organization, GPG key and product.
#
# product -----------↘
# `-→ gpg_key → organization
gpg_key = entities.GPGKey(content=read_data_file(VALID_GPG_KEY_FILE),
organization=self.org).create()
product = entities.Product(gpg_key=gpg_key,
organization=self.org).create()
self.assertEqual(product.gpg_key.id, gpg_key.id)
def test_positive_create_with_gpg(self):
"""Create a product and provide a GPG key.
@Assert: A product is created with the specified GPG key.
@Feature: Product
"""
# Create an organization, GPG key and product.
#
# product -----------↘
# `-→ gpg_key → organization
gpg_key = entities.GPGKey(
content=read_data_file(VALID_GPG_KEY_FILE),
organization=self.org,
).create()
product = entities.Product(
gpg_key=gpg_key, organization=self.org).create()
self.assertEqual(product.gpg_key.id, gpg_key.id)
def test_negative_create_with_same_name(self):
"""@Test: Create a new partition table with same name
@Feature: Partition table - Negative Create
@Assert: Partition table is not created
"""
name = gen_string('utf8')
layout = read_data_file(PARTITION_SCRIPT_DATA_FILE)
os_family = 'Red Hat'
with Session(self.browser) as session:
make_partitiontable(
session, name=name, layout=layout, os_family=os_family)
self.assertIsNotNone(self.partitiontable.search(name))
make_partitiontable(
session, name=name, layout=layout, os_family=os_family)
self.assertIsNotNone(self.partitiontable.wait_until_element
(common_locators['name_haserror']))
def test_positive_product_create_with_create_sync_plan(session, module_org):
"""Perform Sync Plan Create from Product Create Page
:id: 4a87b533-12b6-4d4e-8a99-4bb95efc4321
:expectedresults: Ensure sync get created and assigned to Product.
:CaseLevel: Integration
:CaseImportance: medium
"""
product_name = gen_string('alpha')
product_description = gen_string('alpha')
gpg_key = entities.GPGKey(
content=read_data_file(VALID_GPG_KEY_FILE),
organization=module_org
).create()
plan_name = gen_string('alpha')
description = gen_string('alpha')
cron_expression = gen_choice(valid_cron_expressions())
with session:
startdate = (
session.browser.get_client_datetime() + timedelta(minutes=10))
sync_plan_values = {
'name': plan_name,
'interval': SYNC_INTERVAL['custom'],
'description': description,
'cron_expression': cron_expression,
'date_time.start_date': startdate.strftime("%Y-%m-%d"),
'date_time.hours': startdate.strftime('%H'),
'date_time.minutes': startdate.strftime('%M'),
}
session.product.create({
'name': product_name,
'gpg_key': gpg_key.name,
'description': product_description,
}, sync_plan_values=sync_plan_values)
assert session.product.search(product_name)[0]['Name'] == product_name
product_values = session.product.read(product_name)
assert product_values['details']['name'] == product_name
assert product_values['details']['sync_plan'] == plan_name
# Delete product
session.product.delete(product_name)
assert not session.product.search(product_name)
def test_delete_version_default(self):
"""@Test: Delete a content-view version associated to 'Library'
@Assert: Deletion fails
@Feature: ContentViewVersion
"""
key_content = read_data_file(ZOO_CUSTOM_GPG_KEY)
org = entities.Organization().create()
gpgkey = entities.GPGKey(
content=key_content,
organization=org,
).create()
# Creates new product without selecting GPGkey
product = entities.Product(organization=org).create()
# Creates new repository with GPGKey
repo = entities.Repository(
url=FAKE_1_YUM_REPO,
gpg_key=gpgkey,
product=product,
).create()
# sync repository
repo.sync()
# Create content view
cv = entities.ContentView(organization=org).create()
cv.repository = [repo]
cv = cv.update(['repository'])
self.assertEqual(len(cv.repository), 1)
# Publish content view
cv.publish()
# Get published content-view version info
cv_info = entities.ContentView(id=cv.id).read_json()
self.assertEqual(len(cv_info['versions']), 1)
# API returns version like '1.0'
version_num = cv_info['versions'][0]['version']
# WebUI displays version like 'Version 1.0'
version = 'Version {0}'.format(version_num)
with Session(self.browser) as session:
session.nav.go_to_select_org(org.name)
session.nav.go_to_content_views()
self.content_views.delete_version(cv.name, version)
self.content_views.check_progress_bar_status(version)
self.content_views.validate_version_deleted(cv.name, version)
def test_positive_create_with_gpg(self):
"""Create a repository and provide a GPG key ID.
@id: 023cf84b-74f3-4e63-a9d7-10afee6c1990
@Assert: A repository is created with the given GPG key ID.
@CaseLevel: Integration
"""
gpg_key = entities.GPGKey(
content=read_data_file(VALID_GPG_KEY_FILE),
organization=self.org,
).create()
repo = entities.Repository(
gpg_key=gpg_key,
product=self.product,
).create()
# Verify that the given GPG key ID is used.
self.assertEqual(gpg_key.id, repo.gpg_key.id)
def test_positive_create_with_gpg(self):
"""Create a repository and provide a GPG key ID.
@id: 023cf84b-74f3-4e63-a9d7-10afee6c1990
@Assert: A repository is created with the given GPG key ID.
@CaseLevel: Integration
"""
gpg_key = entities.GPGKey(
content=read_data_file(VALID_GPG_KEY_FILE),
organization=self.org,
).create()
repo = entities.Repository(
gpg_key=gpg_key,
product=self.product,
).create()
# Verify that the given GPG key ID is used.
self.assertEqual(gpg_key.id, repo.gpg_key.id)
def test_positive_create_with_gpg(self):
"""Create a product and provide a GPG key.
@id: 57331c1f-15dd-4c9f-b8fc-3010847b2975
@Assert: A product is created with the specified GPG key.
@CaseLevel: Integration
"""
# Create an organization, GPG key and product.
#
# product -----------↘
# `-→ gpg_key → organization
gpg_key = entities.GPGKey(
content=read_data_file(VALID_GPG_KEY_FILE),
organization=self.org,
).create()
product = entities.Product(
gpg_key=gpg_key, organization=self.org).create()
self.assertEqual(product.gpg_key.id, gpg_key.id)
def test_negative_create_with_invalid_name(self):
"""@Test: Create partition table with invalid names
@Feature: Partition table - Negative Create
@Assert: Partition table is not created
"""
with Session(self.browser) as session:
for name in invalid_values_list(interface='ui'):
with self.subTest(name):
make_partitiontable(
session,
name=name,
layout=read_data_file(PARTITION_SCRIPT_DATA_FILE),
os_family='Red Hat'
)
self.assertIsNotNone(
self.partitiontable.wait_until_element(
common_locators['name_haserror'])
)
def test_positive_create_2(self):
"""@Test: Create a product and provide a GPG key.
@Assert: A product is created with the specified GPG key.
@Feature: Product
"""
# Create an organization, GPG key and product.
#
# product -----------↘
# `-→ gpg_key → organization
#
# Re-using an organization speeds up the test.
org = entities.Organization().create()
gpg_key = entities.GPGKey(
content=read_data_file(VALID_GPG_KEY_FILE),
organization=org,
).create()
product = entities.Product(gpg_key=gpg_key, organization=org).create()
self.assertEqual(product.gpg_key.id, gpg_key.id)
def test_positive_create_with_gpg(self):
"""Create a repository and provide a GPG key ID.
@Assert: A repository is created with the given GPG key ID.
@Feature: Repository
"""
# Create this dependency tree:
#
# repository -> product -.
# `-> gpg key --`-> organization
#
gpg_key = entities.GPGKey(
content=read_data_file(VALID_GPG_KEY_FILE),
organization=self.org,
).create()
repo = entities.Repository(
gpg_key=gpg_key,
product=self.product,
).create()
# Verify that the given GPG key ID is used.
self.assertEqual(gpg_key.id, repo.read().gpg_key.id)
def setUpClass(cls):
"""Create an user and import different keys from data json file"""
super(SshKeyInUserTestCase, cls).setUpClass()
cls.user = entities.User().create()
cls.data_keys = json.loads(read_data_file('sshkeys.json'))
def test_positive_consume_content_using_repo(self):
"""Hosts can install packages using gpg key associated with single
custom repository
:id: c6b78312-91d3-47a2-a6c6-f906a4522fe4
:expectedresults: host can install package from custom repository
:CaseLevel: System
"""
key_name = gen_string('alphanumeric')
# step1: Create gpg-key
gpgkey = entities.GPGKey(
content=read_data_file(ZOO_CUSTOM_GPG_KEY),
name=key_name,
organization=self.organization,
).create()
# step 1.2: Create new lifecycle environments
lc_env = entities.LifecycleEnvironment(
organization=self.organization).create()
# step2: Creates new product without selecting GPGkey
product = entities.Product(
name=gen_string('alpha'),
organization=self.organization,
).create()
# step3: Creates new repository with GPGKey
repo = entities.Repository(
name=gen_string('alpha'),
url=FAKE_1_YUM_REPO,
product=product,
gpg_key=gpgkey,
).create()
# step 3.1: sync repository
repo.sync()
# step 4: Create content view
content_view = entities.ContentView(
organization=self.organization).create()
# step 5: Associate repository to new content view
content_view.repository = [repo]
content_view = content_view.update(['repository'])
# step 6: Publish content view
content_view.publish()
content_view = content_view.read()
self.assertEqual(len(content_view.version), 1)
# step 6.2: Promote content view to lifecycle_env
content_view.version[0].promote(data={u'environment_id': lc_env.id})
# step 7: Create activation key
act_key = entities.ActivationKey(
content_view=content_view,
environment=lc_env,
name=gen_string('alpha'),
organization=self.organization,
).create()
for sub in entities.Subscription(
organization=self.organization).search():
if sub.read_json()['product_name'] == product.name:
act_key.add_subscriptions(data={
'quantity': 1,
'subscription_id': sub.id,
})
break
# Create VM
package_name = 'cow'
with VirtualMachine(distro=DISTRO_RHEL6) as vm:
# Download and Install rpm
result = vm.run(
"wget -nd -r -l1 --no-parent -A '*-latest.noarch.rpm'"
" http://{0}/pub/".format(settings.server.hostname))
self.assertEqual(result.return_code, 0)
result = vm.run('rpm -i katello-ca-consumer*.noarch.rpm')
self.assertEqual(
result.return_code, 0,
'failed to install katello-ca rpm: {0} and return code: {1}'.
format(result.stderr, result.return_code))
# Register client with foreman server using activation-key
result = vm.run(
u'subscription-manager register --activationkey {0} '
'--org {1} --force'.format(act_key.name,
self.organization.label))
# Commenting following lines because:
# When we register a host without associating the installed OS
# subscriptions, SM register command succeed with exit code '1'.
# self.assertEqual(
# result.return_code, 0,
# "failed to register client:: {0} and return code: {1}"
# .format(result.stderr, result.return_code)
# )
# Validate if gpgcheck flag is enabled in repo file
repo_file = '/etc/yum.repos.d/redhat.repo'
result = vm.run(
'cat {0} | grep gpgcheck | cut -d " " -f3'.format(repo_file))
self.assertEqual(u'1', result.stdout[0])
# Install contents from sat6 server
result = vm.run('yum install -y {0}'.format(package_name))
self.assertEqual(
result.return_code, 0,
'Package install failed: {0} and return code: {1}'.format(
result.stderr, result.return_code))
# Verify if package is installed by query it
result = vm.run('rpm -q {0}'.format(package_name))
self.assertEqual(result.return_code, 0)
def setUpClass(cls):
super(GPGKeyProductAssociateTestCase, cls).setUpClass()
cls.key_content = read_data_file(VALID_GPG_KEY_FILE)
cls.key_path = get_data_file(VALID_GPG_KEY_FILE)
cls.organization = entities.Organization().create()
def setup_class(cls):
cls.key_content = read_data_file(VALID_GPG_KEY_FILE)
cls.key_path = get_data_file(VALID_GPG_KEY_FILE)
cls.organization = entities.Organization().create()
def setUpClass(cls):
"""Create an organization which can be re-used in tests."""
super(GPGKeyTestCase, cls).setUpClass()
cls.org = entities.Organization().create()
cls.key_content = read_data_file(VALID_GPG_KEY_FILE)
def test_positive_end_to_end(session, module_org):
"""Perform end to end testing for product component
:id: d0e1f0d1-2380-4508-b270-62c1d8b3e2ff
:expectedresults: All expected CRUD actions finished successfully
:CaseLevel: Integration
:CaseImportance: High
"""
product_name = gen_string('alpha')
new_product_name = gen_string('alpha')
product_label = gen_string('alpha')
product_description = gen_string('alpha')
gpg_key = entities.GPGKey(
content=read_data_file(VALID_GPG_KEY_FILE),
organization=module_org
).create()
sync_plan = entities.SyncPlan(organization=module_org).create()
with session:
# Create new product using different parameters
session.product.create({
'name': product_name,
'label': product_label,
'gpg_key': gpg_key.name,
'sync_plan': sync_plan.name,
'description': product_description,
})
assert session.product.search(product_name)[0]['Name'] == product_name
# Verify that created entity has expected parameters
product_values = session.product.read(product_name)
assert product_values['details']['name'] == product_name
assert product_values['details']['label'] == product_label
assert product_values['details']['gpg_key'] == gpg_key.name
assert product_values['details']['description'] == product_description
assert product_values['details']['sync_plan'] == sync_plan.name
# Update a product with a different name
session.product.update(
product_name, {'details.name': new_product_name}
)
assert not session.product.search(product_name)
assert session.product.search(new_product_name)[0]['Name'] == new_product_name
# Add a repo to product
session.repository.create(
new_product_name,
{
'name': gen_string('alpha'),
'repo_type': REPO_TYPE['yum'],
'repo_content.upstream_url': FAKE_1_YUM_REPO,
}
)
# Synchronize the product
result = session.product.synchronize(new_product_name)
assert result['result'] == 'success'
product_values = session.product.read(new_product_name)
assert product_values['details']['repos_count'] == '1'
assert product_values['details']['sync_state'] == 'Syncing Complete.'
# Delete product
session.product.delete(new_product_name)
assert not session.product.search(new_product_name)
def gpg_content():
return read_data_file(VALID_GPG_KEY_FILE)
def setUpClass(cls):
"""Create an user and import different keys from data json file"""
super(SshKeyInUserTestCase, cls).setUpClass()
cls.user = entities.User().create()
cls.data_keys = json.loads(read_data_file('sshkeys.json'))
@TestType: Functional
@CaseImportance: High
@Upstream: No
"""
import json
from robottelo import ssh
from robottelo.cli import hammer
from robottelo.decorators import bz_bug_is_open, tier1
from robottelo.helpers import read_data_file
from robottelo.test import CLITestCase
from six import StringIO
HAMMER_COMMANDS = json.loads(read_data_file('hammer_commands.json'))
def _fetch_command_info(command):
"""Fetch command info from expected commands info dictionary."""
info = HAMMER_COMMANDS
if command != 'hammer':
found = []
parts = command.split(' ')[1:] # exclude hammer
for part in parts:
for command in info['subcommands']:
if command['name'] == part:
found.append(part)
info = command
break
if found != parts:
def setUpClass(cls):
super(GPGKey, cls).setUpClass()
cls.key_content = read_data_file(VALID_GPG_KEY_FILE)
cls.key_path = get_data_file(VALID_GPG_KEY_FILE)
cls.organization = entities.Organization().create()
def test_positive_consume_content_using_repo(self):
"""Hosts can install packages using gpg key associated with
single custom repository
@id: c6b78312-91d3-47a2-a6c6-f906a4522fe4
@assert: host can install package from custom repository
@CaseLevel: System
"""
key_name = gen_string("alphanumeric")
# step1: Create gpg-key
gpgkey = entities.GPGKey(
content=read_data_file(ZOO_CUSTOM_GPG_KEY), name=key_name, organization=self.organization
).create()
# step 1.2: Create new lifecycle environments
lc_env = entities.LifecycleEnvironment(organization=self.organization).create()
# step2: Creates new product without selecting GPGkey
product = entities.Product(name=gen_string("alpha"), organization=self.organization).create()
# step3: Creates new repository with GPGKey
repo = entities.Repository(
name=gen_string("alpha"), url=FAKE_1_YUM_REPO, product=product, gpg_key=gpgkey
).create()
# step 3.1: sync repository
repo.sync()
# step 4: Create content view
content_view = entities.ContentView(organization=self.organization).create()
# step 5: Associate repository to new content view
content_view.repository = [repo]
content_view = content_view.update(["repository"])
# step 6: Publish content view
content_view.publish()
content_view = content_view.read()
self.assertEqual(len(content_view.version), 1)
# step 6.2: Promote content view to lifecycle_env
content_view.version[0].promote(data={u"environment_id": lc_env.id})
# step 7: Create activation key
act_key = entities.ActivationKey(
content_view=content_view, environment=lc_env, name=gen_string("alpha"), organization=self.organization
).create()
for sub in entities.Subscription(organization=self.organization).search():
if sub.read_json()["product_name"] == product.name:
act_key.add_subscriptions(data={"quantity": 1, "subscription_id": sub.id})
break
# Create VM
package_name = "cow"
with VirtualMachine(distro=DISTRO_RHEL6) as vm:
# Download and Install rpm
result = vm.run(
"wget -nd -r -l1 --no-parent -A '*.noarch.rpm' http://{0}/pub/".format(settings.server.hostname)
)
self.assertEqual(result.return_code, 0)
result = vm.run("rpm -i katello-ca-consumer*.noarch.rpm")
self.assertEqual(
result.return_code,
0,
"failed to install katello-ca rpm: {0} and return code: {1}".format(result.stderr, result.return_code),
)
# Register client with foreman server using activation-key
result = vm.run(
u"subscription-manager register --activationkey {0} "
"--org {1} --force".format(act_key.name, self.organization.label)
)
# Commenting following lines because:
# When we register a host without associating the installed OS
# subscriptions, SM register command succeed with exit code '1'.
# self.assertEqual(
# result.return_code, 0,
# "failed to register client:: {0} and return code: {1}"
# .format(result.stderr, result.return_code)
# )
# Validate if gpgcheck flag is enabled in repo file
repo_file = "/etc/yum.repos.d/redhat.repo"
result = vm.run('cat {0} | grep gpgcheck | cut -d " " -f3'.format(repo_file))
self.assertEqual(u"1", result.stdout[0])
# Install contents from sat6 server
result = vm.run("yum install -y {0}".format(package_name))
self.assertEqual(
result.return_code,
0,
"Package install failed: {0} and return code: {1}".format(result.stderr, result.return_code),
)
# Verify if package is installed by query it
result = vm.run("rpm -q {0}".format(package_name))
self.assertEqual(result.return_code, 0)
def template_data():
return read_data_file(PARTITION_SCRIPT_DATA_FILE)
"""Tests related to hammer command and its options and subcommands."""
import json
from robottelo import ssh
from robottelo.cli import hammer
from robottelo.decorators import bz_bug_is_open, tier1
from robottelo.helpers import read_data_file
from robottelo.test import CLITestCase
HAMMER_COMMANDS = json.loads(read_data_file('hammer_commands.json'))
def _fetch_command_info(command):
"""Fetch command info from expected commands info dictionary."""
info = HAMMER_COMMANDS
if command != 'hammer':
found = []
parts = command.split(' ')[1:] # exclude hammer
for part in parts:
for command in info['subcommands']:
if command['name'] == part:
found.append(part)
info = command
break
if found != parts:
return None
return info
class HammerCommandsTestCase(CLITestCase):
"""Tests for ensuring that all expected hammer subcommands and its options
def create_user(self):
"""Create an user and import different keys from data json file"""
user = entities.User().create()
data_keys = json.loads(read_data_file('sshkeys.json'))
return dict(user=user, data_keys=data_keys)
:Upstream: No
"""
import pytest
from fauxfactory import gen_string
from nailgun import entities
from requests import HTTPError
from robottelo.constants import VALID_GPG_KEY_BETA_FILE
from robottelo.constants import VALID_GPG_KEY_FILE
from robottelo.datafactory import invalid_values_list
from robottelo.datafactory import parametrized
from robottelo.datafactory import valid_data_list
from robottelo.helpers import read_data_file
key_content = read_data_file(VALID_GPG_KEY_FILE)
@pytest.mark.parametrize('name', **parametrized(valid_data_list()))
@pytest.mark.tier1
def test_positive_create_with_name(module_org, name):
"""Create a GPG key with valid name.
:id: 741d969b-28ef-481f-bcf7-ed4cd920b030
:parametrized: yes
:expectedresults: A GPG key is created with the given name.
:CaseImportance: Critical
"""
def template_data():
return read_data_file(OS_TEMPLATE_DATA_FILE)
def setUpClass(cls):
"""Create an organization which can be re-used in tests."""
super(GPGKeyTestCase, cls).setUpClass()
cls.org = entities.Organization().create()
cls.key_content = read_data_file(VALID_GPG_KEY_FILE)
