Esempio n. 1
0
    def test_deprecated_msg_param(self):
        with warnings.catch_warnings(record=True) as w:
            assertions.assert_is_not(False, None, msg="This is a message")

            assertions.assert_equal(len(w), 1)
            assert issubclass(w[-1].category, DeprecationWarning)
            assertions.assert_in("msg is deprecated", str(w[-1].message))
Esempio n. 2
0
 def test_load_response_content_success(self):
     content = 'not:valid:json'
     http_response = build_file_mock(content)
     response = client.load_response_content(http_response)
     assert_equal(response.error, client.DECODE_ERROR)
     assert_in('No JSON object', response.msg)
     assert_equal(response.content, content)
Esempio n. 3
0
 def test_build_action_run_collection(self):
     collection = ActionRunFactory.build_action_run_collection(self.job_run)
     assert_equal(collection.action_graph, self.action_graph)
     assert_in('act1', collection.run_map)
     assert_in('act2', collection.run_map)
     assert_length(collection.run_map, 2)
     assert_equal(collection.run_map['act1'].action_name, 'act1')
Esempio n. 4
0
 def test_build_action_run_collection(self):
     collection = ActionRunFactory.build_action_run_collection(
         self.job_run, self.action_runner)
     assert_equal(collection.action_graph, self.action_graph)
     assert_in('act1', collection.run_map)
     assert_in('act2', collection.run_map)
     assert_length(collection.run_map, 2)
     assert_equal(collection.run_map['act1'].action_name, 'act1')
Esempio n. 5
0
 def test_valid_time_delta_invalid(self):
     exception = assert_raises(
         ConfigError,
         config_utils.valid_time_delta,
         'no time',
         self.context,
     )
     assert_in('not a valid time delta: no time', str(exception))
Esempio n. 6
0
 def test_build_url_request_with_data(self):
     data = {'param': 'is_set', 'other': 1}
     request = client.build_url_request(self.url, data)
     assert request.has_header('User-agent')
     assert_equal(request.get_method(), 'POST')
     assert_equal(request.get_full_url(), self.url)
     assert_in('param=is_set', request.data)
     assert_in('other=1', request.data)
Esempio n. 7
0
 def test_build_url_request_with_data(self):
     data = {'param': 'is_set', 'other': 1}
     request = client.build_url_request(self.url, data)
     assert request.has_header('User-agent')
     assert_equal(request.get_method(), 'POST')
     assert_equal(request.get_full_url(), self.url)
     assert_in('param=is_set', request.get_data())
     assert_in('other=1', request.get_data())
Esempio n. 8
0
    def test_deprecated_msg_param(self):
        with warnings.catch_warnings(record=True) as w:
            assertions.assert_all_not_match_regex("qux", ["foobar", "barbaz"],
                                                  msg="This is a message")

            assertions.assert_equal(len(w), 1)
            assert issubclass(w[-1].category, DeprecationWarning)
            assertions.assert_in("msg is deprecated", str(w[-1].message))
 def test_proxy_list(self):
     the_list = range(3)
     validator = mock.Mock(return_value=the_list)
     value_proxy = proxy.ValueProxy(validator, self.value_cache, 'the_list')
     assert_equal(value_proxy, the_list)
     assert_in(2, value_proxy)
     assert_equal(value_proxy[:1], [0])
     assert_equal(len(value_proxy), 3)
Esempio n. 10
0
 def test__str__(self):
     self.collection._is_run_blocked = lambda r: r.action_name != 'cleanup'
     expected = [
         "ActionRunCollection", "second_name(scheduled:blocked)",
         "action_name(scheduled:blocked)", "cleanup(scheduled)"
     ]
     for expectation in expected:
         assert_in(expectation, str(self.collection))
Esempio n. 11
0
    def test_deprecated_msg_param(self):
        with warnings.catch_warnings(record=True) as w:
            assertions.assert_dict_subset({"a": 1, "b": 2},
                                          {"a": 1, "b": 2, "c": 3},
                                          msg="This is a message")

            assertions.assert_equal(len(w), 1)
            assert issubclass(w[-1].category, DeprecationWarning)
            assertions.assert_in("msg is deprecated", str(w[-1].message))
Esempio n. 12
0
    def test_deprecated_msg_param(self):
        with warnings.catch_warnings(record=True) as w:
            assertions.assert_all_not_match_regex("qux",
                                                  ["foobar", "barbaz"],
                                                  msg="This is a message")

            assertions.assert_equal(len(w), 1)
            assert issubclass(w[-1].category, DeprecationWarning)
            assertions.assert_in("msg is deprecated", str(w[-1].message))
