Python selenium.SeleniumExecutor类代码示例

    def test_chrome_proxy(self):
        self.obj.responses = [
            ResponseEmul(200, '{"result" : {}}'),
            ResponseEmul(200, '{"result" : {"port": "port1", "host": "host1"}}'),
            ResponseEmul(200, ''),
            ResponseEmul(200, ''),  # startup: startRecording
            ResponseEmul(200, ''),  # shutdown: stopRecording
            ResponseEmul(200, '{"result" : "http://jmx_url"}'),
            ResponseEmul(200, 'regular jmx contents'),
            ResponseEmul(200, '{"result" : "http://smartjmx_url"}'),
            ResponseEmul(200, 'smartjmx content')]

        self.obj.engine.config.merge({
            'modules': {
                'recorder': {
                    'token': '123'}}})
        self.obj.settings = self.obj.engine.config.get('modules').get('recorder')
        self.sniff_log(self.obj.log)

        executor = SeleniumExecutor()
        executor.env = self.obj.engine.env
        self.obj.engine.provisioning.executors = [executor]

        self.obj.prepare()

        if is_linux():
            self._check_linux()
        elif is_windows():
            self._check_windows()
        else:  # MacOS
            self._check_mac()

        self.obj.shutdown()
        self.obj.post_process()

 def test_selenium_startup_shutdown_python_folder(self):
     """
     run tests from .py files
     :return:
     """
     obj = SeleniumExecutor()
     obj.engine = EngineEmul()
     obj.engine.config.merge({
         'execution': {
             'scenario': {'script': __dir__() + '/../selenium/python/'},
             'executor': 'selenium'
         },
         'reporting': [{'module': 'junit-xml'}]
     })
     obj.engine.config.merge({"provisioning": "local"})
     obj.execution = obj.engine.config['execution']
     obj.settings.merge(obj.engine.config.get("modules").get("selenium"))
     obj.prepare()
     obj.startup()
     while not obj.check():
         time.sleep(1)
     obj.shutdown()
     prepared_files = os.listdir(obj.runner.working_dir)
     python_files = [fname for fname in prepared_files if fname.endswith(".py")]
     self.assertEqual(2, len(python_files))
     self.assertTrue(os.path.exists(obj.runner.settings.get("report-file")))

    def test_resource_files_collection_remote_nose(self):
        obj = SeleniumExecutor()
        obj.engine = EngineEmul()
        obj.execution.merge({"scenario": {"script": __dir__() + "/../selenium/python/"}})
        obj.settings.merge(obj.engine.config.get("modules").get("selenium"))

        self.assertEqual(len(obj.resource_files()), 1)

    def test_selenium_startup_shutdown_java_folder(self):
        """
        run tests from .java files
        :return:
        """
        obj = SeleniumExecutor()
        obj.engine = EngineEmul()
        obj.engine.config.merge(yaml.load(open("tests/yaml/selenium_executor_java.yml").read()))
        obj.engine.config.merge({"provisioning": "local"})
        obj.execution = obj.engine.config['execution']
        obj.settings.merge(obj.engine.config.get("modules").get("selenium"))
        obj.prepare()
        obj.startup()
        while not obj.check():
            time.sleep(1)
        obj.shutdown()

        prepared_files = os.listdir(obj.runner.working_dir)
        java_files = [file for file in prepared_files if file.endswith(".java")]
        class_files = [file for file in prepared_files if file.endswith(".class")]
        jars = [file for file in prepared_files if file.endswith(".jar")]
        self.assertEqual(2, len(java_files))
        self.assertEqual(2, len(class_files))
        self.assertEqual(1, len(jars))
        self.assertTrue(os.path.exists(os.path.join(obj.runner.working_dir, "compiled.jar")))
        self.assertTrue(os.path.exists(obj.runner.report_file))

    def test_selenium_startup_shutdown_python_single(self):
        """
        run tests from .py file
        :return:
        """

        obj = SeleniumExecutor()
        obj.engine = EngineEmul()
        obj.engine.config = BetterDict()
        obj.engine.config.merge(yaml.load(open("tests/yaml/selenium_executor_python.yml").read()))
        obj.engine.config.merge({"provisioning": "local"})
        obj.execution = obj.engine.config["execution"]

        obj.execution.merge({"scenario": {"script": ABS_PATH("/../../tests/selenium/python/test_blazemeter_fail.py")}})

        obj.settings.merge(obj.engine.config.get("modules").get("selenium"))
        obj.prepare()
        obj.startup()
        while not obj.check():
            time.sleep(1)
        obj.shutdown()
        prepared_files = os.listdir(obj.runner.working_dir)
        python_files = [file for file in prepared_files if file.endswith(".py")]
        self.assertEqual(1, len(python_files))
        self.assertTrue(os.path.exists(obj.runner.settings.get("report-file")))

    def test_install_tools(self):
        """
        check installation of selenium-server, junit
        :return:
        """
        dummy_installation_path = os.path.abspath(__dir__() + "/../../build/tmp/selenium-taurus")
        base_link = "file://" + __dir__() + "/../data/"

        shutil.rmtree(os.path.dirname(dummy_installation_path), ignore_errors=True)

        selenium_server_link = SeleniumExecutor.SELENIUM_DOWNLOAD_LINK
        SeleniumExecutor.SELENIUM_DOWNLOAD_LINK = base_link + "selenium-server-standalone-2.46.0.jar"

        junit_link = SeleniumExecutor.JUNIT_DOWNLOAD_LINK
        SeleniumExecutor.JUNIT_DOWNLOAD_LINK = base_link + "junit-4.12.jar"

        self.assertFalse(os.path.exists(dummy_installation_path))
        obj = SeleniumExecutor()
        obj.engine = EngineEmul()
        obj.settings.merge({"selenium-tools": {
            "junit": {"selenium-server": os.path.join(dummy_installation_path, "selenium-server.jar")}}})
        obj.settings.merge({"selenium-tools": {
            "junit": {"path": os.path.join(dummy_installation_path, "tools", "junit", "junit.jar")}}})

        obj.execution = BetterDict()
        obj.execution.merge({"scenario": {"script": os.path.abspath(__dir__() + "/../../tests/selenium/jar/")}})
        obj.prepare()
        self.assertTrue(os.path.exists(os.path.join(dummy_installation_path, "selenium-server.jar")))
        self.assertTrue(os.path.exists(os.path.join(dummy_installation_path, "tools", "junit", "junit.jar")))

        SeleniumExecutor.SELENIUM_DOWNLOAD_LINK = selenium_server_link
        SeleniumExecutor.JUNIT_DOWNLOAD_LINK = junit_link

    def test_selenium_startup_shutdown_jar_single(self):
        """
        runt tests from single jar
        :return:
        """
        obj = SeleniumExecutor()
        obj.engine = EngineEmul()
        obj.engine.config.merge(yaml.load(open("tests/yaml/selenium_executor_jar.yml").read()))
        obj.engine.config.merge({"provisioning": "local"})
        obj.execution = obj.engine.config['execution']
        obj.execution.merge(
            {"scenario": {"script": os.path.abspath(__dir__() + "/../../tests/selenium/jar/dummy.jar")}})
        obj.settings.merge(obj.engine.config.get("modules").get("selenium"))
        obj.prepare()
        obj.startup()
        while not obj.check():
            time.sleep(1)
        obj.shutdown()

        prepared_files = os.listdir(obj.runner.working_dir)
        java_files = [file for file in prepared_files if file.endswith(".java")]
        class_files = [file for file in prepared_files if file.endswith(".class")]
        jars = [file for file in prepared_files if file.endswith(".jar")]
        self.assertEqual(len(java_files), 0)
        self.assertEqual(len(class_files), 0)
        self.assertEqual(len(jars), 1)
        self.assertTrue(os.path.exists(obj.runner.report_file))

    def test_resource_files_collection_remote_nose(self):
        obj = SeleniumExecutor()
        obj.engine = EngineEmul()
        obj.execution.merge({"scenario": {"script": __dir__() + "/../selenium/python/"}})
        obj.settings.merge(obj.engine.config.get("modules").get("selenium"))

        res_files = obj.resource_files()
        res_artifacts = os.listdir(os.path.join(obj.engine.artifacts_dir, res_files[0]))
        self.assertEqual(len(res_artifacts), 2)

 def test_empty_scenario(self):
     """
     Raise runtime error when no scenario provided
     :return:
     """
     obj = SeleniumExecutor()
     obj.engine = EngineEmul()
     obj.engine.config.merge({ScenarioExecutor.EXEC: {"executor": "selenium"}})
     obj.execution = obj.engine.config['execution']
     self.assertRaises(ValueError, obj.prepare)

 def test_remote_prov_requests(self):
     obj = SeleniumExecutor()
     obj.engine = EngineEmul()
     obj.execution.merge({
         "scenario": {
             "requests": [
                 "http://blazedemo.com"
             ]
         }
     })
     obj.resource_files()

 def test_empty_scenario(self):
     """
     Raise runtime error when no scenario provided
     :return:
     """
     obj = SeleniumExecutor()
     obj.engine = EngineEmul()
     obj.engine.config = BetterDict()
     obj.engine.config.merge({"execution": {"executor": "selenium"}})
     obj.execution = obj.engine.config["execution"]
     self.assertRaises(RuntimeError, obj.prepare)

 def test_selenium_prepare_python_folder(self):
     """
     Check if scripts exist in working dir
     :return:
     """
     obj = SeleniumExecutor()
     obj.engine = EngineEmul()
     obj.execution.merge({"scenario": {"script": __dir__() + "/../selenium/python/"}})
     obj.prepare()
     python_scripts = os.listdir(obj.runner.working_dir)
     self.assertEqual(len(python_scripts), 2)

 def test_prepare_java_package(self):
     """
     Check if scripts exist in working dir
     :return:
     """
     obj = SeleniumExecutor()
     obj.engine = EngineEmul()
     obj.execution = BetterDict()
     obj.execution.merge(
         {"scenario": {"script": os.path.abspath(__dir__() + "/../../tests/selenium/java_package/")}})
     obj.prepare()
     self.assertTrue(os.path.exists(os.path.join(obj.runner.working_dir, "compiled.jar")))

 def test_javac_fail(self):
     """
     Test RuntimeError when compilation fails
     :return:
     """
     obj = SeleniumExecutor()
     obj.engine = EngineEmul()
     obj.engine.config = BetterDict()
     obj.engine.config.merge(
         {"execution": {"executor": "selenium", "scenario": {"script": "tests/selenium/invalid/invalid.java"}}})
     obj.execution = obj.engine.config['execution']
     self.assertRaises(RuntimeError, obj.prepare)

 def test_prepare_jar_folder(self):
     """
     Check if jars exist in working dir
     :return:
     """
     obj = SeleniumExecutor()
     obj.engine = EngineEmul()
     obj.execution = BetterDict()
     obj.execution.merge({"scenario": {"script": os.path.abspath(__dir__() + "/../../tests/selenium/jar/")}})
     obj.prepare()
     java_scripts = os.listdir(obj.runner.working_dir)
     self.assertEqual(len(java_scripts), 2)