Esempio n. 1
0
    def test_side_effect(self):
        mock = Mock()

        def effect(*args, **kwargs):
            raise SystemError('kablooie')

        mock.side_effect = effect
        self.assertRaises(SystemError, mock, 1, 2, fish=3)
        mock.assert_called_with(1, 2, fish=3)

        results = [1, 2, 3]
        def effect():
            return results.pop()
        mock.side_effect = effect

        self.assertEqual([mock(), mock(), mock()], [3, 2, 1],
                          "side effect not used correctly")

        mock = Mock(side_effect=sentinel.SideEffect)
        self.assertEqual(mock.side_effect, sentinel.SideEffect,
                          "side effect in constructor not used")

        def side_effect():
            return DEFAULT
        mock = Mock(side_effect=side_effect, return_value=sentinel.RETURN)
        self.assertEqual(mock(), sentinel.RETURN)
Esempio n. 2
0
    def test_side_effect(self):
        mock = Mock()

        def effect(*args, **kwargs):
            raise SystemError('kablooie')

        mock.side_effect = effect
        self.assertRaises(SystemError, mock, 1, 2, fish=3)
        mock.assert_called_with(1, 2, fish=3)

        results = [1, 2, 3]

        def effect():
            return results.pop()

        mock.side_effect = effect

        self.assertEqual([mock(), mock(), mock()], [3, 2, 1],
                         "side effect not used correctly")

        mock = Mock(side_effect=sentinel.SideEffect)
        self.assertEqual(mock.side_effect, sentinel.SideEffect,
                         "side effect in constructor not used")

        def side_effect():
            return DEFAULT

        mock = Mock(side_effect=side_effect, return_value=sentinel.RETURN)
        self.assertEqual(mock(), sentinel.RETURN)
Esempio n. 3
0
def test_success(cli_paths):
    string_io = io.StringIO()
    pytest.helpers.create_cli_project(cli_paths.test_directory_path)
    material_path = pytest.helpers.create_cli_material(
        cli_paths.test_directory_path, "test_material")
    script = supriya.cli.ManageMaterialScript()
    command = ["--edit", "test_material"]
    mock_path = "supriya.cli.ProjectPackageScript._call_subprocess"
    with unittest.mock.patch(mock_path) as mock:
        mock.return_value = 0
        with uqbar.io.RedirectedStreams(
                stdout=string_io), uqbar.io.DirectoryChange(
                    cli_paths.inner_project_path):
            try:
                script(command)
            except SystemExit as e:
                raise RuntimeError("SystemExit: {}".format(e.code))
    pytest.helpers.compare_strings(
        r"""
        Edit candidates: 'test_material' ...
        """,
        string_io.getvalue(),
    )
    definition_path = material_path.joinpath("definition.py")
    command = "{} {!s}".format(
        supriya.config.get("core", "editor", fallback="vim"), definition_path)
    mock.assert_called_with(command)
def test_success(cli_paths):
    string_io = io.StringIO()
    pytest.helpers.create_cli_project(cli_paths.test_directory_path)
    material_path = pytest.helpers.create_cli_material(
        cli_paths.test_directory_path, "test_material"
    )
    script = supriya.cli.ManageMaterialScript()
    command = ["--edit", "test_material"]
    mock_path = "supriya.cli.ProjectPackageScript._call_subprocess"
    with unittest.mock.patch(mock_path) as mock:
        mock.return_value = 0
        with uqbar.io.RedirectedStreams(stdout=string_io), uqbar.io.DirectoryChange(
            cli_paths.inner_project_path
        ):
            try:
                script(command)
            except SystemExit as exception:
                if exception.args[0]:
                    raise RuntimeError("SystemExit: {}".format(exception.code))
    pytest.helpers.compare_strings(
        r"""
        Edit candidates: 'test_material' ...
        """,
        string_io.getvalue(),
    )
    definition_path = material_path.joinpath("definition.py")
    command = "{} {!s}".format(
        supriya.config.get("core", "editor", fallback="vim"), definition_path
    )
    mock.assert_called_with(command)
