Merge lp:~mandel/ubuntuone-dev-tools/tcp-testcases into lp:ubuntuone-dev-tools

[Manuel de la Peña]

- Added a two new test cases that allow to start a server and connect a client in a safe manner (LP: #963082)

- Added a two new test cases that allow to start a service and connect a client in a safe manner (LP: #963082)

[Alejandro J. Cura (alecu)]

444 +def server_protocol_factory(cls=protocol.Protocol):
.
.
.
465 +def client_protocol_factory(cls=protocol.Protocol):

Since the above functions are never used with optional arguments, they should take only one mandatory argument.
----
479 + ClientSaveProtocol.connected_clients.append(self)

What's the list of connected_clients used for?
Instead of a class variable of ClientSaveProtocol, it should be an instance variable of the twisted factory that creates all these instances, and that's usually available as "self.factory" inside the protocol instnace.
----
"is a complicated manner." -> "is a complicated matter."
"arre" -> "are"
'%shas not started' <- missing space

review: Needs Fixing

[lp:~mandel/ubuntuone-dev-tools/tcp-testcases]

65. By Manuel de la Peña on 2012-04-09

Fixed code according to the reviews.

[dobey (dobey)]

38 +class Aditioner(pb.Referenceable):
39 + """A remote aditioner."""

Bad spelling. And "Additioner" isn't a word. Maybe "Adder" would be what you want to call it?

Also, I am not fond of having the module be "tx" as it's not a general twisted module, but for a very specific feature which is provided by twisted. Perhaps "twistedpb" would be a better name. Maybe I'm wrong, but this seems like a specific set of test cases for use with testing usage of the IPC mechanism we've built for use on Windows using TCP. The naming should better reflect that, I think.

7 +# Copyright 2011 Canonical Ltd.
419 +# Copyright 2011 Canonical Ltd.

The year is not 2011 any more. Stop living in the past!

Also, all copyright headers need to include the block of text for the OpenSSL exception. You can see it in the other source files now, as well as LICENSE in the root of the tree.

492 +class SaveServiceRunner(object):

Can you please explain the usage of the terms "Save" and "Service" in this code? It seems to me for "Service" you mean "twisted pb server" though it isn't entirely clear. And I have no idea what "Save" is supposed to mean in any of the contexts here.

review: Needs Fixing

[lp:~mandel/ubuntuone-dev-tools/tcp-testcases]

66. By Manuel de la Peña on 2012-04-12

Made changes according to review.

67. By Manuel de la Peña on 2012-04-12

Fixed errors during the merge.

68. By Manuel de la Peña on 2012-04-12

Merged with trunk updated license.

69. By Manuel de la Peña on 2012-04-12

Use the correct dates.

[dobey (dobey)]

I still see plenty usage of "save" and "Save" in the code. Is this not supposed to be "safe" and "Safe" instead?

[Alejandro J. Cura (alecu)]

Great work on this branch, mandel!

I love that the SafeTCPServer internally handles the port and that there's no need for the user of this classes to worry about that.

I'm going to ask for a change, though I'm already hearing you cursing from afar :-)

So, looking at test_multiple_services it seems that only one SafeTCPServer is used for both listen_server calls. I think this adds a lot of seemingly unneeded complexity in SafeTCPServer, that needs the self.server_factories dictionary and associated dict entries for each connection, and then each client needs to specify which server it wants to connect to as the first parameter to connect_client(). This also limits to one the number of servers of a given class that can be started with each SafeTCPServer.

My requested change is to simplify the API so, instead of having a SafeTCPServer for multiple ServerFactories...

        self.tcp_server = SafeTCPServer()
        calculator_s = self.tcp_server.listen_server(pb.PBServerFactory, self.calculator)
        self.addCleanup(self.tcp_server.clean_up, calculator_s)
        calculator_c = self.tcp_server.connect_client(calculator_s, pb.PBClientFactory)

... we would have one SafeTCPServer *per* ServerFactory, like this:

        self.tcp_server = SafeTCPServer(pb.PBServerFactory, self.calculator)
        self.addCleanup(self.tcp_server.clean_up)
        calculator_c = self.tcp_server.connect_client(pb.PBClientFactory)

The above change means that a lot of code and complexity in SafeTCPServer can be chopped by removing the self.server_factories dictionary.

Even better it would be to be allow multiple client connections to the same SafeTCPServer, but I think that it can wait till a later branch.

Oh, and two smaller issues:

1) I think we should somehow mark the instance attributes added to the factories so they don't collide with similar attributes that may be added by the code being tested. For instance, instead of .disconnecting or .on_connection_lost, the instance attributes added could be named something like _testserver_disconnecting, ._testserver_on_connection_lost.

