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)

    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())

    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)

 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')

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)

 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')

 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)

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)

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)

    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_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)

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)

    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)

    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")

    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())

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

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

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'])

    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)

    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)