Пример #1
0
    def test_has_attr_fail(self):
        class Config(object):
            color = 'red'

        widget = Fake("widget").expects("configure")\
                               .with_args(arg.has_attr(size=12))
        widget.configure(Config())
Пример #2
0
    def test_has_attr_fail_wrong_value(self):
        class Config(object):
            color = 'red'

        widget = Fake("widget").expects("configure")\
                               .with_args(arg.has_attr(color="green"))
        widget.configure(Config())
Пример #3
0
    def test_connect_does_not_prompt_password_when_ssh_raises_channel_exception(self):
        def raise_channel_exception_once(*args, **kwargs):
            if raise_channel_exception_once.should_raise_channel_exception:
                raise_channel_exception_once.should_raise_channel_exception = False
                raise ssh.ChannelException(2, 'Connect failed')
        raise_channel_exception_once.should_raise_channel_exception = True

        def generate_fake_client():
            fake_client = Fake('SSHClient', allows_any_call=True, expect_call=True)
            fake_client.provides('connect').calls(raise_channel_exception_once)
            return fake_client

        fake_ssh = Fake('ssh', allows_any_call=True)
        fake_ssh.provides('SSHClient').calls(generate_fake_client)
        # We need the real exceptions here to preserve the inheritence structure
        fake_ssh.SSHException = ssh.SSHException
        fake_ssh.ChannelException = ssh.ChannelException
        patched_connect = patch_object('fabric.network', 'ssh', fake_ssh)
        patched_password = patch_object('fabric.network', 'prompt_for_password', Fake('prompt_for_password', callable = True).times_called(0))
        try:
            connect('user', 'localhost', 22, HostConnectionCache())
        finally:
            # Restore ssh
            patched_connect.restore()
            patched_password.restore()
    def test_expectations_with_multiple_return_values(self):
        db = Fake("db").expects("get_id").returns(1).expects("set_id").next_call(for_method="get_id").returns(2)
        eq_(db.get_id(), 1)
        eq_(db.set_id(), None)
        eq_(db.get_id(), 2)

        fudge.verify()
Пример #5
0
def test_settings_read_attribute_as_int():
    clear_expectations()

    fake_config = Fake("config")
    fake_config.expects("get").with_args("name", "setting").returns("10")

    ss = SettingsSection(None, "name", fake_config)
    assert ss.as_int("setting") == 10
Пример #6
0
 def test_too_many_calls(self):
     db = Fake("db")\
         .remember_order()\
         .expects("get_id").returns(1)\
         .expects("set_id")
     eq_(db.get_id(), 1)
     eq_(db.set_id(), None)
     # extra :
     eq_(db.get_id(), 1)
Пример #7
0
 def test_returns(self):
     db = Fake("db")\
         .provides("get_id").returns(1)\
         .provides("set_id")\
         .next_call(for_method="get_id").returns(2)
     # print [c.return_val for c in db._declared_calls["get_id"]._calls]
     eq_(db.get_id(), 1)
     eq_(db.set_id(), None)
     eq_(db.get_id(), 2)
Пример #8
0
 def test_contains_list(self):
     db = Fake("db").expects("execute_statements").with_args(
                                         arg.contains("select * from foo"))
     db.execute_statements([
         "update foo",
         "select * from foo",
         "drop table foo"
     ])
     fudge.verify()
Пример #9
0
    def test_chained_fakes_honor_order(self):
        Thing = Fake("thing").remember_order().expects("__init__")
        holder = Thing.expects("get_holder").returns_fake()
        holder = holder.expects("init")

        thing = Thing()
        holder = thing.get_holder()
        # missing thing.init()
        fudge.verify()
Пример #10
0
    def test_has_attr_ok(self):
        class Config(object):
            size = 12
            color = 'red'
            weight = 'heavy'

        widget = Fake("widget").expects("configure")\
                               .with_args(arg.has_attr(size=12,color='red'))
        widget.configure(Config())