Esempio n. 13
0
    def test_check_if_pidfile_exists_file_exists(self):
        self.pidfile.__exit__(None, None, None)
        with open(self.filename, 'w') as fh:
            fh.write('123\n')

        with mock.patch.object(PIDFile, 'is_process_running') as mock_method:
            mock_method.return_value = True
            exception = assert_raises(SystemExit, PIDFile, self.filename)
            assert_in('Daemon running as 123', str(exception))
Esempio n. 14
0
 def test_validate_with_none(self):
     expected_msg = "A StubObject is required"
     exception = assert_raises(
         ConfigError,
         self.validator.validate,
         None,
         config_utils.NullConfigContext,
     )
     assert_in(expected_msg, str(exception))
 def test_build_getter(self):
     validator = mock.Mock()
     getter = getters.build_getter(validator)
     assert callable(getter), "Getter is not callable"
     value_proxy = getter('the_name')
     namespace = config.get_namespace(config.DEFAULT)
     assert_in(id(value_proxy), namespace.value_proxies)
     assert_equal(value_proxy.config_key, "the_name")
     assert_equal(value_proxy.namespace, namespace)
Esempio n. 16
0
    def test_deprecated_msg_param(self):
        with warnings.catch_warnings(record=True) as w:
            assertions.assert_subset(set([1, 2]),
                                     set([1, 2, 3]),
                                     msg="This is a message")

            assertions.assert_equal(len(w), 1)
            assert issubclass(w[-1].category, DeprecationWarning)
            assertions.assert_in("msg is deprecated", str(w[-1].message))
Esempio n. 17
0
 def test_build_getter(self):
     validator = mock.Mock()
     getter = getters.build_getter(validator)
     assert callable(getter), "Getter is not callable"
     value_proxy = getter('the_name')
     namespace = config.get_namespace(config.DEFAULT)
     assert_in(id(value_proxy), namespace.value_proxies)
     assert_equal(value_proxy.config_key, "the_name")
     assert_equal(value_proxy.namespace, namespace)
Esempio n. 18
0
    def test_check_if_pidfile_exists_file_exists(self):
        self.pidfile.__exit__(None, None, None)
        with open(self.filename, 'w') as fh:
            fh.write('123\n')

        with mock.patch.object(PIDFile, 'is_process_running') as mock_method:
            mock_method.return_value = True
            exception = assert_raises(SystemExit, PIDFile, self.filename)
            assert_in('Daemon running as 123', str(exception))
Esempio n. 19
0
 def test_build_new_run_manual(self):
     autospec_method(self.run_collection.remove_old_runs)
     run_time = datetime.datetime(2012, 3, 14, 15, 9, 26)
     mock_job = build_mock_job()
     job_run = self.run_collection.build_new_run(
         mock_job, run_time, self.mock_node, True)
     assert_in(job_run, self.run_collection.runs)
     self.run_collection.remove_old_runs.assert_called_with()
     assert_equal(job_run.run_num, 5)
     assert job_run.manual
 def test_build_getter_with_getter_namespace(self):
     validator = mock.Mock()
     name = 'the stars'
     getter = getters.build_getter(validator, getter_namespace=name)
     assert callable(getter), "Getter is not callable"
     value_proxy = getter('the_name')
     namespace = config.get_namespace(name)
     assert_in(id(value_proxy), namespace.value_proxies)
     assert_equal(value_proxy.config_key, "the_name")
     assert_equal(value_proxy.namespace, namespace)
Esempio n. 21
0
 def test__str__(self):
     self.collection._is_run_blocked = lambda r: r.action_name != 'cleanup'
     expected = [
         "ActionRunCollection",
         "second_name(scheduled:blocked)",
         "action_name(scheduled:blocked)",
         "cleanup(scheduled)"
     ]
     for expectation in expected:
         assert_in(expectation, str(self.collection))
Esempio n. 22
0
 def test_build_getter_with_getter_namespace(self):
     validator = mock.Mock()
     name = 'the stars'
     getter = getters.build_getter(validator, getter_namespace=name)
     assert callable(getter), "Getter is not callable"
     value_proxy = getter('the_name')
     namespace = config.get_namespace(name)
     assert_in(id(value_proxy), namespace.value_proxies)
     assert_equal(value_proxy.config_key, "the_name")
     assert_equal(value_proxy.namespace, namespace)
