def __download_file(self, url, path_file, timeout):
"""
download a file from the server using a request with retries policy
:param url: server url to request
:param path_file: path and file where to download
:param timeout: threshold until the video file is downloaded
:return boolean
"""
status_code = 0
init_time = time.time()
self.driver_wrapper.logger.info('Downloading file from Selenoid node: %s' % url)
# retries policy
while status_code != STATUS_OK and time.time() - init_time < float(timeout):
body = requests.get(url)
status_code = body.status_code
if status_code != STATUS_OK:
time.sleep(1)
took = time.time() - init_time # time used to download the file
# create the folders and store the file downloaded
if status_code == STATUS_OK:
path, name = os.path.split(path_file)
makedirs_safe(path)
try:
fp = open(path_file, 'wb')
fp.write(body.content)
fp.close()
self.driver_wrapper.logger.info('File has been downloaded successfully to "%s" and took %d '
'seconds' % (path_file, took))
return True
except IOError as e:
self.driver_wrapper.logger.warning('Error writing downloaded file in "%s":\n %s' % (path_file, e))
else:
self.driver_wrapper.logger.warning('File "%s" does not exist in the server after %s seconds' % (url,
timeout))
return False
def test_create_existing_folder():
folder = os.path.join('output', str(uuid.uuid4()))
os.makedirs(folder)
makedirs_safe(folder)
assert os.path.isdir(folder)
os.rmdir(folder)
def retrieve_remote_downloaded_file(context,
filename,
destination_filename=None):
"""
Retrieves a file downloaded in a remote node and saves it in the output folder
:param context: behave context
:param filename: downloaded file
:param destination_filename: local destination name
:returns: destination file path
"""
destination_filepath = None
if context.download_directory is not None and context.driver_wrapper.config.getboolean_optional(
'Server', 'enabled'):
url = _get_download_directory_url(context)
file_url = '%s/%s' % (url, filename)
destination_folder = os.path.join(DriverWrappersPool.output_directory,
DOWNLOADS_FOLDER,
context.download_directory)
makedirs_safe(destination_folder)
destination_filename = destination_filename if destination_filename else filename
destination_filepath = os.path.join(destination_folder,
destination_filename)
context.logger.info('Retrieving downloaded file from "%s" to "%s"',
file_url, destination_filepath)
urlretrieve(file_url.encode('utf-8').decode(), destination_filepath)
return destination_filepath
def get_download_directory_base(context):
"""
Get base folder to download files
:param context: behave context
:returns: base folder
"""
if context.download_directory is None:
base = None
elif context.driver_wrapper.config.getboolean_optional(
'Server', 'enabled'):
try:
platform = context.driver_wrapper.config.get('Driver',
'type').split('-')[3]
except IndexError:
platform = 'linux'
if platform.lower().startswith('win'):
# Windows node
base = 'C:\\tmp\\%s\\' % DOWNLOADS_FOLDER
else:
# Linux or Mac node
base = '/tmp/%s/' % DOWNLOADS_FOLDER
else:
# Local folder
destination_folder = os.path.join(DriverWrappersPool.output_directory,
DOWNLOADS_FOLDER, '')
makedirs_safe(destination_folder)
base = str(destination_folder)
return base
def configure_common_directories(cls, tc_config_files):
"""Configure common config and output folders for all tests
:param tc_config_files: test case specific config files
"""
if cls.config_directory is None:
# Get config directory from properties
config_directory = cls.get_configured_value('TOOLIUM_CONFIG_DIRECTORY', 'Config_directory',
tc_config_files.config_directory, 'conf')
prop_filenames = cls.get_configured_value('TOOLIUM_CONFIG_PROPERTIES_FILENAMES', 'Config_prop_filenames',
tc_config_files.config_properties_filenames, 'properties.cfg')
cls.config_directory = cls._find_parent_directory(config_directory, prop_filenames.split(';')[0])
# Get output directory from properties and create it
cls.output_directory = cls.get_configured_value('TOOLIUM_OUTPUT_DIRECTORY', 'Output_directory',
tc_config_files.output_directory, 'output')
if not os.path.isabs(cls.output_directory):
# If output directory is relative, we use the same path as config directory
cls.output_directory = os.path.join(os.path.dirname(cls.config_directory), cls.output_directory)
makedirs_safe(cls.output_directory)
# Get visual baseline directory from properties
default_baseline = os.path.join(cls.output_directory, 'visualtests', 'baseline')
cls.visual_baseline_directory = cls.get_configured_value('TOOLIUM_VISUAL_BASELINE_DIRECTORY',
'Visual_baseline_directory',
tc_config_files.visual_baseline_directory,
default_baseline)
if not os.path.isabs(cls.visual_baseline_directory):
# If baseline directory is relative, we use the same path as config directory
cls.visual_baseline_directory = os.path.join(os.path.dirname(cls.config_directory),
cls.visual_baseline_directory)
def save_webdriver_logs_by_type(self, log_type, test_name):
"""Get webdriver logs of the specified type and write them to a log file
:param log_type: browser, client, driver, performance, server, syslog, crashlog or logcat
:param test_name: test that has generated these logs
"""
logs = self.driver_wrapper.driver.get_log(log_type)
if len(logs) > 0:
from toolium.driver_wrappers_pool import DriverWrappersPool
makedirs_safe(DriverWrappersPool.logs_directory)
log_file_name = '{}_{}.txt'.format(get_valid_filename(test_name),
log_type)
log_file_name = os.path.join(DriverWrappersPool.logs_directory,
log_file_name)
with open(log_file_name, 'a+', encoding='utf-8') as log_file:
driver_type = self.driver_wrapper.config.get('Driver', 'type')
log_file.write(
u"\n{} '{}' test logs with driver = {}\n\n".format(
datetime.now(), test_name, driver_type))
for entry in logs:
timestamp = datetime.fromtimestamp(
float(entry['timestamp']) /
1000.).strftime('%Y-%m-%d %H:%M:%S.%f')
log_file.write(u'{}\t{}\t{}\n'.format(
timestamp, entry['level'], entry['message'].rstrip()))
def test_path_utils_makedirs_compatibility():
# Check that path_utils works with old imports
from toolium.utils.path_utils import makedirs_safe
folder = os.path.join('output', str(uuid.uuid4()))
makedirs_safe(folder)
assert os.path.isdir(folder)
os.rmdir(folder)
def __init__(self, driver_wrapper=None, force=False):
self.driver_wrapper = driver_wrapper if driver_wrapper else DriverWrappersPool.get_default_wrapper(
)
self.force = force
if not self.driver_wrapper.config.getboolean_optional(
'VisualTests', 'enabled') and not self.force:
return
if 'PerceptualEngine' not in globals():
raise Exception(
'The visual tests are enabled, but needle is not installed')
self.utils = self.driver_wrapper.utils
self.logger = logging.getLogger(__name__)
self.output_directory = DriverWrappersPool.visual_output_directory
# Update baseline with real platformVersion value
if '{platformVersion}' in self.driver_wrapper.baseline_name:
platform_version = self.driver_wrapper.driver.desired_capabilities[
'platformVersion']
baseline_name = self.driver_wrapper.baseline_name.replace(
'{platformVersion}', platform_version)
self.driver_wrapper.baseline_name = baseline_name
self.driver_wrapper.visual_baseline_directory = os.path.join(
DriverWrappersPool.visual_baseline_directory,
get_valid_filename(baseline_name))
self.baseline_directory = self.driver_wrapper.visual_baseline_directory
self.engine = self._get_engine()
self.save_baseline = self.driver_wrapper.config.getboolean_optional(
'VisualTests', 'save')
# Create folders
makedirs_safe(self.baseline_directory)
makedirs_safe(self.output_directory)
# Copy js, css and html template to output directory
dst_template_path = os.path.join(self.output_directory,
self.report_name)
if not os.path.exists(dst_template_path):
resources_path = os.path.join(
os.path.dirname(os.path.realpath(__file__)), 'resources')
orig_template_path = os.path.join(resources_path,
self.template_name)
orig_javascript_path = os.path.join(resources_path,
self.javascript_name)
dst_javascript_path = os.path.join(self.output_directory,
self.javascript_name)
orig_css_path = os.path.join(resources_path, self.css_name)
dst_css_path = os.path.join(self.output_directory, self.css_name)
shutil.copyfile(orig_template_path, dst_template_path)
shutil.copyfile(orig_javascript_path, dst_javascript_path)
shutil.copyfile(orig_css_path, dst_css_path)
self._add_summary_to_report()
def _download_video(self, video_url, video_name):
"""Download a video from the remote node
:param video_url: video url
:param video_name: video name
"""
from toolium.driver_wrappers_pool import DriverWrappersPool
filename = '{0:0=2d}_{1}'.format(DriverWrappersPool.videos_number, video_name)
filename = '{}.mp4'.format(get_valid_filename(filename))
filepath = os.path.join(DriverWrappersPool.videos_directory, filename)
makedirs_safe(DriverWrappersPool.videos_directory)
response = requests.get(video_url)
open(filepath, 'wb').write(response.content)
self.logger.info("Video saved in '%s'", filepath)
DriverWrappersPool.videos_number += 1
def capture_screenshot(self, name):
"""Capture screenshot and save it in screenshots folder
:param name: screenshot name suffix
:returns: screenshot path
"""
from toolium.driver_wrappers_pool import DriverWrappersPool
filename = '{0:0=2d}_{1}'.format(DriverWrappersPool.screenshots_number, name)
filename = '{}.png'.format(get_valid_filename(filename))
filepath = os.path.join(DriverWrappersPool.screenshots_directory, filename)
makedirs_safe(DriverWrappersPool.screenshots_directory)
if self.driver_wrapper.driver.get_screenshot_as_file(filepath):
self.logger.info('Screenshot saved in %s', filepath)
DriverWrappersPool.screenshots_number += 1
return filepath
return None
def run_makedirs(folder, exceptions):
try:
makedirs_safe(folder)
except Exception as exc:
exceptions.put(exc)
