added new pypsyc as 'mjacob2'

mjacob2/tests/test_server/test_db.py

@@ -0,0 +1,50 @@
+"""
+    :copyright: 2010 by Manuel Jacob
+    :license: MIT
+"""
+from greenlet import greenlet
+from nose.tools import assert_raises
+from tests.helpers import mockify, mockified, check_success
+
+from pypsyc.server.db import Database
+
+
+class TestDatabase:
+    def test_sync(self):
+        db = Database(':memory:')
+        db.execute('CREATE TABLE test(test TEXT)')
+        db.execute("INSERT INTO test VALUES ('test')")
+
+        result = db.fetch('SELECT test FROM test')
+        assert result == [('test',)]
+        assert isinstance(result[0][0], str)
+
+        db.stop()
+
+    @check_success
+    @mockified('pypsyc.server.db',['sqlite3', 'Thread', 'reactor'])
+    def test_async(self, sqlite3, Thread, reactor):
+        db = Database('')
+        mockify(db, ['_execute', '_fetch'])
+        e = Exception()
+        db._execute.side_effect = e
+
+        def f():
+            assert_raises(Exception, db.execute)
+            assert db.fetch() == db._fetch.return_value
+            self.success = True
+        gl = greenlet(f)
+        gl.switch()
+
+        # emulate reactor calling this methods
+        gl.throw(e)
+        gl.switch(db._fetch.return_value)
+
+        db.stop()
+        assert db.thread.method_calls == [('start',), ('join',)]
+
+        db.run_async()
+        assert sqlite3.method_calls == [('connect', ('',))]
+        assert reactor.method_calls == [
+                ('callFromThread', (gl.throw, e)),
+                ('callFromThread', (gl.switch, db._fetch.return_value))]

mjacob2/tests/test_server/test_multicast.py

@@ -0,0 +1,162 @@
+"""
+    ::copyright: 2010 by Manuel Jacob
+    :license: MIT
+"""
+from mock import Mock
+from tests.constants import (SERVER1, SERVER2, SERVER1_UNI, SERVER2_UNI, USER1, USER2,
+     USER1_UNI, USER2_UNI, RESOURCE, PLACE_UNI, VARIABLES)
+from tests.helpers import mockified, rendered
+
+from pypsyc.core.psyc import PSYCPacket
+from pypsyc.server import Entity
+from pypsyc.server.multicast import ContextSlave
+from pypsyc.server.person import Resource
+
+
+EXTERN_USER_UNI = SERVER2_UNI.chain(USER1)
+SET_PACKET = PSYCPacket({'=': VARIABLES})
+ADD_PACKET = PSYCPacket({'+': VARIABLES})
+REMOVE_PACKET = PSYCPacket({'-': VARIABLES})
+
+class TestContextMaster(object):
+    def setup(self):
+        self.server = Mock()
+        self.server.hostname = SERVER1
+        self.server.routing.mrouting_table = self.mrouting_table = {}
+        root = Entity(server=self.server)
+        self.user1 = Entity(root, USER1)
+        self.user1.castmsg = Mock()
+        user2 = Entity(root, USER2)
+        Resource(user2, RESOURCE, Mock())
+
+    def test_extern_member(self):
+        circuit = Mock()
+        self.server.routing.srouting_table = {SERVER2: circuit}
+
+        self.user1.context_master.add_member(EXTERN_USER_UNI)
+        assert self.mrouting_table[USER1_UNI] == set([circuit])
+
+        self.user1.context_master.remove_member(EXTERN_USER_UNI)
+        assert self.mrouting_table[USER1_UNI] == set()
+
+    def test_set_persistent(self):
+        self.user1.context_master.state_set(**VARIABLES)
+        assert self.user1.castmsg.call_args_list == [((SET_PACKET,),),]
+
+        state = self.user1.context_master.add_member(USER2_UNI)
+        assert state == VARIABLES
+
+    def test_persistent_list(self):
+        self.user1.context_master.state_add(**VARIABLES)
+        assert self.user1.castmsg.call_args_list == [((ADD_PACKET,),)]
+        self.user1.castmsg.reset_mock()
+
+        state = self.user1.context_master.add_member(USER2_UNI)
+        assert state == VARIABLES
+
+        self.user1.context_master.state_remove(**VARIABLES)
+        assert self.user1.castmsg.call_args_list == [((REMOVE_PACKET,),)]
+
+        state = self.user1.context_master.add_member(USER2_UNI)
+        assert state == {}
+
+    def test_remove_inheritance(self):
+        self.user1.context_master.state_add(_a='a', _a_b='b')
+        self.user1.context_master.state_remove(_a='a')
+
+        state = self.user1.context_master.add_member(USER2_UNI)
+        assert state == {}
+
+
+RESOURCE1 = '*resource1'
+RESOURCE2 = '*resource2'
+USER1_RESOURCE1_UNI = USER1_UNI.chain(RESOURCE1)
+USER1_RESOURCE2_UNI = USER1_UNI.chain(RESOURCE2)
+
+class TestContextSlave(object):
+    @mockified('pypsyc.server.multicast', ['ContextSlaveProtocol'])
+    def setup(self, ContextSlaveProtocol):
+        person = Mock()
+        self.entity = person.entity
+        self.entity._root.uni = SERVER1_UNI
+        self.entity.uni = USER1_UNI
+        self.entity.server.routing.mrouting_table = self.mrouting_table = {}
+        self.entity.children = {}
+        self.entity.children[RESOURCE1] = self.resource1 = Mock()
+        self.entity.children[RESOURCE2] = self.resource2 = Mock()
+        self.protocol = ContextSlaveProtocol.return_value
+        self.protocol.enter.return_value = VARIABLES
+        self.context_slave = ContextSlave(person)
+        assert ContextSlaveProtocol.call_args_list == [((person,),)]
+
+    def test_enter_leave(self):
+        self.context_slave.enter(PLACE_UNI, USER1_RESOURCE1_UNI)
+        assert self.protocol.method_calls == [('enter', (PLACE_UNI,))]
+        assert self.mrouting_table[PLACE_UNI] == set([self.resource1.circuit])
+        assert self.resource1.circuit.method_calls == [
+                ('send', ({'_context': PLACE_UNI}, rendered(SET_PACKET)))]
+        self.protocol.reset_mock()
+
+        self.context_slave.leave(PLACE_UNI, USER1_RESOURCE1_UNI)
+        assert self.protocol.method_calls == [('leave', (PLACE_UNI,))]
+        assert self.mrouting_table[PLACE_UNI] == set()
+
+    def test_enter_leave_all_resources(self):
+        self.context_slave.enter(PLACE_UNI)
+        assert self.protocol.method_calls == [('enter', (PLACE_UNI,))]
+        assert self.mrouting_table[PLACE_UNI] == set([self.resource1.circuit,
+                                                      self.resource2.circuit])
+        assert self.resource1.circuit.method_calls == [
+                ('send', ({'_context': PLACE_UNI}, rendered(SET_PACKET)),)]
+        assert self.resource2.circuit.method_calls == [
+                ('send', ({'_context': PLACE_UNI}, rendered(SET_PACKET)),)]
+        self.protocol.reset_mock()
+
+        self.context_slave.leave(PLACE_UNI)
+        assert self.protocol.method_calls == [('leave', (PLACE_UNI,))]
+        assert self.mrouting_table[PLACE_UNI] == set()
+
+    def test_enter_leave_two_resources(self):
+        extern_circuit = Mock()
+        self.mrouting_table[PLACE_UNI] = set([extern_circuit])
+
+        self.context_slave.enter(PLACE_UNI, USER1_RESOURCE1_UNI)
+        self.context_slave.enter(PLACE_UNI, USER1_RESOURCE2_UNI)
+        assert self.protocol.method_calls == [('enter', (PLACE_UNI,))]
+        assert self.mrouting_table[PLACE_UNI] == set([extern_circuit,
+                                                      self.resource1.circuit,
+                                                      self.resource2.circuit])
+        assert self.resource1.circuit.method_calls == [
+                ('send', ({'_context': PLACE_UNI}, rendered(SET_PACKET)))]
+        self.protocol.reset_mock()
+
+        self.context_slave.leave(PLACE_UNI, USER1_RESOURCE1_UNI)
+        assert self.protocol.method_calls == []
+        self.context_slave.leave(PLACE_UNI, USER1_RESOURCE2_UNI)
+        assert self.protocol.method_calls == [('leave', (PLACE_UNI,))]
+        assert self.mrouting_table[PLACE_UNI] == set([extern_circuit])
+
+    def test_enter_leave_extern(self):
+        self.context_slave.enter(EXTERN_USER_UNI, USER1_RESOURCE1_UNI)
+        assert self.protocol.method_calls == [('enter', (EXTERN_USER_UNI,))]
+        assert self.mrouting_table[EXTERN_USER_UNI] == \
+                set([self.resource1.circuit])
+        assert self.resource1.circuit.method_calls == [
+                ('send', ({'_context':EXTERN_USER_UNI}, rendered(SET_PACKET)))]
+        self.protocol.reset_mock()
+
+        self.context_slave.leave(EXTERN_USER_UNI, USER1_RESOURCE1_UNI)
+        assert self.protocol.method_calls == [('leave', (EXTERN_USER_UNI,))]
+        assert EXTERN_USER_UNI not in self.mrouting_table
+
+    def test_leave_all(self):
+        self.context_slave.enter(PLACE_UNI, USER1_RESOURCE1_UNI)
+        self.protocol.reset_mock()
+
+        self.context_slave.leave_all()
+        assert self.protocol.method_calls == [('leave', (PLACE_UNI,))]
+        assert self.mrouting_table[PLACE_UNI] == set()
+
+    def test_not_leave(self):
+        self.context_slave.leave(PLACE_UNI)
+        assert self.protocol.method_calls == []