Esempio n. 23
0
 def test_client_returns_zero_on_success(self):
     server_process = subprocess.Popen(
         ["python", "-m", "testify.test_program", "testing_suite.example_test", "--serve", "9001"],
         stdout=open(os.devnull, "w"),
         stderr=open(os.devnull, "w"),
     )
     # test_call has the side-effect of asserting the return code is 0
     ret = test_call(["python", "-m", "testify.test_program", "--connect", "localhost:9001"])
     assert_in("PASSED", ret)
     assert_equal(server_process.wait(), 0)
Esempio n. 24
0
 def test_restore_state(self):
     count = 3
     state_data = [dict(instance_number=i * 3, node="node") for i in xrange(count)]
     autospec_method(self.collection._build_instance)
     created = self.collection.restore_state(state_data)
     assert_length(created, count)
     assert_equal(set(created), set(self.collection.instances))
     expected = [mock.call(self.node_pool.get_by_hostname.return_value, d["instance_number"]) for d in state_data]
     for expected_call in expected:
         assert_in(expected_call, self.collection._build_instance.mock_calls)
Esempio n. 25
0
 def test_rerun_with_failure_limit(self):
     proc = subprocess.Popen(
         (sys.executable, "-m", "testify.test_program", "--rerun-test-file=/dev/stdin", "--failure-limit", "1"),
         stdin=subprocess.PIPE,
         stdout=subprocess.PIPE,
     )
     stdout, _ = proc.communicate(
         b"test.fails_two_tests FailsTwoTests.test1\n" b"test.fails_two_tests FailsTwoTests.test2\n"
     )
     assert_in(b"FAILED.  1 test / 1 case: 0 passed, 1 failed.", stdout)
Esempio n. 26
0
    def test_getters(self):
        get_conf = getters.NamespaceGetters(self.namespace)
        proxies = [
            get_conf.get_bool('is_it'),
            get_conf.get_time('when'),
            get_conf.get_list_of_bool('options')
        ]

        namespace = config.get_namespace(get_conf.namespace)
        for proxy in proxies:
            assert_in(id(proxy), namespace.value_proxies)
    def test_getters(self):
        get_conf = getters.NamespaceGetters(self.namespace)
        proxies = [
            get_conf.get_bool('is_it'),
            get_conf.get_time('when'),
            get_conf.get_list_of_bool('options')
        ]

        namespace = config.get_namespace(get_conf.namespace)
        for proxy in proxies:
            assert_in(id(proxy), namespace.value_proxies)
Esempio n. 28
0
 def test_invalid(self):
     exception = assert_raises(
         ConfigError,
         self.validator,
         'c',
         self.context,
     )
     assert_in(
         'Value at  is not in %s: ' % str(set(self.enum)),
         str(exception),
     )
Esempio n. 29
0
 def test_build_new_run_manual(self):
     self.run_collection.remove_old_runs = Turtle()
     run_time = datetime.datetime(2012, 3, 14, 15, 9, 26)
     job = Turtle(name="thejob")
     job.action_graph.action_map = {}
     node = MockNode("thenode")
     job_run = self.run_collection.build_new_run(job, run_time, node, True)
     assert_in(job_run, self.run_collection.runs)
     assert_call(self.run_collection.remove_old_runs, 0)
     assert_equal(job_run.run_num, 5)
     assert job_run.manual
Esempio n. 30
0
    def test_end_to_end_basic(self):
        self.start_with_config(SINGLE_ECHO_CONFIG)
        client = self.sandbox.client

        assert_equal(
            self.client.config('MASTER')['config'], SINGLE_ECHO_CONFIG)

        # reconfigure and confirm results
        second_config = DOUBLE_ECHO_CONFIG + TOUCH_CLEANUP_FMT
        self.sandbox.tronfig(second_config)
        events = summarize_events(client.events())
        assert_in(('', 'restoring'), events)
        assert_in(('MASTER.echo_job.0', 'created'), events)
        assert_equal(client.config('MASTER')['config'], second_config)

        # reconfigure, by uploading a third configuration
        self.sandbox.tronfig(ALT_NAMESPACED_ECHO_CONFIG, name='ohce')
        self.sandbox.client.home()

        # run the job and check its output
        echo_job_name = 'MASTER.echo_job'
        job_url = client.get_url(echo_job_name)
        action_url = client.get_url('MASTER.echo_job.1.echo_action')

        self.sandbox.tronctl('start', echo_job_name)

        def wait_on_cleanup():
            return (len(client.job(job_url)['runs']) >= 2
                    and client.action_runs(action_url)['state']
                    == actionrun.ActionRun.STATE_SUCCEEDED.name)

        sandbox.wait_on_sandbox(wait_on_cleanup)

        echo_action_run = client.action_runs(action_url)
        another_action_url = client.get_url(
            'MASTER.echo_job.1.another_echo_action')
        other_act_run = client.action_runs(another_action_url)
        assert_equal(echo_action_run['state'],
                     actionrun.ActionRun.STATE_SUCCEEDED.name)
        assert_equal(echo_action_run['stdout'], ['Echo!'])
        assert_equal(other_act_run['state'],
                     actionrun.ActionRun.STATE_FAILED.name)

        now = datetime.datetime.now()
        stdout = now.strftime(
            'Today is %Y-%m-%d, which is the same as %Y-%m-%d')
        assert_equal(other_act_run['stdout'], [stdout])

        job_runs_url = client.get_url('%s.1' % echo_job_name)
        assert_equal(
            client.job_runs(job_runs_url)['state'],
            actionrun.ActionRun.STATE_FAILED.name)
