Merge lp:~free.ekanayaka/landscape-client/amp-test-readability into lp:~landscape/landscape-client/trunk

[Free Ekanayaka]

This is the last branch I have around cleaning up the AMP-based machinery in the client. It essentially just change the tests:

- Drop the Words class, which had a bunch of ad-hoc methods used to exercise the behavior of the MethodCall protocol. Essentially each method was associated with a test, but the context was not clear by reading the test itself (you'd have to go and read the implementation in the Words class).

- Modify most methods to define the remotely-exposed method being tested, so the context is clear.

- Partially re-wrote RemoteObjectTest, which had a bunch of tests which were only duplicating tests from MethodCallTest. Now this test class has only tests that are really specific to RemoteObject.

This is the last branch I have around cleaning up the AMP-based machinery in the client. It essentially just change the tests:

- Drop the Words class, which had a bunch of ad-hoc methods used to exercise the behavior of the MethodCall protocol. Essentially each method was associated with a test, but the context was not clear by reading the test itself (you'd have to go and read the implementation in the Words class).

- Modify most methods to define the remotely-exposed method being tested, so the context is clear.

- Partially re-wrote RemoteObjectTest, which had a bunch of tests which were only duplicating tests from MethodCallTest. Now this test class has only tests that are really specific to RemoteObject.

[Christopher Armstrong (radix)]

I like code removal :-) Words was really weird. +1

review: Approve

[Chris Glass (tribaal)]

Nice! +1

[1]
landscape/lib/tests/test_amp.py:6: 'TestCase' imported but unused

review: Approve

=== modified file 'landscape/lib/amp.py'
--- landscape/lib/amp.py	2013-05-07 15:55:25 +0000
+++ landscape/lib/amp.py	2013-05-13 12:57:34 +0000
@@ -216,8 +216,8 @@
     _chunk_size = MAX_VALUE_LENGTH
 
     def __init__(self, protocol, clock):
-        self.protocol = protocol
-        self.clock = clock
+        self._protocol = protocol
+        self._clock = clock
 
     def _call_remote_with_timeout(self, command, **kwargs):
         """Send an L{AMP} command that will errback in case of a timeout.
@@ -240,9 +240,9 @@
             # The peer didn't respond on time, raise an error.
             deferred.errback(MethodCallError("timeout"))
 
-        call = self.clock.callLater(self.timeout, handle_timeout)
+        call = self._clock.callLater(self.timeout, handle_timeout)
 
-        result = self.protocol.callRemote(command, **kwargs)
+        result = self._protocol.callRemote(command, **kwargs)
         result.addBoth(handle_response)
         return deferred
 
@@ -273,7 +273,7 @@
             for chunk in chunks[:-1]:
 
                 def create_send_chunk(sequence, chunk):
-                    send_chunk = lambda x: self.protocol.callRemote(
+                    send_chunk = lambda x: self._protocol.callRemote(
                         MethodCallChunk, sequence=sequence, chunk=chunk)
                     return send_chunk
 

=== modified file 'landscape/lib/tests/test_amp.py'
--- landscape/lib/tests/test_amp.py	2013-05-06 18:17:43 +0000
+++ landscape/lib/tests/test_amp.py	2013-05-13 12:57:34 +0000
@@ -88,102 +88,18 @@
         self.connection.lose(self, Failure(ConnectionDone()))
 
 
-class WordsException(Exception):
-    """Test exception."""
-
-
-class Words(object):
-    """
-    Test class to be used as target object of a L{MethodCallServerFactory}.
-    """
-
-    def __init__(self, clock=None):
-        self._clock = clock
-
-    def secret(self):
-        raise RuntimeError("I'm not supposed to be called!")
-
-    def empty(self):
-        pass
-
-    def motd(self):
-        return "Words are cool"
-
-    def capitalize(self, word):
-        return word.capitalize()
-
-    def is_short(self, word):
-        return len(word) < 4
-
-    def concatenate(self, word1, word2):
-        return word1 + word2
-
-    def lower_case(self, word, index=None):
-        if index is None:
-            return word.lower()
-        else:
-            return word[:index] + word[index:].lower()
-
-    def multiply_alphabetically(self, word_times):
-        result = ""
-        for word, times in sorted(word_times.iteritems()):
-            result += word * times
-        return result
-
-    def meaning_of_life(self):
-
-        class Complex(object):
-            pass
-        return Complex()
-
-    def _check(self, word, seed, value=3):
-        if seed == "cool" and value == 4:
-            return "Guessed!"
-
-    def guess(self, word, *args, **kwargs):
-        return self._check(word, *args, **kwargs)
-
-    def translate(self, word):
-        raise WordsException("Unknown word")
-
-    def google(self, word):
-        deferred = Deferred()
-        if word == "Landscape":
-            self._clock.callLater(0.01, lambda: deferred.callback("Cool!"))
-        elif word == "Easy query":
-            deferred.callback("Done!")
-        elif word == "Weird stuff":
-            error = Exception("bad")
-            self._clock.callLater(0.01, lambda: deferred.errback(error))
-        elif word == "Censored":
-            deferred.errback(Exception("very bad"))
-        elif word == "Long query":
-            # Do nothing, the deferred won't be fired at all
-            pass
-        elif word == "Slowish query":
-            # Fire the result after a while.
-            self._clock.callLater(120.0, lambda: deferred.callback("Done!"))
-        return deferred
-
-
-METHODS = ["empty",
-           "motd",
-           "capitalize",
-           "is_short",
-           "concatenate",
-           "lower_case",
-           "multiply_alphabetically",
-           "translate",
-           "meaning_of_life",
-           "guess",
-           "google"]
+class DummyObject(object):
+
+    method = None
 
 
 class MethodCallTest(LandscapeTest):
 
     def setUp(self):
         super(MethodCallTest, self).setUp()
-        server = MethodCallServerProtocol(Words(), METHODS)
+        self.methods = ["method"]
+        self.object = DummyObject()
+        server = MethodCallServerProtocol(self.object, self.methods)
         client = MethodCallClientProtocol()
         self.connection = FakeConnection(client, server)
         self.connection.make()
@@ -195,7 +111,8 @@
         If a method is not included in L{MethodCallServerFactory.methods} it
         can't be called.
         """
-        deferred = self.sender.send_method_call(method="secret",
+        self.methods.remove("method")
+        deferred = self.sender.send_method_call(method="method",
                                                 args=[],
                                                 kwargs={})
         self.connection.flush()
@@ -206,7 +123,8 @@
         A connected client can issue a L{MethodCall} without arguments and
         with an empty response.
         """
-        deferred = self.sender.send_method_call(method="empty",
+        self.object.method = lambda: None
+        deferred = self.sender.send_method_call(method="method",
                                                 args=[],
                                                 kwargs={})
         self.connection.flush()
@@ -217,18 +135,20 @@
         A connected client can issue a L{MethodCall} targeted to an
         object method with a return value.
         """
-        deferred = self.sender.send_method_call(method="motd",
+        self.object.method = lambda: "Cool result"
+        deferred = self.sender.send_method_call(method="method",
                                                 args=[],
                                                 kwargs={})
         self.connection.flush()
-        self.assertEqual("Words are cool", self.successResultOf(deferred))
+        self.assertEqual("Cool result", self.successResultOf(deferred))
 
     def test_with_one_argument(self):
         """
         A connected AMP client can issue a L{MethodCall} with one argument and
         a response value.
         """
-        deferred = self.sender.send_method_call(method="capitalize",
+        self.object.method = lambda word: word.capitalize()
+        deferred = self.sender.send_method_call(method="method",
                                                 args=["john"],
                                                 kwargs={})
         self.connection.flush()
@@ -238,7 +158,8 @@
         """
         The return value of a L{MethodCall} argument can be a boolean.
         """
-        deferred = self.sender.send_method_call(method="is_short",
+        self.object.method = lambda word: len(word) < 3
+        deferred = self.sender.send_method_call(method="method",
                                                 args=["hi"],
                                                 kwargs={})
         self.connection.flush()
@@ -248,7 +169,8 @@
         """
         A connected client can issue a L{MethodCall} with many arguments.
         """
-        deferred = self.sender.send_method_call(method="concatenate",
+        self.object.method = lambda word1, word2: word1 + word2
+        deferred = self.sender.send_method_call(method="method",
                                                 args=["We ", "rock"],
                                                 kwargs={})
         self.connection.flush()
@@ -259,7 +181,8 @@
         A connected client can issue a L{MethodCall} for methods having
         default arguments.
         """
-        deferred = self.sender.send_method_call(method="lower_case",
+        self.object.method = lambda word, index=0: word[index:].lower()
+        deferred = self.sender.send_method_call(method="method",
                                                 args=["OHH"],
                                                 kwargs={})
         self.connection.flush()
@@ -271,29 +194,34 @@
         having default values in the target object.  If a value is specified by
         the caller it will be used in place of the default value
         """
-        deferred = self.sender.send_method_call(method="lower_case",
-                                                args=["OHH"],
+        self.object.method = lambda word, index=0: word[index:].lower()
+        deferred = self.sender.send_method_call(method="method",
+                                                args=["ABC"],
                                                 kwargs={"index": 2})
         self.connection.flush()
-        self.assertEqual("OHh", self.successResultOf(deferred))
+        self.assertEqual("c", self.successResultOf(deferred))
 
     def test_with_dictionary_arguments(self):
         """
         Method arguments passed to a L{MethodCall} can be dictionaries.
         """
-        deferred = self.sender.send_method_call(method="multiply_"
-                                                       "alphabetically",
-                                                args=[{"foo": 2, "bar": 3}],
+        self.object.method = lambda d: "".join(d.keys()) * sum(d.values())
+        deferred = self.sender.send_method_call(method="method",
+                                                args=[{"foo": 1, "bar": 2}],
                                                 kwargs={})
         self.connection.flush()
-        self.assertEqual("barbarbarfoofoo", self.successResultOf(deferred))
+        self.assertEqual("foobarfoobarfoobar", self.successResultOf(deferred))
 
     def test_with_non_serializable_return_value(self):
         """
         If the target object method returns an object that can't be serialized,
-        the L{MethodCall} result is C{None}.
+        the L{MethodCall} raises an error.
         """
-        deferred = self.sender.send_method_call(method="meaning_of_life",
+        class Complex(object):
+            pass
+
+        self.object.method = lambda: Complex()
+        deferred = self.sender.send_method_call(method="method",
                                                 args=[],
                                                 kwargs={})
         self.connection.flush()
@@ -304,206 +232,106 @@
         The L{MethodCall} protocol supports sending method calls with arguments
         bigger than the maximum AMP parameter value size.
         """
-        deferred = self.sender.send_method_call(method="is_short",
+        self.object.method = lambda word: len(word) == 65535
+        deferred = self.sender.send_method_call(method="method",
                                                 args=["!" * 65535],
                                                 kwargs={})
         self.connection.flush()
-        self.assertFalse(self.successResultOf(deferred))
+        self.assertTrue(self.successResultOf(deferred))
 
     def test_with_long_argument_multiple_calls(self):
         """
         The L{MethodCall} protocol supports concurrently sending multiple
         method calls with arguments bigger than the maximum AMP value size.
         """
-        deferred1 = self.sender.send_method_call(method="is_short",
+        self.object.method = lambda word: len(word)
+        deferred1 = self.sender.send_method_call(method="method",
                                                  args=["!" * 80000],
                                                  kwargs={})
-        deferred2 = self.sender.send_method_call(method="is_short",
+        deferred2 = self.sender.send_method_call(method="method",
                                                  args=["*" * 90000],
                                                  kwargs={})
 
         self.connection.flush()
-        self.assertFalse(self.successResultOf(deferred1))
-        self.assertFalse(self.successResultOf(deferred2))
+        self.assertEqual(80000, self.successResultOf(deferred1))
+        self.assertEqual(90000, self.successResultOf(deferred2))
 
-    def test_translate(self):
+    def test_with_exception(self):
         """
         If the target object method raises an exception, the remote call fails
         with a L{MethodCallError}.
         """
-        deferred = self.sender.send_method_call(method="translate",
-                                                args=["hi"],
+        self.object.method = lambda a, b: a / b
+        deferred = self.sender.send_method_call(method="method",
+                                                args=[1, 0],
                                                 kwargs={})
         self.connection.flush()
         self.failureResultOf(deferred).trap(MethodCallError)
 
-
-class RemoteObjectTest(LandscapeTest):
-
-    def setUp(self):
-        super(RemoteObjectTest, self).setUp()
-        self.clock = Clock()
-        self.factory = MethodCallClientFactory(self.clock)
-        server_factory = MethodCallServerFactory(Words(self.clock), METHODS)
-        self.connector = FakeConnector(self.factory, server_factory)
-        self.connector.connect()
-        self.remote = self.successResultOf(self.factory.getRemoteObject())
-
-    def test_method_call_sender_with_forbidden_method(self):
-        """
-        A L{RemoteObject} can send L{MethodCall}s without arguments and withj
-        an empty response.
-        """
-        deferred = self.remote.secret()
-        self.failureResultOf(deferred).trap(MethodCallError)
-
-    def test_with_no_arguments(self):
-        """
-        A L{RemoteObject} can send L{MethodCall}s without arguments and withj
-        an empty response.
-        """
-        deferred = self.remote.empty()
-        self.assertIs(None, self.successResultOf(deferred))
-
-    def test_with_return_value(self):
-        """
-        A L{RemoteObject} can send L{MethodCall}s without arguments and get
-        back the value of the commands's response.
-        """
-        deferred = self.remote.motd()
-        self.assertEqual("Words are cool", self.successResultOf(deferred))
-
-    def test_with_one_argument(self):
-        """
-        A L{RemoteObject} can send L{MethodCall}s with one argument and get
-        the response value.
-        """
-        deferred = self.remote.capitalize("john")
-        self.assertEqual("John", self.successResultOf(deferred))
-
-    def test_with_one_keyword_argument(self):
-        """
-        A L{RemoteObject} can send L{MethodCall}s with a named argument.
-        """
-        deferred = self.remote.capitalize(word="john")
-        self.assertEqual("John", self.successResultOf(deferred))
-
-    def test_with_boolean_return_value(self):
-        """
-        The return value of a L{MethodCall} argument can be a boolean.
-        """
-        return self.assertSuccess(self.remote.is_short("hi"), True)
-
-    def test_with_many_arguments(self):
-        """
-        A L{RemoteObject} can send L{MethodCall}s with more than one argument.
-        """
-        deferred = self.remote.concatenate("You ", "rock")
-        self.assertEqual("You rock", self.successResultOf(deferred))
-
-    def test_with_many_keyword_arguments(self):
-        """
-        A L{RemoteObject} can send L{MethodCall}s with several
-        named arguments.
-        """
-        deferred = self.remote.concatenate(word2="rock", word1="You ")
-        self.assertEqual("You rock", self.successResultOf(deferred))
-
-    def test_with_default_arguments(self):
-        """
-        A L{RemoteObject} can send a L{MethodCall} having an argument with
-        a default value.
-        """
-        deferred = self.remote.lower_case("OHH")
-        self.assertEqual("ohh", self.successResultOf(deferred))
-
-    def test_with_overriden_default_arguments(self):
-        """
-        A L{RemoteObject} can send L{MethodCall}s overriding the default
-        value of an argument.
-        """
-        deferred = self.remote.lower_case("OHH", 2)
-        self.assertEqual("OHh", self.successResultOf(deferred))
-
-    def test_with_dictionary_arguments(self):
-        """
-        A L{RemoteObject} can send a L{MethodCall}s for methods requiring
-        a dictionary arguments.
-        """
-        deferred = self.remote.multiply_alphabetically({"foo": 2, "bar": 3})
-        self.assertEqual("barbarbarfoofoo", self.successResultOf(deferred))
-
-    def test_with_generic_args_and_kwargs(self):
-        """
-        A L{RemoteObject} behaves well with L{MethodCall}s for methods
-        having generic C{*args} and C{**kwargs} arguments.
-        """
-        deferred = self.remote.guess("word", "cool", value=4)
-        self.assertEqual("Guessed!", self.successResultOf(deferred))
-
     def test_with_successful_deferred(self):
         """
         If the target object method returns a L{Deferred}, it is handled
         transparently.
         """
+        self.object.deferred = Deferred()
+        self.object.method = lambda: self.object.deferred
         result = []
-        deferred = self.remote.google("Landscape")
+        deferred = self.sender.send_method_call(method="method",
+                                                args=[],
+                                                kwargs={})
         deferred.addCallback(result.append)
 
+        self.connection.flush()
+
         # At this point the receiver is waiting for method to complete, so
         # the deferred has not fired yet
         self.assertEqual([], result)
 
-        # Simulate time advancing and the receiver responding
-        self.clock.advance(0.5)
-        self.connector.connection.flush()
+        # Fire the deferred and let the receiver respond
+        self.object.deferred.callback("Hey!")
+        self.connection.flush()
 
-        self.assertEqual(["Cool!"], result)
+        self.assertEqual(["Hey!"], result)
 
     def test_with_failing_deferred(self):
         """
         If the target object method returns a failing L{Deferred}, a
         L{MethodCallError} is raised.
         """
+        self.object.deferred = Deferred()
+        self.object.method = lambda: self.object.deferred
         result = []
-        deferred = self.remote.google("Weird stuff")
+        deferred = self.sender.send_method_call(method="method",
+                                                args=[],
+                                                kwargs={})
         deferred.addErrback(result.append)
 
+        self.connection.flush()
+
         # At this point the receiver is waiting for method to complete, so
         # the deferred has not fired yet
         self.assertEqual([], result)
 
         # Simulate time advancing and the receiver responding
-        self.clock.advance(0.5)
-        self.connector.connection.flush()
+        self.object.deferred.errback(Exception())
+        self.connection.flush()
 
         [failure] = result
         failure.trap(MethodCallError)
 
-    def test_with_already_callback_deferred(self):
-        """
-        The target object method can return an already fired L{Deferred}.
-        """
-        deferred = self.remote.google("Easy query")
-        self.assertEqual("Done!", self.successResultOf(deferred))
-
-    def test_with_already_errback_deferred(self):
-        """
-        If the target object method can return an already failed L{Deferred}.
-        """
-        deferred = self.remote.google("Censored")
-        self.failureResultOf(deferred).trap(MethodCallError)
-
     def test_with_deferred_timeout(self):
         """
         If the peer protocol doesn't send a response for a deferred within
         the given timeout, the method call fails.
         """
+        self.object.method = lambda: Deferred()
         result = []
-        deferred = self.remote.google("Long query")
+        deferred = self.sender.send_method_call(method="method",
+                                                args=[],
+                                                kwargs={})
         deferred.addErrback(result.append)
 
-        self.clock.advance(60.0)
+        self.clock.advance(60)
 
         [failure] = result
         failure.trap(MethodCallError)
@@ -513,15 +341,71 @@
         If the peer protocol sends a late response for a request that has
         already timeout, that response is ignored.
         """
+        self.object.deferred = Deferred()
+        self.object.method = lambda: self.object.deferred
         result = []
-        deferred = self.remote.google("Slowish query")
+        deferred = self.sender.send_method_call(method="method",
+                                                args=[],
+                                                kwargs={})
         deferred.addErrback(result.append)
 
-        self.clock.advance(120.0)
+        self.clock.advance(60)
+        self.object.deferred.callback("late")
 
         [failure] = result
         failure.trap(MethodCallError)
 
+
+class RemoteObjectTest(LandscapeTest):
+
+    def setUp(self):
+        super(RemoteObjectTest, self).setUp()
+        self.methods = ["method"]
+        self.object = DummyObject()
+        self.clock = Clock()
+        self.factory = MethodCallClientFactory(self.clock)
+        server_factory = MethodCallServerFactory(self.object, self.methods)
+        self.connector = FakeConnector(self.factory, server_factory)
+        self.connector.connect()
+        self.remote = self.successResultOf(self.factory.getRemoteObject())
+
+    def test_with_forbidden_method(self):
+        """
+        A L{RemoteObject} can send L{MethodCall}s without arguments and withj
+        an empty response.
+        """
+        self.methods.remove("method")
+        deferred = self.remote.method()
+        failure = self.failureResultOf(deferred)
+        self.assertEqual("Forbidden method 'method'", str(failure.value))
+
+    def test_with_no_arguments(self):
+        """
+        A L{RemoteObject} can send L{MethodCall}s without arguments and with
+        an empty response.
+        """
+        self.object.method = lambda: None
+        deferred = self.remote.method()
+        self.assertIs(None, self.successResultOf(deferred))
+
+    def test_with_return_value(self):
+        """
+        A L{RemoteObject} can send L{MethodCall}s without arguments and get
+        back the value of the commands's response.
+        """
+        self.object.method = lambda: "Cool"
+        deferred = self.remote.method()
+        self.assertEqual("Cool", self.successResultOf(deferred))
+
+    def test_with_arguments(self):
+        """
+        A L{RemoteObject} can send L{MethodCall}s with one argument and get
+        the response value.
+        """
+        self.object.method = lambda word, times=2: word * times
+        deferred = self.remote.method("hi", times=3)
+        self.assertEqual("hihihi", self.successResultOf(deferred))
+
     def test_method_call_error(self):
         """
         If a L{MethodCall} fails due to a L{MethodCallError},
@@ -529,8 +413,9 @@
         C{retryOnReconnect} error is set, as a L{MethodCallError} is a
         permanent failure that is not likely to ever succeed.
         """
+        self.methods.remove("method")
         self.factory.retryOnReconnect = True
-        deferred = self.remote.secret()
+        deferred = self.remote.method()
         self.failureResultOf(deferred).trap(MethodCallError)
 
     def test_retry(self):
@@ -539,10 +424,11 @@
         factory, the L{RemoteObject} will transparently retry to perform
         the L{MethodCall} requests that failed due to the broken connections.
         """
+        self.object.method = lambda word: word.capitalize()
         self.factory.factor = 0.19
         self.factory.retryOnReconnect = True
         self.connector.disconnect()
-        deferred = self.remote.capitalize("john")
+        deferred = self.remote.method("john")
 
         # The deferred has not fired yet, because it's been put in the pending
         # queue, until the call gets a chance to be retried upon reconnection
@@ -560,10 +446,11 @@
         the L{RemoteObject} will properly propagate the error to the original
         caller.
         """
+        self.methods.remove("method")
         self.factory.factor = 0.19
         self.factory.retryOnReconnect = True
         self.connector.disconnect()
-        deferred = self.remote.secret()
+        deferred = self.remote.method()
 
         # The deferred has not fired yet, because it's been put in the pending
         # queue, until the call gets a chance to be retried upon reconnection
@@ -573,7 +460,7 @@
         self.clock.advance(1)
 
         failure = self.failureResultOf(deferred)
-        self.assertEqual("Forbidden method 'secret'", str(failure.value))
+        self.assertEqual("Forbidden method 'method'", str(failure.value))
 
 
 class MethodCallClientFactoryTest(LandscapeTest):
@@ -657,26 +544,30 @@
         If the connection is lost, the L{RemoteObject} created by the creator
         will transparently handle the reconnection.
         """
-        server_factory = MethodCallServerFactory(Words(self.clock), METHODS)
+        dummy_object = DummyObject()
+        dummy_object.method = lambda: None
+        server_factory = MethodCallServerFactory(dummy_object, ["method"])
         connector = FakeConnector(self.factory, server_factory)
         connector.connect()
         remote = self.successResultOf(self.factory.getRemoteObject())
 
         connector.disconnect()
         self.clock.advance(5)
-        deferred = remote.empty()
+        deferred = remote.method()
         self.assertIsNone(self.successResultOf(deferred))
 
 
-class MethodCallFunctionalTest(TestCase):
+class MethodCallFunctionalTest(LandscapeTest):
 
     def setUp(self):
         super(MethodCallFunctionalTest, self).setUp()
+        self.methods = ["method"]
+        self.object = DummyObject()
+        self.object.method = lambda word: word.capitalize()
         self.socket = self.mktemp()
-        self.server = MethodCallServerFactory(Words(reactor), METHODS)
+        self.server = MethodCallServerFactory(self.object, self.methods)
         self.client = MethodCallClientFactory(reactor)
         self.port = reactor.listenUNIX(self.socket, self.server)
-        #self.client.maxRetries = 0  # By default, don't try to reconnect
 
     def tearDown(self):
         super(MethodCallFunctionalTest, self).tearDown()
@@ -691,7 +582,7 @@
         """
         connector = reactor.connectUNIX(self.socket, self.client)
         remote = yield self.client.getRemoteObject()
-        result = yield remote.capitalize("john")
+        result = yield remote.method("john")
         self.assertEqual(result, "John")
         self.client.stopTrying()
         connector.disconnect()
@@ -724,7 +615,7 @@
         yield deferred
 
         # The remote object is still working
-        result = yield remote.capitalize("john")
+        result = yield remote.method("john")
         self.assertEqual(result, "John")
         self.client.stopTrying()
         connector.disconnect()
@@ -745,7 +636,7 @@
         connector.disconnect()
 
         # This call will fail but it's transparently retried
-        result = yield remote.capitalize("john")
+        result = yield remote.method("john")
         self.assertEqual(result, "John")
         self.client.stopTrying()
         connector.disconnect()
@@ -757,6 +648,7 @@
         the L{RemoteObject} will properly propagate the error to the original
         caller.
         """
+        self.methods.remove("method")
         self.client.factor = 0.01  # Try reconnecting very quickly
         self.client.retryOnReconnect = True
         connector = reactor.connectUNIX(self.socket, self.client)
@@ -766,7 +658,7 @@
         connector.disconnect()
 
         # A method call error is not retried
-        yield self.assertFailure(remote.secret(), MethodCallError)
+        yield self.assertFailure(remote.method(), MethodCallError)
         self.client.stopTrying()
         connector.disconnect()
 
@@ -777,6 +669,7 @@
         connection is ready. If for whatever reason the connection drops
         again very quickly, the C{_retry} method will behave as expected.
         """
+        self.methods.remove("method")
         self.client.factor = 0.01  # Try reconnecting very quickly
         self.client.retryOnReconnect = True
         connector = reactor.connectUNIX(self.socket, self.client)
@@ -787,7 +680,7 @@
 
         def handle_reconnect(protocol):
             # In this precise moment we have a newly connected protocol
-            remote._sender.protocol = protocol
+            remote._sender._protocol = protocol
 
             # Pretend that the connection is lost again very quickly
             protocol.transport.loseConnection()
@@ -800,14 +693,14 @@
             self.client.notifyOnConnect(remote._handle_connect)
 
         def assert_failure(error):
-            self.assertEqual(str(error), "Forbidden method 'secret'")
+            self.assertEqual(str(error), "Forbidden method 'method'")
 
         # Use our own reconnect handler
         self.client.dontNotifyOnConnect(remote._handle_connect)
         self.client.notifyOnConnect(handle_reconnect)
 
-        error = yield self.assertFailure(remote.secret(), MethodCallError)
-        self.assertEqual(str(error), "Forbidden method 'secret'")
+        error = yield self.assertFailure(remote.method(), MethodCallError)
+        self.assertEqual(str(error), "Forbidden method 'method'")
 
         self.client.stopTrying()
         connector.disconnect()
@@ -827,11 +720,11 @@
         # Disconnect
         connector.disconnect()
 
-        result1 = yield remote.guess("word", "cool", value=4)
-        result2 = yield remote.motd()
+        result1 = yield remote.method("john")
+        result2 = yield remote.method("bill")
 
-        self.assertEqual(result1, "Guessed!")
-        self.assertEqual(result2, "Words are cool")
+        self.assertEqual(result1, "John")
+        self.assertEqual(result2, "Bill")
         self.client.stopTrying()
         connector.disconnect()
 
@@ -855,8 +748,8 @@
 
         # Wait for reconnection and peform another call
         yield deferred
-        result = yield remote.motd()
-        self.assertEqual(result, "Words are cool")
+        result = yield remote.method("john")
+        self.assertEqual(result, "John")
 
         self.client.stopTrying()
         connector.disconnect()
@@ -877,7 +770,7 @@
         # Disconnect
         connector.disconnect()
 
-        error = yield self.assertFailure(remote.modt(), MethodCallError)
+        error = yield self.assertFailure(remote.method("foo"), MethodCallError)
         self.assertEqual("timeout", str(error))
 
         self.client.stopTrying()