From 6081f4947e9c4d7dfbdaf6439e662b173d309a8e Mon Sep 17 00:00:00 2001 From: "Paul \"LeoNerd\" Evans" Date: Wed, 10 Sep 2014 16:42:31 +0100 Subject: Tiny trivial PoC unit-test using SQLite in :memory: mode --- tests/storage/test_profile.py | 78 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 78 insertions(+) create mode 100644 tests/storage/test_profile.py (limited to 'tests/storage') diff --git a/tests/storage/test_profile.py b/tests/storage/test_profile.py new file mode 100644 index 0000000000..fff0a8c4fd --- /dev/null +++ b/tests/storage/test_profile.py @@ -0,0 +1,78 @@ +# -*- coding: utf-8 -*- +# Copyright 2014 OpenMarket Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +from twisted.trial import unittest +from twisted.internet import defer + +from mock import Mock, call +from twisted.enterprise.adbapi import ConnectionPool + +from synapse.server import HomeServer +from synapse.storage import prepare_database +from synapse.storage.profile import ProfileStore + + +class SQLiteMemoryDbPool(ConnectionPool, object): + def __init__(self): + super(SQLiteMemoryDbPool, self).__init__( + "sqlite3", ":memory:", + cp_min=1, + cp_max=1, + ) + + def prepare(self): + return self.runWithConnection(prepare_database) + + #def runInteraction(self, interaction, *args, **kwargs): + # # Just use a cursor as the txn directly + # txn = self.db.cursor() + + # def _on_success(result): + # txn.commit() + # return result + # def _on_failure(failure): + # txn.rollback() + # raise failure + + # d = interaction(txn, *args, **kwargs) + # d.addCallbacks(_on_success, _on_failure) + # return d + + +class ProfileStoreTestCase(unittest.TestCase): + def setUp(self): + hs = HomeServer("test", + db_pool=SQLiteMemoryDbPool(), + ) + hs.get_db_pool().prepare() + + self.store = ProfileStore(hs) + + self.u_frank = hs.parse_userid("@frank:test") + + @defer.inlineCallbacks + def test_displayname(self): + yield self.store.create_profile( + self.u_frank.localpart + ) + + yield self.store.set_profile_displayname( + self.u_frank.localpart, "Frank" + ) + + name = yield self.store.get_profile_displayname(self.u_frank.localpart) + + self.assertEquals("Frank", name) -- cgit 1.4.1 From 53d0f69dc3b4a3f19f9e48c63a5dbc704b944c0c Mon Sep 17 00:00:00 2001 From: "Paul \"LeoNerd\" Evans" Date: Wed, 10 Sep 2014 16:49:34 +0100 Subject: Also test avatar_url profile field --- tests/storage/test_profile.py | 14 ++++++++++++++ 1 file changed, 14 insertions(+) (limited to 'tests/storage') diff --git a/tests/storage/test_profile.py b/tests/storage/test_profile.py index fff0a8c4fd..bca056b295 100644 --- a/tests/storage/test_profile.py +++ b/tests/storage/test_profile.py @@ -76,3 +76,17 @@ class ProfileStoreTestCase(unittest.TestCase): name = yield self.store.get_profile_displayname(self.u_frank.localpart) self.assertEquals("Frank", name) + + @defer.inlineCallbacks + def test_avatar_url(self): + yield self.store.create_profile( + self.u_frank.localpart + ) + + yield self.store.set_profile_avatar_url( + self.u_frank.localpart, "http://my.site/here" + ) + + name = yield self.store.get_profile_avatar_url(self.u_frank.localpart) + + self.assertEquals("http://my.site/here", name) -- cgit 1.4.1 From 9774949cc989e2a24e2e8070bb4bd299335891ab Mon Sep 17 00:00:00 2001 From: "Paul \"LeoNerd\" Evans" Date: Wed, 10 Sep 2014 16:50:09 +0100 Subject: It's considered polite to actually wait for DB prepare before running tests --- tests/storage/test_profile.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) (limited to 'tests/storage') diff --git a/tests/storage/test_profile.py b/tests/storage/test_profile.py index bca056b295..45c69dafae 100644 --- a/tests/storage/test_profile.py +++ b/tests/storage/test_profile.py @@ -53,11 +53,14 @@ class SQLiteMemoryDbPool(ConnectionPool, object): class ProfileStoreTestCase(unittest.TestCase): + + @defer.inlineCallbacks def setUp(self): hs = HomeServer("test", db_pool=SQLiteMemoryDbPool(), ) - hs.get_db_pool().prepare() + + yield hs.get_db_pool().prepare() self.store = ProfileStore(hs) -- cgit 1.4.1 From 08f5c48fc81753ac29d4f76080a44bcd5aa52ece Mon Sep 17 00:00:00 2001 From: "Paul \"LeoNerd\" Evans" Date: Wed, 10 Sep 2014 16:56:02 +0100 Subject: Move SQLiteMemoryDbPool implementation into tests.utils --- tests/storage/test_profile.py | 28 +--------------------------- tests/utils.py | 14 ++++++++++++++ 2 files changed, 15 insertions(+), 27 deletions(-) (limited to 'tests/storage') diff --git a/tests/storage/test_profile.py b/tests/storage/test_profile.py index 45c69dafae..82e0c33be7 100644 --- a/tests/storage/test_profile.py +++ b/tests/storage/test_profile.py @@ -18,38 +18,12 @@ from twisted.trial import unittest from twisted.internet import defer from mock import Mock, call -from twisted.enterprise.adbapi import ConnectionPool from synapse.server import HomeServer from synapse.storage import prepare_database from synapse.storage.profile import ProfileStore - -class SQLiteMemoryDbPool(ConnectionPool, object): - def __init__(self): - super(SQLiteMemoryDbPool, self).__init__( - "sqlite3", ":memory:", - cp_min=1, - cp_max=1, - ) - - def prepare(self): - return self.runWithConnection(prepare_database) - - #def runInteraction(self, interaction, *args, **kwargs): - # # Just use a cursor as the txn directly - # txn = self.db.cursor() - - # def _on_success(result): - # txn.commit() - # return result - # def _on_failure(failure): - # txn.rollback() - # raise failure - - # d = interaction(txn, *args, **kwargs) - # d.addCallbacks(_on_success, _on_failure) - # return d +from tests.utils import SQLiteMemoryDbPool class ProfileStoreTestCase(unittest.TestCase): diff --git a/tests/utils.py b/tests/utils.py index d90214e418..bc5d35e56b 100644 --- a/tests/utils.py +++ b/tests/utils.py @@ -16,12 +16,14 @@ from synapse.http.server import HttpServer from synapse.api.errors import cs_error, CodeMessageException, StoreError from synapse.api.constants import Membership +from synapse.storage import prepare_database from synapse.api.events.room import ( RoomMemberEvent, MessageEvent ) from twisted.internet import defer, reactor +from twisted.enterprise.adbapi import ConnectionPool from collections import namedtuple from mock import patch, Mock @@ -120,6 +122,18 @@ class MockClock(object): self.now += secs +class SQLiteMemoryDbPool(ConnectionPool, object): + def __init__(self): + super(SQLiteMemoryDbPool, self).__init__( + "sqlite3", ":memory:", + cp_min=1, + cp_max=1, + ) + + def prepare(self): + return self.runWithConnection(prepare_database) + + class MemoryDataStore(object): Room = namedtuple( -- cgit 1.4.1 From dc7f39677f19be9f53054e97e095055166836acc Mon Sep 17 00:00:00 2001 From: "Paul \"LeoNerd\" Evans" Date: Wed, 10 Sep 2014 16:56:52 +0100 Subject: Remember to kill now-dead import in test_profile.py --- tests/storage/test_profile.py | 1 - 1 file changed, 1 deletion(-) (limited to 'tests/storage') diff --git a/tests/storage/test_profile.py b/tests/storage/test_profile.py index 82e0c33be7..7e082091b3 100644 --- a/tests/storage/test_profile.py +++ b/tests/storage/test_profile.py @@ -20,7 +20,6 @@ from twisted.internet import defer from mock import Mock, call from synapse.server import HomeServer -from synapse.storage import prepare_database from synapse.storage.profile import ProfileStore from tests.utils import SQLiteMemoryDbPool -- cgit 1.4.1 From dd1a9100c5eae1b2a55893de0f3e13b2877dfc77 Mon Sep 17 00:00:00 2001 From: "Paul \"LeoNerd\" Evans" Date: Wed, 10 Sep 2014 17:51:05 +0100 Subject: Added unit tests for PresenceDataStore too --- tests/storage/test_presence.py | 166 +++++++++++++++++++++++++++++++++++++++++ tests/storage/test_profile.py | 2 - 2 files changed, 166 insertions(+), 2 deletions(-) create mode 100644 tests/storage/test_presence.py (limited to 'tests/storage') diff --git a/tests/storage/test_presence.py b/tests/storage/test_presence.py new file mode 100644 index 0000000000..f0a04ae830 --- /dev/null +++ b/tests/storage/test_presence.py @@ -0,0 +1,166 @@ +# -*- coding: utf-8 -*- +# Copyright 2014 OpenMarket Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +from twisted.trial import unittest +from twisted.internet import defer + +from synapse.server import HomeServer +from synapse.storage.presence import PresenceStore + +from tests.utils import SQLiteMemoryDbPool, MockClock + + +class PresenceStoreTestCase(unittest.TestCase): + + @defer.inlineCallbacks + def setUp(self): + hs = HomeServer("test", + clock=MockClock(), + db_pool=SQLiteMemoryDbPool(), + ) + + yield hs.get_db_pool().prepare() + + self.store = PresenceStore(hs) + + self.u_apple = hs.parse_userid("@apple:test") + self.u_banana = hs.parse_userid("@banana:test") + + @defer.inlineCallbacks + def test_state(self): + yield self.store.create_presence( + self.u_apple.localpart + ) + + state = yield self.store.get_presence_state( + self.u_apple.localpart + ) + + self.assertEquals( + {"state": None, "status_msg": None, "mtime": None}, state + ) + + yield self.store.set_presence_state( + self.u_apple.localpart, {"state": "online", "status_msg": "Here"} + ) + + state = yield self.store.get_presence_state( + self.u_apple.localpart + ) + + self.assertEquals( + {"state": "online", "status_msg": "Here", "mtime": 1000000}, state + ) + + @defer.inlineCallbacks + def test_visibility(self): + self.assertFalse((yield self.store.is_presence_visible( + observed_localpart=self.u_apple.localpart, + observer_userid=self.u_banana.to_string(), + ))) + + yield self.store.allow_presence_visible( + observed_localpart=self.u_apple.localpart, + observer_userid=self.u_banana.to_string(), + ) + + self.assertTrue((yield self.store.is_presence_visible( + observed_localpart=self.u_apple.localpart, + observer_userid=self.u_banana.to_string(), + ))) + + yield self.store.disallow_presence_visible( + observed_localpart=self.u_apple.localpart, + observer_userid=self.u_banana.to_string(), + ) + + self.assertFalse((yield self.store.is_presence_visible( + observed_localpart=self.u_apple.localpart, + observer_userid=self.u_banana.to_string(), + ))) + + @defer.inlineCallbacks + def test_presence_list(self): + self.assertEquals( + [], + (yield self.store.get_presence_list( + observer_localpart=self.u_apple.localpart, + )) + ) + self.assertEquals( + [], + (yield self.store.get_presence_list( + observer_localpart=self.u_apple.localpart, + accepted=True, + )) + ) + + yield self.store.add_presence_list_pending( + observer_localpart=self.u_apple.localpart, + observed_userid=self.u_banana.to_string(), + ) + + self.assertEquals( + [{"observed_user_id": "@banana:test", "accepted": 0}], + (yield self.store.get_presence_list( + observer_localpart=self.u_apple.localpart, + )) + ) + self.assertEquals( + [], + (yield self.store.get_presence_list( + observer_localpart=self.u_apple.localpart, + accepted=True, + )) + ) + + yield self.store.set_presence_list_accepted( + observer_localpart=self.u_apple.localpart, + observed_userid=self.u_banana.to_string(), + ) + + self.assertEquals( + [{"observed_user_id": "@banana:test", "accepted": 1}], + (yield self.store.get_presence_list( + observer_localpart=self.u_apple.localpart, + )) + ) + self.assertEquals( + [{"observed_user_id": "@banana:test", "accepted": 1}], + (yield self.store.get_presence_list( + observer_localpart=self.u_apple.localpart, + accepted=True, + )) + ) + + yield self.store.del_presence_list( + observer_localpart=self.u_apple.localpart, + observed_userid=self.u_banana.to_string(), + ) + + self.assertEquals( + [], + (yield self.store.get_presence_list( + observer_localpart=self.u_apple.localpart, + )) + ) + self.assertEquals( + [], + (yield self.store.get_presence_list( + observer_localpart=self.u_apple.localpart, + accepted=True, + )) + ) diff --git a/tests/storage/test_profile.py b/tests/storage/test_profile.py index 7e082091b3..fa96abf03b 100644 --- a/tests/storage/test_profile.py +++ b/tests/storage/test_profile.py @@ -17,8 +17,6 @@ from twisted.trial import unittest from twisted.internet import defer -from mock import Mock, call - from synapse.server import HomeServer from synapse.storage.profile import ProfileStore -- cgit 1.4.1 From d83202b938a67cc3120efb7b77e607d5584ad31c Mon Sep 17 00:00:00 2001 From: "Paul \"LeoNerd\" Evans" Date: Thu, 11 Sep 2014 11:32:46 +0100 Subject: Added unit tests of DirectoryStore --- tests/storage/test_directory.py | 66 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 66 insertions(+) create mode 100644 tests/storage/test_directory.py (limited to 'tests/storage') diff --git a/tests/storage/test_directory.py b/tests/storage/test_directory.py new file mode 100644 index 0000000000..49c41700f6 --- /dev/null +++ b/tests/storage/test_directory.py @@ -0,0 +1,66 @@ +# -*- coding: utf-8 -*- +# Copyright 2014 OpenMarket Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +from twisted.trial import unittest +from twisted.internet import defer + +from synapse.server import HomeServer +from synapse.storage.directory import DirectoryStore + +from tests.utils import SQLiteMemoryDbPool + + +class DirectoryStoreTestCase(unittest.TestCase): + + @defer.inlineCallbacks + def setUp(self): + hs = HomeServer("test", + db_pool=SQLiteMemoryDbPool(), + ) + + yield hs.get_db_pool().prepare() + + self.store = DirectoryStore(hs) + + self.room = hs.parse_roomid("!abcde:test") + self.alias = hs.parse_roomalias("#my-room:test") + + @defer.inlineCallbacks + def test_room_to_alias(self): + yield self.store.create_room_alias_association( + room_alias=self.alias, + room_id=self.room.to_string(), + servers=["test"], + ) + + aliases = yield self.store.get_aliases_for_room(self.room.to_string()) + + self.assertEquals(["#my-room:test"], aliases) + + @defer.inlineCallbacks + def test_alias_to_room(self): + yield self.store.create_room_alias_association( + room_alias=self.alias, + room_id=self.room.to_string(), + servers=["test"], + ) + + mapping = yield self.store.get_association_from_room_alias( + self.alias + ) + + self.assertEquals(self.room.to_string(), mapping.room_id) + self.assertEquals(["test"], mapping.servers) -- cgit 1.4.1 From 493b1e6d3ccb9fd806e6d4c22daa1b6657c6ae7f Mon Sep 17 00:00:00 2001 From: "Paul \"LeoNerd\" Evans" Date: Thu, 11 Sep 2014 15:21:15 +0100 Subject: Need to prepare() the SQLiteMemoryDbPool before passing it to HomeServer constructor, as DataStore's constructor will want it ready --- tests/handlers/test_directory.py | 7 ++++--- tests/handlers/test_presence.py | 7 ++++--- tests/handlers/test_profile.py | 7 ++++--- tests/storage/test_directory.py | 7 ++++--- tests/storage/test_presence.py | 7 ++++--- tests/storage/test_profile.py | 7 ++++--- 6 files changed, 24 insertions(+), 18 deletions(-) (limited to 'tests/storage') diff --git a/tests/handlers/test_directory.py b/tests/handlers/test_directory.py index 58ecf561ff..f7eb7b4f03 100644 --- a/tests/handlers/test_directory.py +++ b/tests/handlers/test_directory.py @@ -50,16 +50,17 @@ class DirectoryTestCase(unittest.TestCase): self.query_handlers[query_type] = handler self.mock_federation.register_query_handler = register_query_handler + db_pool = SQLiteMemoryDbPool() + yield db_pool.prepare() + hs = HomeServer("test", - db_pool=SQLiteMemoryDbPool(), + db_pool=db_pool, http_client=None, resource_for_federation=Mock(), replication_layer=self.mock_federation, ) hs.handlers = DirectoryHandlers(hs) - yield hs.get_db_pool().prepare() - self.handler = hs.get_handlers().directory_handler self.store = hs.get_datastore() diff --git a/tests/handlers/test_presence.py b/tests/handlers/test_presence.py index c98f877e84..61e9cc7042 100644 --- a/tests/handlers/test_presence.py +++ b/tests/handlers/test_presence.py @@ -68,17 +68,18 @@ class PresenceStateTestCase(unittest.TestCase): @defer.inlineCallbacks def setUp(self): + db_pool = SQLiteMemoryDbPool() + yield db_pool.prepare() + hs = HomeServer("test", clock=MockClock(), - db_pool=SQLiteMemoryDbPool(), + db_pool=db_pool, handlers=None, resource_for_federation=Mock(), http_client=None, ) hs.handlers = JustPresenceHandlers(hs) - yield hs.get_db_pool().prepare() - self.store = hs.get_datastore() # Mock the RoomMemberHandler diff --git a/tests/handlers/test_profile.py b/tests/handlers/test_profile.py index 8b9685a527..63c9295944 100644 --- a/tests/handlers/test_profile.py +++ b/tests/handlers/test_profile.py @@ -49,8 +49,11 @@ class ProfileTestCase(unittest.TestCase): self.query_handlers[query_type] = handler self.mock_federation.register_query_handler = register_query_handler + db_pool = SQLiteMemoryDbPool() + yield db_pool.prepare() + hs = HomeServer("test", - db_pool=SQLiteMemoryDbPool(), + db_pool=db_pool, http_client=None, handlers=None, resource_for_federation=Mock(), @@ -58,8 +61,6 @@ class ProfileTestCase(unittest.TestCase): ) hs.handlers = ProfileHandlers(hs) - yield hs.get_db_pool().prepare() - self.store = hs.get_datastore() self.frank = hs.parse_userid("@1234ABCD:test") diff --git a/tests/storage/test_directory.py b/tests/storage/test_directory.py index 49c41700f6..c4c321dda6 100644 --- a/tests/storage/test_directory.py +++ b/tests/storage/test_directory.py @@ -27,12 +27,13 @@ class DirectoryStoreTestCase(unittest.TestCase): @defer.inlineCallbacks def setUp(self): + db_pool = SQLiteMemoryDbPool() + yield db_pool.prepare() + hs = HomeServer("test", - db_pool=SQLiteMemoryDbPool(), + db_pool=db_pool, ) - yield hs.get_db_pool().prepare() - self.store = DirectoryStore(hs) self.room = hs.parse_roomid("!abcde:test") diff --git a/tests/storage/test_presence.py b/tests/storage/test_presence.py index f0a04ae830..f3fab4fe79 100644 --- a/tests/storage/test_presence.py +++ b/tests/storage/test_presence.py @@ -27,13 +27,14 @@ class PresenceStoreTestCase(unittest.TestCase): @defer.inlineCallbacks def setUp(self): + db_pool = SQLiteMemoryDbPool() + yield db_pool.prepare() + hs = HomeServer("test", clock=MockClock(), - db_pool=SQLiteMemoryDbPool(), + db_pool=db_pool, ) - yield hs.get_db_pool().prepare() - self.store = PresenceStore(hs) self.u_apple = hs.parse_userid("@apple:test") diff --git a/tests/storage/test_profile.py b/tests/storage/test_profile.py index fa96abf03b..1855278044 100644 --- a/tests/storage/test_profile.py +++ b/tests/storage/test_profile.py @@ -27,12 +27,13 @@ class ProfileStoreTestCase(unittest.TestCase): @defer.inlineCallbacks def setUp(self): + db_pool = SQLiteMemoryDbPool() + yield db_pool.prepare() + hs = HomeServer("test", - db_pool=SQLiteMemoryDbPool(), + db_pool=db_pool, ) - yield hs.get_db_pool().prepare() - self.store = ProfileStore(hs) self.u_frank = hs.parse_userid("@frank:test") -- cgit 1.4.1 From 3d6aee079ef7cb44a7c5a7ea4f13f67a6850128a Mon Sep 17 00:00:00 2001 From: "Paul \"LeoNerd\" Evans" Date: Thu, 11 Sep 2014 17:44:00 +0100 Subject: Unit-test for RegistrationStore using SQLiteMemoryDbPool --- tests/storage/test_registration.py | 69 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 69 insertions(+) create mode 100644 tests/storage/test_registration.py (limited to 'tests/storage') diff --git a/tests/storage/test_registration.py b/tests/storage/test_registration.py new file mode 100644 index 0000000000..5e11ce3511 --- /dev/null +++ b/tests/storage/test_registration.py @@ -0,0 +1,69 @@ +# -*- coding: utf-8 -*- +# Copyright 2014 OpenMarket Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +from twisted.trial import unittest +from twisted.internet import defer + +from synapse.server import HomeServer +from synapse.storage.registration import RegistrationStore + +from tests.utils import SQLiteMemoryDbPool + + +class RegistrationStoreTestCase(unittest.TestCase): + + @defer.inlineCallbacks + def setUp(self): + db_pool = SQLiteMemoryDbPool() + yield db_pool.prepare() + + hs = HomeServer("test", + db_pool=db_pool, + ) + + self.store = RegistrationStore(hs) + + self.user_id = "@my-user:test" + self.tokens = ["AbCdEfGhIjKlMnOpQrStUvWxYz", + "BcDeFgHiJkLmNoPqRsTuVwXyZa"] + self.pwhash = "{xx1}123456789" + + @defer.inlineCallbacks + def test_register(self): + yield self.store.register(self.user_id, self.tokens[0], self.pwhash) + + self.assertEquals( + # TODO(paul): Surely this field should be 'user_id', not 'name' + # Additionally surely it shouldn't come in a 1-element list + [{"name": self.user_id, "password_hash": self.pwhash}], + (yield self.store.get_user_by_id(self.user_id)) + ) + + self.assertEquals( + self.user_id, + (yield self.store.get_user_by_token(self.tokens[0])) + ) + + @defer.inlineCallbacks + def test_add_tokens(self): + yield self.store.register(self.user_id, self.tokens[0], self.pwhash) + yield self.store.add_access_token_to_user(self.user_id, self.tokens[1]) + + self.assertEquals( + self.user_id, + (yield self.store.get_user_by_token(self.tokens[1])) + ) + -- cgit 1.4.1 From 2026942b056ea46cb0f14336ea00c4c7d8b14311 Mon Sep 17 00:00:00 2001 From: "Paul \"LeoNerd\" Evans" Date: Fri, 12 Sep 2014 16:44:07 +0100 Subject: Initial hack at some RoomMemberStore unit tests --- tests/storage/test_roommember.py | 109 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 109 insertions(+) create mode 100644 tests/storage/test_roommember.py (limited to 'tests/storage') diff --git a/tests/storage/test_roommember.py b/tests/storage/test_roommember.py new file mode 100644 index 0000000000..5a6e93d4d1 --- /dev/null +++ b/tests/storage/test_roommember.py @@ -0,0 +1,109 @@ +# -*- coding: utf-8 -*- +# Copyright 2014 OpenMarket Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +from twisted.trial import unittest +from twisted.internet import defer + +from synapse.server import HomeServer +from synapse.api.constants import Membership +from synapse.api.events.room import RoomMemberEvent + +from tests.utils import SQLiteMemoryDbPool + + +class RoomMemberStoreTestCase(unittest.TestCase): + + @defer.inlineCallbacks + def setUp(self): + db_pool = SQLiteMemoryDbPool() + yield db_pool.prepare() + + hs = HomeServer("test", + db_pool=db_pool, + ) + + # We can't test the RoomMemberStore on its own without the other event + # storage logic + self.store = hs.get_datastore() + self.event_factory = hs.get_event_factory() + + self.u_alice = hs.parse_userid("@alice:test") + self.u_bob = hs.parse_userid("@bob:test") + + self.room = hs.parse_roomid("!abc123:test") + + @defer.inlineCallbacks + def inject_room_member(self, room, user, membership): + # Have to create a join event using the eventfactory + yield self.store.persist_event( + self.event_factory.create_event( + etype=RoomMemberEvent.TYPE, + user_id=user.to_string(), + state_key=user.to_string(), + room_id=room.to_string(), + membership=membership, + content={"membership": membership}, + depth=1, + ) + ) + + @defer.inlineCallbacks + def test_one_member(self): + yield self.inject_room_member(self.room, self.u_alice, Membership.JOIN) + + self.assertEquals( + Membership.JOIN, + (yield self.store.get_room_member( + user_id=self.u_alice.to_string(), + room_id=self.room.to_string(), + )).membership + ) + self.assertEquals( + [self.u_alice.to_string()], + [m.user_id for m in ( + yield self.store.get_room_members(self.room.to_string()) + )] + ) + self.assertEquals( + [self.room.to_string()], + [m.room_id for m in ( + yield self.store.get_rooms_for_user_where_membership_is( + self.u_alice.to_string(), [Membership.JOIN] + )) + ] + ) + self.assertFalse( + (yield self.store.user_rooms_intersect( + [self.u_alice.to_string(), self.u_bob.to_string()] + )) + ) + + @defer.inlineCallbacks + def test_two_members(self): + yield self.inject_room_member(self.room, self.u_alice, Membership.JOIN) + yield self.inject_room_member(self.room, self.u_bob, Membership.JOIN) + + self.assertEquals( + {self.u_alice.to_string(), self.u_bob.to_string()}, + {m.user_id for m in ( + yield self.store.get_room_members(self.room.to_string()) + )} + ) + self.assertTrue( + (yield self.store.user_rooms_intersect( + [self.u_alice.to_string(), self.u_bob.to_string()] + )) + ) -- cgit 1.4.1 From ae7dfeb5b6e8ee491f137d9a706cc83b9294b86f Mon Sep 17 00:00:00 2001 From: "Paul \"LeoNerd\" Evans" Date: Mon, 15 Sep 2014 14:19:16 +0100 Subject: Use new 'tests.unittest' in new storage level tests --- tests/storage/test_directory.py | 2 +- tests/storage/test_presence.py | 2 +- tests/storage/test_profile.py | 2 +- tests/storage/test_registration.py | 2 +- tests/storage/test_roommember.py | 2 +- 5 files changed, 5 insertions(+), 5 deletions(-) (limited to 'tests/storage') diff --git a/tests/storage/test_directory.py b/tests/storage/test_directory.py index c4c321dda6..9a80bf6c04 100644 --- a/tests/storage/test_directory.py +++ b/tests/storage/test_directory.py @@ -14,7 +14,7 @@ # limitations under the License. -from twisted.trial import unittest +from tests import unittest from twisted.internet import defer from synapse.server import HomeServer diff --git a/tests/storage/test_presence.py b/tests/storage/test_presence.py index f3fab4fe79..9655d3cf42 100644 --- a/tests/storage/test_presence.py +++ b/tests/storage/test_presence.py @@ -14,7 +14,7 @@ # limitations under the License. -from twisted.trial import unittest +from tests import unittest from twisted.internet import defer from synapse.server import HomeServer diff --git a/tests/storage/test_profile.py b/tests/storage/test_profile.py index 1855278044..21df2babdc 100644 --- a/tests/storage/test_profile.py +++ b/tests/storage/test_profile.py @@ -14,7 +14,7 @@ # limitations under the License. -from twisted.trial import unittest +from tests import unittest from twisted.internet import defer from synapse.server import HomeServer diff --git a/tests/storage/test_registration.py b/tests/storage/test_registration.py index 5e11ce3511..91e221d53e 100644 --- a/tests/storage/test_registration.py +++ b/tests/storage/test_registration.py @@ -14,7 +14,7 @@ # limitations under the License. -from twisted.trial import unittest +from tests import unittest from twisted.internet import defer from synapse.server import HomeServer diff --git a/tests/storage/test_roommember.py b/tests/storage/test_roommember.py index 5a6e93d4d1..dd18291b4c 100644 --- a/tests/storage/test_roommember.py +++ b/tests/storage/test_roommember.py @@ -14,7 +14,7 @@ # limitations under the License. -from twisted.trial import unittest +from tests import unittest from twisted.internet import defer from synapse.server import HomeServer -- cgit 1.4.1 From 1aaa4290810dbc39c427af5cce8da1ee041d7a74 Mon Sep 17 00:00:00 2001 From: "Paul \"LeoNerd\" Evans" Date: Mon, 15 Sep 2014 15:00:14 +0100 Subject: Also unittest RoomMemberStore's joined_hosts_for_room() --- tests/storage/test_roommember.py | 48 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 48 insertions(+) (limited to 'tests/storage') diff --git a/tests/storage/test_roommember.py b/tests/storage/test_roommember.py index dd18291b4c..eae278ee8d 100644 --- a/tests/storage/test_roommember.py +++ b/tests/storage/test_roommember.py @@ -43,6 +43,9 @@ class RoomMemberStoreTestCase(unittest.TestCase): self.u_alice = hs.parse_userid("@alice:test") self.u_bob = hs.parse_userid("@bob:test") + # User elsewhere on another host + self.u_charlie = hs.parse_userid("@charlie:elsewhere") + self.room = hs.parse_roomid("!abc123:test") @defer.inlineCallbacks @@ -107,3 +110,48 @@ class RoomMemberStoreTestCase(unittest.TestCase): [self.u_alice.to_string(), self.u_bob.to_string()] )) ) + + @defer.inlineCallbacks + def test_room_hosts(self): + yield self.inject_room_member(self.room, self.u_alice, Membership.JOIN) + + self.assertEquals( + ["test"], + (yield self.store.get_joined_hosts_for_room(self.room.to_string())) + ) + + # Should still have just one host after second join from it + yield self.inject_room_member(self.room, self.u_bob, Membership.JOIN) + + self.assertEquals( + ["test"], + (yield self.store.get_joined_hosts_for_room(self.room.to_string())) + ) + + # Should now have two hosts after join from other host + yield self.inject_room_member(self.room, self.u_charlie, Membership.JOIN) + + self.assertEquals( + {"test", "elsewhere"}, + set((yield + self.store.get_joined_hosts_for_room(self.room.to_string()) + )) + ) + + # Should still have both hosts + yield self.inject_room_member(self.room, self.u_alice, Membership.LEAVE) + + self.assertEquals( + {"test", "elsewhere"}, + set((yield + self.store.get_joined_hosts_for_room(self.room.to_string()) + )) + ) + + # Should have only one host after other leaves + yield self.inject_room_member(self.room, self.u_charlie, Membership.LEAVE) + + self.assertEquals( + ["test"], + (yield self.store.get_joined_hosts_for_room(self.room.to_string())) + ) -- cgit 1.4.1 From e32cfed1d8778ce59f406853686675bb8185dfb4 Mon Sep 17 00:00:00 2001 From: "Paul \"LeoNerd\" Evans" Date: Mon, 15 Sep 2014 18:41:24 +0100 Subject: Initial pass at a RoomStore test --- tests/storage/test_room.py | 53 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 53 insertions(+) create mode 100644 tests/storage/test_room.py (limited to 'tests/storage') diff --git a/tests/storage/test_room.py b/tests/storage/test_room.py new file mode 100644 index 0000000000..2477f965e6 --- /dev/null +++ b/tests/storage/test_room.py @@ -0,0 +1,53 @@ +# -*- coding: utf-8 -*- +# Copyright 2014 OpenMarket Ltd +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + + +from tests import unittest +from twisted.internet import defer + +from synapse.server import HomeServer +from synapse.storage.room import RoomStore + +from tests.utils import SQLiteMemoryDbPool + + +class RoomStoreTestCase(unittest.TestCase): + + @defer.inlineCallbacks + def setUp(self): + db_pool = SQLiteMemoryDbPool() + yield db_pool.prepare() + + hs = HomeServer("test", + db_pool=db_pool, + ) + + self.store = RoomStore(hs) + + self.room = hs.parse_roomid("!abcde:test") + self.u_creator = hs.parse_userid("@creator:test") + + @defer.inlineCallbacks + def test_store_room(self): + yield self.store.store_room(self.room.to_string(), + room_creator_user_id=self.u_creator.to_string(), + is_public=True + ) + + room = yield self.store.get_room(self.room.to_string()) + + self.assertEquals(self.room.to_string(), room.room_id) + self.assertEquals(self.u_creator.to_string(), room.creator) + self.assertTrue(room.is_public) -- cgit 1.4.1 From de1485323749b5aed0d0143c695180eb25ee8808 Mon Sep 17 00:00:00 2001 From: "Paul \"LeoNerd\" Evans" Date: Wed, 17 Sep 2014 15:33:10 +0100 Subject: More RoomStore tests --- tests/storage/test_room.py | 44 ++++++++++++++++++++++++++++++++++++++++---- 1 file changed, 40 insertions(+), 4 deletions(-) (limited to 'tests/storage') diff --git a/tests/storage/test_room.py b/tests/storage/test_room.py index 2477f965e6..8d85d56b9a 100644 --- a/tests/storage/test_room.py +++ b/tests/storage/test_room.py @@ -18,7 +18,6 @@ from tests import unittest from twisted.internet import defer from synapse.server import HomeServer -from synapse.storage.room import RoomStore from tests.utils import SQLiteMemoryDbPool @@ -34,20 +33,57 @@ class RoomStoreTestCase(unittest.TestCase): db_pool=db_pool, ) - self.store = RoomStore(hs) + # We can't test RoomStore on its own without the DirectoryStore, for + # management of the 'room_aliases' table + self.store = hs.get_datastore() self.room = hs.parse_roomid("!abcde:test") + self.alias = hs.parse_roomalias("#a-room-name:test") self.u_creator = hs.parse_userid("@creator:test") - @defer.inlineCallbacks - def test_store_room(self): yield self.store.store_room(self.room.to_string(), room_creator_user_id=self.u_creator.to_string(), is_public=True ) + @defer.inlineCallbacks + def test_get_room(self): room = yield self.store.get_room(self.room.to_string()) self.assertEquals(self.room.to_string(), room.room_id) self.assertEquals(self.u_creator.to_string(), room.creator) self.assertTrue(room.is_public) + + @defer.inlineCallbacks + def test_store_room_config(self): + yield self.store.store_room_config(self.room.to_string(), + visibility=False + ) + + room = yield self.store.get_room(self.room.to_string()) + + self.assertFalse(room.is_public) + + @defer.inlineCallbacks + def test_get_rooms(self): + # get_rooms does an INNER JOIN on the room_aliases table :( + + rooms = yield self.store.get_rooms(is_public=True) + # Should be empty before we add the alias + self.assertEquals([], rooms) + + yield self.store.create_room_alias_association( + room_alias=self.alias, + room_id=self.room.to_string(), + servers=["test"] + ) + + rooms = yield self.store.get_rooms(is_public=True) + + self.assertEquals(1, len(rooms)) + self.assertEquals({ + "name": None, + "room_id": self.room.to_string(), + "topic": None, + "aliases": [self.alias.to_string()], + }, rooms[0]) -- cgit 1.4.1 From ba41ca45fa40cb23bd8f28f6802788f7f38a46b7 Mon Sep 17 00:00:00 2001 From: "Paul \"LeoNerd\" Evans" Date: Wed, 17 Sep 2014 16:04:05 +0100 Subject: Use new assertObjectHasAttributes() in tests/storage/test_room.py --- tests/storage/test_room.py | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) (limited to 'tests/storage') diff --git a/tests/storage/test_room.py b/tests/storage/test_room.py index 8d85d56b9a..9e794074d3 100644 --- a/tests/storage/test_room.py +++ b/tests/storage/test_room.py @@ -50,9 +50,12 @@ class RoomStoreTestCase(unittest.TestCase): def test_get_room(self): room = yield self.store.get_room(self.room.to_string()) - self.assertEquals(self.room.to_string(), room.room_id) - self.assertEquals(self.u_creator.to_string(), room.creator) - self.assertTrue(room.is_public) + self.assertObjectHasAttributes( + {"room_id": self.room.to_string(), + "creator": self.u_creator.to_string(), + "is_public": True}, + room + ) @defer.inlineCallbacks def test_store_room_config(self): -- cgit 1.4.1 From b588ce920df77a4cfd3af9dd806d17c7bcf1d4cb Mon Sep 17 00:00:00 2001 From: "Paul \"LeoNerd\" Evans" Date: Wed, 17 Sep 2014 16:31:11 +0100 Subject: Unit tests for (some) room events via the RoomStore --- tests/storage/test_room.py | 85 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 85 insertions(+) (limited to 'tests/storage') diff --git a/tests/storage/test_room.py b/tests/storage/test_room.py index 9e794074d3..9979be2f65 100644 --- a/tests/storage/test_room.py +++ b/tests/storage/test_room.py @@ -18,6 +18,9 @@ from tests import unittest from twisted.internet import defer from synapse.server import HomeServer +from synapse.api.events.room import ( + RoomNameEvent, RoomTopicEvent +) from tests.utils import SQLiteMemoryDbPool @@ -90,3 +93,85 @@ class RoomStoreTestCase(unittest.TestCase): "topic": None, "aliases": [self.alias.to_string()], }, rooms[0]) + + +class RoomEventsStoreTestCase(unittest.TestCase): + + @defer.inlineCallbacks + def setUp(self): + db_pool = SQLiteMemoryDbPool() + yield db_pool.prepare() + + hs = HomeServer("test", + db_pool=db_pool, + ) + + # Room events need the full datastore, for persist_event() and + # get_room_state() + self.store = hs.get_datastore() + self.event_factory = hs.get_event_factory(); + + self.room = hs.parse_roomid("!abcde:test") + + yield self.store.store_room(self.room.to_string(), + room_creator_user_id="@creator:text", + is_public=True + ) + + @defer.inlineCallbacks + def inject_room_event(self, **kwargs): + yield self.store.persist_event( + self.event_factory.create_event( + room_id=self.room.to_string(), + **kwargs + ) + ) + + @defer.inlineCallbacks + def test_room_name(self): + name = u"A-Room-Name" + + yield self.inject_room_event( + etype=RoomNameEvent.TYPE, + name=name, + content={"name": name}, + depth=1, + ) + + state = yield self.store.get_current_state( + room_id=self.room.to_string() + ) + + self.assertEquals(1, len(state)) + self.assertObjectHasAttributes( + {"type": "m.room.name", + "room_id": self.room.to_string(), + "name": name}, + state[0] + ) + + @defer.inlineCallbacks + def test_room_name(self): + topic = u"A place for things" + + yield self.inject_room_event( + etype=RoomTopicEvent.TYPE, + topic=topic, + content={"topic": topic}, + depth=1, + ) + + state = yield self.store.get_current_state( + room_id=self.room.to_string() + ) + + self.assertEquals(1, len(state)) + self.assertObjectHasAttributes( + {"type": "m.room.topic", + "room_id": self.room.to_string(), + "topic": topic}, + state[0] + ) + + # Not testing the various 'level' methods for now because there's lots + # of them and need coalescing; see JIRA SPEC-11 -- cgit 1.4.1 From bcf512193705a0aaca2da3bbfd62ce6f4cb65980 Mon Sep 17 00:00:00 2001 From: "Paul \"LeoNerd\" Evans" Date: Wed, 17 Sep 2014 16:58:59 +0100 Subject: Neaten more of the storage layer tests with assertObjectHasAttributes; more standardisation on test layout --- tests/storage/test_directory.py | 17 +++++++++-------- tests/storage/test_profile.py | 14 ++++++++------ tests/storage/test_room.py | 11 +++++------ 3 files changed, 22 insertions(+), 20 deletions(-) (limited to 'tests/storage') diff --git a/tests/storage/test_directory.py b/tests/storage/test_directory.py index 9a80bf6c04..7e8e7e1e83 100644 --- a/tests/storage/test_directory.py +++ b/tests/storage/test_directory.py @@ -47,9 +47,10 @@ class DirectoryStoreTestCase(unittest.TestCase): servers=["test"], ) - aliases = yield self.store.get_aliases_for_room(self.room.to_string()) - - self.assertEquals(["#my-room:test"], aliases) + self.assertEquals( + ["#my-room:test"], + (yield self.store.get_aliases_for_room(self.room.to_string())) + ) @defer.inlineCallbacks def test_alias_to_room(self): @@ -59,9 +60,9 @@ class DirectoryStoreTestCase(unittest.TestCase): servers=["test"], ) - mapping = yield self.store.get_association_from_room_alias( - self.alias - ) - self.assertEquals(self.room.to_string(), mapping.room_id) - self.assertEquals(["test"], mapping.servers) + self.assertObjectHasAttributes( + {"room_id": self.room.to_string(), + "servers": ["test"]}, + (yield self.store.get_association_from_room_alias(self.alias)) + ) diff --git a/tests/storage/test_profile.py b/tests/storage/test_profile.py index 21df2babdc..5d36723c28 100644 --- a/tests/storage/test_profile.py +++ b/tests/storage/test_profile.py @@ -48,9 +48,10 @@ class ProfileStoreTestCase(unittest.TestCase): self.u_frank.localpart, "Frank" ) - name = yield self.store.get_profile_displayname(self.u_frank.localpart) - - self.assertEquals("Frank", name) + self.assertEquals( + "Frank", + (yield self.store.get_profile_displayname(self.u_frank.localpart)) + ) @defer.inlineCallbacks def test_avatar_url(self): @@ -62,6 +63,7 @@ class ProfileStoreTestCase(unittest.TestCase): self.u_frank.localpart, "http://my.site/here" ) - name = yield self.store.get_profile_avatar_url(self.u_frank.localpart) - - self.assertEquals("http://my.site/here", name) + self.assertEquals( + "http://my.site/here", + (yield self.store.get_profile_avatar_url(self.u_frank.localpart)) + ) diff --git a/tests/storage/test_room.py b/tests/storage/test_room.py index 9979be2f65..369a73d917 100644 --- a/tests/storage/test_room.py +++ b/tests/storage/test_room.py @@ -51,13 +51,11 @@ class RoomStoreTestCase(unittest.TestCase): @defer.inlineCallbacks def test_get_room(self): - room = yield self.store.get_room(self.room.to_string()) - self.assertObjectHasAttributes( {"room_id": self.room.to_string(), "creator": self.u_creator.to_string(), "is_public": True}, - room + (yield self.store.get_room(self.room.to_string())) ) @defer.inlineCallbacks @@ -66,9 +64,10 @@ class RoomStoreTestCase(unittest.TestCase): visibility=False ) - room = yield self.store.get_room(self.room.to_string()) - - self.assertFalse(room.is_public) + self.assertObjectHasAttributes( + {"is_public": False}, + (yield self.store.get_room(self.room.to_string())) + ) @defer.inlineCallbacks def test_get_rooms(self): -- cgit 1.4.1 From bfae582fa3e92e4b6279ce7d5004ae933fe579a9 Mon Sep 17 00:00:00 2001 From: "Paul \"LeoNerd\" Evans" Date: Wed, 17 Sep 2014 18:27:30 +0100 Subject: Remark on remaining storage modules that still need unit tests --- tests/storage/TESTS_NEEDED_FOR | 5 +++++ 1 file changed, 5 insertions(+) create mode 100644 tests/storage/TESTS_NEEDED_FOR (limited to 'tests/storage') diff --git a/tests/storage/TESTS_NEEDED_FOR b/tests/storage/TESTS_NEEDED_FOR new file mode 100644 index 0000000000..8e5d0cbdc4 --- /dev/null +++ b/tests/storage/TESTS_NEEDED_FOR @@ -0,0 +1,5 @@ +synapse/storage/feedback.py +synapse/storage/keys.py +synapse/storage/pdu.py +synapse/storage/stream.py +synapse/storage/transactions.py -- cgit 1.4.1