Esempio n. 5
0
    def test_init_and_close_loop_for_test(self):
        default_loop = self.create_default_loop()

        @asynctest.lenient
        class LoopTest(asynctest.TestCase):
            failing = False

            def runTest(self):
                try:
                    self.assertIsNotNone(self.loop)
                    self.assertFalse(self.loop.close.called)
                except Exception:
                    self.failing = True
                    raise

            def runFailingTest(self):
                self.runTest()
                raise SystemError()

        for method, test in itertools.product(self.run_methods, ('runTest', 'runFailingTest', )):
            with self.subTest(method=method, test=test), \
                    unittest.mock.patch('asyncio.new_event_loop') as mock:
                mock_loop = unittest.mock.Mock(asyncio.AbstractEventLoop)
                mock.return_value = mock_loop

                case = LoopTest(test)
                try:
                    getattr(case, method)()
                except SystemError:
                    pass

                mock.assert_called_with()
                mock_loop.close.assert_called_with()
                self.assertFalse(case.failing)
                self.assertIs(default_loop, asyncio.get_event_loop())
Esempio n. 6
0
 def test_received_cmd_is_invalid(self):
     inst = self.make_agent(core.BaseAgent, None)
     with unittest.mock.patch.object(inst.timer, 'wait',
                                     return_value=('invalid', None)):
         with unittest.mock.patch.object(inst.timer, 'response') as mock:
             inst.delayfunc(5)
             mock.assert_called_with(is_ok=False, detail='invalid cmd')
Esempio n. 7
0
 def test_init_slack_client(self, mock):
     """
     Test __init__ method SlackClient call.
     """
     proxies = {'http': {'vpprx': 0000}, 'https': {'vpprx': 0000}}
     token = 'TestToken'
     SlackHandler(token, '#channel', proxies)
     mock.assert_called_with(token, proxies=proxies)
Esempio n. 8
0
def test_resolve_charm_type(config):
    """The config indicates the project is a charm."""
    config.set(type="charm")
    cmd = PackCommand(config)

    with patch.object(cmd, "_pack_charm") as mock:
        cmd.run(noargs)
    mock.assert_called_with(noargs)
Esempio n. 9
0
 def test_init_url(self, mock):
     """
     Test __init__ method correctly set url.
     """
     flask_engine = FlaskEngine({'/test': {'cls': MethodView}}, {})
     mock.assert_called_with(
         '/test', view_func=flask_engine._get_view(MethodView), methods=None
     )
Esempio n. 10
0
 def test_add_custom_constructors(self, mock):
     """
     Test add_custom_constructors method return value and call yaml.add_constructor.
     """
     custom_constructors = {'!test': YamlConstructor.simple_join}
     ret = self.yaml_parser.add_custom_constructors(custom_constructors)
     mock.assert_called_with('!test', custom_constructors['!test'])
     self.assertEqual(self.yaml_parser, ret)
    def test_calculate_percentage_of_image_being_real_function_calls_convert_list_to_format_for_analysis_function(
            self):
        image_analysis = ImageAnalysis()
        with patch.object(DataUtils,
                          'convert_list_to_format_for_analysis') as mock:
            image_analysis.calculate_percentage_of_image_being_real("image")

        mock.assert_called_with("image")
Esempio n. 12
0
 def test_assert_called_with(self):
     mock = Mock()
     mock()
     mock.assert_called_with()
     self.assertRaises(AssertionError, mock.assert_called_with, 1)
     mock.reset_mock()
     self.assertRaises(AssertionError, mock.assert_called_with)
     mock(1, 2, 3, a='fish', b='nothing')
     mock.assert_called_with(1, 2, 3, a='fish', b='nothing')
Esempio n. 13
0
def test_callbackConnect_non_gns3_server(http_client):

    params = {
        "virus": True,
    }
    mock = unittest.mock.MagicMock()
    http_client._callbackConnect("GET", "/version", mock, {}, {}, params)
    assert http_client._connected is False
    mock.assert_called_with({"message": "The remote server http://127.0.0.1:8000 is not a GNS3 server"}, error=True, server=http_client)
Esempio n. 14
0
 def test_add_getter_constructor(self, mock, mock_partial):
     """
     Test add_getter_constructor method.
     """
     name = '!test'
     data = {}
     ret = self.yaml_parser.add_getter_constructor(name, data)
     mock.assert_called_with(name, mock_partial())
     self.assertEqual(self.yaml_parser, ret)
Esempio n. 15
0
 def _check(mock):
     mock(1, b=2, c=3)
     mock.assert_called_with(1, 2, 3)
     mock.assert_called_with(a=1, b=2, c=3)
     self.assertRaises(AssertionError,
                       mock.assert_called_with,
                       1,
                       b=3,
                       c=2)