mjacob2/tests/test_server/test_person.py

@@ -0,0 +1,268 @@
+"""
+    :copyright: 2010 by Manuel Jacob
+    :license: MIT
+"""
+import hmac
+from hashlib import sha256
+
+from mock import Mock
+from nose.tools import assert_raises
+from tests.constants import (SERVER1, USER1, USER1_UNI, USER2_UNI, RESOURCE,
+     RESOURCE1_UNI, RESOURCE2_UNI, PLACE_UNI, VARIABLES, PASSWORD, MESSAGE,
+     ONLINE, ERROR)
+from tests.helpers import mockified
+
+from pypsyc.protocol import (AuthenticationError, FriendshipPendingError,
+     FriendshipEstablishedError, EntryDeniedError)
+from pypsyc.server import Entity
+from pypsyc.server.db import Database
+from pypsyc.server.person import Person
+
+
+class TestPerson(object):
+    def setup(self):
+        self.server = Mock()
+        self.server.hostname = SERVER1
+        self.server.database = Database(':memory:')
+
+        root = Entity(server=self.server)
+        self.entity = Entity(root, USER1)
+
+    @mockified('pypsyc.server.person', ['RoutingErrorRelaying'])
+    def test_unknown_target_error(self, RoutingErrorRelaying):
+        RESOURCE1 = USER1_UNI.chain('*resource1')
+        RESOURCE2 = USER1_UNI.chain('*resource2')
+
+        Entity(self.entity, '*resource1')
+        Entity(self.entity, '*resource2')
+        routing_error_relaying = RoutingErrorRelaying.return_value
+        person = Person(self.entity)
+        assert RoutingErrorRelaying.call_args_list == [((person,),)]
+
+        person.unknown_target_error(USER2_UNI)
+        assert routing_error_relaying.method_calls == [
+                ('relay_unknown_target_error', (RESOURCE1, USER2_UNI)),
+                ('relay_unknown_target_error', (RESOURCE2, USER2_UNI))]
+
+    @mockified('pypsyc.server.person', ['RoutingErrorRelaying'])
+    def test_unknown_target_error(self, RoutingErrorRelaying):
+        RESOURCE1 = USER1_UNI.chain('*resource1')
+        RESOURCE2 = USER1_UNI.chain('*resource2')
+
+        Entity(self.entity, '*resource1')
+        Entity(self.entity, '*resource2')
+        routing_error_relaying = RoutingErrorRelaying.return_value
+        person = Person(self.entity)
+        assert RoutingErrorRelaying.call_args_list == [((person,),)]
+
+        person.delivery_failed_error(USER2_UNI, ERROR)
+        assert routing_error_relaying.method_calls == [
+                ('relay_delivery_failed_error', (RESOURCE1, USER2_UNI, ERROR)),
+                ('relay_delivery_failed_error', (RESOURCE2, USER2_UNI, ERROR))]
+
+    @mockified('pypsyc.server.person', ['LinkingServer', 'FriendshipProtocol',
+                                        'ContextSlave'])
+    def test_authenticate(self, LinkingServer, FriendshipProtocol,
+                          ContextSlave):
+        NONCE = 'random_nonce'
+        DIGEST = hmac.new(PASSWORD, NONCE, sha256).digest()
+
+        circuit = Mock()
+        circuit.allowed_sources = []
+        friendship_protocol = FriendshipProtocol.return_value
+        context_slave = ContextSlave.return_value
+
+        person = Person(self.entity)
+        person.register(PASSWORD)
+        assert LinkingServer.call_args_list == [((person,),)]
+
+        assert_raises(AuthenticationError,
+                person.authenticate, ('hmac', 'wrong', NONCE), None, RESOURCE)
+
+        sql = "INSERT INTO friendships VALUES(?, ?, 'established')"
+        self.server.database.execute(sql, USER1_UNI, USER2_UNI)
+
+        person.authenticate(('hmac', DIGEST, NONCE), circuit, RESOURCE)
+        assert self.entity.children[RESOURCE].circuit == circuit
+        assert circuit.allowed_sources == [RESOURCE1_UNI]
+        friendships = {USER2_UNI: {'state': 'established'}}
+        assert friendship_protocol.method_calls == [
+                ('cast_presence', (7,)),
+                ('send_friendships', (RESOURCE1_UNI, friendships))]
+        assert context_slave.method_calls == [
+                ('enter', (USER2_UNI, RESOURCE1_UNI))]
+        friendship_protocol.reset_mock()
+        context_slave.reset_mock()
+
+        person.unlink(RESOURCE)
+        assert self.entity.children == {}
+        assert friendship_protocol.method_calls == [('cast_presence', (1,))]
+        assert context_slave.method_calls == [('leave_all',)]
+
+    @mockified('pypsyc.server.person', ['MessageRelaying'])
+    def test_message_relay(self, MessageRelaying):
+        message_relaying = MessageRelaying.return_value
+        person = Person(self.entity)
+        assert MessageRelaying.call_args_list == [((person,),)]
+
+        person.private_message_relay(RESOURCE1_UNI, USER2_UNI, MESSAGE)
+        person.private_message_relay(RESOURCE2_UNI, USER2_UNI, MESSAGE)
+        assert message_relaying.method_calls == [
+                ('send_private_message', (USER2_UNI, MESSAGE))]
+
+    @mockified('pypsyc.server.person', ['MessageRelaying'])
+    def test_message(self, MessageRelaying):
+        RESOURCE1 = USER1_UNI.chain('*resource1')
+        RESOURCE2 = USER1_UNI.chain('*resource2')
+
+        Entity(self.entity, '*resource1')
+        Entity(self.entity, '*resource2')
+        message_relaying = MessageRelaying.return_value
+        person = Person(self.entity)
+
+        person.private_message(USER2_UNI, MESSAGE)
+        assert message_relaying.method_calls == [
+                ('relay_private_message', (USER2_UNI, RESOURCE1, MESSAGE)),
+                ('relay_private_message', (USER2_UNI, RESOURCE2, MESSAGE))]
+
+    @mockified('pypsyc.server.person', ['FriendshipProtocol', 'ContextSlave'])
+    def test_outgoing_friendship(self, FriendshipProtocol, ContextSlave):
+        friendship_protocol = FriendshipProtocol.return_value
+        context_slave = ContextSlave.return_value
+        person = Person(self.entity)
+        person.register('')
+        Entity(self.entity, RESOURCE)
+
+        person.client_add_friend(USER2_UNI)
+        fs = {'state': 'pending'}
+        assert friendship_protocol.method_calls == [
+                ('establish', (USER2_UNI,)),
+                ('send_updated_friendship', (RESOURCE1_UNI, USER2_UNI, fs))]
+        friendship_protocol.reset_mock()
+        assert_raises(FriendshipPendingError, person.client_add_friend,
+                      USER2_UNI)
+
+        state = person.friendship_request(USER2_UNI)
+        assert state == 'established'
+        state = person.friendship_request(USER2_UNI)
+        assert state == 'established'
+        fs = {'state': 'established'}
+        assert friendship_protocol.method_calls == [
+                ('send_updated_friendship', (RESOURCE1_UNI, USER2_UNI, fs))]
+        assert context_slave.method_calls == [('enter', (USER2_UNI,))]
+        assert_raises(FriendshipEstablishedError, person.client_add_friend,
+                      USER2_UNI)
+
+    @mockified('pypsyc.server.person', ['FriendshipProtocol', 'ContextSlave'])
+    def test_incoming_friendship(self, FriendshipProtocol, ContextSlave):
+        friendship_protocol = FriendshipProtocol.return_value
+        context_slave = ContextSlave.return_value
+        person = Person(self.entity)
+        person.register('')
+        Entity(self.entity, RESOURCE)
+
+        state = person.friendship_request(USER2_UNI)
+        assert state == 'pending'
+        state = person.friendship_request(USER2_UNI)
+        assert state == 'pending'
+        fs = {'state': 'offered'}
+        assert friendship_protocol.method_calls == [
+                ('send_updated_friendship', (RESOURCE1_UNI, USER2_UNI, fs))]
+        friendship_protocol.reset_mock()
+
+        person.client_add_friend(USER2_UNI)
+        fs = {'state': 'established'}
+        assert friendship_protocol.method_calls == [
+                ('establish', (USER2_UNI,)),
+                ('send_updated_friendship', (RESOURCE1_UNI, USER2_UNI, fs))]
+        assert context_slave.method_calls == [('enter', (USER2_UNI,))]
+        assert_raises(FriendshipEstablishedError, person.client_add_friend,
+                      USER2_UNI)
+
+    @mockified('pypsyc.server.person', ['FriendshipProtocol', 'ContextSlave'])
+    def test_cancel_friendship(self, FriendshipProtocol, ContextSlave):
+        friendship_protocol = FriendshipProtocol.return_value
+        context_slave = ContextSlave.return_value
+        person = Person(self.entity)
+        person.register('')
+        Entity(self.entity, RESOURCE)
+
+        person.friendship_cancel(USER2_UNI)
+        assert context_slave.method_calls == [('leave', (USER2_UNI,))]
+        assert friendship_protocol.method_calls == [
+                ('send_removed_friendship', (RESOURCE1_UNI, USER2_UNI))]
+
+    @mockified('pypsyc.server.person', ['FriendshipProtocol', 'ContextSlave'])
+    def test_remove_friend(self, FriendshipProtocol, ContextSlave):
+        friendship_protocol = FriendshipProtocol.return_value
+        context_slave = ContextSlave.return_value
+        person = Person(self.entity)
+        person.register('')
+        Entity(self.entity, RESOURCE)
+
+        person.client_remove_friend(USER2_UNI)
+        assert context_slave.method_calls == [('leave', (USER2_UNI,))]
+        assert friendship_protocol.method_calls == [
+                ('remove', (USER2_UNI,)),
+                ('send_removed_friendship', (RESOURCE1_UNI, USER2_UNI))]
+
+    @mockified('pypsyc.server.person', ['FriendshipProtocol', 'ContextSlave',
+                                        'ContextMasterProtocol'])
+    def test_enter_context(self, FriendshipProtocol, ContextSlave,
+                           ContextMasterProtocol):
+        cm = self.entity.context_master = Mock()
+        cm.add_member.return_value = VARIABLES
+        person = Person(self.entity)
+        person.register('')
+        person.friendship_request(USER2_UNI)
+        person.client_add_friend(USER2_UNI)
+        assert ContextMasterProtocol.call_args_list == [((person,),)]
+
+        state = person.enter_request(USER2_UNI)
+        assert state == VARIABLES
+        assert cm.method_calls == [('add_member', (USER2_UNI,))]
+
+    def test_enter_context_entry_denied(self):
+        person = Person(self.entity)
+        person.register('')
+
+        assert_raises(EntryDeniedError, person.enter_request, USER2_UNI)
+
+    def test_leave_context(self):
+        cm = self.entity.context_master = Mock()
+        person = Person(self.entity)
+
+        person.leave_context(USER2_UNI)
+        assert cm.method_calls == [('remove_member', (USER2_UNI,))]
+
+    @mockified('pypsyc.server.person', ['FriendshipProtocol'])
+    def test_client_presence(self, FriendshipProtocol):
+        friendship_protocol = FriendshipProtocol.return_value
+
+        person = Person(self.entity)
+        assert FriendshipProtocol.call_args_list == [((person,),)]
+
+        person.client_presence(ONLINE)
+        assert friendship_protocol.method_calls == [
+                ('cast_presence', (ONLINE,))]
+
+    @mockified('pypsyc.server.person', ['ContextSlave',
+                                        'ClientInterfaceProtocol'])
+    def test_client_subscribe(self, ContextSlave, ClientInterfaceProtocol):
+        context_slave = ContextSlave.return_value
+        person = Person(self.entity)
+        assert ContextSlave.call_args_list == [((person,),)]
+        assert ClientInterfaceProtocol.call_args_list == [((person,),)]
+
+        person.client_subscribe(PLACE_UNI, RESOURCE1_UNI)
+        assert context_slave.method_calls == [
+                ('enter', (PLACE_UNI, RESOURCE1_UNI))]
+
+    @mockified('pypsyc.server.person', ['ContextSlave'])
+    def test_client_unsubscribe(self, ContextSlave):
+        context_slave = ContextSlave.return_value
+        person = Person(self.entity)
+
+        person.client_unsubscribe(PLACE_UNI, RESOURCE1_UNI)
+        assert context_slave.method_calls == [
+                ('leave', (PLACE_UNI, RESOURCE1_UNI))]