Пример #11
0
 def test_repr_shortens_long_values(self):
     fake = Fake("widget").provides("set_bits").with_args(
         "12345678910111213141516171819202122232425262728293031"
     )
     try:
         fake.set_bits()
     except AssertionError, exc:
         eq_(str(exc),
         "fake:widget.set_bits('123456789101112131415161718192021222324252627...') "
         "was called unexpectedly with args ()")
Пример #12
0
 def test_multiple_returns_affect_order(self):
     db = Fake("db")\
         .remember_order()\
         .expects("get_id").returns(1)\
         .expects("set_id")\
         .next_call(for_method="get_id").returns(2)
     eq_(db.get_id(), 1)
     eq_(db.set_id(), None)
     eq_(db.get_id(), 2)
     fudge.verify()
Пример #13
0
def test_task_will_invoke_provided_class():
    def foo(): pass
    fake = Fake()
    fake.expects("__init__").with_args(foo)
    fudge.clear_calls()
    fudge.clear_expectations()

    foo = decorators.task(foo, task_class=fake)

    fudge.verify()
Пример #14
0
def test_settings_read_attribute_with_no_section_returns_none():
    clear_expectations()

    fake_config = Fake("config")
    fake_config.expects("get").with_args("name", "setting_true_1").raises(NoSectionError("name"))
    fake_config.next_call("get").with_args("name", "setting_true_2").raises(NoOptionError("name", "setting_true_2"))

    ss = SettingsSection(None, "name", fake_config)
    assert not ss.as_bool("setting_true_1")
    assert not ss.as_bool("setting_true_2")
Пример #15
0
def test_controller_cache_is_server_cache():
    clear_expectations()
    clear()

    fake_server = Fake('server')
    fake_server.cache = "cache"

    controller = Controller()
    controller.server = fake_server

    assert controller.cache == "cache"
Пример #16
0
def test_task_passes_args_to_the_task_class():
    random_vars = ("some text", random.randint(100, 200))
    def foo(): pass

    fake = Fake()
    fake.expects("__init__").with_args(foo, *random_vars)
    fudge.clear_calls()
    fudge.clear_expectations()

    foo = decorators.task(foo, task_class=fake, *random_vars)
    fudge.verify()
Пример #17
0
 def test_kwarg_diffs_are_not_shortened(self):
     fake = Fake("widget").provides("set_bits").with_args(
         newbits="12345678910111213141516171819202122232425262728293031"
     )
     try:
         # this should not be shortened but the above arg spec should:
         fake.set_bits(newbits="99999999999999999999999999999999999999999999999999999999")
     except AssertionError, exc:
         eq_(str(exc),
         "fake:widget.set_bits(newbits='123456789101112131415161718192021222324252627...') "
         "was called unexpectedly with args "
         "(newbits='99999999999999999999999999999999999999999999999999999999')")
Пример #18
0
def test_healthcheck_action_returns_working_if_no_text_in_config():
    clear_expectations()
    clear()

    settings_health_check.Ion = Fake('Ion')
    settings_health_check.Ion.healthcheck_text = None

    fake_server_health_check = Fake('server')
    fake_server_health_check.expects('test_connection').returns(True)

    controller = Controller()
    controller.server = fake_server_health_check

    assert controller.healthcheck() == "WORKING"
Пример #19
0
def test_wrapped_column_has_sort_url():
    meta = Fake().has_attr(order_by="nu")
    table = Fake().has_attr(_meta=meta)
    column_a = Fake().has_attr(name="nu")
    column_b = Fake().has_attr(name="xi")

    # mock out url building, to avoid awakening django.
    table.provides("get_url").calls(lambda order_by: ["omicron", order_by])

    wrapped_column_a = WrappedColumn(table, column_a)
    wrapped_column_b = WrappedColumn(table, column_b)

    assert wrapped_column_a.sort_url == ["omicron", "-nu"]
    assert wrapped_column_b.sort_url == ["omicron", "xi"]
Пример #20
0
def test_healthcheck_action():
    clear_expectations()
    clear()

    settings_health_check.Ion = Fake('Ion')
    settings_health_check.Ion.healthcheck_text = "CUSTOMTEXT"

    fake_server_health_check = Fake('server')
    fake_server_health_check.expects('test_connection').returns(True)

    controller = Controller()
    controller.server = fake_server_health_check

    assert controller.healthcheck() == "CUSTOMTEXT"