Esempio n. 16
0
    def test_setting_call(self):
        mock = Mock()

        def __call__(self, a):
            return self._mock_call(a)
        type(mock).__call__ = __call__
        mock('one')
        mock.assert_called_with('one')
        self.assertRaises(TypeError, mock, 'one', 'two')
Esempio n. 17
0
 def test_assert_called_with(self):
     mock = Mock()
     mock()
     mock.assert_called_with()
     self.assertRaises(AssertionError, mock.assert_called_with, 1)
     mock.reset_mock()
     self.assertRaises(AssertionError, mock.assert_called_with)
     mock(1, 2, 3, a='fish', b='nothing')
     mock.assert_called_with(1, 2, 3, a='fish', b='nothing')
Esempio n. 18
0
 def test_java_exception_side_effect(self):
     import java
     mock = Mock(side_effect=java.lang.RuntimeException('Boom!'))
     try:
         mock(1, 2, fish=3)
     except java.lang.RuntimeException:
         pass
     self.fail('java exception not raised')
     mock.assert_called_with(1, 2, fish=3)
Esempio n. 19
0
    def test_eval_without_handler(self, mocker):
        """Ensure that code is sent to octave for evaluation."""
        mock = mocker.patch('matl_online.octave.OctaveEngine.eval')

        session = OctaveSession()
        code = '1 + 1'
        session.eval(code)

        mock.assert_called_with(code)
Esempio n. 20
0
    def test_fetch(self, mock, requests_mock):
        url = f'https://api.um.warszawa.pl/api/action/busestrams_get/' \
              f'?resource_id=f2e5503e927d-4ad3-9500-4ab9e55deb59&apikey=foo' \
              f'&type=1'
        requests_mock.get(url, text='{"result": "bar"}')

        fetcher = PositionFetcher(api_key='foo')
        fetcher.fetch()
        mock.assert_called_with('bar')
Esempio n. 21
0
    def test_fetch(self, mock, requests_mock):
        url = f'https://api.um.warszawa.pl/api/action/dbstore_get/' \
              f'?id=ab75c33d-3a26-4342-b36a-6e5fef0a3ac3&apikey=foo'
        requests_mock.get(url, text='{"result": "bar"}')

        fetcher = ScheduleFetcher(api_key='foo')
        fetcher.fetch()

        mock.assert_called_with('bar')
 def assert_called_with(self, mock: mock.Mock, status: int,
                        text_output: str, performance_data: str):
     mock.assert_called_with(url='1.2.3.4',
                             user='******',
                             password='******',
                             status=status,
                             host_name=cwatcher.HOSTNAME,
                             service_name='my_service',
                             text_output=text_output,
                             performance_data=performance_data)
Esempio n. 23
0
 def test_emit_with_file(self, mock):
     """
     Test emit method with fiel.
     """
     file = '/file/path'
     record = self._record
     record.args = [file]
     self.handler.emit(record)
     mock.assert_called_with(record, file)
     self.assertIsNone(record.args)
Esempio n. 24
0
    def test_setting_call(self):
        mock = Mock()
        def __call__(self, a):
            return self._mock_call(a)

        type(mock).__call__ = __call__
        mock('one')
        mock.assert_called_with('one')

        self.assertRaises(TypeError, mock, 'one', 'two')
Esempio n. 25
0
    def test_fetch_schedules(self, mock, requests_mock):
        url = f'https://api.um.warszawa.pl/api/action/dbtimetable_get/' \
              f'?id=e923fa0e-d96c-43f9-ae6e-60518c9f3238&apikey=foo' \
              f'&busstopId=420&busstopNr=0&line=100'
        requests_mock.get(url, text='{"result": "bar"}')

        fetcher = ScheduleFetcher(api_key='foo')
        fetcher.fetch_schedules(self.LINES[0], self.STOPS[0])

        mock.assert_called_with('bar', self.LINES[0], self.STOPS[0])
Esempio n. 26
0
def test_callbackConnect_version_non_local(http_client):

    params = {
        "local": False,
        "version": __version__
    }
    mock = unittest.mock.MagicMock()
    http_client._callbackConnect("GET", "/version", mock, {}, {}, params)
    assert http_client._connected is False
    mock.assert_called_with({"message": "Running server is not a GNS3 local server (not started with --local)"}, error=True, server=http_client)