mjacob2/tests/test_server/test_place.py

@@ -0,0 +1,68 @@
+"""
+    :copyright: 2010 by Manuel Jacob
+    :license: MIT
+"""
+from mock import Mock
+from tests.constants import (SERVER1, USER1_UNI, USER2_UNI, USER1_NICK,
+     RESOURCE1_UNI, RESOURCE2_UNI, PLACE, VARIABLES, MESSAGE)
+from tests.helpers import mockified
+
+from pypsyc.server import Entity
+from pypsyc.server.place import Place
+
+
+class TestPlace(object):
+    def setup(self):
+        self.server = Mock()
+        self.server.hostname = SERVER1
+
+        root = Entity(server=self.server)
+        self.entity = Entity(root, PLACE)
+        self.entity.context_master = Mock()
+
+    @mockified('pypsyc.server.place', ['ContextProtocol',
+                                       'ConferencingProtocol'])
+    def test_subscription(self, ContextProtocol, ConferencingProtocol):
+        conferencing_protocol = ConferencingProtocol.return_value
+        self.entity.context_master.add_member.return_value = VARIABLES
+
+        place = Place(self.entity)
+        assert ContextProtocol.call_args_list == [((place,),)]
+
+        state = place.enter_request(USER1_UNI)
+        assert state == VARIABLES
+        assert conferencing_protocol.method_calls == [
+                ('cast_member_entered', (USER1_UNI, USER1_NICK))]
+        assert self.entity.context_master.method_calls == [
+                ('add_member', (USER1_UNI,))]
+
+    @mockified('pypsyc.server.place', ['ConferencingProtocol'])
+    def test_leave(self, ConferencingProtocol):
+        conferencing_protocol = ConferencingProtocol.return_value
+        place = Place(self.entity)
+
+        place.enter_request(USER1_UNI)
+        self.entity.context_master.reset_mock()
+        conferencing_protocol.reset_mock()
+
+        place.leave_context(USER1_UNI)
+        assert self.entity.context_master.method_calls == [
+                ('remove_member', (USER1_UNI,))]
+        assert conferencing_protocol.method_calls == [
+                ('cast_member_left', (USER1_UNI,))]
+
+    @mockified('pypsyc.server.place', ['ConferencingProtocol'])
+    def test_public_message(self, ConferencingProtocol):
+        conferencing_protocol = ConferencingProtocol.return_value
+
+        place = Place(self.entity)
+        assert ConferencingProtocol.call_args_list == [((place,),)]
+        place.enter_request(USER1_UNI)
+        place.enter_request(USER2_UNI)
+        place.leave_context(USER2_UNI)
+        conferencing_protocol.reset_mock()
+
+        place.public_message(RESOURCE2_UNI, MESSAGE)
+        place.public_message(RESOURCE1_UNI, MESSAGE)
+        assert conferencing_protocol.method_calls == [
+                ('cast_public_message', (USER1_UNI, MESSAGE))]

