def test_positive_create_in_different_orgs(self):
"""@Test: Create Content Product with same name but in another org
@Feature: Content Product - Positive Create
@Assert: Product is created successfully in both the orgs.
"""
for prd_name in generate_strings_list():
with self.subTest(prd_name):
# Note 1: the second org is created before logging in to
# browser session otherwise this new org will not show up in
# org dropdown
# Note 2: Also note that the session is logged out and logged
# back in for every iteration unlike other subTest()
# implementations mainly for re-populating the org dropdown
org2 = entities.Organization().create()
with Session(self.browser) as session:
make_product(
session,
org=self.organization.name,
loc=self.loc.name,
name=prd_name,
description=gen_string('alphanumeric'),
)
self.assertIsNotNone(self.products.search(prd_name))
make_product(
session,
org=org2.name,
loc=self.loc.name,
name=prd_name,
description=gen_string('alphanumeric'),
)
self.assertIsNotNone(self.products.search(prd_name))
def test_positive_create_2(self, prd_name):
"""@Test: Create Content Product with same name but in another org
@Feature: Content Product - Positive Create
@Assert: Product is created successfully in both the orgs.
"""
description = "test 123"
org2_name = entities.Organization(
name=gen_string("alpha", 8)).create()['name']
with Session(self.browser) as session:
make_product(session,
org=self.org_name,
loc=self.loc_name,
name=prd_name,
description=description)
self.assertIsNotNone(self.products.search(prd_name))
make_product(session,
org=org2_name,
loc=self.loc_name,
name=prd_name,
description=description,
force_context=True)
self.assertIsNotNone(self.products.search(prd_name))
def test_positive_update_1(self, repo_name):
"""
@Feature: Content Repo - Positive Update
@Test: Update Content Repo with repository url
@Assert: Repo is updated with new url
"""
prd_name = generate_string("alpha", 8)
locator = locators["repo.fetch_url"]
repo_url = "http://inecas.fedorapeople.org/fakerepos/zoo3/"
new_repo_url = "http://inecas.fedorapeople.org/fakerepos/zoo2/"
description = "test 123"
with Session(self.browser) as session:
make_product(session, self.org_name, self.loc_name, name=prd_name,
description=description)
self.assertIsNotNone(self.products.search(prd_name))
self.repository.create(repo_name, product=prd_name, url=repo_url)
self.assertIsNotNone(self.repository.search(repo_name))
self.repository.search(repo_name).click()
url_text = self.repository.wait_until_element(locator).text
self.assertEqual(url_text, repo_url)
self.navigator.go_to_products()
self.products.search(prd_name).click()
self.repository.update(repo_name, new_url=new_repo_url)
url_text = self.repository.wait_until_element(locator).text
self.assertEqual(url_text, new_repo_url)
def test_positive_create_in_different_orgs(self, prd_name):
"""@Test: Create Content Product with same name but in another org
@Feature: Content Product - Positive Create
@Assert: Product is created successfully in both the orgs.
"""
org2 = entities.Organization().create()
with Session(self.browser) as session:
make_product(
session,
org=self.organization.name,
loc=self.loc.name,
name=prd_name,
description=gen_string('alphanumeric'),
)
self.assertIsNotNone(self.products.search(prd_name))
make_product(
session,
org=org2.name,
loc=self.loc.name,
name=prd_name,
description=gen_string('alphanumeric'),
force_context=True,
)
self.assertIsNotNone(self.products.search(prd_name))
def test_positive_create_1(self, prd_name):
"""@Test: Create Content Product minimal input parameters
@Feature: Content Product - Positive Create
@Assert: Product is created
"""
description = "test 123"
with Session(self.browser) as session:
make_product(session, org=self.org_name, loc=self.loc_name,
name=prd_name, description=description)
self.assertIsNotNone(self.products.search(prd_name))
def test_negative_create_1(self, prd_name):
"""@Test: Create Content Product with too long input parameters
@Feature: Content Product - Negative Create too long
@Assert: Product is not created
"""
locator = common_locators["common_haserror"]
description = "test_negative_create_1"
with Session(self.browser) as session:
make_product(session, org=self.org_name, loc=self.loc_name,
name=prd_name, description=description)
error = session.nav.wait_until_element(locator)
self.assertIsNotNone(error)
def test_remove_prd(self, prd_name):
"""@Test: Delete Content Product
@Feature: Content Product - Positive Delete
@Assert: Product is deleted
"""
description = "test 123"
with Session(self.browser) as session:
make_product(session, org=self.org_name, loc=self.loc_name,
name=prd_name, description=description)
self.assertIsNotNone(self.products.search(prd_name))
self.products.delete(prd_name, True)
self.assertIsNone(self.products.search(prd_name))
def test_positive_create_1(self, prd_name):
"""@Test: Create Content Product minimal input parameters
@Feature: Content Product - Positive Create
@Assert: Product is created
"""
description = "test 123"
with Session(self.browser) as session:
make_product(session,
org=self.org_name,
loc=self.loc_name,
name=prd_name,
description=description)
self.assertIsNotNone(self.products.search(prd_name))
def test_discover_repo_1(self):
"""
@Feature: Content Repos - Discover repo via http URL
@Test: Create Content Repos via repo discovery under existing
product
@Assert: Repos is discovered and created
"""
prd_name = generate_string("alpha", 8)
url = "http://omaciel.fedorapeople.org/"
discovered_urls = ["fakerepo01/"]
with Session(self.browser) as session:
make_product(session, self.org_name, self.loc_name, name=prd_name)
self.assertIsNotNone(self.products.search(prd_name))
self.repository.discover_repo(url, discovered_urls,
product=prd_name)
def test_create_repo_1(self, repo_name):
"""
@Feature: Content Repos - Positive Create
@Test: Create Content Repos with minimal input parameters
@Assert: Repos is created
"""
prd_name = generate_string("alpha", 8)
repo_url = "http://inecas.fedorapeople.org/fakerepos/zoo3/"
description = "test 123"
with Session(self.browser) as session:
make_product(session, self.org_name, self.loc_name, name=prd_name,
description=description)
self.assertIsNotNone(self.products.search(prd_name))
self.repository.create(repo_name, product=prd_name, url=repo_url)
self.assertIsNotNone(self.repository.search(repo_name))
def test_positive_update_1(self, prd_name):
"""@Test: Update Content Product with minimal input parameters
@Feature: Content Product - Positive Update
@Assert: Product is updated
"""
new_prd_name = gen_string("alpha", 8)
description = "test 123"
with Session(self.browser) as session:
make_product(session, org=self.org_name, loc=self.loc_name,
name=prd_name, description=description)
self.assertIsNotNone(self.products.search(prd_name))
self.products.update(prd_name, new_name=new_prd_name)
self.assertIsNotNone(self.products.search(new_prd_name))
def test_negative_create_2(self):
"""@Test: Create Content Product without input parameter
@Feature: Content Product - Negative Create zero length
@Assert: Product is not created
"""
locator = common_locators["common_invalid"]
prd_name = ""
description = "test_negative_create_2"
with Session(self.browser) as session:
make_product(session, org=self.org_name, loc=self.loc_name,
name=prd_name, description=description)
invalid = self.products.wait_until_element(locator)
self.assertIsNotNone(invalid)
def test_positive_create_basic(self, prd_name):
"""@Test: Create Content Product minimal input parameters
@Feature: Content Product - Positive Create
@Assert: Product is created
"""
with Session(self.browser) as session:
make_product(
session,
org=self.organization.name,
loc=self.loc.name,
name=prd_name,
description=gen_string('alphanumeric'),
)
self.assertIsNotNone(self.products.search(prd_name))
def test_negative_create_4(self, prd_name):
"""@Test: Create Content Product with same name input parameter
@Feature: Content Product - Negative Create with same name
@Assert: Product is not created
"""
locator = common_locators["common_haserror"]
description = "test_negative_create_4"
with Session(self.browser) as session:
make_product(session, org=self.org_name, loc=self.loc_name,
name=prd_name, description=description)
self.assertIsNotNone(self.products.search(prd_name))
self.products.create(prd_name, description)
error = self.products.wait_until_element(locator)
self.assertIsNotNone(error)
def test_negative_create_1(self, prd_name):
"""@Test: Create Content Product with too long input parameters
@Feature: Content Product - Negative Create too long
@Assert: Product is not created
"""
locator = common_locators["common_haserror"]
description = "test_negative_create_1"
with Session(self.browser) as session:
make_product(session,
org=self.org_name,
loc=self.loc_name,
name=prd_name,
description=description)
error = session.nav.wait_until_element(locator)
self.assertIsNotNone(error)
def test_remove_prd(self, prd_name):
"""@Test: Delete Content Product
@Feature: Content Product - Positive Delete
@Assert: Product is deleted
"""
description = "test 123"
with Session(self.browser) as session:
make_product(session,
org=self.org_name,
loc=self.loc_name,
name=prd_name,
description=description)
self.assertIsNotNone(self.products.search(prd_name))
self.products.delete(prd_name, True)
self.assertIsNone(self.products.search(prd_name))
def test_positive_create_2(self, prd_name):
"""@Test: Create Content Product with same name but in another org
@Feature: Content Product - Positive Create
@Assert: Product is created
"""
description = "test 123"
org2_name = generate_string("alpha", 8)
with Session(self.browser) as session:
make_product(session, org=self.org_name, loc=self.loc_name,
name=prd_name, description=description)
self.assertIsNotNone(self.products.search(prd_name))
make_product(session, org=org2_name, loc=self.loc_name,
name=prd_name, description=description)
self.assertIsNotNone(self.products.search(prd_name))
def test_negative_create_4(self, repo_name):
"""
@Feature: Content Repos - Negative Create with same name
@Test: Create Content Repos with long name input parameter
@Assert: Repos is not created
"""
locator = common_locators["common_haserror"]
prd_name = generate_string("alpha", 8)
repo_url = "http://inecas.fedorapeople.org/fakerepos/zoo3/"
description = "test 123"
with Session(self.browser) as session:
make_product(session, self.org_name, self.loc_name, name=prd_name,
description=description)
self.assertIsNotNone(self.products.search(prd_name))
self.repository.create(repo_name, product=prd_name, url=repo_url)
error = self.repository.wait_until_element(locator)
self.assertTrue(error)
def test_negative_create_with_blank_name(self, name):
"""@Test: Create Content Product without input parameter
@Feature: Content Product - Negative Create zero length
@Assert: Product is not created
"""
with Session(self.browser) as session:
make_product(
session,
org=self.organization.name,
loc=self.loc.name,
name=name,
description=gen_string('alphanumeric'),
)
self.assertIsNotNone(self.products.wait_until_element(
common_locators['common_invalid']))
def test_negative_update_1(self, prd_name):
"""@Test: Update Content Product with too long input parameters
@Feature: Content Product - Negative Update
@Assert: Product is not updated
"""
locator = common_locators["alert.error"]
new_prd_name = gen_string("alpha", 256)
description = "test_negative_update_0"
with Session(self.browser) as session:
make_product(session, org=self.org_name, loc=self.loc_name,
name=prd_name, description=description)
self.assertIsNotNone(self.products.search(prd_name))
self.products.update(prd_name, new_name=new_prd_name)
error = self.products.wait_until_element(locator)
self.assertIsNotNone(error)
def test_negative_create_too_long_name(self, prd_name):
"""@Test: Create Content Product with too long input parameters
@Feature: Content Product - Negative Create too long
@Assert: Product is not created
"""
with Session(self.browser) as session:
make_product(
session,
org=self.organization.name,
loc=self.loc.name,
name=prd_name,
description=gen_string('alphanumeric'),
)
self.assertIsNotNone(session.nav.wait_until_element(
common_locators['common_haserror']))
def test_negative_create_2(self):
"""@Test: Create Content Product without input parameter
@Feature: Content Product - Negative Create zero length
@Assert: Product is not created
"""
locator = common_locators["common_invalid"]
prd_name = ""
description = "test_negative_create_2"
with Session(self.browser) as session:
make_product(session,
org=self.org_name,
loc=self.loc_name,
name=prd_name,
description=description)
invalid = self.products.wait_until_element(locator)
self.assertIsNotNone(invalid)
def test_remove_prd(self, prd_name):
"""@Test: Delete Content Product
@Feature: Content Product - Positive Delete
@Assert: Product is deleted
"""
with Session(self.browser) as session:
make_product(
session,
org=self.organization.name,
loc=self.loc.name,
name=prd_name,
description=gen_string('alphanumeric'),
)
self.assertIsNotNone(self.products.search(prd_name))
self.products.delete(prd_name)
self.assertIsNone(self.products.search(prd_name))
def test_negative_create_with_invalid_name(self):
"""Create Content Product with invalid names
@id: 11efd16c-6471-4191-934f-79c7278c66e8
@Assert: Product is not created
"""
with Session(self.browser) as session:
for name in invalid_values_list(interface='ui'):
with self.subTest(name):
make_product(
session,
org=self.organization.name,
loc=self.loc.name,
name=name,
description=gen_string('alphanumeric'),
)
self.assertIsNotNone(self.products.wait_until_element(
common_locators['common_invalid']))
def test_positive_delete(self):
"""Delete Content Product
@Feature: Content Product - Positive Delete
@Assert: Product is deleted
"""
with Session(self.browser) as session:
for prd_name in generate_strings_list():
with self.subTest(prd_name):
make_product(
session,
org=self.organization.name,
loc=self.loc.name,
name=prd_name,
description=gen_string('alphanumeric'),
)
self.assertIsNotNone(self.products.search(prd_name))
self.products.delete(prd_name)
def test_positive_create_with_name(self):
"""Create Content Product providing different names and minimal
input parameters
@Feature: Content Product - Positive Create
@Assert: Product is created
"""
with Session(self.browser) as session:
for prd_name in generate_strings_list():
with self.subTest(prd_name):
make_product(
session,
org=self.organization.name,
loc=self.loc.name,
name=prd_name,
description=gen_string('alphanumeric'),
)
self.assertIsNotNone(self.products.search(prd_name))
def test_positive_create_with_name(self):
"""Create Content Product providing different names and minimal
input parameters
@Feature: Content Product - Positive Create
@Assert: Product is created
"""
with Session(self.browser) as session:
for prd_name in generate_strings_list():
with self.subTest(prd_name):
make_product(
session,
org=self.organization.name,
loc=self.loc.name,
name=prd_name,
description=gen_string('alphanumeric'),
)
self.assertIsNotNone(self.products.search(prd_name))
def test_negative_create_with_invalid_name(self):
"""Create Content Product with invalid names
@Feature: Content Product - Negative Create zero length
@Assert: Product is not created
"""
with Session(self.browser) as session:
for name in invalid_values_list(interface='ui'):
with self.subTest(name):
make_product(
session,
org=self.organization.name,
loc=self.loc.name,
name=name,
description=gen_string('alphanumeric'),
)
self.assertIsNotNone(self.products.wait_until_element(
common_locators['common_invalid']))
def test_positive_update_1(self, prd_name):
"""@Test: Update Content Product with minimal input parameters
@Feature: Content Product - Positive Update
@Assert: Product is updated
"""
new_prd_name = gen_string("alpha", 8)
description = "test 123"
with Session(self.browser) as session:
make_product(session,
org=self.org_name,
loc=self.loc_name,
name=prd_name,
description=description)
self.assertIsNotNone(self.products.search(prd_name))
self.products.update(prd_name, new_name=new_prd_name)
self.assertIsNotNone(self.products.search(new_prd_name))
def test_positive_delete(self):
"""Delete Content Product
@Feature: Content Product - Positive Delete
@Assert: Product is deleted
"""
with Session(self.browser) as session:
for prd_name in generate_strings_list():
with self.subTest(prd_name):
make_product(
session,
org=self.organization.name,
loc=self.loc.name,
name=prd_name,
description=gen_string('alphanumeric'),
)
self.assertIsNotNone(self.products.search(prd_name))
self.products.delete(prd_name)
def test_positive_create_in_different_orgs(self):
"""Create Content Product with same name but in another org
@Feature: Content Product - Positive Create
@Assert: Product is created successfully in both organizations.
"""
organization_2 = entities.Organization().create()
with Session(self.browser) as session:
for prd_name in generate_strings_list():
with self.subTest(prd_name):
for org in [self.organization.name, organization_2.name]:
make_product(
session,
org=org,
loc=self.loc.name,
name=prd_name,
description=gen_string('alphanumeric'),
)
self.assertIsNotNone(self.products.search(prd_name))
def test_positive_create_2(self, prd_name):
"""@Test: Create Content Product with same name but in another org
@Feature: Content Product - Positive Create
@Assert: Product is created successfully in both the orgs.
"""
description = "test 123"
org2_name = entities.Organization(
name=gen_string("alpha", 8)
).create_json()['name']
with Session(self.browser) as session:
make_product(session, org=self.org_name, loc=self.loc_name,
name=prd_name, description=description)
self.assertIsNotNone(self.products.search(prd_name))
make_product(session, org=org2_name, loc=self.loc_name,
name=prd_name, description=description,
force_context=True)
self.assertIsNotNone(self.products.search(prd_name))
def test_negative_update_with_too_long_name(self):
"""Update Content Product with too long input parameters
@id: c6938675-4a2a-4bec-9315-b1c951b628bb
@Assert: Product is not updated
"""
prd_name = gen_string('alpha')
with Session(self.browser) as session:
make_product(
session,
org=self.organization.name,
loc=self.loc.name,
name=prd_name,
description=gen_string('alphanumeric'),
)
self.assertIsNotNone(self.products.search(prd_name))
self.products.update(prd_name, new_name=gen_string('alpha', 256))
self.assertIsNotNone(self.products.wait_until_element(
common_locators['alert.error']))
def test_negative_update_with_too_long_name(self):
"""Update Content Product with too long input parameters
@Feature: Content Product - Negative Update
@Assert: Product is not updated
"""
prd_name = gen_string('alpha')
with Session(self.browser) as session:
make_product(
session,
org=self.organization.name,
loc=self.loc.name,
name=prd_name,
description=gen_string('alphanumeric'),
)
self.assertIsNotNone(self.products.search(prd_name))
self.products.update(prd_name, new_name=gen_string('alpha', 256))
self.assertIsNotNone(self.products.wait_until_element(
common_locators['alert.error']))
def test_positive_create_in_different_orgs(self):
"""Create Content Product with same name but in another org
@Feature: Content Product - Positive Create
@Assert: Product is created successfully in both organizations.
"""
organization_2 = entities.Organization().create()
with Session(self.browser) as session:
for prd_name in generate_strings_list():
with self.subTest(prd_name):
for org in [self.organization.name, organization_2.name]:
make_product(
session,
org=org,
loc=self.loc.name,
name=prd_name,
description=gen_string('alphanumeric'),
)
self.assertIsNotNone(self.products.search(prd_name))
def test_negative_create_4(self, prd_name):
"""@Test: Create Content Product with same name input parameter
@Feature: Content Product - Negative Create with same name
@Assert: Product is not created
"""
locator = common_locators["common_haserror"]
description = "test_negative_create_4"
with Session(self.browser) as session:
make_product(session,
org=self.org_name,
loc=self.loc_name,
name=prd_name,
description=description)
self.assertIsNotNone(self.products.search(prd_name))
self.products.create(prd_name, description)
error = self.products.wait_until_element(locator)
self.assertIsNotNone(error)
def test_positive_create_with_name(self):
"""Create Content Product providing different names and minimal
input parameters
:id: b73d9440-1f30-4fc5-ad7c-e1febe879cbc
:expectedresults: Product is created
:CaseImportance: Critical
"""
with Session(self) as session:
for prd_name in generate_strings_list():
with self.subTest(prd_name):
make_product(
session,
org=self.organization.name,
loc=self.loc.name,
name=prd_name,
description=gen_string('alphanumeric'),
)
self.assertIsNotNone(self.products.search(prd_name))
def test_positive_delete(self):
"""Delete Content Product
:id: cf80bafb-8581-483a-b5c1-3a162642c6c1
:expectedresults: Product is deleted
:CaseImportance: Critical
"""
with Session(self) as session:
for prd_name in generate_strings_list():
with self.subTest(prd_name):
make_product(
session,
org=self.organization.name,
loc=self.loc.name,
name=prd_name,
description=gen_string('alphanumeric'),
)
self.assertIsNotNone(self.products.search(prd_name))
self.products.delete(prd_name)
def test_negative_create_with_same_name(self):
"""Create Content Product with same name input parameter
@id: 90ceee6e-0ccc-4065-87ba-42d36484f032
@Assert: Product is not created
"""
prd_name = gen_string('alphanumeric')
description = gen_string('alphanumeric')
with Session(self.browser) as session:
make_product(
session,
org=self.organization.name,
loc=self.loc.name,
name=prd_name,
description=description,
)
self.assertIsNotNone(self.products.search(prd_name))
self.products.create(prd_name, description)
self.assertIsNotNone(self.products.wait_until_element(
common_locators['common_haserror']))
def test_negative_create_with_invalid_name(self):
"""Create Content Product with invalid names
:id: 11efd16c-6471-4191-934f-79c7278c66e8
:expectedresults: Product is not created
:CaseImportance: Critical
"""
with Session(self) as session:
for name in invalid_values_list(interface='ui'):
with self.subTest(name):
make_product(
session,
org=self.organization.name,
loc=self.loc.name,
name=name,
description=gen_string('alphanumeric'),
)
self.assertIsNotNone(self.products.wait_until_element(
common_locators['common_invalid']))
def test_negative_create_with_same_name(self):
"""Create Content Product with same name input parameter
@Feature: Content Product - Negative Create with same name
@Assert: Product is not created
"""
prd_name = gen_string('alphanumeric')
description = gen_string('alphanumeric')
with Session(self.browser) as session:
make_product(
session,
org=self.organization.name,
loc=self.loc.name,
name=prd_name,
description=description,
)
self.assertIsNotNone(self.products.search(prd_name))
self.products.create(prd_name, description)
self.assertIsNotNone(self.products.wait_until_element(
common_locators['common_haserror']))
def test_negative_update_1(self, prd_name):
"""@Test: Update Content Product with too long input parameters
@Feature: Content Product - Negative Update
@Assert: Product is not updated
"""
locator = common_locators["alert.error"]
new_prd_name = gen_string("alpha", 256)
description = "test_negative_update_0"
with Session(self.browser) as session:
make_product(session,
org=self.org_name,
loc=self.loc_name,
name=prd_name,
description=description)
self.assertIsNotNone(self.products.search(prd_name))
self.products.update(prd_name, new_name=new_prd_name)
error = self.products.wait_until_element(locator)
self.assertIsNotNone(error)
def test_positive_create_with_name(self):
"""Create Content Product providing different names and minimal
input parameters
:id: b73d9440-1f30-4fc5-ad7c-e1febe879cbc
:expectedresults: Product is created
:CaseImportance: Critical
"""
with Session(self.browser) as session:
for prd_name in generate_strings_list():
with self.subTest(prd_name):
make_product(
session,
org=self.organization.name,
loc=self.loc.name,
name=prd_name,
description=gen_string('alphanumeric'),
)
self.assertIsNotNone(self.products.search(prd_name))
def test_positive_delete(self):
"""Delete Content Product
:id: cf80bafb-8581-483a-b5c1-3a162642c6c1
:expectedresults: Product is deleted
:CaseImportance: Critical
"""
with Session(self.browser) as session:
for prd_name in generate_strings_list():
with self.subTest(prd_name):
make_product(
session,
org=self.organization.name,
loc=self.loc.name,
name=prd_name,
description=gen_string('alphanumeric'),
)
self.assertIsNotNone(self.products.search(prd_name))
self.products.delete(prd_name)
def test_positive_update_name(self):
"""Update Content Product name with minimal input parameters
@Feature: Content Product - Positive Update
@Assert: Product is updated
"""
prd_name = gen_string('alpha')
with Session(self.browser) as session:
make_product(
session,
org=self.organization.name,
loc=self.loc.name,
name=prd_name,
description=gen_string('alphanumeric'),
)
self.assertIsNotNone(self.products.search(prd_name))
for new_prd_name in generate_strings_list():
with self.subTest(new_prd_name):
self.products.update(prd_name, new_name=new_prd_name)
self.assertIsNotNone(self.products.search(new_prd_name))
prd_name = new_prd_name # for next iteration
def test_positive_update_to_original_name(self):
"""Rename Product back to original name.
@Feature: Content Product - Positive Update
@Assert: Product renamed to previous value.
"""
prd_name = gen_string('alphanumeric')
new_prd_name = gen_string('alphanumeric')
with Session(self.browser) as session:
make_product(
session,
org=self.organization.name,
loc=self.loc.name,
name=prd_name,
)
self.assertIsNotNone(self.products.search(prd_name))
self.products.update(prd_name, new_name=new_prd_name)
self.assertIsNotNone(self.products.search(new_prd_name))
# Rename Product to original and verify
self.products.update(new_prd_name, new_name=prd_name)
self.assertIsNotNone(self.products.search(prd_name))
def test_positive_update_to_original_name(self):
"""Rename Product back to original name.
@Feature: Content Product - Positive Update
@Assert: Product renamed to previous value.
"""
prd_name = gen_string('alphanumeric')
new_prd_name = gen_string('alphanumeric')
with Session(self.browser) as session:
make_product(
session,
org=self.organization.name,
loc=self.loc.name,
name=prd_name,
)
self.assertIsNotNone(self.products.search(prd_name))
self.products.update(prd_name, new_name=new_prd_name)
self.assertIsNotNone(self.products.search(new_prd_name))
# Rename Product to original and verify
self.products.update(new_prd_name, new_name=prd_name)
self.assertIsNotNone(self.products.search(prd_name))
def test_positive_update_name(self):
"""Update Content Product name with minimal input parameters
@Feature: Content Product - Positive Update
@Assert: Product is updated
"""
prd_name = gen_string('alpha')
with Session(self.browser) as session:
make_product(
session,
org=self.organization.name,
loc=self.loc.name,
name=prd_name,
description=gen_string('alphanumeric'),
)
self.assertIsNotNone(self.products.search(prd_name))
for new_prd_name in generate_strings_list():
with self.subTest(new_prd_name):
self.products.update(prd_name, new_name=new_prd_name)
self.assertIsNotNone(self.products.search(new_prd_name))
prd_name = new_prd_name # for next iteration
def test_positive_create_in_different_orgs(self):
"""Create Content Product with same name but in another org
:id: 469fc036-a48a-4c0a-9da9-33e73f903479
:expectedresults: Product is created successfully in both
organizations.
:CaseLevel: Integration
"""
organization_2 = entities.Organization().create()
with Session(self.browser) as session:
for prd_name in generate_strings_list():
with self.subTest(prd_name):
for org in [self.organization.name, organization_2.name]:
make_product(
session,
org=org,
loc=self.loc.name,
name=prd_name,
description=gen_string('alphanumeric'),
)
self.assertIsNotNone(self.products.search(prd_name))
def test_positive_update_to_original_name(self):
"""Rename Product back to original name.
:id: 6632effe-06ba-4690-b81d-4f5eae20b7b9
:expectedresults: Product renamed to previous value.
:CaseLevel: Integration
"""
prd_name = gen_string('alphanumeric')
new_prd_name = gen_string('alphanumeric')
with Session(self.browser) as session:
make_product(
session,
org=self.organization.name,
loc=self.loc.name,
name=prd_name,
)
self.assertIsNotNone(self.products.search(prd_name))
self.products.update(prd_name, new_name=new_prd_name)
self.assertIsNotNone(self.products.search(new_prd_name))
# Rename Product to original and verify
self.products.update(new_prd_name, new_name=prd_name)
self.assertIsNotNone(self.products.search(prd_name))
def test_positive_update_name(self):
"""Update Content Product name with minimal input parameters
:id: 2c0539b4-84e1-46c6-aaca-12fe3865da3d
:expectedresults: Product is updated
:CaseImportance: Critical
"""
prd_name = gen_string('alpha')
with Session(self.browser) as session:
make_product(
session,
org=self.organization.name,
loc=self.loc.name,
name=prd_name,
description=gen_string('alphanumeric'),
)
self.assertIsNotNone(self.products.search(prd_name))
for new_prd_name in generate_strings_list():
with self.subTest(new_prd_name):
self.products.update(prd_name, new_name=new_prd_name)
self.assertIsNotNone(self.products.search(new_prd_name))
prd_name = new_prd_name # for next iteration
def test_positive_smoke(self):
"""Check that basic content can be created
* Create a new user with admin permissions
* Using the new user from above:
* Create a new organization
* Create two new lifecycle environments
* Create a custom product
* Create a custom YUM repository
* Create a custom PUPPET repository
* Synchronize both custom repositories
* Create a new content view
* Associate both repositories to new content view
* Publish content view
* Promote content view to both lifecycles
* Create a new libvirt compute resource
* Create a new subnet
* Create a new domain
* Create a new hostgroup and associate previous entities to it
@Feature: Smoke Test
@Assert: All entities are created and associated.
"""
user_name = gen_string('alpha')
password = gen_string('alpha')
org_name = gen_string('alpha')
env_1_name = gen_string('alpha')
env_2_name = gen_string('alpha')
product_name = gen_string('alpha')
yum_repository_name = gen_string('alpha')
puppet_repository_name = gen_string('alpha')
cv_name = gen_string('alpha')
compute_resource_name = gen_string('alpha')
subnet_name = gen_string('alpha')
domain_name = gen_string('alpha')
domain = DOMAIN % domain_name
hostgroup_name = gen_string('alpha')
# Create new user with admin permissions
with Session(self.browser) as session:
make_user(
session,
username=user_name,
password1=password,
password2=password
)
self.assertIsNotNone(self.user.search(user_name))
self.assertTrue(self.user.user_admin_role_toggle(user_name))
# FIX ME: UI doesn't authenticate user created via UI auto: Issue #1152
# Once #1152 is fixed; need to pass user_name and password to Session
with Session(self.browser) as session:
# Create New organization
make_org(session, org_name=org_name)
self.assertIsNotNone(self.org.search(org_name))
# Create New Lifecycle environment1
make_lifecycle_environment(session, org=org_name, name=env_1_name)
self.assertIsNotNone(self.lifecycleenvironment.search(env_1_name))
# Create New Lifecycle environment2
make_lifecycle_environment(
session,
org=org_name,
name=env_2_name,
prior=env_1_name
)
self.assertIsNotNone(self.lifecycleenvironment.search(env_2_name))
# Create custom product
make_product(session, org=org_name, name=product_name)
product = self.products.search(product_name)
self.assertIsNotNone(product)
# Create a YUM repository
product.click()
make_repository(
session,
name=yum_repository_name,
url=GOOGLE_CHROME_REPO
)
self.assertIsNotNone(self.repository.search(yum_repository_name))
# Create a puppet Repository
self.products.search(product_name).click()
make_repository(
session,
name=puppet_repository_name,
url=FAKE_0_PUPPET_REPO,
repo_type=REPO_TYPE['puppet']
)
self.assertIsNotNone(self.repository.search(
puppet_repository_name
))
# Sync YUM and puppet repository
self.navigator.go_to_sync_status()
self.assertIsNotNone(self.sync.sync_custom_repos(
product_name,
[yum_repository_name, puppet_repository_name]
))
# Create new content-view
make_contentview(session, org=org_name, name=cv_name)
self.assertIsNotNone(self.content_views.search(cv_name))
# Add YUM repository to content-view
self.content_views.add_remove_repos(cv_name, [yum_repository_name])
if not bz_bug_is_open(1191422):
self.assertIsNotNone(self.content_views.wait_until_element(
common_locators['alert.success']
))
# Add puppet-module to content-view
if not bz_bug_is_open(1297308):
self.content_views.add_puppet_module(
cv_name, 'httpd', filter_term='Latest'
)
# Publish content-view
self.content_views.publish(cv_name)
if not bz_bug_is_open(1191422):
self.assertIsNotNone(self.content_views.wait_until_element(
common_locators['alert.success']
))
# Promote content-view to life-cycle environment 1
self.content_views.promote(
cv_name, version='Version 1', env=env_1_name)
if not bz_bug_is_open(1191422):
self.assertIsNotNone(self.content_views.wait_until_element(
common_locators['alert.success']
))
# Promote content-view to life-cycle environment 2
self.content_views.promote(
cv_name, version='Version 1', env=env_2_name)
if not bz_bug_is_open(1191422):
self.assertIsNotNone(self.content_views.wait_until_element(
common_locators['alert.success']
))
# Create a new libvirt compute resource
url = (
LIBVIRT_RESOURCE_URL % settings.server.hostname
)
make_resource(
session,
org=org_name,
name=compute_resource_name,
provider_type=FOREMAN_PROVIDERS['libvirt'],
parameter_list=[['URL', url, 'field']],
)
self.assertIsNotNone(
self.compute_resource.search(compute_resource_name))
# Create a subnet
make_subnet(
session,
org=org_name,
subnet_name=subnet_name,
subnet_network=gen_ipaddr(ip3=True),
subnet_mask='255.255.255.0'
)
self.assertIsNotNone(self.subnet.search(subnet_name))
# Create a Domain
make_domain(
session,
org=org_name,
name=domain,
description=domain
)
self.assertIsNotNone(self.domain.search(domain))
# Create a HostGroup
make_hostgroup(session, name=hostgroup_name)
self.assertIsNotNone(self.hostgroup.search(hostgroup_name))
def test_positive_end_to_end(self):
"""Perform end to end smoke tests using RH and custom repos.
1. Create a new user with admin permissions
2. Using the new user from above
1. Create a new organization
2. Clone and upload manifest
3. Create a new lifecycle environment
4. Create a custom product
5. Create a custom YUM repository
6. Create a custom PUPPET repository
7. Enable a Red Hat repository
8. Synchronize the three repositories
9. Create a new content view
10. Associate the YUM and Red Hat repositories to new content view
11. Add a PUPPET module to new content view
12. Publish content view
13. Promote content view to the lifecycle environment
14. Create a new activation key
15. Add the products to the activation key
16. Create a new libvirt compute resource
17. Create a new subnet
18. Create a new domain
19. Create a new hostgroup and associate previous entities to it
20. Provision a client
@id: 6b7c6187-3cc2-4bd3-89f2-fa7a5f570986
@Assert: All tests should succeed and Content should be successfully
fetched by client.
"""
activation_key_name = gen_string('alpha')
compute_resource_name = gen_string('alpha')
cv_name = gen_string('alpha')
domain_name = DOMAIN % gen_string('alpha')
hostgroup_name = gen_string('alpha')
lce_name = gen_string('alpha')
org_name = gen_string('alpha')
password = gen_string('alpha')
product_name = gen_string('alpha')
puppet_repository_name = gen_string('alpha')
if self.fake_manifest_is_set:
repos = self.sync.create_repos_tree(RHVA_REPO_TREE)
subnet_name = gen_string('alpha')
username = gen_string('alpha')
yum_repository_name = gen_string('alpha')
# step 1: Create a new user with admin permissions
with Session(self.browser) as session:
make_user(
session,
admin=True,
password1=password,
password2=password,
username=username,
)
self.assertIsNotNone(self.user.search(username))
self.assertTrue(self.user.user_admin_role_toggle(username))
with Session(self.browser, username, password) as session:
# step 2.1: Create a new organization
make_org(session, org_name=org_name)
self.assertIsNotNone(self.org.search(org_name))
# step 2.2: Clone and upload manifest
if self.fake_manifest_is_set:
session.nav.go_to_select_org(org_name)
session.nav.go_to_red_hat_subscriptions()
with manifests.clone() as manifest:
self.subscriptions.upload(manifest)
self.assertTrue(
session.nav.wait_until_element(
common_locators['alert.success']))
# step 2.3: Create a new lifecycle environment
make_lifecycle_environment(session, org=org_name, name=lce_name)
self.assertIsNotNone(self.lifecycleenvironment.search(lce_name))
# step 2.4: Create a custom product
make_product(session, org=org_name, name=product_name)
self.assertIsNotNone(self.products.search(product_name))
# step 2.5: Create custom YUM repository
self.products.search(product_name).click()
make_repository(session,
name=yum_repository_name,
url=CUSTOM_RPM_REPO)
self.assertIsNotNone(self.repository.search(yum_repository_name))
# step 2.6: Create custom PUPPET repository
self.products.search(product_name).click()
make_repository(session,
name=puppet_repository_name,
url=FAKE_0_PUPPET_REPO,
repo_type=REPO_TYPE['puppet'])
self.assertIsNotNone(
self.repository.search(puppet_repository_name))
# step 2.7: Enable a Red Hat repository
if self.fake_manifest_is_set:
session.nav.go_to_red_hat_repositories()
self.sync.enable_rh_repos(repos, REPO_TAB['rpms'])
# step 2.8: Synchronize the three repositories
self.navigator.go_to_sync_status()
self.assertIsNotNone(
self.sync.sync_custom_repos(
product_name,
[yum_repository_name, puppet_repository_name]))
if self.fake_manifest_is_set:
self.assertTrue(self.sync.sync_rh_repos(repos))
# step 2.9: Create content view
make_contentview(session, org=org_name, name=cv_name)
self.assertIsNotNone(self.content_views.search(cv_name))
self.content_views.add_remove_repos(cv_name, [yum_repository_name])
self.assertIsNotNone(
self.content_views.wait_until_element(
common_locators['alert.success']))
# step 2.10: Associate the YUM and Red Hat repositories to new
# content view
repositories = [yum_repository_name]
if self.fake_manifest_is_set:
repositories.append(REPOS['rhva65']['name'])
repositories.append(REPOS['rhva6']['name'])
self.content_views.add_remove_repos(cv_name, repositories)
self.assertIsNotNone(
self.content_views.wait_until_element(
common_locators['alert.success']))
# step 2.11: Add a PUPPET module to new content view
self.content_views.add_puppet_module(cv_name,
'httpd',
filter_term='Latest')
# step 2.12: Publish content view
self.content_views.publish(cv_name)
self.assertIsNotNone(
self.content_views.wait_until_element(
common_locators['alert.success_sub_form']))
# step 2.13: Promote content view to the lifecycle environment
self.content_views.promote(cv_name,
version='Version 1',
env=lce_name)
self.assertIsNotNone(
self.content_views.wait_until_element(
common_locators['alert.success_sub_form']))
# step 2.14: Create a new activation key
make_activationkey(session,
org=org_name,
name=activation_key_name,
env=lce_name,
content_view=cv_name)
self.assertIsNotNone(
self.activationkey.wait_until_element(
common_locators['alert.success']))
# step 2.15: Add the products to the activation key
self.activationkey.associate_product(activation_key_name,
[DEFAULT_SUBSCRIPTION_NAME])
# step 2.15.1: Enable product content
if self.fake_manifest_is_set:
self.activationkey.enable_repos(activation_key_name,
[REPOSET['rhva6']])
# step 2.16: Create a new libvirt compute resource
make_resource(
session,
org=org_name,
name=compute_resource_name,
provider_type=FOREMAN_PROVIDERS['libvirt'],
parameter_list=[[
'URL',
(LIBVIRT_RESOURCE_URL %
settings.compute_resources.libvirt_hostname), 'field'
]],
)
self.assertIsNotNone(
self.compute_resource.search(compute_resource_name))
# step 2.17: Create a new subnet
make_subnet(session,
org=org_name,
subnet_name=subnet_name,
subnet_network=gen_ipaddr(ip3=True),
subnet_mask='255.255.255.0')
self.assertIsNotNone(self.subnet.search(subnet_name))
# step 2.18: Create a new domain
make_domain(session,
org=org_name,
name=domain_name,
description=domain_name)
self.assertIsNotNone(self.domain.search(domain_name))
# step 2.19: Create a new hostgroup and associate previous entities
# to it
make_hostgroup(session, name=hostgroup_name)
self.assertIsNotNone(self.hostgroup.search(hostgroup_name))
# step 2.20: Provision a client
self.client_provisioning(activation_key_name, org_name)
def test_positive_puppet_install(self):
"""Perform puppet end to end smoke tests using RH repos.
@id: 30b0f872-d035-431a-988f-2b3fde620c78
@Assert: Client should get configured by puppet-module.
"""
activation_key_name = gen_string('alpha')
cv_name = gen_string('alpha')
env_name = gen_string('alpha')
org_name = gen_string('alpha')
product_name = gen_string('alpha')
puppet_module = 'motd'
puppet_repository_name = gen_string('alpha')
repos = self.sync.create_repos_tree(SAT6_TOOLS_TREE)
rhel_prd = DEFAULT_SUBSCRIPTION_NAME
rhel6_repo = settings.rhel6_repo
with Session(self.browser) as session:
# Create New organization
make_org(session, org_name=org_name)
self.assertIsNotNone(self.org.search(org_name))
# Create New Lifecycle environment
make_lifecycle_environment(session, org=org_name, name=env_name)
self.assertIsNotNone(self.lifecycleenvironment.search(env_name))
session.nav.go_to_red_hat_subscriptions()
# Upload manifest from webui
with manifests.clone() as manifest:
self.subscriptions.upload(manifest)
self.assertTrue(
session.nav.wait_until_element(
common_locators['alert.success']))
session.nav.go_to_red_hat_repositories()
# List of dictionary passed to enable the redhat repos
# It selects Product->Reposet-> Repo
self.sync.enable_rh_repos(repos, REPO_TAB['rpms'])
session.nav.go_to_sync_status()
# Sync the repos
# syn.sync_rh_repos returns boolean values and not objects
self.assertTrue(
self.sync.sync_noversion_rh_repos(PRDS['rhel'],
[REPOS['rhst6']['name']]))
# Create custom product
make_product(session, org=org_name, name=product_name)
product = self.products.search(product_name)
self.assertIsNotNone(product)
# Create a puppet Repository
product.click()
make_repository(session,
name=puppet_repository_name,
url=FAKE_6_PUPPET_REPO,
repo_type=REPO_TYPE['puppet'])
self.assertIsNotNone(
self.repository.search(puppet_repository_name))
# Sync the repos
# syn.sync_rh_repos returns boolean values and not objects
session.nav.go_to_sync_status()
self.assertIsNotNone(
self.sync.sync_custom_repos(product_name,
[puppet_repository_name]))
# Create new content-view
make_contentview(session, org=org_name, name=cv_name)
self.assertIsNotNone(self.content_views.search(cv_name))
# Add YUM repository to content-view
self.content_views.add_remove_repos(
cv_name,
[REPOS['rhst6']['name']],
)
if not bz_bug_is_open(1191422):
self.assertIsNotNone(
self.content_views.wait_until_element(
common_locators['alert.success']))
# Add puppet-module to content-view
self.content_views.add_puppet_module(cv_name,
puppet_module,
filter_term='Latest')
# Publish content-view
self.content_views.publish(cv_name)
if not bz_bug_is_open(1191422):
self.assertIsNotNone(
self.content_views.wait_until_element(
common_locators['alert.success_sub_form']))
# Promote content-view to life-cycle environment.
self.content_views.promote(cv_name,
version='Version 1',
env=env_name)
if not bz_bug_is_open(1191422):
self.assertIsNotNone(
self.content_views.wait_until_element(
common_locators['alert.success_sub_form']))
# Create Activation-Key
make_activationkey(session,
org=org_name,
name=activation_key_name,
env=env_name,
content_view=cv_name)
self.activationkey.associate_product(activation_key_name,
[product_name, rhel_prd])
self.activationkey.enable_repos(activation_key_name,
[REPOSET['rhst6']])
if not bz_bug_is_open(1191541):
self.assertIsNotNone(
self.activationkey.wait_until_element(
common_locators['alert.success']))
# Create VM
with VirtualMachine(distro=DISTRO_RHEL6) as vm:
vm.install_katello_ca()
vm.register_contenthost(org_name, activation_key_name)
vm.configure_puppet(rhel6_repo)
host = vm.hostname
set_context(session, org=ANY_CONTEXT['org'])
session.nav.go_to_hosts()
self.hosts.update_host_bulkactions(
[host],
action='Assign Organization',
parameters_list=[{
'organization': org_name
}],
)
self.hosts.update(
name=host,
parameters_list=[
['Host', 'Lifecycle Environment', env_name],
['Host', 'Content View', cv_name],
['Host', 'Reset Puppet Environment', True],
],
puppet_classes=[puppet_module])
vm.run(u'puppet agent -t')
result = vm.run(u'cat /etc/motd | grep FQDN')
self.assertEqual(result.return_code, 0)
def test_smoke(self):
"""@Test: Check that basic content can be created
* Create a new user with admin permissions
* Using the new user from above:
* Create a new organization
* Create two new lifecycle environments
* Create a custom product
* Create a custom YUM repository
* Create a custom PUPPET repository
* Synchronize both custom repositories
* Create a new content view
* Associate both repositories to new content view
* Publish content view
* Promote content view to both lifecycles
* Create a new libvirt compute resource
* Create a new subnet
* Create a new domain
* Create a new hostgroup and associate previous entities to it
@Feature: Smoke Test
@Assert: All entities are created and associated.
"""
user_name = gen_string("alpha", 6)
password = gen_string("alpha", 6)
org_name = gen_string("alpha", 6)
env_1_name = gen_string("alpha", 6)
env_2_name = gen_string("alpha", 6)
product_name = gen_string("alpha", 6)
yum_repository_name = gen_string("alpha", 6)
puppet_repository_name = gen_string("alpha", 6)
cv_name = gen_string("alpha", 6)
puppet_module = "httpd"
module_ver = 'Latest'
compute_resource_name = gen_string("alpha", 6)
libvirt_url = "qemu+tcp://%s:16509/system"
provider_type = FOREMAN_PROVIDERS['libvirt']
url = (libvirt_url % conf.properties['main.server.hostname'])
subnet_name = gen_string("alpha", 6)
domain_name = gen_string("alpha", 6)
domain = description = DOMAIN % domain_name
hostgroup_name = gen_string("alpha", 6)
# Create new user with admin permissions
with Session(self.browser) as session:
make_user(session,
username=user_name,
password1=password,
password2=password)
self.assertIsNotNone(self.user.search(user_name, "login"))
is_admin_role_selected = self.user.admin_role_to_user(user_name)
self.assertTrue(is_admin_role_selected)
# FIX ME: UI doesn't authenticate user created via UI auto: Issue #1152
# Once #1152 is fixed; need to pass user_name and password to Session
with Session(self.browser) as session:
# Create New organization
make_org(session, org_name=org_name)
self.assertIsNotNone(self.org.search(org_name))
# Create New Lifecycle environment1
make_lifecycle_environment(session, org=org_name, name=env_1_name)
strategy, value = locators["content_env.select_name"]
self.assertIsNotNone(
self.contentenv.wait_until_element(
(strategy, value % env_1_name)))
# Create New Lifecycle environment2
make_lifecycle_environment(session,
org=org_name,
name=env_2_name,
prior=env_1_name)
self.assertIsNotNone(
self.contentenv.wait_until_element(
(strategy, value % env_2_name)))
# Create custom product
make_product(session, org=org_name, name=product_name)
self.assertIsNotNone(self.products.search(product_name))
# Create a YUM repository
make_repository(session,
org=org_name,
name=yum_repository_name,
product=product_name,
url=GOOGLE_CHROME_REPO)
self.assertIsNotNone(self.repository.search(yum_repository_name))
# Create a puppet Repository
make_repository(session,
org=org_name,
name=puppet_repository_name,
product=product_name,
url=FAKE_0_PUPPET_REPO,
repo_type=REPO_TYPE['puppet'])
self.assertIsNotNone(
self.repository.search(puppet_repository_name))
# Sync YUM and puppet repository
self.navigator.go_to_sync_status()
sync = self.sync.sync_custom_repos(
product_name, [yum_repository_name, puppet_repository_name])
self.assertIsNotNone(sync)
# Create new content-view
make_contentview(session, org=org_name, name=cv_name)
self.assertIsNotNone(self.content_views.search(cv_name))
# Add YUM repository to content-view
self.content_views.add_remove_repos(cv_name, [yum_repository_name])
if not bz_bug_is_open(1191422):
self.assertIsNotNone(
self.content_views.wait_until_element(
common_locators["alert.success"]))
# Add puppet-module to content-view
self.content_views.add_puppet_module(cv_name,
puppet_module,
filter_term=module_ver)
# Publish content-view
self.content_views.publish(cv_name)
if not bz_bug_is_open(1191422):
self.assertIsNotNone(
self.content_views.wait_until_element(
common_locators["alert.success"]))
# Promote content-view to life-cycle environment 1
self.content_views.promote(cv_name,
version="Version 1",
env=env_1_name)
if not bz_bug_is_open(1191422):
self.assertIsNotNone(
self.content_views.wait_until_element(
common_locators["alert.success"]))
# Promote content-view to life-cycle environment 2
self.content_views.promote(cv_name,
version="Version 1",
env=env_2_name)
if not bz_bug_is_open(1191422):
self.assertIsNotNone(
self.content_views.wait_until_element(
common_locators["alert.success"]))
# Create a new libvirt compute resource
make_resource(session,
org=org_name,
name=compute_resource_name,
provider_type=provider_type,
url=url)
self.assertIsNotNone(
self.compute_resource.search(compute_resource_name))
# Create a subnet
make_subnet(session,
org=org_name,
subnet_name=subnet_name,
subnet_network=gen_ipaddr(ip3=True),
subnet_mask="255.255.255.0")
self.assertIsNotNone(self.subnet.search_subnet(subnet_name))
# Create a Domain
make_domain(session,
org=org_name,
name=domain,
description=description)
self.assertIsNotNone(self.domain.search(description))
# Create a HostGroup
make_hostgroup(session, name=hostgroup_name)
self.assertIsNotNone(self.hostgroup.search(hostgroup_name))