Esempio n. 27
0
def test_callbackConnect_major_version_invalid(http_client):

    params = {
        "local": True,
        "version": "1.2.3"
    }
    mock = unittest.mock.MagicMock()
    http_client._callbackConnect("GET", "/version", mock, {}, {}, params)
    assert http_client._connected is False
    mock.assert_called_with({"message": "Client version {} differs with server version 1.2.3".format(__version__)}, error=True, server=http_client)
Esempio n. 28
0
    def test_fetch_lines(self, mock, requests_mock):
        url = f'https://api.um.warszawa.pl/api/action/dbtimetable_get/' \
              f'?id=88cd555f-6f31-43ca-9de4-66c479ad5942&apikey=foo' \
              f'&busstopId=420&busstopNr=0'
        requests_mock.get(url, text='{"result": "bar"}')

        fetcher = ScheduleFetcher(api_key='foo')
        fetcher.fetch_lines(self.STOPS[0])

        mock.assert_called_with('bar', self.STOPS[0])
Esempio n. 29
0
    def test_tournament_start_success(self):
        # Test that RPP can successfully send a tournament start message and recieve ack
        rpp = RemotePlayerProxy('name', 1.0, self.dummy_socket)
        rpp._RemotePlayerProxy__socket = self.mock_socket
        self.mock_socket.recv.return_value = b'"void"'
        expected_client_request = f'["start", [true]]'

        with patch.object(rpp, '_RemotePlayerProxy__send_message') as mock:
            ack = rpp.tournament_has_started()
            mock.assert_called_with(expected_client_request)
            self.assertEqual(ack, True)
Esempio n. 30
0
    def test_playing_with_no_ack(self):
        # Test that RPP will return False if no ack received for set_color
        rpp = RemotePlayerProxy('name', 1.0, self.dummy_socket)
        rpp._RemotePlayerProxy__socket = self.mock_socket
        self.mock_socket.recv.return_value = b'whoops'
        expected_client_request = f'["playing-with", ["white", "black"]]'

        with patch.object(rpp, '_RemotePlayerProxy__send_message') as mock:
            ack = rpp.notify_opponent_colors([Color.WHITE, Color.BLACK])
            mock.assert_called_with(expected_client_request)
            self.assertEqual(ack, False)
Esempio n. 31
0
    def test_playing_with_success(self):
        # Test that RPP can successfully send a color and receive ACK from client
        rpp = RemotePlayerProxy('name', 1.0, self.dummy_socket)
        rpp._RemotePlayerProxy__socket = self.mock_socket
        self.mock_socket.recv.return_value = b'"void"'
        expected_client_request = f'["playing-with", ["red", "brown"]]'

        with patch.object(rpp, '_RemotePlayerProxy__send_message') as mock:
            ack = rpp.notify_opponent_colors([Color.RED, Color.BROWN])
            mock.assert_called_with(expected_client_request)
            self.assertEqual(ack, True)
Esempio n. 32
0
    def test_set_color_no_ack(self):
        # Test that RPP will return False if no ack received for set_color
        rpp = RemotePlayerProxy('name', 1.0, self.dummy_socket)
        rpp._RemotePlayerProxy__socket = self.mock_socket
        self.mock_socket.recv.return_value = b'[1, 2]'
        expected_client_request = f'["playing-as", ["white"]]'

        with patch.object(rpp, '_RemotePlayerProxy__send_message') as mock:
            ack = rpp.set_color(Color.WHITE)
            mock.assert_called_with(expected_client_request)
            self.assertEqual(ack, False)
Esempio n. 33
0
    def test_setting_call(self):
        mock = Mock()

        def __call__(self, a):
            return self._mock_call(a)

        type(mock).__call__ = __call__
        mock("one")
        mock.assert_called_with("one")

        self.assertRaises(TypeError, mock, "one", "two")
    def test_send_cdi_email(self):
        with unittest.mock.patch('prog_code.util.mail_util.send_msg') as mock:
            form_url = parent_account_util.URL_TEMPLATE % 'url'
            msg = parent_account_util.get_cdi_email_template() % ('child',
                                                                  form_url)

            test_form = TEST_PARENT_FORM('child', 'url', 'test email')
            parent_account_util.send_cdi_email(test_form)

            mock.assert_called_with('test email',
                                    parent_account_util.CDI_EMAIL_SUBJECT, msg)
