def _prepare_browser(self, url):
"""Starts the browser, navigates to satellite, performs post-init
browser tweaks, initializes navigator and UI entities, and logs in to
satellite.
"""
if self._session_cookie:
LOGGER.info(
'Starting UI session id: %r from a session cookie',
self._session_cookie.cookies.get_dict()['_session_id'],
)
else:
LOGGER.info('Starting UI session %r for user %r', self.name, self._user)
self._factory = SeleniumBrowserFactory(
test_name=self.name, session_cookie=self._session_cookie, hostname=self._hostname
)
try:
selenium_browser = self._factory.get_browser()
self.browser = AirgunBrowser(selenium_browser, self)
LOGGER.info(f'Setting initial URL to {url}')
self.browser.url = url
self._factory.post_init()
# Navigator
self.navigator = Navigate(self.browser)
self.navigator.dest_dict = navigator.dest_dict.copy()
if self._session_cookie is None and self._login:
self.login.login({'username': self._user, 'password': self._password})
except Exception as exception:
self.__exit__(*sys.exc_info())
raise exception
def __enter__(self):
"""Starts the browser, navigates to satellite, performs post-init
browser tweaks, initializes navigator and UI entities, and logs in to
satellite.
"""
LOGGER.info(
u'Starting UI session %r for user %r', self.name, self._user)
self._factory = SeleniumBrowserFactory(test_name=self.name)
try:
selenium_browser = self._factory.get_browser()
selenium_browser.maximize_window()
self.browser = AirgunBrowser(selenium_browser, self)
self.browser.url = 'https://' + settings.satellite.hostname
self._factory.post_init()
# Navigator
self.navigator = copy.deepcopy(navigator)
self.navigator.browser = self.browser
self.login.login({
'username': self._user, 'password': self._password})
except Exception as exception:
self.__exit__(*sys.exc_info())
raise exception
return self
def __enter__(self):
"""Starts the browser, navigates to satellite, performs post-init
browser tweaks, initializes navigator and UI entities, and logs in to
satellite.
"""
LOGGER.info(u'Starting UI session %r for user %r', self.name,
self._user)
self._factory = SeleniumBrowserFactory(test_name=self.name)
selenium_browser = self._factory.get_browser()
selenium_browser.maximize_window()
self.browser = AirgunBrowser(selenium_browser, self)
self.browser.url = 'https://' + settings.satellite.hostname
self._factory.post_init()
# Navigator
self.navigator = copy.deepcopy(navigator)
self.navigator.browser = self.browser
# Entities
self.activationkey = ActivationKeyEntity(self.browser)
self.architecture = ArchitectureEntity(self.browser)
self.location = LocationEntity(self.browser)
self.login = LoginEntity(self.browser)
self.operatingsystem = OperatingSystemEntity(self.browser)
self.organization = OrganizationEntity(self.browser)
self.subnet = SubnetEntity(self.browser)
self.login.login({'username': self._user, 'password': self._password})
return self
class Session:
"""A session context manager which is a key controller in airgun.
It is responsible for initializing and starting
:class:`airgun.browser.AirgunBrowser`, navigating to satellite, performing
post-init browser tweaks, initializing navigator, all available UI
entities, and logging in to satellite.
When session is about to close, it saves a screenshot in case of any
exception, attempts to log out from satellite and performs all necessary
browser closure steps like quitting the browser, sending results to
saucelabs, stopping docker container etc.
For tests level it offers direct control over when UI session is started
and stopped as well as provides all the entities available without the need
to import and initialize them manually.
Usage::
def test_foo():
with Session('test_foo') as session:
session.architecture.create({'name': 'bar'})
[...]
# steps executed after UI session was closed
You can also pass credentials different from default ones specified in
settings like that::
with Session(test_name, user='******', password='******'):
# [...]
Every test may use multiple sessions if needed::
def test_foo():
with Session('test_foo', 'admin', 'password') as admin_session:
# UI steps, performed by 'admin' user
admin_session.user.create({'login': '******', 'password: '******'})
# [...]
with Session('test_foo', 'user1', 'pwd1') as user1_session:
# UI steps, performed by 'user1' user
user1_session.architecture.create({'name': 'bar'})
# [...]
Nested sessions are supported as well, just don't forget to use different
variables for sessions::
def test_foo():
with Session('test_foo', 'admin', 'password') as admin_session:
# UI steps, performed by 'admin' user only
admin_session.user.create({'login': '******', 'password: '******'})
# [...]
with Session('test_foo', 'user1', 'pwd1') as user1_session:
# UI steps, performed by 'user1' user OR 'admin' in
# different browser instances
user1_session.architecture.create({'name': 'bar'})
admin_session.architecture.search('bar')
# [...]
# UI steps, performed by 'admin' user only
admin_session.user.delete({'login': '******'})
"""
def __init__(
self,
session_name=None,
user=None,
password=None,
session_cookie=None,
hostname=None,
url=None,
login=True,
):
"""Stores provided values, doesn't perform any actions.
:param str optional session_name: string representing session name.
Used in screenshot names, saucelabs test results, docker container
names etc. You should provide your test name here in most cases.
Any '/' or ' ' characters will be converted to '_'.
Defaults to random alphanumeric value.
:param str optional user: username (login) of user, who will perform UI
actions. If None is passed - default one provided by settings will
beused.
:param str optional password: password for provided user. If None is
passed - default one from settings will be used.
:param requests.sessions.Session optional session_cookie: session object to be used
to bypass login
and hostname)
:param str optional hostname: The hostname of a target that differs from
settings.satellite.hostname
:param str optional url: URL path to open when starting session (without protocol
"""
if session_name:
for c in '/ ':
session_name = session_name.replace(c, '_')
self.name = session_name or gen_string('alphanumeric')
self._user = user or settings.satellite.username
self._password = password or settings.satellite.password
self._session_cookie = session_cookie
self._factory = None
self._hostname = hostname or settings.satellite.hostname
self._url = url
self._login = login
self.navigator = None
self.browser = None
def __call__(self, user=None, password=None, session_cookie=None, url=None, login=None):
"""Stores provided values. This allows tests to provide additional
value when Session object is returned from fixture and used as
context manager. Arguments are the same as when initializing
Session object, except session_name.
"""
if user is not None:
self._user = user
if password is not None:
self._password = password
if session_cookie is not None:
self._session_cookie = session_cookie
if url is not None:
self._url = url
if login is not None:
self._login = login
return self
def __enter__(self):
"""Just a shim to make it compatible with context manager
protocol. The real work is done by _open the first time
any entity is requested.
"""
return self
def __exit__(self, exc_type, exc_value, traceback):
"""Attempts to log out, saves the screenshot and performs all required
session closure activities.
NOTE: exceptions during logout or saving screenshot are just logged and
not risen not to shadow real session result.
"""
if self.browser is None:
# browser was never started, don't do anything
return
LOGGER.info('Stopping UI session %r for user %r', self.name, self._user)
passed = True if exc_type is None else False
try:
if not passed:
self.take_screenshot()
except Exception as err:
LOGGER.exception(err)
finally:
self._factory.finalize(passed)
def _open(self, entity):
"""Initializes requested entity. If this is first time session
requests an entity, also initialize and prepare browser.
"""
if self.browser is None:
if self._url:
endpoint = self._url
else:
endpoint = getattr(entity, 'endpoint_path', '/')
full_url = f"https://{self._hostname}{endpoint}"
self._prepare_browser(full_url)
return entity(self.browser)
def _prepare_browser(self, url):
"""Starts the browser, navigates to satellite, performs post-init
browser tweaks, initializes navigator and UI entities, and logs in to
satellite.
"""
if self._session_cookie:
LOGGER.info(
'Starting UI session id: %r from a session cookie',
self._session_cookie.cookies.get_dict()['_session_id'],
)
else:
LOGGER.info('Starting UI session %r for user %r', self.name, self._user)
self._factory = SeleniumBrowserFactory(
test_name=self.name, session_cookie=self._session_cookie, hostname=self._hostname
)
try:
selenium_browser = self._factory.get_browser()
self.browser = AirgunBrowser(selenium_browser, self)
LOGGER.info(f'Setting initial URL to {url}')
self.browser.url = url
self._factory.post_init()
# Navigator
self.navigator = Navigate(self.browser)
self.navigator.dest_dict = navigator.dest_dict.copy()
if self._session_cookie is None and self._login:
self.login.login({'username': self._user, 'password': self._password})
except Exception as exception:
self.__exit__(*sys.exc_info())
raise exception
def take_screenshot(self):
"""Take screen shot from the current browser window.
The screenshot named f'{self.name}-screenshot-YYYY-mm-dd_HH_MM_SS.png'
will be stored in the path f'{settings.screenshots_path}/YYYY-mm-dd/'.
All directories will be created if they don't exist. Make sure that the
user running Robottelo has the right permissions to create files and
directories.
This method is called automatically in case any exception during UI
session happens.
"""
now = datetime.now()
path = os.path.join(
settings.selenium.screenshots_path,
now.strftime('%Y-%m-%d'),
)
if not os.path.exists(path):
os.makedirs(path)
path = os.path.join(
path,
f'{self.name}-screenshot-{now.strftime("%Y-%m-%d_%H_%M_%S")}.png',
)
LOGGER.debug('Saving screenshot %s', path)
if not self.browser.selenium.save_screenshot(path):
LOGGER.error('Failed to save screenshot %s', path)
@cached_property
def activationkey(self):
"""Instance of Activation Key entity."""
return self._open(ActivationKeyEntity)
@cached_property
def architecture(self):
"""Instance of Architecture entity."""
return self._open(ArchitectureEntity)
@cached_property
def audit(self):
"""Instance of Audit entity."""
return self._open(AuditEntity)
@cached_property
def bookmark(self):
"""Instance of Bookmark entity."""
return self._open(BookmarkEntity)
@cached_property
def cloudinventory(self):
"""Instance of RH Cloud Inventory Upload entity."""
return self._open(CloudInventoryEntity)
@cached_property
def cloudinsights(self):
"""Instance of RH Cloud Insights entity."""
return self._open(CloudInsightsEntity)
@cached_property
def computeprofile(self):
"""Instance of Compute Profile entity."""
return self._open(ComputeProfileEntity)
@cached_property
def configgroup(self):
"""Instance of Config Group entity."""
return self._open(ConfigGroupEntity)
@cached_property
def containerimagetag(self):
"""Instance of Container Image Tags entity."""
return self._open(ContainerImageTagEntity)
@cached_property
def contentcredential(self):
"""Instance of Content Credential entity."""
return self._open(ContentCredentialEntity)
@cached_property
def contenthost(self):
"""Instance of Content Host entity."""
return self._open(ContentHostEntity)
@cached_property
def computeresource(self):
"""Instance of ComputeResource entity."""
return self._open(ComputeResourceEntity)
@cached_property
def contentview(self):
"""Instance of Content View entity."""
return self._open(ContentViewEntity)
@cached_property
def contentviewfilter(self):
"""Instance of Content View Filter entity."""
return self._open(ContentViewFilterEntity)
@cached_property
def dashboard(self):
"""Instance of Dashboard entity."""
return self._open(DashboardEntity)
@cached_property
def discoveredhosts(self):
return self._open(DiscoveredHostsEntity)
@cached_property
def discoveryrule(self):
"""Instance of Discovery Rule entity."""
return self._open(DiscoveryRuleEntity)
@cached_property
def domain(self):
"""Instance of domain entity."""
return self._open(DomainEntity)
@cached_property
def errata(self):
"""Instance of Errata entity."""
return self._open(ErrataEntity)
@cached_property
def filter(self):
"""Instance of Filter entity."""
return self._open(FilterEntity)
@cached_property
def hardwaremodel(self):
"""Instance of Hardware Model entity."""
return self._open(HardwareModelEntity)
@cached_property
def host(self):
"""Instance of Host entity."""
return self._open(HostEntity)
@cached_property
def hostcollection(self):
"""Instance of Host Collection entity."""
return self._open(HostCollectionEntity)
@cached_property
def hostgroup(self):
"""Instance of Host Group entity."""
return self._open(HostGroupEntity)
@cached_property
def http_proxy(self):
"""Instance of HTTP Proxy entity."""
return self._open(HTTPProxyEntity)
@cached_property
def insightsaction(self):
"""Instance of RHAI Action entity."""
return self._open(ActionEntity)
@cached_property
def insightsinventory(self):
"""Instance of RHAI Inventory entity."""
return self._open(InventoryHostEntity)
@cached_property
def insightsoverview(self):
"""Instance of RHAI Overview entity."""
return self._open(OverviewEntity)
@cached_property
def insightsplan(self):
"""Instance of RHAI Plan entity."""
return self._open(PlanEntity)
@cached_property
def insightsrule(self):
"""Instance of RHAI Rule entity."""
return self._open(RuleEntity)
@cached_property
def jobinvocation(self):
"""Instance of Job Invocation entity."""
return self._open(JobInvocationEntity)
@cached_property
def insightsmanage(self):
"""Instance of RHAI Manage entity."""
return self._open(ManageEntity)
@cached_property
def jobtemplate(self):
"""Instance of Job Template entity."""
return self._open(JobTemplateEntity)
@cached_property
def ldapauthentication(self):
"""Instance of LDAP Authentication entity."""
return self._open(LDAPAuthenticationEntity)
@cached_property
def lifecycleenvironment(self):
"""Instance of LCE entity."""
return self._open(LCEEntity)
@cached_property
def location(self):
"""Instance of Location entity."""
return self._open(LocationEntity)
@cached_property
def login(self):
"""Instance of Login entity."""
return self._open(LoginEntity)
@cached_property
def operatingsystem(self):
"""Instance of Operating System entity."""
return self._open(OperatingSystemEntity)
@cached_property
def organization(self):
"""Instance of Organization entity."""
return self._open(OrganizationEntity)
@cached_property
def oscapcontent(self):
"""Instance of OSCAP Content entity."""
return self._open(OSCAPContentEntity)
@cached_property
def oscappolicy(self):
"""Instance of OSCAP Policy entity."""
return self._open(OSCAPPolicyEntity)
@cached_property
def oscaptailoringfile(self):
"""Instance of OSCAP Tailoring File entity."""
return self._open(OSCAPTailoringFileEntity)
@cached_property
def package(self):
"""Instance of Packge entity."""
return self._open(PackageEntity)
@cached_property
def media(self):
"""Instance of Media entity."""
return self._open(MediaEntity)
@cached_property
def modulestream(self):
"""Instance of Module Stream entity."""
return self._open(ModuleStreamEntity)
@cached_property
def partitiontable(self):
"""Instance of Partition Table entity."""
return self._open(PartitionTableEntity)
@cached_property
def puppetclass(self):
"""Instance of Puppet Class entity."""
return self._open(PuppetClassEntity)
@cached_property
def puppetenvironment(self):
"""Instance of Puppet Environment entity."""
return self._open(PuppetEnvironmentEntity)
@cached_property
def product(self):
"""Instance of Product entity."""
return self._open(ProductEntity)
@cached_property
def provisioningtemplate(self):
"""Instance of Provisioning Template entity."""
return self._open(ProvisioningTemplateEntity)
@cached_property
def reporttemplate(self):
"""Instance of Report Template entity."""
return self._open(ReportTemplateEntity)
@cached_property
def redhatrepository(self):
"""Instance of Red Hat Repository entity."""
return self._open(RedHatRepositoryEntity)
@cached_property
def repository(self):
"""Instance of Repository entity."""
return self._open(RepositoryEntity)
@cached_property
def role(self):
"""Instance of Role entity."""
return self._open(RoleEntity)
@cached_property
def rhsso_login(self):
"""Instance of RHSSOLoginEntity entity."""
return self._open(RHSSOLoginEntity)
@cached_property
def settings(self):
"""Instance of Settings entity."""
return self._open(SettingsEntity)
@cached_property
def sc_parameter(self):
"""Instance of Smart Class Parameter entity."""
return self._open(SmartClassParameterEntity)
@cached_property
def smartvariable(self):
"""Instance of Smart Variable entity."""
return self._open(SmartVariableEntity)
@cached_property
def subnet(self):
"""Instance of Subnet entity."""
return self._open(SubnetEntity)
@cached_property
def subscription(self):
"""Instance of Subscription entity."""
return self._open(SubscriptionEntity)
@cached_property
def syncplan(self):
"""Instance of Sync Plan entity."""
return self._open(SyncPlanEntity)
@cached_property
def sync_status(self):
"""Instance of Sync Status entity"""
return self._open(SyncStatusEntity)
@cached_property
def sync_template(self):
"""Instance of Sync Templates entity"""
return self._open(SyncTemplatesEntity)
@cached_property
def task(self):
"""Instance of Task entity."""
return self._open(TaskEntity)
@cached_property
def user(self):
"""Instance of User entity."""
return self._open(UserEntity)
@cached_property
def usergroup(self):
"""Instance of User Group entity."""
return self._open(UserGroupEntity)
@cached_property
def virtwho_configure(self):
"""Instance of Virtwho Configure entity."""
return self._open(VirtwhoConfigureEntity)
class Session(object):
"""A session context manager which is a key controller in airgun.
It is responsible for initializing and starting
:class:`airgun.browser.AirgunBrowser`, navigating to satellite, performing
post-init browser tweaks, initializing navigator, all available UI
entities, and logging in to satellite.
When session is about to close, it saves a screenshot in case of any
exception, attempts to log out from satellite and performs all necessary
browser closure steps like quitting the browser, sending results to
saucelabs, stopping docker container etc.
For tests level it offers direct control over when UI session is started
and stopped as well as provides all the entities available without the need
to import and initialize them manually.
Usage::
def test_foo():
# steps executed before starting UI session
# [...]
# start of UI session
with Session('test_foo') as session:
# steps executed during UI session. For example:
session.architecture.create({'name': 'bar'})
[...]
# steps executed after UI session was closed
You can also pass credentials different from default ones specified in
settings like that::
with Session(test_name, user='******', password='******'):
# [...]
Every test may use multiple sessions if needed::
def test_foo():
with Session('test_foo', 'admin', 'password') as admin_session:
# UI steps, performed by 'admin' user
admin_session.user.create({'login': '******', 'password: '******'})
# [...]
with Session('test_foo', 'user1', 'pwd1') as user1_session:
# UI steps, performed by 'user1' user
user1_session.architecture.create({'name': 'bar'})
# [...]
Nested sessions are supported as well, just don't forget to use different
variables for sessions::
def test_foo():
with Session('test_foo', 'admin', 'password') as admin_session:
# UI steps, performed by 'admin' user only
admin_session.user.create({'login': '******', 'password: '******'})
# [...]
with Session('test_foo', 'user1', 'pwd1') as user1_session:
# UI steps, performed by 'user1' user OR 'admin' in
# different browser instances
user1_session.architecture.create({'name': 'bar'})
admin_session.architecture.search('bar')
# [...]
# UI steps, performed by 'admin' user only
admin_session.user.delete({'login': '******'})
"""
def __init__(self, session_name=None, user=None, password=None):
"""Stores provided values, doesn't perform any actions.
:param str optional session_name: string representing session name.
Used in screenshot names, saucelabs test results, docker container
names etc. You should provide your test name here in most cases.
Defaults to random alphanumeric value.
:param str optional user: username (login) of user, who will perform UI
actions. If None is passed - default one provided by settings will
beused.
:param str optional password: password for provided user. If None is
passed - default one from settings will be used.
"""
self.name = session_name or gen_string('alphanumeric')
self._user = user or settings.satellite.username
self._password = password or settings.satellite.password
self._factory = None
self.browser = None
def __enter__(self):
"""Starts the browser, navigates to satellite, performs post-init
browser tweaks, initializes navigator and UI entities, and logs in to
satellite.
"""
LOGGER.info(
u'Starting UI session %r for user %r', self.name, self._user)
self._factory = SeleniumBrowserFactory(test_name=self.name)
try:
selenium_browser = self._factory.get_browser()
selenium_browser.maximize_window()
self.browser = AirgunBrowser(selenium_browser, self)
self.browser.url = 'https://' + settings.satellite.hostname
self._factory.post_init()
# Navigator
self.navigator = copy.deepcopy(navigator)
self.navigator.browser = self.browser
self.login.login({
'username': self._user, 'password': self._password})
except Exception as exception:
self.__exit__(*sys.exc_info())
raise exception
return self
def __exit__(self, exc_type, exc_value, traceback):
"""Attempts to log out, saves the screenshot and performs all required
session closure activities.
NOTE: exceptions during logout or saving screenshot are just logged and
not risen not to shadow real session result.
"""
LOGGER.info(
u'Stopping UI session %r for user %r', self.name, self._user)
passed = True if exc_type is None else False
try:
if passed:
self.login.logout()
else:
self.take_screenshot()
except Exception as err:
LOGGER.exception(err)
finally:
self._factory.finalize(passed)
def take_screenshot(self):
"""Take screen shot from the current browser window.
The screenshot named ``screenshot-YYYY-mm-dd_HH_MM_SS.png`` will be
placed on the path specified by
``settings.screenshots_path/YYYY-mm-dd/ClassName/method_name/``.
All directories will be created if they don't exist. Make sure that the
user running Robottelo have the right permissions to create files and
directories matching the complete.
This method is called automatically in case any exception during UI
session happens.
"""
now = datetime.now()
path = os.path.join(
settings.selenium.screenshots_path,
now.strftime('%Y-%m-%d'),
)
if not os.path.exists(path):
os.makedirs(path)
filename = '{0}-screenshot-{1}.png'.format(
self.name.replace(' ', '_'),
now.strftime('%Y-%m-%d_%H_%M_%S')
)
path = os.path.join(path, filename)
LOGGER.debug('Saving screenshot %s', path)
self.browser.selenium.save_screenshot(path)
@cached_property
def activationkey(self):
"""Instance of Activation Key entity."""
return ActivationKeyEntity(self.browser)
@cached_property
def architecture(self):
"""Instance of Architecture entity."""
return ArchitectureEntity(self.browser)
@cached_property
def computeprofile(self):
"""Instance of Compute Profile entity."""
return ComputeProfileEntity(self.browser)
@cached_property
def contentcredential(self):
"""Instance of Content Credential entity."""
return ContentCredentialEntity(self.browser)
@cached_property
def contentview(self):
"""Instance of Content View entity."""
return ContentViewEntity(self.browser)
@cached_property
def hostcollection(self):
"""Instance of Host Collection entity."""
return HostCollectionEntity(self.browser)
@cached_property
def lifecycleenvironment(self):
"""Instance of LCE entity."""
return LCEEntity(self.browser)
@cached_property
def location(self):
"""Instance of Location entity."""
return LocationEntity(self.browser)
@cached_property
def login(self):
"""Instance of Login entity."""
return LoginEntity(self.browser)
@cached_property
def operatingsystem(self):
"""Instance of Operating System entity."""
return OperatingSystemEntity(self.browser)
@cached_property
def organization(self):
"""Instance of Organization entity."""
return OrganizationEntity(self.browser)
@cached_property
def partitiontable(self):
"""Instance of Partition Table entity."""
return PartitionTableEntity(self.browser)
@cached_property
def product(self):
"""Instance of Product entity."""
return ProductEntity(self.browser)
@cached_property
def provisioningtemplate(self):
"""Instance of Provisioning Template entity."""
return ProvisioningTemplateEntity(self.browser)
@cached_property
def subnet(self):
"""Instance of Subnet entity."""
return SubnetEntity(self.browser)
@cached_property
def syncplan(self):
"""Instance of Sync Plan entity."""
return SyncPlanEntity(self.browser)
@cached_property
def user(self):
"""Instance of User entity."""
return UserEntity(self.browser)
class Session(object):
"""A session context manager which is a key controller in airgun.
It is responsible for initializing and starting
:class:`airgun.browser.AirgunBrowser`, navigating to satellite, performing
post-init browser tweaks, initializing navigator, all available UI
entities, and logging in to satellite.
When session is about to close, it saves a screenshot in case of any
exception, attempts to log out from satellite and performs all necessary
browser closure steps like quitting the browser, sending results to
saucelabs, stopping docker container etc.
For tests level it offers direct control over when UI session is started
and stopped as well as provides all the entities available without the need
to import and initialize them manually.
Usage::
def test_foo():
# steps executed before starting UI session
# [...]
# start of UI session
with Session('test_foo') as session:
# steps executed during UI session. For example:
session.architecture.create({'name': 'bar'})
[...]
# steps executed after UI session was closed
You can also pass credentials different from default ones specified in
settings like that::
with Session(test_name, user='******', password='******'):
# [...]
Every test may use multiple sessions if needed::
def test_foo():
with Session('test_foo', 'admin', 'password') as admin_session:
# UI steps, performed by 'admin' user
admin_session.user.create({'login': '******', 'password: '******'})
# [...]
with Session('test_foo', 'user1', 'pwd1') as user1_session:
# UI steps, performed by 'user1' user
user1_session.architecture.create({'name': 'bar'})
# [...]
Nested sessions are supported as well, just don't forget to use different
variables for sessions::
def test_foo():
with Session('test_foo', 'admin', 'password') as admin_session:
# UI steps, performed by 'admin' user only
admin_session.user.create({'login': '******', 'password: '******'})
# [...]
with Session('test_foo', 'user1', 'pwd1') as user1_session:
# UI steps, performed by 'user1' user OR 'admin' in
# different browser instances
user1_session.architecture.create({'name': 'bar'})
admin_session.architecture.search('bar')
# [...]
# UI steps, performed by 'admin' user only
admin_session.user.delete({'login': '******'})
"""
def __init__(self, session_name=None, user=None, password=None, session_cookie=None):
"""Stores provided values, doesn't perform any actions.
:param str optional session_name: string representing session name.
Used in screenshot names, saucelabs test results, docker container
names etc. You should provide your test name here in most cases.
Defaults to random alphanumeric value.
:param str optional user: username (login) of user, who will perform UI
actions. If None is passed - default one provided by settings will
beused.
:param str optional password: password for provided user. If None is
passed - default one from settings will be used.
:param requests.sessions.Session optional session_cookie: session object to be used
to bypass login
"""
self.name = session_name or gen_string('alphanumeric')
self._user = user or settings.satellite.username
self._password = password or settings.satellite.password
self._session_cookie = session_cookie
self._factory = None
self.browser = None
def __enter__(self):
"""Starts the browser, navigates to satellite, performs post-init
browser tweaks, initializes navigator and UI entities, and logs in to
satellite.
"""
if self._session_cookie:
LOGGER.info(u'Starting UI session id: %r from a session cookie',
self._session_cookie.cookies.get_dict()['_session_id'])
else:
LOGGER.info(u'Starting UI session %r for user %r', self.name, self._user)
self._factory = SeleniumBrowserFactory(
test_name=self.name,
session_cookie=self._session_cookie
)
try:
selenium_browser = self._factory.get_browser()
self.browser = AirgunBrowser(selenium_browser, self)
self.browser.url = 'https://' + settings.satellite.hostname
self._factory.post_init()
# Navigator
self.navigator = copy.deepcopy(navigator)
self.navigator.browser = self.browser
if self._session_cookie is None:
self.login.login({
'username': self._user, 'password': self._password})
except Exception as exception:
self.__exit__(*sys.exc_info())
raise exception
return self
def __exit__(self, exc_type, exc_value, traceback):
"""Attempts to log out, saves the screenshot and performs all required
session closure activities.
NOTE: exceptions during logout or saving screenshot are just logged and
not risen not to shadow real session result.
"""
LOGGER.info(
u'Stopping UI session %r for user %r', self.name, self._user)
passed = True if exc_type is None else False
try:
if passed:
self.login.logout()
else:
self.take_screenshot()
except Exception as err:
LOGGER.exception(err)
finally:
self._factory.finalize(passed)
def take_screenshot(self):
"""Take screen shot from the current browser window.
The screenshot named ``screenshot-YYYY-mm-dd_HH_MM_SS.png`` will be
placed on the path specified by
``settings.screenshots_path/YYYY-mm-dd/ClassName/method_name/``.
All directories will be created if they don't exist. Make sure that the
user running Robottelo have the right permissions to create files and
directories matching the complete.
This method is called automatically in case any exception during UI
session happens.
"""
now = datetime.now()
path = os.path.join(
settings.selenium.screenshots_path,
now.strftime('%Y-%m-%d'),
)
if not os.path.exists(path):
os.makedirs(path)
filename = '{0}-screenshot-{1}.png'.format(
self.name.replace(' ', '_'),
now.strftime('%Y-%m-%d_%H_%M_%S')
)
path = os.path.join(path, filename)
LOGGER.debug('Saving screenshot %s', path)
self.browser.selenium.save_screenshot(path)
@cached_property
def activationkey(self):
"""Instance of Activation Key entity."""
return ActivationKeyEntity(self.browser)
@cached_property
def architecture(self):
"""Instance of Architecture entity."""
return ArchitectureEntity(self.browser)
@cached_property
def audit(self):
"""Instance of Audit entity."""
return AuditEntity(self.browser)
@cached_property
def bookmark(self):
"""Instance of Bookmark entity."""
return BookmarkEntity(self.browser)
@cached_property
def computeprofile(self):
"""Instance of Compute Profile entity."""
return ComputeProfileEntity(self.browser)
@cached_property
def configgroup(self):
"""Instance of Config Group entity."""
return ConfigGroupEntity(self.browser)
@cached_property
def container(self):
"""Instance of Container entity."""
return ContainerEntity(self.browser)
@cached_property
def containerimagetag(self):
"""Instance of Container Image Tags entity."""
return ContainerImageTagEntity(self.browser)
@cached_property
def contentcredential(self):
"""Instance of Content Credential entity."""
return ContentCredentialEntity(self.browser)
@cached_property
def contenthost(self):
"""Instance of Content Host entity."""
return ContentHostEntity(self.browser)
@cached_property
def computeresource(self):
"""Instance of ComputeResource entity."""
return ComputeResourceEntity(self.browser)
@cached_property
def contentview(self):
"""Instance of Content View entity."""
return ContentViewEntity(self.browser)
@cached_property
def contentviewfilter(self):
"""Instance of Content View Filter entity."""
return ContentViewFilterEntity(self.browser)
@cached_property
def dashboard(self):
"""Instance of Dashboard entity."""
return DashboardEntity(self.browser)
@cached_property
def discoveredhosts(self):
return DiscoveredHostsEntity(self.browser)
@cached_property
def discoveryrule(self):
"""Instance of Discovery Rule entity."""
return DiscoveryRuleEntity(self.browser)
@cached_property
def domain(self):
"""Instance of domain entity."""
return DomainEntity(self.browser)
@cached_property
def errata(self):
"""Instance of Errata entity."""
return ErrataEntity(self.browser)
@cached_property
def filter(self):
"""Instance of Filter entity."""
return FilterEntity(self.browser)
@cached_property
def hardwaremodel(self):
"""Instance of Hardware Model entity."""
return HardwareModelEntity(self.browser)
@cached_property
def host(self):
"""Instance of Host entity."""
return HostEntity(self.browser)
@cached_property
def hostcollection(self):
"""Instance of Host Collection entity."""
return HostCollectionEntity(self.browser)
@cached_property
def hostgroup(self):
"""Instance of Host Group entity."""
return HostGroupEntity(self.browser)
@cached_property
def insightsaction(self):
"""Instance of RHAI Action entity."""
return ActionEntity(self.browser)
@cached_property
def insightsinventory(self):
"""Instance of RHAI Inventory entity."""
return InventoryHostEntity(self.browser)
@cached_property
def insightsoverview(self):
"""Instance of RHAI Overview entity."""
return OverviewEntity(self.browser)
@cached_property
def insightsplan(self):
"""Instance of RHAI Plan entity."""
return PlanEntity(self.browser)
@cached_property
def insightsrule(self):
"""Instance of RHAI Rule entity."""
return RuleEntity(self.browser)
@cached_property
def jobinvocation(self):
"""Instance of Job Invocation entity."""
return JobInvocationEntity(self.browser)
@cached_property
def insightsmanage(self):
"""Instance of RHAI Manage entity."""
return ManageEntity(self.browser)
@cached_property
def jobtemplate(self):
"""Instance of Job Template entity."""
return JobTemplateEntity(self.browser)
@cached_property
def ldapauthentication(self):
"""Instance of LDAP Authentication entity."""
return LDAPAuthenticationEntity(self.browser)
@cached_property
def lifecycleenvironment(self):
"""Instance of LCE entity."""
return LCEEntity(self.browser)
@cached_property
def location(self):
"""Instance of Location entity."""
return LocationEntity(self.browser)
@cached_property
def login(self):
"""Instance of Login entity."""
return LoginEntity(self.browser)
@cached_property
def operatingsystem(self):
"""Instance of Operating System entity."""
return OperatingSystemEntity(self.browser)
@cached_property
def organization(self):
"""Instance of Organization entity."""
return OrganizationEntity(self.browser)
@cached_property
def oscapcontent(self):
"""Instance of OSCAP Content entity."""
return OSCAPContentEntity(self.browser)
@cached_property
def oscappolicy(self):
"""Instance of OSCAP Policy entity."""
return OSCAPPolicyEntity(self.browser)
@cached_property
def oscaptailoringfile(self):
"""Instance of OSCAP Tailoring File entity."""
return OSCAPTailoringFileEntity(self.browser)
@cached_property
def package(self):
"""Instance of Packge entity."""
return PackageEntity(self.browser)
@cached_property
def media(self):
"""Instance of Media entity."""
return MediaEntity(self.browser)
@cached_property
def modulestream(self):
"""Instance of Module Stream entity."""
return ModuleStreamEntity(self.browser)
@cached_property
def partitiontable(self):
"""Instance of Partition Table entity."""
return PartitionTableEntity(self.browser)
@cached_property
def puppetclass(self):
"""Instance of Puppet Class entity."""
return PuppetClassEntity(self.browser)
@cached_property
def puppetenvironment(self):
"""Instance of Puppet Environment entity."""
return PuppetEnvironmentEntity(self.browser)
@cached_property
def product(self):
"""Instance of Product entity."""
return ProductEntity(self.browser)
@cached_property
def provisioningtemplate(self):
"""Instance of Provisioning Template entity."""
return ProvisioningTemplateEntity(self.browser)
@cached_property
def reporttemplate(self):
"""Instance of Report Template entity."""
return ReportTemplateEntity(self.browser)
@cached_property
def redhatrepository(self):
"""Instance of Red Hat Repository entity."""
return RedHatRepositoryEntity(self.browser)
@cached_property
def repository(self):
"""Instance of Repository entity."""
return RepositoryEntity(self.browser)
@cached_property
def role(self):
"""Instance of Role entity."""
return RoleEntity(self.browser)
@cached_property
def settings(self):
"""Instance of Settings entity."""
return SettingsEntity(self.browser)
@cached_property
def sc_parameter(self):
"""Instance of Smart Class Parameter entity."""
return SmartClassParameterEntity(self.browser)
@cached_property
def smartvariable(self):
"""Instance of Smart Variable entity."""
return SmartVariableEntity(self.browser)
@cached_property
def subnet(self):
"""Instance of Subnet entity."""
return SubnetEntity(self.browser)
@cached_property
def subscription(self):
"""Instance of Subscription entity."""
return SubscriptionEntity(self.browser)
@cached_property
def syncplan(self):
"""Instance of Sync Plan entity."""
return SyncPlanEntity(self.browser)
@cached_property
def sync_status(self):
"""Instance of Sync Status entity"""
return SyncStatusEntity(self.browser)
@cached_property
def task(self):
"""Instance of Task entity."""
return TaskEntity(self.browser)
@cached_property
def trend(self):
"""Instance of Trend entity."""
return TrendEntity(self.browser)
@cached_property
def user(self):
"""Instance of User entity."""
return UserEntity(self.browser)
@cached_property
def usergroup(self):
"""Instance of User Group entity."""
return UserGroupEntity(self.browser)
@cached_property
def virtwho_configure(self):
"""Instance of Virtwho Configure entity."""
return VirtwhoConfigureEntity(self.browser)