2) I agree with dobey regarding the "Safe" and "Save" terminology. Instead of "SafeTCPServer" we should find another name that conveys a bit better what this classes are about. My (admittedly also ugly) proposals: "CleanableTCPServer" or "CloseableTCPServer".

review: Needs Fixing

[Manuel de la Peña (mandel)]

> Great work on this branch, mandel!
>
> I love that the SafeTCPServer internally handles the port and that there's no
> need for the user of this classes to worry about that.
>
> I'm going to ask for a change, though I'm already hearing you cursing from
> afar :-)
>
> So, looking at test_multiple_services it seems that only one SafeTCPServer is
> used for both listen_server calls. I think this adds a lot of seemingly
> unneeded complexity in SafeTCPServer, that needs the self.server_factories
> dictionary and associated dict entries for each connection, and then each
> client needs to specify which server it wants to connect to as the first
> parameter to connect_client(). This also limits to one the number of servers
> of a given class that can be started with each SafeTCPServer.
>
> My requested change is to simplify the API so, instead of having a
> SafeTCPServer for multiple ServerFactories...
>
> self.tcp_server = SafeTCPServer()
> calculator_s = self.tcp_server.listen_server(pb.PBServerFactory,
> self.calculator)
> self.addCleanup(self.tcp_server.clean_up, calculator_s)
> calculator_c = self.tcp_server.connect_client(calculator_s,
> pb.PBClientFactory)
>
> ... we would have one SafeTCPServer *per* ServerFactory, like this:
>
> self.tcp_server = SafeTCPServer(pb.PBServerFactory, self.calculator)
> self.addCleanup(self.tcp_server.clean_up)
> calculator_c = self.tcp_server.connect_client(pb.PBClientFactory)
>
> The above change means that a lot of code and complexity in SafeTCPServer can
> be chopped by removing the self.server_factories dictionary.

Sure, no problem what so ever, will be ready by the time you are back :)

>
> Even better it would be to be allow multiple client connections to the same
> SafeTCPServer, but I think that it can wait till a later branch.
>
> Oh, and two smaller issues:
>
> 1) I think we should somehow mark the instance attributes added to the
> factories so they don't collide with similar attributes that may be added by
> the code being tested. For instance, instead of .disconnecting or
> .on_connection_lost, the instance attributes added could be named something
> like _testserver_disconnecting, ._testserver_on_connection_lost.
>

Ok

> 2) I agree with dobey regarding the "Safe" and "Save" terminology. Instead of
> "SafeTCPServer" we should find another name that conveys a bit better what
> this classes are about. My (admittedly also ugly) proposals:
> "CleanableTCPServer" or "CloseableTCPServer".

Does sound terrible, what a bout TidyTCPServer?

[lp:~mandel/ubuntuone-dev-tools/tcp-testcases]

70. By Manuel de la Peña on 2012-04-13

Done the following per reviews:
1. Simplified the API so that the service runner only runs one service.
2. Renamed the deferreds so that the names are more explicit to avoid colisions.
3. Renamed the runner to use 'tidy' whichs explains better its use.