Пример #21
0
def test_render_template_uses_all_server_template_filters():
    clear_expectations()
    clear()

    fake_server = Fake('server')
    fake_server.template_path = "template_path"
    fake_server.template_filters = {"some":lambda x: "y"}

    controller = Controller()
    controller.server = fake_server
    controller.server.apps = []

    result = controller.render_template("template_file")

    assert result == "expected"
Пример #22
0
def test_healthcheck_action_fails_if_database_not_found():
    clear_expectations()
    clear()

    settings_health_check.Ion = Fake('Ion')
    settings_health_check.Ion.healthcheck_text = None

    fake_server_health_check = Fake('server')
    controller = Controller()
    controller.server = fake_server_health_check

    fake_server_health_check.expects('test_connection').returns(False)
    fake_server_health_check.test_connection_error = ValueError('Fake error')

    try:
        controller.healthcheck()
    except RuntimeError, err:
        assert str(err) == "The connection to the database failed with error: Fake error"
        return
Пример #23
0
def test_wrapped_column_is_sorted_via_table():
    meta = Fake().has_attr(order_by="kappa")
    table = Fake().has_attr(_meta=meta)
    column_a = Fake().has_attr(name="kappa")
    column_b = Fake().has_attr(name="mu")

    wrapped_column_a = WrappedColumn(table, column_a)  # sorted
    wrapped_column_b = WrappedColumn(table, column_b)  # unsorted

    assert wrapped_column_a.is_sorted == True
    assert wrapped_column_b.is_sorted == False
    assert wrapped_column_a.sort_direction == "asc"
    assert wrapped_column_b.sort_direction == None

    meta.has_attr(order_by="-mu")
    assert wrapped_column_a.is_sorted == False
    assert wrapped_column_b.is_sorted == True
    assert wrapped_column_a.sort_direction == None
    assert wrapped_column_b.sort_direction == "desc"
Пример #24
0
def test_settings_read_attribute_as_bool():
    clear_expectations()

    fake_config = Fake("config")
    fake_config.expects("get").with_args("name", "setting_true_1").returns("True")
    fake_config.next_call("get").with_args("name", "setting_true_2").returns("true")
    fake_config.next_call("get").with_args("name", "setting_false_1").returns("False")
    fake_config.next_call("get").with_args("name", "setting_false_2").returns("false")

    ss = SettingsSection(None, "name", fake_config)
    assert ss.as_bool("setting_true_1")
    assert ss.as_bool("setting_true_2")
    assert not ss.as_bool("setting_false_1")
    assert not ss.as_bool("setting_false_2")
Пример #25
0
def password_response(password, times_called=None, silent=True):
    """
    Context manager which patches ``getpass.getpass`` to return ``password``.

    ``password`` may be a single string or an iterable of strings:

    * If single string, given password is returned every time ``getpass`` is
      called.
    * If iterable, iterated over for each call to ``getpass``, after which
      ``getpass`` will error.

    If ``times_called`` is given, it is used to add a ``Fake.times_called``
    clause to the mock object, e.g. ``.times_called(1)``. Specifying
    ``times_called`` alongside an iterable ``password`` list is unsupported
    (see Fudge docs on ``Fake.next_call``).

    If ``silent`` is True, no prompt will be printed to ``sys.stderr``.
    """
    fake = Fake('getpass', callable=True)
    # Assume stringtype or iterable, turn into mutable iterable
    if isinstance(password, StringTypes):
        passwords = [password]
    else:
        passwords = list(password)
    # Optional echoing of prompt to mimic real behavior of getpass
    # NOTE: also echo a newline if the prompt isn't a "passthrough" from the
    # server (as it means the server won't be sending its own newline for us).
    echo = lambda x, y: y.write(x + ("\n" if x != " " else ""))
    # Always return first (only?) password right away
    fake = fake.returns(passwords.pop(0))
    if not silent:
        fake = fake.calls(echo)
    # If we had >1, return those afterwards
    for pw in passwords:
        fake = fake.next_call().returns(pw)
        if not silent:
            fake = fake.calls(echo)
    # Passthrough times_called
    if times_called:
        fake = fake.times_called(times_called)
    return patched_context(getpass, 'getpass', fake)
