class Sync(UITestCase):
"""Implements Custom Sync tests in UI"""
@classmethod
def setUpClass(cls): # noqa
org_attrs = entities.Organization().create()
cls.org_name = org_attrs['name']
cls.org_id = org_attrs['id']
super(Sync, cls).setUpClass()
@run_only_on('sat')
@data(*generate_strings_list())
def test_sync_custom_repos(self, repository_name):
"""@Test: Create Content Custom Sync with minimal input parameters
@Feature: Content Custom Sync - Positive Create
@Assert: Whether Sync is successful
"""
# Creates new product
product_attrs = entities.Product(organization=self.org_id).create()
# Creates new repository
entities.Repository(name=repository_name,
url=FAKE_1_YUM_REPO,
product=product_attrs['id']).create()
with Session(self.browser) as session:
session.nav.go_to_select_org(Sync.org_name)
session.nav.go_to_sync_status()
sync = self.sync.sync_custom_repos(product_attrs['name'],
[repository_name])
# syn.sync_custom_repos returns boolean values and not objects
self.assertTrue(sync)
def test_sync_rh_repos(self):
"""@Test: Create Content RedHat Sync with two repos.
@Feature: Content RedHat Sync - Positive Create
@Assert: Whether Syncing RedHat Repos is successful
"""
repos = self.sync.create_repos_tree(RHCT)
manifest_path = manifests.clone()
# upload_file function should take care of uploading to sauce labs.
upload_file(manifest_path, remote_file=manifest_path)
with Session(self.browser) as session:
session.nav.go_to_select_org(self.org_name)
session.nav.go_to_red_hat_subscriptions()
self.subscriptions.upload(manifest_path)
session.nav.go_to_red_hat_repositories()
self.sync.enable_rh_repos(repos)
session.nav.go_to_sync_status()
sync = self.sync.sync_rh_repos(repos)
# syn.sync_rh_repos returns boolean values and not objects
self.assertTrue(sync)
class PuppetClasses(UITestCase):
"""Implements puppet classes tests in UI."""
@data(
{
'name': gen_string('alpha', 10),
'new_name': gen_string('alpha', 10)
}, {
'name': gen_string('numeric', 10),
'new_name': gen_string('numeric', 10)
}, {
'name': gen_string('alphanumeric', 10),
'new_name': gen_string('alphanumeric', 10)
}, {
'name': gen_string('utf8', 10),
'new_name': gen_string('utf8', 10)
}, {
'name': gen_string('latin1', 20),
'new_name': gen_string('latin1', 10)
})
def test_update_positive_1(self, testdata):
"""@Test: Create new puppet-class
@Feature: Puppet-Classes - Positive Update
@Assert: Puppet-Classes is updated.
"""
name = testdata['name']
new_name = testdata['new_name']
with Session(self.browser) as session:
make_puppetclasses(session, name=name)
search = self.puppetclasses.search(name)
self.assertIsNotNone(search)
self.puppetclasses.update(name, new_name)
@skip_if_bug_open('bugzilla', 1126473)
@data(*generate_strings_list(len1=8))
def test_delete_positive_1(self, name):
"""@Test: Create new puppet-class
@Feature: Puppet-Classes - Positive delete
@Assert: Puppet-Class is deleted
@BZ: 1126473
"""
with Session(self.browser) as session:
make_puppetclasses(session, name=name)
search = self.puppetclasses.search(name)
self.assertIsNotNone(search)
self.puppetclasses.delete(name, True)
self.assertIsNotNone(
session.nav.wait_until_element(
common_locators["notif.success"]))
self.assertIsNone(self.puppetclasses.search(name))
class Sync(BaseUI):
"""
Implements Custom Sync tests in UI
"""
org_name = None
def setUp(self):
super(Sync, self).setUp()
# Make sure to use the Class' org_name instance
if Sync.org_name is None:
Sync.org_name = generate_string("alpha", 10)
with Session(self.browser) as session:
make_org(session, org_name=Sync.org_name)
@attr('ui', 'sync', 'implemented')
@data(*generate_strings_list())
def test_sync_repos(self, repo_name):
"""
@Feature: Content Custom Sync - Positive Create
@Test: Create Content Custom Sync with minimal input parameters
@Assert: Whether Sync is successful
"""
prd_name = generate_string("alpha", 6)
repo_url = "http://inecas.fedorapeople.org/fakerepos/zoo3/"
description = "test 123"
self.login.login(self.katello_user, self.katello_passwd)
self.navigator.go_to_select_org(self.org_name)
self.navigator.go_to_products()
self.products.create(prd_name, 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.navigator.go_to_sync_status()
sync = self.sync.sync_custom_repos(prd_name, [repo_name])
self.assertIsNotNone(sync)
@unittest.skip("Test needs to create manifests using stageportal stuff")
def test_sync_rhrepos(self):
"""
@Feature: Content RedHat Sync - Positive Create
@Test: Create Content RedHat Sync with two repos.
@Assert: Whether Syncing RedHat Repos is successful
"""
repos = self.sync.create_repos_tree(RHCT)
self.login.login(self.katello_user, self.katello_passwd)
# TODO: Create manifests and import using stageportal stuff.
self.navigator.go_to_red_hat_repositories()
self.sync.enable_rh_repos(repos)
self.navigator.go_to_sync_status()
sync = self.sync.sync_rh_repos(repos)
self.assertIsNotNone(sync)
def test_return_type(self):
"""Tests if generate string list returns a unicode string"""
for string in generate_strings_list():
self.assertIsInstance(string, unicode)
def test_end_to_end(self):
"""@Test: Perform end to end smoke tests using RH repos.
1. Create new organization and environment
2. Upload manifest
3. Sync a RedHat repository
4. Create content-view
5. Add repository to contet-view
6. Promote/publish content-view
7. Create an activation-key
8. Add product to activation-key
9. Create new virtualmachine
10. Pull rpm from Foreman server and install on client
11. Register client with foreman server using activation-key
12. Install rpm on client
@Feature: Smoke test
@Assert: All tests should succeed and Content should be successfully
fetched by client
"""
# Product, RepoSet and repository variables
rhel_product_name = "Red Hat Enterprise Linux Server"
rhel_repo_set = "Red Hat Enterprise Virtualization Agents " "for RHEL 6 Server (RPMs)"
rhel_repo_name = "Red Hat Enterprise Virtualization Agents " "for RHEL 6 Server " "RPMs x86_64 6Server"
org_name = random.choice(generate_strings_list())
# Create new org and environment
new_org = make_org({u"name": org_name})
new_env = make_lifecycle_environment({u"organization-id": new_org["id"], u"name": gen_alphanumeric()})
# Clone manifest and upload it
manifest = manifests.clone()
ssh.upload_file(manifest, remote_file=manifest)
result = Subscription.upload({u"file": manifest, u"organization-id": new_org["id"]})
self.assertEqual(result.return_code, 0)
# Enable repo from Repository Set
result = RepositorySet.enable(
{
u"name": rhel_repo_set,
u"organization-id": new_org["id"],
u"product": rhel_product_name,
u"releasever": "6Server",
u"basearch": "x86_64",
}
)
self.assertEqual(result.return_code, 0)
# Fetch repository info
result = Repository.info(
{u"name": rhel_repo_name, u"product": rhel_product_name, u"organization-id": new_org["id"]}
)
rhel_repo = result.stdout
# Synchronize the repository
result = Repository.synchronize(
{u"name": rhel_repo_name, u"organization-id": new_org["id"], u"product": rhel_product_name}
)
self.assertEqual(result.return_code, 0)
# Create CV and associate repo to it
new_cv = make_content_view({u"organization-id": new_org["id"]})
result = ContentView.add_repository(
{u"id": new_cv["id"], u"repository-id": rhel_repo["id"], u"organization-id": new_org["id"]}
)
self.assertEqual(result.return_code, 0)
# Publish a version1 of CV
result = ContentView.publish({u"id": new_cv["id"]})
self.assertEqual(result.return_code, 0)
# Get the CV info
result = ContentView.info({u"id": new_cv["id"]})
self.assertEqual(result.return_code, 0)
# Store the version1 id
version1_id = result.stdout["versions"][0]["id"]
# Promotion of version1 to next env
result = ContentView.version_promote({u"id": version1_id, u"to-lifecycle-environment-id": new_env["id"]})
self.assertEqual(result.return_code, 0)
# Create activation key
activation_key = make_activation_key(
{
u"name": gen_alphanumeric(),
u"lifecycle-environment-id": new_env["id"],
u"organization-id": new_org["id"],
u"content-view": new_cv["name"],
}
)
# List the subscriptions in given org
result = Subscription.list({u"organization-id": new_org["id"]}, per_page=False)
self.assertEqual(result.return_code, 0)
# Get the subscription ID from subscriptions list
for subscription in result.stdout:
if subscription["name"] == DEFAULT_SUBSCRIPTION_NAME:
subscription_id = subscription["id"]
subscription_quantity = int(subscription["quantity"])
self.assertGreater(int(subscription_quantity), 0)
# Add the subscriptions to activation-key
result = ActivationKey.add_subscription(
{u"id": activation_key["id"], u"subscription-id": subscription_id, u"quantity": 1}
)
self.assertEqual(result.return_code, 0)
# Enable product content
ActivationKey.content_override(
{
u"id": activation_key["id"],
u"organization-id": new_org["id"],
u"content-label": "rhel-6-server-rhev-agent-rpms",
u"value": "1",
}
)
# Create VM
package_name = "python-kitchen"
server_name = conf.properties["main.server.hostname"]
with VirtualMachine(distro="rhel66") as vm:
# Download and Install rpm
result = vm.run("wget -nd -r -l1 --no-parent -A '*.noarch.rpm' http://{0}/pub/".format(server_name))
self.assertEqual(result.return_code, 0)
result = vm.run("rpm -i katello-ca-consumer*.noarch.rpm")
self.assertEqual(result.return_code, 0)
# Register client with foreman server using activation-key
result = vm.run(
u"subscription-manager register --activationkey {0} "
"--org {1} --force".format(activation_key["name"], new_org["label"])
)
self.assertEqual(result.return_code, 0)
# Install contents from sat6 server
result = vm.run("yum install -y {0}".format(package_name))
self.assertEqual(result.return_code, 0)
# Verify if package is installed by query it
result = vm.run("rpm -q {0}".format(package_name))
self.assertEqual(result.return_code, 0)
class HardwareModelTestCase(UITestCase):
"""Implements Hardware Model tests in UI."""
@data(*generate_strings_list(len1=8))
def test_create_positive_1(self, name):
"""@test: Create new Hardware-Model
@feature: Hardware-Model - Positive Create
@assert: Hardware-Model is created
"""
with Session(self.browser) as session:
make_hw_model(session, name=name)
search = self.hardwaremodel.search(name)
self.assertIsNotNone(search)
@data(gen_string('alphanumeric', 255), gen_string('alpha', 255),
gen_string('numeric', 255), gen_string('latin1', 255),
gen_string('utf8', 255))
def test_create_positive_2(self, name):
"""@test: Create new Hardware-Model with 255 chars
@feature: Hardware-Model - Positive Create
@assert: Hardware-Model is created with 255 chars
"""
with Session(self.browser) as session:
make_hw_model(session, name=name)
search = self.hardwaremodel.search(name)
self.assertIsNotNone(search)
@data(*generate_strings_list(len1=256))
def test_create_negative_1(self, name):
"""@test: Create new Hardware-Model with 256 chars
@feature: Hardware-Model - Negative Create
@assert: Hardware-Model is not created
"""
with Session(self.browser) as session:
make_hw_model(session, name=name)
error = session.nav.wait_until_element(
common_locators["name_haserror"])
self.assertIsNotNone(error)
def test_create_negative_2(self):
"""@test: Create new Hardware-Model with blank name
@feature: Hardware-Model - Negative Create
@assert: Hardware-Model is not created
"""
name = ""
with Session(self.browser) as session:
make_hw_model(session, name=name)
error = session.nav.wait_until_element(
common_locators["name_haserror"])
self.assertIsNotNone(error)
def test_create_negative_3(self):
"""@test: Create new Hardware-Model with whitespace name
@feature: Hardware-Model - Negative Create
@assert: Hardware-Model is not created
"""
name = " "
with Session(self.browser) as session:
make_hw_model(session, name=name)
error = session.nav.wait_until_element(
common_locators["name_haserror"])
self.assertIsNotNone(error)
@data({
'name': gen_string('alpha'),
'new_name': gen_string('alpha')
}, {
'name': gen_string('numeric'),
'new_name': gen_string('numeric')
}, {
'name': gen_string('alphanumeric'),
'new_name': gen_string('alphanumeric')
}, {
'name': gen_string('utf8'),
'new_name': gen_string('utf8')
}, {
'name': gen_string('latin1'),
'new_name': gen_string('latin1')
})
def test_update_positive_1(self, testdata):
"""@test: Updates the Hardware-Model
@feature: Hardware-Model - Positive Update
@assert: Hardware-Model is updated.
"""
name = testdata['name']
new_name = testdata['new_name']
with Session(self.browser) as session:
make_hw_model(session, name=name)
search = self.hardwaremodel.search(name)
self.assertIsNotNone(search)
self.hardwaremodel.update(name, new_name)
search = self.hardwaremodel.search(new_name)
self.assertIsNotNone(search)
@data(*generate_strings_list(len1=8))
def test_delete_positive_1(self, name):
"""@test: Deletes the Hardware-Model
@feature: Hardware-Model - Positive delete
@assert: Hardware-Model is deleted
"""
with Session(self.browser) as session:
make_hw_model(session, name=name)
search = self.hardwaremodel.search(name)
self.assertIsNotNone(search)
self.hardwaremodel.delete(name, True)
self.assertIsNone(self.hardwaremodel.search(name, timeout=3))
class Org(UITestCase):
"""Implements Organization tests in UI"""
# Tests for issues
@skip_if_bug_open('bugzilla', 1177610)
def test_auto_search(self):
"""@test: Can auto-complete search for an organization by partial name
@feature: Organizations
@assert: Created organization can be auto search by its partial name
@BZ: 1177610
"""
org_name = gen_string("alpha", 8)
part_string = org_name[:3]
with Session(self.browser) as session:
page = session.nav.go_to_org
make_org(session, org_name=org_name)
auto_search = self.org.auto_complete_search(
page,
locators["org.org_name"],
part_string,
org_name,
search_key='name')
self.assertIsNotNone(auto_search)
# Positive Create
@data(*generate_strings_list())
def test_positive_create_1(self, org_name):
"""@test: Create organization with valid name only.
@feature: Organizations
@assert: organization is created, label is auto-generated
@BZ: 1131469
"""
with Session(self.browser) as session:
make_org(session, org_name=org_name)
self.assertIsNotNone(self.org.search(org_name))
@stubbed('parent_org feature is disabled currently')
@data(
{
'label': gen_string('alpha'),
'name': gen_string('alpha'),
'desc': gen_string('alpha')
}, {
'label': gen_string('numeric'),
'name': gen_string('numeric'),
'desc': gen_string('numeric')
}, {
'label': gen_string('alphanumeric'),
'name': gen_string('alphanumeric'),
'desc': gen_string('alphanumeric')
}, {
'label': gen_string('alpha'),
'name': gen_string('utf8'),
'desc': gen_string('utf8')
}, {
'label': gen_string('alpha'),
'name': gen_string('latin1'),
'desc': gen_string('latin1')
}, {
'label': gen_string('alpha'),
'name': gen_string('html'),
'desc': gen_string('html')
})
def test_positive_create_2(self, test_data):
"""@test: Create organization with valid name, label, parent_org, desc.
@feature: Organizations
@assert: organization is created.
"""
parent = gen_string("alpha", 8)
desc = test_data['desc']
label = test_data['label']
org_name = test_data['name']
with Session(self.browser) as session:
make_org(session, org_name=parent)
make_org(session,
org_name=org_name,
label=label,
desc=desc,
parent_org=parent)
self.assertIsNotNone(self.org.search(org_name))
@data({
'name': gen_string('alpha', 10),
'label': gen_string('alpha', 10)
}, {
'name': gen_string('numeric', 10),
'label': gen_string('numeric', 10)
}, {
'name': gen_string('alphanumeric', 10),
'label': gen_string('alphanumeric', 10)
})
# As label cannot contain chars other than ascii alpha numerals, '_', '-'.
def test_positive_create_3(self, test_data):
"""@test: Create organization with valid unmatching name and label only
@feature: Organizations
@assert: organization is created, label does not match name
"""
name_loc = locators["org.name"]
label_loc = locators["org.label"]
org_name = test_data['name']
org_label = test_data['label']
with Session(self.browser) as session:
make_org(session, org_name=org_name, label=org_label)
self.org.search(org_name).click()
name = session.nav.wait_until_element(name_loc).get_attribute(
"value")
label = session.nav.wait_until_element(label_loc).get_attribute(
"value")
self.assertNotEqual(name, label)
@data(gen_string('alpha', 10), gen_string('numeric', 10),
gen_string('alphanumeric', 10))
# As label cannot contain chars other than ascii alpha numerals, '_', '-'.
def test_positive_create_4(self, org_label):
"""@test: Create organization with valid matching name and label only.
@feature: Organizations
@assert: organization is created, label matches name
"""
name_loc = locators["org.name"]
label_loc = locators["org.label"]
org_name = org_label
with Session(self.browser) as session:
make_org(session, org_name=org_name, label=org_label)
self.org.search(org_name).click()
name = self.org.wait_until_element(name_loc).get_attribute("value")
label = self.org.wait_until_element(label_loc).get_attribute(
"value")
self.assertEqual(name, label)
@skip_if_bug_open('bugzilla', 1079482)
@skip_if_bug_open('bugzilla', 1131469)
@data({
'name': gen_string('alpha', 10),
'desc': gen_string('alpha', 10)
}, {
'name': gen_string('numeric', 10),
'desc': gen_string('numeric', 10)
}, {
'name': gen_string('alphanumeric', 10),
'desc': gen_string('alphanumeric', 10)
}, {
'name': gen_string('utf8', 10),
'desc': gen_string('utf8', 10)
}, {
'name': gen_string('latin1', 20),
'desc': gen_string('latin1', 10)
}, {
'name': gen_string('html', 20),
'desc': gen_string('html', 10)
})
def test_positive_create_5(self, test_data):
"""@test: Create organization with valid name and description only.
@feature: Organizations
@assert: organization is created, label is auto-generated
@BZ: 1079482
@BZ: 1131469
"""
desc = test_data['desc']
org_name = test_data['name']
label_loc = locators["org.label"]
with Session(self.browser) as session:
make_org(session, org_name=org_name, desc=desc)
self.assertIsNotNone(self.org.search(org_name))
self.org.search(org_name).click()
label_ele = session.nav.wait_until_element(label_loc)
label_value = label_ele.get_attribute("value")
self.assertIsNotNone(label_value)
@data(
{
'org_name': gen_string('alpha', 10),
'loc_name': gen_string('alpha', 10)
}, {
'org_name': gen_string('numeric', 10),
'loc_name': gen_string('numeric', 10)
}, {
'org_name': gen_string('alphanumeric', 10),
'loc_name': gen_string('alphanumeric', 10)
}, {
'org_name': gen_string('utf8', 10),
'loc_name': gen_string('utf8', 10)
}, {
'org_name': gen_string('latin1', 20),
'loc_name': gen_string('latin1', 10)
}, {
'org_name': gen_string('html', 20),
'loc_name': gen_string('html', 10)
})
def test_positive_create_6(self, test_data):
"""@test: Select both organization and location.
@feature: Organizations
@assert: Both organization and location are selected.
"""
org_name = test_data['org_name']
loc_name = test_data['loc_name']
location = entities.Location(name=loc_name).create()
self.assertEqual(location['name'], loc_name)
with Session(self.browser) as session:
make_org(session, org_name=org_name)
self.assertIsNotNone(self.org.search(org_name))
organization = session.nav.go_to_select_org(org_name)
location = session.nav.go_to_select_loc(loc_name)
self.assertEqual(organization, org_name)
self.assertEqual(location, loc_name)
@data(*generate_strings_list(len1=256))
def test_negative_create_0(self, org_name):
"""@test: Create organization with valid label and description, name is
too long.
@feature: Organizations Negative Tests
@assert: organization is not created
"""
with Session(self.browser) as session:
make_org(session, org_name=org_name)
error = session.nav.wait_until_element(
common_locators["name_haserror"])
self.assertIsNotNone(error)
def test_negative_create_1(self):
"""@test: Create organization with valid label and description, name is
blank.
@feature: Organizations - Negative Tests
@assert: organization is not created
"""
org_name = ""
with Session(self.browser) as session:
make_org(session, org_name=org_name)
error = session.nav.wait_until_element(
common_locators["name_haserror"])
self.assertIsNotNone(error)
def test_negative_create_2(self):
"""@test: Create organization with valid label and description, name is
whitespace.
@feature: Organizations Negative Test.
@assert: organization is not created
"""
org_name = " "
with Session(self.browser) as session:
make_org(session, org_name=org_name)
error = session.nav.wait_until_element(
common_locators["name_haserror"])
self.assertIsNotNone(error)
@skip_if_bug_open('bugzilla', 1131469)
@data(*generate_strings_list())
def test_negative_create_3(self, org_name):
"""@test: Create organization with valid values, then create a new one
with same values.
@feature: Organizations Negative Test.
@assert: organization is not created
@BZ: 1131469
"""
with Session(self.browser) as session:
make_org(session, org_name=org_name)
self.assertIsNotNone(self.org.search(org_name))
self.org.create(org_name)
error = session.nav.wait_until_element(
common_locators["name_haserror"])
self.assertIsNotNone(error)
# Positive Delete
@stubbed('Organization deletion is disabled')
@data(*generate_strings_list())
def test_positive_delete_1(self, org_name):
"""@test: Create organization with valid values then delete it.
@feature: Organizations Positive Delete test.
@assert: organization is deleted
"""
with Session(self.browser) as session:
make_org(session, org_name=org_name)
self.assertIsNotNone(self.org.search(org_name))
self.org.remove(org_name, really=True)
self.assertIsNone(self.org.search(org_name))
# Negative Delete
# Positive Update
@skip_if_bug_open('bugzilla', 1131469)
@data(*generate_strings_list())
def test_positive_update_1(self, new_name):
"""@test: Create organization with valid values then update its name.
@feature: Organizations Positive Update test.
@assert: organization name is updated
@BZ: 1131469
"""
org_name = gen_string("alpha", 8)
with Session(self.browser) as session:
make_org(session, org_name=org_name)
self.assertIsNotNone(self.org.search(org_name))
self.org.update(org_name, new_name=new_name)
self.assertIsNotNone(self.org.search(new_name))
# Negative Update
@skip_if_bug_open('bugzilla', 1131469)
@data(*generate_strings_list())
def test_negative_update_1(self, org_name):
"""@test: Create organization with valid values then fail to update
its name.
@feature: Organizations Negative Update test.
@assert: organization name is not updated
@BZ: 1131469
"""
with Session(self.browser) as session:
make_org(session, org_name=org_name)
self.assertIsNotNone(self.org.search(org_name))
new_name = gen_string("alpha", 256)
self.org.update(org_name, new_name=new_name)
error = session.nav.wait_until_element(
common_locators["name_haserror"])
self.assertIsNotNone(error)
# Miscellaneous
@skip_if_bug_open('bugzilla', 1131469)
@data(*generate_strings_list())
def test_search_key_1(self, org_name):
"""@test: Create organization and search/find it.
@feature: Organizations search.
@assert: organization can be found
@BZ: 1131469
"""
with Session(self.browser) as session:
make_org(session, org_name=org_name)
self.assertIsNotNone(self.org.search(org_name))
# Associations
@run_only_on('sat')
@data(*generate_strings_list())
def test_remove_domain_1(self, domain_name):
"""@test: Add a domain to an organization and remove it by organization
name and domain name.
@feature: Organizations Disassociate domain.
@assert: the domain is removed from the organization
"""
strategy, value = common_locators["entity_select"]
strategy1, value1 = common_locators["entity_deselect"]
org_name = gen_string("alpha", 8)
domain = entities.Domain(name=domain_name).create()
self.assertEqual(domain['name'], domain_name)
with Session(self.browser) as session:
make_org(session, org_name=org_name, domains=[domain_name])
self.org.search(org_name).click()
session.nav.wait_until_element(
tab_locators["context.tab_domains"]).click()
element = session.nav.wait_until_element(
(strategy1, value1 % domain_name))
# Item is listed in 'Selected Items' list and not 'All Items' list.
self.assertIsNotNone(element)
self.org.update(org_name, domains=[domain_name])
self.org.search(org_name).click()
session.nav.wait_until_element(
tab_locators["context.tab_domains"]).click()
element = session.nav.wait_until_element(
(strategy, value % domain_name))
# Item is listed in 'All Items' list and not 'Selected Items' list.
self.assertIsNotNone(element)
# Note: HTML username is invalid as per the UI msg.
@data(
{u'user_name': gen_string('alpha', 8)},
{u'user_name': gen_string('numeric', 8)},
{u'user_name': gen_string('alphanumeric', 8)},
{u'user_name': gen_string('utf8', 8)},
{u'user_name': gen_string('latin1', 8)},
)
def test_remove_user_1(self, test_data):
"""@test: Create admin users then add user and remove it
by using the organization name.
@feature: Organizations dis-associate user.
@assert: The user is added then removed from the organization
"""
strategy, value = common_locators["entity_select"]
strategy1, value1 = common_locators["entity_deselect"]
org_name = gen_string("alpha", 8)
password = gen_string("alpha", 8)
user_name = test_data['user_name']
user = entities.User(login=user_name,
firstname=user_name,
lastname=user_name,
password=password).create()
self.assertEqual(user['login'], user_name)
with Session(self.browser) as session:
make_org(session, org_name=org_name, users=[user_name])
self.org.search(org_name).click()
session.nav.wait_until_element(
tab_locators["context.tab_users"]).click()
element = session.nav.wait_until_element(
(strategy1, value1 % user_name))
# Item is listed in 'Selected Items' list and not 'All Items' list.
self.assertIsNotNone(element)
self.org.update(org_name, users=[user_name], new_users=None)
self.org.search(org_name).click()
session.nav.wait_until_element(
tab_locators["context.tab_users"]).click()
element = session.nav.wait_until_element(
(strategy, value % user_name))
# Item is listed in 'All Items' list and not 'Selected Items' list.
self.assertIsNotNone(element)
@run_only_on('sat')
@data(*generate_strings_list())
def test_remove_hostgroup_1(self, host_grp_name):
"""@test: Add a hostgroup and remove it by using the organization
name and hostgroup name.
@feature: Organizations remove hostgroup.
@assert: hostgroup is added to organization then removed.
"""
strategy, value = common_locators["entity_select"]
strategy1, value1 = common_locators["entity_deselect"]
org_name = gen_string("alpha", 8)
host_grp = entities.HostGroup(name=host_grp_name).create()
self.assertEqual(host_grp['name'], host_grp_name)
with Session(self.browser) as session:
make_org(session, org_name=org_name, hostgroups=[host_grp_name])
self.org.search(org_name).click()
session.nav.wait_until_element(
tab_locators["context.tab_hostgrps"]).click()
element = session.nav.wait_until_element(
(strategy1, value1 % host_grp_name))
# Item is listed in 'Selected Items' list and not 'All Items' list.
self.assertIsNotNone(element)
self.org.update(org_name,
hostgroups=[host_grp_name],
new_hostgroups=None)
self.org.search(org_name).click()
session.nav.wait_until_element(
tab_locators["context.tab_hostgrps"]).click()
element = session.nav.wait_until_element(
(strategy, value % host_grp_name))
# Item is listed in 'All Items' list and not 'Selected Items' list.
self.assertIsNotNone(element)
@run_only_on('sat')
@stubbed()
@data("""DATADRIVENGOESHERE
smartproxy name is alpha
smartproxy name is numeric
smartproxy name is alpha_numeric
smartproxy name is utf-8
smartproxy name is latin1
smartproxy name is html
""")
def test_add_smartproxy_1(self, test_data):
"""@test: Add a smart proxy by using org and smartproxy name
@feature: Organizations
@assert: smartproxy is added
@status: manual
"""
pass
@run_only_on('sat')
@data(*generate_strings_list())
def test_add_subnet_1(self, subnet_name):
"""@test: Add a subnet by using organization name and subnet name.
@feature: Organizations associate subnet.
@assert: subnet is added.
"""
strategy, value = common_locators["entity_deselect"]
org_name = gen_string("alpha", 8)
subnet_network = gen_ipaddr(ip3=True)
subnet_mask = "255.255.255.0"
subnet = entities.Subnet(name=subnet_name,
network=subnet_network,
mask=subnet_mask).create()
self.assertEqual(subnet['name'], subnet_name)
with Session(self.browser) as session:
make_org(session, org_name=org_name)
self.assertIsNotNone(self.org.search(org_name))
self.org.update(org_name, new_subnets=[subnet_name])
self.org.search(org_name).click()
self.org.wait_until_element(
tab_locators["context.tab_subnets"]).click()
element = session.nav.wait_until_element(
(strategy, value % subnet_name))
self.assertIsNotNone(element)
@run_only_on('sat')
@data(*generate_strings_list())
def test_add_domain_1(self, domain_name):
"""@test: Add a domain to an organization.
@feature: Organizations associate domain.
@assert: Domain is added to organization.
"""
strategy, value = common_locators["entity_deselect"]
org_name = gen_string("alpha", 8)
domain = entities.Domain(name=domain_name).create()
self.assertEqual(domain['name'], domain_name)
with Session(self.browser) as session:
make_org(session, org_name=org_name)
self.assertIsNotNone(self.org.search(org_name))
self.org.update(org_name, new_domains=[domain_name])
self.org.search(org_name).click()
session.nav.wait_until_element(
tab_locators["context.tab_domains"]).click()
element = session.nav.wait_until_element(
(strategy, value % domain_name))
self.assertIsNotNone(element)
@data(
{u'user_name': gen_string('alpha', 8)},
{u'user_name': gen_string('numeric', 8)},
{u'user_name': gen_string('alphanumeric', 8)},
{u'user_name': gen_string('utf8', 8)},
{u'user_name': gen_string('latin1', 8)},
)
def test_add_user_2(self, test_data):
"""@test: Create different types of users then add user
by using the organization name.
@feature: Organizations associate user.
@assert: User is added to organization.
"""
user_name = test_data['user_name']
strategy, value = common_locators["entity_deselect"]
org_name = gen_string("alpha", 8)
password = gen_string("alpha", 8)
user = entities.User(login=user_name,
firstname=user_name,
lastname=user_name,
password=password).create()
self.assertEqual(user['login'], user_name)
with Session(self.browser) as session:
make_org(session, org_name=org_name)
self.assertIsNotNone(self.org.search(org_name))
self.org.update(org_name, new_users=[user_name])
self.org.search(org_name).click()
session.nav.wait_until_element(
tab_locators["context.tab_users"]).click()
element = session.nav.wait_until_element(
(strategy, value % user_name))
self.assertIsNotNone(element)
@run_only_on('sat')
@data(*generate_strings_list())
def test_add_hostgroup_1(self, host_grp_name):
"""@test: Add a hostgroup by using the organization
name and hostgroup name.
@feature: Organizations associate host-group.
@assert: hostgroup is added to organization
"""
strategy, value = common_locators["entity_deselect"]
org_name = gen_string("alpha", 8)
host_grp = entities.HostGroup(name=host_grp_name).create()
self.assertEqual(host_grp['name'], host_grp_name)
with Session(self.browser) as session:
make_org(session, org_name=org_name)
self.assertIsNotNone(self.org.search(org_name))
self.org.update(org_name, new_hostgroups=[host_grp_name])
self.org.search(org_name).click()
session.nav.wait_until_element(
tab_locators["context.tab_hostgrps"]).click()
element = session.nav.wait_until_element(
(strategy, value % host_grp_name))
self.assertIsNotNone(element)
@run_only_on('sat')
@data(*generate_strings_list())
def test_add_location_1(self, location_name):
"""@test: Add a location by using the organization
name and location name.
@feature: Organizations associate location.
@assert: location is added to organization.
"""
strategy, value = common_locators["entity_deselect"]
org_name = gen_string("alpha", 8)
location = entities.Location(name=location_name).create()
self.assertEqual(location['name'], location_name)
with Session(self.browser) as session:
make_org(session, org_name=org_name)
self.assertIsNotNone(self.org.search(org_name))
self.org.update(org_name, new_locations=[location_name])
self.org.search(org_name).click()
session.nav.wait_until_element(
tab_locators["context.tab_locations"]).click()
element = session.nav.wait_until_element(
(strategy, value % location_name))
self.assertIsNotNone(element)
@run_only_on('sat')
@data(*generate_strings_list())
def test_remove_computeresource_1(self, resource_name):
"""@test: Remove computeresource by using the organization
name and computeresource name.
@feature: Organizations dis-associate compute-resource.
@assert: computeresource is added then removed.
"""
strategy, value = common_locators["entity_select"]
strategy1, value1 = common_locators["entity_deselect"]
org_name = gen_string("alpha", 8)
libvirt_url = "qemu+tcp://%s:16509/system"
url = (libvirt_url % conf.properties['main.server.hostname'])
resource = entities.ComputeResource(name=resource_name,
provider='Libvirt',
url=url).create()
self.assertEqual(resource['name'], resource_name)
with Session(self.browser) as session:
make_org(session, org_name=org_name, resources=[resource_name])
self.org.search(org_name).click()
session.nav.wait_until_element(
tab_locators["context.tab_resources"]).click()
element = session.nav.wait_until_element(
(strategy1, value1 % resource_name))
# Item is listed in 'Selected Items' list and not 'All Items' list.
self.assertIsNotNone(element)
self.org.update(org_name,
resources=[resource_name],
new_resources=None)
self.org.search(org_name).click()
session.nav.wait_until_element(
tab_locators["context.tab_resources"]).click()
element = session.nav.wait_until_element(
(strategy, value % resource_name))
# Item is listed in 'All Items' list and not 'Selected Items' list.
self.assertIsNotNone(element)
@run_only_on('sat')
@data(*generate_strings_list())
def test_remove_medium_1(self, medium_name):
"""@test: Remove medium by using organization name and medium name.
@feature: Organizations disassociate installation media.
@assert: medium is added then removed.
"""
strategy, value = common_locators["entity_select"]
strategy1, value1 = common_locators["entity_deselect"]
org_name = gen_string("alpha", 8)
path = URL % gen_string("alpha", 6)
medium = entities.Media(
name=medium_name,
media_path=path,
os_family='Redhat',
).create()
self.assertEqual(medium['name'], medium_name)
with Session(self.browser) as session:
make_org(session, org_name=org_name, medias=[medium_name])
self.org.search(org_name).click()
session.nav.wait_until_element(
tab_locators["context.tab_media"]).click()
element = session.nav.wait_until_element(
(strategy1, value1 % medium_name))
# Item is listed in 'Selected Items' list and not 'All Items' list.
self.assertIsNotNone(element)
self.navigator.go_to_org()
self.org.update(org_name, medias=[medium_name], new_medias=None)
self.org.search(org_name).click()
session.nav.wait_until_element(
tab_locators["context.tab_media"]).click()
element = session.nav.wait_until_element(
(strategy, value % medium_name))
# Item is listed in 'All Items' list and not 'Selected Items' list.
self.assertIsNotNone(element)
@run_only_on('sat')
@data(*generate_strings_list())
def test_remove_configtemplate_1(self, template_name):
"""@test: Remove config template.
@feature: Organizations dissociate config templates.
@assert: configtemplate is added then removed.
@BZ: 1129612
"""
strategy, value = common_locators["entity_select"]
strategy1, value1 = common_locators["entity_deselect"]
org_name = gen_string("alpha", 8)
entities.ConfigTemplate(name=template_name).create()
with Session(self.browser) as session:
make_org(session, org_name=org_name, templates=[template_name])
self.org.search(org_name).click()
session.nav.wait_until_element(
tab_locators["context.tab_template"]).click()
element = session.nav.wait_until_element(
(strategy1, value1 % template_name))
# Item is listed in 'Selected Items' list and not 'All Items' list.
self.assertIsNotNone(element)
self.org.update(org_name, templates=[template_name])
self.org.search(org_name).click()
session.nav.wait_until_element(
tab_locators["context.tab_template"]).click()
element = self.org.wait_until_element(
(strategy, value % template_name))
# Item is listed in 'All Items' list and not 'Selected Items' list.
self.assertIsNotNone(element)
@run_only_on('sat')
@data(gen_string('alpha', 8), gen_string('numeric', 8),
gen_string('alphanumeric', 8))
def test_add_environment_1(self, env_name):
"""@test: Add environment by using organization name and env name.
@feature: Organizations associate environment.
@assert: environment is added.
"""
strategy, value = common_locators["entity_deselect"]
org_name = gen_string("alpha", 8)
env = entities.Environment(name=env_name).create()
self.assertEqual(env['name'], env_name)
with Session(self.browser) as session:
make_org(session, org_name=org_name)
self.assertIsNotNone(self.org.search(org_name))
self.org.update(org_name, new_envs=[env_name])
self.org.search(org_name).click()
session.nav.wait_until_element(
tab_locators["context.tab_env"]).click()
element = session.nav.wait_until_element(
(strategy, value % env_name))
self.assertIsNotNone(element)
@run_only_on('sat')
@stubbed()
@data("""DATADRIVENGOESHERE
smartproxy name is alpha
smartproxy name is numeric
smartproxy name is alpha_numeric
smartproxy name is utf-8
smartproxy name is latin1
smartproxy name is html
""")
def test_remove_smartproxy_1(self, test_data):
"""@test: Remove smartproxy by using organization name and smartproxy
name
@feature: Organizations
@assert: smartproxy is added then removed
@status: manual
"""
pass
@run_only_on('sat')
@data(*generate_strings_list())
def test_add_computeresource_1(self, resource_name):
"""@test: Add compute resource using the organization
name and computeresource name.
@feature: Organizations associate compute resource.
@assert: computeresource is added.
"""
strategy, value = common_locators["entity_deselect"]
org_name = gen_string("alpha", 8)
libvirt_url = "qemu+tcp://%s:16509/system"
url = (libvirt_url % conf.properties['main.server.hostname'])
resource = entities.ComputeResource(name=resource_name,
provider='Libvirt',
url=url).create()
self.assertEqual(resource['name'], resource_name)
with Session(self.browser) as session:
make_org(session, org_name=org_name)
self.assertIsNotNone(self.org.search(org_name))
self.org.update(org_name, new_resources=[resource_name])
self.org.search(org_name).click()
session.nav.wait_until_element(
tab_locators["context.tab_resources"]).click()
element = session.nav.wait_until_element(
(strategy, value % resource_name))
self.assertIsNotNone(element)
@run_only_on('sat')
@data(*generate_strings_list())
def test_add_medium_1(self, medium_name):
"""@test: Add medium by using the organization name and medium name.
@feature: Organizations associate medium.
@assert: medium is added.
"""
strategy, value = common_locators["entity_deselect"]
org_name = gen_string("alpha", 8)
path = URL % gen_string("alpha", 6)
medium = entities.Media(
name=medium_name,
media_path=path,
os_family='Redhat',
).create()
self.assertEqual(medium['name'], medium_name)
with Session(self.browser) as session:
make_org(session, org_name=org_name)
self.assertIsNotNone(self.org.search(org_name))
self.org.update(org_name, new_medias=[medium_name])
self.org.search(org_name).click()
session.nav.wait_until_element(
tab_locators["context.tab_media"]).click()
element = session.nav.wait_until_element(
(strategy, value % medium_name))
self.assertIsNotNone(element)
@run_only_on('sat')
@data(*generate_strings_list())
def test_add_configtemplate_1(self, template_name):
"""@test: Add config template by using organization name and
configtemplate name.
@feature: Organizations associate config template.
@assert: configtemplate is added
@BZ: 1129612
"""
strategy, value = common_locators["entity_deselect"]
org_name = gen_string("alpha", 8)
entities.ConfigTemplate(name=template_name).create()
with Session(self.browser) as session:
make_org(session, org_name=org_name)
self.assertIsNotNone(self.org.search(org_name))
self.org.update(org_name, new_templates=[template_name])
self.org.search(org_name).click()
self.org.wait_until_element(
tab_locators["context.tab_template"]).click()
element = session.nav.wait_until_element(
(strategy, value % template_name))
self.assertIsNotNone(element)
@run_only_on('sat')
@data(gen_string('alpha', 8), gen_string('numeric', 8),
gen_string('alphanumeric', 8))
def test_remove_environment_1(self, env_name):
"""@test: Remove environment by using org & evironment name.
@feature: Organizations dis-associate environment.
@assert: environment is removed from Organization.
"""
strategy, value = common_locators["entity_select"]
strategy1, value1 = common_locators["entity_deselect"]
org_name = gen_string("alpha", 8)
env = entities.Environment(name=env_name).create()
self.assertEqual(env['name'], env_name)
with Session(self.browser) as session:
make_org(session, org_name=org_name, envs=[env_name])
self.org.search(org_name).click()
session.nav.wait_until_element(
tab_locators["context.tab_env"]).click()
element = session.nav.wait_until_element(
(strategy1, value1 % env_name))
# Item is listed in 'Selected Items' list and not 'All Items' list.
self.assertIsNotNone(element)
self.org.update(org_name, envs=[env_name])
self.org.search(org_name).click()
session.nav.wait_until_element(
tab_locators["context.tab_env"]).click()
element = session.nav.wait_until_element(
(strategy, value % env_name))
# Item is listed in 'All Items' list and not 'Selected Items' list.
self.assertIsNotNone(element)
@run_only_on('sat')
@data(*generate_strings_list())
def test_remove_subnet_1(self, subnet_name):
"""@test: Remove subnet by using organization name and subnet name.
@feature: Organizations dis-associate subnet.
@assert: subnet is added then removed.
"""
strategy, value = common_locators["entity_select"]
strategy1, value1 = common_locators["entity_deselect"]
org_name = gen_string("alpha", 8)
subnet_network = gen_ipaddr(ip3=True)
subnet_mask = "255.255.255.0"
subnet = entities.Subnet(name=subnet_name,
network=subnet_network,
mask=subnet_mask).create()
self.assertEqual(subnet['name'], subnet_name)
with Session(self.browser) as session:
make_org(session, org_name=org_name, subnets=[subnet_name])
self.org.search(org_name).click()
session.nav.wait_until_element(
tab_locators["context.tab_subnets"]).click()
element = session.nav.wait_until_element(
(strategy1, value1 % subnet_name))
# Item is listed in 'Selected Items' list and not 'All Items' list.
self.assertIsNotNone(element)
self.org.update(org_name, subnets=[subnet_name])
self.org.search(org_name).click()
session.nav.wait_until_element(
tab_locators["context.tab_subnets"]).click()
element = session.nav.wait_until_element(
(strategy, value % subnet_name))
# Item is listed in 'All Items' list and not 'Selected Items' list.
self.assertIsNotNone(element)
def test_return_type(self):
"""Tests if generate string list returns a unicode string"""
for string in generate_strings_list():
self.assertIsInstance(string, unicode)
class Template(UITestCase):
"""Implements Provisioning Template tests from UI"""
@data(*generate_strings_list(len1=8))
def test_positive_create_template(self, name):
"""@Test: Create new template
@Feature: Template - Positive Create
@Assert: New provisioning template of type 'provision'
should be created successfully
"""
temp_type = 'provision'
template_path = get_data_file(OS_TEMPLATE_DATA_FILE)
with Session(self.browser) as session:
make_templates(session,
name=name,
template_path=template_path,
custom_really=True,
template_type=temp_type)
self.assertIsNotNone(self.template.search(name))
def test_negative_create_template_1(self):
"""@Test: Template - Create a new template with 256 characters in name
@Feature: Template - Negative Create
@Assert: Template is not created
"""
name = gen_string("alpha", 256)
temp_type = 'provision'
template_path = get_data_file(OS_TEMPLATE_DATA_FILE)
with Session(self.browser) as session:
make_templates(session,
name=name,
template_path=template_path,
custom_really=True,
template_type=temp_type)
self.assertIsNotNone(
self.template.wait_until_element(
common_locators["name_haserror"]))
@data(" ", "")
def test_negative_create_template_2(self, name):
"""@Test: Create a new template with blank and whitespace in name
@Feature: Template - Negative Create
@Assert: Template is not created
"""
temp_type = 'provision'
template_path = get_data_file(OS_TEMPLATE_DATA_FILE)
with Session(self.browser) as session:
make_templates(session,
name=name,
template_path=template_path,
custom_really=True,
template_type=temp_type)
self.assertIsNotNone(
self.template.wait_until_element(
common_locators["name_haserror"]))
def test_negative_create_template_4(self):
"""@Test: Template - Create a new template with same name
@Feature: Template - Negative Create
@Assert: Template is not created
"""
name = gen_string("alpha", 16)
temp_type = 'provision'
template_path = get_data_file(OS_TEMPLATE_DATA_FILE)
with Session(self.browser) as session:
make_templates(session,
name=name,
template_path=template_path,
custom_really=True,
template_type=temp_type)
self.assertIsNotNone(self.template.search(name))
make_templates(session,
name=name,
template_path=template_path,
custom_really=True,
template_type=temp_type)
self.assertIsNotNone(
self.template.wait_until_element(
common_locators["name_haserror"]))
def test_negative_create_template_5(self):
"""@Test: Template - Create a new template without selecting its type
@Feature: Template - Negative Create
@Assert: Template is not created
"""
name = gen_string("alpha", 16)
temp_type = ""
template_path = get_data_file(OS_TEMPLATE_DATA_FILE)
with Session(self.browser) as session:
with self.assertRaises(Exception) as context:
make_templates(session,
name=name,
template_path=template_path,
custom_really=True,
template_type=temp_type)
self.assertEqual(
context.exception.message, "Could not create template '%s'"
" without type" % name)
def test_negative_create_template_6(self):
"""@Test: Template - Create a new template without uploading a template
@Feature: Template - Negative Create
@Assert: Template is not created
"""
name = gen_string("alpha", 16)
temp_type = 'PXELinux'
template_path = ""
with Session(self.browser) as session:
with self.assertRaises(Exception) as context:
make_templates(session,
name=name,
template_path=template_path,
custom_really=True,
template_type=temp_type)
self.assertEqual(context.exception.message,
"Could not create blank template '%s'" % name)
def test_negative_create_template_7(self):
"""@Test: Create a new template with 256 characters in audit comments
@Feature: Template - Negative Create
@Assert: Template is not created
"""
name = gen_string("alpha", 16)
audit_comment = gen_string("alpha", 256)
temp_type = 'PXELinux'
template_path = get_data_file(OS_TEMPLATE_DATA_FILE)
with Session(self.browser) as session:
make_templates(session,
name=name,
template_path=template_path,
custom_really=True,
audit_comment=audit_comment,
template_type=temp_type)
self.assertIsNotNone(
self.template.wait_until_element(common_locators["haserror"]))
@data(*generate_strings_list(len1=8))
def test_positive_create_snippet_template(self, name):
"""@Test: Create new template of type snippet
@Feature: Template - Positive Create
@Assert: New provisioning template of type 'snippet'
should be created successfully
"""
template_path = get_data_file(SNIPPET_DATA_FILE)
with Session(self.browser) as session:
make_templates(session,
name=name,
template_path=template_path,
custom_really=True,
snippet=True)
self.assertIsNotNone(self.template.search(name))
@skip_if_bug_open('bugzilla', 1177756)
@data(*generate_strings_list(len1=8))
def test_remove_template(self, template_name):
"""@Test: Remove a template
@Feature: Template - Positive Delete
@Assert: Template removed successfully
@BZ: 1177756
"""
entities.ConfigTemplate(name=template_name).create_json()
with Session(self.browser):
self.template.delete(template_name, True)
self.assertIsNotNone(
self.template.wait_until_element(
common_locators["notif.success"]))
def test_update_template(self):
"""@Test: Update template name and template type
@Feature: Template - Positive Update
@Assert: The template name and type should be updated successfully
"""
name = gen_string("alpha", 6)
new_name = gen_string("alpha", 6)
temp_type = 'provision'
new_temp_type = 'PXELinux'
template_path = get_data_file(OS_TEMPLATE_DATA_FILE)
with Session(self.browser) as session:
make_templates(session,
name=name,
template_path=template_path,
custom_really=True,
template_type=temp_type)
self.assertIsNotNone(self.template.search(name))
self.template.update(name, False, new_name, None, new_temp_type)
self.assertIsNotNone(self.template.search(new_name))
def test_update_template_os(self):
"""@Test: Creates new template, along with two OS's
and associate list of OS's with created template
@Feature: Template - Positive Update
@Assert: The template should be updated with newly created OS's
successfully
"""
name = gen_string("alpha", 6)
new_name = gen_string("alpha", 6)
temp_type = 'provision'
os_list = [
entities.OperatingSystem().create_json()['name'] for _ in range(2)
]
template_path = get_data_file(OS_TEMPLATE_DATA_FILE)
with Session(self.browser) as session:
make_templates(session,
name=name,
template_path=template_path,
custom_really=True,
template_type=temp_type)
self.assertIsNotNone(self.template.search(name))
self.template.update(name, False, new_name, new_os_list=os_list)
self.assertIsNotNone(self.template.search(new_name))
def test_clone_template(self):
"""@Test: Assure ability to clone a provisioning template
@Feature: Template - Clone
@Steps:
1. Go to Provisioning template UI
2. Choose a template and attempt to clone it
@Assert: template is cloned
"""
name = gen_string("alpha", 6)
clone_name = gen_string("alpha", 6)
temp_type = 'provision'
os_list = [
entities.OperatingSystem().create_json()['name'] for _ in range(2)
]
template_path = get_data_file(OS_TEMPLATE_DATA_FILE)
with Session(self.browser) as session:
make_templates(session,
name=name,
template_path=template_path,
custom_really=True,
template_type=temp_type)
self.assertIsNotNone(self.template.search(name))
self.template.clone(name,
custom_really=False,
clone_name=clone_name,
os_list=os_list)
self.assertIsNotNone(self.template.search(clone_name))
class UserGroup(UITestCase):
"""Implements UserGroup tests from UI"""
@classmethod
def setUpClass(cls): # noqa
cls.org_name = entities.Organization().create()
super(UserGroup, cls).setUpClass()
@skip_if_bug_open('bugzilla', 1142588)
@data(*generate_strings_list())
def test_positive_create_usergroup(self, group_name):
"""@Test: Create new Usergroup
@Feature: Usergroup - Positive Create
@Assert: Usergroup is created
"""
user_name = gen_string("alpha", 6)
password = gen_string("alpha", 6)
# Create a new user
entities.User(
login=user_name,
password=password,
).create()
with Session(self.browser) as session:
make_usergroup(session, name=group_name, users=[user_name])
self.assertIsNotNone(self.usergroup.search(group_name))
@skip_if_bug_open('bugzilla', 1142588)
@data(*generate_strings_list(len1=256))
def test_negative_create_usergroup_1(self, group_name):
"""@Test: Create a new UserGroup with 256 characters in name
@Feature: Usergroup - Negative Create
@Assert: Usergroup is not created
"""
with Session(self.browser) as session:
make_usergroup(session, org=self.org_name, name=group_name)
self.assertIsNotNone(
self.usergroup.wait_until_element(
common_locators["name_haserror"]))
self.assertIsNone(self.usergroup.search(group_name))
@data(" ", "")
def test_negative_create_usergroup_2(self, group_name):
"""@Test: Create a new UserGroup with blank and whitespace in name
@Feature: Usergroup - Negative Create
@Assert: Usergroup is not created
"""
with Session(self.browser) as session:
make_usergroup(session, org=self.org_name, name=group_name)
self.assertIsNotNone(
self.usergroup.wait_until_element(
common_locators["name_haserror"]))
@data(*generate_strings_list())
def test_negative_create_usergroup_3(self, group_name):
"""@Test: Create a new UserGroup with same name
@Feature: Usergroup - Negative Create
@Assert: Usergroup cannot be created with existing name
"""
with Session(self.browser) as session:
make_usergroup(session, org=self.org_name, name=group_name)
self.assertIsNotNone(self.usergroup.search(group_name))
make_usergroup(session, org=self.org_name, name=group_name)
self.assertIsNotNone(
self.usergroup.wait_until_element(
common_locators["name_haserror"]))
@skip_if_bug_open('bugzilla', 1142588)
@data(*generate_strings_list())
def test_remove_empty_usergroup(self, group_name):
"""@Test: Delete an empty Usergroup
@Feature: Usergroup - Positive Delete
@Assert: Usergroup is deleted
"""
with Session(self.browser) as session:
make_usergroup(session, org=self.org_name, name=group_name)
self.assertIsNotNone(self.usergroup.search(group_name))
self.usergroup.delete(group_name, True)
self.assertIsNotNone(
self.usergroup.wait_until_element(
common_locators["notif.success"]))
self.assertIsNone(self.usergroup.search(group_name))
@skip_if_bug_open('bugzilla', 1142588)
@data(*generate_strings_list())
def test_remove_usergroup(self, group_name):
"""@Test: Delete an Usergroup that contains a user
@Feature: Usergroup - Positive Delete
@Assert: Usergroup is deleted but not the added user
"""
user_name = gen_string("alpha", 6)
password = gen_string("alpha", 6)
# Create a new user
entities.User(login=user_name, password=password).create()
with Session(self.browser) as session:
make_usergroup(session, name=group_name, users=[user_name])
self.assertIsNotNone(self.usergroup.search(group_name))
self.usergroup.delete(group_name, True)
self.assertIsNotNone(
self.usergroup.wait_until_element(
common_locators["notif.success"]))
self.assertIsNone(self.usergroup.search(group_name))
self.assertIsNotNone(
self.user.search(name=user_name, search_key="login"))
@skip_if_bug_open('bugzilla', 1142588)
@data({
'name': gen_string("alpha", 6),
'new_name': gen_string("alpha", 6)
}, {
'name': gen_string("alphanumeric", 6),
'new_name': gen_string("alphanumeric", 6)
}, {
'name': gen_string("numeric", 6),
'new_name': gen_string("numeric", 6)
}, {
'name': gen_string("utf8", 6),
'new_name': gen_string("utf8", 6)
}, {
'name': gen_string("latin1", 6),
'new_name': gen_string("latin1", 6)
})
def test_update_usergroup(self, test_data):
"""@Test: Update usergroup with name or users
@Feature: Usergroup - Positive Update
@Assert: Usergroup is updated
"""
name = test_data['name']
new_name = test_data['new_name']
user_name = gen_string("alpha", 6)
password = gen_string("alpha", 6)
# Create a new user
entities.User(login=user_name, password=password).create()
with Session(self.browser) as session:
make_usergroup(session, name=name)
self.assertIsNotNone(self.usergroup.search(name))
self.usergroup.update(name, new_name, users=[user_name])
self.assertIsNotNone(self.usergroup.search(new_name))
class Repos(UITestCase):
"""Implements Repos tests in UI"""
@classmethod
def setUpClass(cls): # noqa
org_attrs = entities.Organization().create()
loc_attrs = entities.Location().create()
cls.org_name = org_attrs['name']
cls.org_id = org_attrs['id']
cls.loc_name = loc_attrs['name']
cls.loc_id = loc_attrs['id']
super(Repos, cls).setUpClass()
def setup_navigate_syncnow(self, session, prd_name, repo_name):
"""Helps with Navigation for syncing via the repos page."""
strategy1, value1 = locators["repo.select"]
strategy2, value2 = locators["repo.select_checkbox"]
session.nav.go_to_select_org(self.org_name)
session.nav.go_to_products()
session.nav.wait_until_element((strategy1, value1 % prd_name)).click()
session.nav.wait_until_element((strategy2, value2 % repo_name)).click()
session.nav.wait_for_ajax()
session.nav.wait_until_element(locators["repo.sync_now"]).click()
session.nav.wait_for_ajax()
def prd_sync_is_ok(self, repo_name):
"""Asserts whether the sync Result is successful."""
strategy1, value1 = locators["repo.select_event"]
self.repository.wait_until_element(
tab_locators["prd.tab_tasks"]).click()
self.repository.wait_for_ajax()
self.repository.wait_until_element(
(strategy1, value1 % repo_name)).click()
self.repository.wait_for_ajax()
timeout = time.time() + 60 * 10
spinner = self.repository.wait_until_element(
locators["repo.result_spinner"], 20)
# Waits until result spinner is visible on the UI or times out
# after 10mins
while spinner:
if time.time() > timeout:
break
spinner = self.repository.wait_until_element(
locators["repo.result_spinner"], 3)
result = self.repository.wait_until_element(
locators["repo.result_event"]).text
return result == 'success'
@run_only_on('sat')
@data(*generate_strings_list())
def test_create_repo_1(self, repo_name):
"""@Test: Create repository with minimal input parameters
@Feature: Content Repos - Positive Create
@Assert: Repos is created
"""
# Creates new product
product_name = entities.Product(
organization=self.org_id,
location=self.loc_id,
).create()['name']
with Session(self.browser) as session:
make_repository(session,
org=self.org_name,
loc=self.loc_name,
name=repo_name,
product=product_name,
url=FAKE_1_YUM_REPO)
self.assertIsNotNone(self.repository.search(repo_name))
@run_only_on('sat')
@data(*generate_strings_list())
def test_create_repo_2(self, repo_name):
"""@Test: Create repository in two different orgs with same name
@Assert: Repos is created
@Feature: Content Repos - Positive Create
"""
org_2_name = gen_string("alpha", 10)
# Creates new product_1
product_1_name = entities.Product(
organization=self.org_id,
location=self.loc_id,
).create()['name']
# Create new product_2 under new organization_2
org_2_id = entities.Organization(name=org_2_name).create()['id']
product_2_name = entities.Product(
organization=org_2_id,
location=self.loc_id,
).create()['name']
with Session(self.browser) as session:
make_repository(session,
org=self.org_name,
loc=self.loc_name,
name=repo_name,
product=product_1_name,
url=FAKE_1_YUM_REPO)
self.assertIsNotNone(self.repository.search(repo_name))
make_repository(session,
org=org_2_name,
loc=self.loc_name,
name=repo_name,
product=product_2_name,
url=FAKE_1_YUM_REPO,
force_context=True)
self.assertIsNotNone(self.repository.search(repo_name))
@run_only_on('sat')
def test_create_repo_3(self):
"""@Test: Create a Docker-based repository
@Feature: Content Repos - Positive Create
@Assert: Docker-based repo is created.
"""
# Creates new product
repo_name = u'busybox'
product_name = entities.Product(
organization=self.org_id,
location=self.loc_id,
).create()['name']
with Session(self.browser) as session:
make_repository(session,
org=self.org_name,
loc=self.loc_name,
name=repo_name,
product=product_name,
repo_type=REPO_TYPE['docker'],
url=DOCKER_REGISTRY_HUB)
self.assertIsNotNone(self.repository.search(repo_name))
@run_only_on('sat')
@skip_if_bug_open('bugzilla', 1167837)
def test_create_repo_4(self):
"""@Test: Create and sync a Docker-based repository
@Feature: Content Repos - Positive Create
@Assert: Docker-based repo is created and synchronized.
"""
# Creates new product
repo_name = u'busybox'
product_name = entities.Product(
organization=self.org_id,
location=self.loc_id,
).create()['name']
with Session(self.browser) as session:
make_repository(session,
org=self.org_name,
loc=self.loc_name,
name=repo_name,
product=product_name,
repo_type=REPO_TYPE['docker'],
url=DOCKER_REGISTRY_HUB)
self.assertIsNotNone(self.repository.search(repo_name))
# Synchronize it
self.navigator.go_to_sync_status()
synced = self.sync.sync_custom_repos(product_name, [repo_name])
self.assertTrue(synced)
@run_only_on('sat')
@data(*generate_strings_list())
def test_create_repo_5(self, repo_name):
"""@Test: Create repository with checksum type as sha256.
@Feature: Content Repos - Positive Create
@Assert: Repos is created with checksum type as sha256.
"""
locator = locators['repo.fetch_checksum']
checksum = CHECKSUM_TYPE[u'sha256']
# Creates new product
product_name = entities.Product(
organization=self.org_id,
location=self.loc_id,
).create()['name']
with Session(self.browser) as session:
make_repository(session,
org=self.org_name,
loc=self.loc_name,
name=repo_name,
product=product_name,
url=FAKE_1_YUM_REPO,
repo_checksum=checksum)
self.repository.search(repo_name).click()
self.repository.wait_for_ajax()
checksum_text = session.nav.wait_until_element(locator).text
self.assertEqual(checksum_text, checksum)
@run_only_on('sat')
@data("", " ")
def test_negative_create_1(self, repo_name):
"""@Test: Create repository with blank and whitespace in name
@Feature: Content Repos - Negative Create zero length
@Assert: Repos is not created
"""
# Creates new product
product_name = entities.Product(organization=self.org_id,
location=self.loc_id).create()['name']
with Session(self.browser) as session:
make_repository(session,
org=self.org_name,
loc=self.loc_name,
name=repo_name,
product=product_name,
url=FAKE_1_YUM_REPO)
invalid = self.products.wait_until_element(
common_locators["common_invalid"])
self.assertIsNotNone(invalid)
@run_only_on('sat')
@data(*generate_strings_list())
def test_negative_create_2(self, repo_name):
"""@Test: Create repository with same name
@Feature: Content Repos - Negative Create with same name
@Assert: Repos is not created
"""
# Creates new product
product_name = entities.Product(organization=self.org_id,
location=self.loc_id).create()['name']
with Session(self.browser) as session:
make_repository(session,
org=self.org_name,
loc=self.loc_name,
name=repo_name,
product=product_name,
url=FAKE_1_YUM_REPO)
self.assertIsNotNone(self.repository.search(repo_name))
make_repository(session,
org=self.org_name,
loc=self.loc_name,
name=repo_name,
product=product_name,
url=FAKE_1_YUM_REPO)
invalid = self.products.wait_until_element(
common_locators["common_invalid"])
self.assertTrue(invalid)
@run_only_on('sat')
@data(*generate_strings_list(len1=256))
def test_negative_create_3(self, repo_name):
"""@Test: Create content repository with 256 characters in name
@Feature: Content Repos - Negative Create
@Assert: Repos is not created
"""
# Creates new product
product_name = entities.Product(organization=self.org_id,
location=self.loc_id).create()['name']
with Session(self.browser) as session:
make_repository(session,
org=self.org_name,
loc=self.loc_name,
name=repo_name,
product=product_name,
url=FAKE_1_YUM_REPO)
error = self.repository.wait_until_element(
common_locators["common_haserror"])
self.assertTrue(error)
@run_only_on('sat')
@data(*generate_strings_list())
def test_positive_update_1(self, repo_name):
"""@Test: Update content repository with new URL
@Feature: Content Repo - Positive Update
@Assert: Repo is updated with new url
"""
locator = locators["repo.fetch_url"]
# Creates new product
product_name = entities.Product(organization=self.org_id,
location=self.loc_id).create()['name']
with Session(self.browser) as session:
make_repository(session,
org=self.org_name,
loc=self.loc_name,
name=repo_name,
product=product_name,
url=FAKE_1_YUM_REPO)
self.assertIsNotNone(self.repository.search(repo_name))
self.repository.search(repo_name).click()
self.repository.wait_for_ajax()
url_text = self.repository.wait_until_element(locator).text
self.assertEqual(url_text, FAKE_1_YUM_REPO)
self.navigator.go_to_products()
self.products.search(product_name).click()
self.repository.update(repo_name, new_url=FAKE_2_YUM_REPO)
url_text = self.repository.wait_until_element(locator).text
self.assertEqual(url_text, FAKE_2_YUM_REPO)
@run_only_on('sat')
@data(*generate_strings_list())
def test_positive_update_2(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)
locator = locators["repo.fetch_gpgkey"]
# Create two new GPGKey's
gpgkey_1_name = entities.GPGKey(content=key_1_content,
organization=self.org_id,
location=self.loc_id).create()['name']
gpgkey_2_name = entities.GPGKey(content=key_2_content,
organization=self.org_id,
location=self.loc_id).create()['name']
# Creates new product
product_name = entities.Product(organization=self.org_id,
location=self.loc_id).create()['name']
with Session(self.browser) as session:
make_repository(session,
org=self.org_name,
loc=self.loc_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.repository.search(repo_name).click()
self.repository.wait_for_ajax()
gpgkey_1_text = self.repository.wait_until_element(locator).text
self.assertEqual(gpgkey_1_text, 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)
gpgkey_2_text = self.repository.wait_until_element(locator).text
self.assertEqual(gpgkey_2_text, gpgkey_2_name)
@run_only_on('sat')
@data(*generate_strings_list())
def test_positive_update_3(self, repo_name):
"""@Test: Update content repository with new checksum type
@Feature: Content Repo - Positive Update of checksum type.
@Assert: Repo is updated with new checksum type.
"""
locator = locators["repo.fetch_checksum"]
checksum_default = CHECKSUM_TYPE['default']
checksum_update = CHECKSUM_TYPE['sha1']
# Creates new product
product_name = entities.Product(organization=self.org_id,
location=self.loc_id).create()['name']
with Session(self.browser) as session:
make_repository(session,
org=self.org_name,
loc=self.loc_name,
name=repo_name,
product=product_name,
url=FAKE_1_YUM_REPO)
self.assertIsNotNone(self.repository.search(repo_name))
self.repository.search(repo_name).click()
self.repository.wait_for_ajax()
checksum_text = self.repository.wait_until_element(locator).text
self.assertEqual(checksum_text, checksum_default)
self.navigator.go_to_products()
self.products.search(product_name).click()
self.repository.update(repo_name,
new_repo_checksum=checksum_update)
checksum_text = self.repository.wait_until_element(locator).text
self.assertEqual(checksum_text, checksum_update)
@run_only_on('sat')
@data(*generate_strings_list())
def test_remove_repo(self, repo_name):
"""@Test: Create content repository and remove it
@Feature: Content Repos - Positive Delete
@Assert: Repos is Deleted
"""
# Creates new product
product_name = entities.Product(organization=self.org_id,
location=self.loc_id).create()['name']
with Session(self.browser) as session:
make_repository(session,
org=self.org_name,
loc=self.loc_name,
name=repo_name,
product=product_name,
url=FAKE_1_YUM_REPO)
self.assertIsNotNone(self.repository.search(repo_name))
self.repository.delete(repo_name)
self.assertIsNone(self.repository.search(repo_name))
@run_only_on('sat')
def test_discover_repo_1(self):
"""@Test: Create repository via repo-discovery under existing product
@Feature: Content Repos - Discover repo via http URL
@Assert: Repos is discovered and created
"""
discovered_urls = "fakerepo01/"
product_name = entities.Product(organization=self.org_id,
location=self.loc_id).create()['name']
with Session(self.browser) as session:
session.nav.go_to_select_org(self.org_name)
session.nav.go_to_products()
self.repository.discover_repo(url_to_discover=REPO_DISCOVERY_URL,
discovered_urls=[discovered_urls],
product=product_name)
@run_only_on('sat')
def test_discover_repo_2(self):
"""@Test: Create repository via repo discovery under new product
@Feature: Content Repos - Discover repo via http URL
@Assert: Repos is discovered and created
"""
product_name = gen_string("alpha", 8)
discovered_urls = "fakerepo01/"
with Session(self.browser) as session:
session.nav.go_to_select_org(self.org_name)
session.nav.go_to_select_loc(self.loc_name)
session.nav.go_to_products()
self.repository.discover_repo(url_to_discover=REPO_DISCOVERY_URL,
discovered_urls=[discovered_urls],
product=product_name,
new_product=True)
self.assertIsNotNone(self.products.search(product_name))
@run_only_on('sat')
@data(*generate_strings_list())
def test_syncnow_custom_repos_1(self, repository_name):
"""@Test: Create Custom yum repos and sync it via the repos page.
@Feature: Custom yum Repos - Sync via repos page
@Assert: Whether Sync is successful
"""
# Creates new product
product_attrs = entities.Product(organization=self.org_id).create()
# Creates new repository
entities.Repository(name=repository_name,
url=FAKE_1_YUM_REPO,
product=product_attrs['id']).create()
with Session(self.browser) as session:
self.setup_navigate_syncnow(session, product_attrs['name'],
repository_name)
# prd_sync_is_ok returns boolean values and not objects
self.assertTrue(self.prd_sync_is_ok(repository_name))
@run_only_on('sat')
@data(*generate_strings_list())
def test_syncnow_custom_repos_2(self, repository_name):
"""@Test: Create Custom puppet repos and sync it via the repos page.
@Feature: Custom puppet Repos - Sync via repos page
@Assert: Whether Sync is successful
"""
# Creates new product
product_attrs = entities.Product(organization=self.org_id).create()
# Creates new puppet repository
entities.Repository(
name=repository_name,
url=FAKE_0_PUPPET_REPO,
product=product_attrs['id'],
content_type=REPO_TYPE['puppet'],
).create()
with Session(self.browser) as session:
self.setup_navigate_syncnow(session, product_attrs['name'],
repository_name)
# prd_sync_is_ok returns boolean values and not objects
self.assertTrue(self.prd_sync_is_ok(repository_name))
@run_only_on('sat')
@skip_if_bug_open('bugzilla', 1167837)
@data(
gen_string('alpha', 8).lower(), gen_string('numeric', 8),
gen_string('alphanumeric', 8).lower(), gen_string('html', 8),
gen_string('utf8', 8))
def test_syncnow_custom_repos_3(self, repository_name):
"""@Test: Create Custom docker repos and sync it via the repos page.
@Feature: Custom docker Repos - Sync via repos page
@Assert: Whether Sync is successful
"""
# Creates new product
product_attrs = entities.Product(organization=self.org_id).create()
# Creates new puppet repository
entities.Repository(
name=repository_name,
url=DOCKER_REGISTRY_HUB,
product=product_attrs['id'],
content_type=REPO_TYPE['docker'],
).create()
with Session(self.browser) as session:
self.setup_navigate_syncnow(session, product_attrs['name'],
repository_name)
# prd_sync_is_ok returns boolean values and not objects
self.assertTrue(self.prd_sync_is_ok(repository_name))
class Subnet(UITestCase):
"""Implements Subnet tests in UI"""
@data(*generate_strings_list(len1=8))
def test_create_subnet_1(self, name):
"""@Test: Create new subnet
@Feature: Subnet - Positive Create
@Assert: Subnet is created
"""
network = gen_ipaddr(ip3=True)
mask = gen_netmask()
with Session(self.browser) as session:
make_subnet(session,
subnet_name=name,
subnet_network=network,
subnet_mask=mask)
self.assertIsNotNone(self.subnet.search_subnet(subnet_name=name))
@skip_if_bug_open('bugzilla', 1123815)
@data({'name': gen_string('alphanumeric', 255)},
{'name': gen_string('alpha', 255)},
{'name': gen_string('numeric', 255)},
{'name': gen_string('latin1', 255)}, {
'name': gen_string('utf8', 255),
u'bz-bug': 1180066
})
def test_create_subnet_2(self, test_data):
"""@Test: Create new subnet with 255 characters in name
@Feature: Subnet - Positive Create
@Assert: Subnet is created with 255 chars
"""
bug_id = test_data.pop('bz-bug', None)
if bug_id is not None and bz_bug_is_open(bug_id):
self.skipTest('Bugzilla bug {0} is open.'.format(bug_id))
network = gen_ipaddr(ip3=True)
mask = gen_netmask()
with Session(self.browser) as session:
make_subnet(session,
subnet_name=test_data['name'],
subnet_network=network,
subnet_mask=mask)
self.assertIsNotNone(
self.subnet.search_subnet(subnet_name=test_data['name']))
def test_create_subnet_3(self):
"""@Test: Create new subnet and associate domain with it
@Feature: Subnet - Positive Create
@Assert: Subnet is created with domain associated
"""
strategy1, value1 = common_locators["entity_deselect"]
strategy2, value2 = common_locators["entity_checkbox"]
name = gen_string("alpha", 4)
network = gen_ipaddr(ip3=True)
mask = gen_netmask()
domain_name = entities.Domain().create()['name']
with Session(self.browser) as session:
make_subnet(session,
subnet_name=name,
subnet_network=network,
subnet_mask=mask,
domains=[domain_name])
self.assertIsNotNone(self.subnet.search_subnet(subnet_name=name))
session.nav.search_entity(name,
locators['subnet.display_name']).click()
session.nav.wait_until_element(
tab_locators["subnet.tab_domain"]).click()
element = session.nav.wait_until_element(
(strategy1, value1 % domain_name))
checkbox_element = session.nav.wait_until_element(
(strategy2, value2 % domain_name))
# Depending upon the number of domains either, checkbox or
# selection list appears.
if element:
self.assertIsNotNone(element)
elif checkbox_element:
self.assertTrue(checkbox_element.is_selected())
else:
self.assertIsNotNone()
@skip_if_bug_open('bugzilla', 1123815)
@data(*generate_strings_list(len1=256))
def test_create_subnet_negative_1(self, name):
"""@Test: Create new subnet with 256 characters in name
@Feature: Subnet - Negative Create
@Assert: Subnet is not created with 256 chars
"""
locator = common_locators["haserror"]
network = gen_ipaddr(ip3=True)
mask = gen_netmask()
with Session(self.browser) as session:
make_subnet(session,
subnet_name=name,
subnet_network=network,
subnet_mask=mask)
error_element = session.nav.wait_until_element(locator)
self.assertIsNotNone(error_element)
@data("", " ")
def test_create_subnet_negative_2(self, name):
"""@Test: Create new subnet with whitespace and blank in name.
@Feature: Subnet - Negative Create.
@Assert: Subnet is not created.
"""
locator = common_locators["haserror"]
network = gen_ipaddr(ip3=True)
mask = gen_netmask()
with Session(self.browser) as session:
make_subnet(session,
subnet_name=name,
subnet_network=network,
subnet_mask=mask)
error_element = session.nav.wait_until_element(locator)
self.assertIsNotNone(error_element)
def test_create_subnet_negative_4(self):
"""@Test: Create new subnet with negative values
@Feature: Subnet - Negative Create.
@Assert: Subnet is not created with negative values
"""
name = gen_string("alpha", 8)
network = "292.256.256.0"
mask = "292.292.292.0"
gateway = "292.256.256.254"
primarydns = "292.256.256.2"
secondarydns = "292.256.256.3"
with Session(self.browser) as session:
make_subnet(session,
subnet_name=name,
subnet_network=network,
subnet_mask=mask,
subnet_gateway=gateway,
subnet_primarydns=primarydns,
subnet_secondarydns=secondarydns)
network_element = session.nav.wait_until_element(
locators["subnet.network_haserror"])
mask_element = session.nav.wait_until_element(
locators["subnet.mask_haserror"])
gateway_element = session.nav.wait_until_element(
locators["subnet.gateway_haserror"])
primarydns_element = session.nav.wait_until_element(
locators["subnet.dnsprimary_haserror"])
secondarydns_element = session.nav.wait_until_element(
locators["subnet.dnssecondary_haserror"])
self.assertIsNotNone(network_element)
self.assertIsNotNone(mask_element)
self.assertIsNotNone(gateway_element)
self.assertIsNotNone(primarydns_element)
self.assertIsNotNone(secondarydns_element)
@data(*generate_strings_list(len1=8))
def test_remove_subnet_1(self, name):
"""@Test: Delete a subnet
@Feature: Subnet - Positive Delete
@Assert: Subnet is deleted
"""
network = gen_ipaddr(ip3=True)
mask = gen_netmask()
with Session(self.browser) as session:
make_subnet(session,
subnet_name=name,
subnet_network=network,
subnet_mask=mask)
self.subnet.delete(name, True)
self.assertIsNone(
self.subnet.search_subnet(subnet_name=name, timeout=5))
@data(*generate_strings_list(len1=8))
def test_remove_subnet_2(self, name):
"""@Test: Delete subnet.
Attempt to delete subnet but cancel in the confirmation dialog box.
@Feature: Subnet - Negative Delete
@Assert: Subnet is not deleted
"""
network = gen_ipaddr(ip3=True)
mask = gen_netmask()
with Session(self.browser) as session:
make_subnet(session,
subnet_name=name,
subnet_network=network,
subnet_mask=mask)
self.subnet.delete(name, False)
self.assertIsNotNone(
self.subnet.search_subnet(subnet_name=name, timeout=5))
@data(*generate_strings_list(len1=8))
def test_update_subnet_1(self, name):
"""@Test: Update Subnet name
@Feature: Subnet - Positive Update
@Assert: Subnet name is updated
"""
network = gen_ipaddr(ip3=True)
mask = gen_netmask()
new_name = gen_string("alpha", 10)
with Session(self.browser) as session:
make_subnet(session,
subnet_name=name,
subnet_network=network,
subnet_mask=mask)
self.subnet.update(name, new_subnet_name=new_name)
result_object = self.subnet.search_subnet(new_name)
self.assertEqual(new_name, result_object['name'])
@data(*generate_strings_list(len1=8))
def test_update_subnet_2(self, name):
"""@Test: Update Subnet network
@Feature: Subnet - Positive Update
@Assert: Subnet network is updated
"""
network = gen_ipaddr(ip3=True)
mask = gen_netmask()
new_network = gen_ipaddr(ip3=True)
with Session(self.browser) as session:
make_subnet(session,
subnet_name=name,
subnet_network=network,
subnet_mask=mask)
self.subnet.update(name, new_subnet_network=new_network)
result_object = self.subnet.search_subnet(name)
self.assertEqual(new_network, result_object['network'])
@data(*generate_strings_list(len1=8))
def test_update_subnet_3(self, name):
"""@Test: Update Subnet mask
@Feature: Subnet - Positive Update
@Assert: Subnet mask is updated
"""
network = gen_ipaddr(ip3=True)
mask = gen_netmask(1, 15)
new_mask = gen_netmask(16, 31)
with Session(self.browser) as session:
make_subnet(session,
subnet_name=name,
subnet_network=network,
subnet_mask=mask)
self.subnet.update(name, new_subnet_mask=new_mask)
result_object = self.subnet.search_subnet(name)
self.assertEqual(new_mask, result_object['mask'])
@data(*generate_strings_list(len1=8))
def test_search_subnet_1(self, name):
"""@Test: Search Subnet with Subnet name
@Feature: Subnet - Positive Search
@Assert: Subnet is found
"""
network = gen_ipaddr(ip3=True)
mask = gen_netmask()
with Session(self.browser) as session:
make_subnet(session,
subnet_name=name,
subnet_network=network,
subnet_mask=mask)
result_object = self.subnet.search_subnet(name)
self.assertEqual(name, result_object['name'])
self.assertEqual(network, result_object['network'])
self.assertEqual(mask, result_object['mask'])
def test_end_to_end(self):
"""@Test: Perform end to end smoke tests using RH repos.
1. Create new organization and environment
2. Upload manifest
3. Sync a RedHat repository
4. Create content-view
5. Add repository to contet-view
6. Promote/publish content-view
7. Create an activation-key
8. Add product to activation-key
9. Create new virtualmachine
10. Pull rpm from Foreman server and install on client
11. Register client with foreman server using activation-key
12. Install rpm on client
@Feature: Smoke test
@Assert: All tests should succeed and Content should be successfully
fetched by client
"""
# Product, RepoSet and repository variables
rhel_product_name = 'Red Hat Enterprise Linux Server'
rhel_repo_set = (
'Red Hat Enterprise Virtualization Agents '
'for RHEL 6 Server (RPMs)'
)
rhel_repo_name = (
'Red Hat Enterprise Virtualization Agents '
'for RHEL 6 Server '
'RPMs x86_64 6Server'
)
org_name = random.choice(generate_strings_list())
# Create new org and environment
new_org = make_org({u'name': org_name})
new_env = make_lifecycle_environment({
u'organization-id': new_org['id'],
u'name': gen_alphanumeric(),
})
# Clone manifest and upload it
manifest = manifests.clone()
upload_file(manifest, remote_file=manifest)
result = Subscription.upload({
u'file': manifest,
u'organization-id': new_org['id'],
})
self.assertEqual(
result.return_code, 0,
"Failed to upload manifest: {0} and return code: {1}"
.format(result.stderr, result.return_code)
)
# Enable repo from Repository Set
result = RepositorySet.enable({
u'name': rhel_repo_set,
u'organization-id': new_org['id'],
u'product': rhel_product_name,
u'releasever': '6Server',
u'basearch': 'x86_64',
})
self.assertEqual(
result.return_code, 0,
"Repo was not enabled: {0} and return code: {1}"
.format(result.stderr, result.return_code)
)
# Fetch repository info
result = Repository.info({
u'name': rhel_repo_name,
u'product': rhel_product_name,
u'organization-id': new_org['id'],
})
rhel_repo = result.stdout
# Synchronize the repository
result = Repository.synchronize({
u'name': rhel_repo_name,
u'organization-id': new_org['id'],
u'product': rhel_product_name,
})
self.assertEqual(
result.return_code, 0,
"Repo was not synchronized: {0} and return code: {1}"
.format(result.stderr, result.return_code)
)
# Create CV and associate repo to it
new_cv = make_content_view({u'organization-id': new_org['id']})
result = ContentView.add_repository({
u'id': new_cv['id'],
u'repository-id': rhel_repo['id'],
u'organization-id': new_org['id'],
})
self.assertEqual(
result.return_code, 0,
"Failed repository association: {0} and return code: {1}"
.format(result.stderr, result.return_code)
)
# Publish a version1 of CV
result = ContentView.publish({u'id': new_cv['id']})
self.assertEqual(
result.return_code, 0,
"Version1 publishing failed: {0} and return code: {1}"
.format(result.stderr, result.return_code)
)
# Get the CV info
result = ContentView.info({u'id': new_cv['id']})
self.assertEqual(
result.return_code, 0,
"ContentView was not found: {0} and return code: {1}"
.format(result.stderr, result.return_code)
)
# Store the version1 id
version1_id = result.stdout['versions'][0]['id']
# Promotion of version1 to next env
result = ContentView.version_promote({
u'id': version1_id,
u'to-lifecycle-environment-id': new_env['id'],
})
self.assertEqual(
result.return_code, 0,
"version1 promotion failed: {0} and return code: {1}"
.format(result.stderr, result.return_code)
)
# Create activation key
activation_key = make_activation_key({
u'name': gen_alphanumeric(),
u'lifecycle-environment-id': new_env['id'],
u'organization-id': new_org['id'],
u'content-view': new_cv['name'],
})
# List the subscriptions in given org
result = Subscription.list(
{u'organization-id': new_org['id']},
per_page=False
)
self.assertEqual(
result.return_code, 0,
"Failed to list subscriptions: {0} and return code: {1}"
.format(result.stderr, result.return_code)
)
# Get the subscription ID from subscriptions list
for subscription in result.stdout:
if subscription['name'] == "Red Hat Employee Subscription":
subscription_id = subscription['id']
subscription_quantity = int(subscription['quantity'])
self.assertGreater(
int(subscription_quantity), 0,
'Unexpected subscription quantity {0}'
.format(subscription_quantity)
)
# Add the subscriptions to activation-key
result = ActivationKey.add_subscription({
u'id': activation_key['id'],
u'subscription-id': subscription_id,
u'quantity': 1,
})
self.assertEqual(
result.return_code, 0,
"Failed to add subscription: {0} and return code: {1}"
.format(result.stderr, result.return_code)
)
# Create VM
package_name = "python-kitchen"
server_name = conf.properties['main.server.hostname']
with VirtualMachine(distro='rhel65') as vm:
# Download and Install rpm
result = vm.run(
"wget -nd -r -l1 --no-parent -A '*.noarch.rpm' http://{0}/pub/"
.format(server_name)
)
self.assertEqual(
result.return_code, 0,
"failed to fetch katello-ca rpm: {0}, return code: {1}"
.format(result.stderr, result.return_code)
)
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(activation_key['name'], new_org['label'])
)
self.assertEqual(
result.return_code, 0,
"failed to register client:: {0} and return code: {1}"
.format(result.stderr, result.return_code)
)
# 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.assertIn(package_name, result.stdout[0])
class ComputeResource(UITestCase):
"""Implements Compute Resource tests in UI"""
@data(*generate_strings_list(len1=8))
def test_create_resource_1(self, name):
"""@Test: Create a new libvirt Compute Resource
@Feature: Compute Resource - Create
@Assert: A libvirt Compute Resource is created
"""
libvirt_url = "qemu+tcp://%s:16509/system"
provider_type = FOREMAN_PROVIDERS['libvirt']
url = (libvirt_url % conf.properties['main.server.hostname'])
with Session(self.browser) as session:
make_resource(session,
name=name,
provider_type=provider_type,
url=url)
search = self.compute_resource.search(name)
self.assertIsNotNone(search)
@data(gen_string('alphanumeric', 255), gen_string('alpha', 255),
gen_string('numeric', 255), gen_string('latin1', 255),
gen_string('utf8', 255))
def test_create_resource_2(self, name):
"""@Test: Create a new libvirt Compute Resource with 255 char name
@Feature: Compute Resource - Create
@Assert: A libvirt Compute Resource is created
"""
libvirt_url = "qemu+tcp://%s:16509/system"
provider_type = FOREMAN_PROVIDERS['libvirt']
url = (libvirt_url % conf.properties['main.server.hostname'])
with Session(self.browser) as session:
make_resource(session,
name=name,
provider_type=provider_type,
url=url)
search = self.compute_resource.search(name)
self.assertIsNotNone(search)
@data(gen_string('alphanumeric', 255), gen_string('alpha', 255),
gen_string('numeric', 255), gen_string('latin1', 255),
gen_string('utf8', 255))
def test_create_resource_3(self, description):
"""@Test: Create libvirt Compute Resource with 255 char description.
@Feature: Compute Resource - Create with long description.
@Assert: A libvirt Compute Resource is not created with 255 char
description.
"""
name = gen_string("alpha", 8)
libvirt_url = "qemu+tcp://%s:16509/system"
provider_type = FOREMAN_PROVIDERS['libvirt']
url = (libvirt_url % conf.properties['main.server.hostname'])
with Session(self.browser) as session:
make_resource(session,
name=name,
description=description,
provider_type=provider_type,
url=url)
search = self.compute_resource.search(name)
self.assertIsNotNone(search)
@data(*generate_strings_list(len1=256))
def test_create_resource_negative_1(self, name):
"""@Test: Create a new libvirt Compute Resource with 256 char name
@Feature: Compute Resource - Create
@Assert: A libvirt Compute Resource is not created
"""
libvirt_url = "qemu+tcp://%s:16509/system"
provider_type = FOREMAN_PROVIDERS['libvirt']
url = (libvirt_url % conf.properties['main.server.hostname'])
with Session(self.browser) as session:
make_resource(session,
name=name,
provider_type=provider_type,
url=url)
self.assertIsNotNone(
self.compute_resource.wait_until_element(
common_locators["name_haserror"]))
@data(*generate_strings_list(len1=256))
def test_create_resource_negative_2(self, description):
"""@Test: Create libvirt Compute Resource with 256 char description.
@Feature: Compute Resource - Create with long description.
@Assert: A libvirt Compute Resource is not created with 256 char
description.
"""
name = gen_string("alpha", 8)
libvirt_url = "qemu+tcp://%s:16509/system"
provider_type = FOREMAN_PROVIDERS['libvirt']
url = (libvirt_url % conf.properties['main.server.hostname'])
with Session(self.browser) as session:
make_resource(session,
name=name,
description=description,
provider_type=provider_type,
url=url)
error_element = session.nav.wait_until_element(
common_locators["haserror"])
self.assertIsNotNone(error_element)
@data("", " ")
def test_create_resource_negative_3(self, name):
"""@Test: Create a new libvirt Compute Resource with whitespace
@Feature: Compute Resource - Create
@Assert: A libvirt Compute Resource is not created
"""
libvirt_url = "qemu+tcp://%s:16509/system"
provider_type = FOREMAN_PROVIDERS['libvirt']
url = (libvirt_url % conf.properties['main.server.hostname'])
with Session(self.browser) as session:
make_resource(session,
name=name,
provider_type=provider_type,
url=url)
error_element = session.nav.wait_until_element(
common_locators["name_haserror"])
self.assertIsNotNone(error_element)
@data({
'name': gen_string('alpha'),
'newname': gen_string('alpha')
}, {
'name': gen_string('numeric'),
'newname': gen_string('numeric')
}, {
'name': gen_string('alphanumeric'),
'newname': gen_string('alphanumeric')
}, {
'name': gen_string('utf8'),
'newname': gen_string('utf8')
}, {
'name': gen_string('latin1'),
'newname': gen_string('latin1')
}, {
'name': gen_string('html'),
'newname': gen_string('html')
})
def test_update_resource(self, testdata):
"""@Test: Update a libvirt Compute Resource's Organization
@Feature: Compute Resource - Update
@Assert: The libvirt Compute Resource is updated
"""
name = testdata['name']
newname = testdata['newname']
org_name1 = entities.Organization(
name=gen_string("alpha", 8)).create_json()['name']
org_name2 = entities.Organization(
name=gen_string("alpha", 8)).create_json()['name']
libvirt_url = "qemu+tcp://%s:16509/system"
provider_type = FOREMAN_PROVIDERS['libvirt']
url = (libvirt_url % conf.properties['main.server.hostname'])
with Session(self.browser) as session:
make_resource(session,
name=name,
orgs=[org_name1],
provider_type=provider_type,
url=url,
org_select=True)
search = self.compute_resource.search(name)
self.assertIsNotNone(search)
self.compute_resource.update(name,
newname, [org_name1], [org_name2],
libvirt_set_passwd=False)
search = self.compute_resource.search(newname)
self.assertIsNotNone(search)
@data(*generate_strings_list(len1=8))
def test_remove_resource(self, name):
"""@Test: Delete a Compute Resource
@Feature: Compute Resource - Delete
@Assert: The Compute Resource is deleted
"""
libvirt_url = "qemu+tcp://%s:16509/system"
provider_type = FOREMAN_PROVIDERS['libvirt']
url = (libvirt_url % conf.properties['main.server.hostname'])
with Session(self.browser) as session:
make_resource(session,
name=name,
provider_type=provider_type,
url=url)
search = self.compute_resource.search(name)
self.assertIsNotNone(search)
self.compute_resource.delete(name, really=True)
self.assertIsNone(self.compute_resource.search(name))
def test_end_to_end(self):
"""@Test: Perform end to end smoke tests using RH repos.
1. Create new organization and environment
2. Upload manifest
3. Sync a RedHat repository
4. Create content-view
5. Add repository to contet-view
6. Promote/publish content-view
7. Create an activation-key
8. Add product to activation-key
9. Create new virtualmachine
10. Pull rpm from Foreman server and install on client
11. Register client with foreman server using activation-key
12. Install rpm on client
@Feature: Smoke test
@Assert: All tests should succeed and Content should be successfully
fetched by client
"""
# Product, RepoSet and repository variables
rhel_product_name = 'Red Hat Enterprise Linux Server'
rhel_repo_set = (
'Red Hat Enterprise Virtualization Agents '
'for RHEL 6 Server (RPMs)'
)
rhel_repo_name = (
'Red Hat Enterprise Virtualization Agents '
'for RHEL 6 Server '
'RPMs x86_64 6Server'
)
org_name = random.choice(generate_strings_list())
# Create new org and environment
new_org = make_org({u'name': org_name})
new_env = make_lifecycle_environment({
u'organization-id': new_org['id'],
u'name': gen_alphanumeric(),
})
# Clone manifest and upload it
manifest = manifests.clone()
upload_file(manifest, remote_file=manifest)
result = Subscription.upload({
u'file': manifest,
u'organization-id': new_org['id'],
})
self.assertEqual(
result.return_code, 0,
"Failed to upload manifest: {0} and return code: {1}"
.format(result.stderr, result.return_code)
)
# Enable repo from Repository Set
result = RepositorySet.enable({
u'name': rhel_repo_set,
u'organization-id': new_org['id'],
u'product': rhel_product_name,
u'releasever': '6Server',
u'basearch': 'x86_64',
})
self.assertEqual(
result.return_code, 0,
"Repo was not enabled: {0} and return code: {1}"
.format(result.stderr, result.return_code)
)
# Fetch repository info
result = Repository.info({
u'name': rhel_repo_name,
u'product': rhel_product_name,
u'organization-id': new_org['id'],
})
rhel_repo = result.stdout
# Synchronize the repository
result = Repository.synchronize({
u'name': rhel_repo_name,
u'organization-id': new_org['id'],
u'product': rhel_product_name,
})
self.assertEqual(
result.return_code, 0,
"Repo was not synchronized: {0} and return code: {1}"
.format(result.stderr, result.return_code)
)
# Create CV and associate repo to it
new_cv = make_content_view({u'organization-id': new_org['id']})
result = ContentView.add_repository({
u'id': new_cv['id'],
u'repository-id': rhel_repo['id'],
u'organization-id': new_org['id'],
})
self.assertEqual(
result.return_code, 0,
"Failed repository association: {0} and return code: {1}"
.format(result.stderr, result.return_code)
)
# Publish a version1 of CV
result = ContentView.publish({u'id': new_cv['id']})
self.assertEqual(
result.return_code, 0,
"Version1 publishing failed: {0} and return code: {1}"
.format(result.stderr, result.return_code)
)
# Get the CV info
result = ContentView.info({u'id': new_cv['id']})
self.assertEqual(
result.return_code, 0,
"ContentView was not found: {0} and return code: {1}"
.format(result.stderr, result.return_code)
)
# Store the version1 id
version1_id = result.stdout['versions'][0]['id']
# Promotion of version1 to next env
result = ContentView.version_promote({
u'id': version1_id,
u'to-lifecycle-environment-id': new_env['id'],
})
self.assertEqual(
result.return_code, 0,
"version1 promotion failed: {0} and return code: {1}"
.format(result.stderr, result.return_code)
)
# Create activation key
activation_key = make_activation_key({
u'name': gen_alphanumeric(),
u'lifecycle-environment-id': new_env['id'],
u'organization-id': new_org['id'],
u'content-view': new_cv['name'],
})
# List the subscriptions in given org
result = Subscription.list(
{u'organization-id': new_org['id']},
per_page=False
)
self.assertEqual(
result.return_code, 0,
"Failed to list subscriptions: {0} and return code: {1}"
.format(result.stderr, result.return_code)
)
# Get the subscription ID from subscriptions list
for subscription in result.stdout:
if subscription['name'] == "Red Hat Employee Subscription":
subscription_id = subscription['id']
subscription_quantity = int(subscription['quantity'])
self.assertGreater(
int(subscription_quantity), 0,
'Unexpected subscription quantity {0}'
.format(subscription_quantity)
)
# Add the subscriptions to activation-key
result = ActivationKey.add_subscription({
u'id': activation_key['id'],
u'subscription-id': subscription_id,
u'quantity': 1,
})
self.assertEqual(
result.return_code, 0,
"Failed to add subscription: {0} and return code: {1}"
.format(result.stderr, result.return_code)
)
# Create VM
package_name = "python-kitchen"
server_name = conf.properties['main.server.hostname']
with VirtualMachine(distro='rhel66') as vm:
# Download and Install rpm
result = vm.run(
"wget -nd -r -l1 --no-parent -A '*.noarch.rpm' http://{0}/pub/"
.format(server_name)
)
self.assertEqual(
result.return_code, 0,
"failed to fetch katello-ca rpm: {0}, return code: {1}"
.format(result.stderr, result.return_code)
)
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(activation_key['name'], new_org['label'])
)
self.assertEqual(
result.return_code, 0,
"failed to register client:: {0} and return code: {1}"
.format(result.stderr, result.return_code)
)
# Enable Red Hat Enterprise Virtualization Agents repo via cli
# As the below repo is disabled by default under ak's prd-content
result = vm.run(
'subscription-manager repos --enable '
'rhel-6-server-rhev-agent-rpms'
)
self.assertEqual(
result.return_code, 0,
"Enabling repo failed: {0} and return code: {1}"
.format(result.stderr, result.return_code)
)
# 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.assertIn(package_name, result.stdout[0])
class PartitionTable(UITestCase):
"""Implements the partition table tests from UI"""
@data(*generate_strings_list(len1=10))
def test_positive_create_partition_table(self, name):
"""@Test: Create a new partition table
@Feature: Partition table - Positive Create
@Assert: Partition table is created
"""
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))
@data(*generate_strings_list(len1=256))
def test_negative_create_partition_table_1(self, name):
"""@Test: Create a new partition table with 256 characters in name
@Feature: Partition table - Negative Create
@Assert: Partition table is not created
"""
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.wait_until_element(
common_locators["name_haserror"]))
self.assertIsNone(self.partitiontable.search(name))
@data("", " ")
def test_negative_create_partition_table_2(self, name):
"""@Test: Create partition table with blank and whitespace in name
@Feature: Partition table - Negative Create
@Assert: Partition table is not created
"""
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.wait_until_element(
common_locators["name_haserror"]))
@data(*generate_strings_list(len1=10))
def test_negative_create_partition_table_3(self, name):
"""@Test: Create a new partition table with same name
@Feature: Partition table - Negative Create
@Assert: Partition table is not created
"""
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"]))
@data(*generate_strings_list(len1=10))
def test_negative_create_partition_table_4(self, name):
"""@Test: Create a new partition table with empty layout
@Feature: Partition table - Negative Create
@Assert: Partition table is not created
"""
layout = ""
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.wait_until_element(
common_locators["haserror"]))
self.assertIsNone(self.partitiontable.search(name))
@skip_if_bug_open('bugzilla', 1177591)
@data(*generate_strings_list(len1=10))
def test_remove_partition_table(self, name):
"""@Test: Delete a partition table
@Feature: Partition table - Positive Delete
@Assert: Partition table is deleted
"""
layout = "test layout"
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))
self.partitiontable.delete(name, really=True)
self.assertIsNotNone(
self.partitiontable.wait_until_element(
common_locators["notif.success"]))
self.assertIsNone(self.partitiontable.search(name))
@data({
u'name': gen_string('alpha'),
u'new_name': gen_string('alpha')
}, {
u'name': gen_string('html'),
u'new_name': gen_string('html')
}, {
u'name': gen_string('utf8'),
u'new_name': gen_string('utf8')
}, {
u'name': gen_string('alphanumeric'),
u'new_name': gen_string('alphanumeric')
})
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
"""
layout = "test layout"
new_layout = read_data_file(PARTITION_SCRIPT_DATA_FILE)
os_family = "Debian"
new_os_family = "Red Hat"
with Session(self.browser) as session:
make_partitiontable(session,
name=test_data['name'],
layout=layout,
os_family=os_family)
self.assertIsNotNone(self.partitiontable.search(test_data['name']))
self.partitiontable.update(test_data['name'],
test_data['new_name'], new_layout,
new_os_family)
self.assertIsNotNone(
self.partitiontable.search(test_data['new_name']))
class Repos(BaseUI):
"""
Implements Repos tests in UI
"""
org_name = None
def setUp(self):
super(Repos, self).setUp()
# Make sure to use the Class' org_name instance
if Repos.org_name is None:
Repos.org_name = generate_string("alpha", 8)
with Session(self.browser) as session:
make_org(session, org_name=Repos.org_name)
@attr('ui', 'repo', 'implemented')
@data(*generate_strings_list())
def test_create_repo(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"
self.login.login(self.katello_user, self.katello_passwd)
self.navigator.go_to_select_org(self.org_name)
self.navigator.go_to_products()
self.products.create(prd_name, 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_negative_create_1(self):
"""
@Feature: Content Repos - Negative Create zero length
@Test: Create Content Repos without input parameter
@Assert: Repos is not created
"""
locator = common_locators["common_invalid"]
repo_name = ""
prd_name = generate_string("alpha", 8)
repo_url = "http://inecas.fedorapeople.org/fakerepos/zoo3/"
description = "test 123"
self.login.login(self.katello_user, self.katello_passwd)
self.navigator.go_to_select_org(self.org_name)
self.navigator.go_to_products()
self.products.create(prd_name, description)
self.assertIsNotNone(self.products.search(prd_name))
self.repository.create(repo_name, product=prd_name, url=repo_url)
invalid = self.products.wait_until_element(locator)
self.assertTrue(invalid)
def test_negative_create_2(self):
"""
@Feature: Content Repos - Negative Create with whitespace
@Test: Create Content Repos with whitespace input parameter
@Assert: Repos is not created
"""
locator = common_locators["common_invalid"]
repo_name = " "
prd_name = generate_string("alpha", 8)
repo_url = "http://inecas.fedorapeople.org/fakerepos/zoo3/"
description = "test 123"
self.login.login(self.katello_user, self.katello_passwd)
self.navigator.go_to_select_org(self.org_name)
self.navigator.go_to_products()
self.products.create(prd_name, description)
self.assertIsNotNone(self.products.search(prd_name))
self.repository.create(repo_name, product=prd_name, url=repo_url)
invalid = self.products.wait_until_element(locator)
self.assertTrue(invalid)
@bzbug("1081059")
@attr('ui', 'repo', 'implemented')
@data(*generate_strings_list())
def test_negative_create_3(self, repo_name):
"""
@Feature: Content Repos - Negative Create with same name
@Test: Create Content Repos with same name input parameter
@Assert: Repos is not created
@BZ: 1081059
"""
locator = common_locators["common_invalid"]
prd_name = generate_string("alpha", 8)
repo_url = "http://inecas.fedorapeople.org/fakerepos/zoo3/"
description = "test 123"
self.login.login(self.katello_user, self.katello_passwd)
self.navigator.go_to_select_org(self.org_name)
self.navigator.go_to_products()
self.products.create(prd_name, 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.navigator.go_to_products()
self.repository.create(repo_name, product=prd_name, url=repo_url)
invalid = self.products.wait_until_element(locator)
self.assertTrue(invalid)
@attr('ui', 'repo', 'implemented')
@data(*generate_strings_list(len1=256))
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"
self.login.login(self.katello_user, self.katello_passwd)
self.navigator.go_to_select_org(self.org_name)
self.navigator.go_to_products()
self.products.create(prd_name, 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)
@attr('ui', 'repo', 'implemented')
@data(*generate_strings_list())
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"
self.login.login(self.katello_user, self.katello_passwd)
self.navigator.go_to_select_org(self.org_name)
self.navigator.go_to_products()
self.products.create(prd_name, 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)
@attr('ui', 'repo', 'implemented')
@data(*generate_strings_list())
def test_positive_update_2(self, repo_name):
"""
@Feature: Content Repo - Positive Update
@Test: Update Content Repo with gpg key
@Assert: Repo is updated with new gpg key
"""
key_path1 = get_data_file(VALID_GPG_KEY_FILE)
key_path2 = get_data_file(VALID_GPG_KEY_BETA_FILE)
prd_name = generate_string("alpha", 8)
gpgkey_name1 = generate_string("alpha", 8)
gpgkey_name2 = generate_string("alpha", 8)
locator = locators["repo.fetch_gpgkey"]
repo_url = "http://inecas.fedorapeople.org/fakerepos/zoo3/"
description = "test 123"
self.login.login(self.katello_user, self.katello_passwd)
self.navigator.go_to_select_org(self.org_name)
self.navigator.go_to_gpg_keys()
self.gpgkey.create(gpgkey_name1, upload_key=True, key_path=key_path1)
self.assertIsNotNone(self.gpgkey.search(gpgkey_name1))
self.gpgkey.create(gpgkey_name2, upload_key=True, key_path=key_path2)
self.assertIsNotNone(self.gpgkey.search(gpgkey_name2))
self.navigator.go_to_products()
self.products.create(prd_name, description)
self.assertIsNotNone(self.products.search(prd_name))
self.repository.create(repo_name,
product=prd_name,
url=repo_url,
gpg_key=gpgkey_name1)
self.assertIsNotNone(self.repository.search(repo_name))
self.repository.search(repo_name).click()
gpgkey_text1 = self.repository.wait_until_element(locator).text
self.assertEqual(gpgkey_text1, gpgkey_name1)
self.navigator.go_to_products()
self.products.search(prd_name).click()
self.repository.update(repo_name, new_gpg_key=gpgkey_name2)
gpgkey_text2 = self.repository.wait_until_element(locator).text
self.assertEqual(gpgkey_text2, gpgkey_name2)
@attr('ui', 'repo', 'implemented')
@data(*generate_strings_list())
def test_remove_repo(self, repo_name):
"""
@Feature: Content Repos - Positive Delete
@Test: Create Content Repos with minimal input parameters
@Assert: Repos is Deleted
"""
prd_name = generate_string("alpha", 8)
repo_url = "http://inecas.fedorapeople.org/fakerepos/zoo3/"
description = "test 123"
self.login.login(self.katello_user, self.katello_passwd)
self.navigator.go_to_select_org(self.org_name)
self.navigator.go_to_products()
self.products.create(prd_name, 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.delete(repo_name)
self.assertIsNone(self.repository.search(repo_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/"]
self.login.login(self.katello_user, self.katello_passwd)
self.navigator.go_to_select_org(self.org_name)
self.navigator.go_to_products()
self.products.create(prd_name)
self.assertIsNotNone(self.products.search(prd_name))
self.repository.discover_repo(url, discovered_urls, product=prd_name)
def test_discover_repo_2(self):
"""
@Feature: Content Repos - Discover repo via http URL
@Test: Create Content Repos via repo discovery under new
product
@Assert: Repos is discovered and created
"""
prd_name = generate_string("alpha", 8)
url = "http://omaciel.fedorapeople.org/"
discovered_urls = ["fakerepo01/"]
self.login.login(self.katello_user, self.katello_passwd)
self.navigator.go_to_select_org(self.org_name)
self.navigator.go_to_products()
self.repository.discover_repo(url,
discovered_urls,
product=prd_name,
new_product=True)
self.assertIsNotNone(self.products.search(prd_name))
class Architecture(UITestCase):
"""Implements Architecture tests from UI"""
@data({
u'name': gen_string('alpha'),
u'os_name': gen_string('alpha')
}, {
u'name': gen_string('html'),
u'os_name': gen_string('html')
}, {
u'name': gen_string('utf8'),
u'os_name': gen_string('utf8')
}, {
u'name': gen_string('alphanumeric'),
u'os_name': gen_string('alphanumeric')
})
def test_positive_create_arch_1(self, test_data):
"""@Test: Create a new Architecture with OS
@Feature: Architecture - Positive Create
@Assert: Architecture is created
"""
entities.OperatingSystem(name=test_data['os_name']).create()
with Session(self.browser) as session:
make_arch(session,
name=test_data['name'],
os_names=[test_data['os_name']])
self.assertIsNotNone(self.architecture.search(test_data['name']))
@data(*generate_strings_list(len1=8))
def test_positive_create_arch_2(self, name):
"""@Test: Create a new Architecture with different data
@Feature: Architecture - Positive Create
@Assert: Architecture is created
"""
with Session(self.browser) as session:
make_arch(session, name=name)
self.assertIsNotNone(self.architecture.search(name))
@data(*generate_strings_list(len1=256))
def test_negative_create_arch_1(self, name):
"""@Test: Create a new Architecture with 256 characters in name
@Feature: Architecture - Negative Create
@Assert: Architecture is not created
"""
with Session(self.browser) as session:
make_arch(session, name=name)
self.assertIsNotNone(
self.architecture.wait_until_element(
common_locators["name_haserror"]))
@data("", " ")
def test_negative_create_arch_2(self, name):
"""@Test: Create a new Architecture with whitespace in name
@Feature: Architecture - Negative Create
@Assert: Architecture is not created
"""
with Session(self.browser) as session:
make_arch(session, name=name)
self.assertIsNotNone(
self.architecture.wait_until_element(
common_locators["name_haserror"]))
@data(*generate_strings_list(len1=6))
def test_negative_create_arch_4(self, name):
"""@Test: Create a new Architecture with same name
@Feature: Architecture - Negative Create
@Assert: Architecture is not created
"""
with Session(self.browser) as session:
make_arch(session, name=name)
self.assertIsNotNone(self.architecture.search(name))
make_arch(session, name=name)
self.assertIsNotNone(
self.architecture.wait_until_element(
common_locators["name_haserror"]))
@skip_if_bug_open('bugzilla', 1123388)
@data({
u'name': gen_string('alpha'),
u'os_name': gen_string('alpha')
}, {
u'name': gen_string('html'),
u'os_name': gen_string('html')
}, {
u'name': gen_string('utf8'),
u'os_name': gen_string('utf8')
}, {
u'name': gen_string('alphanumeric'),
u'os_name': gen_string('alphanumeric')
})
def test_remove_arch(self, test_data):
"""@Test: Delete an existing Architecture
@Feature: Architecture - Delete
@Assert: Architecture is deleted
@BZ: 1131815
"""
entities.OperatingSystem(name=test_data['os_name']).create()
with Session(self.browser) as session:
make_arch(session,
name=test_data['name'],
os_names=[test_data['os_name']])
self.assertIsNotNone(self.architecture.search(test_data['name']))
self.architecture.delete(test_data['name'], True)
self.assertIsNone(self.architecture.search(test_data['name']))
@skip_if_bug_open('bugzilla', 1123388)
@data(
{
u'old_name': gen_string('alpha'),
u'new_name': gen_string('alpha'),
u'os_name': gen_string('alpha')
}, {
u'old_name': gen_string('html'),
u'new_name': gen_string('html'),
u'os_name': gen_string('html')
}, {
u'old_name': gen_string('utf8'),
u'new_name': gen_string('utf8'),
u'os_name': gen_string('utf8')
}, {
u'old_name': gen_string('alphanumeric'),
u'new_name': gen_string('alphanumeric'),
u'os_name': gen_string('alphanumeric')
})
def test_update_arch(self, test_data):
"""@Test: Update Architecture with new name and OS
@Feature: Architecture - Update
@Assert: Architecture is updated
"""
entities.OperatingSystem(name=test_data['os_name']).create()
with Session(self.browser) as session:
make_arch(session, name=test_data['old_name'])
self.assertIsNotNone(
self.architecture.search(test_data['old_name']))
self.architecture.update(test_data['old_name'],
test_data['new_name'],
new_os_names=[test_data['os_name']])
self.assertIsNotNone(
self.architecture.search(test_data['new_name']))
class Org(BaseUI):
"""
Implements Organization tests in UI
"""
# Tests for issues
def test_redmine_4443(self):
"""
@test: Can auto-complete search for an organization by partial name
@feature: Organizations
@assert: Created organization can be auto search by its partial name
@BZ: redmine #4443
"""
org_name = generate_string("alpha", 8)
part_string = org_name[:3]
self.login.login(self.katello_user, self.katello_passwd)
self.navigator.go_to_org()
self.org.create(org_name)
self.navigator.go_to_org()
self.assertIsNotNone(
self.org.auto_complete_search(part_string,
org_name,
search_key='name'))
# Positive Create
@attr('ui', 'org', 'implemented')
@data(*generate_strings_list())
def test_positive_create_1(self, org_name):
"""
@feature: Organizations
@test: Create organization with valid name only
@assert: organization is created, label is auto-generated
"""
self.login.login(self.katello_user, self.katello_passwd)
self.navigator.go_to_org()
self.org.create(org_name)
self.navigator.go_to_org()
self.assertIsNotNone(self.org.search(org_name))
@attr('ui', 'org', 'implemented')
@data(
{
'label': generate_string('alpha', 10),
'name': generate_string('alpha', 10),
'desc': generate_string('alpha', 10)
}, {
'label': generate_string('numeric', 10),
'name': generate_string('numeric', 10),
'desc': generate_string('numeric', 10)
}, {
'label': generate_string('alphanumeric', 10),
'name': generate_string('alphanumeric', 10),
'desc': generate_string('alphanumeric', 10)
}, {
'label': generate_string('alpha', 10),
'name': generate_string('utf8', 10),
'desc': generate_string('utf8', 10)
}, {
'label': generate_string('alpha', 10),
'name': generate_string('latin1', 20),
'desc': generate_string('latin1', 10)
}, {
'label': generate_string('alpha', 10),
'name': generate_string('html', 20),
'desc': generate_string('html', 10)
})
def test_positive_create_2(self, test_data):
"""
@feature: Organizations
@test: Create organization with valid name, label, parent_org, desc
@assert: organization is created
"""
parent = generate_string("alpha", 8)
desc = test_data['desc']
label = test_data['label']
org_name = test_data['name']
self.login.login(self.katello_user, self.katello_passwd)
self.navigator.go_to_org()
# If parent org is not required to be static.
self.org.create(parent)
self.navigator.go_to_org()
self.org.create(org_name, label=label, desc=desc, parent_org=parent)
self.navigator.go_to_org()
self.assertIsNotNone(self.org.search(org_name))
@attr('ui', 'org', 'implemented')
@data(
{
'name': generate_string('alpha', 10),
'label': generate_string('alpha', 10)
}, {
'name': generate_string('numeric', 10),
'label': generate_string('numeric', 10)
}, {
'name': generate_string('alphanumeric', 10),
'label': generate_string('alphanumeric', 10)
})
# As label cannot contain chars other than ascii alpha numerals, '_', '-'.
def test_positive_create_3(self, test_data):
"""
@feature: Organizations
@test: Create organization with valid unmatching name and label only
@assert: organization is created, label does not match name
"""
name_loc = locators["org.name"]
label_loc = locators["org.label"]
org_name = test_data['name']
org_label = test_data['label']
self.login.login(self.katello_user, self.katello_passwd)
self.navigator.go_to_org()
self.org.create(org_name, label=org_label)
self.navigator.go_to_org()
self.org.search(org_name).click()
name = self.org.wait_until_element(name_loc).get_attribute("value")
label = self.org.wait_until_element(label_loc).get_attribute("value")
self.assertNotEqual(name, label)
@attr('ui', 'org', 'implemented')
@data({'data': generate_string('alpha', 10)},
{'data': generate_string('numeric', 10)},
{'data': generate_string('alphanumeric', 10)})
# As label cannot contain chars other than ascii alpha numerals, '_', '-'.
def test_positive_create_4(self, test_data):
"""
@feature: Organizations
@test: Create organization with valid matching name and label only
@assert: organization is created, label matches name
"""
name_loc = locators["org.name"]
label_loc = locators["org.label"]
org_name = org_label = test_data['data']
self.login.login(self.katello_user, self.katello_passwd)
self.navigator.go_to_org()
self.org.create(org_name, label=org_label)
self.navigator.go_to_org()
self.org.search(org_name).click()
name = self.org.wait_until_element(name_loc).get_attribute("value")
label = self.org.wait_until_element(label_loc).get_attribute("value")
self.assertEqual(name, label)
@bzbug("1079482")
@attr('ui', 'org', 'implemented')
@data(
{
'name': generate_string('alpha', 10),
'desc': generate_string('alpha', 10)
}, {
'name': generate_string('numeric', 10),
'desc': generate_string('numeric', 10)
}, {
'name': generate_string('alphanumeric', 10),
'desc': generate_string('alphanumeric', 10)
}, {
'name': generate_string('utf8', 10),
'desc': generate_string('utf8', 10)
}, {
'name': generate_string('latin1', 20),
'desc': generate_string('latin1', 10)
}, {
'name': generate_string('html', 20),
'desc': generate_string('html', 10)
})
def test_positive_create_5(self, test_data):
"""
@feature: Organizations
@test: Create organization with valid name and description only
@assert: organization is created, label is auto-generated
@BZ: 1079482
"""
desc = test_data['desc']
org_name = test_data['name']
label_loc = locators["org.label"]
self.login.login(self.katello_user, self.katello_passwd)
self.navigator.go_to_org()
self.org.create(org_name, desc=desc)
self.navigator.go_to_org()
self.assertIsNotNone(self.org.search(org_name))
self.navigator.go_to_org()
self.org.search(org_name).click()
label_ele = self.org.wait_until_element(label_loc)
label_value = label_ele.get_attribute("value")
self.assertTrue(label_value)
@attr('ui', 'org', 'implemented')
@data(*generate_strings_list(len1=256))
def test_negative_create_0(self, org_name):
"""
@feature: Organizations
@test: Create organization with valid label and description, name is
too long
@assert: organization is not created
"""
self.login.login(self.katello_user, self.katello_passwd)
self.navigator.go_to_org()
self.org.create(org_name)
error = self.org.wait_until_element(common_locators["name_haserror"])
self.assertTrue(error)
def test_negative_create_1(self):
"""
@feature: Organizations
@test: Create organization with valid label and description, name is
blank
@assert: organization is not created
"""
org_name = ""
self.login.login(self.katello_user, self.katello_passwd)
self.navigator.go_to_org()
self.org.create(org_name)
error = self.org.wait_until_element(common_locators["name_haserror"])
self.assertTrue(error)
def test_negative_create_2(self):
"""
@feature: Organizations
@test: Create organization with valid label and description, name is
whitespace
@assert: organization is not created
"""
org_name = " "
self.login.login(self.katello_user, self.katello_passwd)
self.navigator.go_to_org()
self.org.create(org_name)
error = self.org.wait_until_element(common_locators["name_haserror"])
self.assertTrue(error)
@attr('ui', 'org', 'implemented')
@data(*generate_strings_list())
def test_negative_create_3(self, org_name):
"""
@feature: Organizations
@test: Create organization with valid values, then create a new one
with same values.
@assert: organization is not created
"""
self.login.login(self.katello_user, self.katello_passwd)
self.navigator.go_to_org()
self.org.create(org_name)
self.navigator.go_to_org()
self.assertIsNotNone(self.org.search(org_name))
self.org.create(org_name)
error = self.org.wait_until_element(common_locators["name_haserror"])
self.assertTrue(error)
# Positive Delete
@attr('ui', 'org', 'implemented')
@data(*generate_strings_list())
def test_positive_delete_1(self, org_name):
"""
@feature: Organizations
@test: Create organization with valid values then delete it
@assert: organization is deleted
"""
self.login.login(self.katello_user, self.katello_passwd)
self.navigator.go_to_org()
self.org.create(org_name)
self.navigator.go_to_org()
self.assertIsNotNone(self.org.search(org_name))
self.org.remove(org_name, really=True)
self.assertIsNone(self.org.search(org_name))
# Negative Delete
# Positive Update
@attr('ui', 'org', 'implemented')
@data(*generate_strings_list())
def test_positive_update_1(self, new_name):
"""
@feature: Organizations
@test: Create organization with valid values then update its name
@assert: organization name is updated
"""
org_name = generate_string("alpha", 8)
self.login.login(self.katello_user, self.katello_passwd)
self.navigator.go_to_org()
self.org.create(org_name)
self.navigator.go_to_org()
self.assertIsNotNone(self.org.search(org_name))
self.org.update(org_name, new_name)
self.assertIsNotNone(self.org.search(new_name))
# Negative Update
@attr('ui', 'org', 'implemented')
@data(*generate_strings_list())
def test_negative_update_1(self, org_name):
"""
@feature: Organizations
@test: Create organization with valid values then fail to update
its name
@assert: organization name is not updated
"""
self.login.login(self.katello_user, self.katello_passwd)
self.navigator.go_to_org()
self.org.create(org_name)
self.navigator.go_to_org()
self.assertIsNotNone(self.org.search(org_name))
new_name = generate_string("alpha", 256)
self.org.update(org_name, new_name)
error = self.org.wait_until_element(common_locators["name_haserror"])
self.assertTrue(error)
# Miscellaneous
@attr('ui', 'org', 'implemented')
@data(*generate_strings_list())
def test_search_key_1(self, org_name):
"""
@feature: Organizations
@test: Create organization and search/find it
@assert: organization can be found
"""
self.login.login(self.katello_user, self.katello_passwd)
self.navigator.go_to_org()
self.org.create(org_name)
self.navigator.go_to_org()
self.assertIsNotNone(self.org.search(org_name))
# Associations
@bzbug('1076562')
@attr('ui', 'org', 'implemented')
@data(*generate_strings_list())
def test_remove_domain_1(self, domain):
"""
@feature: Organizations
@test: Add a domain to an organization and remove it by organization
name and domain name
@assert: the domain is removed from the organization
@BZ: 1076562
"""
strategy = common_locators["entity_select"][0]
value = common_locators["entity_select"][1]
strategy1 = common_locators["entity_deselect"][0]
value1 = common_locators["entity_deselect"][1]
org_name = generate_string("alpha", 8)
self.login.login(self.katello_user, self.katello_passwd)
self.navigator.go_to_domains()
self.domain.create(domain)
self.assertIsNotNone(self.domain.search(domain))
self.navigator.go_to_org()
self.org.create(org_name, domains=[domain], edit=True)
self.org.search(org_name).click()
self.org.wait_until_element(tab_locators["orgs.tab_domains"]).click()
element = self.org.wait_until_element((strategy1, value1 % domain))
# Item is listed in 'Selected Items' list and not 'All Items' list.
self.assertTrue(element)
self.org.update(org_name, domains=[domain])
self.org.search(org_name).click()
self.org.wait_until_element(tab_locators["orgs.tab_domains"]).click()
element = self.org.wait_until_element((strategy, value % domain))
# Item is listed in 'All Items' list and not 'Selected Items' list.
self.assertTrue(element)
@bzbug('1076562')
@attr('ui', 'org', 'implemented')
@data(*generate_strings_list())
def test_remove_user_3(self, user_name):
"""
@feature: Organizations
@test: Create admin users then add user and remove it
by using the organization name
@assert: The user is added then removed from the organization
@BZ: 1076562
"""
strategy = common_locators["entity_select"][0]
value = common_locators["entity_select"][1]
strategy1 = common_locators["entity_deselect"][0]
value1 = common_locators["entity_deselect"][1]
org_name = generate_string("alpha", 8)
password = generate_string("alpha", 8)
email = generate_email_address()
search_key = "login"
self.login.login(self.katello_user, self.katello_passwd)
self.navigator.go_to_users()
self.user.create(user_name, email, password, password)
self.assertIsNotNone(self.user.search(user_name, search_key))
self.navigator.go_to_org()
self.org.create(org_name, users=[user_name], edit=True)
self.org.search(org_name).click()
self.org.wait_until_element(tab_locators["orgs.tab_users"]).click()
element = self.org.wait_until_element((strategy1, value1 % user_name))
# Item is listed in 'Selected Items' list and not 'All Items' list.
self.assertTrue(element)
self.navigator.go_to_org()
self.org.update(org_name, users=[user_name], new_users=None)
self.org.search(org_name).click()
self.org.wait_until_element(tab_locators["orgs.tab_users"]).click()
element = self.org.wait_until_element((strategy, value % user_name))
# Item is listed in 'All Items' list and not 'Selected Items' list.
self.assertTrue(element)
@bzbug('1076562')
@attr('ui', 'org', 'implemented')
@data(*generate_strings_list())
def test_remove_hostgroup_1(self, host_grp):
"""
@feature: Organizations
@test: Add a hostgroup and remove it by using the organization
name and hostgroup name
@assert: hostgroup is added to organization then removed
@BZ: 1076562
"""
strategy = common_locators["entity_select"][0]
value = common_locators["entity_select"][1]
strategy1 = common_locators["entity_deselect"][0]
value1 = common_locators["entity_deselect"][1]
org_name = generate_string("alpha", 8)
self.login.login(self.katello_user, self.katello_passwd)
self.navigator.go_to_host_groups()
self.hostgroup.create(host_grp)
self.assertIsNotNone(self.hostgroup.search(host_grp))
self.navigator.go_to_org()
self.org.create(org_name, hostgroups=[host_grp], edit=True)
self.org.search(org_name).click()
self.org.wait_until_element(tab_locators["orgs.tab_hostgrps"]).click()
element = self.org.wait_until_element((strategy1, value1 % host_grp))
# Item is listed in 'Selected Items' list and not 'All Items' list.
self.assertTrue(element)
self.navigator.go_to_org()
self.org.update(org_name, hostgroups=[host_grp], new_hostgroups=None)
self.org.search(org_name).click()
self.org.wait_until_element(tab_locators["orgs.tab_hostgrps"]).click()
element = self.org.wait_until_element((strategy, value % host_grp))
# Item is listed in 'All Items' list and not 'Selected Items' list.
self.assertTrue(element)
@unittest.skip(NOT_IMPLEMENTED)
@data("""DATADRIVENGOESHERE
smartproxy name is alpha
smartproxy name is numeric
smartproxy name is alpha_numeric
smartproxy name is utf-8
smartproxy name is latin1
smartproxy name is html
""")
def test_add_smartproxy_1(self, test_data):
"""
@feature: Organizations
@test: Add a smart proxy by using organization name and smartproxy name
@assert: smartproxy is added
@status: manual
"""
pass
@bzbug('1076562')
@attr('ui', 'org', 'implemented')
@data(*generate_strings_list())
def test_add_subnet_1(self, subnet_name):
"""
@feature: Organizations
@test: Add a subnet by using organization name and subnet name
@assert: subnet is added
@BZ: 1076562
"""
strategy = common_locators["entity_deselect"][0]
value = common_locators["entity_deselect"][1]
org_name = generate_string("alpha", 8)
subnet_network = generate_ipaddr(ip3=True)
subnet_mask = "255.255.255.0"
self.login.login(self.katello_user, self.katello_passwd)
self.navigator.go_to_org()
self.org.create(org_name)
self.navigator.go_to_org()
self.assertIsNotNone(self.org.search(org_name))
self.navigator.go_to_subnets()
self.subnet.create(None, subnet_name, subnet_network, subnet_mask)
self.assertIsNotNone(self.subnet.search_subnet(subnet_name))
self.navigator.go_to_org()
self.org.update(org_name, new_subnets=[subnet_name])
self.org.search(org_name).click()
self.org.wait_until_element(tab_locators["orgs.tab_subnets"]).click()
element = self.org.wait_until_element((strategy, value % subnet_name))
self.assertTrue(element)
@bzbug('1076562')
@attr('ui', 'org', 'implemented')
@data(*generate_strings_list())
def test_add_domain_1(self, domain):
"""
@feature: Organizations
@test: Add a domain to an organization
@assert: Domain is added to organization
@BZ: 1076562
"""
strategy = common_locators["entity_deselect"][0]
value = common_locators["entity_deselect"][1]
org_name = generate_string("alpha", 8)
self.login.login(self.katello_user, self.katello_passwd)
self.navigator.go_to_org()
self.org.create(org_name)
self.navigator.go_to_org()
self.assertIsNotNone(self.org.search(org_name))
self.navigator.go_to_domains()
self.domain.create(domain)
self.assertIsNotNone(self.domain.search(domain))
self.navigator.go_to_org()
self.org.update(org_name, new_domains=[domain])
self.org.search(org_name).click()
self.org.wait_until_element(tab_locators["orgs.tab_domains"]).click()
element = self.org.wait_until_element((strategy, value % domain))
self.assertTrue(element)
@bzbug('1076562')
@attr('ui', 'org', 'implemented')
@data(*generate_strings_list())
def test_add_user_2(self, user):
"""
@feature: Organizations
@test: Create different types of users then add user
by using the organization name
@assert: User is added to organization
@BZ: 1076562
"""
strategy = common_locators["entity_deselect"][0]
value = common_locators["entity_deselect"][1]
org_name = generate_string("alpha", 8)
password = generate_string("alpha", 8)
email = generate_email_address()
search_key = "login"
self.login.login(self.katello_user, self.katello_passwd)
self.navigator.go_to_org()
self.org.create(org_name)
self.navigator.go_to_org()
self.assertIsNotNone(self.org.search(org_name))
self.navigator.go_to_users()
self.user.create(user, email, password, password)
self.assertIsNotNone(self.user.search(user, search_key))
self.navigator.go_to_org()
self.org.update(org_name, new_users=[user])
self.org.search(org_name).click()
self.org.wait_until_element(tab_locators["orgs.tab_users"]).click()
element = self.org.wait_until_element((strategy, value % user))
self.assertTrue(element)
@bzbug('1076562')
@attr('ui', 'org', 'implemented')
@data(*generate_strings_list())
def test_add_hostgroup_1(self, host_grp):
"""
@feature: Organizations
@test: Add a hostgroup by using the organization
name and hostgroup name
@assert: hostgroup is added to organization
@BZ: 1076562
"""
strategy = common_locators["entity_deselect"][0]
value = common_locators["entity_deselect"][1]
org_name = generate_string("alpha", 8)
self.login.login(self.katello_user, self.katello_passwd)
self.navigator.go_to_org()
self.org.create(org_name)
self.navigator.go_to_org()
self.assertIsNotNone(self.org.search(org_name))
self.navigator.go_to_host_groups()
self.hostgroup.create(host_grp)
self.assertIsNotNone(self.hostgroup.search(host_grp))
self.org.update(org_name, new_hostgroups=[host_grp])
self.org.search(org_name).click()
self.org.wait_until_element(tab_locators["orgs.tab_hostgrps"]).click()
element = self.org.wait_until_element((strategy, value % host_grp))
self.assertTrue(element)
@bzbug('1076562')
@attr('ui', 'org', 'implemented')
@data(*generate_strings_list())
def test_add_location_1(self, location):
"""
@feature: Organizations
@test: Add a location by using the organization
name and location name
@assert: location is added to organization
@BZ: 1076562
"""
strategy = common_locators["entity_deselect"][0]
value = common_locators["entity_deselect"][1]
org_name = generate_string("alpha", 8)
self.login.login(self.katello_user, self.katello_passwd)
self.navigator.go_to_org()
self.org.create(org_name)
self.navigator.go_to_org()
self.assertIsNotNone(self.org.search(org_name))
self.navigator.go_to_host_groups()
self.location.create(location)
self.assertIsNotNone(self.location.search(location))
self.org.update(org_name, new_locations=[location])
self.org.search(org_name).click()
self.org.wait_until_element(tab_locators["orgs.tab_locations"]).click()
element = self.org.wait_until_element((strategy, value % location))
self.assertTrue(element)
@bzbug('1076562')
@attr('ui', 'org', 'implemented')
@data(*generate_strings_list())
def test_remove_computeresource_1(self, resource_name):
"""
@feature: Organizations
@test: Remove computeresource by using the organization
name and computeresource name
@assert: computeresource is added then removed
@BZ: 1076562
"""
strategy = common_locators["entity_select"][0]
value = common_locators["entity_select"][1]
strategy1 = common_locators["entity_deselect"][0]
value1 = common_locators["entity_deselect"][1]
org_name = generate_string("alpha", 8)
libvirt_url = "qemu+tcp://%s:16509/system"
url = (libvirt_url % conf.properties['main.server.hostname'])
self.login.login(self.katello_user, self.katello_passwd)
self.navigator.go_to_compute_resources()
self.compute_resource.create(resource_name,
None,
provider_type="Libvirt",
url=url)
self.navigator.go_to_compute_resources()
self.assertIsNotNone(self.compute_resource.search(resource_name))
self.navigator.go_to_org()
self.org.create(org_name, resources=[resource_name], edit=True)
self.org.search(org_name).click()
self.org.wait_until_element(tab_locators["orgs.tab_resources"]).click()
element = self.org.wait_until_element(
(strategy1, value1 % resource_name))
# Item is listed in 'Selected Items' list and not 'All Items' list.
self.assertTrue(element)
self.org.update(org_name,
resources=[resource_name],
new_resources=None)
self.org.search(org_name).click()
self.org.wait_until_element(tab_locators["orgs.tab_resources"]).click()
element = self.org.wait_until_element(
(strategy, value % resource_name))
# Item is listed in 'All Items' list and not 'Selected Items' list.
self.assertTrue(element)
@bzbug('1076562')
@attr('ui', 'org', 'implemented')
@data(*generate_strings_list())
def test_remove_medium_1(self, medium):
"""
@feature: Organizations
@test: Remove medium by using organization name and medium name
@assert: medium is added then removed
@BZ: 1076562
"""
strategy = common_locators["entity_select"][0]
value = common_locators["entity_select"][1]
strategy1 = common_locators["entity_deselect"][0]
value1 = common_locators["entity_deselect"][1]
org_name = generate_string("alpha", 8)
path = URL % generate_string("alpha", 6)
os_family = "Red Hat"
self.login.login(self.katello_user, self.katello_passwd)
self.navigator.go_to_installation_media()
self.medium.create(medium, path, os_family)
self.assertIsNotNone(self.medium.search(medium))
self.navigator.go_to_org()
self.org.create(org_name, medias=[medium], edit=True)
self.org.search(org_name).click()
self.org.wait_until_element(tab_locators["orgs.tab_media"]).click()
element = self.org.wait_until_element((strategy1, value1 % medium))
# Item is listed in 'Selected Items' list and not 'All Items' list.
self.assertTrue(element)
self.org.update(org_name, medias=[medium], new_medias=None)
self.org.search(org_name).click()
self.org.wait_until_element(tab_locators["orgs.tab_media"]).click()
element = self.org.wait_until_element((strategy, value % medium))
# Item is listed in 'All Items' list and not 'Selected Items' list.
self.assertTrue(element)
@bzbug('1076562')
@attr('ui', 'org', 'implemented')
@data(*generate_strings_list())
def test_remove_configtemplate_1(self, template):
"""
@feature: Organizations
@test: Remove config template
@assert: configtemplate is added then removed
@BZ: 1076562
"""
strategy = common_locators["entity_select"][0]
value = common_locators["entity_select"][1]
strategy1 = common_locators["entity_deselect"][0]
value1 = common_locators["entity_deselect"][1]
org_name = generate_string("alpha", 8)
temp_type = 'provision'
template_path = get_data_file(OS_TEMPLATE_DATA_FILE)
self.login.login(self.katello_user, self.katello_passwd)
self.navigator.go_to_provisioning_templates()
self.template.create(template, template_path, True, temp_type, None)
self.assertIsNotNone(self.template.search(template))
self.navigator.go_to_org()
self.org.create(org_name, templates=[template], edit=True)
self.org.search(org_name).click()
self.org.wait_until_element(tab_locators["orgs.tab_template"]).click()
element = self.org.wait_until_element((strategy1, value1 % template))
# Item is listed in 'Selected Items' list and not 'All Items' list.
self.assertTrue(element)
self.org.update(org_name, templates=[template])
self.org.search(org_name).click()
self.org.wait_until_element(tab_locators["orgs.tab_template"]).click()
element = self.org.wait_until_element((strategy, value % template))
# Item is listed in 'All Items' list and not 'Selected Items' list.
self.assertTrue(element)
@attr('ui', 'org', 'implemented')
@data(*generate_strings_list())
def test_add_environment_1(self, env):
"""
@feature: Organizations
@test: Add environment by using organization name and evironment name
@assert: environment is added
@status: manual
"""
strategy = common_locators["entity_deselect"][0]
value = common_locators["entity_deselect"][1]
org_name = generate_string("alpha", 8)
self.login.login(self.katello_user, self.katello_passwd)
self.navigator.go_to_org()
self.org.create(org_name)
self.navigator.go_to_org()
self.assertIsNotNone(self.org.search(org_name))
self.navigator.go_to_environments()
self.environment.create(env, None)
search = self.environment.search(env)
self.assertIsNotNone(search)
self.navigator.go_to_org()
self.org.update(org_name, new_envs=[env])
self.org.search(org_name).click()
self.org.wait_until_element(tab_locators["orgs.tab_env"]).click()
element = self.org.wait_until_element((strategy, value % env))
self.assertTrue(element)
@unittest.skip(NOT_IMPLEMENTED)
@data("""DATADRIVENGOESHERE
smartproxy name is alpha
smartproxy name is numeric
smartproxy name is alpha_numeric
smartproxy name is utf-8
smartproxy name is latin1
smartproxy name is html
""")
def test_remove_smartproxy_1(self, test_data):
"""
@feature: Organizations
@test: Remove smartproxy by using organization name and smartproxy name
@assert: smartproxy is added then removed
@status: manual
"""
pass
@bzbug('1076562')
@attr('ui', 'org', 'implemented')
@data(*generate_strings_list())
def test_add_computeresource_1(self, resource_name):
"""
@feature: Organizations
@test: Add compute resource using the organization
name and computeresource name
@assert: computeresource is added
@BZ: 1076562
"""
strategy = common_locators["entity_deselect"][0]
value = common_locators["entity_deselect"][1]
org_name = generate_string("alpha", 8)
libvirt_url = "qemu+tcp://%s:16509/system"
url = (libvirt_url % conf.properties['main.server.hostname'])
self.login.login(self.katello_user, self.katello_passwd)
self.navigator.go_to_org()
self.org.create(org_name)
self.navigator.go_to_org()
self.assertIsNotNone(self.org.search(org_name))
self.navigator.go_to_compute_resources()
self.compute_resource.create(resource_name, [org_name],
provider_type="Libvirt",
url=url)
self.navigator.go_to_compute_resources()
self.assertIsNotNone(self.compute_resource.search(resource_name))
self.navigator.go_to_org()
self.org.update(org_name, new_resources=[resource_name])
self.org.search(org_name).click()
self.org.wait_until_element(tab_locators["orgs.tab_resources"]).click()
element = self.org.wait_until_element(
(strategy, value % resource_name))
self.assertTrue(element)
@bzbug('1076562')
@attr('ui', 'org', 'implemented')
@data(*generate_strings_list())
def test_add_medium_1(self, medium):
"""
@feature: Organizations
@test: Add medium by using the organization name and medium name
@assert: medium is added
@BZ: 1076562
"""
strategy = common_locators["entity_deselect"][0]
value = common_locators["entity_deselect"][1]
org_name = generate_string("alpha", 8)
path = URL % generate_string("alpha", 6)
os_family = "Red Hat"
self.login.login(self.katello_user, self.katello_passwd)
self.navigator.go_to_org()
self.org.create(org_name)
self.navigator.go_to_org()
self.assertIsNotNone(self.org.search(org_name))
self.navigator.go_to_installation_media()
self.medium.create(medium, path, os_family)
self.assertIsNotNone(self.medium.search(medium))
self.navigator.go_to_org()
self.org.update(org_name, new_medias=[medium])
self.org.search(org_name).click()
self.org.wait_until_element(tab_locators["orgs.tab_media"]).click()
element = self.org.wait_until_element((strategy, value % medium))
self.assertTrue(element)
@bzbug('1076562')
@attr('ui', 'org', 'implemented')
@data(*generate_strings_list())
def test_add_configtemplate_1(self, template):
"""
@feature: Organizations
@test: Add config template by using organization name and
configtemplate name
@assert: configtemplate is added
@BZ: 1076562
"""
strategy = common_locators["entity_deselect"][0]
value = common_locators["entity_deselect"][1]
org_name = generate_string("alpha", 8)
temp_type = 'provision'
template_path = get_data_file(OS_TEMPLATE_DATA_FILE)
self.login.login(self.katello_user, self.katello_passwd)
self.navigator.go_to_org()
self.org.create(org_name)
self.navigator.go_to_org()
self.assertIsNotNone(self.org.search(org_name))
self.navigator.go_to_provisioning_templates()
self.template.create(template, template_path, True, temp_type, None)
self.assertIsNotNone(self.template.search(template))
self.navigator.go_to_org()
self.org.update(org_name, new_templates=[template])
self.org.search(org_name).click()
self.org.wait_until_element(tab_locators["orgs.tab_media"]).click()
element = self.org.wait_until_element((strategy, value % template))
self.assertTrue(element)
@bzbug('1076562')
@attr('ui', 'org', 'implemented')
@data(*generate_strings_list())
def test_remove_environment_1(self, env):
"""
@feature: Organizations
@test: Remove environment by using organization name & evironment name
@assert: environment is removed from Organization
@BZ: 1076562
"""
strategy = common_locators["entity_select"][0]
value = common_locators["entity_select"][1]
strategy1 = common_locators["entity_deselect"][0]
value1 = common_locators["entity_deselect"][1]
org_name = generate_string("alpha", 8)
self.login.login(self.katello_user, self.katello_passwd)
self.navigator.go_to_environments()
self.environment.create(env, None)
search = self.environment.search(env)
self.assertIsNotNone(search)
self.navigator.go_to_org()
self.org.create(org_name, envs=[env], edit=True)
self.org.search(org_name).click()
self.org.wait_until_element(tab_locators["orgs.tab_env"]).click()
element = self.org.wait_until_element((strategy1, value1 % env))
# Item is listed in 'Selected Items' list and not 'All Items' list.
self.assertTrue(element)
self.org.update(org_name, new_envs=[env])
self.org.search(org_name).click()
self.org.wait_until_element(tab_locators["orgs.tab_env"]).click()
element = self.org.wait_until_element((strategy, value % env))
# Item is listed in 'All Items' list and not 'Selected Items' list.
self.assertTrue(element)
@bzbug('1076562')
@attr('ui', 'org', 'implemented')
@data(*generate_strings_list())
def test_remove_subnet_1(self, subnet_name):
"""
@feature: Organizations
@test: Remove subnet by using organization name and subnet name
@assert: subnet is added then removed
@BZ: 1076562
"""
strategy = common_locators["entity_select"][0]
value = common_locators["entity_select"][1]
strategy1 = common_locators["entity_deselect"][0]
value1 = common_locators["entity_deselect"][1]
org_name = generate_string("alpha", 8)
subnet_network = generate_ipaddr(ip3=True)
subnet_mask = "255.255.255.0"
self.login.login(self.katello_user, self.katello_passwd)
self.navigator.go_to_subnets()
self.subnet.create(None, subnet_name, subnet_network, subnet_mask)
self.assertIsNotNone(self.subnet.search_subnet(subnet_name))
self.navigator.go_to_org()
self.org.create(org_name, subnets=[subnet_name], edit=True)
self.org.search(org_name).click()
self.org.wait_until_element(tab_locators["orgs.tab_subnets"]).click()
element = self.org.wait_until_element(
(strategy1, value1 % subnet_name))
# Item is listed in 'Selected Items' list and not 'All Items' list.
self.assertTrue(element)
self.org.update(org_name, subnets=[subnet_name], new_subnets=None)
self.org.search(org_name).click()
self.org.wait_until_element(tab_locators["orgs.tab_subnets"]).click()
element = self.org.wait_until_element((strategy, value % subnet_name))
# Item is listed in 'All Items' list and not 'Selected Items' list.
self.assertTrue(element)
class ConfigGroups(UITestCase):
"""Implements Config Groups tests in UI."""
@data(*generate_strings_list(len1=8))
def test_create_positive_1(self, name):
"""@Test: Create new Config-Group
@Feature: Config-Groups - Positive Create
@Assert: Config-Groups is created
"""
with Session(self.browser) as session:
make_config_groups(session, name=name)
search = self.configgroups.search(name)
self.assertIsNotNone(search)
@data(gen_string('alphanumeric', 255), gen_string('alpha', 255),
gen_string('numeric', 255), gen_string('latin1', 255),
gen_string('utf8', 255))
def test_create_positive_2(self, name):
"""@Test: Create new config-groups with 255 chars
@Feature: Config-Groups - Positive Create
@Assert: Config-Groups is created with 255 chars
"""
with Session(self.browser) as session:
make_config_groups(session, name=name)
search = self.configgroups.search(name)
self.assertIsNotNone(search)
@data(*generate_strings_list(len1=256))
def test_create_negative_1(self, name):
"""@Test: Create new config-groups with 256 chars
@Feature: Config-Groups - Negative Create
@Assert: Config-Groups is not created
"""
with Session(self.browser) as session:
make_config_groups(session, name=name)
error = session.nav.wait_until_element(
common_locators["name_haserror"])
self.assertIsNotNone(error)
search = self.configgroups.search(name)
self.assertIsNone(search)
@data("", " ")
def test_create_negative_2(self, name):
"""@Test: Create new config-groups with blank name
@Feature: Config-Groups - Negative Create
@Assert: Config-Groups is not created
"""
with Session(self.browser) as session:
make_config_groups(session, name=name)
error = session.nav.wait_until_element(
common_locators["name_haserror"])
self.assertIsNotNone(error)
@data(
{
'name': gen_string('alpha', 10),
'new_name': gen_string('alpha', 10)
}, {
'name': gen_string('numeric', 10),
'new_name': gen_string('numeric', 10)
}, {
'name': gen_string('alphanumeric', 10),
'new_name': gen_string('alphanumeric', 10)
}, {
'name': gen_string('utf8', 10),
'new_name': gen_string('utf8', 10)
}, {
'name': gen_string('latin1', 20),
'new_name': gen_string('latin1', 10)
})
def test_update_positive_1(self, testdata):
"""@Test: Create new config-group
@Feature: Config-Groups - Positive Update
@Assert: Config-Groups is updated.
"""
name = testdata['name']
new_name = testdata['new_name']
with Session(self.browser) as session:
make_config_groups(session, name=name)
search = self.configgroups.search(name)
self.assertIsNotNone(search)
self.configgroups.update(name, new_name)
search = self.configgroups.search(new_name)
self.assertIsNotNone(search)
@data(*generate_strings_list(len1=8))
def test_delete_positive_1(self, name):
"""@Test: Create new config-groups
@Feature: Config-Groups - Positive delete
@Assert: Config-Groups is deleted
"""
with Session(self.browser) as session:
make_config_groups(session, name=name)
search = self.configgroups.search(name)
self.assertIsNotNone(search)
self.configgroups.delete(
name, True, drop_locator=locators["config_groups.dropdown"])
self.assertIsNotNone(
session.nav.wait_until_element(
common_locators["notif.success"]))
self.assertIsNone(self.configgroups.search(name))
class Location(UITestCase):
"""Implements Location tests in UI"""
# Auto Search
@skip_if_bug_open('bugzilla', 1177610)
def test_auto_search(self):
"""@test: Can auto-complete search for location by partial name
@feature: Locations
@assert: Created location can be auto search by its partial name
@BZ: 1177610
"""
loc_name = gen_string("alpha", 8)
part_string = loc_name[:3]
with Session(self.browser) as session:
page = session.nav.go_to_loc
make_loc(session, name=loc_name)
auto_search = self.location.auto_complete_search(
page,
locators['location.select_name'],
part_string,
loc_name,
search_key='name')
self.assertIsNotNone(auto_search)
# Positive Create
@data(*generate_strings_list())
def test_positive_create_1(self, loc_name):
"""@test: Create Location with valid name only
@feature: Locations
@assert: Location is created, label is auto-generated
"""
with Session(self.browser) as session:
make_loc(session, name=loc_name)
self.assertIsNotNone(self.location.search(loc_name))
@skip_if_bug_open('bugzilla', 1123818)
@data(*generate_strings_list(len1=247))
def test_negative_create_1(self, loc_name):
"""@test: Create location with name as too long
@feature: Locations
@assert: location is not created
@BZ: 1123818
"""
with Session(self.browser) as session:
make_loc(session, name=loc_name)
error = session.nav.wait_until_element(
common_locators["name_haserror"])
self.assertIsNotNone(error)
def test_negative_create_2(self):
"""@test: Create location with name as blank
@feature: Locations
@assert: location is not created
"""
loc_name = ""
with Session(self.browser) as session:
make_loc(session, name=loc_name)
error = session.nav.wait_until_element(
common_locators["name_haserror"])
self.assertIsNotNone(error)
def test_negative_create_3(self):
"""@test: Create location with name as whitespace
@feature: Locations
@assert: location is not created
"""
loc_name = " "
with Session(self.browser) as session:
make_loc(session, name=loc_name)
error = session.nav.wait_until_element(
common_locators["name_haserror"])
self.assertIsNotNone(error)
@data(*generate_strings_list())
def test_negative_create_4(self, loc_name):
"""@test: Create location with valid values, then create a new one
with same values.
@feature: Locations
@assert: location is not created
"""
with Session(self.browser) as session:
make_loc(session, name=loc_name)
self.assertIsNotNone(self.location.search(loc_name))
make_loc(session, name=loc_name)
error = session.nav.wait_until_element(
common_locators["name_haserror"])
self.assertIsNotNone(error)
@data(
{
'org_name': gen_string('alpha', 10),
'loc_name': gen_string('alpha', 10)
}, {
'org_name': gen_string('numeric', 10),
'loc_name': gen_string('numeric', 10)
}, {
'org_name': gen_string('alphanumeric', 10),
'loc_name': gen_string('alphanumeric', 10)
}, {
'org_name': gen_string('utf8', 10),
'loc_name': gen_string('utf8', 10)
}, {
'org_name': gen_string('latin1', 20),
'loc_name': gen_string('latin1', 10)
}, {
'org_name': gen_string('html', 20),
'loc_name': gen_string('html', 10)
})
def test_positive_create_6(self, test_data):
"""@test: Select both organization and location.
@feature: Locations
@assert: Both organization and location are selected.
"""
org_name = test_data['org_name']
loc_name = test_data['loc_name']
org = entities.Organization(name=org_name).create()
self.assertEqual(org['name'], org_name)
with Session(self.browser) as session:
make_loc(session, name=loc_name)
self.assertIsNotNone(self.location.search(loc_name))
location = session.nav.go_to_select_loc(loc_name)
organization = session.nav.go_to_select_org(org_name)
self.assertEqual(location, loc_name)
self.assertEqual(organization, org_name)
# Positive Update
@data(*generate_strings_list())
def test_positive_update_1(self, new_name):
"""@test: Create Location with valid values then update its name
@feature: Locations
@assert: Location name is updated
"""
loc_name = gen_string("alpha", 8)
with Session(self.browser) as session:
make_loc(session, name=loc_name)
self.assertIsNotNone(self.location.search(loc_name))
self.location.update(loc_name, new_name=new_name)
self.assertIsNotNone(self.location.search(new_name))
# Negative Update
@skip_if_bug_open('bugzilla', 1123818)
@data(*generate_strings_list())
def test_negative_update_1(self, loc_name):
"""@test: Create Location with valid values then fail to update
its name
@feature: Locations
@assert: Location name is not updated
@BZ: 1123818
"""
with Session(self.browser) as session:
make_loc(session, name=loc_name)
self.assertIsNotNone(self.location.search(loc_name))
new_name = gen_string("alpha", 256)
self.location.update(loc_name, new_name=new_name)
error = session.nav.wait_until_element(
common_locators["name_haserror"])
self.assertIsNotNone(error)
# Miscellaneous
@data(*generate_strings_list())
def test_search_key_1(self, loc_name):
"""@test: Create location and search/find it
@feature: Locations
@assert: location can be found
"""
with Session(self.browser) as session:
make_loc(session, name=loc_name)
self.assertIsNotNone(self.location.search(loc_name))
@data(*generate_strings_list())
def test_add_subnet_1(self, subnet_name):
"""@test: Add a subnet by using location name and subnet name
@feature: Locations
@assert: subnet is added
"""
strategy, value = common_locators["entity_deselect"]
loc_name = gen_string("alpha", 8)
subnet_network = gen_ipaddr(ip3=True)
subnet_mask = "255.255.255.0"
subnet = entities.Subnet(name=subnet_name,
network=subnet_network,
mask=subnet_mask).create()
self.assertEqual(subnet['name'], subnet_name)
with Session(self.browser) as session:
make_loc(session, name=loc_name)
self.assertIsNotNone(self.location.search(loc_name))
self.location.update(loc_name, new_subnets=[subnet_name])
self.location.search(loc_name).click()
session.nav.wait_until_element(
tab_locators["context.tab_subnets"]).click()
element = session.nav.wait_until_element(
(strategy, value % subnet_name))
self.assertIsNotNone(element)
@data(*generate_strings_list())
def test_add_domain_1(self, domain_name):
"""@test: Add a domain to a Location
@feature: Locations
@assert: Domain is added to Location
"""
strategy, value = common_locators["entity_deselect"]
loc_name = gen_string("alpha", 8)
domain = entities.Domain(name=domain_name).create()
self.assertEqual(domain['name'], domain_name)
with Session(self.browser) as session:
make_loc(session, name=loc_name)
self.assertIsNotNone(self.location.search(loc_name))
self.location.update(loc_name, new_domains=[domain_name])
self.location.search(loc_name).click()
session.nav.wait_until_element(
tab_locators["context.tab_domains"]).click()
element = session.nav.wait_until_element(
(strategy, value % domain_name))
self.assertIsNotNone(element)
@data(gen_string('alpha', 8), gen_string('numeric', 8),
gen_string('alphanumeric', 8), gen_string('utf8', 8),
gen_string('latin1', 8))
def test_add_user_1(self, user_name):
"""@test: Create user then add user
by using the location name
@feature: Locations
@assert: User is added to location
"""
strategy, value = common_locators["entity_deselect"]
loc_name = gen_string("alpha", 8)
password = gen_string("alpha", 8)
user = entities.User(login=user_name,
firstname=user_name,
lastname=user_name,
password=password).create()
self.assertEqual(user['login'], user_name)
with Session(self.browser) as session:
make_loc(session, name=loc_name)
self.assertIsNotNone(self.location.search(loc_name))
self.location.update(loc_name, new_users=[user_name])
self.location.search(loc_name).click()
session.nav.wait_until_element(
tab_locators["context.tab_users"]).click()
element = session.nav.wait_until_element(
(strategy, value % user_name))
self.assertIsNotNone(element)
def test_allvalues_hostgroup(self):
"""@test: check whether host group has the 'All values' checked.
@feature: Locations
@assert: host group 'All values' checkbox is checked.
"""
loc_name = gen_string("alpha", 8)
with Session(self.browser) as session:
page = session.nav.go_to_loc
make_loc(session, name=loc_name)
self.assertIsNotNone(self.location.search(loc_name))
selected = self.location.check_all_values(
page,
loc_name,
locators["location.select_name"],
tab_locators["context.tab_hostgrps"],
context="location")
self.assertIsNotNone(selected)
@data(*generate_strings_list())
def test_add_hostgroup_1(self, host_grp_name):
"""@test: Add a hostgroup by using the location
name and hostgroup name
@feature: Locations
@assert: hostgroup is added to location
"""
strategy, value = common_locators["all_values_selection"]
loc_name = gen_string("alpha", 8)
host_grp = entities.HostGroup(name=host_grp_name).create()
self.assertEqual(host_grp['name'], host_grp_name)
with Session(self.browser) as session:
make_loc(session, name=loc_name)
self.assertIsNotNone(self.location.search(loc_name))
self.location.search(loc_name).click()
session.nav.wait_until_element(
tab_locators["context.tab_hostgrps"]).click()
element = session.nav.wait_until_element(
(strategy, value % host_grp_name))
self.assertIsNotNone(element)
@data(*generate_strings_list())
def test_add_org_1(self, org_name):
"""@test: Add a organization by using the location
name
@feature: Locations
@assert: organization is added to location
"""
strategy, value = common_locators["entity_deselect"]
loc_name = gen_string("alpha", 8)
org = entities.Organization(name=org_name).create()
self.assertEqual(org['name'], org_name)
with Session(self.browser) as session:
make_loc(session, name=loc_name)
self.assertIsNotNone(self.location.search(loc_name))
self.location.update(loc_name, new_organizations=[org_name])
self.location.search(loc_name).click()
session.nav.wait_until_element(
tab_locators["context.tab_organizations"]).click()
element = session.nav.wait_until_element(
(strategy, value % org_name))
self.assertIsNotNone(element)
@data(gen_string('alpha', 8), gen_string('numeric', 8),
gen_string('alphanumeric', 8))
def test_add_environment_1(self, env_name):
"""@test: Add environment by using location name and evironment name
@feature: Locations
@assert: environment is added
"""
strategy, value = common_locators["entity_deselect"]
loc_name = gen_string("alpha", 8)
env = entities.Environment(name=env_name).create()
self.assertEqual(env['name'], env_name)
with Session(self.browser) as session:
make_loc(session, name=loc_name)
self.assertIsNotNone(self.location.search(loc_name))
self.location.update(loc_name, new_envs=[env_name])
self.location.search(loc_name).click()
session.nav.wait_until_element(
tab_locators["context.tab_env"]).click()
element = session.nav.wait_until_element(
(strategy, value % env_name))
self.assertIsNotNone(element)
@data(*generate_strings_list())
def test_add_computeresource_1(self, resource_name):
"""@test: Add compute resource using the location
name and computeresource name
@feature: Locations
@assert: computeresource is added
"""
strategy, value = common_locators["entity_deselect"]
loc_name = gen_string("alpha", 8)
libvirt_url = "qemu+tcp://%s:16509/system"
url = (libvirt_url % conf.properties['main.server.hostname'])
resource = entities.ComputeResource(name=resource_name,
provider='Libvirt',
url=url).create()
self.assertEqual(resource['name'], resource_name)
with Session(self.browser) as session:
make_loc(session, name=loc_name)
self.assertIsNotNone(self.location.search(loc_name))
self.location.update(loc_name, new_resources=[resource_name])
self.location.search(loc_name).click()
session.nav.wait_until_element(
tab_locators["context.tab_resources"]).click()
element = session.nav.wait_until_element(
(strategy, value % resource_name))
self.assertIsNotNone(element)
@data(*generate_strings_list())
def test_add_medium_1(self, medium_name):
"""@test: Add medium by using the location name and medium name
@feature: Locations
@assert: medium is added
"""
strategy, value = common_locators["entity_deselect"]
loc_name = gen_string("alpha", 8)
path = INSTALL_MEDIUM_URL % gen_string("alpha", 6)
medium = entities.Media(
name=medium_name,
media_path=path,
os_family='Redhat',
).create()
self.assertEqual(medium['name'], medium_name)
with Session(self.browser) as session:
make_loc(session, name=loc_name)
self.assertIsNotNone(self.location.search(loc_name))
self.location.update(loc_name, new_medias=[medium_name])
self.location.search(loc_name).click()
session.nav.wait_until_element(
tab_locators["context.tab_media"]).click()
element = session.nav.wait_until_element(
(strategy, value % medium_name))
self.assertIsNotNone(element)
def test_allvalues_configtemplate(self):
"""@test: check whether config template has the 'All values' checked.
@feature: Locations
@assert: configtemplate 'All values' checkbox is checked.
"""
loc_name = gen_string("alpha", 8)
with Session(self.browser) as session:
page = session.nav.go_to_loc
make_loc(session, name=loc_name)
self.assertIsNotNone(self.location.search(loc_name))
selected = self.location.check_all_values(
page,
loc_name,
locators["location.select_name"],
tab_locators["context.tab_template"],
context="location")
self.assertIsNotNone(selected)
@data(*generate_strings_list())
def test_add_configtemplate_1(self, template):
"""@test: Add config template by using location name and
configtemplate name.
@feature: Locations
@assert: configtemplate is added.
"""
strategy, value = common_locators["all_values_selection"]
loc_name = gen_string("alpha", 8)
temp_type = 'provision'
template_path = get_data_file(OS_TEMPLATE_DATA_FILE)
with Session(self.browser) as session:
make_loc(session, name=loc_name)
self.assertIsNotNone(self.location.search(loc_name))
make_templates(session,
name=template,
template_path=template_path,
custom_really=True,
template_type=temp_type)
self.assertIsNotNone(self.template.search(template))
self.location.search(loc_name).click()
session.nav.wait_until_element(
tab_locators["context.tab_template"]).click()
element = session.nav.wait_until_element(
(strategy, value % template))
self.assertIsNotNone(element)
@data(gen_string('alpha', 8), gen_string('numeric', 8),
gen_string('alphanumeric', 8))
def test_remove_environment_1(self, env_name):
"""@test: Remove environment by using location name & evironment name
@feature: Locations
@assert: environment is removed from Location
"""
strategy, value = common_locators["entity_select"]
strategy1, value1 = common_locators["entity_deselect"]
loc_name = gen_string("alpha", 8)
env = entities.Environment(name=env_name).create()
self.assertEqual(env['name'], env_name)
with Session(self.browser) as session:
make_loc(session, name=loc_name, envs=[env_name])
self.location.search(loc_name).click()
session.nav.wait_until_element(
tab_locators["context.tab_env"]).click()
element = session.nav.wait_until_element(
(strategy1, value1 % env_name))
# Item is listed in 'Selected Items' list and not 'All Items' list.
self.assertIsNotNone(element)
self.location.update(loc_name, envs=[env_name])
self.location.search(loc_name).click()
session.nav.wait_until_element(
tab_locators["context.tab_env"]).click()
element = session.nav.wait_until_element(
(strategy, value % env_name))
# Item is listed in 'All Items' list and not 'Selected Items' list.
self.assertIsNotNone(element)
@data(*generate_strings_list())
def test_remove_subnet_1(self, subnet_name):
"""@test: Remove subnet by using location name and subnet name
@feature: Locations
@assert: subnet is added then removed
"""
strategy, value = common_locators["entity_select"]
strategy1, value1 = common_locators["entity_deselect"]
loc_name = gen_string("alpha", 8)
subnet_network = gen_ipaddr(ip3=True)
subnet_mask = "255.255.255.0"
subnet = entities.Subnet(name=subnet_name,
network=subnet_network,
mask=subnet_mask).create()
self.assertEqual(subnet['name'], subnet_name)
with Session(self.browser) as session:
make_loc(session, name=loc_name, subnets=[subnet_name])
self.location.search(loc_name).click()
session.nav.wait_until_element(
tab_locators["context.tab_subnets"]).click()
element = session.nav.wait_until_element(
(strategy1, value1 % subnet_name))
# Item is listed in 'Selected Items' list and not 'All Items' list.
self.assertIsNotNone(element)
self.location.update(loc_name, subnets=[subnet_name])
self.location.search(loc_name).click()
self.location.wait_until_element(
tab_locators["context.tab_subnets"]).click()
element = session.nav.wait_until_element(
(strategy, value % subnet_name))
# Item is listed in 'All Items' list and not 'Selected Items' list.
self.assertIsNotNone(element)
@data(*generate_strings_list())
def test_remove_domain_1(self, domain_name):
"""@test: Add a domain to an location and remove it by location
name and domain name
@feature: Locations
@assert: the domain is removed from the location
"""
strategy, value = common_locators["entity_select"]
strategy1, value1 = common_locators["entity_deselect"]
loc_name = gen_string("alpha", 8)
domain = entities.Domain(name=domain_name).create()
self.assertEqual(domain['name'], domain_name)
with Session(self.browser) as session:
make_loc(session, name=loc_name, domains=[domain_name])
self.location.search(loc_name).click()
session.nav.wait_until_element(
tab_locators["context.tab_domains"]).click()
element = session.nav.wait_until_element(
(strategy1, value1 % domain_name))
# Item is listed in 'Selected Items' list and not 'All Items' list.
self.assertIsNotNone(element)
self.location.update(loc_name, domains=[domain_name])
self.location.search(loc_name).click()
session.nav.wait_until_element(
tab_locators["context.tab_domains"]).click()
element = session.nav.wait_until_element(
(strategy, value % domain_name))
# Item is listed in 'All Items' list and not 'Selected Items' list.
self.assertIsNotNone(element)
@data(gen_string('alpha', 8), gen_string('numeric', 8),
gen_string('alphanumeric', 8), gen_string('utf8', 8),
gen_string('latin1', 8))
def test_remove_user_1(self, user_name):
"""@test: Create admin users then add user and remove it
by using the location name
@feature: Locations
@assert: The user is added then removed from the location
"""
strategy, value = common_locators["entity_select"]
strategy1, value1 = common_locators["entity_deselect"]
loc_name = gen_string("alpha", 8)
password = gen_string("alpha", 8)
user = entities.User(login=user_name,
firstname=user_name,
lastname=user_name,
password=password).create()
self.assertEqual(user['login'], user_name)
with Session(self.browser) as session:
make_loc(session, name=loc_name, users=[user_name])
self.location.search(loc_name).click()
session.nav.wait_until_element(
tab_locators["context.tab_users"]).click()
element = session.nav.wait_until_element(
(strategy1, value1 % user_name))
# Item is listed in 'Selected Items' list and not 'All Items' list.
self.assertIsNotNone(element)
self.location.update(loc_name, users=[user_name])
self.location.search(loc_name).click()
session.nav.wait_until_element(
tab_locators["context.tab_users"]).click()
element = session.nav.wait_until_element(
(strategy, value % user_name))
# Item is listed in 'All Items' list and not 'Selected Items' list.
self.assertIsNotNone(element)
@data(*generate_strings_list())
def test_remove_hostgroup_1(self, host_grp_name):
"""@test: Add a hostgroup and remove it by using the location
name and hostgroup name
@feature: Locations
@assert: hostgroup is added to location then removed
"""
strategy, value = common_locators["all_values_selection"]
loc_name = gen_string("alpha", 8)
host_grp = entities.HostGroup(name=host_grp_name).create()
self.assertEqual(host_grp['name'], host_grp_name)
with Session(self.browser) as session:
make_loc(session, name=loc_name)
self.location.search(loc_name).click()
session.nav.wait_until_element(
tab_locators["context.tab_hostgrps"]).click()
element = session.nav.wait_until_element(
(strategy, value % host_grp_name))
# Item is listed in 'Selected Items' list and not 'All Items' list.
self.assertIsNotNone(element)
self.hostgroup.delete(host_grp_name, True)
self.location.search(loc_name).click()
session.nav.wait_until_element(
tab_locators["context.tab_hostgrps"]).click()
element = session.nav.wait_until_element(
(strategy, value % host_grp_name))
# Item is listed in 'All Items' list and not 'Selected Items' list.
self.assertIsNone(element)
@data(*generate_strings_list())
def test_remove_computeresource_1(self, resource_name):
"""@test: Remove computeresource by using the location
name and computeresource name
@feature: Locations
@assert: computeresource is added then removed
"""
strategy, value = common_locators["entity_select"]
strategy1, value1 = common_locators["entity_deselect"]
loc_name = gen_string("alpha", 8)
libvirt_url = "qemu+tcp://%s:16509/system"
url = (libvirt_url % conf.properties['main.server.hostname'])
resource = entities.ComputeResource(name=resource_name,
provider='Libvirt',
url=url).create()
self.assertEqual(resource['name'], resource_name)
with Session(self.browser) as session:
make_loc(session, name=loc_name, resources=[resource_name])
self.location.search(loc_name).click()
session.nav.wait_until_element(
tab_locators["context.tab_resources"]).click()
ele = self.location.wait_until_element(
(strategy1, value1 % resource_name))
# Item is listed in 'Selected Items' list and not 'All Items' list.
self.assertIsNotNone(ele)
self.location.update(loc_name, resources=[resource_name])
self.location.search(loc_name).click()
session.nav.wait_until_element(
tab_locators["context.tab_resources"]).click()
element = session.nav.wait_until_element(
(strategy, value % resource_name))
# Item is listed in 'All Items' list and not 'Selected Items' list.
self.assertIsNotNone(element)
@data(*generate_strings_list())
def test_remove_medium_1(self, medium_name):
"""@test: Remove medium by using location name and medium name
@feature: Locations
@assert: medium is added then removed
"""
strategy, value = common_locators["entity_select"]
strategy1, value1 = common_locators["entity_deselect"]
loc_name = gen_string("alpha", 8)
path = INSTALL_MEDIUM_URL % gen_string("alpha", 6)
medium = entities.Media(
name=medium_name,
media_path=path,
os_family='Redhat',
).create()
self.assertEqual(medium['name'], medium_name)
with Session(self.browser) as session:
make_loc(session, name=loc_name, medias=[medium_name])
self.location.search(loc_name).click()
session.nav.wait_until_element(
tab_locators["context.tab_media"]).click()
element = session.nav.wait_until_element(
(strategy1, value1 % medium_name))
# Item is listed in 'Selected Items' list and not 'All Items' list.
self.assertIsNotNone(element)
self.location.update(loc_name, medias=[medium_name])
self.location.search(loc_name).click()
session.nav.wait_until_element(
tab_locators["context.tab_media"]).click()
element = session.nav.wait_until_element(
(strategy, value % medium_name))
# Item is listed in 'All Items' list and not 'Selected Items' list.
self.assertIsNotNone(element)
@data(
{u'user_name': gen_string('alpha', 8)},
{u'user_name': gen_string('numeric', 8)},
{u'user_name': gen_string('alphanumeric', 8)},
{
u'user_name': gen_string('utf8', 8),
'bugzilla': 1164247
},
{u'user_name': gen_string('latin1', 8)},
{u'user_name': gen_string('html', 8)},
)
def test_remove_configtemplate_1(self, testdata):
"""
@test: Remove config template
@feature: Locations
@assert: configtemplate is added then removed
"""
bug_id = testdata.pop('bugzilla', None)
if bug_id is not None and bz_bug_is_open(bug_id):
self.skipTest('Bugzilla bug {0} is open.'.format(bug_id))
template = testdata['user_name']
strategy, value = common_locators["all_values_selection"]
loc_name = gen_string("alpha", 8)
temp_type = 'provision'
template_path = get_data_file(OS_TEMPLATE_DATA_FILE)
with Session(self.browser) as session:
make_templates(session,
name=template,
template_path=template_path,
template_type=temp_type,
custom_really=True)
self.assertIsNotNone(self.template.search(template))
make_loc(session, name=loc_name)
self.location.search(loc_name).click()
session.nav.wait_until_element(
tab_locators["context.tab_template"]).click()
element = session.nav.wait_until_element(
(strategy, value % template))
# Item is listed in 'Selected Items' list and not 'All Items' list.
self.assertIsNotNone(element)
self.template.delete(template, True)
self.location.search(loc_name).click()
session.nav.wait_until_element(
tab_locators["context.tab_template"]).click()
element = session.nav.wait_until_element(
(strategy, value % template))
# Item is listed in 'All Items' list and not 'Selected Items' list.
self.assertIsNone(element)
class Hostgroup(UITestCase):
"""Implements HostGroup tests from UI"""
@data(*generate_strings_list(len1=4))
def test_create_hostgroup(self, name):
"""@Test: Create new hostgroup
@Feature: Hostgroup - Positive Create
@Assert: Hostgroup is created
"""
with Session(self.browser) as session:
make_hostgroup(session, name=name)
self.assertIsNotNone(self.hostgroup.search(name))
@skip_if_bug_open('bugzilla', 1121755)
@skip_if_bug_open('bugzilla', 1131416)
@data(*generate_strings_list(len1=4))
def test_delete_hostgroup(self, name):
"""@Test: Delete a hostgroup
@Feature: Hostgroup - Positive Delete
@Assert: Hostgroup is deleted
"""
with Session(self.browser) as session:
make_hostgroup(session, name=name)
self.assertIsNotNone(self.hostgroup.search(name))
self.hostgroup.delete(name, really=True)
self.assertIsNone(self.hostgroup.search(name))
@data({
u'name': gen_string('alpha'),
u'new_name': gen_string('alpha')
}, {
u'name': gen_string('latin1'),
u'new_name': gen_string('latin1')
}, {
u'name': gen_string('numeric'),
u'new_name': gen_string('numeric')
}, {
u'name': gen_string('html'),
u'new_name': gen_string('html')
}, {
u'name': gen_string('utf8'),
u'new_name': gen_string('utf8')
}, {
u'name': gen_string('alphanumeric'),
u'new_name': gen_string('alphanumeric')
})
def test_update_hostgroup(self, test_data):
"""@Test: Update hostgroup with a new name
@Feature: Hostgroup - Positive Update
@Assert: Hostgroup is updated
"""
with Session(self.browser) as session:
make_hostgroup(session, name=test_data['name'])
self.assertIsNotNone(self.hostgroup.search(test_data['name']))
self.hostgroup.update(test_data['name'],
new_name=test_data['new_name'])
self.assertIsNotNone(self.hostgroup.search(test_data['new_name']))
@data(*generate_strings_list(len1=256))
def test_negative_create_hostgroup_1(self, name):
"""@Test: Create new hostgroup with 256 chars in name
@Feature: Hostgroup - Negative Create
@Assert: Hostgroup is not created
"""
with Session(self.browser) as session:
make_hostgroup(session, name=name)
self.assertIsNotNone(
self.hostgroup.wait_until_element(
common_locators["name_haserror"]))
@data(*generate_strings_list(len1=6))
def test_negative_create_hostgroup_2(self, name):
"""@Test: Create new hostgroup with same name
@Feature: Hostgroup - Negative Create
@Assert: Hostgroup is not created
"""
with Session(self.browser) as session:
make_hostgroup(session, name=name)
self.assertIsNotNone(self.hostgroup.search(name))
make_hostgroup(session, name=name)
self.assertIsNotNone(
self.hostgroup.wait_until_element(
common_locators["name_haserror"]))
@ddt_data("", " ")
def test_negative_create_hostgroup_3(self, name):
"""@Test: Create new hostgroup with whitespaces in name
@Feature: Hostgroup - Negative Create
@Assert: Hostgroup is not created
"""
with Session(self.browser) as session:
make_hostgroup(session, name=name)
self.assertIsNotNone(
self.hostgroup.wait_until_element(
common_locators["name_haserror"]))
class Syncplan(BaseUI):
"""
Implements Sync Plan tests in UI
"""
org_name = None
def setUp(self):
super(Syncplan, self).setUp()
# Make sure to use the Class' org_name instance
if Syncplan.org_name is None:
Syncplan.org_name = generate_string("alpha", 8)
with Session(self.browser) as session:
make_org(session, org_name=Syncplan.org_name)
def configure_syncplan(self):
"""
Configures sync plan in UI
"""
self.login.login(self.katello_user, self.katello_passwd)
self.navigator.go_to_select_org(self.org_name)
self.navigator.go_to_sync_plans()
@attr('ui', 'syncplan', 'implemented')
@data(
{
u'name': generate_string('alpha', 10),
u'desc': generate_string('alpha', 10),
u'interval': SYNC_INTERVAL['hour']
}, {
u'name': generate_string('numeric', 10),
u'desc': generate_string('numeric', 10),
u'interval': SYNC_INTERVAL['hour']
}, {
u'name': generate_string('alphanumeric', 10),
u'desc': generate_string('alphanumeric', 10),
u'interval': SYNC_INTERVAL['hour']
}, {
u'name': generate_string('utf8', 10),
u'desc': generate_string('utf8', 10),
u'interval': SYNC_INTERVAL['hour']
}, {
u'name': generate_string('html', 20),
u'desc': generate_string('html', 10),
u'interval': SYNC_INTERVAL['hour']
}, {
u'name': generate_string('alpha', 10),
u'desc': generate_string('alpha', 10),
u'interval': SYNC_INTERVAL['day']
}, {
u'name': generate_string('numeric', 10),
u'desc': generate_string('numeric', 10),
u'interval': SYNC_INTERVAL['day']
}, {
u'name': generate_string('alphanumeric', 10),
u'desc': generate_string('alphanumeric', 10),
u'interval': SYNC_INTERVAL['day']
}, {
u'name': generate_string('utf8', 10),
u'desc': generate_string('utf8', 10),
u'interval': SYNC_INTERVAL['day']
}, {
u'name': generate_string('html', 20),
u'desc': generate_string('html', 10),
u'interval': SYNC_INTERVAL['day']
}, {
u'name': generate_string('alpha', 10),
u'desc': generate_string('alpha', 10),
u'interval': SYNC_INTERVAL['week']
}, {
u'name': generate_string('numeric', 10),
u'desc': generate_string('numeric', 10),
u'interval': SYNC_INTERVAL['week']
}, {
u'name': generate_string('alphanumeric', 10),
u'desc': generate_string('alphanumeric', 10),
u'interval': SYNC_INTERVAL['week']
}, {
u'name': generate_string('utf8', 10),
u'desc': generate_string('utf8', 10),
u'interval': SYNC_INTERVAL['week']
}, {
u'name': generate_string('html', 20),
u'desc': generate_string('html', 10),
u'interval': SYNC_INTERVAL['week']
})
def test_positive_create_1(self, test_data):
"""
@Feature: Content Sync Plan - Positive Create
@Test: Create Sync Plan with minimal input parameters
@Assert: Sync Plan is created
"""
self.configure_syncplan()
self.syncplan.create(test_data['name'],
description=test_data['desc'],
sync_interval=test_data['interval'])
self.assertIsNotNone(self.products.search(test_data['name']))
@bzbug("1087425")
@attr('ui', 'syncplan', 'implemented')
@data(*generate_strings_list())
def test_positive_create_2(self, name):
"""
@Feature: Content Sync Plan - Positive Create
@Test: Create Sync Plan with same input parameters
@Assert: Sync Plan is not created
@BZ: 1087425
"""
description = "with same name"
# TODO: Due to bug 1087425 using common_haserror instead of name_error
locator = common_locators["common_haserror"]
self.configure_syncplan()
self.syncplan.create(name)
self.assertIsNotNone(self.products.search(name))
self.syncplan.create(name, description)
error = self.products.wait_until_element(locator)
self.assertTrue(error)
@bzbug("1082632")
@attr('ui', 'syncplan', 'implemented')
def test_positive_create_3(self):
"""
@Feature: Content Sync Plan - Positive Create
@Test: Create Sync plan with specified start time
@Assert: Sync Plan is created with the specified time.
@BZ: 1082632
"""
locator = locators["sp.fetch_startdate"]
plan_name = generate_string("alpha", 8)
self.configure_syncplan()
description = "sync plan create with start date"
current_date = datetime.now()
startdate = current_date + timedelta(minutes=10)
starthour = startdate.strftime("%H")
startminute = startdate.strftime("%M")
# Formatting current_date to web-UI format "%b %d, %Y %I:%M:%S %p"
# Removed zero padded hrs & mins as fetching via web-UI doesn't have it
# Removed the seconds info as it would be too quick to validate via UI.
fetch_starttime = startdate.strftime("%b %d, %Y %I:%M:%S %p").\
lstrip("0").replace(" 0", " ").rpartition(':')[0]
self.syncplan.create(plan_name,
description,
start_hour=starthour,
start_minute=startminute)
self.assertIsNotNone(self.products.search(plan_name))
self.syncplan.search(plan_name).click()
self.syncplan.wait_for_ajax()
# Removed the seconds info as it would be too quick to validate via UI.
starttime_text = str(self.syncplan.wait_until_element(locator).text).\
rpartition(':')[0]
self.assertEqual(starttime_text, fetch_starttime)
@attr('ui', 'syncplan', 'implemented')
def test_positive_create_4(self):
"""
@Feature: Content Sync Plan - Positive Create
@Test: Create Sync plan with specified start date
@Assert: Sync Plan is created with the specified date
"""
locator = locators["sp.fetch_startdate"]
plan_name = generate_string("alpha", 8)
self.configure_syncplan()
description = "sync plan create with start date"
current_date = datetime.now()
startdate = current_date + timedelta(days=10)
startdate_str = startdate.strftime("%Y-%m-%d")
# validating only for date
fetch_startdate = startdate.strftime("%b %d, %Y %I:%M:%S %p").\
rpartition(',')[0]
self.syncplan.create(plan_name, description, startdate=startdate_str)
self.assertIsNotNone(self.products.search(plan_name))
self.syncplan.search(plan_name).click()
self.syncplan.wait_for_ajax()
startdate_text = str(self.syncplan.wait_until_element(locator).text).\
rpartition(',')[0]
self.assertEqual(startdate_text, fetch_startdate)
def test_negative_create_1(self):
"""
@Feature: Content Sync Plan - Negative Create
@Test: Create Sync Plan with whitespace as name input parameters
@Assert: Sync Plan is not created with whitespace input
"""
name = " "
locator = common_locators["common_invalid"]
self.configure_syncplan()
self.syncplan.create(name)
invalid = self.products.wait_until_element(locator)
self.assertTrue(invalid)
def test_negative_create_2(self):
"""
@Feature: Content Sync Plan - Negative Create
@Test: Create Sync Plan with blank as name input parameters
@Assert: Sync Plan is not created with blank input
"""
name = ""
locator = common_locators["common_invalid"]
self.configure_syncplan()
self.syncplan.create(name)
invalid = self.products.wait_until_element(locator)
self.assertTrue(invalid)
@bzbug("1087425")
@attr('ui', 'syncplan', 'implemented')
@data(*generate_strings_list(len1=256))
def test_negative_create_3(self, name):
"""
@Feature: Content Sync Plan - Negative Create
@Test: Create Sync Plan with long chars for name as input parameters
@Assert: Sync Plan is not created with more than 255 chars
@BZ: 1087425
"""
locator = common_locators["common_haserror"]
description = "more than 255 chars"
self.configure_syncplan()
self.syncplan.create(name, description)
error = self.products.wait_until_element(locator)
self.assertTrue(error)
@attr('ui', 'syncplan', 'implemented')
@data(*generate_strings_list())
def test_positive_update_1(self, plan_name):
"""
@Feature: Content Sync Plan - Positive Update name
@Test: Update Sync plan's name
@Assert: Sync Plan's name is updated
"""
new_plan_name = generate_string("alpha", 8)
description = "update sync plan"
self.configure_syncplan()
self.syncplan.create(plan_name, description)
self.assertIsNotNone(self.products.search(plan_name))
self.syncplan.update(plan_name, new_name=new_plan_name)
self.assertIsNotNone(self.products.search(new_plan_name))
@attr('ui', 'syncplan', 'implemented')
@data(
{
u'name': generate_string('alpha', 10),
u'interval': SYNC_INTERVAL['hour']
}, {
u'name': generate_string('numeric', 10),
u'interval': SYNC_INTERVAL['hour']
}, {
u'name': generate_string('alphanumeric', 10),
u'interval': SYNC_INTERVAL['hour']
}, {
u'name': generate_string('utf8', 10),
u'interval': SYNC_INTERVAL['hour']
}, {
u'name': generate_string('html', 20),
u'interval': SYNC_INTERVAL['hour']
}, {
u'name': generate_string('alpha', 10),
u'interval': SYNC_INTERVAL['day']
}, {
u'name': generate_string('numeric', 10),
u'interval': SYNC_INTERVAL['day']
}, {
u'name': generate_string('alphanumeric', 10),
u'interval': SYNC_INTERVAL['day']
}, {
u'name': generate_string('utf8', 10),
u'interval': SYNC_INTERVAL['day']
}, {
u'name': generate_string('html', 20),
u'interval': SYNC_INTERVAL['day']
}, {
u'name': generate_string('alpha', 10),
u'interval': SYNC_INTERVAL['week']
}, {
u'name': generate_string('numeric', 10),
u'interval': SYNC_INTERVAL['week']
}, {
u'name': generate_string('alphanumeric', 10),
u'interval': SYNC_INTERVAL['week']
}, {
u'name': generate_string('utf8', 10),
u'interval': SYNC_INTERVAL['week']
}, {
u'name': generate_string('html', 20),
u'interval': SYNC_INTERVAL['week']
})
def test_positive_update_2(self, test_data):
"""
@Feature: Content Sync Plan - Positive Update interval
@Test: Update Sync plan's interval
@Assert: Sync Plan's interval is updated
"""
description = "delete sync plan"
locator = locators["sp.fetch_interval"]
self.configure_syncplan()
self.syncplan.create(test_data['name'], description)
self.assertIsNotNone(self.products.search(test_data['name']))
self.syncplan.update(test_data['name'],
new_sync_interval=test_data['interval'])
self.navigator.go_to_sync_plans()
self.syncplan.search(test_data['name']).click()
interval_text = self.syncplan.wait_until_element(locator).text
self.assertEqual(interval_text, test_data['interval'])
@attr('ui', 'syncplan', 'implemented')
@data(*generate_strings_list())
def test_positive_update_3(self, plan_name):
"""
@Feature: Content Sync Plan - Positive Update add products
@Test: Update Sync plan and associate products
@Assert: Sync Plan has the associated product
"""
prd_name = generate_string("alpha", 8)
description = "update sync plan, add prds"
strategy, value = locators["sp.prd_select"]
self.login.login(self.katello_user, self.katello_passwd)
self.navigator.go_to_select_org(self.org_name)
self.navigator.go_to_products()
self.products.create(prd_name, description)
self.assertIsNotNone(self.products.search(prd_name))
self.navigator.go_to_sync_plans()
self.syncplan.create(plan_name, description)
self.assertIsNotNone(self.products.search(plan_name))
self.syncplan.update(plan_name, add_products=[prd_name])
self.syncplan.search(plan_name).click()
self.syncplan.wait_for_ajax()
self.syncplan.wait_until_element(tab_locators["sp.tab_products"]).\
click()
self.syncplan.wait_for_ajax()
prd_element = self.syncplan.wait_until_element(
(strategy, value % prd_name))
self.assertTrue(prd_element)
@attr('ui', 'syncplan', 'implemented')
@data(*generate_strings_list())
def test_positive_update_4(self, plan_name):
"""
@Feature: Content Sync Plan - Positive Update remove products
@Test: Update Sync plan and disassociate products
@Assert: Sync Plan does not have the associated product
"""
prd_name = generate_string("alpha", 8)
plan_name = generate_string("alpha", 8)
description = "update sync plan, add prds"
strategy, value = locators["sp.prd_select"]
self.login.login(self.katello_user, self.katello_passwd)
self.navigator.go_to_select_org(self.org_name)
self.navigator.go_to_products()
self.products.create(prd_name, description)
self.assertIsNotNone(self.products.search(prd_name))
self.navigator.go_to_sync_plans()
self.syncplan.create(plan_name, description)
self.assertIsNotNone(self.products.search(plan_name))
self.syncplan.update(plan_name, add_products=[prd_name])
self.syncplan.search(plan_name).click()
self.syncplan.wait_for_ajax()
self.syncplan.wait_until_element(tab_locators["sp.tab_products"]).\
click()
self.syncplan.wait_for_ajax()
prd_element = self.syncplan.wait_until_element(
(strategy, value % prd_name))
self.assertTrue(prd_element)
self.syncplan.update(plan_name, rm_products=[prd_name])
self.syncplan.search(plan_name).click()
self.syncplan.wait_for_ajax()
self.syncplan.wait_until_element(tab_locators["sp.tab_products"]).\
click()
self.syncplan.wait_for_ajax()
self.syncplan.wait_until_element(tab_locators["sp.add_prd"]).\
click()
self.syncplan.wait_for_ajax()
prd_element = self.syncplan.wait_until_element(
(strategy, value % prd_name))
self.assertTrue(prd_element)
@attr('ui', 'syncplan', 'implemented')
@data(*generate_strings_list())
def test_positive_delete_1(self, plan_name):
"""
@Feature: Content Sync Plan - Positive Delete
@Test: Delete a Sync plan
@Assert: Sync Plan is deleted
"""
description = "delete sync plan"
self.configure_syncplan()
self.syncplan.create(plan_name, description)
self.assertIsNotNone(self.products.search(plan_name))
self.syncplan.delete(plan_name)
self.assertIsNone(self.products.search(plan_name))
class Products(UITestCase):
"""Implements Product tests in UI"""
@classmethod
def setUpClass(cls): # noqa
cls.org_name = entities.Organization().create()['name']
cls.loc_name = entities.Location().create()['name']
super(Products, cls).setUpClass()
@run_only_on('sat')
@data(*generate_strings_list())
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))
@run_only_on('sat')
@data(*generate_strings_list())
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))
@run_only_on('sat')
@data(*generate_strings_list(len1=256))
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)
@run_only_on('sat')
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)
@run_only_on('sat')
def test_negative_create_3(self):
"""@Test: Create Content Product with whitespace input parameter
@Feature: Content Product - Negative Create with whitespace
@Assert: Product is not created
"""
locator = common_locators["common_invalid"]
prd_name = " "
description = "test_negative_create_3"
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)
@run_only_on('sat')
@data(*generate_strings_list())
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)
@run_only_on('sat')
@data(*generate_strings_list())
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))
@run_only_on('sat')
@data(*generate_strings_list())
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)
@skip_if_bug_open('redmine', 7845)
@run_only_on('sat')
@data(*generate_strings_list())
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))
class Domain(UITestCase):
"""Implements Domain tests in UI"""
@data(*generate_strings_list(len1=4))
def test_create_domain_1(self, name):
"""@Test: Create a new domain
@Feature: Domain - Positive Create domain
@Assert: Domain is created
"""
domain_name = description = DOMAIN % name
with Session(self.browser) as session:
make_domain(session, name=domain_name, description=description)
element = self.domain.search(description)
self.assertIsNotNone(element)
# The length of chars is in accordance with DOMAIN global variable.
@data(
gen_string('alphanumeric', 243),
gen_string('alpha', 243),
gen_string('numeric', 243),
gen_string('latin1', 243),
gen_string('utf8', 243),
)
def test_create_domain_2(self, name):
"""@Test: Create a new domain
@Feature: Domain - Positive Create domain with 255 chars
@Assert: Domain is created
"""
domain_name = description = DOMAIN % name
with Session(self.browser) as session:
make_domain(session, name=domain_name, description=description)
element = self.domain.search(description)
self.assertIsNotNone(element)
@data(*generate_strings_list(len1=4))
def test_remove_domain(self, name):
"""@Test: Delete a domain
@Feature: Domain - Delete
@Assert: Domain is deleted
"""
name = gen_string("alpha", 4)
domain_name = description = DOMAIN % name
with Session(self.browser) as session:
make_domain(session, name=domain_name, description=description)
element = self.domain.search(description)
self.assertIsNotNone(element)
self.domain.delete(description, really=True,)
self.assertIsNotNone(self.user.wait_until_element(
common_locators["notif.success"]))
self.assertIsNone(self.domain.search(description, timeout=5))
@data({'name': gen_string('alpha', 10),
'newname': gen_string('alpha', 10)},
{'name': gen_string('numeric', 10),
'newname': gen_string('numeric', 10)},
{'name': gen_string('alphanumeric', 10),
'newname': gen_string('alphanumeric', 10)},
{'name': gen_string('utf8', 10),
'newname': gen_string('utf8', 10)},
{'name': gen_string('latin1', 10),
'newname': gen_string('latin1', 10)},
{'name': gen_string('html', 10),
'newname': gen_string('html', 10)})
def test_update_domain(self, testdata):
"""@Test: Update a domain with name and description\
@Feature: Domain - Update
@Assert: Domain is updated
"""
domain_name = description = DOMAIN % testdata['name']
new_name = new_description = DOMAIN % testdata['newname']
with Session(self.browser) as session:
make_domain(session, name=domain_name, description=description)
element = self.domain.search(description)
self.assertIsNotNone(element)
self.domain.update(domain_name, new_name, new_description)
self.assertIsNotNone(self.domain.search(new_description))
# The length of chars is in accordance with DOMAIN global variable.
@data(*generate_strings_list(len1=244))
def test_negative_create_domain_1(self, name):
"""@Test: Negative create a domain with name and description\
@Feature: Domain - Negative Create
@Assert: Domain is not created
"""
domain_name = description = DOMAIN % name
with Session(self.browser) as session:
make_domain(session, name=domain_name, description=description)
element = self.domain.search(description, timeout=5)
self.assertIsNone(element)
@data("", " ")
def test_negative_create_domain_2(self, name):
"""@Test: Create domain with whitespace and blank in name
@Feature: Domain - Negative Create
@Assert: Domain is not created
"""
domain_name = description = name
with Session(self.browser) as session:
make_domain(session, name=domain_name, description=description)
error = session.nav.wait_until_element(
common_locators["name_haserror"])
self.assertIsNotNone(error)
@data(*generate_strings_list(len1=4))
def test_positive_set_domain_parameter_1(self, name):
"""@Test: Set parameter name and value for domain
@Feature: Domain - Misc
@Assert: Domain is updated
"""
domain_name = description = DOMAIN % name
param_name = gen_string("alpha", 4)
param_value = gen_string("alpha", 3)
with Session(self.browser) as session:
make_domain(session, name=domain_name, description=description)
element = self.domain.search(description)
self.assertIsNotNone(element)
try:
self.domain.set_domain_parameter(description, param_name,
param_value)
except Exception as e:
self.fail(e)
def test_positive_set_domain_parameter_2(self):
"""@Test: Set a parameter in a domain with 255 chars in name and value.
@Feature: Domain - Misc.
@Assert: Domain parameter is created.
"""
name = gen_string("alpha", 4)
domain_name = description = DOMAIN % name
param_name = gen_string("alpha", 255)
param_value = gen_string("alpha", 255)
with Session(self.browser) as session:
make_domain(session, name=domain_name, description=description)
element = self.domain.search(description)
self.assertIsNotNone(element)
try:
self.domain.set_domain_parameter(description, param_name,
param_value)
except Exception as e:
self.fail(e)
def test_positive_set_domain_parameter_3(self):
"""@Test: Set a parameter in a domain with blank value.
@Feature: Domain - Misc.
@Assert: Domain parameter is created with blank value.
"""
name = gen_string("alpha", 4)
domain_name = description = DOMAIN % name
param_name = gen_string("alpha", 4)
param_value = ""
with Session(self.browser) as session:
make_domain(session, name=domain_name, description=description)
element = self.domain.search(description)
self.assertIsNotNone(element)
try:
self.domain.set_domain_parameter(description, param_name,
param_value)
except Exception as e:
self.fail(e)
def test_set_domain_parameter_negative_1(self):
"""@Test: Set a parameter in a domain with 256 chars in name and value.
@Feature: Domain - Misc.
@Assert: Domain parameter is not updated.
"""
name = gen_string("alpha", 4)
domain_name = description = DOMAIN % name
param_name = gen_string("alpha", 256)
param_value = gen_string("alpha", 256)
with Session(self.browser) as session:
make_domain(session, name=domain_name, description=description)
element = self.domain.search(description)
self.assertIsNotNone(element)
try:
self.domain.set_domain_parameter(description, param_name,
param_value)
except Exception as e:
self.fail(e)
self.assertIsNotNone(session.nav.wait_until_element(
common_locators["common_param_error"]))
@skip_if_bug_open('bugzilla', 1123360)
def test_set_domain_parameter_negative_2(self):
"""@Test: Again set the same parameter for domain with name and value.
@Feature: Domain - Misc.
@Assert: Domain parameter is not updated.
@BZ: 1123360
"""
name = gen_string("alpha", 4)
domain_name = description = DOMAIN % name
param_name = gen_string("alpha", 8)
param_value = gen_string("alpha", 8)
with Session(self.browser) as session:
make_domain(session, name=domain_name, description=description)
element = self.domain.search(description)
self.assertIsNotNone(element)
try:
self.domain.set_domain_parameter(description, param_name,
param_value)
self.domain.set_domain_parameter(description, param_name,
param_value)
except Exception as e:
self.fail(e)
self.assertIsNotNone(session.nav.wait_until_element(
common_locators["common_param_error"]))
@data(*generate_strings_list(len1=4))
def test_remove_domain_parameter(self, name):
"""@Test: Remove a selected domain paramter
@Feature: Domain - Misc
@Assert: Domain parameter is removed
"""
domain_name = description = DOMAIN % name
param_name = gen_string("alpha", 3)
param_value = gen_string("alpha", 3)
with Session(self.browser) as session:
make_domain(session, name=domain_name, description=description)
element = self.domain.search(description)
self.assertIsNotNone(element)
try:
self.domain.set_domain_parameter(description, param_name,
param_value)
self.domain.remove_domain_parameter(description, param_name)
except Exception as e:
self.fail(e)
class Medium(UITestCase):
"""Implements all Installation Media tests"""
@data(*generate_strings_list(len1=4))
def test_positive_create_medium_1(self, name):
"""@Test: Create a new media
@Feature: Media - Positive Create
@Assert: Media is created
"""
path = INSTALL_MEDIUM_URL % gen_string("alpha", 6)
os_family = "Red Hat"
with Session(self.browser) as session:
make_media(session, name=name, path=path, os_family=os_family)
self.assertIsNotNone(self.medium.search(name))
@data(gen_string('alphanumeric', 255), gen_string('alpha', 255),
gen_string('numeric', 255), gen_string('latin1', 255),
gen_string('utf8', 255))
def test_positive_create_medium_2(self, name):
"""@Test: Create a new media with 255 characters in name
@Feature: Media - Positive Create
@Assert: Media is created
"""
path = INSTALL_MEDIUM_URL % gen_string("alpha", 6)
os_family = "Red Hat"
with Session(self.browser) as session:
make_media(session, name=name, path=path, os_family=os_family)
self.assertIsNotNone(self.medium.search(name))
def test_negative_create_medium_1(self):
"""@Test: Create a new install media with 256 characters in name
@Feature: Media - Negative Create
@Assert: Media is not created
"""
name = gen_string("alpha", 256)
path = INSTALL_MEDIUM_URL % name
os_family = "Red Hat"
with Session(self.browser) as session:
make_media(session, name=name, path=path, os_family=os_family)
self.assertIsNotNone(
self.medium.wait_until_element(
common_locators["name_haserror"]))
self.assertIsNone(self.medium.search(name))
@data("", " ")
def test_negative_create_medium_2(self, name):
"""@Test: Create a new install media with blank and whitespace in name
@Feature: Media - Negative Create
@Assert: Media is not created
"""
path = INSTALL_MEDIUM_URL % gen_string("alpha", 6)
os_family = "Red Hat"
with Session(self.browser) as session:
make_media(session, name=name, path=path, os_family=os_family)
self.assertIsNotNone(
self.medium.wait_until_element(
common_locators["name_haserror"]))
def test_negative_create_medium_4(self):
"""@Test: Create a new install media with same name
@Feature: Media - Negative Create
@Assert: Media is not created
"""
name = gen_string("alpha", 6)
path = INSTALL_MEDIUM_URL % name
os_family = "Red Hat"
with Session(self.browser) as session:
make_media(session, name=name, path=path, os_family=os_family)
self.assertIsNotNone(self.medium.search(name))
make_media(session, name=name, path=path, os_family=os_family)
self.assertIsNotNone(
self.medium.wait_until_element(
common_locators["name_haserror"]))
def test_negative_create_medium_5(self):
"""@Test: Create a new install media without media URL
@Feature: Media - Negative Create
@Assert: Media is not created
"""
name = gen_string("alpha", 6)
path = ""
os_family = "Red Hat"
with Session(self.browser) as session:
make_media(session, name=name, path=path, os_family=os_family)
self.assertIsNotNone(
self.medium.wait_until_element(common_locators["haserror"]))
self.assertIsNone(self.medium.search(name))
def test_negative_create_medium_6(self):
"""@Test: Create an install media with an existing URL
@Feature: Media - Negative Create
@Assert: Media is not created
"""
name = gen_string("alpha", 6)
new_name = gen_string("alpha", 6)
path = INSTALL_MEDIUM_URL % gen_string("alpha", 6)
os_family = "Red Hat"
with Session(self.browser) as session:
make_media(session, name=name, path=path, os_family=os_family)
self.assertIsNotNone(self.medium.search(name))
make_media(session, name=new_name, path=path, os_family=os_family)
self.assertIsNotNone(
self.medium.wait_until_element(common_locators["haserror"]))
self.assertIsNone(self.medium.search(new_name))
def test_remove_medium(self):
"""@Test: Delete a media
@Feature: Media - Delete
@Assert: Media is deleted
"""
name = gen_string("alpha", 6)
path = INSTALL_MEDIUM_URL % name
os_family = "Red Hat"
with Session(self.browser) as session:
make_media(session, name=name, path=path, os_family=os_family)
self.assertIsNotNone(self.medium.search(name))
self.medium.delete(name, True)
self.assertIsNone(self.medium.search(name))
def test_update_medium(self):
"""@Test: Updates Install media with name, path, OS family
@Feature: Media - Update
@Assert: Media is updated
"""
name = gen_string("alpha", 6)
newname = gen_string("alpha", 4)
path = INSTALL_MEDIUM_URL % name
newpath = INSTALL_MEDIUM_URL % newname
os_family = "Red Hat"
new_os_family = "Debian"
with Session(self.browser) as session:
make_media(session, name=name, path=path, os_family=os_family)
self.assertIsNotNone(self.medium.search(name))
self.medium.update(name, newname, newpath, new_os_family)
self.assertTrue(self, self.medium.search(newname))
class Syncplan(UITestCase):
"""Implements Sync Plan tests in UI"""
@classmethod
def setUpClass(cls): # noqa
org_attrs = entities.Organization().create()
cls.org_name = org_attrs['name']
cls.org_id = org_attrs['id']
super(Syncplan, cls).setUpClass()
@data({u'name': gen_string('alpha', 10),
u'desc': gen_string('alpha', 10),
u'interval': SYNC_INTERVAL['hour']},
{u'name': gen_string('numeric', 10),
u'desc': gen_string('numeric', 10),
u'interval': SYNC_INTERVAL['hour']},
{u'name': gen_string('alphanumeric', 10),
u'desc': gen_string('alphanumeric', 10),
u'interval': SYNC_INTERVAL['hour']},
{u'name': gen_string('utf8', 10),
u'desc': gen_string('utf8', 10),
u'interval': SYNC_INTERVAL['hour']},
{u'name': gen_string('html', 20),
u'desc': gen_string('html', 10),
u'interval': SYNC_INTERVAL['hour']},
{u'name': gen_string('alpha', 10),
u'desc': gen_string('alpha', 10),
u'interval': SYNC_INTERVAL['day']},
{u'name': gen_string('numeric', 10),
u'desc': gen_string('numeric', 10),
u'interval': SYNC_INTERVAL['day']},
{u'name': gen_string('alphanumeric', 10),
u'desc': gen_string('alphanumeric', 10),
u'interval': SYNC_INTERVAL['day']},
{u'name': gen_string('utf8', 10),
u'desc': gen_string('utf8', 10),
u'interval': SYNC_INTERVAL['day']},
{u'name': gen_string('html', 20),
u'desc': gen_string('html', 10),
u'interval': SYNC_INTERVAL['day']},
{u'name': gen_string('alpha', 10),
u'desc': gen_string('alpha', 10),
u'interval': SYNC_INTERVAL['week']},
{u'name': gen_string('numeric', 10),
u'desc': gen_string('numeric', 10),
u'interval': SYNC_INTERVAL['week']},
{u'name': gen_string('alphanumeric', 10),
u'desc': gen_string('alphanumeric', 10),
u'interval': SYNC_INTERVAL['week']},
{u'name': gen_string('utf8', 10),
u'desc': gen_string('utf8', 10),
u'interval': SYNC_INTERVAL['week']},
{u'name': gen_string('html', 20),
u'desc': gen_string('html', 10),
u'interval': SYNC_INTERVAL['week']})
def test_positive_create_1(self, test_data):
"""@Test: Create Sync Plan with minimal input parameters
@Feature: Content Sync Plan - Positive Create
@Assert: Sync Plan is created
"""
with Session(self.browser) as session:
make_syncplan(session, org=self.org_name,
name=test_data['name'],
description=test_data['desc'],
sync_interval=test_data['interval'])
self.assertIsNotNone(self.syncplan.search(test_data['name']))
@skip_if_bug_open('bugzilla', 1131661)
def test_positive_create_2(self):
"""@Test: Create Sync plan with specified start time
@Feature: Content Sync Plan - Positive Create
@Assert: Sync Plan is created with the specified time.
@BZ: 1131661
"""
locator = locators["sp.fetch_startdate"]
plan_name = gen_string("alpha", 8)
description = "sync plan create with start date"
current_date = datetime.now()
startdate = current_date + timedelta(minutes=10)
starthour = startdate.strftime("%H")
startminute = startdate.strftime("%M")
# Formatting current_date to web-UI format "%b %d, %Y %I:%M:%S %p" and
# removed zero-padded date(%-d) and hrs(%l) as fetching via web-UI
# doesn't have it
formatted_date_time = startdate.strftime("%b %-d, %Y %l:%M:%S %p")
# Removed the seconds info as it would be too quick to validate via UI.
starttime = formatted_date_time.rpartition(':')[0]
with Session(self.browser) as session:
make_syncplan(session, org=self.org_name, name=plan_name,
description=description, start_hour=starthour,
start_minute=startminute)
self.assertIsNotNone(self.syncplan.search(plan_name))
self.syncplan.search(plan_name).click()
self.syncplan.wait_for_ajax()
starttime_text = self.syncplan.wait_until_element(locator).text
# Removed the seconds info as it would be too quick
# to validate via UI.
saved_starttime = str(starttime_text).rpartition(':')[0]
self.assertEqual(saved_starttime, starttime)
@skip_if_bug_open('bugzilla', 1131661)
def test_positive_create_3(self):
"""@Test: Create Sync plan with specified start date
@Feature: Content Sync Plan - Positive Create
@Assert: Sync Plan is created with the specified date
@BZ: 1131661
"""
locator = locators["sp.fetch_startdate"]
plan_name = gen_string("alpha", 8)
description = "sync plan create with start date"
current_date = datetime.now()
startdate = current_date + timedelta(days=10)
startdate_str = startdate.strftime("%Y-%m-%d")
current_date_time = startdate.strftime("%b %-d, %Y %I:%M:%S %p")
# validating only for date
fetch_startdate = current_date_time.rpartition(',')[0]
with Session(self.browser) as session:
make_syncplan(session, org=self.org_name, name=plan_name,
description=description, startdate=startdate_str)
self.assertIsNotNone(self.syncplan.search(plan_name))
self.syncplan.search(plan_name).click()
self.syncplan.wait_for_ajax()
startdate_text = self.syncplan.wait_until_element(locator).text
saved_startdate = str(startdate_text).rpartition(',')[0]
self.assertEqual(saved_startdate, fetch_startdate)
@data("", " ")
def test_negative_create_1(self, name):
"""@Test: Create Sync Plan with blank and whitespace in name
@Feature: Content Sync Plan - Negative Create
@Assert: Sync Plan is not created
"""
locator = common_locators["common_invalid"]
with Session(self.browser) as session:
make_syncplan(session, org=self.org_name, name=name,
submit_validate=False)
invalid = self.syncplan.wait_until_element(locator)
self.assertIsNotNone(invalid)
@skip_if_bug_open('bugzilla', 1087425)
@data(*generate_strings_list(len1=256))
def test_negative_create_2(self, name):
"""@Test: Create Sync Plan with 256 characters in name
@Feature: Content Sync Plan - Negative Create
@Assert: Sync Plan is not created with more than 255 chars
@BZ: 1087425
"""
locator = common_locators["common_haserror"]
description = "more than 255 chars"
with Session(self.browser) as session:
make_syncplan(session, org=self.org_name, name=name,
description=description, submit_validate=False)
error = self.syncplan.wait_until_element(locator)
self.assertIsNotNone(error)
@data(*generate_strings_list())
def test_negative_create_3(self, name):
"""@Test: Create Sync Plan with an existing name
@Feature: Content Sync Plan - Positive Create
@Assert: Sync Plan cannot be created with existing name
@BZ: 1087425
"""
description = "with same name"
# TODO: Due to bug 1087425 using common_haserror instead of name_error
locator = common_locators["common_haserror"]
with Session(self.browser) as session:
make_syncplan(session, org=self.org_name, name=name)
self.assertIsNotNone(self.syncplan.search(name))
make_syncplan(session, org=self.org_name, name=name,
description=description, submit_validate=False)
error = self.syncplan.wait_until_element(locator)
self.assertIsNotNone(error)
@data(*generate_strings_list())
def test_positive_update_1(self, plan_name):
"""@Test: Update Sync plan's name
@Feature: Content Sync Plan - Positive Update name
@Assert: Sync Plan's name is updated
"""
new_plan_name = gen_string("alpha", 8)
entities.Organization(id=self.org_id).sync_plan(
name=plan_name,
interval=SYNC_INTERVAL['day']
)
with Session(self.browser) as session:
session.nav.go_to_select_org(self.org_name)
session.nav.go_to_sync_plans()
self.syncplan.update(plan_name, new_name=new_plan_name)
self.assertIsNotNone(self.syncplan.search(new_plan_name))
@data({u'name': gen_string('alpha', 10),
u'interval': SYNC_INTERVAL['hour']},
{u'name': gen_string('numeric', 10),
u'interval': SYNC_INTERVAL['hour']},
{u'name': gen_string('alphanumeric', 10),
u'interval': SYNC_INTERVAL['hour']},
{u'name': gen_string('utf8', 10),
u'interval': SYNC_INTERVAL['hour']},
{u'name': gen_string('html', 20),
u'interval': SYNC_INTERVAL['hour']},
{u'name': gen_string('alpha', 10),
u'interval': SYNC_INTERVAL['day']},
{u'name': gen_string('numeric', 10),
u'interval': SYNC_INTERVAL['day']},
{u'name': gen_string('alphanumeric', 10),
u'interval': SYNC_INTERVAL['day']},
{u'name': gen_string('utf8', 10),
u'interval': SYNC_INTERVAL['day']},
{u'name': gen_string('html', 20),
u'interval': SYNC_INTERVAL['day']},
{u'name': gen_string('alpha', 10),
u'interval': SYNC_INTERVAL['week']},
{u'name': gen_string('numeric', 10),
u'interval': SYNC_INTERVAL['week']},
{u'name': gen_string('alphanumeric', 10),
u'interval': SYNC_INTERVAL['week']},
{u'name': gen_string('utf8', 10),
u'interval': SYNC_INTERVAL['week']},
{u'name': gen_string('html', 20),
u'interval': SYNC_INTERVAL['week']})
def test_positive_update_2(self, test_data):
"""@Test: Update Sync plan's interval
@Feature: Content Sync Plan - Positive Update interval
@Assert: Sync Plan's interval is updated
"""
locator = locators["sp.fetch_interval"]
entities.Organization(id=self.org_id).sync_plan(
name=test_data['name'],
interval=SYNC_INTERVAL['day']
)
with Session(self.browser) as session:
session.nav.go_to_select_org(self.org_name)
session.nav.go_to_sync_plans()
self.syncplan.update(test_data['name'],
new_sync_interval=test_data['interval'])
session.nav.go_to_sync_plans()
self.syncplan.search(test_data['name']).click()
self.syncplan.wait_for_ajax()
# Assert updated sync interval
interval_text = self.syncplan.wait_until_element(locator).text
self.assertEqual(interval_text, test_data['interval'])
@data(*generate_strings_list())
def test_positive_update_3(self, plan_name):
"""@Test: Update Sync plan and associate products
@Feature: Content Sync Plan - Positive Update add products
@Assert: Sync Plan has the associated product
"""
strategy, value = locators["sp.prd_select"]
product_name = entities.Product(
organization=self.org_id
).create()['name']
entities.Organization(id=self.org_id).sync_plan(
name=plan_name,
interval=SYNC_INTERVAL['week']
)
with Session(self.browser) as session:
session.nav.go_to_select_org(self.org_name)
session.nav.go_to_sync_plans()
self.syncplan.update(plan_name, add_products=[product_name])
self.syncplan.search(plan_name).click()
self.syncplan.wait_for_ajax()
# Assert product is associated with sync plan
self.syncplan.wait_until_element(
tab_locators["sp.tab_products"]).click()
self.syncplan.wait_for_ajax()
element = self.syncplan.wait_until_element(
(strategy, value % product_name))
self.assertIsNotNone(element)
@data(*generate_strings_list())
def test_positive_update_4(self, plan_name):
"""@Test: Update Sync plan and disassociate products
@Feature: Content Sync Plan - Positive Update remove products
@Assert: Sync Plan does not have the associated product
"""
strategy, value = locators["sp.prd_select"]
product_name = entities.Product(
organization=self.org_id
).create()['name']
entities.Organization(id=self.org_id).sync_plan(
name=plan_name,
interval=SYNC_INTERVAL['week']
)
with Session(self.browser) as session:
session.nav.go_to_select_org(self.org_name)
session.nav.go_to_sync_plans()
self.syncplan.update(plan_name, add_products=[product_name])
self.syncplan.search(plan_name).click()
self.syncplan.wait_for_ajax()
self.syncplan.wait_until_element(
tab_locators["sp.tab_products"]).click()
self.syncplan.wait_for_ajax()
element = self.syncplan.wait_until_element(
(strategy, value % product_name))
self.assertIsNotNone(element)
# Dis-associate the product from sync plan and the selected product
# should automatically move from 'List/Remove` tab to 'Add' tab
self.syncplan.update(plan_name, rm_products=[product_name])
self.syncplan.search(plan_name).click()
self.syncplan.wait_for_ajax()
self.syncplan.wait_until_element(
tab_locators["sp.tab_products"]).click()
self.syncplan.wait_for_ajax()
self.syncplan.wait_until_element(
tab_locators["sp.add_prd"]).click()
self.syncplan.wait_for_ajax()
element = self.syncplan.wait_until_element(
(strategy, value % product_name))
self.assertIsNotNone(element)
@data(*generate_strings_list())
def test_positive_delete_1(self, plan_name):
"""@Test: Delete a Sync plan
@Feature: Content Sync Plan - Positive Delete
@Assert: Sync Plan is deleted
"""
entities.Organization(id=self.org_id).sync_plan(
name=plan_name,
interval=SYNC_INTERVAL['day']
)
with Session(self.browser) as session:
session.nav.go_to_select_org(self.org_name)
session.nav.go_to_sync_plans()
self.syncplan.delete(plan_name)
self.assertIsNone(self.syncplan.search(plan_name))
class Products(BaseUI):
"""
Implements Product tests in UI
"""
org_name = None
def setUp(self):
super(Products, self).setUp()
# Make sure to use the Class' org_name instance
if Products.org_name is None:
Products.org_name = generate_string("alpha", 8)
with Session(self.browser) as session:
make_org(session, org_name=Products.org_name)
@attr('ui', 'prd', 'implemented')
@data(*generate_strings_list())
def test_positive_create_0(self, prd_name):
"""
@Feature: Content Product - Positive Create
@Test: Create Content Product minimal input parameters
@Assert: Product is created
"""
description = "test 123"
self.login.login(self.katello_user, self.katello_passwd)
self.navigator.go_to_select_org(self.org_name)
self.navigator.go_to_products()
self.products.create(prd_name, description)
self.assertIsNotNone(self.products.search(prd_name))
@attr('ui', 'prd', 'implemented')
@data(*generate_strings_list(len1=256))
def test_negative_create_0(self, prd_name):
"""
@Feature: Content Product - Negative Create too long
@Test: Create Content Product with too long input parameters
@Assert: Product is not created
"""
locator = common_locators["common_haserror"]
description = "test_negative_create_0"
self.login.login(self.katello_user, self.katello_passwd)
self.navigator.go_to_select_org(Products.org_name)
self.navigator.go_to_products()
self.products.create(prd_name, description)
error = self.products.wait_until_element(locator)
self.assertTrue(error)
def test_negative_create_1(self):
"""
@Feature: Content Product - Negative Create zero length
@Test: Create Content Product without input parameter
@Assert: Product is not created
"""
locator = common_locators["common_invalid"]
prd_name = ""
description = "test_negative_create_1"
self.login.login(self.katello_user, self.katello_passwd)
self.navigator.go_to_select_org(Products.org_name)
self.navigator.go_to_products()
self.products.create(prd_name, description)
invalid = self.products.wait_until_element(locator)
self.assertTrue(invalid)
def test_negative_create_2(self):
"""
@Feature: Content Product - Negative Create with whitespace
@Test: Create Content Product with whitespace input parameter
@Assert: Product is not created
"""
locator = common_locators["common_invalid"]
prd_name = " "
description = "test_negative_create_2"
self.login.login(self.katello_user, self.katello_passwd)
self.navigator.go_to_select_org(Products.org_name)
self.navigator.go_to_products()
self.products.create(prd_name, description)
invalid = self.products.wait_until_element(locator)
self.assertTrue(invalid)
@attr('ui', 'prd', 'implemented')
@data(*generate_strings_list())
def test_negative_create_3(self, prd_name):
"""
@Feature: Content Product - Negative Create with same name
@Test: Create Content Product with same name input parameter
@Assert: Product is not created
"""
locator = common_locators["common_haserror"]
description = "test_negative_create_3"
self.login.login(self.katello_user, self.katello_passwd)
self.navigator.go_to_select_org(Products.org_name)
self.navigator.go_to_products()
self.products.create(prd_name, description)
self.assertIsNotNone(self.products.search(prd_name))
self.products.create(prd_name, description)
error = self.products.wait_until_element(locator)
self.assertTrue(error)
@attr('ui', 'prd', 'implemented')
@data(*generate_strings_list())
def test_positive_update_0(self, prd_name):
"""
@Feature: Content Product - Positive Update
@Test: Update Content Product with minimal input parameters
@Assert: Product is updated
"""
new_prd_name = generate_string("alpha", 8)
description = "test 123"
self.login.login(self.katello_user, self.katello_passwd)
self.navigator.go_to_select_org(self.org_name)
self.navigator.go_to_products()
self.products.create(prd_name, 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))
@attr('ui', 'prd', 'implemented')
@data(*generate_strings_list())
def test_negative_update_0(self, prd_name):
"""
@Feature: Content Product - Negative Update
@Test: Update Content Product with too long input parameters
@Assert: Product is not updated
"""
locator = common_locators["common_haserror"]
new_prd_name = generate_string("alpha", 256)
description = "test_negative_update_0"
self.login.login(self.katello_user, self.katello_passwd)
self.navigator.go_to_select_org(Products.org_name)
self.navigator.go_to_products()
self.products.create(prd_name, 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.assertTrue(error)
@attr('ui', 'prd', 'implemented')
@data(*generate_strings_list())
def test_remove_prd(self, prd_name):
"""
@Feature: Content Product - Positive Delete
@Test: Delete Content Product
@Assert: Product is deleted
"""
description = "test 123"
self.login.login(self.katello_user, self.katello_passwd)
self.navigator.go_to_select_org(self.org_name)
self.navigator.go_to_products()
self.products.create(prd_name, description)
self.assertIsNotNone(self.products.search(prd_name))
self.products.delete(prd_name, True)
self.assertIsNone(self.products.search(prd_name))