Esempio n. 35
0
def test_callbackConnect_non_gns3_server(http_client):

    http_client.setMaxRetryConnection(0)
    params = {
        "virus": True,
    }
    mock = unittest.mock.MagicMock()
    http_client._query_waiting_connections.append((None, mock))
    http_client._callbackConnect(params)
    assert http_client._connected is False
    mock.assert_called_with({"message": "The remote server http://127.0.0.1:3080 is not a GNS3 server"}, error=True, server=None)
Esempio n. 36
0
    def test_tournament_start_no_ack(self):
        # Test that RPP will return False if no ack received for tournament_start
        rpp = RemotePlayerProxy('name', 1.0, self.dummy_socket)
        rpp._RemotePlayerProxy__socket = self.mock_socket
        self.mock_socket.recv.return_value = b'[][]'
        expected_client_request = f'["start", [true]]'

        with patch.object(rpp, '_RemotePlayerProxy__send_message') as mock:
            ack = rpp.tournament_has_started()
            mock.assert_called_with(expected_client_request)
            self.assertEqual(ack, False)
Esempio n. 37
0
    def test_get_windows_symbols(self):
        ''' ensures that the windows symbol server endpoint is working '''
        url = url_for_ish(self.WEBPAGES.Get_Windows_Symbols, path='test_path')
        with unittest.mock.patch('flask.send_file') as send_file_mock:
            with unittest.mock.patch(
                    'storage.Storage.getWindowsSymbolFilePath',
                    return_value=None) as mock:
                self.app.get(url)
                mock.assert_called_with('test_path')

            send_file_mock.assert_called_once()
Esempio n. 38
0
def test_callbackConnect_major_version_invalid(http_client):

    params = {
        "local": True,
        "version": "1.2.3"
    }
    mock = unittest.mock.MagicMock()
    http_client._query_waiting_connections.append((None, mock))
    http_client._callbackConnect(params)
    assert http_client._connected is False
    mock.assert_called_with({"message": "Client version {} is not the same as server (controller) version 1.2.3".format(__version__)}, error=True, server=None)
Esempio n. 39
0
    def test_java_exception_side_effect(self):
        import java
        mock = Mock(side_effect=java.lang.RuntimeException("Boom!"))

        # can't use assertRaises with java exceptions
        try:
            mock(1, 2, fish=3)
        except java.lang.RuntimeException:
            pass
        else:
            self.fail('java exception not raised')
        mock.assert_called_with(1, 2, fish=3)
Esempio n. 40
0
def test_resolve_no_config_packs_charm(config, tmp_path):
    """There is no config, so it's decided to pack a charm."""
    config.set(project=Project(
        config_provided=False,
        dirpath=tmp_path,
        started_at=datetime.datetime.utcnow(),
    ))
    cmd = PackCommand(config)

    with patch.object(cmd, "_pack_charm") as mock:
        cmd.run(noargs)
    mock.assert_called_with(noargs)
Esempio n. 41
0
    def test_java_exception_side_effect(self):
        import java
        mock = Mock(side_effect=java.lang.RuntimeException("Boom!"))

        # can't use assertRaises with java exceptions
        try:
            mock(1, 2, fish=3)
        except java.lang.RuntimeException:
            pass
        else:
            self.fail('java exception not raised')
        mock.assert_called_with(1,2, fish=3)
Esempio n. 42
0
def test_callbackConnect_version_non_local(http_client):

    params = {"local": False, "version": __version__}
    mock = unittest.mock.MagicMock()
    http_client._callbackConnect("GET", "/version", mock, {}, {}, params)
    assert http_client._connected is False
    mock.assert_called_with(
        {
            "message":
            "Running server is not a GNS3 local server (not started with --local)"
        },
        error=True,
        server=http_client)
Esempio n. 43
0
def test__request():
    client = Client(domain='test', token='test')

    with unittest.mock.patch('requests.request') as mock:
        client.deals(1).update(title='test')

        mock.assert_called_with(
            'PUT',
            'https://test.pipedrive.com/api/v1/deals/1',
            json={'title': 'test'},
            params={'api_token': 'test'},
            headers={'Content-Type': 'application/json'},
        )
Esempio n. 44
0
    def test_assert_called_with(self):
        mock = Mock()
        mock()

        # Will raise an exception if it fails
        mock.assert_called_with()
        self.assertRaises(AssertionError, mock.assert_called_with, 1)

        mock.reset_mock()
        self.assertRaises(AssertionError, mock.assert_called_with)

        mock(1, 2, 3, a="fish", b="nothing")
        mock.assert_called_with(1, 2, 3, a="fish", b="nothing")