Esempio n. 31
0
    def test_deprecated_msg_param(self):
        with warnings.catch_warnings(record=True) as w:
            assertions.assert_dicts_equal({
                "a": 1,
                "b": 2
            }, {
                "a": 1,
                "b": 2
            },
                                          msg="This is a message")

            assertions.assert_equal(len(w), 1)
            assert issubclass(w[-1].category, DeprecationWarning)
            assertions.assert_in("msg is deprecated", str(w[-1].message))
Esempio n. 32
0
 def test_rerun_with_failure_limit(self):
     proc = subprocess.Popen(
         (
             sys.executable, '-m', 'testify.test_program',
             '--rerun-test-file=/dev/stdin',
             '--failure-limit', '1',
         ),
         stdin=subprocess.PIPE,
         stdout=subprocess.PIPE,
     )
     stdout, _ = proc.communicate(
         b'test.fails_two_tests FailsTwoTests.test1\n'
         b'test.fails_two_tests FailsTwoTests.test2\n'
     )
     assert_in(b'FAILED.  1 test / 1 case: 0 passed, 1 failed.', stdout)
Esempio n. 33
0
 def test_restore_state(self):
     count = 3
     state_data = [
         dict(instance_number=i * 3, node='node') for i in xrange(count)
     ]
     autospec_method(self.collection._build_instance)
     created = self.collection.restore_state(state_data)
     assert_length(created, count)
     assert_equal(set(created), set(self.collection.instances))
     expected = [
         mock.call(self.node_pool.get_by_hostname.return_value,
                   d['instance_number']) for d in state_data
     ]
     for expected_call in expected:
         assert_in(expected_call,
                   self.collection._build_instance.mock_calls)
Esempio n. 34
0
    def test_end_to_end_basic(self):
        self.start_with_config(SINGLE_ECHO_CONFIG)
        client = self.sandbox.client

        assert_equal(self.client.config('MASTER')['config'], SINGLE_ECHO_CONFIG)

        # reconfigure and confirm results
        second_config = DOUBLE_ECHO_CONFIG + TOUCH_CLEANUP_FMT
        self.sandbox.tronfig(second_config)
        events = summarize_events(client.events())
        assert_in(('', 'restoring'), events)
        assert_in(('MASTER.echo_job.0', 'created'), events)
        assert_equal(client.config('MASTER')['config'], second_config)

        # reconfigure, by uploading a third configuration
        self.sandbox.tronfig(ALT_NAMESPACED_ECHO_CONFIG, name='ohce')
        self.sandbox.client.home()

        # run the job and check its output
        echo_job_name = 'MASTER.echo_job'
        job_url = client.get_url(echo_job_name)
        action_url = client.get_url('MASTER.echo_job.1.echo_action')

        self.sandbox.tronctl('start', echo_job_name)

        def wait_on_cleanup():
            return (len(client.job(job_url)['runs']) >= 2 and
                    client.action_runs(action_url)['state'] ==
                    actionrun.ActionRun.STATE_SUCCEEDED.name)
        sandbox.wait_on_sandbox(wait_on_cleanup)

        echo_action_run = client.action_runs(action_url)
        another_action_url = client.get_url('MASTER.echo_job.1.another_echo_action')
        other_act_run = client.action_runs(another_action_url)
        assert_equal(echo_action_run['state'],
            actionrun.ActionRun.STATE_SUCCEEDED.name)
        assert_equal(echo_action_run['stdout'], ['Echo!'])
        assert_equal(other_act_run['state'],
            actionrun.ActionRun.STATE_FAILED.name)

        now = datetime.datetime.now()
        stdout = now.strftime('Today is %Y-%m-%d, which is the same as %Y-%m-%d')
        assert_equal(other_act_run['stdout'], [stdout])

        job_runs_url = client.get_url('%s.1' % echo_job_name)
        assert_equal(client.job_runs(job_runs_url)['state'],
            actionrun.ActionRun.STATE_FAILED.name)