Пример #26
0
 def table(self):
     return Fake('Table').has_attr(prefixed_page_field='page',
                                   prefixed_per_page_field='per_page',
                                   prefixed_order_by_field='sort')
Пример #27
0
class TestErrorHandling(FabricTest):
    @with_patched_object(utils, 'warn',
                         Fake('warn', callable=True, expect_call=True))
    def test_error_warns_if_warn_only_True_and_func_None(self):
        """
        warn_only=True, error(func=None) => calls warn()
        """
        with settings(warn_only=True):
            error('foo')

    @with_patched_object(utils, 'abort',
                         Fake('abort', callable=True, expect_call=True))
    def test_error_aborts_if_warn_only_False_and_func_None(self):
        """
        warn_only=False, error(func=None) => calls abort()
        """
        with settings(warn_only=False):
            error('foo')

    def test_error_calls_given_func_if_func_not_None(self):
        """
        error(func=callable) => calls callable()
        """
        error('foo', func=Fake(callable=True, expect_call=True))

    @mock_streams('stdout')
    @with_patched_object(
        utils, 'abort',
        Fake('abort', callable=True,
             expect_call=True).calls(lambda x: sys.stdout.write(x + "\n")))
    def test_error_includes_stdout_if_given_and_hidden(self):
        """
        error() correctly prints stdout if it was previously hidden
        """
        # Mostly to catch regression bug(s)
        stdout = "this is my stdout"
        with hide('stdout'):
            error("error message", func=utils.abort, stdout=stdout)
        assert_contains(stdout, sys.stdout.getvalue())

    @mock_streams('stderr')
    @with_patched_object(
        utils, 'abort',
        Fake('abort', callable=True,
             expect_call=True).calls(lambda x: sys.stderr.write(x + "\n")))
    def test_error_includes_stderr_if_given_and_hidden(self):
        """
        error() correctly prints stderr if it was previously hidden
        """
        # Mostly to catch regression bug(s)
        stderr = "this is my stderr"
        with hide('stderr'):
            error("error message", func=utils.abort, stderr=stderr)
        assert_contains(stderr, sys.stderr.getvalue())

    @mock_streams('stderr')
    def test_warnings_print_magenta_if_colorize_on(self):
        with settings(colorize_errors=True):
            error("oh god", func=utils.warn, stderr="oops")
        # can't use assert_contains as ANSI codes contain regex specialchars
        eq_(magenta("\nWarning: oh god\n\n"), sys.stderr.getvalue())

    @mock_streams('stderr')
    @raises(SystemExit)
    def test_errors_print_red_if_colorize_on(self):
        with settings(colorize_errors=True):
            error("oh god", func=utils.abort, stderr="oops")
        # can't use assert_contains as ANSI codes contain regex specialchars
        eq_(red("\Error: oh god\n\n"), sys.stderr.getvalue())
Пример #28
0
 def test_passes_fail(self):
     counter = Fake("counter").expects("set_name").with_args(arg.isinstance(str))
     counter.set_name(25)
Пример #29
0
 def test_passes_fail(self):
     def is_str(v):
         return isinstance(v,str)
     counter = Fake("counter").expects("set_name").with_args(arg.passes_test(is_str))
     counter.set_name(25)
Пример #30
0
 def test_endswith_ok(self):
     db = Fake("db").expects("execute").with_args(
         arg.endswith("values (1,2,3,4)"))
     db.execute("insert into foo values (1,2,3,4)")
 def test_calls_task_function_objects(self):
     """
     should execute the passed-in function object
     """
     execute(Fake(callable=True, expect_call=True))