Esempio n. 45
0
def test_callbackConnect_minor_version_invalid(http_client):

    new_version = "{}.{}.{}".format(__version_info__[0], __version_info__[1], __version_info__[2] + 1)
    params = {
        "local": True,
        "version": new_version
    }
    mock = unittest.mock.MagicMock()

    # Stable release
    if __version_info__[3] == 0:
        http_client._callbackConnect("GET", "/version", mock, {}, {}, params)
        assert http_client._connected is False
        mock.assert_called_with({"message": "Client version {} differs with server version {}".format(__version__, new_version)}, error=True, server=http_client)
    else:
        http_client._callbackConnect("GET", "/version", mock, {}, {}, params)
        assert http_client._connected is True
Esempio n. 46
0
    def test_init_and_close_loop_for_test(self):
        default_loop = self.create_default_loop()

        @asynctest.lenient
        class LoopTest(asynctest.TestCase):
            failing = False

            def runTest(self):
                try:
                    self.assertIsNotNone(self.loop)
                    self.assertFalse(self.loop.close.called)
                except Exception:
                    self.failing = True
                    raise

            def runFailingTest(self):
                self.runTest()
                raise SystemError()

        for method, test in itertools.product(self.run_methods, ('runTest', 'runFailingTest', )):
            with self.subTest(method=method, test=test), \
                    unittest.mock.patch('asyncio.new_event_loop') as mock:
                mock_loop = unittest.mock.Mock(asyncio.AbstractEventLoop)
                mock_loop.run_until_complete.side_effect = default_loop.run_until_complete

                if sys.version_info >= (3, 6):
                    mock_loop.shutdown_asyncgens = asynctest.CoroutineMock()

                mock.return_value = mock_loop

                case = LoopTest(test)
                try:
                    getattr(case, method)()
                except SystemError:
                    pass

                mock.assert_called_with()
                mock_loop.close.assert_called_with()

                if sys.version_info >= (3, 6):
                    mock_loop.shutdown_asyncgens.assert_awaited()

                # If failing is True, one of the assertions in runTest failed
                self.assertFalse(case.failing)
                # Also, ensure we didn't override the original loop
                self.assertIs(default_loop, asyncio.get_event_loop())
Esempio n. 47
0
def test_callbackConnect_minor_version_invalid(http_client):

    new_version = "{}.{}.{}".format(__version_info__[0], __version_info__[1], __version_info__[2] + 1)
    params = {
        "local": True,
        "version": new_version
    }
    mock = unittest.mock.MagicMock()

    http_client._query_waiting_connections.append((None, mock))
    # Stable release
    if __version_info__[3] == 0:
        http_client._callbackConnect(params)
        assert http_client._connected is False
        mock.assert_called_with({"message": "Client version {} is not the same as server (controller) version {}".format(__version__, new_version)}, error=True, server=None)
    else:
        http_client._callbackConnect(params)
        assert http_client._connected is True
Esempio n. 48
0
def assert_called(context):
    actual = json.loads(context.text or '{}')
    # Kinda hacky but tokens are time based
    mail = context.mocks['jam.plugins.user.sendgrid'].SendGridClient().send.call_args[0][0]

    mock = context.mocks['jam.plugins.user.sendgrid'].Mail
    mock.assert_called_with(to=actual['to'])

    if actual.get('from'):
        mail.set_from(actual.get('from'))

    token = mail.add_substitution.call_args_list[0][0][1]
    mail.add_substitution.assert_any_call(':token', token)

    user = mail.add_substitution.call_args_list[1][0][1]
    mail.add_substitution.assert_any_call(':user', user)

    mail.add_filter.assert_any_call('templates', 'enable', 1)
    mail.add_filter.assert_any_call('templates', 'template_id', actual['template'])
Esempio n. 49
0
    def test_before_test_called_before_user_setup(self):
        mock = unittest.mock.Mock()
        setattr(asynctest._fail_on._fail_on, "before_test_default", mock)
        self.addCleanup(delattr, asynctest._fail_on._fail_on,
                        "before_test_default")

        class TestCase(asynctest.TestCase):
            def setUp(self):
                self.assertTrue(mock.called)

            def runTest(self):
                pass

        for method in self.run_methods:
            with self.subTest(method=method):
                case = Test.FooTestCase()
                getattr(case, method)()

                self.assert_checked("default")
                self.assertTrue(mock.called)
                mock.assert_called_with(case)