mjacob2/tests/test_server/test_root.py

@@ -0,0 +1,21 @@
+"""
+    :copyright: 2010 by Manuel Jacob
+    :license: MIT
+"""
+from mock import Mock
+from tests.constants import SERVER1
+
+from pypsyc.server import Entity
+from pypsyc.server.root import Root
+
+
+class TestRoot(object):
+    def setup(self):
+        server = Mock()
+        server.hostname = SERVER1
+
+        root_entity = Entity(server=server)
+        self.root = Root(root_entity)
+
+    def test_root(self):
+        pass

mjacob2/tests/test_server/test_routing.py

@@ -0,0 +1,353 @@
+"""
+    :copyright: 2010 by Manuel Jacob
+    :license: MIT
+"""
+from mock import Mock
+from nose.tools import assert_raises
+from tests.constants import (SERVER1, SERVER2, SERVER1_UNI, SERVER2_UNI,
+     SERVER3_UNI, USER1, USER2, USER1_UNI, USER2_UNI, RESOURCE, RESOURCE1_UNI,
+     RESOURCE2_UNI, PLACE_UNI, INTERFACE, IP, PORT, CONTENT)
+from tests.helpers import (inited_header, connect_circuits, mockified,
+     AsyncMethod, PlaceHolder)
+
+from pypsyc.core.mmp import Uni
+from pypsyc.protocol import Error
+from pypsyc.server.routing import (InvalidTargetError, InvalidSourceError,
+     ServerCircuit, _TreeNode, Routing)
+from pypsyc.util import DNSError
+
+
+class TestServerCircuit(object):
+    def setup(self):
+        self.sc = ServerCircuit()
+        self.sc.factory = self.routing = Mock()
+        self.sc.psyc = Mock()
+        self.sc.allowed_sources.append(SERVER2_UNI)
+
+    def _send(self, header):
+        self.sc.packet_received(inited_header(header), CONTENT)
+
+    def test_withtarget(self):
+        HEADER1 = {'_target': SERVER1_UNI}
+        HEADER2 = {'_target': SERVER1_UNI, '_source': SERVER2_UNI}
+        HEADER3 = {'_target': SERVER1_UNI, '_source': SERVER3_UNI}
+
+        self._send(HEADER1)
+        assert self.routing.method_calls == [
+                ('route_singlecast', (HEADER1, CONTENT))]
+
+        self._send(HEADER2)
+        assert self.routing.method_calls == [
+                ('route_singlecast', (HEADER1, CONTENT)),
+                ('route_singlecast', (HEADER2, CONTENT))]
+
+        self._send(HEADER3)
+        assert self.routing.method_calls == [
+                ('route_singlecast', (HEADER1, CONTENT)),
+                ('route_singlecast', (HEADER2, CONTENT))]
+
+    def test_withouttarget(self):
+        HEADER1 = {}
+        HEADER2 = {'_source': SERVER2_UNI}
+        HEADER3 = {'_source': SERVER3_UNI}
+
+        self._send(HEADER1)
+        assert self.routing.method_calls == []
+        assert self.sc.psyc.method_calls == [
+                ('handle_packet', (HEADER1, CONTENT))]
+
+        self._send(HEADER2)
+        assert self.routing.method_calls == []
+        assert self.sc.psyc.method_calls == [
+                ('handle_packet', (HEADER1, CONTENT)),
+                ('handle_packet', (HEADER2, CONTENT))]
+
+        self._send(HEADER3)
+        assert self.routing.method_calls == []
+        assert self.sc.psyc.method_calls == [
+                ('handle_packet', (HEADER1, CONTENT)),
+                ('handle_packet', (HEADER2, CONTENT))]
+
+    def test_context(self):
+        HEADER1 = {'_context': PLACE_UNI}
+        HEADER2 = {'_context': PLACE_UNI, '_target': USER1_UNI}
+
+        self._send(HEADER1)
+        assert self.routing.method_calls == [
+                ('route_multicast', (HEADER1, CONTENT))]
+
+        self._send(HEADER2)
+        assert self.routing.method_calls == [
+                ('route_multicast', (HEADER1, CONTENT)),
+                ('route_singlecast', (HEADER2, CONTENT))]
+
+    def test_context_withsource(self):
+        HEADER1 = {'_context': PLACE_UNI, '_source': USER1_UNI}
+        HEADER2 = {'_context': PLACE_UNI, '_source': USER2_UNI,
+                   '_target': USER1_UNI}
+
+        assert_raises(NotImplementedError, self._send, HEADER1)
+        assert self.routing.method_calls == []
+
+        assert_raises(NotImplementedError, self._send, HEADER2)
+        assert self.routing.method_calls == []
+
+    def test_verification(self):
+        sc1, sc2 = connect_circuits(ServerCircuit(), ServerCircuit())
+        sc2.factory = Mock()
+
+        sc1.request_verification(SERVER1_UNI, SERVER2_UNI)
+        assert sc2.factory.method_calls == [
+                ('verify_address', (sc2, SERVER1_UNI, SERVER2_UNI))]
+        assert type(sc2.factory.method_calls[0][1][1]) is Uni
+        assert sc1.allowed_sources == [SERVER2_UNI]
+        assert sc2.allowed_sources == [SERVER1_UNI]
+        assert type(sc2.allowed_sources[0]) is Uni
+
+    def test_verification_invalid_source(self):
+        sc1, sc2 = connect_circuits(ServerCircuit(), ServerCircuit())
+        sc2.factory = Mock()
+        sc2.factory.verify_address.side_effect = InvalidSourceError
+
+        assert_raises(InvalidSourceError, sc1.request_verification,
+                      SERVER1_UNI, SERVER2_UNI)
+        assert sc1.allowed_sources == []
+        assert sc2.allowed_sources == []
+
+    def test_verification_invalid_target(self):
+        sc1, sc2 = connect_circuits(ServerCircuit(), ServerCircuit())
+        sc2.factory = Mock()
+        sc2.factory.verify_address.side_effect = InvalidTargetError
+
+        assert_raises(InvalidTargetError, sc1.request_verification,
+                      SERVER1_UNI, SERVER2_UNI)
+        assert sc1.allowed_sources == []
+        assert sc2.allowed_sources == []
+
+    def test_connection_lost(self):
+        root = self.routing.root = _TreeNode()
+        person = Mock()
+        person_entity = _TreeNode(root, USER1)
+        person_entity.packages = {'person': person}
+        self.sc.allowed_sources.append(RESOURCE1_UNI)
+
+        self.routing.srouting_table = {SERVER2: Mock()}
+        self.sc.connectionLost(None)
+        assert self.routing.srouting_table == {}
+        assert person.method_calls == [('unlink', (RESOURCE,))]
+
+
+def test_treenode():
+    root = _TreeNode()
+    assert root._root == root
+
+    n1 = _TreeNode(root, 'n1')
+    assert root.children == {'n1': n1}
+    assert n1._parent == root
+    assert n1._root == root
+
+    n2 = _TreeNode(n1, 'n2')
+    assert n1.children == {'n2': n2}
+    assert n2._parent == n1
+    assert n2._root == root
+
+
+class StubEntity(_TreeNode):
+    def __init__(self, *args, **kwds):
+        _TreeNode.__init__(self, *args, **kwds)
+        self.headers = []
+
+    def handle_packet(self, header, contents):
+        self.headers.append(header)
+
+EXTERN_HEADER = {'_source': USER1_UNI, '_target': SERVER2_UNI}
+
+class TestRouting(object):
+    def test_sroute_local(self):
+        HEADER1 = {'_target': SERVER1_UNI}
+        HEADER2 = {'_target': USER1_UNI}
+        HEADER3 = {'_target': RESOURCE2_UNI}
+
+        root = StubEntity()
+        user1 = StubEntity(root, USER1)
+        user2 = StubEntity(root, USER2)
+        home = StubEntity(user2, RESOURCE)
+        routing = Routing(SERVER1, INTERFACE)
+        routing.init(root)
+
+        routing.route_singlecast(inited_header(HEADER1), CONTENT)
+        routing.route_singlecast(inited_header(HEADER2), CONTENT)
+        routing.route_singlecast(inited_header(HEADER3), CONTENT)
+        assert root.headers == [HEADER1]
+        assert user1.headers == [HEADER2]
+        assert user2.headers == []
+        assert home.headers == [HEADER3]
+
+    def test_sroute_unkown_target(self):
+        HEADER1 = inited_header({'_source': USER1_UNI, '_target': USER2_UNI})
+        HEADER2 = inited_header({'_target': USER2_UNI, '_tag': 'tag'})
+        KWDS = {'mc': '_error_unknown_target', '_uni': USER2_UNI, 'data': None}
+
+        root = StubEntity()
+        root.sendmsg = Mock()
+        routing = Routing(SERVER1, INTERFACE)
+        routing.init(root)
+
+        routing.route_singlecast(HEADER1, CONTENT)
+        routing.route_singlecast(HEADER2, CONTENT)
+        assert root.sendmsg.call_args_list == [
+                ((USER1_UNI, None, None), KWDS),
+                ((None, None, {'_tag_relay': 'tag'}), KWDS)]
+        assert root.headers == []
+
+    def test_sroute_extern(self):
+        routing = Routing(SERVER1, INTERFACE)
+        circuit = routing.srouting_table[SERVER2] = Mock()
+
+        routing.route_singlecast(inited_header(EXTERN_HEADER), CONTENT)
+        assert circuit.method_calls == [(('send'), (EXTERN_HEADER, CONTENT))]
+
+    @mockified('pypsyc.server.routing', ['resolve_hostname', 'connect'])
+    def test_sroute_extern_queued(self, resolve_hostname, connect):
+        resolve_hostname.return_value = IP, PORT
+        connected = connect.side_effect = AsyncMethod()
+        root = Mock()
+        root.uni = SERVER1_UNI
+        routing = Routing(SERVER1, INTERFACE)
+        routing.init(root)
+
+        routing.route_singlecast(inited_header(EXTERN_HEADER), CONTENT)
+        routing.route_singlecast(inited_header(EXTERN_HEADER), CONTENT)
+        assert connect.call_args_list == [
+                ((IP, PORT, routing), {'bindAddress': (INTERFACE, 0)})]
+
+        circuit = Mock()
+        connected.callback(circuit)
+        assert circuit.method_calls == [
+                ('request_verification', (SERVER1_UNI, SERVER2_UNI)),
+                ('send', (EXTERN_HEADER, CONTENT)),
+                ('send', (EXTERN_HEADER, CONTENT))]
+        assert type(circuit.method_calls[0][1][1]) is Uni
+        assert routing.srouting_table == {SERVER2: circuit}
+        assert routing.queues == {}
+
+    @mockified('pypsyc.server.routing', ['resolve_hostname'])
+    def test_sroute_extern_resolution_fail(self, resolve_hostname):
+        KWDS = {'mc': '_failure_unsuccessful_delivery', '_uni': SERVER2_UNI}
+        resolved = resolve_hostname.side_effect = AsyncMethod()
+        data_ph = KWDS['data'] = PlaceHolder()
+        root = Mock()
+        routing = Routing(SERVER1, INTERFACE)
+        routing.init(root)
+
+        routing.route_singlecast(inited_header(EXTERN_HEADER), CONTENT)
+        routing.route_singlecast(inited_header(EXTERN_HEADER), CONTENT)
+        resolved.errback(DNSError)
+        assert root.method_calls == [
+                ('sendmsg', (USER1_UNI, None, None), KWDS)] * 2
+        assert 'resolve' in data_ph.obj
+        assert routing.queues == {}
+
+    @mockified('pypsyc.server.routing', ['resolve_hostname', 'connect'])
+    def test_sroute_extern_connection_fail(self, resolve_hostname, connect):
+        KWDS = {'mc': '_failure_unsuccessful_delivery', '_uni': SERVER2_UNI}
+        resolve_hostname.return_value = None, None
+        connected = connect.side_effect = AsyncMethod()
+        data_ph = KWDS['data'] = PlaceHolder()
+        root = Mock()
+        routing = Routing(SERVER1, INTERFACE)
+        routing.init(root)
+
+        routing.route_singlecast(inited_header(EXTERN_HEADER), CONTENT)
+        connected.errback(Exception('error'))
+        assert root.method_calls == [
+                ('sendmsg', (USER1_UNI, None, None), KWDS)]
+        assert 'connect' in data_ph.obj
+        assert routing.queues == {}
+
+    @mockified('pypsyc.server.routing', ['resolve_hostname', 'connect'])
+    def test_sroute_extern_verification_fail(self, resolve_hostname, connect):
+        KWDS = {'mc': '_failure_unsuccessful_delivery', '_uni': SERVER2_UNI}
+        resolve_hostname.return_value = None, None
+        circuit = connect.return_value
+        verified = circuit.request_verification.side_effect = AsyncMethod()
+        data_ph = KWDS['data'] = PlaceHolder()
+        root = Mock()
+        routing = Routing(SERVER1, INTERFACE)
+        routing.init(root)
+
+        routing.route_singlecast(inited_header(EXTERN_HEADER), CONTENT)
+        verified.errback(Error)
+        assert root.method_calls == [
+                ('sendmsg', (USER1_UNI, None, None), KWDS)]
+        assert 'verify' in data_ph.obj
+        assert routing.queues == {}
+
+    @mockified('pypsyc.server.routing', ['resolve_hostname', 'connect'])
+    def test_sroute_extern_no_source(self, resolve_hostname, connect):
+        header = inited_header({'_target': SERVER2_UNI})
+        header.source = Mock()
+        routing = Routing(SERVER1, INTERFACE)
+
+        routing.route_singlecast(header, CONTENT)
+        header['_source'] = ''
+        routing.route_singlecast(header, CONTENT)
+        assert resolve_hostname.call_args_list == []
+        assert connect.call_args_list == []
+        assert routing.srouting_table == {}
+        assert routing.queues == {}
+
+    def test_mroute(self):
+        HEADER = {'_context': PLACE_UNI}
+        circuit1 = Mock()
+        circuit2 = Mock()
+        routing = Routing(SERVER1, INTERFACE)
+        routing.mrouting_table[PLACE_UNI] = [circuit1, circuit2]
+
+        routing.route_multicast(inited_header(HEADER), iter(CONTENT))
+        assert circuit1.method_calls == [('send', (HEADER, CONTENT))]
+        assert circuit2.method_calls == [('send', (HEADER, CONTENT))]
+
+    @mockified('pypsyc.server.routing', ['reactor'])
+    def test_listen(self, reactor):
+        routing = Routing(SERVER1, INTERFACE)
+        routing.listen(PORT)
+        assert reactor.method_calls == [
+                ('listenTCP', (PORT, routing), {'interface': INTERFACE})]
+
+    def _setup_verification(self):
+        root = Mock()
+        root.uni = SERVER1_UNI
+        routing = Routing(SERVER1, INTERFACE)
+        routing.init(root)
+        circuit = Mock()
+        circuit.transport.client = IP, 35771
+        return routing, circuit
+
+    @mockified('pypsyc.server.routing', ['resolve_hostname'])
+    def test_verification(self, resolve_hostname):
+        resolve_hostname.return_value = IP, PORT
+        routing, circuit = self._setup_verification()
+
+        routing.verify_address(circuit, SERVER2_UNI, SERVER1_UNI)
+        assert resolve_hostname.call_args_list == [((SERVER2,),)]
+        assert routing.srouting_table == {SERVER2: circuit}
+
+    @mockified('pypsyc.server.routing', ['resolve_hostname'])
+    def test_verification_invalid_target(self, resolve_hostname):
+        routing, circuit = self._setup_verification()
+
+        assert_raises(InvalidTargetError, routing.verify_address,
+                      circuit, SERVER2_UNI, SERVER3_UNI)
+        assert resolve_hostname.call_args_list == []
+        assert routing.srouting_table == {}
+
+    @mockified('pypsyc.server.routing', ['resolve_hostname'])
+    def test_verification_invalid_source(self, resolve_hostname):
+        resolve_hostname.return_value = '10.0.0.2', PORT
+        routing, circuit = self._setup_verification()
+
+        assert_raises(InvalidSourceError, routing.verify_address,
+                      circuit, SERVER2_UNI, SERVER1_UNI)
+        assert resolve_hostname.call_args_list == [((SERVER2,),)]
+        assert routing.srouting_table == {}