Пример #32
0
 def test_expects_call_shortcut_ok(self):
     remove = Fake("os.remove").expects_call()
     remove()
     fudge.verify()
     assert isinstance(remove, Fake)
 class MyTask(Task):
     run = Fake(callable=True, expect_call=True)
Пример #34
0
class TestSSHConfig(FabricTest):
    def env_setup(self):
        super(TestSSHConfig, self).env_setup()
        env.use_ssh_config = True
        env.ssh_config_path = support("ssh_config")
        # Undo the changes FabricTest makes to env for server support
        env.user = env.local_user
        env.port = env.default_port

    def test_global_user_with_default_env(self):
        """
        Global User should override default env.user
        """
        eq_(normalize("localhost")[0], "satan")

    def test_global_user_with_nondefault_env(self):
        """
        Global User should NOT override nondefault env.user
        """
        with settings(user="******"):
            eq_(normalize("localhost")[0], "foo")

    def test_specific_user_with_default_env(self):
        """
        Host-specific User should override default env.user
        """
        eq_(normalize("myhost")[0], "neighbor")

    def test_user_vs_host_string_value(self):
        """
        SSH-config derived user should NOT override host-string user value
        """
        eq_(normalize("myuser@localhost")[0], "myuser")
        eq_(normalize("myuser@myhost")[0], "myuser")

    def test_global_port_with_default_env(self):
        """
        Global Port should override default env.port
        """
        eq_(normalize("localhost")[2], "666")

    def test_global_port_with_nondefault_env(self):
        """
        Global Port should NOT override nondefault env.port
        """
        with settings(port="777", use_ssh_config=False):
            eq_(normalize("localhost")[2], "777")

    def test_specific_port_with_default_env(self):
        """
        Host-specific Port should override default env.port
        """
        eq_(normalize("myhost")[2], "664")

    def test_port_vs_host_string_value(self):
        """
        SSH-config derived port should NOT override host-string port value
        """
        eq_(normalize("localhost:123")[2], "123")
        eq_(normalize("myhost:123")[2], "123")

    def test_hostname_alias(self):
        """
        Hostname setting overrides host string's host value
        """
        eq_(normalize("localhost")[1], "localhost")
        eq_(normalize("myalias")[1], "otherhost")

    @with_patched_object(utils, 'warn',
                         Fake('warn', callable=True, expect_call=True))
    def test_warns_with_bad_config_file_path(self):
        # use_ssh_config is already set in our env_setup()
        with settings(hide('everything'), ssh_config_path="nope_bad_lol"):
            normalize('foo')

    @server()
    def test_real_connection(self):
        """
        Test-server connection using ssh_config values
        """
        with settings(
                hide('everything'),
                ssh_config_path=support("testserver_ssh_config"),
                host_string='testserver',
        ):
            ok_(run("ls /simple").succeeded)
Пример #35
0
 def generate_fake_client():
     fake_client = Fake('SSHClient',
                        allows_any_call=True,
                        expect_call=True)
     fake_client.provides('connect').calls(raise_channel_exception_once)
     return fake_client
Пример #36
0
 def table(self):
     return Fake("Table").has_attr(
         prefixed_page_field="page",
         prefixed_per_page_field="per_page",
         prefixed_order_by_field="sort",
     )
def test_datecolumn_formats_dates():
    date = datetime.date(2010, 1, 1)
    cell = Fake().has_attr(value=date)
    column = DateColumn(format="D d M Y")
    assert column.render(cell) == "Fri 01 Jan 2010"
Пример #38
0
 def test_startswith_ok_uni(self):
     db = Fake("db").expects("execute").with_args(
         arg.startswith(u"Ivan_Krsti\u0107"))
     db.execute(u"Ivan_Krsti\u0107(); foo();")
Пример #39
0
 def test_contains_fail(self):
     db = Fake("db").expects("execute").with_args(arg.contains("table foo"))
     db.execute("select into table notyourmama;")
     fudge.verify()
def test_datecolumn_defaults_to_DATE_FORMAT():
    date = datetime.date(2010, 1, 1)
    cell = Fake().has_attr(value=date)
    column = DateColumn()
    assert column.render(cell) == "2010-01-01"
