def generate_system_facts(name=None):
"""Generate random system facts for registration.
:param str name: A valid FQDN for a system. If one is not
provided, then a random value will be generated.
:return: A dictionary with random system facts
:rtype: dict
"""
if name is None:
name = u"{0}.example.net".format(FauxFactory.generate_alpha().lower())
# Make a copy of the system facts 'template'
new_facts = copy.deepcopy(SYSTEM_FACTS)
# Select a random RHEL version...
distro = FauxFactory.generate_choice(DISTRO_IDS)
# ...and update our facts
new_facts["distribution.id"] = distro["id"]
new_facts["distribution.version"] = distro["version"]
new_facts["dmi.bios.relase_date"] = _bios_date().strftime("%m/%d/%Y")
new_facts["dmi.memory.maximum_capacity"] = FauxFactory.generate_choice(MEMORY_CAPACITY)
new_facts["dmi.memory.size"] = FauxFactory.generate_choice(MEMORY_SIZE)
new_facts["dmi.system.uuid"] = FauxFactory.generate_uuid()
new_facts["dmi.system.version"] = u"RHEL"
new_facts["lscpu.architecture"] = distro["architecture"]
new_facts["net.interface.eth1.hwaddr"] = FauxFactory.generate_mac()
new_facts["net.interface.eth1.ipaddr"] = FauxFactory.generate_ipaddr()
new_facts["network.hostname"] = name
new_facts["network.ipaddr"] = new_facts["net.interface.eth1.ipaddr"]
new_facts["uname.machine"] = distro["architecture"]
new_facts["uname.nodename"] = name
new_facts["uname.release"] = distro["kernel"]
new_facts["virt.uuid"] = new_facts["dmi.system.uuid"]
return new_facts
def test_smoke(self):
"""
@Test: Check that basic content can be created
* Create a new user with admin permissions
* Using the new user from above:
* Create a new organization
* Create two new lifecycle environments
* Create a custom product
* Create a custom YUM repository
* Create a custom PUPPET repository
* Synchronize both custom repositories
* Create a new content view
* Associate both repositories to new content view
* Publish content view
* Promote content view to both lifecycles
* Create a new libvirt compute resource
* Create a new subnet
* Create a new domain
* Create a new capsule
* Create a new hostgroup and associate previous entities to it
@Feature: Smoke Test
@Assert: All entities are created and associated.
"""
# Create new user
new_user = make_user({'admin': 'true'})
# Create new org as new user
new_org = self._create(
new_user,
Org,
{u'name': self._generate_name()}
)
# Create new lifecycle environment 1
lifecycle1 = self._create(
new_user,
LifecycleEnvironment,
{u'organization-id': new_org['id'],
u'name': self._generate_name(),
u'prior': u'Library'}
)
# Create new lifecycle environment 2
lifecycle2 = self._create(
new_user,
LifecycleEnvironment,
{u'organization-id': new_org['id'],
u'name': self._generate_name(),
u'prior': lifecycle1['name']}
)
# Create a new product
new_product = self._create(
new_user,
Product,
{u'organization-id': new_org['id'],
u'name': self._generate_name()}
)
# Create a YUM repository
new_repo1 = self._create(
new_user,
Repository,
{u'product-id': new_product['id'],
u'name': self._generate_name(),
u'content-type': u'yum',
u'publish-via-http': u'true',
u'url': GOOGLE_CHROME_REPO}
)
# Create a Puppet repository
new_repo2 = self._create(
new_user,
Repository,
{u'product-id': new_product['id'],
u'name': self._generate_name(),
u'content-type': u'puppet',
u'publish-via-http': u'true',
u'url': FAKE_PUPPET_REPO}
)
# Synchronize YUM repository
result = Repository.with_user(
new_user['login'],
new_user['password']
).synchronize({'id': new_repo1['id']})
self.assertEqual(
result.return_code,
0,
u"Return code is non-zero: {0}".format(result.return_code))
self.assertEqual(
len(result.stderr),
0,
u"Failed to synchronize YUM repo: {0}".format(result.stderr))
# Synchronize puppet repository
result = Repository.with_user(
new_user['login'],
new_user['password']
).synchronize({'id': new_repo2['id']})
self.assertEqual(
result.return_code,
0,
u"Return code is non-zero: {0}".format(result.return_code))
self.assertEqual(
len(result.stderr),
0,
u"Failed to synchronize Puppet repo: {0}".format(result.stderr))
# Create a Content View
new_cv = self._create(
new_user,
ContentView,
{u'organization-id': new_org['id'],
u'name': self._generate_name()}
)
# Associate yum repository to content view
result = ContentView.with_user(
new_user['login'],
new_user['password']
).add_repository(
{u'id': new_cv['id'],
u'repository-id': new_repo1['id']})
self.assertEqual(
result.return_code,
0,
u"Return code is non-zero: {0}".format(result.return_code))
self.assertEqual(
len(result.stderr),
0,
u"Failed to add YUM repo to content view: {0}".format(
result.stderr))
# Fetch puppet module
puppet_result = PuppetModule.with_user(
new_user['login'],
new_user['password']
).list(
{u'repository-id': new_repo2['id'],
u'per-page': False})
self.assertEqual(
puppet_result.return_code,
0,
u"Return code is non-zero: {0}".format(result.return_code))
self.assertEqual(
len(puppet_result.stderr),
0,
u"Puppet modules list was not generated: {0}".format(
result.stderr))
# Associate puppet repository to content view
result = ContentView.with_user(
new_user['login'],
new_user['password']
).puppet_module_add(
{
u'content-view-id': new_cv['id'],
u'name': puppet_result.stdout[0]['name']
}
)
self.assertEqual(
result.return_code,
0,
u"Return code is non-zero: {0}".format(result.return_code))
self.assertEqual(
len(result.stderr),
0,
u"Failed to add YUM repo to content view: {0}".format(
result.stderr))
# Publish content view
result = ContentView.with_user(
new_user['login'],
new_user['password']
).publish({u'id': new_cv['id']})
self.assertEqual(
result.return_code,
0,
u"Return code is non-zero: {0}".format(result.return_code))
self.assertEqual(
len(result.stderr),
0,
u"Failed to publish content view: {0}".format(result.stderr))
# Only after we publish version1 the info is populated.
result = ContentView.with_user(
new_user['login'],
new_user['password']
).info({u'id': new_cv['id']})
self.assertEqual(
result.return_code,
0,
u"Return code is non-zero: {0}".format(result.return_code))
self.assertEqual(
len(result.stderr),
0,
u"Could not fetch content view info: {0}".format(result.stderr))
# Let us now store the version1 id
version1_id = result.stdout['versions'][0]['id']
# Promote content view to first lifecycle
result = ContentView.with_user(
new_user['login'],
new_user['password']
).version_promote(
{u'id': result.stdout['versions'][0]['id'],
u'lifecycle-environment-id': lifecycle1['id']})
self.assertEqual(
result.return_code,
0,
u"Return code is non-zero: {0}".format(result.return_code))
self.assertEqual(
len(result.stderr),
0,
u"Failed to promote content view to lifecycle '{0}': {1}".format(
lifecycle1['name'], result.stderr))
# Promote content view to second lifecycle
result = ContentView.with_user(
new_user['login'],
new_user['password']
).version_promote(
{u'id': version1_id,
u'lifecycle-environment-id': lifecycle2['id']})
self.assertEqual(
result.return_code,
0,
u"Return code is non-zero: {0}".format(result.return_code))
self.assertEqual(
len(result.stderr),
0,
u"Failed to promote content view to lifecycle '{0}': {1}".format(
lifecycle2['name'], result.stderr))
# Create a new libvirt compute resource
result = self._create(
new_user,
ComputeResource,
{
u'name': self._generate_name(),
u'provider': u'Libvirt',
u'url': u'qemu+tcp://{0}:16509/system'.format(
conf.properties['main.server.hostname'])
})
# Create a new subnet
new_subnet = self._create(
new_user,
Subnet,
{
u'name': self._generate_name(),
u'network': FauxFactory.generate_ipaddr(ip3=True),
u'mask': u'255.255.255.0'
}
)
# Create a domain
new_domain = self._create(
new_user,
Domain,
{
u'name': self._generate_name(),
}
)
# Fetch Puppet environment for second lifecycle
# (unfortunately it is not straight forward to extract this)
# The puppet environment we want has a name like this...
env_name = u'KT_{0}_{1}_'.format(
# Hyphens are replaced by underscores
new_org['label'].replace('-', '_',),
lifecycle2['label'].replace('-', '_')
)
# We fetch all the puppet environments for our organization...
result = Environment.with_user(
new_user['login'],
new_user['password']
).list(
{
u'search': u'organization=\"{0}\"'.format(
new_org['name'])
})
self.assertEqual(
result.return_code,
0,
u"Return code is non-zero: {0}".format(result.return_code))
self.assertEqual(
len(result.stderr),
0,
u"Failed to fetch puppet environments: {0}".format(
result.stderr))
# Now look for the puppet environment that matches lifecycle2
puppet_env = [
env for env in result.stdout if env['name'].startswith(
env_name)]
self.assertEqual(
len(puppet_env),
1,
u'Could not find the puppet environment: {0}'.format(env_name))
# Create new Capsule...
new_capsule = self._create(
new_user,
Proxy,
{
u'name': self._generate_name(),
u'url': u'https://{0}:9090/'.format(
conf.properties['main.server.hostname'])
}
)
# ...and add it to the organization
result = Org.with_user(
new_user['login'],
new_user['password']
).add_smart_proxy(
{
u'id': new_org['id'],
u'smart-proxy-id': new_capsule['id']
}
)
self.assertEqual(
result.return_code,
0,
u"Return code is non-zero: {0}".format(result.return_code))
self.assertEqual(
len(result.stderr),
0,
u"Failed to add capsule '{0}' to org '{1}': {2}".format(
new_capsule['name'], new_org['name'], result.stderr))
# Create a hostgroup...
new_hg = self._create(
new_user,
HostGroup,
{
u'name': self._generate_name(),
u'domain-id': new_domain['id'],
u'subnet-id': new_subnet['id'],
u'environment-id': puppet_env[0]['id'],
u'puppet-ca-proxy-id': new_capsule['id'],
u'puppet-proxy-id': new_capsule['id'],
}
)
# ...and add it to the organization
result = Org.with_user(
new_user['login'],
new_user['password']
).add_hostgroup(
{
u'id': new_org['id'],
u'hostgroup-id': new_hg['id']
}
)
self.assertEqual(
result.return_code,
0,
u"Return code is non-zero: {0}".format(result.return_code))
self.assertEqual(
len(result.stderr),
0,
u"Failed to add hostgroup '{0}' to org '{1}': {2}".format(
new_hg['name'], new_org['name'], result.stderr))