mjacob2/tests/test_server/test_server.py

@@ -0,0 +1,134 @@
+"""
+    :copyright: 2010 by Manuel Jacob
+    :license: MIT
+"""
+from contextlib import contextmanager
+
+from mock import Mock
+from nose.tools import assert_raises
+from tests.constants import (SERVER1, SERVER1_UNI, USER1, USER1_UNI, PLACE,
+     INTERFACE, PORT, PASSWORD)
+from tests.helpers import mockified, rendered, AsyncMethod
+
+from pypsyc.core.psyc import PSYCPacket
+from pypsyc.server import Entity, Server
+from pypsyc.server.routing import _TreeNode
+
+
+class TestEntity(object):
+    def setup(self):
+        self.server = Mock()
+        self.server.hostname = SERVER1
+        self.entity = Entity(server=self.server)
+
+    def test_uni(self):
+        assert self.entity.uni == SERVER1_UNI
+        assert Entity(self.entity, USER1).uni == USER1_UNI
+
+    def test_castmsg(self):
+        HEADER = {'_context': self.entity.uni}
+        PACKET = PSYCPacket(mc='_message_public', data="Hello")
+
+        self.entity.castmsg(PACKET)
+        assert self.server.routing.method_calls == [
+                ('route_multicast', (HEADER, rendered(PACKET)))]
+
+    def test_castmsg_kwds(self):
+        HEADER = {'_context': self.entity.uni}
+        PACKET = PSYCPacket(mc='_message_public', data="Hello")
+
+        self.entity.castmsg(mc='_message_public', data="Hello")
+        assert self.server.routing.method_calls == [
+                ('route_multicast', (HEADER, rendered(PACKET)))]
+
+
+def StubEntity(*args, **kwds):
+    entity = _TreeNode(*args, **kwds)
+    entity.packages = {}
+    return entity
+
+class TestServer(object):
+    @mockified('pypsyc.server', ['Routing', 'Entity', 'run_webif', 'signal'])
+    def test_server1(self, Routing, Entity, run_webif, signal):
+        WEBIF_PORT = 8080
+        routing = Routing.return_value
+        root = Entity.return_value = StubEntity()
+        run_webif.side_effect = AsyncMethod()
+
+        server = Server(SERVER1, INTERFACE, PORT, WEBIF_PORT, ':memory:')
+        assert Routing.call_args_list == [((SERVER1, INTERFACE),)]
+        assert Entity.call_args_list == [({'server': server},)]
+        assert routing.method_calls == [('init', (root,)), ('listen', (PORT,))]
+        assert run_webif.call_args_list == [
+                ((server, INTERFACE, WEBIF_PORT, None),)]
+        assert signal.signal.called
+
+        with mockified('pypsyc.server', ['iter_entry_points', 'Entity']) as x:
+            with self._test_load_package(root, *x) as packages:
+                assert server.add_package(None, 'package') == packages[0]
+                assert server.add_place('place') == packages[1]
+                assert server.add_package(PLACE, 'package') == packages[2]
+                assert server.add_package(USER1, 'package') == packages[3]
+                person = server.register_person('user1', PASSWORD)
+                assert person == packages[4]
+                assert person.method_calls == [('register', (PASSWORD,))]
+        assert_raises(AssertionError, server.add_package, None, 'package')
+
+        self._test_server2(server.database)
+
+    @mockified('pypsyc.server', ['Routing', 'Entity', 'Database', 'run_webif'])
+    def _test_server2(self, database, Routing, Entity, Database, run_webif):
+        routing = Routing.return_value
+        root = Entity.return_value = StubEntity()
+        Database.return_value = database
+        executed = database.execute = AsyncMethod()
+
+        server = Server(SERVER1, INTERFACE, 0, 0, ':memory:')
+        assert routing.method_calls == [('init', (root,))]
+        assert run_webif.call_args_list == []
+
+        with mockified('pypsyc.server', ['iter_entry_points', 'Entity']) as x:
+            with self._test_load_package(root, *x):
+                executed.callback()
+        assert_raises(AssertionError, server.add_package, None, 'package1')
+
+    @contextmanager
+    def _test_load_package(self, root, iter_entry_points, Entity):
+        package_classes = [Mock(), Mock(), Mock(), Mock(), Mock()]
+        entrypoint = Mock()
+        entrypoint.load.side_effect = iter(package_classes).next
+        iter_entry_points.return_value = [entrypoint]
+        Entity.side_effect = StubEntity
+
+        packages = [package.return_value for package in package_classes]
+        yield packages
+        assert Entity.call_args_list == [((root, PLACE),), ((root, USER1),)]
+        assert iter_entry_points.call_args_list == [
+                (('pypsyc.server.packages', 'package'),),
+                (('pypsyc.server.packages', 'place'),),
+                (('pypsyc.server.packages', 'package'),),
+                (('pypsyc.server.packages', 'package'),),
+                (('pypsyc.server.packages', 'person'),)]
+        place = root.children[PLACE]
+        person = root.children[USER1]
+        assert package_classes[0].call_args_list == [((root,),)]
+        assert package_classes[1].call_args_list == [((place,),)]
+        assert package_classes[2].call_args_list == [((place,),)]
+        assert package_classes[3].call_args_list == [((person,),)]
+        assert package_classes[4].call_args_list == [((person,),)]
+        assert root.packages == {'package': packages[0]}
+        assert place.packages == {'place': packages[1], 'package': packages[2]}
+        assert person.packages == {'package': packages[3],
+                                   'person': packages[4]}
+
+    @mockified('pypsyc.server', ['Routing', 'Entity', 'Database', 'signal',
+                                 'reactor'])
+    def test_shutdown(self, Routing, Entity, Database, signal, reactor):
+        database = Database.return_value
+        database.fetch.return_value = ()
+        server = Server(SERVER1, INTERFACE, 0, 0, ':memory')
+        database.reset_mock()
+
+        server.shutdown()
+        assert database.method_calls == [('stop',)]
+        assert reactor.method_calls == [('stop',)]