Esempio n. 35
0
 def test_rerun_with_failure_limit(self):
     proc = subprocess.Popen(
         (
             sys.executable,
             '-m',
             'testify.test_program',
             '--rerun-test-file=/dev/stdin',
             '--failure-limit',
             '1',
         ),
         stdin=subprocess.PIPE,
         stdout=subprocess.PIPE,
     )
     stdout, _ = proc.communicate(
         b'test.fails_two_tests FailsTwoTests.test1\n'
         b'test.fails_two_tests FailsTwoTests.test2\n')
     assert_in(b'FAILED.  1 test / 1 case: 0 passed, 1 failed.', stdout)
Esempio n. 36
0
 def test_client_returns_zero_on_success(self):
     server_process = subprocess.Popen(
         [
             'python', '-m', 'testify.test_program',
             'testing_suite.example_test',
             '--serve', '9001',
         ],
         stdout=open(os.devnull, 'w'),
         stderr=open(os.devnull, 'w'),
     )
     # test_call has the side-effect of asserting the return code is 0
     ret = test_call([
         'python', '-m', 'testify.test_program',
         '--connect', 'localhost:9001',
     ])
     assert_in('PASSED', ret)
     assert_equal(server_process.wait(), 0)
Esempio n. 37
0
 def test_client_returns_zero_on_success(self):
     server_process = subprocess.Popen(
         [
             'python', '-m', 'testify.test_program',
             'testing_suite.example_test',
             '--serve', '9001',
         ],
         stdout=open(os.devnull, 'w'),
         stderr=open(os.devnull, 'w'),
     )
     # test_call has the side-effect of asserting the return code is 0
     ret = test_call([
         'python', '-m', 'testify.test_program',
         '--connect', 'localhost:9001',
     ])
     assert_in('PASSED', ret)
     assert_equal(server_process.wait(), 0)
Esempio n. 38
0
    def test_service_failed_restart(self):
        config = BASIC_CONFIG + dedent("""
            services:
                -   name: service_restart
                    node: local
                    pid_file: "/tmp/file_dne"
                    command: "sleep 1; cat /bogus/file/DNE"
                    monitor_interval: 1
                    restart_delay: 2
        """)
        self.start_with_config(config)
        service_name = 'MASTER.service_restart'
        service_url = self.client.get_url(service_name)
        self.sandbox.tronctl('start', service_name)

        waiter = sandbox.build_waiter_func(self.client.service, service_url)
        waiter(service.ServiceState.FAILED)
        service_content = self.client.service(service_url)
        expected = 'cat: /bogus/file/DNE: No such file or directory'
        assert_in(service_content['instances'][0]['failures'][0], expected)
        waiter(service.ServiceState.STARTING)
Esempio n. 39
0
    def test_service_failed_restart(self):
        config = BASIC_CONFIG + dedent("""
            services:
                -   name: service_restart
                    node: local
                    pid_file: "/tmp/file_dne"
                    command: "sleep 1; cat /bogus/file/DNE"
                    monitor_interval: 1
                    restart_delay: 2
        """)
        self.start_with_config(config)
        service_name = 'MASTER.service_restart'
        service_url = self.client.get_url(service_name)
        self.sandbox.tronctl('start', service_name)

        waiter = sandbox.build_waiter_func(self.client.service, service_url)
        waiter(service.ServiceState.FAILED)
        service_content = self.client.service(service_url)
        expected = 'cat: /bogus/file/DNE: No such file or directory'
        assert_in(service_content['instances'][0]['failures'][0], expected)
        waiter(service.ServiceState.STARTING)
Esempio n. 40
0
 def test_render_template(self):
     config_content = "asdf asdf"
     container = self.manager.load.return_value = mock.create_autospec(
         config_parse.ConfigContainer, )
     container.get_node_names.return_value = ['one', 'two', 'three']
     container.get_master.return_value.command_context = {'zing': 'stars'}
     content = self.controller.render_template(config_content)
     assert_in('# one\n# three\n# two\n', content)
     assert_in('# %-30s: %s' % ('zing', 'stars'), content)
     assert_in(config_content, content)