Esempio n. 50
0
    def test_setting_state_emits_on_state_change(self):
        mock = unittest.mock.Mock()
        mock.return_value = None
        self.tr.on_state_change.connect(mock)

        self.tr.state = tracking.MessageState.DELIVERED_TO_SERVER
        self.assertEqual(
            self.tr.state,
            tracking.MessageState.DELIVERED_TO_SERVER)
        mock.assert_called_with(
            tracking.MessageState.DELIVERED_TO_SERVER
        )

        self.tr.state = tracking.MessageState.DELIVERED_TO_RECIPIENT
        self.assertEqual(
            self.tr.state,
            tracking.MessageState.DELIVERED_TO_RECIPIENT)
        mock.assert_called_with(
            tracking.MessageState.DELIVERED_TO_RECIPIENT
        )

        self.tr.state = tracking.MessageState.SEEN_BY_RECIPIENT
        self.assertEqual(
            self.tr.state,
            tracking.MessageState.SEEN_BY_RECIPIENT)
        mock.assert_called_with(
            tracking.MessageState.SEEN_BY_RECIPIENT
        )
Esempio n. 51
0
    def test_assert_called_with_function_spec(self):
        def f(a, b, c, d=None):
            pass

        mock = Mock(spec=f)

        mock(1, b=2, c=3)
        mock.assert_called_with(1, 2, 3)
        mock.assert_called_with(a=1, b=2, c=3)
        self.assertRaises(AssertionError, mock.assert_called_with, 1, b=3, c=2)
        # Expected call doesn't match the spec's signature
        with self.assertRaises(AssertionError) as cm:
            mock.assert_called_with(e=8)
        self.assertIsInstance(cm.exception.__cause__, TypeError)
 def test_reference_expansion(self):
     response = {
         'manifests': [
             {
                 'entry': 'a',
                 'annotations': {
                     'org.opencontainers.image.ref.name': '1.0',
                 },
             },
         ],
     }
     for uri, base, expected in [
                 (
                     'index.json',
                     'https://example.com/a',
                     'https://example.com/index.json',
                 ),
                 (
                     'index.json',
                     'https://example.com/a/',
                     'https://example.com/a/index.json',
                 ),
                 (
                     'https://{host}/{path}#{fragment}',
                     'https://a.example.com/b/',
                     'https://example.com/a#1.0'
                 ),
                 (
                     '//{host}/{path}#{fragment}',
                     'https://a.example.com/b/',
                     'https://example.com/a#1.0'
                 ),
                 (
                     '/{path}#{fragment}',
                     'https://b.example.com/c/',
                     'https://b.example.com/a#1.0',
                 ),
                 (
                     '{path}#{fragment}',
                     'https://b.example.com/c/',
                     'https://b.example.com/c/a#1.0',
                 ),
                 (
                     '#{fragment}',
                     'https://example.com/a',
                     'https://example.com/a#1.0',
                 ),
                 (
                     '#{fragment}',
                     'https://example.com/a/',
                     'https://example.com/a/#1.0',
                 ),
             ]:
         with self.subTest(label='{} from {}'.format(uri, base)):
             engine = oci_index_template.Engine(uri=uri, base=base)
             with unittest.mock.patch(
                     target='oci_discovery.ref_engine.oci_index_template._fetch_json.fetch',
                     return_value={
                         'uri': expected,
                         'json': response
                     }) as mock:
                 resolved = list(engine.resolve(name='example.com/a#1.0'))
                 mock.assert_called_with(
                     uri=expected,
                     media_type='application/vnd.oci.image.index.v1+json')
             self.assertEqual(
                 resolved,
                 [
                     {
                         'mediaType': 'application/vnd.oci.descriptor.v1+json',
                         'root': root,
                         'uri': expected,
                     }
                     for root in response['manifests']
                 ])
Esempio n. 53
0
 def _check(mock):
     mock(1, b=2, c=3)
     mock.assert_called_with(1, 2, 3)
     mock.assert_called_with(a=1, b=2, c=3)
     self.assertRaises(AssertionError, mock.assert_called_with,
                       1, b=3, c=2)
Esempio n. 54
0
 def test_simple_setters(self, elem, code, method, args):
     code(elem)
     mock = getattr(elem._elem, method)
     mock.assert_called_with(*args)