mjacob2/tests/test_server/test_webif/test_webif.py

@@ -0,0 +1,139 @@
+"""
+    :copyright: 2010 by Manuel Jacob
+    :license: MIT
+"""
+from mock import Mock, sentinel
+from nose.tools import assert_raises
+from tests.constants import USER1, USER1_NICK, PASSWORD
+from tests.helpers import mockified, PlaceHolder
+
+from pypsyc.server import webif
+from pypsyc.server.db import Database
+from pypsyc.server.webif import app, PersistentStore, run_webif
+
+
+class TestViews(object):
+    @classmethod
+    def setup_class(cls):
+        app.secret_key = 'testing key'
+
+    def setup(self):
+        self.server = webif.server = Mock()
+        self.server.root.children = {}
+        self.client = app.test_client()
+
+    def test_index(self):
+        rv = self.client.get('/')
+        assert 'register' in rv.data
+
+    def _register(self, username, password, password2):
+        return self.client.post('/register', data=dict(
+                username=username, password=password, password2=password2
+        ), follow_redirects=True)
+
+    def test_register_get(self):
+        rv = self.client.get('/register')
+        assert 'Username' in rv.data
+        assert 'Register' in rv.data
+
+    def test_register_post(self):
+        rv = self._register(USER1_NICK, PASSWORD, PASSWORD)
+        assert 'you were registered' in rv.data
+        assert self.server.method_calls == [
+                ('register_person', (USER1_NICK, PASSWORD))]
+
+    def test_register_nousername(self):
+        rv = self._register('', '', '')
+        assert 'please specify a valid username' in rv.data
+
+    def test_register_username_inuse(self):
+        self.server.root.children = {USER1: True}
+
+        rv = self._register(USER1_NICK, '', '')
+        assert 'username already in use' in rv.data
+
+    def test_register_nopassword(self):
+        rv = self._register(USER1_NICK, '', '')
+        assert 'your password must have at least 6 characters' in rv.data
+
+    def test_register_shortpassword(self):
+        rv = self._register(USER1_NICK, 'passw', 'passw')
+        assert 'your password must have at least 6 characters' in rv.data
+
+    def test_register_unmatching_passwords(self):
+        rv = self._register(USER1_NICK, PASSWORD, 'password2')
+        assert 'the two passwords do not match' in rv.data
+
+
+def test_persistent_store():
+    webif.server = Mock()
+    webif.server.database = Database(':memory:')
+
+    store = PersistentStore()
+    assert_raises(KeyError, store.__getitem__, 'key')
+    assert dict(store) == {}
+    assert len(store) == 0
+
+    store['key'] = 'value'
+    assert store['key'] == 'value'
+    assert len(store) == 1
+
+    store['key'] = 'value2'
+    assert dict(store) == {'key': 'value2'}
+    assert len(store) == 1
+
+    del store['key']
+    assert dict(store) == {}
+    assert len(store) == 0
+
+
+@mockified('pypsyc.server.webif', ['PersistentStore', 'urandom',
+                                   'WSGIResource', 'Site', 'reactor',
+                                   'greenlet'])
+def test_run_webif_ssl(PersistentStore, urandom, WSGIResource, Site, reactor,
+                       greenlet):
+    store = PersistentStore.return_value = {'secret_key': 'key1'*5}
+    reactor_ph = PlaceHolder()
+    threadpool_ph = PlaceHolder()
+    wsgi_resource = WSGIResource.return_value
+    site = Site.return_value
+
+    run_webif(sentinel.server, sentinel.interface, sentinel.port,
+              sentinel.context_factory)
+    assert webif.server == sentinel.server
+    assert PersistentStore.call_args_list == [()]
+    assert webif.store == store
+    assert app.secret_key == 'key1'*5
+    assert not urandom.called
+    assert WSGIResource.call_args_list == [
+            ((reactor_ph, threadpool_ph, app.wsgi_app),)]
+    assert Site.call_args_list == [((wsgi_resource,),)]
+    assert reactor.method_calls == [
+            ('listenSSL', (sentinel.port, site, sentinel.context_factory),
+             {'interface': sentinel.interface})]
+
+    func = Mock()
+    reactor_ph.obj.callFromThread(func, sentinel.a, b=sentinel.b)
+    assert func.call_args_list == [((sentinel.a,), {'b': sentinel.b})]
+
+    threadpool_ph.obj.callInThread(sentinel.func, sentinel.a, b=sentinel.b)
+    assert greenlet.call_args_list == [((sentinel.func,),)]
+    assert greenlet.return_value.method_calls == [
+            ('switch', (sentinel.a,), {'b': sentinel.b})]
+
+
+@mockified('pypsyc.server.webif', ['PersistentStore', 'urandom',
+                                   'WSGIResource', 'Site', 'reactor'])
+def test_run_webif_tcp(PersistentStore, urandom, WSGIResource, Site, reactor):
+    store = PersistentStore.return_value = {}
+    rand = urandom.return_value = 'key2'*5
+    wsgi_resource = WSGIResource.return_value
+    site = Site.return_value
+
+    run_webif(sentinel.server, sentinel.interface, sentinel.port, None)
+    assert urandom.call_args_list == [((20,),)]
+    assert app.secret_key == rand
+    assert store['secret_key'] == rand
+    assert Site.call_args_list == [((wsgi_resource,),)]
+    assert reactor.method_calls == [
+            ('listenTCP', (sentinel.port, site), {'interface': 'localhost'})]