class GstWebRTCTestsManager(TestsManager): scenarios_manager = ScenarioManager() name = "webrtc" def __init__(self): super(GstWebRTCTestsManager, self).__init__() self.loading_testsuite = self.name self._scenarios = [] def add_scenarios(self, scenarios): if isinstance(scenarios, list): self._scenarios.extend(scenarios) else: self._scenarios.append(scenarios) self._scenarios = list(set(self._scenarios)) def set_scenarios(self, scenarios): self._scenarios = [] self.add_scenarios(scenarios) def get_scenarios(self): return self._scenarios def populate_testsuite(self): self.add_scenarios (DEFAULT_SCENARIOS) self.set_default_blacklist(DEFAULT_BLACKLIST) def list_tests(self): if self.tests: return self.tests scenarios = [(scenario_name, self.scenarios_manager.get_scenario(scenario_name)) for scenario_name in self.get_scenarios()] for browser in DEFAULT_BROWSERS: for name, scenario in scenarios: if not scenario: self.warning("Could not find scenario %s" % name) continue if not SCENARIO_OVERRIDES_SUPPORTED[name]: # no override choices supported classname = browser + '.' + name print ("adding", classname) self.add_test(GstWebRTCTest(classname, self, scenario, browser)) else: for overrides in itertools.product(*[OVERRIDE_CHOICES[c] for c in SCENARIO_OVERRIDES_SUPPORTED[name]]): oname = '.'.join (overrides) opaths = [SCENARIO_OVERRIDES[p] for p in overrides] classname = browser + '.' + oname + '.' + name print ("adding", classname) self.add_test(GstWebRTCTest(classname, self, scenario, browser, opaths)) return self.tests
class GESTestsManager(TestsManager): name = "ges" _scenarios = ScenarioManager() def __init__(self): super(GESTestsManager, self).__init__() def init(self): try: if "--set-scenario=" in subprocess.check_output( [GES_LAUNCH_COMMAND, "--help"]).decode(): return True else: self.warning( "Can not use ges-launch, it seems not to be compiled against" " gst-validate") except subprocess.CalledProcessError as e: self.warning("Can not use ges-launch: %s" % e) except OSError as e: self.warning("Can not use ges-launch: %s" % e) def add_options(self, parser): group = parser.add_argument_group( "GStreamer Editing Services specific option" " and behaviours", description=""" The GStreamer Editing Services launcher will be usable only if GES has been compiled against GstValidate You can simply run scenarios specifying project as args. For example the following will run all available and activated scenarios on project.xges: $gst-validate-launcher ges /some/ges/project.xges Available options:""") group.add_argument("-P", "--projects-paths", dest="projects_paths", default=os.path.join(utils.DEFAULT_GST_QA_ASSETS, "ges", "ges-projects"), help="Paths in which to look for moved medias") group.add_argument("-r", "--disable-recurse-paths", dest="disable_recurse", default=False, action="store_true", help="Whether to recurse into paths to find medias") def set_settings(self, options, args, reporter): TestsManager.set_settings(self, options, args, reporter) self._scenarios.config = self.options try: os.makedirs(utils.url2path(options.dest)[0]) except OSError: pass def list_tests(self): return self.tests def register_defaults(self, project_paths=None): projects = list() if not self.args: if project_paths == None: path = self.options.projects_paths else: path = project_paths for root, dirs, files in os.walk(path): for f in files: if not f.endswith(".xges"): continue projects.append(utils.path2url(os.path.join(path, root, f))) else: for proj_uri in self.args: if not utils.isuri(proj_uri): proj_uri = utils.path2url(proj_uri) if os.path.exists(proj_uri): projects.append(proj_uri) if self.options.long_limit != 0: scenarios = [ "none", "scrub_forward_seeking", "scrub_backward_seeking" ] else: scenarios = [ "play_15s", "scrub_forward_seeking_full", "scrub_backward_seeking_full" ] for proj_uri in projects: # First playback casses project = XgesProjectDescriptor(proj_uri) for scenario_name in scenarios: scenario = self._scenarios.get_scenario(scenario_name) if scenario is None: continue if scenario.get_min_media_duration() >= ( project.get_duration() / utils.GST_SECOND): continue classname = "playback.%s.%s" % ( scenario.name, os.path.basename(proj_uri).replace( ".xges", "")) self.add_test( GESPlaybackTest(classname, self.options, self.reporter, project, scenario=scenario)) # And now rendering casses for comb in GES_ENCODING_TARGET_COMBINATIONS: classname = "render.%s.%s" % (str(comb).replace( ' ', '_'), os.path.splitext(os.path.basename(proj_uri))[0]) self.add_test( GESRenderTest(classname, self.options, self.reporter, project, combination=comb))
class GstValidateTranscodingTest(GstValidateTest, GstValidateEncodingTestInterface): scenarios_manager = ScenarioManager() def __init__(self, classname, options, reporter, combination, uri, media_descriptor, timeout=DEFAULT_TIMEOUT, scenario=None, extra_env_variables=None): Loggable.__init__(self) extra_env_variables = extra_env_variables or {} file_dur = long(media_descriptor.get_duration()) / GST_SECOND if not media_descriptor.get_num_tracks("video"): self.debug("%s audio only file applying transcoding ratio." "File 'duration' : %s" % (classname, file_dur)) duration = file_dur / AUDIO_ONLY_FILE_TRANSCODING_RATIO else: duration = file_dur try: timeout = GST_VALIDATE_PROTOCOL_TIMEOUTS[ media_descriptor.get_protocol()] except KeyError: pass super(GstValidateTranscodingTest, self).__init__(GST_VALIDATE_TRANSCODING_COMMAND, classname, options, reporter, duration=duration, timeout=timeout, scenario=scenario, media_descriptor=media_descriptor, extra_env_variables=None) extra_env_variables = extra_env_variables or {} GstValidateEncodingTestInterface.__init__(self, combination, media_descriptor) self.uri = uri def set_rendering_info(self): self.dest_file = os.path.join( self.options.dest, self.classname.replace(".transcode.", os.sep).replace(".", os.sep)) mkdir(os.path.dirname(urlparse.urlsplit(self.dest_file).path)) if urlparse.urlparse(self.dest_file).scheme == "": self.dest_file = path2url(self.dest_file) profile = self.get_profile() self.add_arguments("-o", profile) def build_arguments(self): GstValidateTest.build_arguments(self) self.set_rendering_info() self.add_arguments(self.uri, self.dest_file) def get_current_value(self): if self.scenario: sent_eos = self.sent_eos_position() if sent_eos is not None: t = time.time() if ((t - sent_eos)) > 30: if self.media_descriptor.get_protocol() == Protocols.HLS: self.set_result( Result.PASSED, """Got no EOS 30 seconds after sending EOS, in HLS known and tolerated issue: https://bugzilla.gnome.org/show_bug.cgi?id=723868""" ) return Result.KNOWN_ERROR self.set_result( Result.FAILED, "Pipeline did not stop 30 Seconds after sending EOS") return Result.FAILED size = self.get_current_size() if size is None: return self.get_current_position() return size def check_results(self): if self.result in [Result.FAILED, Result.TIMEOUT] or \ self.process.returncode != 0: GstValidateTest.check_results(self) return res, msg = self.check_encoded_file() self.set_result(res, msg)
class PitiviTestsManager(TestsManager): name = "pitivi" """The name identifying this test manager class.""" _scenarios = ScenarioManager() def init(self): """Initializes the manager.""" self.fixme("Implement init checking") return True def add_options(self, parser): """Adds options to the specified ArgumentParser.""" group = parser.add_argument_group( "Pitivi specific option group" " and behaviours", description="") group.add_argument("--pitivi-executable", dest="pitivi_executable", default=os.path.join("..", "..", "bin", "pitivi"), help="Path to the pitivi executable") group.add_argument("--pitivi-scenarios-paths", dest="pitivi_scenario_paths", help="Paths in which to look for scenario files") def set_settings(self, options, args, reporter): """Configures the manager based on the specified options.""" TestsManager.set_settings(self, options, args, reporter) PitiviTestsManager._scenarios.config = self.options try: os.makedirs(utils.url2path(options.dest)[0]) except OSError: pass def list_tests(self): """Lists the tests in the order they have been added.""" return self.tests def find_scenarios(self): """Yields paths to the found scenario files.""" for path in self.options.pitivi_scenario_paths: for root, unused_dirs, files in os.walk(path): for file in files: if not file.endswith(".scenario"): continue yield os.path.join(path, root, file) def register_defaults(self): """Adds the available scenario files as tests.""" for scenario_name in self.find_scenarios(): scenario = PitiviTestsManager._scenarios.get_scenario( scenario_name) if scenario is None: continue classname = "pitivi.%s" % scenario.name self.add_test( PitiviTest(self.options.pitivi_executable, classname, self.options, self.reporter, scenario=scenario))