71. By Manuel de la Peña on 2012-04-13

clean_up does notlonger need to get the factory to clean.

72. By Manuel de la Peña on 2012-04-13

Use tidy not save/safe.

73. By Manuel de la Peña on 2012-04-13

Do not use save.

[dobey (dobey)]

+class ServerSaveProtocolTestCase(ProtocolTestCase):
+class ClientSaveProtocolTestCase(ProtocolTestCase):

These 2 are left. ;)

review: Needs Fixing

[dobey (dobey)]

+class MultipleSercicesTestCase(TestCase):

Also, just caught this spelling faux pas. But weren't we also going to use the term "Server" for all these as well?

[lp:~mandel/ubuntuone-dev-tools/tcp-testcases]

74. By Manuel de la Peña on 2012-04-13

Do no use save.

75. By Manuel de la Peña on 2012-04-13

Remove the use of the word service, is misleading.

[dobey (dobey)]

Seems ok to me now.

review: Approve

[Manuel de la Peña (mandel)]

review: Abstain

[Alejandro J. Cura (alecu)]

Love this branch.

review: Approve

=== added file 'ubuntuone/devtools/testcases/tests/test_txtcpserver.py'
--- ubuntuone/devtools/testcases/tests/test_txtcpserver.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/devtools/testcases/tests/test_txtcpserver.py	2012-04-13 17:08:21 +0000
@@ -0,0 +1,417 @@
+# -*- coding: utf-8 -*-
+# Copyright 2012 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the
+# OpenSSL library under certain conditions as described in each
+# individual source file, and distribute linked combinations
+# including the two.
+# You must obey the GNU General Public License in all respects
+# for all of the code used other than OpenSSL.  If you modify
+# file(s) with this exception, you may extend this exception to your
+# version of the file(s), but you are not obligated to do so.  If you
+# do not wish to do so, delete this exception statement from your
+# version.  If you delete this exception statement from all source
+# files in the program, then also delete it here.
+
+"""Test the twisted test cases."""
+
+from twisted.internet import defer, protocol
+from twisted.spread import pb
+from twisted.trial.unittest import TestCase
+
+from ubuntuone.devtools.testcases.txtcpserver import (
+    client_protocol_factory,
+    server_protocol_factory,
+    PbServerTestCase,
+    TidyTCPServer,
+    TCPServerTestCase,
+)
+
+# no init
+# pylint: disable=W0232
+
+
+class Adder(pb.Referenceable):
+    """A remote adder."""
+
+    def remote_add(self, first, second):
+        """Remote adding numbers."""
+        return first + second
+
+
+class Calculator(pb.Root):
+    """A calculator ran somewhere on the net."""
+
+    def __init__(self, adder):
+        """Create a new instance."""
+         # pb.Root has no __init__
+        self.adder = adder
+
+    def remote_get_adder(self):
+        """Get the remote added."""
+        return self.adder
+
+    def remote_check_adder(self, other_adder):
+        """Check if the are the same."""
+        return self.adder == other_adder
+
+
+class Echoer(pb.Root):
+    """An echoer that repeats what we say."""
+
+    def remote_say(self, sentence):
+        """Echo what we want to say."""
+        return 'Echoer: %s' % sentence
+# pylint: enable=W0232
+
+
+class FakeFactory(object):
+    """A fake server/client factory."""
+
+    def __init__(self):
+        """Create a new instance."""
+        self._disconnecting = False
+        self.testserver_on_connection_lost = defer.Deferred()
+        self.testserver_on_connection_made = defer.Deferred()
+
+
+# class_factory not callable
+# pylint: disable=E1102
+class ProtocolTestCase(TestCase):
+    """Test the protocol classes."""
+
+    class_factory = None
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        """Set the different tests."""
+        yield super(ProtocolTestCase, self).setUp()
+        self.called = []
+
+        def connection_lost(*args):
+            """Fake connection lost method."""
+            self.called.append('connectionLost')
+
+        self.patch(pb.Broker, 'connectionLost', connection_lost)
+
+        def connection_made(*args):
+            """Fake connection made."""
+            self.called.append('connectionMade')
+
+        self.patch(pb.Broker, 'connectionMade', connection_made)
+
+    def test_correct_inheritance(self):
+        """Test that the super class is correct."""
+        if self.class_factory:
+            protocol_cls = self.class_factory(pb.Broker)
+            protocol_instance = protocol_cls()
+            self.assertIsInstance(protocol_instance, pb.Broker)
+
+    def test_correct_none_inheritance(self):
+        """Test the inheritance when the class is none."""
+        if self.class_factory:
+            protocol_cls = self.class_factory(None)
+            protocol_instance = protocol_cls()
+            self.assertIsInstance(protocol_instance, protocol.Protocol)
+
+    def _assert_disconnecting(self, disconnecting):
+        """Assert the disconnection."""
+        if self.class_factory:
+            protocol_cls = self.class_factory(pb.Broker)
+            prot = protocol_cls()
+            prot.factory = FakeFactory()
+            prot.factory._disconnecting = disconnecting
+            prot.connectionLost()
+            self.assertIn('connectionLost', self.called,
+                                        'Super connectionLost most be called')
+            self.assertEqual(disconnecting,
+                           prot.factory.testserver_on_connection_lost.called)
+
+    def test_connection_lost_disconnecting(self):
+        """Test the connectionLost method."""
+        self._assert_disconnecting(True)
+
+    def test_connection_lost_not_disconnecting(self):
+        """Test the connectionLost method."""
+        self._assert_disconnecting(False)
+
+    def test_connection_lost_called(self):
+        """Test the connectionLost method."""
+        if self.class_factory:
+            protocol_cls = self.class_factory(pb.Broker)
+            prot = protocol_cls()
+            prot.factory = FakeFactory()
+            prot.factory._disconnecting = True
+            # call the deferred, if the code does not work we will get an
+            # exception
+            prot.factory.testserver_on_connection_lost.callback(True)
+            prot.connectionLost()
+            self.assertIn('connectionLost', self.called,
+                                        'Super connectionLost must be called')
+# pylint: enable=E1102
+
+
+class TidyServerProtocolTestCase(ProtocolTestCase):
+    """Test the generated tidy protocol."""
+
+    class_factory = lambda _, *a: server_protocol_factory(*a)
+
+
+# pylint: disable=E1101
+class TidyClientProtocolTestCase(ProtocolTestCase):
+    """Test the generated tidy protocol."""
+
+    class_factory = lambda _, *a: client_protocol_factory(*a)
+
+    def test_connection_made(self):
+        """Test the connectionMade method."""
+        # setting the factory here is to work around a pylint bug
+        pb.Broker.factory = FakeFactory()
+        protocol_cls = self.class_factory(pb.Broker)
+        protocol_instance = protocol_cls()
+        protocol_instance.connectionMade()
+        self.assertIn('connectionMade', self.called,
+                                        'Super connectionMade must be called')
+        self.assertTrue(
+               protocol_instance.factory.testserver_on_connection_made.called)
+
+    # factory outside init
+    def test_connection_made_called(self):
+        """Test the connectionMade method."""
+        # setting the factory here is to work around a pylint bug
+        pb.Broker.factory = FakeFactory()
+        protocol_cls = self.class_factory(pb.Broker)
+
+        protocol_instance = protocol_cls()
+
+        # call the deferred, if the code does not work we will get an
+        # exception
+        protocol_instance.factory.testserver_on_connection_made.callback(True)
+        protocol_instance.connectionMade()
+        self.assertIn('connectionMade', self.called,
+                                        'Super connectionMade must be called')
+# pylint: enable=E1101
+
+
+class TestPlainTwistedTestCase(TCPServerTestCase):
+    """Test using a server.
+
+    This test class is not testing the server and client perse but testing
+    that we can use a PbServerFactory and PbClientFactory in a way that the
+    connection will be closed correctly.
+    """
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        """Set the diff tests."""
+        yield super(TestPlainTwistedTestCase, self).setUp()
+        self.adder = Adder()
+        self.calculator = Calculator(self.adder)
+        self.listen_server(pb.PBServerFactory, self.calculator)
+        self.connect_client(pb.PBClientFactory)
+        yield self.client_connected
+
+    @defer.inlineCallbacks
+    def test_addition(self):
+        """Test adding numbers."""
+        first_number = 1
+        second_number = 2
+        calculator = yield self.client_factory.getRootObject()
+        adder = yield calculator.callRemote('get_adder')
+        result = yield adder.callRemote('add', first_number, second_number)
+        self.assertEqual(first_number + second_number, result)
+
+    @defer.inlineCallbacks
+    def test_check_adder(self):
+        """Test comparing the adder."""
+        calculator = yield self.client_factory.getRootObject()
+        adder = yield calculator.callRemote('get_adder')
+        check = yield calculator.callRemote('check_adder', adder)
+        self.assertTrue(check)
+
+
+class TestNoConnetionTrackingTestCase(TCPServerTestCase):
+    """Test using a server.
+
+    This test class is not testing the server and the client perse but testing
+    that we can use the PbServerFactory and PbClientFactory in a way that the
+    connection will be closed and some of the actions performed in the setup
+    and not recorded.
+    """
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        """Set the diff tests."""
+        yield super(TestNoConnetionTrackingTestCase, self).setUp()
+        self.adder = Adder()
+        self.calculator = Calculator(self.adder)
+        # connect client and server
+        self.listen_server(pb.PBServerFactory, self.calculator)
+        self.connect_client(pb.PBClientFactory)
+
+        # ensure we are connected
+        yield self.client_connected
+
+        self.first_number = 1
+        self.second_number = 2
+        self.setup_result = None
+
+        # perform some actions before the tests
+        calculator = yield self.client_factory.getRootObject()
+        adder = yield calculator.callRemote('get_adder')
+        self.setup_result = yield adder.callRemote('add',
+                                                    self.first_number,
+                                                    self.second_number)
+
+    def test_deferreds(self):
+        """Test that the deferreds are not broken."""
+        self.assertFalse(self.client_disconnected.called)
+        self.assertFalse(self.server_disconnected.called)
+
+    @defer.inlineCallbacks
+    def test_addition(self):
+        """Test adding numbers."""
+        first_number = 1
+        second_number = 2
+        calculator = yield self.client_factory.getRootObject()
+        adder = yield calculator.callRemote('get_adder')
+        result = yield adder.callRemote('add', first_number, second_number)
+        self.assertEqual(first_number + second_number, result)
+        self.assertEqual(self.setup_result, result)
+
+    @defer.inlineCallbacks
+    def test_check_adder(self):
+        """Test comparing the adder."""
+        calculator = yield self.client_factory.getRootObject()
+        adder = yield calculator.callRemote('get_adder')
+        check = yield calculator.callRemote('check_adder', adder)
+        self.assertTrue(check)
+
+
+class TestPlainPbTestCase(PbServerTestCase):
+    """Test using a server.
+
+    This test class is not testing the server and client perse but testing
+    that we can use a PbServerFactory and PbClientFactory in a way that the
+    connection will be closed correctly.
+    """
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        """Set the diff tests."""
+        yield super(TestPlainPbTestCase, self).setUp()
+        self.adder = Adder()
+        self.calculator = Calculator(self.adder)
+        self.listen_server(self.calculator)
+        self.connect_client()
+        yield self.client_connected
+
+    @defer.inlineCallbacks
+    def test_addition(self):
+        """Test adding numbers."""
+        first_number = 1
+        second_number = 2
+        calculator = yield self.client_factory.getRootObject()
+        adder = yield calculator.callRemote('get_adder')
+        result = yield adder.callRemote('add', first_number, second_number)
+        self.assertEqual(first_number + second_number, result)
+
+    @defer.inlineCallbacks
+    def test_check_adder(self):
+        """Test comparing the adder."""
+        calculator = yield self.client_factory.getRootObject()
+        adder = yield calculator.callRemote('get_adder')
+        check = yield calculator.callRemote('check_adder', adder)
+        self.assertTrue(check)
+
+
+class MultipleServersTestCase(TestCase):
+    """Ensure that several servers can be ran."""
+
+    timeout = 2
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        """Set the diff tests."""
+        yield super(MultipleServersTestCase, self).setUp()
+        self.first_tcp_server = TidyTCPServer()
+        self.second_tcp_server = TidyTCPServer()
+        self.adder = Adder()
+        self.calculator = Calculator(self.adder)
+        self.echoer = Echoer()
+
+    @defer.inlineCallbacks
+    def test_single_server(self):
+        """Test setting a single server."""
+        first_number = 1
+        second_number = 2
+        self.first_tcp_server.listen_server(pb.PBServerFactory,
+                                                              self.calculator)
+        self.addCleanup(self.first_tcp_server.clean_up)
+        calculator_c = self.first_tcp_server.connect_client(pb.PBClientFactory)
+        # ensure we do have connected
+        yield calculator_c.testserver_on_connection_made
+        calculator = yield calculator_c.getRootObject()
+        adder = yield calculator.callRemote('get_adder')
+        result = yield adder.callRemote('add', first_number, second_number)
+        self.assertEqual(first_number + second_number, result)
+
+    @defer.inlineCallbacks
+    def test_multiple_server(self):
+        """Test setting multiple server."""
+        first_number = 1
+        second_number = 2
+        # first server
+        self.first_tcp_server.listen_server(pb.PBServerFactory,
+                                                              self.calculator)
+        self.addCleanup(self.first_tcp_server.clean_up)
+
+        # second server
+        self.second_tcp_server.listen_server(pb.PBServerFactory, self.echoer)
+        self.addCleanup(self.second_tcp_server.clean_up)
+
+        # connect the diff clients
+        calculator_c = self.first_tcp_server.connect_client(pb.PBClientFactory)
+        echoer_c = self.second_tcp_server.connect_client(pb.PBClientFactory)
+        # ensure we do have connected
+        yield calculator_c.testserver_on_connection_made
+        yield echoer_c.testserver_on_connection_made
+
+        calculator = yield calculator_c.getRootObject()
+        adder = yield calculator.callRemote('get_adder')
+        result = yield adder.callRemote('add', first_number, second_number)
+        self.assertEqual(first_number + second_number, result)
+        echoer = yield echoer_c.getRootObject()
+        echo = yield echoer.callRemote('say', 'hello')
+        self.assertEqual(self.echoer.remote_say('hello'), echo)
+
+    def test_no_single_client(self):
+        """Test setting a single server no client."""
+        # start server but do not connect a client
+        self.first_tcp_server.listen_server(pb.PBServerFactory,
+                                                              self.calculator)
+        self.addCleanup(self.first_tcp_server.clean_up)
+
+    def test_no_multiple_clients(self):
+        """Test setting multiple servers no clients."""
+        # first server
+        self.first_tcp_server.listen_server(pb.PBServerFactory,
+                                                              self.calculator)
+        self.addCleanup(self.first_tcp_server.clean_up)
+
+        # second server
+        self.second_tcp_server.listen_server(pb.PBServerFactory, self.echoer)
+        self.addCleanup(self.second_tcp_server.clean_up)