Пример #41
0
 def test_endswith_ok_uni(self):
     db = Fake("db").expects("execute").with_args(
         arg.endswith(u"Ivan Krsti\u0107"))
     db.execute(u"select Ivan Krsti\u0107")
Пример #42
0
def faketable():
    yield (Fake("Table").has_attr(prefixed_page_field="page",
                                  prefixed_per_page_field="per_page",
                                  prefixed_order_by_field="sort"))
Пример #43
0
def table():
    yield (Fake('Table').has_attr(prefixed_page_field='page',
                                  prefixed_per_page_field='per_page',
                                  prefixed_order_by_field='sort'))
Пример #44
0
class TestErrorHandling(FabricTest):
    dummy_string = 'test1234!'

    @with_patched_object(utils, 'warn',
                         Fake('warn', callable=True, expect_call=True))
    def test_error_warns_if_warn_only_True_and_func_None(self):
        """
        warn_only=True, error(func=None) => calls warn()
        """
        with settings(warn_only=True):
            error('foo')

    @with_patched_object(utils, 'abort',
                         Fake('abort', callable=True, expect_call=True))
    def test_error_aborts_if_warn_only_False_and_func_None(self):
        """
        warn_only=False, error(func=None) => calls abort()
        """
        with settings(warn_only=False):
            error('foo')

    def test_error_calls_given_func_if_func_not_None(self):
        """
        error(func=callable) => calls callable()
        """
        error('foo', func=Fake(callable=True, expect_call=True))

    @mock_streams('stdout')
    @with_patched_object(
        utils, 'abort',
        Fake('abort', callable=True,
             expect_call=True).calls(lambda x: sys.stdout.write(x + "\n")))
    def test_error_includes_stdout_if_given_and_hidden(self):
        """
        error() correctly prints stdout if it was previously hidden
        """
        # Mostly to catch regression bug(s)
        stdout = "this is my stdout"
        with hide('stdout'):
            error("error message", func=utils.abort, stdout=stdout)
        assert_contains(stdout, sys.stdout.getvalue())

    @mock_streams('stdout')
    @with_patched_object(
        utils, 'abort',
        Fake('abort', callable=True,
             expect_call=True).calls(lambda x: sys.stdout.write(x + "\n")))
    @with_patched_object(output, 'exceptions', True)
    @with_patched_object(utils, 'format_exc',
                         Fake('format_exc', callable=True,
                              expect_call=True).returns(dummy_string))
    def test_includes_traceback_if_exceptions_logging_is_on(self):
        """
        error() includes traceback in message if exceptions logging is on
        """
        error("error message", func=utils.abort, stdout=error)
        assert_contains(self.dummy_string, sys.stdout.getvalue())

    @mock_streams('stdout')
    @with_patched_object(
        utils, 'abort',
        Fake('abort', callable=True,
             expect_call=True).calls(lambda x: sys.stdout.write(x + "\n")))
    @with_patched_object(output, 'debug', True)
    @with_patched_object(utils, 'format_exc',
                         Fake('format_exc', callable=True,
                              expect_call=True).returns(dummy_string))
    def test_includes_traceback_if_debug_logging_is_on(self):
        """
        error() includes traceback in message if debug logging is on (backwardis compatibility)
        """
        error("error message", func=utils.abort, stdout=error)
        assert_contains(self.dummy_string, sys.stdout.getvalue())

    @mock_streams('stdout')
    @with_patched_object(
        utils, 'abort',
        Fake('abort', callable=True,
             expect_call=True).calls(lambda x: sys.stdout.write(x + "\n")))
    @with_patched_object(output, 'exceptions', True)
    @with_patched_object(utils, 'format_exc',
                         Fake('format_exc', callable=True,
                              expect_call=True).returns(None))
    def test_doesnt_print_None_when_no_traceback_present(self):
        """
        error() doesn't include None in message if there is no traceback
        """
        error("error message", func=utils.abort, stdout=error)
        assert_not_contains('None', sys.stdout.getvalue())

    @mock_streams('stderr')
    @with_patched_object(
        utils, 'abort',
        Fake('abort', callable=True,
             expect_call=True).calls(lambda x: sys.stderr.write(x + "\n")))
    def test_error_includes_stderr_if_given_and_hidden(self):
        """
        error() correctly prints stderr if it was previously hidden
        """
        # Mostly to catch regression bug(s)
        stderr = "this is my stderr"
        with hide('stderr'):
            error("error message", func=utils.abort, stderr=stderr)
        assert_contains(stderr, sys.stderr.getvalue())

    @mock_streams('stderr')
    def test_warnings_print_magenta_if_colorize_on(self):
        with settings(colorize_errors=True):
            error("oh god", func=utils.warn, stderr="oops")
        # can't use assert_contains as ANSI codes contain regex specialchars
        eq_(magenta("\nWarning: oh god\n\n"), sys.stderr.getvalue())

    @mock_streams('stderr')
    @raises(SystemExit)
    def test_errors_print_red_if_colorize_on(self):
        with settings(colorize_errors=True):
            error("oh god", func=utils.abort, stderr="oops")
        # can't use assert_contains as ANSI codes contain regex specialchars
        eq_(red("\Error: oh god\n\n"), sys.stderr.getvalue())
