def Set_S3_Credentials(self, access_key, secret_key, location=None):
"""
Initializes a connection to an S3 API endpoint
Must be called before any other keywords are used
_access_key_ is the AWS access key
_secret_key_ is the AWS secret key
_location_ is the S3 API endpoint. If not set, defaults to AWS, can
be in the format https://host:port or http://host:port
"""
if location:
host, port, is_secure, path = self._parse_s3_location(location)
logger.debug("Initializing S3Connection to host %s" % host)
self._conn = S3Connection(access_key, secret_key,
host=host, port=port, is_secure=is_secure,
calling_format=OrdinaryCallingFormat(),
validate_certs=False,
path=path)
else:
logger.debug("Initializing S3Connection to AWS default")
self._conn = S3Connection(access_key, secret_key,
calling_format=OrdinaryCallingFormat(),
validate_certs=False)
def connect_to_rabbitmq (self, host, port, username = '******', password = '******', timeout = 15, alias = None):
"""
Подключение к серверу RabbitMq.
*Args:*\n
_host_ - имя сервера;\n
_port_ - номер порта;\n
_username_ - имя пользователя;\n
_password_ - пароль пользователя;\n
_timeout_ - время ожидания соединения;\n
_alias_ - псевдоним соединения;\n
*Returns:*\n
Индекс текущего соединения.
*Raises:*\n
socket.error в том случае, если невозможно создать соединение.
*Example:*\n
| Connect To Rabbitmq | my_host_name | 15672 | guest | guest | alias=rmq |
"""
port=int (port)
timeout=int (timeout)
logger.debug ('Connecting using : host=%s, port=%d, username=%s, password=%s, timeout=%d, alias=%s '%(host, port, username, password, timeout, alias))
self.headers={"Authorization":"Basic "+base64.b64encode(username+":"+password)}
try:
self._connection=httplib.HTTPConnection (host, port, timeout)
self._connection.connect()
return self._cache.register(self._connection, alias)
except socket.error, e:
raise Exception ("Could not connect to RabbitMq", str(e))
def start_process(self, command, *arguments, **configuration):
"""Starts a new process on background.
See `Specifying command and arguments` and `Process configuration`
for more information about the arguments.
Makes the started process new `active process`. Returns an identifier
that can be used as a handle to active the started process if needed.
"""
config = ProcessConfig(**configuration)
executable_command = self._cmd(arguments, command, config.shell)
logger.info('Starting process:\n%s' % executable_command)
logger.debug('Process configuration:\n%s' % config)
process = subprocess.Popen(executable_command,
stdout=config.stdout_stream,
stderr=config.stderr_stream,
stdin=subprocess.PIPE,
shell=config.shell,
cwd=config.cwd,
env=config.env,
universal_newlines=True)
self._results[process] = ExecutionResult(process,
config.stdout_stream,
config.stderr_stream)
return self._processes.register(process, alias=config.alias)
def docker_process_args(passed_args_dict, default_args_dict, method_name):
"""Accepts two dicts and combines them preferring passed
args while filling unspecified args with default values.
Parameters:
:param passed_args_dict: A dict of the passed keyword args for the method.
:param default_args_dict: A dict of the default keyword args for the method.
Returns:
:returns dict: returns dict containing passed args, with
defaults for all other keyword args.
"""
logger.info("Processing args for %s method" % method_name)
logger.info(passed_args_dict)
logger.info(default_args_dict)
processed_args_dict = {}
if passed_args_dict is None:
passed_args_dict = {}
try:
for key in default_args_dict:
if key in passed_args_dict:
processed_args_dict[key] = passed_args_dict[key]
else:
processed_args_dict[key] = default_args_dict[key]
except TypeError:
logger.debug("Error: One or both of the passed arguments is not a dictionary")
return processed_args_dict
def query(self, selectStatement, **named_args):
"""
Uses the input `selectStatement` to query for the values that
will be returned as a list of tuples.
Tip: Unless you want to log all column values of the specified rows,
try specifying the column names in your select statements
as much as possible to prevent any unnecessary surprises with schema
changes and to easily see what your [] indexing is trying to retrieve
(i.e. instead of `"select * from my_table"`, try
`"select id, col_1, col_2 from my_table"`).
For example, given we have a table `person` with the following data:
| id | first_name | last_name |
| 1 | Franz Allan | See |
When you do the following:
| @{queryResults} | Query | SELECT * FROM person |
| Log Many | @{queryResults} |
You will get the following:
[1, 'Franz Allan', 'See']
Also, you can do something like this:
| ${queryResults} | Query | SELECT first_name, last_name FROM person |
| Log | ${queryResults[0][1]}, ${queryResults[0][0]} |
And get the following
See, Franz Allan
"""
logger.debug("Running query: {query}".format(query=selectStatement))
logger.debug("Query parameters: {named_args}".format(named_args=named_args))
with self._dbconnection.begin():
logger.info(selectStatement)
return self._dbconnection.execute(selectStatement, **named_args).fetchall()
def read_single_value_from_table(self, tableName, columnName, whereClause):
"""
Reads single value from table.
If there will be more than one row that satisfies performed query, \
then this will throw an AssertionError.
*Arguments:*
- tableName: string, table name.
- columnName: string, column name or names divided by comma.
*Return:*
- Fetched single value.
*Examples:*
| @{queryResult} | Read Single Value From Table | employee \
| name, surname | age=27 |
"""
sqlStatement = 'SELECT %s FROM %s WHERE %s' % (columnName, tableName,
whereClause)
result = self.query(sqlStatement)
assert len(result) == 1, \
("Expected to have 1 row from '%s' "
"but got %s rows : %s." % (sqlStatement, len(result), result))
logger.debug("Got 1 row from %s: %s." % (sqlStatement, result))
return result[0]
def _print_link(self, path, rc):
if rc == 0:
name = path + '.png'
logger.info('<a href="%s"><img src="%s"></a>' % (name, name), True)
else:
logger.debug('Message sequence generation with seqdiag failed. Linking sequence file instead.')
logger.info('<a href="%s">Message sequence</a>' % path, True)
def verify_number_of_rows_matching_where(self, tableName, where,
rowNumValue):
"""
Fetches rows using given where-clause from the table with given
'tableName'.
Verifies that number of rows equals to the given rowNumValue,
otherwise AssertionError is thrown.
If number of rows will be not equal to actual, \
then this will throw an AssertionError.
*Arguments:*
- tableName: string, table name;
- where: string, where-clause;
- rowNumValue: int, expected number of rows.
*Return:*
- None.
*Examples:*
| Verify Number Of Rows Matching Where | TableName | name='John' | 12 |
"""
selectStatement = "select * from %s where %s" % (tableName, where)
count = self.rows_count(selectStatement)
assert count == rowNumValue, ("Expected to get %s row(s) for where-"
"clause statement '%s', but got %s." %
(rowNumValue, where, count))
logger.debug("Number of rows matching 'where %s' statement equals to"
"%s." % (where, rowNumValue))
def verify_resource_id_has_attributes_in_DB(self, resource_id, label, order='', label_tag='', company_typ_cd=''):
if company_typ_cd!='':
statement = "Select * from Presentation where PRSNTTN_LABEL='%s' and PRSNTTN_ORDER in ('%s')" \
"and PRSNTTN_LABEL_TAG in ('%s') and PRSNTTN_ID in " \
"(select PRSNTTN_ID from RESOURC where RSRC_ID='%s' and CMPNY_TYP_CD ='%s')"%(label, order, label_tag, resource_id, company_typ_cd)
elif order!='' and label_tag!='':
statement = "Select * from Presentation where PRSNTTN_LABEL='%s' and PRSNTTN_ORDER in ('%s')" \
"and PRSNTTN_LABEL_TAG in ('%s') and PRSNTTN_ID in " \
"(select PRSNTTN_ID from RESOURC where RSRC_ID='%s')"%(label, order, label_tag, resource_id)
else:
statement = "Select * from Presentation where PRSNTTN_LABEL='%s' and PRSNTTN_ID in " \
"(select PRSNTTN_ID from RESOURC where RSRC_ID='%s')"%(label, resource_id)
logger.debug("fun: verify_resource_id_has_attributes_in_DB")
logger.debug(statement)
try:
self.conn.check_if_exists_in_database(statement)
msg = "==Verified Resource '%s' has attributes in DB Succeed! \nRSRC_ID %s has Label-->'%s' + Order-->'%s' + Tag-->'%s' and Company_Type_CD-->'%s'\n %s"%(resource_id, resource_id, label, order, label_tag, company_typ_cd, statement)
logger.info(msg)
except AssertionError, e:
query = "select PRSNTTN_LABEL, PRSNTTN_ORDER, PRSNTTN_LABEL_TAG from Presentation where PRSNTTN_ID in "\
"(select PRSNTTN_ID from RESOURC where RSRC_ID='%s')"%(resource_id)
result = self.conn.query(query)
admin = self.conn.query("SELECT CMPNY_TYP_CD FROM RESOURC WHERE RSRC_ID='%s'"%resource_id)
msg = "!!!Expected:['%s', '%s', '%s', '%s'] --> Actual: [%s, %s]"%(label, order, label_tag, company_typ_cd, result[0], admin[0][0])
logger.warn(e.message)
raise AssertionError(msg)
def get_json_file(self, path):
"""Returns [http://goo.gl/o0X6Pp|JSON] object from [http://goo.gl/o0X6Pp|JSON] file
with all variables replaced.
Arguments:
- ``path``: The path to JSON file.
Examples:
_request.json_
| [{
| "bad": ${false},
| "good": ${true},
| "key": 5.5,
| "key2": "value2"
| }]
| @{var} = | Get JSON File | request.json |
| # [{'key2': 'value2', 'bad': False, 'good': True, 'key': Decimal('5.5')}] |
"""
content = self._os.get_file(path)
content = self._builtin.replace_variables(content)
content = sub(r'(False|True)', lambda match: match.group(1).lower(), content)
logger.debug(content)
return self.json_loads(content)
def _execute_sql(self, sqlStatement, commitNeeded=False):
"""
Executes sql.
*Arguments:*
- sqlStatement: string, sql statement.
- commitNeeded: bool, if True - commit will be performed after
executing statement.
*Return:*
- Database cursor object.
"""
try:
cur = self._connectionCache.current.connection.cursor()
logger.debug("Executing: %s" % sqlStatement)
cur.execute(sqlStatement)
if commitNeeded:
self._connectionCache.current.connection.commit()
return cur
finally:
if cur:
logger.debug("Rolling back: %s" % sqlStatement)
self._connectionCache.current.connection.rollback()
def update_entity(self, type, id, update_field_value_map, parent_type=None, parent_id=None):
"""
The lock/unlock check-out/check-in are implemented as per the manual, but we always get 404 error
and the update is actually successful without such operation. so we comment these for actions for now
:param type:
:param id:
:param update_field_value_map:
:param parent_type:
:param parent_id:
:return:
"""
url = self._base_url
if parent_type != None:
url += '/%ss/%s' % (parent_type, parent_id) # hacky~~ again TODO
url += '/%ss/%s' % (type, id)
# lock entity first
# self.lock_entity(url)
# self.check_out_entity(url,'Checking out by auto test script')
update_field_value_map['_type'] = type
xml = self._convert_entity_to_xml(update_field_value_map)
logger.debug(url)
logger.debug(xml)
local_headers = self.headers.copy()
local_headers['Content-type'] = 'application/xml'
http = httplib2.Http()
resp_header, resp_content = http.request(url, 'PUT', body=xml, headers=local_headers)
if resp_header['status'] != '200': # OK
# raise RuntimeError(
logger.warn(resp_header)
logger.warn(resp_content)
logger.warn(
'Not able to update entity with fields %s, see the log for response details' % update_field_value_map)
# self.check_in_entity(url, 'Checking out by auto test script')
# self.unlock_entity(url)
return self._parse_alm_entities(resp_content)
def table_must_contain_more_than_number_of_rows(self, tableName,
rowsNumber):
"""
Checks that table contains more number of rows than specified.
If table contains less or equal number of rows than specified, \
then this will throw an AssertionError.
*Arguments:*
- tableName: string, table name.
- rowsNumber: int, rows number.
*Return:*
- None
*Examples:*
| Table Must Contain More Than Number Of Rows | employee | 1000 |
"""
selectStatement = "SELECT * FROM %s" % tableName
rowsCount = self.rows_count(selectStatement)
assert rowsCount > rowsNumber,\
('Table %s has %s row(s) but should have more than %s row(s).'
% (tableName, rowsCount, rowsNumber))
logger.debug("Table %s contains %s row(s)." % (tableName, rowsCount))
def select_user(self, user_id, error=None):
"""
Assumes current browser is on the user selection page
:param user_id:
:return:
"""
xpath_candidates = ("xpath=//select[@name='dnqualifier']",)
for xpath in xpath_candidates:
logger.debug("Try xpath %s " % xpath)
logger.warn("Try xpath %s " % xpath)
ele = self._element_find(xpath, True, False)
if ele is not None:
ele = self._element_find("xpath=//option[@value='%s']" % user_id, True, False)
if ele is not None:
self.select_from_list(xpath, user_id)
else:
logger.warn("xpath=//option[contains(@value,'%s')]" % user_id, True)
ele = self._element_find("xpath=//option[contains(@value,'%s')]" % user_id, True, False)
if ele is not None:
full_value = ele.get_attribute("value")
self.select_from_list(xpath, full_value)
else:
raise RuntimeError("Not able to find user selection by value %s " % user_id)
return
raise AssertionError("Could not find user selection")
def get_transaction_isolation_level(self):
"""
Gets transaction isolation level.
*Note:* This method works only with 'psycopg2' driver.
*Arguments:*
- None
*Return:*
- Value that contains the name of the transaction isolation level
Possible return values are: TRANSACTION_READ_UNCOMMITTED, \
TRANSACTION_READ_COMMITTED, TRANSACTION_REPEATABLE_READ, \
TRANSACTION_SERIALIZABLE or TRANSACTION_NONE.
*Examples:*
| ${isolation_level} | Get Transaction Isolation Level |
"""
# // TODO: Extend this method to work with other drivers.
driverName = self._connectionCache.current.driverName
assert driverName == 'psycopg2',\
"Impossible to use this keyword with '%s' driver." % driverName
selectStatement = "SELECT CURRENT_SETTING('transaction_isolation');"
result = 'TRANSACTION_%s' % \
self.query(selectStatement)[0][0].replace(' ', '_').upper()
logger.debug("Transaction isolation level is %s." % result)
return result
def transaction_isolation_level_must_be(self, transactionLevel):
"""
Checks that transaction isolation level is equal to specified.
If transaction isolation level is not equal to specified, then this \
will throw an AssertionError.
*Note:* This method works only with 'psycopg2' driver.
*Arguments:*
- transactionLevel: string, transaction isolation level.
Possible return values are: TRANSACTION_READ_UNCOMMITTED, \
TRANSACTION_READ_COMMITTED, TRANSACTION_REPEATABLE_READ, \
TRANSACTION_SERIALIZABLE or TRANSACTION_NONE.
*Return:*
- None
*Examples:*
| ${isolation_level} | Get Transaction Isolation Level |
"""
result = self.get_transaction_isolation_level()
assert transactionLevel.upper() == result, \
("Expected transaction isolation level '%s' "
"but current is '%s'." % (transactionLevel.upper(), result))
logger.debug("Transaction isolation level is %s." % result)
def load_template(self, template, *args, **kws):
msg = Pos3Msg(self.templatemap[template])
for arg in args:
if arg.count('=') == 1:
k, v = arg.split('=')
kws[k] = v
kws.update(self.fields)
for k, v in kws.items():
msg.setField(k, v)
if not self.checkedin and template not in ['TEMPLATE_POSCHECKIN_1', 'TEMPLATE_POSCHECKIN_2']:
self.check_in()
if not kws or 'voucherNo' not in kws.keys():
msg.setField('voucherNo', self._get_next_voucherNo())
if self.batchNo and (not kws or 'batchNo' not in kws.keys()):
msg.setField('batchNo', self.batchNo)
if not kws or 'transactionRandId' not in kws.keys():
msg.setField('transactionRandId', self.generate_transactionRandId())
self.sendmsg = msg.constructMsg()
logger.debug('===Sending Message:'+self.sendmsg)
return self.sendmsg
def check_primary_key_columns_for_table(self, tableName, columns):
"""
Checks that specified primary key columns equal to table key columns.
If table contains less or greater number of rows than specified,
then this will throw an AssertionError.
*Note:* This method works only with 'psycopg2' driver.
*Arguments:*
- tableName: string, table name.
- columns: list or string divided by comma, table columns.
*Return:*
- Primary key columns.
*Examples:*
| ${key_columns} | Check Primary Key Columns For Table \
| id, password_hash |
"""
tableColumns = self.get_primary_key_columns_for_table(tableName)
if not isinstance(columns, list):
columns = [c.strip().lower() for c in columns.split(',')]
assert set(tableColumns) == set(columns),\
('Primary key columns %s in table %s do not match '
'with specified %s.' % (tableColumns, tableName, columns))
logger.debug("Primary key columns %s in table %s match with specified"
" %s." % (tableColumns, tableName, columns))
def get_all_stats(path):
logger.info('Getting stats from <a href="file://%s">%s</a>' % (path, path),
html=True)
stats_line = _get_stats_line(path)
logger.debug('Stats line: %s' % stats_line)
total, tags, suite = eval(stats_line)
return total, tags, suite
def __set_isolation_level(self, level):
try:
self._dbconnection.set_isolation_level(level)
except:
logger.debug("Error setting isolation level")
self._dbconnection.rollback()
raise
def createTestCase(self, testProjectId, testSuiteId, testCaseName, summary, authorlogin, steps = ''):
"""
Создание нового тесткейса.
*Args:*\n
_testProjectId_ - ID проекта, в который необходимо добавить тесткейс;\n
_testSuiteId_ - ID тестсьюты, в которую необходимо добавить тесткейс;\n
_testCaseName_ - имя тесткейса;\n
_summary_ - описание тесткейса;\n
_authorlogin_ - имя пользователя, от которого создаётся тесткейс;\n
_steps_ - шаги выполнения тесткейса;
*Returns:*\n
ID созданного тесткейса.
"""
data={"devKey": self.devKey,
"testprojectid": testProjectId,
"testsuiteid": testSuiteId,
"testcasename":testCaseName,
"summary":summary,
"authorlogin":authorlogin}
data['actiononduplicatedname']='block'
data['checkduplicatedname']='true'
data['steps']=steps
answer=self.server.tl.createTestCase(data)
out=answer[0]
logger.debug (out)
testcaseid=out ['id']
return testcaseid
def db_elements_are_not_equal(self, selectStatement, firstAliasOrIndex,
secondAliasOrIndex):
"""
Checks that fetched results of performed query on two
databases are not equal.
If DB elements will be equal, then this will
throw an AssertionError.
*Arguments:*
- selectStatement: string, sql select statement.
- firstAliasOrIndex: string or int, alias or index of \
first database.
- secondAliasOrIndex: string or int, alias or index of \
second database.
*Return:*
- None
*Examples:*
| DB Elements Are Not Equal | select name, surname from employee | \
SomeCompanyDB1 | SomeCompanyDB1 |
"""
result = self._get_elements_from_two_db(selectStatement,
firstAliasOrIndex,
secondAliasOrIndex)
assert set(result[0]) != set(result[1]), \
("Expected to have not equal elements but they equal. "
"Query result:'%s'" % (result[0]))
logger.debug("Results fetched from %s on %s and %s databases are"
" not equal." % (selectStatement, firstAliasOrIndex,
secondAliasOrIndex))
def _cmp_bool(src, dst):
try:
if bool(src) == bool(dst):
return True
except:
logger.debug("_cmp_bool: expect bool but get %s" % str(type(src)))
logger.debug("_cmp_bool: Can not convert to bool: %s" % str(src))
return False
def run_ansible_extended_params(self, paramDict):
"""
Run Ansible by passing Runner a dict of parameters
@param paramDict:
"""
result = ansible.runner.Runner(**paramDict).run()
logger.debug(result)
return result
def Create_Bucket(self, bucket):
"""
Creates a bucket
_bucket_: name of bucket to create
"""
logger.debug("Creating bucket %s" % bucket)
self._conn.create_bucket(bucket)
def user_should_not_have_permissions_in_xroads7_web_service(self, user_login_id, *permissions):
all_permission = self.clt.service.getAllUserPerms(user_login_id)
logger.debug("All permissions: %s " % ', '.join(all_permission))
actually_in = Xroads7WS.none_in_long(list(permissions), all_permission)
logger.debug("Permissions not expected but assigned : %s " % ', '.join(actually_in))
if len(actually_in) > 0:
raise AssertionError("User %s should NOT have any of permissions %s. But actually %s are available"
% (user_login_id, list(permissions), actually_in))
def user_should_have_permissions_in_xroads7_web_service(self, user_login_id, *permissions):
all_permission = self.clt.service.getAllUserPerms(user_login_id)
logger.debug("All permissions: %s " % ', '.join(all_permission))
actually_not_in = Xroads7WS.all_in_long(list(permissions), all_permission)
logger.debug("Permissions expected but missing: %s " % ', '.join(actually_not_in))
if len(actually_not_in) > 0:
raise AssertionError("User %s should have these permissions %s. But actually %s are not available"
% (user_login_id, list(permissions), actually_not_in))
def _normalize(self, elements):
# Apparently IEDriver has returned invalid data earlier and recently
# ChromeDriver has done sometimes returned None:
# https://github.com/SeleniumHQ/selenium/issues/4555
if not isinstance(elements, list):
logger.debug("WebDriver find returned %s" % elements)
return []
return elements
def __init__(self, display_size=(1280, 1024)):
logger.debug(" ... in ext_robot constructor ... ")
if sys.platform.startswith("linux"):
from pyvirtualdisplay import Display
self.display = Display(visible=0, size=display_size)
else:
self.display = None
def _eval_math_expr(src, dst):
if not isinstance(src, (int, long, float)):
logger.debug("_eval_math_expr: receives src non-int/long/float: %s" % str(src))
return False
for t in (int, long, float):
if isinstance(src, t) and eval(str(t(src)).join(dst.split('y'))):
return True
logger.debug("_eval_math_expr: '%s' not satisfied math expr '%s'" % (str(src), dst))
return False
def _remotelib(self):
if self.__remotelib is None:
uri = BuiltIn().get_variable_value('${PABOTLIBURI}')
logger.debug('PabotLib URI %r' % uri)
self.__remotelib = Remote(uri) if uri else None
return self.__remotelib
def __init__(self, ifname):
"""
Instantiate a new DnsmasqDhcpServerWrapper object that observes a dnsmasq DHCP server via D-Bus
"""
self._lease_database = DhcpServerLeaseList()
self._ifname = ifname # We store the interface but dnsmasq does not provide information concerning the interface in its D-Bus announcements... so we cannot use it for now
# This also means that we can have only one instance of dnsmasq on the machine, or leases for all interfaces will mix in our database
self._watched_macaddr = None # The MAC address on which we are currently waiting for a lease to be allocated (or renewed)
self.watched_macaddr_got_lease_event = threading.Event(
) # At initialisation, event is cleared
self._dbus_loop = gobject.MainLoop()
self._bus = dbus.SystemBus()
wait_bus_owner_timeout = 5 # Wait for 5s to have an owner for the bus name we are expecting
logger.debug('Going to wait for an owner on bus name ' +
DnsmasqDhcpServerWrapper.DNSMASQ_DBUS_NAME)
while not self._bus.name_has_owner(
DnsmasqDhcpServerWrapper.DNSMASQ_DBUS_NAME):
time.sleep(0.2)
wait_bus_owner_timeout -= 0.2
if wait_bus_owner_timeout <= 0: # We timeout without having an owner for the expected bus name
raise Exception('No owner found for bus name ' +
DnsmasqDhcpServerWrapper.DNSMASQ_DBUS_NAME)
logger.debug('Got an owner for bus name ' +
DnsmasqDhcpServerWrapper.DNSMASQ_DBUS_NAME)
gobject.threads_init(
) # Allow the mainloop to run as an independent thread
dbus.mainloop.glib.threads_init()
dbus_object_name = DnsmasqDhcpServerWrapper.DNSMASQ_DBUS_OBJECT_PATH
logger.debug('Going to communicate with object ' + dbus_object_name)
self._dnsmasq_proxy = self._bus.get_object(
DnsmasqDhcpServerWrapper.DNSMASQ_DBUS_SERVICE_INTERFACE,
dbus_object_name) # Required to attach to signals
self._dbus_iface = dbus.Interface(
self._dnsmasq_proxy, DnsmasqDhcpServerWrapper.
DNSMASQ_DBUS_SERVICE_INTERFACE) # Required to invoke methods
logger.debug("Connected to D-Bus")
self._dnsmasq_proxy.connect_to_signal(
"DhcpLeaseAdded",
self._handleDhcpLeaseAdded,
dbus_interface=DnsmasqDhcpServerWrapper.
DNSMASQ_DBUS_SERVICE_INTERFACE,
message_keyword='dbus_message'
) # Handle the IpConfigApplied signal
self._dnsmasq_proxy.connect_to_signal(
"DhcpLeaseUpdated",
self._handleDhcpLeaseUpdated,
dbus_interface=DnsmasqDhcpServerWrapper.
DNSMASQ_DBUS_SERVICE_INTERFACE,
message_keyword='dbus_message'
) # Handle the IpConfigApplied signal
self._dnsmasq_proxy.connect_to_signal(
"DhcpLeaseDeleted",
self._handleDhcpLeaseDeleted,
dbus_interface=DnsmasqDhcpServerWrapper.
DNSMASQ_DBUS_SERVICE_INTERFACE,
message_keyword='dbus_message'
) # Handle the IpConfigApplied signal
self._dbus_loop_thread = threading.Thread(
target=self._loopHandleDbus
) # Start handling D-Bus messages in a background thread
self._dbus_loop_thread.setDaemon(
True
) # D-Bus loop should be forced to terminate when main program exits
self._dbus_loop_thread.start()
self._bus.watch_name_owner(
DnsmasqDhcpServerWrapper.DNSMASQ_DBUS_NAME,
self._handleBusOwnerChanged
) # Install a callback to run when the bus owner changes
self._getversion_unlock_event = threading.Event(
) # Create a new threading event that will allow the GetVersion() D-Bus call below to execute within a timed limit
self._getversion_unlock_event.clear()
self._remote_version = ''
self._dbus_iface.GetVersion(reply_handler=self._getVersionUnlock,
error_handler=self._getVersionError)
if not self._getversion_unlock_event.wait(
4): # We give 4s for slave to answer the GetVersion() request
raise Exception('TimeoutOnGetVersion')
else:
logger.debug('dnsmasq version: ' + self._remote_version)
self.reset()
def __init__(self):
if os.path.isfile(self.get_convert_path):
logger.debug("Convert file exits path, path used :" +
self.get_convert_path)
else:
message = "Missing file convert.exe"
logger.debug(message)
if os.path.isfile(self.get_compare_path):
logger.debug("Compare file exits , path used :" +
self.get_compare_path)
else:
message = "Missing file compare.exe"
logger.debug(message)
if os.path.isfile(self.get_identify_path):
logger.debug("Identify file exits, path used :" +
self.get_identify_path)
else:
message = "Missing file identify.exe"
logger.debug(message)
def _on_message_list(self, client, userdata, message):
logger.debug('Received message: %s on topic: %s with QoS: %s' %
(str(message.payload), message.topic, str(message.qos)))
self._messages.append(message.payload)
def __init__(self, channel, baudrate):
self._tag = self.__class__.__name__ + ' '
logger.debug(self._tag + "__init__ called")
# PCAN Setting
self._pcanbasic = PCANBasic()
self._channel = CanComm.CHANNELS[channel]
self._baudrate = CanComm.BAUDRATES[baudrate]
if platform.system() == 'Windows':
self._hwtype = CanComm.HWTYPES['ISA-82C200']
self._ioport = CanComm.IOPORTS['0100']
self._interrupt = CanComm.INTERRUPTS['3']
else:
self._hwtype = CanComm.HWTYPES['ISA-82C200']
self._ioport = CanComm.IOPORTS['0100']
self._interrupt = CanComm.INTERRUPTS['11']
# CanMsg Setting
self._tbox011 = None
self._sas300 = None
self._ems302 = None
self._ems303 = None
self._abs330 = None
self._ems360 = None
self._bcm350 = None
self._bcm365 = None
self._bcm383 = None
self._ic34a = None
self._ic367 = None
self._ic380 = None
self._ac378 = None
self._peps341 = None
self._tcu328 = None
self._bcm401 = None
# Timer Setting
# self._tmr_read = None
# Threading Setting
self._lock = threading.RLock()
self._alive = False
self._transmitter_thread = None
self._transmit_by_cycle = []
self._can_matrix_dict = {
# 左前门开关状态
'LF_DOOR_REQ':
self._on_request_lf_door,
# 右前门开关状态
'RF_DOOR_REQ':
self._on_request_rf_door,
# 左后门开关状态
'LR_DOOR_REQ':
self._on_request_lr_door,
# 右后门开关状态
'RR_DOOR_REQ':
self._on_request_rr_door,
# 后尾箱开关状态
'TRUNK_DOOR_REQ':
self._on_request_trunk_door,
# 左前窗开关状态
'LF_WINDOW_REQ':
self._on_request_lf_window,
# 右前窗开关状态
'RF_WINDOW_REQ':
self._on_request_rf_window,
# 左后窗开关状态
'LR_WINDOW_REQ':
self._on_request_lr_window,
# 右后窗开关状态
'RR_WINDOW_REQ':
self._on_request_rr_window,
# 天窗开关状态
'ROOF_WINDOW_REQ':
self._on_request_roof_window,
# 空调开关状态
'AC_REQ':
self._on_request_ac,
# 空调前除霜开关状态
'FRONT_DEFROST_REQ':
self._on_request_front_defrost,
# 空调后除霜开关状态
'REAR_DEFROST_REQ':
self._on_request_rear_defrost,
# 空调温度
'AC_TEMPERATURE_REQ':
self._on_request_ac_temperature,
# 驾驶员左前门锁开关状态
'LOCK_DOOR_REQ':
self._on_request_lock_door,
# 发动机状态
'ENGINE_REQ':
self._on_request_engine,
# 雨刷开关状态
'WIPER_REQ':
self._on_request_wiper,
# 手刹状态
'HANDBRAKE_REQ':
self._on_request_handbrake,
# 前除霜状态
'FRONT_DEFROST_STS':
self._on_front_defrost_status,
# PEPS电源状态
'PEPS_POWER_REQ':
self._on_request_peps_power,
# 档位
'GEAR_POS_REQ':
self._on_request_gear_pos,
# 左前胎压
'LF_TIRE_PRESSURE_REQ':
self._on_request_lf_tire_pressure,
# 左后胎压
'LR_TIRE_PRESSURE_REQ':
self._on_request_lr_tire_pressure,
# 右前胎压
'RF_TIRE_PRESSURE_REQ':
self._on_request_rf_tire_pressure,
# 右后胎压
'RR_TIRE_PRESSURE_REQ':
self._on_request_rr_tire_pressure,
# 蓄电池电压
'BATTERY_VOLTAGE_REQ':
self._on_request_battery_voltage,
# 剩余油量
'FUEL_LEVEL_REQ':
self._on_request_fuel_level,
# 剩余里程
'REMAIN_MILEAGE_REQ':
self._on_request_remain_mileage,
# 是否系安全带
'BELT_REQ':
self._on_request_belt,
# 近光灯状态
'FRONT_FOG_LAMP_REQ':
self._on_request_front_fog_lamp,
# 远光灯状态
'REAR_FOG_LAMP_REQ':
self._on_request_rear_fog_lamp,
# G值
'G_VALUE_REQ':
self._on_request_g_value,
# 光照强度
'LIGHT_INTENSITY_REQ':
self._on_request_light_intensity,
# 瞬时油耗
'CURR_FUEL_CONSUMPTION_REQ':
self._on_request_curr_fuel_consumption,
# 当前速度
'CURR_SPEED_REQ':
self._on_request_curr_speed,
# 当前转速
'ENGINE_SPEED_REQ':
self._on_request_engine_speed,
# 方向盘转角，左为正，右为负
'STEERING_ANGLE_REQ':
self._on_request_steering_angle,
# 油门脚踏板角度
'ACCELERATOR_PEDAL_ANGLE_REQ':
self._on_request_accelerator_pedal_angle,
# 刹车板角度
'BRAKE_PEDAL_ANGLE_REQ':
self._on_request_brake_pedal_angle,
# 离合器角度
'CLUTCH_PEDAL_ANGLE_REQ':
self._on_request_clutch_pedal_angle,
# 总里程
'TOTAL_MILEAGE_REQ':
self._on_request_total_mileage,
# 车辆位置
# 当前追踪状态
# 平均油耗
'AVERAGE_FUEL_CONSUMPTION_REQ':
self._on_request_average_fuel_consumption,
}
def pre_process_request(self):
if len(list(self.request_headers.items())) > 0:
logger.debug("Request headers:")
for name, value in self.request_headers.items():
logger.debug("%s: %s" % (name, value))
else:
logger.debug("No request headers set")
if self.request_body is None:
logger.debug("No request body set")
else:
logger.debug("Request body:")
logger.debug(self.request_body)
def _create_session(self, alias, url, headers, cookies, auth, timeout,
proxies, verify, debug, max_retries, backoff_factor,
disable_warnings, retry_status_list,
retry_method_list):
logger.debug('Creating session: %s' % alias)
s = session = requests.Session()
s.headers.update(headers)
s.auth = auth if auth else s.auth
s.proxies = proxies if proxies else s.proxies
try:
max_retries = int(max_retries)
retry_status_list = [int(x) for x in retry_status_list
] if retry_status_list else None
except ValueError as err:
raise ValueError("Error converting session parameter: %s" % err)
if max_retries > 0:
retry = Retry(total=max_retries,
backoff_factor=backoff_factor,
status_forcelist=retry_status_list,
method_whitelist=retry_method_list)
http = requests.adapters.HTTPAdapter(max_retries=retry)
https = requests.adapters.HTTPAdapter(max_retries=retry)
# Replace the session's original adapters
s.mount('http://', http)
s.mount('https://', https)
# Disable requests warnings, useful when you have large number of testcase
# you will observe drastical changes in Robot log.html and output.xml files size
if disable_warnings:
logging.basicConfig(
) # you need to initialize logging, otherwise you will not see anything from requests
logging.getLogger().setLevel(logging.ERROR)
requests_log = logging.getLogger("requests")
requests_log.setLevel(logging.ERROR)
requests_log.propagate = True
if not verify:
requests.packages.urllib3.disable_warnings()
# verify can be a Boolean or a String
if isinstance(verify, bool):
s.verify = verify
elif isinstance(verify, str) or isinstance(verify, unicode):
if verify.lower() == 'true' or verify.lower() == 'false':
s.verify = self.builtin.convert_to_boolean(verify)
else:
# String for CA_BUNDLE, not a Boolean String
s.verify = verify
else:
# not a Boolean nor a String
s.verify = verify
# cant pass these into the Session anymore
self.timeout = float(timeout) if timeout is not None else None
self.cookies = cookies
self.verify = verify if self.builtin.convert_to_boolean(
verify) != True else None
s.url = url
# Enable http verbosity
if int(debug) >= 1:
self.debug = int(debug)
httplib.HTTPConnection.debuglevel = self.debug
self._cache.register(session, alias=alias)
return session
def my_keyword(arg):
logger.debug('Got argument %s.' % arg)
logger.info('<i>This</i> is a boring example.', html=True)
logger.debug('<i>This</i> is a boring example.', html=True)
def completeRegister(self, completeUid):
'''complete register key worlds
:param completeUid
:return completeRegisterResp'''
'''/ITAS/reg/registration/request/listPage.do
get current userid'''
path = '/ITAS/reg/registration/request/listPage.do'
listPageUrl = _globalVariables.BASEURL + path
listPageResp = _globalVariables.SESSION.get(listPageUrl)
rightBoundary = 'currentUserUid\" value=\''
leftBoundary = '\'/>'
currentUserUid = _GloableKeywords.subString(listPageResp.text,
rightBoundary,
leftBoundary)
'''search data'''
searchDict = self.searchRegister(completeUid)
completeRegisterData['parameter.requestUid'] = searchDict[
'creg08RequestUid']
completeRegisterData['taxpayerRequest.creg07RequestUid'] = searchDict[
'creg08RequestUid']
completeRegisterData[
'registrationRequest.creg08RequestUid'] = searchDict[
'creg08RequestUid']
completeRegisterData[
'registrationRequest.creg08RequestDate'] = searchDict[
'creg08RequestDate']
completeRegisterData[
'registrationRequest.creg08CaptureOfficer'] = searchDict[
'creg08CaptureOfficer']
completeRegisterData['oldIdNumber'] = searchDict['creg08IdNumber']
completeRegisterData['treg00NaturalPerson.creg00IdNo'] = searchDict[
'creg08IdNumber']
completeRegisterData[
'registrationRequest.creg08Applicant'] = searchDict[
'creg08Applicant']
axBizProcInstId = searchDict['creg08AxBizTaskId']
'''/ITAS/reg/registration/request/process.do'''
path = '/ITAS/reg/registration/request/process.do'
query ='axBizBackUrl=/ITAS/reg/registration/request/listPage.do' \
'&axBizViewFlowFormPageUrl=com/cacss/itas/reg/registration.edit' \
'&requestType=TXP_REG&requestUid='+completeUid+'&requestStatus=APPROVED' \
'&axBizProcInstId='+axBizProcInstId+'¤tUserUid='+currentUserUid +\
'&rnd='+str(random.random())
processUrl = _globalVariables.BASEURL + path + '?' + query
processResp = _globalVariables.SESSION.post(processUrl)
leftBoundary = 'var reqProcId = "'
rightBoundary = '";'
axBizTaskId = _GloableKeywords.subString(processResp.text,
leftBoundary, rightBoundary)
completeRegisterData[
'treg02Individual.creg02IndividualUid'] = _GloableKeywords.subString(
processResp.text, 'creg02IndividualUid" value="', '" />')
completeRegisterData[
'treg00NaturalPerson.creg00NaturalPersonUid'] = _GloableKeywords.subString(
processResp.text, 'creg02IndividualUid" value="', '" />')
completeRegisterData[
'postalAddress.creg26AddressUid'] = _GloableKeywords.subString(
processResp.text, 'postalAddress.creg26AddressUid" value="',
'"/>')
completeRegisterData[
'parameter.creg01Tin'] = _GloableKeywords.subString(
processResp.text, 'creg01Tin" value="', '"/>')
completeRegisterData[
'individualResidentialAddr.creg26AddressUid'] = _GloableKeywords.subString(
processResp.text,
'individualResidentialAddr.creg26AddressUid" value="', '"/>')
completeRegisterData['creg01Tin'] = _GloableKeywords.subString(
processResp.text, 'creg01Tin" value="', '"/>')
completeRegisterData['creg01TaxpayerUid'] = _GloableKeywords.subString(
processResp.text, 'creg01TaxpayerUid" value="', '"/>')
completeRegisterData['creg01PostAddrUid'] = _GloableKeywords.subString(
processResp.text, 'creg01PostAddrUid" value="', '"/>')
completeRegisterData[
'creg01PhysicalAddrUid" value="'] = _GloableKeywords.subString(
processResp.text, 'creg01PhysicalAddrUid" value="', '"/>')
'''taxtype data'''
path = '/ITAS/reg/taxtype/config.do'
query = 'taxpayerCategory=IND&taxpayerType=INDSP&requestUid=' + completeUid + '&branchUid=&requestStatus=APPROVED&requestType=TXP_REG'
configTaxTypeUrl = _globalVariables.BASEURL + path + '?' + query
configTaxTypeData = {
'axgrid_listcols':
'cret09TaxTypeName,registeredTaxType.creg06EffectiveDate,registeredTaxType.creg06Fin,registeredTaxType.creg06Status,registeredTaxType.taxpayer.creg06IsRegular,registeredTaxType.creg06ExpiryDate,registeredTaxType.taxpayer.functions',
'axgridid': 'taxtypeview',
'taxtypeview_pageSize': 10,
'taxtypeview_sort': '',
'taxtypeview_startIndex': 0
}
configTaxTypeResp = _globalVariables.SESSION.post(
configTaxTypeUrl, configTaxTypeData)
logger.debug('configTaxTypeResp.text' + configTaxTypeResp.text)
convertResult = _GloableKeywords.parseRespToDictOrCuple(
configTaxTypeResp.text)
completeRegisterData[
'registeredTaxType[0].cret09TaxtypeUid'] = convertResult[
'cret09TaxtypeUid']
completeRegisterData[
'registeredTaxType[0].creg06EffectiveDate'] = convertResult[
'registeredTaxType']['creg06EffectiveDate']
completeRegisterData[
'registeredTaxType[0].creg06RegistTaxtypeUid'] = convertResult[
'registeredTaxType']['creg06RegistTaxtypeUid']
completeRegisterData['registeredTaxType[0].creg06Fin'] = convertResult[
'registeredTaxType']['creg06Fin']
'''attachment data'''
path = '/ITAS/reg/attachment/list.do'
query = 'entityId='+completeUid+'&attachmentTable=TREG05_ATTACHMENT&requestUid='+completeUid+\
'&requestStatus=APPROVED&requestType=TXP_REG&taxpayerCategory=TAXPAYER_TYPE,ID_TYPE,TAX_TYPE'
attachmentTaxTypeUrl = _globalVariables.BASEURL + path + '?' + query
attachmentTypeData = {
'attachmentview_pageSize': 10,
'attachmentview_sort': '',
'attachmentview_startIndex': 0,
'axgrid_listcols':
'ccmn00DocumentTypecode,ccmn00IsUpload,ccmn00UploadDate,ccmn00Note,ccmn00ArchivedDate',
'axgridid': 'attachmentview'
}
attachmentTypeResp = _globalVariables.SESSION.post(
attachmentTaxTypeUrl, attachmentTypeData)
attachmentResult = _GloableKeywords.parseRespToDictOrCuple(
attachmentTypeResp.text)
for i in range(3):
completeRegisterData[
'attachments[' + str(i) +
'].ccmn00IsUpload'] = attachmentResult[i]['ccmn00IsUpload']
completeRegisterData[
'attachments[' + str(i) +
'].ccmn00Barcode'] = attachmentResult[i]['ccmn00Barcode']
completeRegisterData[
'attachments[' + str(i) +
'].ccmn00AttachUid'] = attachmentResult[i]['ccmn00AttachUid']
completeRegisterData[
'attachments[' + str(i) +
'].ccmn00DocumentTypecode'] = attachmentResult[i][
'ccmn00DocumentTypecode']
completeRegisterData[
'attachments[' + str(i) +
'].ccmn00Entity'] = attachmentResult[i]['ccmn00Entity']
completeRegisterData[
'attachments[' + str(i) +
'].mandatory'] = attachmentResult[i]['mandatory']
completeRegisterData[
'attachments[' + str(i) +
'].ccmn00IsConf'] = attachmentResult[i]['ccmn00IsConf']
completeRegisterData[
'attachments[' + str(i) +
'].ccmn00UploadDate'] = attachmentResult[i]['ccmn00UploadDate']
completeRegisterData['attachments[' + str(i) +
'].ccmn00ArchivedDate'] = attachmentResult[i][
'ccmn00ArchivedDate']
'''account data'''
path = '/ITAS/reg/account/list.do'
query = 'taxpayerUid=&requestStatus=APPROVED&requestType=TXP_REG&requestUid=' + completeUid
accountUrl = _globalVariables.BASEURL + path + '?' + query
accountData = {
'accountview_pageSize': 10,
'accountview_sort': '',
'accountview_startIndex': 0,
'axgrid_listcols':
'creg04BankName,creg04BranchName,creg04BranchNo,creg04AccountType,creg04AccountNo,creg04Holder,creg04IsShared',
'axgridid': 'accountview'
}
accountResp = _globalVariables.SESSION.post(accountUrl, accountData)
accountResult = _GloableKeywords.parseRespToDictOrCuple(
accountResp.text)
completeRegisterData['accounts[0].creg04AccountNo'] = accountResult[
'creg04AccountNo']
completeRegisterData['accounts[0].creg04Holder'] = accountResult[
'creg04Holder']
completeRegisterData['accounts[0].creg04BankName'] = accountResult[
'creg04BankName']
completeRegisterData['accounts[0].creg04AccountType'] = accountResult[
'creg04AccountType']
completeRegisterData['accounts[0].creg04BranchName'] = accountResult[
'creg04BranchName']
completeRegisterData['accounts[0].creg04BranchNo'] = accountResult[
'creg04BranchNo']
completeRegisterData['oldFirstName'] = accountResult['creg04Holder']
completeRegisterData['parameter.account_holder_name'] = accountResult[
'creg04Holder']
completeRegisterData[
'treg00NaturalPerson.creg00FirstName'] = accountResult[
'creg04Holder']
completeRegisterData[
'treg00NaturalPerson.creg00Email'] = accountResult[
'creg04Holder'] + '@qq.com'
completeRegisterData['accounts[0].creg04AccountUid'] = accountResult[
'creg04AccountUid']
'''deal with lastname'''
completeRegisterData['oldLastName'] = searchDict[
'creg08Applicant'].split(accountResult['creg04Holder'])[1][1:]
completeRegisterData[
'treg00NaturalPerson.creg00LastName'] = searchDict[
'creg08Applicant'].split(accountResult['creg04Holder'])[1][1:]
'''submit.do'''
path = '/ITAS/UserFlow/submit.do'
query = 'axBizIsNew=false&axBizIsFlow=true&axBizFlowAction=complete&axBizTaskId='+axBizTaskId+ \
'&axBizEntityType=com.cacss.itas.reg.entity.Taxpayer'
completeUrl = _globalVariables.BASEURL + path + '?' + query
completeResp = _globalVariables.SESSION.post(completeUrl,
completeRegisterData)
return completeResp.text
def get_elements_from_dom_content(*args, **kwargs):
try:
args, kwargs, locator = _equal_sign_handler(args, kwargs, fn)
msg = None
params = signature(fn).parameters
args, kwargs = _args_to_kwargs(params, args, kwargs)
timeout = get_timeout(**kwargs)
logger.debug('Timeout is {} sec'.format(timeout))
try:
if 'go_to' not in str(fn) and 'switch_window' not in str(fn):
frame.wait_page_loaded()
except UnexpectedAlertPresentException as e:
if not CONFIG["HandleAlerts"]:
raise QWebUnexpectedAlert(str(e))
logger.debug('Got {}. Trying to retry..'.format(e))
time.sleep(SHORT_DELAY)
start = time.time()
while time.time() < timeout + start:
try:
kwargs['timeout'] = float(timeout + start - time.time())
config.set_config('FrameTimeout',
float(timeout + start - time.time()))
return fn(*args, **kwargs)
except (QWebUnexpectedConditionError, QWebTimeoutError) as e:
logger.warn('Got {}'.format(e))
except (InvalidSelectorException, NoSuchElementException,
QWebElementNotFoundError,
UnexpectedAlertPresentException,
QWebStalingElementError,
StaleElementReferenceException,
QWebIconNotFoundError) as e:
time.sleep(SHORT_DELAY)
logger.debug(
'Got exception: {}. Trying to retry..'.format(e))
except InvalidSessionIdException:
CONFIG.set_value("OSScreenshots", True)
raise QWebBrowserError(
"Browser session lost. Did browser crash?")
except (WebDriverException, QWebDriverError) as e:
if any(s in str(e) for s in FATAL_MESSAGES):
CONFIG.set_value("OSScreenshots", True)
raise QWebBrowserError(e)
logger.info(
'From timeout decorator: Webdriver exception. Retrying..'
)
logger.info(e)
time.sleep(SHORT_DELAY)
err = QWebDriverError
msg = e
except QWebValueError as ve:
logger.debug(
'Got QWebValueError: {}. Trying to retry..'.format(ve))
err = QWebValueError
msg = ve
time.sleep(SHORT_DELAY)
if msg:
raise err(msg)
if 'count' in str(fn):
return 0
if 'is_text' in str(fn) or 'is_no_text' in str(fn):
return False
raise QWebElementNotFoundError(
'Unable to find element for locator {} in {} sec'.format(
locator, timeout))
except QWebSearchingMode:
pass
def _encode_message(self, message_fields, header_fields):
msg = self._get_message_template().encode(message_fields,
header_fields)
logger.debug('%s' % repr(msg))
return msg
def _log_start(self, command, config):
if is_list_like(command):
command = self.join_command_line(command)
logger.info('Starting process:\n%s' % system_decode(command))
logger.debug('Process configuration:\n%s' % config)
def open_browser(executable_path="chromedriver",
chrome_args=None,
desired_capabilities=None,
**kwargs):
"""Open Chrome browser instance and cache the driver.
Parameters
----------
executable_path : str (Default "chromedriver")
path to the executable. If the default is used it assumes the
executable is in the $PATH.
port : int (Default 0)
port you would like the service to run, if left as 0, a free port will
be found.
desired_capabilities : dict (Default None)
Dictionary object with non-browser specific capabilities only, such as
"proxy" or "loggingPref".
chrome_args : Optional arguments to modify browser settings
"""
options = Options()
logger.debug('opt: {}'.format(options))
# If user wants to re-use existing browser session then
# he/she has to set variable BROWSER_REUSE_ENABLED to True.
# If enabled, then web driver connection details are written
# to an argument file. This file enables re-use of the current
# chrome session.
#
# When variables BROWSER_SESSION_ID and BROWSER_EXECUTOR_URL are
# set from argument file, then OpenBrowser will use those
# parameters instead of opening new chrome session.
# New Remote Web Driver is created in headless mode.
chrome_path = kwargs.get(
'chrome_path', None) or BuiltIn().get_variable_value('${CHROME_PATH}')
if chrome_path:
options.binary_location = chrome_path
browser_reuse, session_id, executor_url = check_browser_reuse(**kwargs)
logger.debug('browser_reuse: {}, session_id: {}, executor_url: {}'.format(
browser_reuse, session_id, executor_url))
if browser_reuse and session_id and executor_url:
options.add_argument("headless")
# Gets rid of Devtools listening .... printing
options.add_experimental_option('excludeSwitches', ['enable-logging'])
driver = Remote(command_executor=executor_url,
desired_capabilities=options.to_capabilities())
BuiltIn().set_global_variable('${BROWSER_REMOTE_SESSION_ID}',
driver.session_id)
driver.session_id = session_id
else:
if user.is_root():
options.add_argument("no-sandbox")
if chrome_args:
if any('headless' in _.lower() for _ in chrome_args):
CONFIG.set_value('Headless', True)
for item in chrome_args:
options.add_argument(item.lstrip())
# options.add_argument("start-maximized")
options.add_argument("--disable-notifications")
if 'headless' in kwargs:
CONFIG.set_value('Headless', True)
options.add_argument("headless")
if 'prefs' in kwargs:
if isinstance(kwargs.get('prefs'), dict):
prefs = kwargs.get('prefs')
else:
prefs = util.prefs_to_dict(kwargs.get('prefs').strip())
options.add_experimental_option('prefs', prefs)
driver = Chrome(BuiltIn().get_variable_value('${CHROMEDRIVER_PATH}')
or executable_path,
options=options,
desired_capabilities=desired_capabilities)
browser_reuse_enabled = util.par2bool(
BuiltIn().get_variable_value('${BROWSER_REUSE_ENABLED}')) or False
if browser_reuse_enabled:
# Write WebDriver session info to RF arguments file for re-use
write_browser_session_argsfile(driver.session_id,
driver.command_executor._url) # pylint: disable=protected-access
# Clear possible existing global values
BuiltIn().set_global_variable('${BROWSER_SESSION_ID}', None)
BuiltIn().set_global_variable('${BROWSER_EXECUTOR_URL}', None)
browser.cache_browser(driver)
return driver
def _log_response(method, response):
logger.debug('%s Response : status=%s, reason=%s\n' %
(method.upper(), response.status_code, response.reason) +
response.text)
def LoadYaml(filepath):
"""Load YAML file and return dict"""
with open(filepath, 'r') as f:
doc = yaml.load(f)
logger.debug(doc)
return doc
def _normalize_result(self, elements):
if not isinstance(elements, list):
logger.debug("WebDriver find returned %s" % elements)
return []
return elements
def GetPID():
"""Returns PID of this process"""
mypid = os.getpid()
logger.debug("My PID is %d" % mypid)
return mypid
def payload_is_superset_of_expected(payload, expected, **kwargs):
"""
Checks that given payload is contained in the expected result.
In other words: payload has at least everything that is expected
AND may have even more content beyond the expected.
# DOCTEST EXAMPLES
## TEST_01
>>> a = '{"1": "one", "2": [1,2,3], "3": 3}'
>>> b = '{"1": "one", "2": [1,2,3]}'
>>> payload_is_superset_of_expected(a, b)
True
## TEST_02
>>> a = '{"1": "one", "2": [1]}'
>>> b = '{"1": "one", "2": [1,2,3]}'
>>> payload_is_superset_of_expected(a, b)
Traceback (most recent call last):
jsonlib.JsonCompareError: Actual payload dosn't meet expectation!
TODO: create a dictionary with proper names for relevant changes
# changes that are relevant / test shoul FAIL
# change meaning
# type_changes expected vs. got
# values_changed expected vs. got
# new_value expected value
# old_value recieved value
# repetition_change expected vs. got
# dictionary_item_added missing in response but was expected
# iterable_item_added missing in response but was expected
# changes that can be ignored / test should PASS
# changed meaning
# dictionary_item_removed is in response bu was NOT expected
# set_item_removed is in response bu was NOT expected
# iterable_item_removed is in response bu was NOT expected
# unprocessed ? if occurs should be handled extra
"""
logger.debug(f"type(payload): {type(payload)}")
logger.debug(f"type(expected): {type(expected)}")
diff = compare_jsons(payload, expected, **kwargs)
changes = [
"type_changes",
"values_changed",
"repetition_change",
"dictionary_item_added",
"iterable_item_added",
"set_item_removed",
"dictionary_item_removed",
"iterable_item_removed",
]
changes_to_ignore = [
"set_item_removed",
"dictionary_item_removed",
"iterable_item_removed",
]
critical_changes = [
"type_changes",
"values_changed",
"repetition_change",
"dictionary_item_added",
"iterable_item_added",
]
if diff != {}:
for change in changes:
# check if change are relevant or can be ignored
if change in critical_changes and change in diff:
logger.error("Critical changes detected!")
raise JsonCompareError("Actual payload dosn't meet expectation!")
elif change in changes_to_ignore and change in diff:
logger.info("Changes detected, but not relevant.")
return True
else:
logger.info("NO difference between payloads.")
return True
def _log_response(method, response):
# TODO big responses should be truncated to avoid huge logs
logger.debug('%s Response : status=%s, reason=%s\n' %
(method.upper(), response.status_code, response.reason) +
response.text)
def compare_jsons(
json_1,
json_2,
exclude_paths=None,
ignore_order=True,
report_repetition=False,
ignore_string_case=False,
ignore_type_subclasses=False,
verbose_level=2,
**kwargs,
):
"""
:json_1: valid JSON string \n
:json_2: valid JSON string \n
# DOCTEST EXAMPLES
## TEST_01
>>> a = '{"1": "one", "2": 2, "3": null}'
>>> b = '{"1": "one", "2": 2, "3": null}'
>>> compare_jsons(a, b)
{}
## TEST_02
>>> a = '{"1": "one", "2": 2}'
>>> b = '{"1": "one", "2": 22}'
>>> compare_jsons(a, b, exclude_paths="root['2']")
{}
## TEST_03
>>> a = '{"1": "one"}'
>>> b = '{"1": "ONE"}'
>>> compare_jsons(a, b, ignore_string_case=True)
{}
"""
logger.debug("BEFORE TRY BLOCK")
logger.debug("json_1 type: {}".format(type(json_1)))
logger.debug("json_2 type: {}".format(type(json_2)))
# if inputs are dictionaries take them as they are otherwise
# try to convert to a python object (dict)
if isinstance(json_1, dict):
actual = json_1
else:
try:
actual = json.loads(json_1)
except (JSONDecodeError, TypeError) as error:
raise JsonCompareError(f"Only VALID JSON strings accepted! ERROR: {error}")
if isinstance(json_2, dict):
expected = json_2
else:
try:
expected = json.loads(json_2)
except (JSONDecodeError, TypeError) as error:
raise JsonCompareError(f"Only VALID JSON strings accepted! ERROR: {error}")
logger.debug("AFTER TRY BLOCK")
logger.debug(f"ACTUAL: {type(actual)}")
logger.debug(f"EXPECTED: {type(expected)}")
logger.debug(f"EXCLUDED PATHS: {exclude_paths} - (type: {type(exclude_paths)})")
logger.debug(f"IGNORE ORDER: {ignore_order} - (type: {type(ignore_order)})")
logger.debug(
f"IGNORE_STRING_CASE: {ignore_string_case} - (type: {type(ignore_string_case)})"
)
logger.debug(f"IGNORE_TYPE_SUBCLASSES: {ignore_type_subclasses}")
logger.debug(f"VERBOSE_LEVEL: {verbose_level}")
logger.debug(f"KWARGS: {kwargs}")
diff = DeepDiff(
actual,
expected,
exclude_paths=exclude_paths,
ignore_order=ignore_order,
report_repetition=report_repetition,
ignore_string_case=ignore_string_case,
ignore_type_subclasses=ignore_type_subclasses,
verbose_level=verbose_level,
**kwargs,
)
# logger.debug(f"DIFF: {diff}")
changes = [
"type_changes",
"values_changed",
"repetition_change",
"dictionary_item_added",
"iterable_item_added",
"dictionary_item_removed",
"iterable_item_removed",
]
change_counter = 0
for change in changes:
if change in diff:
change_counter += 1
logger.debug(f"{change_counter}. CHANGE ({change}): \n{diff[change]}\n\n")
return diff.to_dict()
def _on_message(self, client, userdata, message):
logger.debug('Received message: %s on topic: %s with QoS: %s' %
(str(message.payload), message.topic, str(message.qos)))
self._verified = re.match(self._payload, str(message.payload))
def Check_JSON(j):
d = demjson.decode(j, strict=True)
logger.debug('got json %s' % d)
assert len(d) > 0
assert 'error' not in d
return d
def debug(self, msg, html=False):
logger.debug(msg, html)
def debug(msg: Any, html=False):
logger.debug(msg, html)
def on_request(self, item, data):
logger.debug(self._tag + ": on_request ")
self._can_matrix_dict[item](data)
return True
def _read_file(path, title):
with open(path) as file:
content = file.read()
logger.debug('%s:\n%s' % (title, content))
return content.splitlines()
def end_test(self, data, _result):
""" Called when a test case ends. """
logger.debug('end_test')
result = Result(tcid=data.name)
result.campaign = os.environ.get('JOB_NAME', data.parent.longname)
if _result.message:
result.execution.note = _result.message
result.execution.duration = float(_result.elapsedtime)
result.execution.environment.framework.name = __robot_info__.project_name
result.execution.environment.framework.version = __robot_info__.version
result.execution.sut.commit_id = os.environ.get('GIT_COMMIT', "")
result.execution.sut.branch = os.environ.get('GIT_BRANCH', "")
result.job.id = os.environ.get('BUILD_TAG', str(uuid.uuid1()))
try:
result.execution.verdict = _result.status.lower()
except Exception as error: # pylint: disable=broad-except
logger.warn(error)
result.execution.verdict = 'inconclusive'
profiling = dict(
suite=dict(duration=_result.parent.elapsedtime,
numtests=_result.parent.test_count),
generated_at=datetime.datetime.now().isoformat(),
)
if _result.tags:
profiling['tags'] = []
for tag in _result.tags:
profiling['tags'].append(tag)
result.execution.profiling = profiling
for key in self._variables:
value = self._variables[key]
if ['LOG_FILE', 'OUTPUT_FILE', 'REPORT_FILE'].__contains__(key):
if not self._store_logs:
logger.debug('Ignore logs')
continue
if not os.path.exists(value):
logger.debug(f"{key} file {value} not exists")
continue
file_stats = os.stat(value)
if file_stats.st_size / (1024 * 1024) > 1.0:
logger.debug('avoid uploading huge log files')
continue
file = File()
file.mime_type = mimetypes.guess_type(value)[0]
file.name = os.path.basename(value)
fobj = open(value, "r")
data = fobj.read()
fobj.close()
file.set_data(data)
continue
dut = None
for key in self._metadata:
value = self._metadata[key]
# Dut
if key.startswith('DUT') and not dut:
dut = Dut()
dut.type = 'hw'
result.execution.append_dut(dut)
if key == 'DUT_TYPE':
dut.type = value
if key == 'DUT_SERIAL_NUMBER':
dut.serial_number = value
# elif key == 'DUT_PLATFORM':
# dut.platform = value
elif key == 'DUT_VERSION':
dut.ver = value
elif key == 'DUT_VENDOR':
dut.vendor = value
elif key == 'DUT_MODEL':
dut.model = value
elif key == 'DUT_PROVIDER':
dut.provider = Provider()
dut.provider.name = value
# Sut
elif key == 'SUT_COMPONENT':
result.execution.sut.append_cut(value)
elif key == 'SUT_FEATURE':
result.execution.sut.append_fut(value)
elif key == 'SUT_COMMIT_ID':
result.execution.sut.commit_id = value
elif key == 'SUT_BRANCH':
result.execution.sut.branch = value
self._results.append(result)
def GetType(oftype):
"""Returns type of object"""
mtype = type(oftype)
logger.debug("Get type: %s" % mtype)
return mtype
def _my_id(self):
if self.__my_id is None:
my_id = BuiltIn().get_variable_value('${CALLER_ID}')
logger.debug('Caller ID is %r' % my_id)
self.__my_id = my_id if my_id else None
return self.__my_id
def emit(self, record):
message, error = self._get_message(record)
method = self._get_logger_method(record.levelno)
method(message)
if error:
logger.debug(error)