=== added file 'ubuntuone/devtools/testcases/txtcpserver.py'
--- ubuntuone/devtools/testcases/txtcpserver.py	1970-01-01 00:00:00 +0000
+++ ubuntuone/devtools/testcases/txtcpserver.py	2012-04-13 17:08:21 +0000
@@ -0,0 +1,230 @@
+# -*- coding: utf-8 -*-
+# Copyright 2012 Canonical Ltd.
+#
+# This program is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License version 3, as published
+# by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranties of
+# MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR
+# PURPOSE.  See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+# In addition, as a special exception, the copyright holders give
+# permission to link the code of portions of this program with the
+# OpenSSL library under certain conditions as described in each
+# individual source file, and distribute linked combinations
+# including the two.
+# You must obey the GNU General Public License in all respects
+# for all of the code used other than OpenSSL.  If you modify
+# file(s) with this exception, you may extend this exception to your
+# version of the file(s), but you are not obligated to do so.  If you
+# do not wish to do so, delete this exception statement from your
+# version.  If you delete this exception statement from all source
+# files in the program, then also delete it here.
+
+"""Base test case for twisted servers."""
+
+from twisted.internet import defer, protocol
+from twisted.spread import pb
+
+from ubuntuone.devtools.testcases import BaseTestCase
+
+# no init method +  twisted common warnings
+# pylint: disable=W0232, C0103, E1101
+
+
+def server_protocol_factory(cls):
+    """Factory to create tidy protocols."""
+
+    if cls is None:
+        cls = protocol.Protocol
+
+    class ServerTidyProtocol(cls):
+        """A tidy protocol."""
+
+        def connectionLost(self, *args):
+            """Lost the connection."""
+            cls.connectionLost(self, *args)
+            # lets tell everyone
+            # pylint: disable=W0212
+            if (self.factory._disconnecting
+                    and self.factory.testserver_on_connection_lost is not None
+                    and not self.factory.testserver_on_connection_lost.called):
+                self.factory.testserver_on_connection_lost.callback(self)
+            # pylint: enable=W0212
+
+    return ServerTidyProtocol
+
+
+def client_protocol_factory(cls):
+    """Factory to create tidy protocols."""
+
+    if cls is None:
+        cls = protocol.Protocol
+
+    class ClientTidyProtocol(cls):
+        """A tidy protocol."""
+
+        def connectionMade(self):
+            """Connection made."""
+            if (self.factory.testserver_on_connection_made is not None
+                    and not self.factory.testserver_on_connection_made.called):
+                self.factory.testserver_on_connection_made.callback(self)
+            cls.connectionMade(self)
+
+        def connectionLost(self, *a):
+            """Connection list."""
+            # pylint: disable=W0212
+            if (self.factory._disconnecting
+                    and self.factory.testserver_on_connection_lost is not None
+                    and not self.factory.testserver_on_connection_lost.called):
+                self.factory.testserver_on_connection_lost.callback(self)
+            # pylint: enable=W0212
+            cls.connectionLost(self, *a)
+
+    return ClientTidyProtocol
+
+
+class TidyTCPServer(object):
+    """Ensure that twisted servers are correctly managed in tests.
+
+    Closing a twisted server is a complicated matter. In order to do so you
+    have to ensure that three different deferreds are fired:
+
+        1. The server must stop listening.
+        2. The client connection must disconnect.
+        3. The server connection must disconnect.
+
+    This class allows to create a server and a client that will ensure that
+    the reactor is left clean by following the pattern described at
+    http://mumak.net/stuff/twisted-disconnect.html
+    """
+
+    def __init__(self):
+        """Create a new instance."""
+        self.listener = None
+        self.server_factory = None
+
+        self.connector = None
+        self.client_factory = None
+
+    def listen_server(self, server_class, *args, **kwargs):
+        """Start a server in a random port."""
+
+        from twisted.internet import reactor
+        self.server_factory = server_class(*args, **kwargs)
+        self.server_factory._disconnecting = False
+        self.server_factory.testserver_on_connection_lost = defer.Deferred()
+        self.server_factory.protocol = server_protocol_factory(
+                                                 self.server_factory.protocol)
+        self.listener = reactor.listenTCP(0, self.server_factory)
+        return self.server_factory
+
+    def connect_client(self, client_class, *args, **kwargs):
+        """Conect a client to a given server."""
+        from twisted.internet import reactor
+
+        if self.server_factory is None:
+            raise ValueError('Server Factory was not provided.')
+        if self.listener is None:
+            raise ValueError('%s has not started listening.',
+                                                          self.server_factory)
+
+        self.client_factory = client_class(*args, **kwargs)
+        self.client_factory._disconnecting = False
+        self.client_factory.protocol = client_protocol_factory(
+                                                 self.client_factory.protocol)
+        self.client_factory.testserver_on_connection_made = defer.Deferred()
+        self.client_factory.testserver_on_connection_lost = defer.Deferred()
+        self.connector = reactor.connectTCP('localhost',
+                                        self.listener.getHost().port,
+                                        self.client_factory)
+        return self.client_factory
+
+    def clean_up(self):
+        """Action to be performed for clean up."""
+        if self.server_factory is None or self.listener is None:
+            # nothing to clean
+            return defer.succeed(None)
+
+        if self.listener and self.connector:
+            # clean client and server
+            self.server_factory._disconnecting = True
+            self.client_factory._disconnecting = True
+            d = defer.maybeDeferred(self.listener.stopListening)
+            self.connector.disconnect()
+            return defer.gatherResults([d,
+                self.client_factory.testserver_on_connection_lost,
+                self.server_factory.testserver_on_connection_lost])
+        if self.listener:
+            # just clean the server since there is no client
+            self.server_factory._disconnecting = True
+            return defer.maybeDeferred(self.listener.stopListening)
+
+
+class TCPServerTestCase(BaseTestCase):
+    """Test that uses a single twisted server."""
+
+    @defer.inlineCallbacks
+    def setUp(self):
+        """Set the diff tests."""
+        yield super(TCPServerTestCase, self).setUp()
+        self.server_runner = TidyTCPServer()
+
+        self.server_factory = None
+        self.client_factory = None
+        self.server_disconnected = None
+        self.client_connected = None
+        self.client_disconnected = None
+        self.listener = None
+        self.connector = None
+        self.addCleanup(self.tear_down_server_client)
+
+    def listen_server(self, server_class, *args, **kwargs):
+        """Listen a server.
+
+        The method takes the server class and the arguments that should be
+        passed to the server constructor.
+        """
+        self.server_factory = self.server_runner.listen_server(server_class,
+                *args, **kwargs)
+        self.server_disconnected = \
+                self.server_factory.testserver_on_connection_lost
+        self.listener = self.server_runner.listener
+
+    def connect_client(self, client_class, *args, **kwargs):
+        """Connect the client.
+
+        The method takes the client factory  class and the arguments that
+        should be passed to the client constructor.
+        """
+        self.client_factory = self.server_runner.connect_client(client_class,
+                                                              *args, **kwargs)
+        self.client_connected = \
+                self.client_factory.testserver_on_connection_made
+        self.client_disconnected = \
+                self.client_factory.testserver_on_connection_lost
+        self.connector = self.server_runner.connector
+
+    def tear_down_server_client(self):
+        """Clean the server and client."""
+        if self.server_factory and self.client_factory:
+            return self.server_runner.clean_up()
+
+
+class PbServerTestCase(TCPServerTestCase):
+    """Test a pb server."""
+
+    def listen_server(self, *args, **kwargs):
+        """Listen a pb server."""
+        super(PbServerTestCase, self).listen_server(pb.PBServerFactory,
+                                                              *args, **kwargs)
+
+    def connect_client(self, *args, **kwargs):
+        """Connect a pb client."""
+        super(PbServerTestCase, self).connect_client(pb.PBClientFactory,
+                                                              *args, **kwargs)