Пример #45
0
 def test_passes(self):
     counter = Fake("counter").expects("increment").with_args(arg.isinstance(int))
     counter.increment(25)
Пример #46
0
 def test_error_calls_given_func_if_func_not_None(self):
     """
     error(func=callable) => calls callable()
     """
     error('foo', func=Fake(callable=True, expect_call=True))
Пример #47
0
 def test_passes_fail(self):
     counter = Fake("counter").expects("set_name").with_args(
         arg.isinstance(str))
     counter.set_name(25)
Пример #48
0
 def test_contains_str(self):
     db = Fake("db").expects("execute").with_args(arg.contains("table foo"))
     db.execute("select into table foo;")
     db.execute("select * from table foo where bar = 1")
     fudge.verify()
Пример #49
0
 def test_passes(self):
     counter = Fake("counter").expects("increment").with_args(
         arg.isinstance(int))
     counter.increment(25)
 class MyTask(Task):
     name = "mytask"
     run = Fake(callable=True, expect_call=True)
Пример #51
0
 def generate_fake_client():
     fake_client = Fake('SSHClient', allows_any_call=True, expect_call=True)
     fake_client.provides('connect').calls(raise_channel_exception_once)
     return fake_client
Пример #52
0
 def save(self):
     self.__class__.index.register(self)
     self.__node__ = Fake('__node__').has_attr(id=self._id)
     return self
Пример #53
0
 def test_startswith_fail(self):
     db = Fake("db").expects("execute").with_args(
         arg.startswith("insert into"))
     db.execute("select from")
Пример #54
0
 def test_multiple_expects_on_chained_fakes_ok(self):
     db = Fake("db").expects("insert").returns_fake().expects("insert")
Пример #55
0
 def test_provides_call_shortcut(self):
     remove = Fake("os.remove").is_callable()
     remove()
     assert isinstance(remove, Fake)
Пример #56
0
 def test_contains_list(self):
     db = Fake("db").expects("execute_statements").with_args(
         arg.contains("select * from foo"))
     db.execute_statements(
         ["update foo", "select * from foo", "drop table foo"])
     fudge.verify()
Пример #57
0
 def test_too_many_args(self):
     db = Fake("db").expects("execute").with_args(bind={'one':1})
     db.execute("select foozilate()", bind={'one':1}) # unexpected statement arg
Пример #58
0
 def test_too_many_args(self):
     db = Fake("db").expects("execute").with_args(bind={'one': 1})
     db.execute("select foozilate()", bind={'one':
                                            1})  # unexpected statement arg
Пример #59
0
 def test_multiple_provides_on_chained_fakes_ok(self):
     db = Fake("db").provides("insert").returns_fake().provides("insert")
Пример #60
0
 def test_any_value(self):
     db = Fake("db").expects("execute").with_args(arg.any())
     db.execute("delete from foo where 1")