Esempio n. 41
0
 def test_render_template(self):
     config_content = "asdf asdf"
     container = self.manager.load.return_value = mock.create_autospec(
         config_parse.ConfigContainer)
     container.get_node_names.return_value = ['one', 'two', 'three']
     container.get_master.return_value.command_context = {'zing': 'stars'}
     content = self.controller.render_template(config_content)
     assert_in('# one\n# three\n# two\n', content)
     assert_in('# %-30s: %s' % ('zing', 'stars'), content)
     assert_in(config_content, content)
Esempio n. 42
0
 def test_run_testify_from_bin(self):
     output = test_call(['bin/testify', 'testing_suite', '-v'])
     assert_in(self.expected_tests, output)
Esempio n. 43
0
 def test_handle_termination_success(self):
     result = self.controller.handle_termination('kill')
     assert_in("Attempting to kill", result)
Esempio n. 44
0
 def test_handle_termination_not_implemented(self):
     self.action_run.stop.side_effect = NotImplementedError
     result = self.controller.handle_termination('stop')
     assert_in("Failed to stop", result)
Esempio n. 45
0
 def test_handle_command_mapped_command_failed(self):
     self.action_run.cancel.return_value = False
     result = self.controller.handle_command('cancel')
     self.action_run.cancel.assert_called_with()
     assert_in("Failed to cancel", result)
Esempio n. 46
0
 def test_handle_command_mapped_command(self):
     result = self.controller.handle_command('cancel')
     self.action_run.cancel.assert_called_with()
     assert_in("now in state", result)
Esempio n. 47
0
 def test_help(self):
     output = test_call(
         [sys.executable, '-m', 'testify.test_program', '--help'])
     assert_in('Usage:', output)
Esempio n. 48
0
 def test_handle_command_start_failure(self):
     self.instance.start.return_value = False
     response = self.controller.handle_command('start')
     self.instance.start.assert_called_with()
     assert_in("Failed to start", response)
Esempio n. 49
0
 def test_handle_mapped_command_failure(self):
     self.job_run.cancel.return_value = False
     result = self.controller.handle_command('cancel')
     self.job_run.cancel.assert_called_with()
     assert_in('Failed to cancel', result)
Esempio n. 50
0
 def test_handle_command_start(self):
     response = self.controller.handle_command('start')
     self.instance.start.assert_called_with()
     assert_in("starting", response)
Esempio n. 51
0
 def test_handle_mapped_command(self):
     result = self.controller.handle_command('start')
     self.job_run.start.assert_called_with()
     assert_in('now in state', result)
Esempio n. 52
0
 def test_run_testify_test_file_class_and_method(self):
     output = test_call(["python", "testing_suite/example_test.py", "-v", "ExampleTestCase.test_one"])
     assert_in("PASSED.  1 test", output)
Esempio n. 53
0
 def test_run_testify_test_file_class(self):
     output = test_call(["python", "testing_suite/example_test.py", "-v", "ExampleTestCase"])
     assert_in("PASSED.  2 tests", output)
Esempio n. 54
0
 def test_run_testify_test_module(self):
     output = test_call(['python', '-m', 'testing_suite.example_test', '-v'])
     assert_in(self.expected_tests, output)
Esempio n. 55
0
 def test_handle_command_start_failed(self):
     self.job_run.is_scheduled = True
     result = self.controller.handle_command('start')
     assert not self.action_run.start.mock_calls
     assert_in("can not be started", result)
Esempio n. 56
0
 def test_run_testify_test_file(self):
     output = test_call(['python', 'testing_suite/example_test.py', '-v'])
     assert_in(self.expected_tests, output)
Esempio n. 57
0
 def test_run_testify_test_file_class(self):
     output = test_call([
             'python', 'testing_suite/example_test.py', '-v',
             'ExampleTestCase'])
     assert_in('PASSED.  2 tests', output)
Esempio n. 58
0
 def test_run_testify_test_file_class_and_method(self):
     output = test_call([
             'python', 'testing_suite/example_test.py', '-v',
             'ExampleTestCase.test_one'])
     assert_in('PASSED.  1 test', output)
Esempio n. 59
0
 def test_run_testify_test_file(self):
     output = test_call(["python", "testing_suite/example_test.py", "-v"])
     assert_in(self.expected_tests, output)