Blackify the teststags/v0.33.3rc1
@@ -0,0 +1 @@ | |||
Synapse's tests are now formatted with the black autoformatter. |
@@ -34,7 +34,6 @@ class TestHandlers(object): | |||
class AuthTestCase(unittest.TestCase): | |||
@defer.inlineCallbacks | |||
def setUp(self): | |||
self.state_handler = Mock() | |||
@@ -53,11 +52,7 @@ class AuthTestCase(unittest.TestCase): | |||
@defer.inlineCallbacks | |||
def test_get_user_by_req_user_valid_token(self): | |||
user_info = { | |||
"name": self.test_user, | |||
"token_id": "ditto", | |||
"device_id": "device", | |||
} | |||
user_info = {"name": self.test_user, "token_id": "ditto", "device_id": "device"} | |||
self.store.get_user_by_access_token = Mock(return_value=user_info) | |||
request = Mock(args={}) | |||
@@ -76,10 +71,7 @@ class AuthTestCase(unittest.TestCase): | |||
self.failureResultOf(d, AuthError) | |||
def test_get_user_by_req_user_missing_token(self): | |||
user_info = { | |||
"name": self.test_user, | |||
"token_id": "ditto", | |||
} | |||
user_info = {"name": self.test_user, "token_id": "ditto"} | |||
self.store.get_user_by_access_token = Mock(return_value=user_info) | |||
request = Mock(args={}) | |||
@@ -90,8 +82,7 @@ class AuthTestCase(unittest.TestCase): | |||
@defer.inlineCallbacks | |||
def test_get_user_by_req_appservice_valid_token(self): | |||
app_service = Mock( | |||
token="foobar", url="a_url", sender=self.test_user, | |||
ip_range_whitelist=None, | |||
token="foobar", url="a_url", sender=self.test_user, ip_range_whitelist=None | |||
) | |||
self.store.get_app_service_by_token = Mock(return_value=app_service) | |||
self.store.get_user_by_access_token = Mock(return_value=None) | |||
@@ -106,8 +97,11 @@ class AuthTestCase(unittest.TestCase): | |||
@defer.inlineCallbacks | |||
def test_get_user_by_req_appservice_valid_token_good_ip(self): | |||
from netaddr import IPSet | |||
app_service = Mock( | |||
token="foobar", url="a_url", sender=self.test_user, | |||
token="foobar", | |||
url="a_url", | |||
sender=self.test_user, | |||
ip_range_whitelist=IPSet(["192.168/16"]), | |||
) | |||
self.store.get_app_service_by_token = Mock(return_value=app_service) | |||
@@ -122,8 +116,11 @@ class AuthTestCase(unittest.TestCase): | |||
def test_get_user_by_req_appservice_valid_token_bad_ip(self): | |||
from netaddr import IPSet | |||
app_service = Mock( | |||
token="foobar", url="a_url", sender=self.test_user, | |||
token="foobar", | |||
url="a_url", | |||
sender=self.test_user, | |||
ip_range_whitelist=IPSet(["192.168/16"]), | |||
) | |||
self.store.get_app_service_by_token = Mock(return_value=app_service) | |||
@@ -160,8 +157,7 @@ class AuthTestCase(unittest.TestCase): | |||
def test_get_user_by_req_appservice_valid_token_valid_user_id(self): | |||
masquerading_user_id = b"@doppelganger:matrix.org" | |||
app_service = Mock( | |||
token="foobar", url="a_url", sender=self.test_user, | |||
ip_range_whitelist=None, | |||
token="foobar", url="a_url", sender=self.test_user, ip_range_whitelist=None | |||
) | |||
app_service.is_interested_in_user = Mock(return_value=True) | |||
self.store.get_app_service_by_token = Mock(return_value=app_service) | |||
@@ -174,15 +170,13 @@ class AuthTestCase(unittest.TestCase): | |||
request.requestHeaders.getRawHeaders = mock_getRawHeaders() | |||
requester = yield self.auth.get_user_by_req(request) | |||
self.assertEquals( | |||
requester.user.to_string(), | |||
masquerading_user_id.decode('utf8') | |||
requester.user.to_string(), masquerading_user_id.decode('utf8') | |||
) | |||
def test_get_user_by_req_appservice_valid_token_bad_user_id(self): | |||
masquerading_user_id = b"@doppelganger:matrix.org" | |||
app_service = Mock( | |||
token="foobar", url="a_url", sender=self.test_user, | |||
ip_range_whitelist=None, | |||
token="foobar", url="a_url", sender=self.test_user, ip_range_whitelist=None | |||
) | |||
app_service.is_interested_in_user = Mock(return_value=False) | |||
self.store.get_app_service_by_token = Mock(return_value=app_service) | |||
@@ -201,17 +195,15 @@ class AuthTestCase(unittest.TestCase): | |||
# TODO(danielwh): Remove this mock when we remove the | |||
# get_user_by_access_token fallback. | |||
self.store.get_user_by_access_token = Mock( | |||
return_value={ | |||
"name": "@baldrick:matrix.org", | |||
"device_id": "device", | |||
} | |||
return_value={"name": "@baldrick:matrix.org", "device_id": "device"} | |||
) | |||
user_id = "@baldrick:matrix.org" | |||
macaroon = pymacaroons.Macaroon( | |||
location=self.hs.config.server_name, | |||
identifier="key", | |||
key=self.hs.config.macaroon_secret_key) | |||
key=self.hs.config.macaroon_secret_key, | |||
) | |||
macaroon.add_first_party_caveat("gen = 1") | |||
macaroon.add_first_party_caveat("type = access") | |||
macaroon.add_first_party_caveat("user_id = %s" % (user_id,)) | |||
@@ -225,15 +217,14 @@ class AuthTestCase(unittest.TestCase): | |||
@defer.inlineCallbacks | |||
def test_get_guest_user_from_macaroon(self): | |||
self.store.get_user_by_id = Mock(return_value={ | |||
"is_guest": True, | |||
}) | |||
self.store.get_user_by_id = Mock(return_value={"is_guest": True}) | |||
user_id = "@baldrick:matrix.org" | |||
macaroon = pymacaroons.Macaroon( | |||
location=self.hs.config.server_name, | |||
identifier="key", | |||
key=self.hs.config.macaroon_secret_key) | |||
key=self.hs.config.macaroon_secret_key, | |||
) | |||
macaroon.add_first_party_caveat("gen = 1") | |||
macaroon.add_first_party_caveat("type = access") | |||
macaroon.add_first_party_caveat("user_id = %s" % (user_id,)) | |||
@@ -257,7 +248,8 @@ class AuthTestCase(unittest.TestCase): | |||
macaroon = pymacaroons.Macaroon( | |||
location=self.hs.config.server_name, | |||
identifier="key", | |||
key=self.hs.config.macaroon_secret_key) | |||
key=self.hs.config.macaroon_secret_key, | |||
) | |||
macaroon.add_first_party_caveat("gen = 1") | |||
macaroon.add_first_party_caveat("type = access") | |||
macaroon.add_first_party_caveat("user_id = %s" % (user,)) | |||
@@ -277,7 +269,8 @@ class AuthTestCase(unittest.TestCase): | |||
macaroon = pymacaroons.Macaroon( | |||
location=self.hs.config.server_name, | |||
identifier="key", | |||
key=self.hs.config.macaroon_secret_key) | |||
key=self.hs.config.macaroon_secret_key, | |||
) | |||
macaroon.add_first_party_caveat("gen = 1") | |||
macaroon.add_first_party_caveat("type = access") | |||
@@ -298,7 +291,8 @@ class AuthTestCase(unittest.TestCase): | |||
macaroon = pymacaroons.Macaroon( | |||
location=self.hs.config.server_name, | |||
identifier="key", | |||
key=self.hs.config.macaroon_secret_key + "wrong") | |||
key=self.hs.config.macaroon_secret_key + "wrong", | |||
) | |||
macaroon.add_first_party_caveat("gen = 1") | |||
macaroon.add_first_party_caveat("type = access") | |||
macaroon.add_first_party_caveat("user_id = %s" % (user,)) | |||
@@ -320,7 +314,8 @@ class AuthTestCase(unittest.TestCase): | |||
macaroon = pymacaroons.Macaroon( | |||
location=self.hs.config.server_name, | |||
identifier="key", | |||
key=self.hs.config.macaroon_secret_key) | |||
key=self.hs.config.macaroon_secret_key, | |||
) | |||
macaroon.add_first_party_caveat("gen = 1") | |||
macaroon.add_first_party_caveat("type = access") | |||
macaroon.add_first_party_caveat("user_id = %s" % (user,)) | |||
@@ -347,7 +342,8 @@ class AuthTestCase(unittest.TestCase): | |||
macaroon = pymacaroons.Macaroon( | |||
location=self.hs.config.server_name, | |||
identifier="key", | |||
key=self.hs.config.macaroon_secret_key) | |||
key=self.hs.config.macaroon_secret_key, | |||
) | |||
macaroon.add_first_party_caveat("gen = 1") | |||
macaroon.add_first_party_caveat("type = access") | |||
macaroon.add_first_party_caveat("user_id = %s" % (user,)) | |||
@@ -380,7 +376,8 @@ class AuthTestCase(unittest.TestCase): | |||
macaroon = pymacaroons.Macaroon( | |||
location=self.hs.config.server_name, | |||
identifier="key", | |||
key=self.hs.config.macaroon_secret_key) | |||
key=self.hs.config.macaroon_secret_key, | |||
) | |||
macaroon.add_first_party_caveat("gen = 1") | |||
macaroon.add_first_party_caveat("type = access") | |||
macaroon.add_first_party_caveat("user_id = %s" % (user_id,)) | |||
@@ -401,9 +398,7 @@ class AuthTestCase(unittest.TestCase): | |||
token = yield self.hs.handlers.auth_handler.issue_access_token( | |||
USER_ID, "DEVICE" | |||
) | |||
self.store.add_access_token_to_user.assert_called_with( | |||
USER_ID, token, "DEVICE" | |||
) | |||
self.store.add_access_token_to_user.assert_called_with(USER_ID, token, "DEVICE") | |||
def get_user(tok): | |||
if token != tok: | |||
@@ -414,10 +409,9 @@ class AuthTestCase(unittest.TestCase): | |||
"token_id": 1234, | |||
"device_id": "DEVICE", | |||
} | |||
self.store.get_user_by_access_token = get_user | |||
self.store.get_user_by_id = Mock(return_value={ | |||
"is_guest": False, | |||
}) | |||
self.store.get_user_by_id = Mock(return_value={"is_guest": False}) | |||
# check the token works | |||
request = Mock(args={}) | |||
@@ -38,7 +38,6 @@ def MockEvent(**kwargs): | |||
class FilteringTestCase(unittest.TestCase): | |||
@defer.inlineCallbacks | |||
def setUp(self): | |||
self.mock_federation_resource = MockHttpResource() | |||
@@ -47,9 +46,7 @@ class FilteringTestCase(unittest.TestCase): | |||
self.mock_http_client.put_json = DeferredMockCallable() | |||
hs = yield setup_test_homeserver( | |||
handlers=None, | |||
http_client=self.mock_http_client, | |||
keyring=Mock(), | |||
handlers=None, http_client=self.mock_http_client, keyring=Mock() | |||
) | |||
self.filtering = hs.get_filtering() | |||
@@ -64,7 +61,7 @@ class FilteringTestCase(unittest.TestCase): | |||
{"room": {"timeline": {"limit": 0}, "state": {"not_bars": ["*"]}}}, | |||
{"event_format": "other"}, | |||
{"room": {"not_rooms": ["#foo:pik-test"]}}, | |||
{"presence": {"senders": ["@bar;pik.test.com"]}} | |||
{"presence": {"senders": ["@bar;pik.test.com"]}}, | |||
] | |||
for filter in invalid_filters: | |||
with self.assertRaises(SynapseError) as check_filter_error: | |||
@@ -81,34 +78,34 @@ class FilteringTestCase(unittest.TestCase): | |||
"include_leave": False, | |||
"rooms": ["!dee:pik-test"], | |||
"not_rooms": ["!gee:pik-test"], | |||
"account_data": {"limit": 0, "types": ["*"]} | |||
"account_data": {"limit": 0, "types": ["*"]}, | |||
} | |||
}, | |||
{ | |||
"room": { | |||
"state": { | |||
"types": ["m.room.*"], | |||
"not_rooms": ["!726s6s6q:example.com"] | |||
"not_rooms": ["!726s6s6q:example.com"], | |||
}, | |||
"timeline": { | |||
"limit": 10, | |||
"types": ["m.room.message"], | |||
"not_rooms": ["!726s6s6q:example.com"], | |||
"not_senders": ["@spam:example.com"] | |||
"not_senders": ["@spam:example.com"], | |||
}, | |||
"ephemeral": { | |||
"types": ["m.receipt", "m.typing"], | |||
"not_rooms": ["!726s6s6q:example.com"], | |||
"not_senders": ["@spam:example.com"] | |||
} | |||
"not_senders": ["@spam:example.com"], | |||
}, | |||
}, | |||
"presence": { | |||
"types": ["m.presence"], | |||
"not_senders": ["@alice:example.com"] | |||
"not_senders": ["@alice:example.com"], | |||
}, | |||
"event_format": "client", | |||
"event_fields": ["type", "content", "sender"] | |||
} | |||
"event_fields": ["type", "content", "sender"], | |||
}, | |||
] | |||
for filter in valid_filters: | |||
try: | |||
@@ -121,229 +118,131 @@ class FilteringTestCase(unittest.TestCase): | |||
pass | |||
def test_definition_types_works_with_literals(self): | |||
definition = { | |||
"types": ["m.room.message", "org.matrix.foo.bar"] | |||
} | |||
event = MockEvent( | |||
sender="@foo:bar", | |||
type="m.room.message", | |||
room_id="!foo:bar" | |||
) | |||
definition = {"types": ["m.room.message", "org.matrix.foo.bar"]} | |||
event = MockEvent(sender="@foo:bar", type="m.room.message", room_id="!foo:bar") | |||
self.assertTrue( | |||
Filter(definition).check(event) | |||
) | |||
self.assertTrue(Filter(definition).check(event)) | |||
def test_definition_types_works_with_wildcards(self): | |||
definition = { | |||
"types": ["m.*", "org.matrix.foo.bar"] | |||
} | |||
event = MockEvent( | |||
sender="@foo:bar", | |||
type="m.room.message", | |||
room_id="!foo:bar" | |||
) | |||
self.assertTrue( | |||
Filter(definition).check(event) | |||
) | |||
definition = {"types": ["m.*", "org.matrix.foo.bar"]} | |||
event = MockEvent(sender="@foo:bar", type="m.room.message", room_id="!foo:bar") | |||
self.assertTrue(Filter(definition).check(event)) | |||
def test_definition_types_works_with_unknowns(self): | |||
definition = { | |||
"types": ["m.room.message", "org.matrix.foo.bar"] | |||
} | |||
definition = {"types": ["m.room.message", "org.matrix.foo.bar"]} | |||
event = MockEvent( | |||
sender="@foo:bar", | |||
type="now.for.something.completely.different", | |||
room_id="!foo:bar" | |||
) | |||
self.assertFalse( | |||
Filter(definition).check(event) | |||
room_id="!foo:bar", | |||
) | |||
self.assertFalse(Filter(definition).check(event)) | |||
def test_definition_not_types_works_with_literals(self): | |||
definition = { | |||
"not_types": ["m.room.message", "org.matrix.foo.bar"] | |||
} | |||
event = MockEvent( | |||
sender="@foo:bar", | |||
type="m.room.message", | |||
room_id="!foo:bar" | |||
) | |||
self.assertFalse( | |||
Filter(definition).check(event) | |||
) | |||
definition = {"not_types": ["m.room.message", "org.matrix.foo.bar"]} | |||
event = MockEvent(sender="@foo:bar", type="m.room.message", room_id="!foo:bar") | |||
self.assertFalse(Filter(definition).check(event)) | |||
def test_definition_not_types_works_with_wildcards(self): | |||
definition = { | |||
"not_types": ["m.room.message", "org.matrix.*"] | |||
} | |||
definition = {"not_types": ["m.room.message", "org.matrix.*"]} | |||
event = MockEvent( | |||
sender="@foo:bar", | |||
type="org.matrix.custom.event", | |||
room_id="!foo:bar" | |||
) | |||
self.assertFalse( | |||
Filter(definition).check(event) | |||
sender="@foo:bar", type="org.matrix.custom.event", room_id="!foo:bar" | |||
) | |||
self.assertFalse(Filter(definition).check(event)) | |||
def test_definition_not_types_works_with_unknowns(self): | |||
definition = { | |||
"not_types": ["m.*", "org.*"] | |||
} | |||
event = MockEvent( | |||
sender="@foo:bar", | |||
type="com.nom.nom.nom", | |||
room_id="!foo:bar" | |||
) | |||
self.assertTrue( | |||
Filter(definition).check(event) | |||
) | |||
definition = {"not_types": ["m.*", "org.*"]} | |||
event = MockEvent(sender="@foo:bar", type="com.nom.nom.nom", room_id="!foo:bar") | |||
self.assertTrue(Filter(definition).check(event)) | |||
def test_definition_not_types_takes_priority_over_types(self): | |||
definition = { | |||
"not_types": ["m.*", "org.*"], | |||
"types": ["m.room.message", "m.room.topic"] | |||
"types": ["m.room.message", "m.room.topic"], | |||
} | |||
event = MockEvent( | |||
sender="@foo:bar", | |||
type="m.room.topic", | |||
room_id="!foo:bar" | |||
) | |||
self.assertFalse( | |||
Filter(definition).check(event) | |||
) | |||
event = MockEvent(sender="@foo:bar", type="m.room.topic", room_id="!foo:bar") | |||
self.assertFalse(Filter(definition).check(event)) | |||
def test_definition_senders_works_with_literals(self): | |||
definition = { | |||
"senders": ["@flibble:wibble"] | |||
} | |||
definition = {"senders": ["@flibble:wibble"]} | |||
event = MockEvent( | |||
sender="@flibble:wibble", | |||
type="com.nom.nom.nom", | |||
room_id="!foo:bar" | |||
) | |||
self.assertTrue( | |||
Filter(definition).check(event) | |||
sender="@flibble:wibble", type="com.nom.nom.nom", room_id="!foo:bar" | |||
) | |||
self.assertTrue(Filter(definition).check(event)) | |||
def test_definition_senders_works_with_unknowns(self): | |||
definition = { | |||
"senders": ["@flibble:wibble"] | |||
} | |||
definition = {"senders": ["@flibble:wibble"]} | |||
event = MockEvent( | |||
sender="@challenger:appears", | |||
type="com.nom.nom.nom", | |||
room_id="!foo:bar" | |||
) | |||
self.assertFalse( | |||
Filter(definition).check(event) | |||
sender="@challenger:appears", type="com.nom.nom.nom", room_id="!foo:bar" | |||
) | |||
self.assertFalse(Filter(definition).check(event)) | |||
def test_definition_not_senders_works_with_literals(self): | |||
definition = { | |||
"not_senders": ["@flibble:wibble"] | |||
} | |||
definition = {"not_senders": ["@flibble:wibble"]} | |||
event = MockEvent( | |||
sender="@flibble:wibble", | |||
type="com.nom.nom.nom", | |||
room_id="!foo:bar" | |||
) | |||
self.assertFalse( | |||
Filter(definition).check(event) | |||
sender="@flibble:wibble", type="com.nom.nom.nom", room_id="!foo:bar" | |||
) | |||
self.assertFalse(Filter(definition).check(event)) | |||
def test_definition_not_senders_works_with_unknowns(self): | |||
definition = { | |||
"not_senders": ["@flibble:wibble"] | |||
} | |||
definition = {"not_senders": ["@flibble:wibble"]} | |||
event = MockEvent( | |||
sender="@challenger:appears", | |||
type="com.nom.nom.nom", | |||
room_id="!foo:bar" | |||
) | |||
self.assertTrue( | |||
Filter(definition).check(event) | |||
sender="@challenger:appears", type="com.nom.nom.nom", room_id="!foo:bar" | |||
) | |||
self.assertTrue(Filter(definition).check(event)) | |||
def test_definition_not_senders_takes_priority_over_senders(self): | |||
definition = { | |||
"not_senders": ["@misspiggy:muppets"], | |||
"senders": ["@kermit:muppets", "@misspiggy:muppets"] | |||
"senders": ["@kermit:muppets", "@misspiggy:muppets"], | |||
} | |||
event = MockEvent( | |||
sender="@misspiggy:muppets", | |||
type="m.room.topic", | |||
room_id="!foo:bar" | |||
) | |||
self.assertFalse( | |||
Filter(definition).check(event) | |||
sender="@misspiggy:muppets", type="m.room.topic", room_id="!foo:bar" | |||
) | |||
self.assertFalse(Filter(definition).check(event)) | |||
def test_definition_rooms_works_with_literals(self): | |||
definition = { | |||
"rooms": ["!secretbase:unknown"] | |||
} | |||
definition = {"rooms": ["!secretbase:unknown"]} | |||
event = MockEvent( | |||
sender="@foo:bar", | |||
type="m.room.message", | |||
room_id="!secretbase:unknown" | |||
) | |||
self.assertTrue( | |||
Filter(definition).check(event) | |||
sender="@foo:bar", type="m.room.message", room_id="!secretbase:unknown" | |||
) | |||
self.assertTrue(Filter(definition).check(event)) | |||
def test_definition_rooms_works_with_unknowns(self): | |||
definition = { | |||
"rooms": ["!secretbase:unknown"] | |||
} | |||
definition = {"rooms": ["!secretbase:unknown"]} | |||
event = MockEvent( | |||
sender="@foo:bar", | |||
type="m.room.message", | |||
room_id="!anothersecretbase:unknown" | |||
) | |||
self.assertFalse( | |||
Filter(definition).check(event) | |||
room_id="!anothersecretbase:unknown", | |||
) | |||
self.assertFalse(Filter(definition).check(event)) | |||
def test_definition_not_rooms_works_with_literals(self): | |||
definition = { | |||
"not_rooms": ["!anothersecretbase:unknown"] | |||
} | |||
definition = {"not_rooms": ["!anothersecretbase:unknown"]} | |||
event = MockEvent( | |||
sender="@foo:bar", | |||
type="m.room.message", | |||
room_id="!anothersecretbase:unknown" | |||
) | |||
self.assertFalse( | |||
Filter(definition).check(event) | |||
room_id="!anothersecretbase:unknown", | |||
) | |||
self.assertFalse(Filter(definition).check(event)) | |||
def test_definition_not_rooms_works_with_unknowns(self): | |||
definition = { | |||
"not_rooms": ["!secretbase:unknown"] | |||
} | |||
definition = {"not_rooms": ["!secretbase:unknown"]} | |||
event = MockEvent( | |||
sender="@foo:bar", | |||
type="m.room.message", | |||
room_id="!anothersecretbase:unknown" | |||
) | |||
self.assertTrue( | |||
Filter(definition).check(event) | |||
room_id="!anothersecretbase:unknown", | |||
) | |||
self.assertTrue(Filter(definition).check(event)) | |||
def test_definition_not_rooms_takes_priority_over_rooms(self): | |||
definition = { | |||
"not_rooms": ["!secretbase:unknown"], | |||
"rooms": ["!secretbase:unknown"] | |||
"rooms": ["!secretbase:unknown"], | |||
} | |||
event = MockEvent( | |||
sender="@foo:bar", | |||
type="m.room.message", | |||
room_id="!secretbase:unknown" | |||
) | |||
self.assertFalse( | |||
Filter(definition).check(event) | |||
sender="@foo:bar", type="m.room.message", room_id="!secretbase:unknown" | |||
) | |||
self.assertFalse(Filter(definition).check(event)) | |||
def test_definition_combined_event(self): | |||
definition = { | |||
@@ -352,16 +251,14 @@ class FilteringTestCase(unittest.TestCase): | |||
"rooms": ["!stage:unknown"], | |||
"not_rooms": ["!piggyshouse:muppets"], | |||
"types": ["m.room.message", "muppets.kermit.*"], | |||
"not_types": ["muppets.misspiggy.*"] | |||
"not_types": ["muppets.misspiggy.*"], | |||
} | |||
event = MockEvent( | |||
sender="@kermit:muppets", # yup | |||
type="m.room.message", # yup | |||
room_id="!stage:unknown" # yup | |||
) | |||
self.assertTrue( | |||
Filter(definition).check(event) | |||
room_id="!stage:unknown", # yup | |||
) | |||
self.assertTrue(Filter(definition).check(event)) | |||
def test_definition_combined_event_bad_sender(self): | |||
definition = { | |||
@@ -370,16 +267,14 @@ class FilteringTestCase(unittest.TestCase): | |||
"rooms": ["!stage:unknown"], | |||
"not_rooms": ["!piggyshouse:muppets"], | |||
"types": ["m.room.message", "muppets.kermit.*"], | |||
"not_types": ["muppets.misspiggy.*"] | |||
"not_types": ["muppets.misspiggy.*"], | |||
} | |||
event = MockEvent( | |||
sender="@misspiggy:muppets", # nope | |||
type="m.room.message", # yup | |||
room_id="!stage:unknown" # yup | |||
) | |||
self.assertFalse( | |||
Filter(definition).check(event) | |||
room_id="!stage:unknown", # yup | |||
) | |||
self.assertFalse(Filter(definition).check(event)) | |||
def test_definition_combined_event_bad_room(self): | |||
definition = { | |||
@@ -388,16 +283,14 @@ class FilteringTestCase(unittest.TestCase): | |||
"rooms": ["!stage:unknown"], | |||
"not_rooms": ["!piggyshouse:muppets"], | |||
"types": ["m.room.message", "muppets.kermit.*"], | |||
"not_types": ["muppets.misspiggy.*"] | |||
"not_types": ["muppets.misspiggy.*"], | |||
} | |||
event = MockEvent( | |||
sender="@kermit:muppets", # yup | |||
type="m.room.message", # yup | |||
room_id="!piggyshouse:muppets" # nope | |||
) | |||
self.assertFalse( | |||
Filter(definition).check(event) | |||
room_id="!piggyshouse:muppets", # nope | |||
) | |||
self.assertFalse(Filter(definition).check(event)) | |||
def test_definition_combined_event_bad_type(self): | |||
definition = { | |||
@@ -406,37 +299,26 @@ class FilteringTestCase(unittest.TestCase): | |||
"rooms": ["!stage:unknown"], | |||
"not_rooms": ["!piggyshouse:muppets"], | |||
"types": ["m.room.message", "muppets.kermit.*"], | |||
"not_types": ["muppets.misspiggy.*"] | |||
"not_types": ["muppets.misspiggy.*"], | |||
} | |||
event = MockEvent( | |||
sender="@kermit:muppets", # yup | |||
type="muppets.misspiggy.kisses", # nope | |||
room_id="!stage:unknown" # yup | |||
) | |||
self.assertFalse( | |||
Filter(definition).check(event) | |||
room_id="!stage:unknown", # yup | |||
) | |||
self.assertFalse(Filter(definition).check(event)) | |||
@defer.inlineCallbacks | |||
def test_filter_presence_match(self): | |||
user_filter_json = { | |||
"presence": { | |||
"types": ["m.*"] | |||
} | |||
} | |||
user_filter_json = {"presence": {"types": ["m.*"]}} | |||
filter_id = yield self.datastore.add_user_filter( | |||
user_localpart=user_localpart, | |||
user_filter=user_filter_json, | |||
) | |||
event = MockEvent( | |||
sender="@foo:bar", | |||
type="m.profile", | |||
user_localpart=user_localpart, user_filter=user_filter_json | |||
) | |||
event = MockEvent(sender="@foo:bar", type="m.profile") | |||
events = [event] | |||
user_filter = yield self.filtering.get_user_filter( | |||
user_localpart=user_localpart, | |||
filter_id=filter_id, | |||
user_localpart=user_localpart, filter_id=filter_id | |||
) | |||
results = user_filter.filter_presence(events=events) | |||
@@ -444,15 +326,10 @@ class FilteringTestCase(unittest.TestCase): | |||
@defer.inlineCallbacks | |||
def test_filter_presence_no_match(self): | |||
user_filter_json = { | |||
"presence": { | |||
"types": ["m.*"] | |||
} | |||
} | |||
user_filter_json = {"presence": {"types": ["m.*"]}} | |||
filter_id = yield self.datastore.add_user_filter( | |||
user_localpart=user_localpart + "2", | |||
user_filter=user_filter_json, | |||
user_localpart=user_localpart + "2", user_filter=user_filter_json | |||
) | |||
event = MockEvent( | |||
event_id="$asdasd:localhost", | |||
@@ -462,8 +339,7 @@ class FilteringTestCase(unittest.TestCase): | |||
events = [event] | |||
user_filter = yield self.filtering.get_user_filter( | |||
user_localpart=user_localpart + "2", | |||
filter_id=filter_id, | |||
user_localpart=user_localpart + "2", filter_id=filter_id | |||
) | |||
results = user_filter.filter_presence(events=events) | |||
@@ -471,27 +347,15 @@ class FilteringTestCase(unittest.TestCase): | |||
@defer.inlineCallbacks | |||
def test_filter_room_state_match(self): | |||
user_filter_json = { | |||
"room": { | |||
"state": { | |||
"types": ["m.*"] | |||
} | |||
} | |||
} | |||
user_filter_json = {"room": {"state": {"types": ["m.*"]}}} | |||
filter_id = yield self.datastore.add_user_filter( | |||
user_localpart=user_localpart, | |||
user_filter=user_filter_json, | |||
) | |||
event = MockEvent( | |||
sender="@foo:bar", | |||
type="m.room.topic", | |||
room_id="!foo:bar" | |||
user_localpart=user_localpart, user_filter=user_filter_json | |||
) | |||
event = MockEvent(sender="@foo:bar", type="m.room.topic", room_id="!foo:bar") | |||
events = [event] | |||
user_filter = yield self.filtering.get_user_filter( | |||
user_localpart=user_localpart, | |||
filter_id=filter_id, | |||
user_localpart=user_localpart, filter_id=filter_id | |||
) | |||
results = user_filter.filter_room_state(events=events) | |||
@@ -499,27 +363,17 @@ class FilteringTestCase(unittest.TestCase): | |||
@defer.inlineCallbacks | |||
def test_filter_room_state_no_match(self): | |||
user_filter_json = { | |||
"room": { | |||
"state": { | |||
"types": ["m.*"] | |||
} | |||
} | |||
} | |||
user_filter_json = {"room": {"state": {"types": ["m.*"]}}} | |||
filter_id = yield self.datastore.add_user_filter( | |||
user_localpart=user_localpart, | |||
user_filter=user_filter_json, | |||
user_localpart=user_localpart, user_filter=user_filter_json | |||
) | |||
event = MockEvent( | |||
sender="@foo:bar", | |||
type="org.matrix.custom.event", | |||
room_id="!foo:bar" | |||
sender="@foo:bar", type="org.matrix.custom.event", room_id="!foo:bar" | |||
) | |||
events = [event] | |||
user_filter = yield self.filtering.get_user_filter( | |||
user_localpart=user_localpart, | |||
filter_id=filter_id, | |||
user_localpart=user_localpart, filter_id=filter_id | |||
) | |||
results = user_filter.filter_room_state(events) | |||
@@ -543,45 +397,32 @@ class FilteringTestCase(unittest.TestCase): | |||
@defer.inlineCallbacks | |||
def test_add_filter(self): | |||
user_filter_json = { | |||
"room": { | |||
"state": { | |||
"types": ["m.*"] | |||
} | |||
} | |||
} | |||
user_filter_json = {"room": {"state": {"types": ["m.*"]}}} | |||
filter_id = yield self.filtering.add_user_filter( | |||
user_localpart=user_localpart, | |||
user_filter=user_filter_json, | |||
user_localpart=user_localpart, user_filter=user_filter_json | |||
) | |||
self.assertEquals(filter_id, 0) | |||
self.assertEquals(user_filter_json, ( | |||
yield self.datastore.get_user_filter( | |||
user_localpart=user_localpart, | |||
filter_id=0, | |||
) | |||
)) | |||
self.assertEquals( | |||
user_filter_json, | |||
( | |||
yield self.datastore.get_user_filter( | |||
user_localpart=user_localpart, filter_id=0 | |||
) | |||
), | |||
) | |||
@defer.inlineCallbacks | |||
def test_get_filter(self): | |||
user_filter_json = { | |||
"room": { | |||
"state": { | |||
"types": ["m.*"] | |||
} | |||
} | |||
} | |||
user_filter_json = {"room": {"state": {"types": ["m.*"]}}} | |||
filter_id = yield self.datastore.add_user_filter( | |||
user_localpart=user_localpart, | |||
user_filter=user_filter_json, | |||
user_localpart=user_localpart, user_filter=user_filter_json | |||
) | |||
filter = yield self.filtering.get_user_filter( | |||
user_localpart=user_localpart, | |||
filter_id=filter_id, | |||
user_localpart=user_localpart, filter_id=filter_id | |||
) | |||
self.assertEquals(filter.get_filter_json(), user_filter_json) | |||
@@ -4,17 +4,16 @@ from tests import unittest | |||
class TestRatelimiter(unittest.TestCase): | |||
def test_allowed(self): | |||
limiter = Ratelimiter() | |||
allowed, time_allowed = limiter.send_message( | |||
user_id="test_id", time_now_s=0, msg_rate_hz=0.1, burst_count=1, | |||
user_id="test_id", time_now_s=0, msg_rate_hz=0.1, burst_count=1 | |||
) | |||
self.assertTrue(allowed) | |||
self.assertEquals(10., time_allowed) | |||
allowed, time_allowed = limiter.send_message( | |||
user_id="test_id", time_now_s=5, msg_rate_hz=0.1, burst_count=1, | |||
user_id="test_id", time_now_s=5, msg_rate_hz=0.1, burst_count=1 | |||
) | |||
self.assertFalse(allowed) | |||
self.assertEquals(10., time_allowed) | |||
@@ -28,7 +27,7 @@ class TestRatelimiter(unittest.TestCase): | |||
def test_pruning(self): | |||
limiter = Ratelimiter() | |||
allowed, time_allowed = limiter.send_message( | |||
user_id="test_id_1", time_now_s=0, msg_rate_hz=0.1, burst_count=1, | |||
user_id="test_id_1", time_now_s=0, msg_rate_hz=0.1, burst_count=1 | |||
) | |||
self.assertIn("test_id_1", limiter.message_counts) | |||
@@ -24,14 +24,10 @@ from tests import unittest | |||
def _regex(regex, exclusive=True): | |||
return { | |||
"regex": re.compile(regex), | |||
"exclusive": exclusive | |||
} | |||
return {"regex": re.compile(regex), "exclusive": exclusive} | |||
class ApplicationServiceTestCase(unittest.TestCase): | |||
def setUp(self): | |||
self.service = ApplicationService( | |||
id="unique_identifier", | |||
@@ -41,8 +37,8 @@ class ApplicationServiceTestCase(unittest.TestCase): | |||
namespaces={ | |||
ApplicationService.NS_USERS: [], | |||
ApplicationService.NS_ROOMS: [], | |||
ApplicationService.NS_ALIASES: [] | |||
} | |||
ApplicationService.NS_ALIASES: [], | |||
}, | |||
) | |||
self.event = Mock( | |||
type="m.something", room_id="!foo:bar", sender="@someone:somewhere" | |||
@@ -52,25 +48,19 @@ class ApplicationServiceTestCase(unittest.TestCase): | |||
@defer.inlineCallbacks | |||
def test_regex_user_id_prefix_match(self): | |||
self.service.namespaces[ApplicationService.NS_USERS].append( | |||
_regex("@irc_.*") | |||
) | |||
self.service.namespaces[ApplicationService.NS_USERS].append(_regex("@irc_.*")) | |||
self.event.sender = "@irc_foobar:matrix.org" | |||
self.assertTrue((yield self.service.is_interested(self.event))) | |||
@defer.inlineCallbacks | |||
def test_regex_user_id_prefix_no_match(self): | |||
self.service.namespaces[ApplicationService.NS_USERS].append( | |||
_regex("@irc_.*") | |||
) | |||
self.service.namespaces[ApplicationService.NS_USERS].append(_regex("@irc_.*")) | |||
self.event.sender = "@someone_else:matrix.org" | |||
self.assertFalse((yield self.service.is_interested(self.event))) | |||
@defer.inlineCallbacks | |||
def test_regex_room_member_is_checked(self): | |||
self.service.namespaces[ApplicationService.NS_USERS].append( | |||
_regex("@irc_.*") | |||
) | |||
self.service.namespaces[ApplicationService.NS_USERS].append(_regex("@irc_.*")) | |||
self.event.sender = "@someone_else:matrix.org" | |||
self.event.type = "m.room.member" | |||
self.event.state_key = "@irc_foobar:matrix.org" | |||
@@ -98,60 +88,47 @@ class ApplicationServiceTestCase(unittest.TestCase): | |||
_regex("#irc_.*:matrix.org") | |||
) | |||
self.store.get_aliases_for_room.return_value = [ | |||
"#irc_foobar:matrix.org", "#athing:matrix.org" | |||
"#irc_foobar:matrix.org", | |||
"#athing:matrix.org", | |||
] | |||
self.store.get_users_in_room.return_value = [] | |||
self.assertTrue((yield self.service.is_interested( | |||
self.event, self.store | |||
))) | |||
self.assertTrue((yield self.service.is_interested(self.event, self.store))) | |||
def test_non_exclusive_alias(self): | |||
self.service.namespaces[ApplicationService.NS_ALIASES].append( | |||
_regex("#irc_.*:matrix.org", exclusive=False) | |||
) | |||
self.assertFalse(self.service.is_exclusive_alias( | |||
"#irc_foobar:matrix.org" | |||
)) | |||
self.assertFalse(self.service.is_exclusive_alias("#irc_foobar:matrix.org")) | |||
def test_non_exclusive_room(self): | |||
self.service.namespaces[ApplicationService.NS_ROOMS].append( | |||
_regex("!irc_.*:matrix.org", exclusive=False) | |||
) | |||
self.assertFalse(self.service.is_exclusive_room( | |||
"!irc_foobar:matrix.org" | |||
)) | |||
self.assertFalse(self.service.is_exclusive_room("!irc_foobar:matrix.org")) | |||
def test_non_exclusive_user(self): | |||
self.service.namespaces[ApplicationService.NS_USERS].append( | |||
_regex("@irc_.*:matrix.org", exclusive=False) | |||
) | |||
self.assertFalse(self.service.is_exclusive_user( | |||
"@irc_foobar:matrix.org" | |||
)) | |||
self.assertFalse(self.service.is_exclusive_user("@irc_foobar:matrix.org")) | |||
def test_exclusive_alias(self): | |||
self.service.namespaces[ApplicationService.NS_ALIASES].append( | |||
_regex("#irc_.*:matrix.org", exclusive=True) | |||
) | |||
self.assertTrue(self.service.is_exclusive_alias( | |||
"#irc_foobar:matrix.org" | |||
)) | |||
self.assertTrue(self.service.is_exclusive_alias("#irc_foobar:matrix.org")) | |||
def test_exclusive_user(self): | |||
self.service.namespaces[ApplicationService.NS_USERS].append( | |||
_regex("@irc_.*:matrix.org", exclusive=True) | |||
) | |||
self.assertTrue(self.service.is_exclusive_user( | |||
"@irc_foobar:matrix.org" | |||
)) | |||
self.assertTrue(self.service.is_exclusive_user("@irc_foobar:matrix.org")) | |||
def test_exclusive_room(self): | |||
self.service.namespaces[ApplicationService.NS_ROOMS].append( | |||
_regex("!irc_.*:matrix.org", exclusive=True) | |||
) | |||
self.assertTrue(self.service.is_exclusive_room( | |||
"!irc_foobar:matrix.org" | |||
)) | |||
self.assertTrue(self.service.is_exclusive_room("!irc_foobar:matrix.org")) | |||
@defer.inlineCallbacks | |||
def test_regex_alias_no_match(self): | |||
@@ -159,47 +136,36 @@ class ApplicationServiceTestCase(unittest.TestCase): | |||
_regex("#irc_.*:matrix.org") | |||
) | |||
self.store.get_aliases_for_room.return_value = [ | |||
"#xmpp_foobar:matrix.org", "#athing:matrix.org" | |||
"#xmpp_foobar:matrix.org", | |||
"#athing:matrix.org", | |||
] | |||
self.store.get_users_in_room.return_value = [] | |||
self.assertFalse((yield self.service.is_interested( | |||
self.event, self.store | |||
))) | |||
self.assertFalse((yield self.service.is_interested(self.event, self.store))) | |||
@defer.inlineCallbacks | |||
def test_regex_multiple_matches(self): | |||
self.service.namespaces[ApplicationService.NS_ALIASES].append( | |||
_regex("#irc_.*:matrix.org") | |||
) | |||
self.service.namespaces[ApplicationService.NS_USERS].append( | |||
_regex("@irc_.*") | |||
) | |||
self.service.namespaces[ApplicationService.NS_USERS].append(_regex("@irc_.*")) | |||
self.event.sender = "@irc_foobar:matrix.org" | |||
self.store.get_aliases_for_room.return_value = ["#irc_barfoo:matrix.org"] | |||
self.store.get_users_in_room.return_value = [] | |||
self.assertTrue((yield self.service.is_interested( | |||
self.event, self.store | |||
))) | |||
self.assertTrue((yield self.service.is_interested(self.event, self.store))) | |||
@defer.inlineCallbacks | |||
def test_interested_in_self(self): | |||
# make sure invites get through | |||
self.service.sender = "@appservice:name" | |||
self.service.namespaces[ApplicationService.NS_USERS].append( | |||
_regex("@irc_.*") | |||
) | |||
self.service.namespaces[ApplicationService.NS_USERS].append(_regex("@irc_.*")) | |||
self.event.type = "m.room.member" | |||
self.event.content = { | |||
"membership": "invite" | |||
} | |||
self.event.content = {"membership": "invite"} | |||
self.event.state_key = self.service.sender | |||
self.assertTrue((yield self.service.is_interested(self.event))) | |||
@defer.inlineCallbacks | |||
def test_member_list_match(self): | |||
self.service.namespaces[ApplicationService.NS_USERS].append( | |||
_regex("@irc_.*") | |||
) | |||
self.service.namespaces[ApplicationService.NS_USERS].append(_regex("@irc_.*")) | |||
self.store.get_users_in_room.return_value = [ | |||
"@alice:here", | |||
"@irc_fo:here", # AS user | |||
@@ -208,6 +174,6 @@ class ApplicationServiceTestCase(unittest.TestCase): | |||
self.store.get_aliases_for_room.return_value = [] | |||
self.event.sender = "@xmpp_foobar:matrix.org" | |||
self.assertTrue((yield self.service.is_interested( | |||
event=self.event, store=self.store | |||
))) | |||
self.assertTrue( | |||
(yield self.service.is_interested(event=self.event, store=self.store)) | |||
) |
@@ -30,7 +30,6 @@ from ..utils import MockClock | |||
class ApplicationServiceSchedulerTransactionCtrlTestCase(unittest.TestCase): | |||
def setUp(self): | |||
self.clock = MockClock() | |||
self.store = Mock() | |||
@@ -38,8 +37,10 @@ class ApplicationServiceSchedulerTransactionCtrlTestCase(unittest.TestCase): | |||
self.recoverer = Mock() | |||
self.recoverer_fn = Mock(return_value=self.recoverer) | |||
self.txnctrl = _TransactionController( | |||
clock=self.clock, store=self.store, as_api=self.as_api, | |||
recoverer_fn=self.recoverer_fn | |||
clock=self.clock, | |||
store=self.store, | |||
as_api=self.as_api, | |||
recoverer_fn=self.recoverer_fn, | |||
) | |||
def test_single_service_up_txn_sent(self): | |||
@@ -54,9 +55,7 @@ class ApplicationServiceSchedulerTransactionCtrlTestCase(unittest.TestCase): | |||
return_value=defer.succeed(ApplicationServiceState.UP) | |||
) | |||
txn.send = Mock(return_value=defer.succeed(True)) | |||
self.store.create_appservice_txn = Mock( | |||
return_value=defer.succeed(txn) | |||
) | |||
self.store.create_appservice_txn = Mock(return_value=defer.succeed(txn)) | |||
# actual call | |||
self.txnctrl.send(service, events) | |||
@@ -77,9 +76,7 @@ class ApplicationServiceSchedulerTransactionCtrlTestCase(unittest.TestCase): | |||
self.store.get_appservice_state = Mock( | |||
return_value=defer.succeed(ApplicationServiceState.DOWN) | |||
) | |||
self.store.create_appservice_txn = Mock( | |||
return_value=defer.succeed(txn) | |||
) | |||
self.store.create_appservice_txn = Mock(return_value=defer.succeed(txn)) | |||
# actual call | |||
self.txnctrl.send(service, events) | |||
@@ -104,9 +101,7 @@ class ApplicationServiceSchedulerTransactionCtrlTestCase(unittest.TestCase): | |||
) | |||
self.store.set_appservice_state = Mock(return_value=defer.succeed(True)) | |||
txn.send = Mock(return_value=defer.succeed(False)) # fails to send | |||
self.store.create_appservice_txn = Mock( | |||
return_value=defer.succeed(txn) | |||
) | |||
self.store.create_appservice_txn = Mock(return_value=defer.succeed(txn)) | |||
# actual call | |||
self.txnctrl.send(service, events) | |||
@@ -124,7 +119,6 @@ class ApplicationServiceSchedulerTransactionCtrlTestCase(unittest.TestCase): | |||
class ApplicationServiceSchedulerRecovererTestCase(unittest.TestCase): | |||
def setUp(self): | |||
self.clock = MockClock() | |||
self.as_api = Mock() | |||
@@ -146,6 +140,7 @@ class ApplicationServiceSchedulerRecovererTestCase(unittest.TestCase): | |||
def take_txn(*args, **kwargs): | |||
return defer.succeed(txns.pop(0)) | |||
self.store.get_oldest_unsent_txn = Mock(side_effect=take_txn) | |||
self.recoverer.recover() | |||
@@ -171,6 +166,7 @@ class ApplicationServiceSchedulerRecovererTestCase(unittest.TestCase): | |||
return defer.succeed(txns.pop(0)) | |||
else: | |||
return defer.succeed(txn) | |||
self.store.get_oldest_unsent_txn = Mock(side_effect=take_txn) | |||
self.recoverer.recover() | |||
@@ -197,7 +193,6 @@ class ApplicationServiceSchedulerRecovererTestCase(unittest.TestCase): | |||
class ApplicationServiceSchedulerQueuerTestCase(unittest.TestCase): | |||
def setUp(self): | |||
self.txn_ctrl = Mock() | |||
self.queuer = _ServiceQueuer(self.txn_ctrl, MockClock()) | |||
@@ -211,9 +206,7 @@ class ApplicationServiceSchedulerQueuerTestCase(unittest.TestCase): | |||
def test_send_single_event_with_queue(self): | |||
d = defer.Deferred() | |||
self.txn_ctrl.send = Mock( | |||
side_effect=lambda x, y: make_deferred_yieldable(d), | |||
) | |||
self.txn_ctrl.send = Mock(side_effect=lambda x, y: make_deferred_yieldable(d)) | |||
service = Mock(id=4) | |||
event = Mock(event_id="first") | |||
event2 = Mock(event_id="second") | |||
@@ -247,6 +240,7 @@ class ApplicationServiceSchedulerQueuerTestCase(unittest.TestCase): | |||
def do_send(x, y): | |||
return make_deferred_yieldable(send_return_list.pop(0)) | |||
self.txn_ctrl.send = Mock(side_effect=do_send) | |||
# send events for different ASes and make sure they are sent | |||
@@ -24,7 +24,6 @@ from tests import unittest | |||
class ConfigGenerationTestCase(unittest.TestCase): | |||
def setUp(self): | |||
self.dir = tempfile.mkdtemp() | |||
self.file = os.path.join(self.dir, "homeserver.yaml") | |||
@@ -33,23 +32,30 @@ class ConfigGenerationTestCase(unittest.TestCase): | |||
shutil.rmtree(self.dir) | |||
def test_generate_config_generates_files(self): | |||
HomeServerConfig.load_or_generate_config("", [ | |||
"--generate-config", | |||
"-c", self.file, | |||
"--report-stats=yes", | |||
"-H", "lemurs.win" | |||
]) | |||
HomeServerConfig.load_or_generate_config( | |||
"", | |||
[ | |||
"--generate-config", | |||
"-c", | |||
self.file, | |||
"--report-stats=yes", | |||
"-H", | |||
"lemurs.win", | |||
], | |||
) | |||
self.assertSetEqual( | |||
set([ | |||
"homeserver.yaml", | |||
"lemurs.win.log.config", | |||
"lemurs.win.signing.key", | |||
"lemurs.win.tls.crt", | |||
"lemurs.win.tls.dh", | |||
"lemurs.win.tls.key", | |||
]), | |||
set(os.listdir(self.dir)) | |||
set( | |||
[ | |||
"homeserver.yaml", | |||
"lemurs.win.log.config", | |||
"lemurs.win.signing.key", | |||
"lemurs.win.tls.crt", | |||
"lemurs.win.tls.dh", | |||
"lemurs.win.tls.key", | |||
] | |||
), | |||
set(os.listdir(self.dir)), | |||
) | |||
self.assert_log_filename_is( | |||
@@ -24,7 +24,6 @@ from tests import unittest | |||
class ConfigLoadingTestCase(unittest.TestCase): | |||
def setUp(self): | |||
self.dir = tempfile.mkdtemp() | |||
print(self.dir) | |||
@@ -43,15 +42,14 @@ class ConfigLoadingTestCase(unittest.TestCase): | |||
def test_generates_and_loads_macaroon_secret_key(self): | |||
self.generate_config() | |||
with open(self.file, | |||
"r") as f: | |||
with open(self.file, "r") as f: | |||
raw = yaml.load(f) | |||
self.assertIn("macaroon_secret_key", raw) | |||
config = HomeServerConfig.load_config("", ["-c", self.file]) | |||
self.assertTrue( | |||
hasattr(config, "macaroon_secret_key"), | |||
"Want config to have attr macaroon_secret_key" | |||
"Want config to have attr macaroon_secret_key", | |||
) | |||
if len(config.macaroon_secret_key) < 5: | |||
self.fail( | |||
@@ -62,7 +60,7 @@ class ConfigLoadingTestCase(unittest.TestCase): | |||
config = HomeServerConfig.load_or_generate_config("", ["-c", self.file]) | |||
self.assertTrue( | |||
hasattr(config, "macaroon_secret_key"), | |||
"Want config to have attr macaroon_secret_key" | |||
"Want config to have attr macaroon_secret_key", | |||
) | |||
if len(config.macaroon_secret_key) < 5: | |||
self.fail( | |||
@@ -80,10 +78,9 @@ class ConfigLoadingTestCase(unittest.TestCase): | |||
def test_disable_registration(self): | |||
self.generate_config() | |||
self.add_lines_to_config([ | |||
"enable_registration: true", | |||
"disable_registration: true", | |||
]) | |||
self.add_lines_to_config( | |||
["enable_registration: true", "disable_registration: true"] | |||
) | |||
# Check that disable_registration clobbers enable_registration. | |||
config = HomeServerConfig.load_config("", ["-c", self.file]) | |||
self.assertFalse(config.enable_registration) | |||
@@ -92,18 +89,23 @@ class ConfigLoadingTestCase(unittest.TestCase): | |||
self.assertFalse(config.enable_registration) | |||
# Check that either config value is clobbered by the command line. | |||
config = HomeServerConfig.load_or_generate_config("", [ | |||
"-c", self.file, "--enable-registration" | |||
]) | |||
config = HomeServerConfig.load_or_generate_config( | |||
"", ["-c", self.file, "--enable-registration"] | |||
) | |||
self.assertTrue(config.enable_registration) | |||
def generate_config(self): | |||
HomeServerConfig.load_or_generate_config("", [ | |||
"--generate-config", | |||
"-c", self.file, | |||
"--report-stats=yes", | |||
"-H", "lemurs.win" | |||
]) | |||
HomeServerConfig.load_or_generate_config( | |||
"", | |||
[ | |||
"--generate-config", | |||
"-c", | |||
self.file, | |||
"--report-stats=yes", | |||
"-H", | |||
"lemurs.win", | |||
], | |||
) | |||
def generate_config_and_remove_lines_containing(self, needle): | |||
self.generate_config() | |||
@@ -24,9 +24,7 @@ from tests import unittest | |||
# Perform these tests using given secret key so we get entirely deterministic | |||
# signatures output that we can test against. | |||
SIGNING_KEY_SEED = decode_base64( | |||
"YJDBA9Xnr2sVqXD9Vj7XVUnmFZcZrlw8Md7kMW+3XA1" | |||
) | |||
SIGNING_KEY_SEED = decode_base64("YJDBA9Xnr2sVqXD9Vj7XVUnmFZcZrlw8Md7kMW+3XA1") | |||
KEY_ALG = "ed25519" | |||
KEY_VER = 1 | |||
@@ -36,7 +34,6 @@ HOSTNAME = "domain" | |||
class EventSigningTestCase(unittest.TestCase): | |||
def setUp(self): | |||
self.signing_key = nacl.signing.SigningKey(SIGNING_KEY_SEED) | |||
self.signing_key.alg = KEY_ALG | |||
@@ -51,7 +48,7 @@ class EventSigningTestCase(unittest.TestCase): | |||
'signatures': {}, | |||
'type': "X", | |||
'unsigned': {'age_ts': 1000000}, | |||
}, | |||
} | |||
) | |||
add_hashes_and_signatures(builder, HOSTNAME, self.signing_key) | |||
@@ -61,8 +58,7 @@ class EventSigningTestCase(unittest.TestCase): | |||
self.assertTrue(hasattr(event, 'hashes')) | |||
self.assertIn('sha256', event.hashes) | |||
self.assertEquals( | |||
event.hashes['sha256'], | |||
"6tJjLpXtggfke8UxFhAKg82QVkJzvKOVOOSjUDK4ZSI", | |||
event.hashes['sha256'], "6tJjLpXtggfke8UxFhAKg82QVkJzvKOVOOSjUDK4ZSI" | |||
) | |||
self.assertTrue(hasattr(event, 'signatures')) | |||
@@ -77,9 +73,7 @@ class EventSigningTestCase(unittest.TestCase): | |||
def test_sign_message(self): | |||
builder = EventBuilder( | |||
{ | |||
'content': { | |||
'body': "Here is the message content", | |||
}, | |||
'content': {'body': "Here is the message content"}, | |||
'event_id': "$0:domain", | |||
'origin': "domain", | |||
'origin_server_ts': 1000000, | |||
@@ -98,8 +92,7 @@ class EventSigningTestCase(unittest.TestCase): | |||
self.assertTrue(hasattr(event, 'hashes')) | |||
self.assertIn('sha256', event.hashes) | |||
self.assertEquals( | |||
event.hashes['sha256'], | |||
"onLKD1bGljeBWQhWZ1kaP9SorVmRQNdN5aM2JYU2n/g", | |||
event.hashes['sha256'], "onLKD1bGljeBWQhWZ1kaP9SorVmRQNdN5aM2JYU2n/g" | |||
) | |||
self.assertTrue(hasattr(event, 'signatures')) | |||
@@ -108,5 +101,5 @@ class EventSigningTestCase(unittest.TestCase): | |||
self.assertEquals( | |||
event.signatures[HOSTNAME][KEY_NAME], | |||
"Wm+VzmOUOz08Ds+0NTWb1d4CZrVsJSikkeRxh6aCcUw" | |||
"u6pNC78FunoD7KNWzqFn241eYHYMGCA5McEiVPdhzBA" | |||
"u6pNC78FunoD7KNWzqFn241eYHYMGCA5McEiVPdhzBA", | |||
) |
@@ -36,9 +36,7 @@ class MockPerspectiveServer(object): | |||
def get_verify_keys(self): | |||
vk = signedjson.key.get_verify_key(self.key) | |||
return { | |||
"%s:%s" % (vk.alg, vk.version): vk, | |||
} | |||
return {"%s:%s" % (vk.alg, vk.version): vk} | |||
def get_signed_key(self, server_name, verify_key): | |||
key_id = "%s:%s" % (verify_key.alg, verify_key.version) | |||
@@ -47,10 +45,8 @@ class MockPerspectiveServer(object): | |||
"old_verify_keys": {}, | |||
"valid_until_ts": time.time() * 1000 + 3600, | |||
"verify_keys": { | |||
key_id: { | |||
"key": signedjson.key.encode_verify_key_base64(verify_key) | |||
} | |||
} | |||
key_id: {"key": signedjson.key.encode_verify_key_base64(verify_key)} | |||
}, | |||
} | |||
signedjson.sign.sign_json(res, self.server_name, self.key) | |||
return res | |||
@@ -62,18 +58,16 @@ class KeyringTestCase(unittest.TestCase): | |||
self.mock_perspective_server = MockPerspectiveServer() | |||
self.http_client = Mock() | |||
self.hs = yield utils.setup_test_homeserver( | |||
handlers=None, | |||
http_client=self.http_client, | |||
handlers=None, http_client=self.http_client | |||
) | |||
keys = self.mock_perspective_server.get_verify_keys() | |||
self.hs.config.perspectives = { | |||
self.mock_perspective_server.server_name: | |||
self.mock_perspective_server.get_verify_keys() | |||
self.mock_perspective_server.server_name: keys | |||
} | |||
def check_context(self, _, expected): | |||
self.assertEquals( | |||
getattr(LoggingContext.current_context(), "request", None), | |||
expected | |||
getattr(LoggingContext.current_context(), "request", None), expected | |||
) | |||
@defer.inlineCallbacks | |||
@@ -89,8 +83,7 @@ class KeyringTestCase(unittest.TestCase): | |||
context_one.request = "one" | |||
wait_1_deferred = kr.wait_for_previous_lookups( | |||
["server1"], | |||
{"server1": lookup_1_deferred}, | |||
["server1"], {"server1": lookup_1_deferred} | |||
) | |||
# there were no previous lookups, so the deferred should be ready | |||
@@ -105,8 +98,7 @@ class KeyringTestCase(unittest.TestCase): | |||
# set off another wait. It should block because the first lookup | |||
# hasn't yet completed. | |||
wait_2_deferred = kr.wait_for_previous_lookups( | |||
["server1"], | |||
{"server1": lookup_2_deferred}, | |||
["server1"], {"server1": lookup_2_deferred} | |||
) | |||
self.assertFalse(wait_2_deferred.called) | |||
# ... so we should have reset the LoggingContext. | |||
@@ -132,21 +124,19 @@ class KeyringTestCase(unittest.TestCase): | |||
persp_resp = { | |||
"server_keys": [ | |||
self.mock_perspective_server.get_signed_key( | |||
"server10", | |||
signedjson.key.get_verify_key(key1) | |||
), | |||
"server10", signedjson.key.get_verify_key(key1) | |||
) | |||
] | |||
} | |||
persp_deferred = defer.Deferred() | |||
@defer.inlineCallbacks | |||
def get_perspectives(**kwargs): | |||
self.assertEquals( | |||
LoggingContext.current_context().request, "11", | |||
) | |||
self.assertEquals(LoggingContext.current_context().request, "11") | |||
with logcontext.PreserveLoggingContext(): | |||
yield persp_deferred | |||
defer.returnValue(persp_resp) | |||
self.http_client.post_json.side_effect = get_perspectives | |||
with LoggingContext("11") as context_11: | |||
@@ -154,9 +144,7 @@ class KeyringTestCase(unittest.TestCase): | |||
# start off a first set of lookups | |||
res_deferreds = kr.verify_json_objects_for_server( | |||
[("server10", json1), | |||
("server11", {}) | |||
] | |||
[("server10", json1), ("server11", {})] | |||
) | |||
# the unsigned json should be rejected pretty quickly | |||
@@ -172,7 +160,7 @@ class KeyringTestCase(unittest.TestCase): | |||
# wait a tick for it to send the request to the perspectives server | |||
# (it first tries the datastore) | |||
yield clock.sleep(1) # XXX find out why this takes so long! | |||
yield clock.sleep(1) # XXX find out why this takes so long! | |||
self.http_client.post_json.assert_called_once() | |||
self.assertIs(LoggingContext.current_context(), context_11) | |||
@@ -186,7 +174,7 @@ class KeyringTestCase(unittest.TestCase): | |||
self.http_client.post_json.return_value = defer.Deferred() | |||
res_deferreds_2 = kr.verify_json_objects_for_server( | |||
[("server10", json1)], | |||
[("server10", json1)] | |||
) | |||
yield clock.sleep(1) | |||
self.http_client.post_json.assert_not_called() | |||
@@ -207,8 +195,7 @@ class KeyringTestCase(unittest.TestCase): | |||
key1 = signedjson.key.generate_signing_key(1) | |||
yield self.hs.datastore.store_server_verify_key( | |||
"server9", "", time.time() * 1000, | |||
signedjson.key.get_verify_key(key1), | |||
"server9", "", time.time() * 1000, signedjson.key.get_verify_key(key1) | |||
) | |||
json1 = {} | |||
signedjson.sign.sign_json(json1, "server9", key1) | |||
@@ -31,25 +31,20 @@ def MockEvent(**kwargs): | |||
class PruneEventTestCase(unittest.TestCase): | |||
""" Asserts that a new event constructed with `evdict` will look like | |||
`matchdict` when it is redacted. """ | |||
def run_test(self, evdict, matchdict): | |||
self.assertEquals( | |||
prune_event(FrozenEvent(evdict)).get_dict(), | |||
matchdict | |||
) | |||
self.assertEquals(prune_event(FrozenEvent(evdict)).get_dict(), matchdict) | |||
def test_minimal(self): | |||
self.run_test( | |||
{ | |||
'type': 'A', | |||
'event_id': '$test:domain', | |||
}, | |||
{'type': 'A', 'event_id': '$test:domain'}, | |||
{ | |||
'type': 'A', | |||
'event_id': '$test:domain', | |||
'content': {}, | |||
'signatures': {}, | |||
'unsigned': {}, | |||
} | |||
}, | |||
) | |||
def test_basic_keys(self): | |||
@@ -70,23 +65,19 @@ class PruneEventTestCase(unittest.TestCase): | |||
'content': {}, | |||
'signatures': {}, | |||
'unsigned': {}, | |||
} | |||
}, | |||
) | |||
def test_unsigned_age_ts(self): | |||
self.run_test( | |||
{ | |||
'type': 'B', | |||
'event_id': '$test:domain', | |||
'unsigned': {'age_ts': 20}, | |||
}, | |||
{'type': 'B', 'event_id': '$test:domain', 'unsigned': {'age_ts': 20}}, | |||
{ | |||
'type': 'B', | |||
'event_id': '$test:domain', | |||
'content': {}, | |||
'signatures': {}, | |||
'unsigned': {'age_ts': 20}, | |||
} | |||
}, | |||
) | |||
self.run_test( | |||
@@ -101,23 +92,19 @@ class PruneEventTestCase(unittest.TestCase): | |||
'content': {}, | |||
'signatures': {}, | |||
'unsigned': {}, | |||
} | |||
}, | |||
) | |||
def test_content(self): | |||
self.run_test( | |||
{ | |||
'type': 'C', | |||
'event_id': '$test:domain', | |||
'content': {'things': 'here'}, | |||
}, | |||
{'type': 'C', 'event_id': '$test:domain', 'content': {'things': 'here'}}, | |||
{ | |||
'type': 'C', | |||
'event_id': '$test:domain', | |||
'content': {}, | |||
'signatures': {}, | |||
'unsigned': {}, | |||
} | |||
}, | |||
) | |||
self.run_test( | |||
@@ -132,27 +119,20 @@ class PruneEventTestCase(unittest.TestCase): | |||
'content': {'creator': '@2:domain'}, | |||
'signatures': {}, | |||
'unsigned': {}, | |||
} | |||
}, | |||
) | |||
class SerializeEventTestCase(unittest.TestCase): | |||
def serialize(self, ev, fields): | |||
return serialize_event(ev, 1479807801915, only_event_fields=fields) | |||
def test_event_fields_works_with_keys(self): | |||
self.assertEquals( | |||
self.serialize( | |||
MockEvent( | |||
sender="@alice:localhost", | |||
room_id="!foo:bar" | |||
), | |||
["room_id"] | |||
MockEvent(sender="@alice:localhost", room_id="!foo:bar"), ["room_id"] | |||
), | |||
{ | |||
"room_id": "!foo:bar", | |||
} | |||
{"room_id": "!foo:bar"}, | |||
) | |||
def test_event_fields_works_with_nested_keys(self): | |||
@@ -161,17 +141,11 @@ class SerializeEventTestCase(unittest.TestCase): | |||
MockEvent( | |||
sender="@alice:localhost", | |||
room_id="!foo:bar", | |||
content={ | |||
"body": "A message", | |||
}, | |||
content={"body": "A message"}, | |||
), | |||
["content.body"] | |||
["content.body"], | |||
), | |||
{ | |||
"content": { | |||
"body": "A message", | |||
} | |||
} | |||
{"content": {"body": "A message"}}, | |||
) | |||
def test_event_fields_works_with_dot_keys(self): | |||
@@ -180,17 +154,11 @@ class SerializeEventTestCase(unittest.TestCase): | |||
MockEvent( | |||
sender="@alice:localhost", | |||
room_id="!foo:bar", | |||
content={ | |||
"key.with.dots": {}, | |||
}, | |||
content={"key.with.dots": {}}, | |||
), | |||
["content.key\.with\.dots"] | |||
["content.key\.with\.dots"], | |||
), | |||
{ | |||
"content": { | |||
"key.with.dots": {}, | |||
} | |||
} | |||
{"content": {"key.with.dots": {}}}, | |||
) | |||
def test_event_fields_works_with_nested_dot_keys(self): | |||
@@ -201,21 +169,12 @@ class SerializeEventTestCase(unittest.TestCase): | |||
room_id="!foo:bar", | |||
content={ | |||
"not_me": 1, | |||
"nested.dot.key": { | |||
"leaf.key": 42, | |||
"not_me_either": 1, | |||
}, | |||
"nested.dot.key": {"leaf.key": 42, "not_me_either": 1}, | |||
}, | |||
), | |||
["content.nested\.dot\.key.leaf\.key"] | |||
["content.nested\.dot\.key.leaf\.key"], | |||
), | |||
{ | |||
"content": { | |||
"nested.dot.key": { | |||
"leaf.key": 42, | |||
}, | |||
} | |||
} | |||
{"content": {"nested.dot.key": {"leaf.key": 42}}}, | |||
) | |||
def test_event_fields_nops_with_unknown_keys(self): | |||
@@ -224,17 +183,11 @@ class SerializeEventTestCase(unittest.TestCase): | |||
MockEvent( | |||
sender="@alice:localhost", | |||
room_id="!foo:bar", | |||
content={ | |||
"foo": "bar", | |||
}, | |||
content={"foo": "bar"}, | |||
), | |||
["content.foo", "content.notexists"] | |||
["content.foo", "content.notexists"], | |||
), | |||
{ | |||
"content": { | |||
"foo": "bar", | |||
} | |||
} | |||
{"content": {"foo": "bar"}}, | |||
) | |||
def test_event_fields_nops_with_non_dict_keys(self): | |||
@@ -243,13 +196,11 @@ class SerializeEventTestCase(unittest.TestCase): | |||
MockEvent( | |||
sender="@alice:localhost", | |||
room_id="!foo:bar", | |||
content={ | |||
"foo": ["I", "am", "an", "array"], | |||
}, | |||
content={"foo": ["I", "am", "an", "array"]}, | |||
), | |||
["content.foo.am"] | |||
["content.foo.am"], | |||
), | |||
{} | |||
{}, | |||
) | |||
def test_event_fields_nops_with_array_keys(self): | |||
@@ -258,13 +209,11 @@ class SerializeEventTestCase(unittest.TestCase): | |||
MockEvent( | |||
sender="@alice:localhost", | |||
room_id="!foo:bar", | |||
content={ | |||
"foo": ["I", "am", "an", "array"], | |||
}, | |||
content={"foo": ["I", "am", "an", "array"]}, | |||
), | |||
["content.foo.1"] | |||
["content.foo.1"], | |||
), | |||
{} | |||
{}, | |||
) | |||
def test_event_fields_all_fields_if_empty(self): | |||
@@ -274,31 +223,21 @@ class SerializeEventTestCase(unittest.TestCase): | |||
type="foo", | |||
event_id="test", | |||
room_id="!foo:bar", | |||
content={ | |||
"foo": "bar", | |||
}, | |||
content={"foo": "bar"}, | |||
), | |||
[] | |||
[], | |||
), | |||
{ | |||
"type": "foo", | |||
"event_id": "test", | |||
"room_id": "!foo:bar", | |||
"content": { | |||
"foo": "bar", | |||
}, | |||
"unsigned": {} | |||
} | |||
"content": {"foo": "bar"}, | |||
"unsigned": {}, | |||
}, | |||
) | |||
def test_event_fields_fail_if_fields_not_str(self): | |||
with self.assertRaises(TypeError): | |||
self.serialize( | |||
MockEvent( | |||
room_id="!foo:bar", | |||
content={ | |||
"foo": "bar", | |||
}, | |||
), | |||
["room_id", 4] | |||
MockEvent(room_id="!foo:bar", content={"foo": "bar"}), ["room_id", 4] | |||
) |
@@ -23,10 +23,7 @@ from tests import unittest | |||
@unittest.DEBUG | |||
class ServerACLsTestCase(unittest.TestCase): | |||
def test_blacklisted_server(self): | |||
e = _create_acl_event({ | |||
"allow": ["*"], | |||
"deny": ["evil.com"], | |||
}) | |||
e = _create_acl_event({"allow": ["*"], "deny": ["evil.com"]}) | |||
logging.info("ACL event: %s", e.content) | |||
self.assertFalse(server_matches_acl_event("evil.com", e)) | |||
@@ -36,10 +33,7 @@ class ServerACLsTestCase(unittest.TestCase): | |||
self.assertTrue(server_matches_acl_event("honestly.not.evil.com", e)) | |||
def test_block_ip_literals(self): | |||
e = _create_acl_event({ | |||
"allow_ip_literals": False, | |||
"allow": ["*"], | |||
}) | |||
e = _create_acl_event({"allow_ip_literals": False, "allow": ["*"]}) | |||
logging.info("ACL event: %s", e.content) | |||
self.assertFalse(server_matches_acl_event("1.2.3.4", e)) | |||
@@ -49,10 +43,12 @@ class ServerACLsTestCase(unittest.TestCase): | |||
def _create_acl_event(content): | |||
return FrozenEvent({ | |||
"room_id": "!a:b", | |||
"event_id": "$a:b", | |||
"type": "m.room.server_acls", | |||
"sender": "@a:b", | |||
"content": content | |||
}) | |||
return FrozenEvent( | |||
{ | |||
"room_id": "!a:b", | |||
"event_id": "$a:b", | |||
"type": "m.room.server_acls", | |||
"sender": "@a:b", | |||
"content": content, | |||
} | |||
) |
@@ -45,20 +45,18 @@ class AppServiceHandlerTestCase(unittest.TestCase): | |||
services = [ | |||
self._mkservice(is_interested=False), | |||
interested_service, | |||
self._mkservice(is_interested=False) | |||
self._mkservice(is_interested=False), | |||
] | |||
self.mock_store.get_app_services = Mock(return_value=services) | |||
self.mock_store.get_user_by_id = Mock(return_value=[]) | |||
event = Mock( | |||
sender="@someone:anywhere", | |||
type="m.room.message", | |||
room_id="!foo:bar" | |||
sender="@someone:anywhere", type="m.room.message", room_id="!foo:bar" | |||
) | |||
self.mock_store.get_new_events_for_appservice.side_effect = [ | |||
(0, [event]), | |||
(0, []) | |||
(0, []), | |||
] | |||
self.mock_as_api.push = Mock() | |||
yield self.handler.notify_interested_services(0) | |||
@@ -74,21 +72,15 @@ class AppServiceHandlerTestCase(unittest.TestCase): | |||
self.mock_store.get_app_services = Mock(return_value=services) | |||
self.mock_store.get_user_by_id = Mock(return_value=None) | |||
event = Mock( | |||
sender=user_id, | |||
type="m.room.message", | |||
room_id="!foo:bar" | |||
) | |||
event = Mock(sender=user_id, type="m.room.message", room_id="!foo:bar") | |||
self.mock_as_api.push = Mock() | |||
self.mock_as_api.query_user = Mock() | |||
self.mock_store.get_new_events_for_appservice.side_effect = [ | |||
(0, [event]), | |||
(0, []) | |||
(0, []), | |||
] | |||
yield self.handler.notify_interested_services(0) | |||
self.mock_as_api.query_user.assert_called_once_with( | |||
services[0], user_id | |||
) | |||
self.mock_as_api.query_user.assert_called_once_with(services[0], user_id) | |||
@defer.inlineCallbacks | |||
def test_query_user_exists_known_user(self): | |||
@@ -96,25 +88,19 @@ class AppServiceHandlerTestCase(unittest.TestCase): | |||
services = [self._mkservice(is_interested=True)] | |||
services[0].is_interested_in_user = Mock(return_value=True) | |||
self.mock_store.get_app_services = Mock(return_value=services) | |||
self.mock_store.get_user_by_id = Mock(return_value={ | |||
"name": user_id | |||
}) | |||
self.mock_store.get_user_by_id = Mock(return_value={"name": user_id}) | |||
event = Mock( | |||
sender=user_id, | |||
type="m.room.message", | |||
room_id="!foo:bar" | |||
) | |||
event = Mock(sender=user_id, type="m.room.message", room_id="!foo:bar") | |||
self.mock_as_api.push = Mock() | |||
self.mock_as_api.query_user = Mock() | |||
self.mock_store.get_new_events_for_appservice.side_effect = [ | |||
(0, [event]), | |||
(0, []) | |||
(0, []), | |||
] | |||
yield self.handler.notify_interested_services(0) | |||
self.assertFalse( | |||
self.mock_as_api.query_user.called, | |||
"query_user called when it shouldn't have been." | |||
"query_user called when it shouldn't have been.", | |||
) | |||
@defer.inlineCallbacks | |||
@@ -129,7 +115,7 @@ class AppServiceHandlerTestCase(unittest.TestCase): | |||
services = [ | |||
self._mkservice_alias(is_interested_in_alias=False), | |||
interested_service, | |||
self._mkservice_alias(is_interested_in_alias=False) | |||
self._mkservice_alias(is_interested_in_alias=False), | |||
] | |||
self.mock_store.get_app_services = Mock(return_value=services) | |||
@@ -140,8 +126,7 @@ class AppServiceHandlerTestCase(unittest.TestCase): | |||
result = yield self.handler.query_room_alias_exists(room_alias) | |||
self.mock_as_api.query_alias.assert_called_once_with( | |||
interested_service, | |||
room_alias_str | |||
interested_service, room_alias_str | |||
) | |||
self.assertEquals(result.room_id, room_id) | |||
self.assertEquals(result.servers, servers) | |||
@@ -81,9 +81,7 @@ class AuthTestCase(unittest.TestCase): | |||
def test_short_term_login_token_gives_user_id(self): | |||
self.hs.clock.now = 1000 | |||
token = self.macaroon_generator.generate_short_term_login_token( | |||
"a_user", 5000 | |||
) | |||
token = self.macaroon_generator.generate_short_term_login_token("a_user", 5000) | |||
user_id = yield self.auth_handler.validate_short_term_login_token_and_get_user_id( | |||
token | |||
) | |||
@@ -98,17 +96,13 @@ class AuthTestCase(unittest.TestCase): | |||
@defer.inlineCallbacks | |||
def test_short_term_login_token_cannot_replace_user_id(self): | |||
token = self.macaroon_generator.generate_short_term_login_token( | |||
"a_user", 5000 | |||
) | |||
token = self.macaroon_generator.generate_short_term_login_token("a_user", 5000) | |||
macaroon = pymacaroons.Macaroon.deserialize(token) | |||
user_id = yield self.auth_handler.validate_short_term_login_token_and_get_user_id( | |||
macaroon.serialize() | |||
) | |||
self.assertEqual( | |||
"a_user", user_id | |||
) | |||
self.assertEqual("a_user", user_id) | |||
# add another "user_id" caveat, which might allow us to override the | |||
# user_id. | |||
@@ -165,7 +159,5 @@ class AuthTestCase(unittest.TestCase): | |||
) | |||
def _get_macaroon(self): | |||
token = self.macaroon_generator.generate_short_term_login_token( | |||
"user_a", 5000 | |||
) | |||
token = self.macaroon_generator.generate_short_term_login_token("user_a", 5000) | |||
return pymacaroons.Macaroon.deserialize(token) |
@@ -28,9 +28,9 @@ user2 = "@theresa:bbb" | |||
class DeviceTestCase(unittest.TestCase): | |||
def __init__(self, *args, **kwargs): | |||
super(DeviceTestCase, self).__init__(*args, **kwargs) | |||
self.store = None # type: synapse.storage.DataStore | |||
self.store = None # type: synapse.storage.DataStore | |||
self.handler = None # type: synapse.handlers.device.DeviceHandler | |||
self.clock = None # type: utils.MockClock | |||
self.clock = None # type: utils.MockClock | |||
@defer.inlineCallbacks | |||
def setUp(self): | |||
@@ -44,7 +44,7 @@ class DeviceTestCase(unittest.TestCase): | |||
res = yield self.handler.check_device_registered( | |||
user_id="@boris:foo", | |||
device_id="fco", | |||
initial_device_display_name="display name" | |||
initial_device_display_name="display name", | |||
) | |||
self.assertEqual(res, "fco") | |||
@@ -56,14 +56,14 @@ class DeviceTestCase(unittest.TestCase): | |||
res1 = yield self.handler.check_device_registered( | |||
user_id="@boris:foo", | |||
device_id="fco", | |||
initial_device_display_name="display name" | |||
initial_device_display_name="display name", | |||
) | |||
self.assertEqual(res1, "fco") | |||
res2 = yield self.handler.check_device_registered( | |||
user_id="@boris:foo", | |||
device_id="fco", | |||
initial_device_display_name="new display name" | |||
initial_device_display_name="new display name", | |||
) | |||
self.assertEqual(res2, "fco") | |||
@@ -75,7 +75,7 @@ class DeviceTestCase(unittest.TestCase): | |||
device_id = yield self.handler.check_device_registered( | |||
user_id="@theresa:foo", | |||
device_id=None, | |||
initial_device_display_name="display" | |||
initial_device_display_name="display", | |||
) | |||
dev = yield self.handler.store.get_device("@theresa:foo", device_id) | |||
@@ -87,43 +87,53 @@ class DeviceTestCase(unittest.TestCase): | |||
res = yield self.handler.get_devices_by_user(user1) | |||
self.assertEqual(3, len(res)) | |||
device_map = { | |||
d["device_id"]: d for d in res | |||
} | |||
self.assertDictContainsSubset({ | |||
"user_id": user1, | |||
"device_id": "xyz", | |||
"display_name": "display 0", | |||
"last_seen_ip": None, | |||
"last_seen_ts": None, | |||
}, device_map["xyz"]) | |||
self.assertDictContainsSubset({ | |||
"user_id": user1, | |||
"device_id": "fco", | |||
"display_name": "display 1", | |||
"last_seen_ip": "ip1", | |||
"last_seen_ts": 1000000, | |||
}, device_map["fco"]) | |||
self.assertDictContainsSubset({ | |||
"user_id": user1, | |||
"device_id": "abc", | |||
"display_name": "display 2", | |||
"last_seen_ip": "ip3", | |||
"last_seen_ts": 3000000, | |||
}, device_map["abc"]) | |||
device_map = {d["device_id"]: d for d in res} | |||
self.assertDictContainsSubset( | |||
{ | |||
"user_id": user1, | |||
"device_id": "xyz", | |||
"display_name": "display 0", | |||
"last_seen_ip": None, | |||
"last_seen_ts": None, | |||
}, | |||
device_map["xyz"], | |||
) | |||
self.assertDictContainsSubset( | |||
{ | |||
"user_id": user1, | |||
"device_id": "fco", | |||
"display_name": "display 1", | |||
"last_seen_ip": "ip1", | |||
"last_seen_ts": 1000000, | |||
}, | |||
device_map["fco"], | |||
) | |||
self.assertDictContainsSubset( | |||
{ | |||
"user_id": user1, | |||
"device_id": "abc", | |||
"display_name": "display 2", | |||
"last_seen_ip": "ip3", | |||
"last_seen_ts": 3000000, | |||
}, | |||
device_map["abc"], | |||
) | |||
@defer.inlineCallbacks | |||
def test_get_device(self): | |||
yield self._record_users() | |||
res = yield self.handler.get_device(user1, "abc") | |||
self.assertDictContainsSubset({ | |||
"user_id": user1, | |||
"device_id": "abc", | |||
"display_name": "display 2", | |||
"last_seen_ip": "ip3", | |||
"last_seen_ts": 3000000, | |||
}, res) | |||
self.assertDictContainsSubset( | |||
{ | |||
"user_id": user1, | |||
"device_id": "abc", | |||
"display_name": "display 2", | |||
"last_seen_ip": "ip3", | |||
"last_seen_ts": 3000000, | |||
}, | |||
res, | |||
) | |||
@defer.inlineCallbacks | |||
def test_delete_device(self): | |||
@@ -153,8 +163,7 @@ class DeviceTestCase(unittest.TestCase): | |||
def test_update_unknown_device(self): | |||
update = {"display_name": "new_display"} | |||
with self.assertRaises(synapse.api.errors.NotFoundError): | |||
yield self.handler.update_device("user_id", "unknown_device_id", | |||
update) | |||
yield self.handler.update_device("user_id", "unknown_device_id", update) | |||
@defer.inlineCallbacks | |||
def _record_users(self): | |||
@@ -168,16 +177,17 @@ class DeviceTestCase(unittest.TestCase): | |||
yield self._record_user(user2, "def", "dispkay", "token4", "ip4") | |||
@defer.inlineCallbacks | |||
def _record_user(self, user_id, device_id, display_name, | |||
access_token=None, ip=None): | |||
def _record_user( | |||
self, user_id, device_id, display_name, access_token=None, ip=None | |||
): | |||
device_id = yield self.handler.check_device_registered( | |||
user_id=user_id, | |||
device_id=device_id, | |||
initial_device_display_name=display_name | |||
initial_device_display_name=display_name, | |||
) | |||
if ip is not None: | |||
yield self.store.insert_client_ip( | |||
user_id, | |||
access_token, ip, "user_agent", device_id) | |||
user_id, access_token, ip, "user_agent", device_id | |||
) | |||
self.clock.advance_time(1000) |
@@ -42,6 +42,7 @@ class DirectoryTestCase(unittest.TestCase): | |||
def register_query_handler(query_type, handler): | |||
self.query_handlers[query_type] = handler | |||
self.mock_registry.register_query_handler = register_query_handler | |||
hs = yield setup_test_homeserver( | |||
@@ -68,10 +69,7 @@ class DirectoryTestCase(unittest.TestCase): | |||
result = yield self.handler.get_association(self.my_room) | |||
self.assertEquals({ | |||
"room_id": "!8765qwer:test", | |||
"servers": ["test"], | |||
}, result) | |||
self.assertEquals({"room_id": "!8765qwer:test", "servers": ["test"]}, result) | |||
@defer.inlineCallbacks | |||
def test_get_remote_association(self): | |||
@@ -81,16 +79,13 @@ class DirectoryTestCase(unittest.TestCase): | |||
result = yield self.handler.get_association(self.remote_room) | |||
self.assertEquals({ | |||
"room_id": "!8765qwer:test", | |||
"servers": ["test", "remote"], | |||
}, result) | |||
self.assertEquals( | |||
{"room_id": "!8765qwer:test", "servers": ["test", "remote"]}, result | |||
) | |||
self.mock_federation.make_query.assert_called_with( | |||
destination="remote", | |||
query_type="directory", | |||
args={ | |||
"room_alias": "#another:remote", | |||
}, | |||
args={"room_alias": "#another:remote"}, | |||
retry_on_dns_fail=False, | |||
ignore_backoff=True, | |||
) | |||
@@ -105,7 +100,4 @@ class DirectoryTestCase(unittest.TestCase): | |||
{"room_alias": "#your-room:test"} | |||
) | |||
self.assertEquals({ | |||
"room_id": "!8765asdf:test", | |||
"servers": ["test"], | |||
}, response) | |||
self.assertEquals({"room_id": "!8765asdf:test", "servers": ["test"]}, response) |
@@ -28,14 +28,13 @@ from tests import unittest, utils | |||
class E2eKeysHandlerTestCase(unittest.TestCase): | |||
def __init__(self, *args, **kwargs): | |||
super(E2eKeysHandlerTestCase, self).__init__(*args, **kwargs) | |||
self.hs = None # type: synapse.server.HomeServer | |||
self.hs = None # type: synapse.server.HomeServer | |||
self.handler = None # type: synapse.handlers.e2e_keys.E2eKeysHandler | |||
@defer.inlineCallbacks | |||
def setUp(self): | |||
self.hs = yield utils.setup_test_homeserver( | |||
handlers=None, | |||
federation_client=mock.Mock(), | |||
handlers=None, federation_client=mock.Mock() | |||
) | |||
self.handler = synapse.handlers.e2e_keys.E2eKeysHandler(self.hs) | |||
@@ -54,30 +53,21 @@ class E2eKeysHandlerTestCase(unittest.TestCase): | |||
device_id = "xyz" | |||
keys = { | |||
"alg1:k1": "key1", | |||
"alg2:k2": { | |||
"key": "key2", | |||
"signatures": {"k1": "sig1"} | |||
}, | |||
"alg2:k3": { | |||
"key": "key3", | |||
}, | |||
"alg2:k2": {"key": "key2", "signatures": {"k1": "sig1"}}, | |||
"alg2:k3": {"key": "key3"}, | |||
} | |||
res = yield self.handler.upload_keys_for_user( | |||
local_user, device_id, {"one_time_keys": keys}, | |||
local_user, device_id, {"one_time_keys": keys} | |||
) | |||
self.assertDictEqual(res, { | |||
"one_time_key_counts": {"alg1": 1, "alg2": 2} | |||
}) | |||
self.assertDictEqual(res, {"one_time_key_counts": {"alg1": 1, "alg2": 2}}) | |||
# we should be able to change the signature without a problem | |||
keys["alg2:k2"]["signatures"]["k1"] = "sig2" | |||
res = yield self.handler.upload_keys_for_user( | |||
local_user, device_id, {"one_time_keys": keys}, | |||
local_user, device_id, {"one_time_keys": keys} | |||
) | |||
self.assertDictEqual(res, { | |||
"one_time_key_counts": {"alg1": 1, "alg2": 2} | |||
}) | |||
self.assertDictEqual(res, {"one_time_key_counts": {"alg1": 1, "alg2": 2}}) | |||
@defer.inlineCallbacks | |||
def test_change_one_time_keys(self): | |||
@@ -87,25 +77,18 @@ class E2eKeysHandlerTestCase(unittest.TestCase): | |||
device_id = "xyz" | |||
keys = { | |||
"alg1:k1": "key1", | |||
"alg2:k2": { | |||
"key": "key2", | |||
"signatures": {"k1": "sig1"} | |||
}, | |||
"alg2:k3": { | |||
"key": "key3", | |||
}, | |||
"alg2:k2": {"key": "key2", "signatures": {"k1": "sig1"}}, | |||
"alg2:k3": {"key": "key3"}, | |||
} | |||
res = yield self.handler.upload_keys_for_user( | |||
local_user, device_id, {"one_time_keys": keys}, | |||
local_user, device_id, {"one_time_keys": keys} | |||
) | |||
self.assertDictEqual(res, { | |||
"one_time_key_counts": {"alg1": 1, "alg2": 2} | |||
}) | |||
self.assertDictEqual(res, {"one_time_key_counts": {"alg1": 1, "alg2": 2}}) | |||
try: | |||
yield self.handler.upload_keys_for_user( | |||
local_user, device_id, {"one_time_keys": {"alg1:k1": "key2"}}, | |||
local_user, device_id, {"one_time_keys": {"alg1:k1": "key2"}} | |||
) | |||
self.fail("No error when changing string key") | |||
except errors.SynapseError: | |||
@@ -113,7 +96,7 @@ class E2eKeysHandlerTestCase(unittest.TestCase): | |||
try: | |||
yield self.handler.upload_keys_for_user( | |||
local_user, device_id, {"one_time_keys": {"alg2:k3": "key2"}}, | |||
local_user, device_id, {"one_time_keys": {"alg2:k3": "key2"}} | |||
) | |||
self.fail("No error when replacing dict key with string") | |||
except errors.SynapseError: | |||
@@ -121,9 +104,7 @@ class E2eKeysHandlerTestCase(unittest.TestCase): | |||
try: | |||
yield self.handler.upload_keys_for_user( | |||
local_user, device_id, { | |||
"one_time_keys": {"alg1:k1": {"key": "key"}} | |||
}, | |||
local_user, device_id, {"one_time_keys": {"alg1:k1": {"key": "key"}}} | |||
) | |||
self.fail("No error when replacing string key with dict") | |||
except errors.SynapseError: | |||
@@ -131,13 +112,12 @@ class E2eKeysHandlerTestCase(unittest.TestCase): | |||
try: | |||
yield self.handler.upload_keys_for_user( | |||
local_user, device_id, { | |||
local_user, | |||
device_id, | |||
{ | |||
"one_time_keys": { | |||
"alg2:k2": { | |||
"key": "key3", | |||
"signatures": {"k1": "sig1"}, | |||
} | |||
}, | |||
"alg2:k2": {"key": "key3", "signatures": {"k1": "sig1"}} | |||
} | |||
}, | |||
) | |||
self.fail("No error when replacing dict key") | |||
@@ -148,31 +128,20 @@ class E2eKeysHandlerTestCase(unittest.TestCase): | |||
def test_claim_one_time_key(self): | |||
local_user = "@boris:" + self.hs.hostname | |||
device_id = "xyz" | |||
keys = { | |||
"alg1:k1": "key1", | |||
} | |||
keys = {"alg1:k1": "key1"} | |||
res = yield self.handler.upload_keys_for_user( | |||
local_user, device_id, {"one_time_keys": keys}, | |||
local_user, device_id, {"one_time_keys": keys} | |||
) | |||
self.assertDictEqual(res, {"one_time_key_counts": {"alg1": 1}}) | |||
res2 = yield self.handler.claim_one_time_keys( | |||
{"one_time_keys": {local_user: {device_id: "alg1"}}}, timeout=None | |||
) | |||
self.assertEqual( | |||
res2, | |||
{ | |||
"failures": {}, | |||
"one_time_keys": {local_user: {device_id: {"alg1:k1": "key1"}}}, | |||
}, | |||
) | |||
self.assertDictEqual(res, { | |||
"one_time_key_counts": {"alg1": 1} | |||
}) | |||
res2 = yield self.handler.claim_one_time_keys({ | |||
"one_time_keys": { | |||
local_user: { | |||
device_id: "alg1" | |||
} | |||
} | |||
}, timeout=None) | |||
self.assertEqual(res2, { | |||
"failures": {}, | |||
"one_time_keys": { | |||
local_user: { | |||
device_id: { | |||
"alg1:k1": "key1" | |||
} | |||
} | |||
} | |||
}) |
@@ -39,8 +39,7 @@ class PresenceUpdateTestCase(unittest.TestCase): | |||
prev_state = UserPresenceState.default(user_id) | |||
new_state = prev_state.copy_and_replace( | |||
state=PresenceState.ONLINE, | |||
last_active_ts=now, | |||
state=PresenceState.ONLINE, last_active_ts=now | |||
) | |||
state, persist_and_notify, federation_ping = handle_update( | |||
@@ -54,23 +53,22 @@ class PresenceUpdateTestCase(unittest.TestCase): | |||
self.assertEquals(state.last_federation_update_ts, now) | |||
self.assertEquals(wheel_timer.insert.call_count, 3) | |||
wheel_timer.insert.assert_has_calls([ | |||
call( | |||
now=now, | |||
obj=user_id, | |||
then=new_state.last_active_ts + IDLE_TIMER | |||
), | |||
call( | |||
now=now, | |||
obj=user_id, | |||
then=new_state.last_user_sync_ts + SYNC_ONLINE_TIMEOUT | |||
), | |||
call( | |||
now=now, | |||
obj=user_id, | |||
then=new_state.last_active_ts + LAST_ACTIVE_GRANULARITY | |||
), | |||
], any_order=True) | |||
wheel_timer.insert.assert_has_calls( | |||
[ | |||
call(now=now, obj=user_id, then=new_state.last_active_ts + IDLE_TIMER), | |||
call( | |||
now=now, | |||
obj=user_id, | |||
then=new_state.last_user_sync_ts + SYNC_ONLINE_TIMEOUT, | |||
), | |||
call( | |||
now=now, | |||
obj=user_id, | |||
then=new_state.last_active_ts + LAST_ACTIVE_GRANULARITY, | |||
), | |||
], | |||
any_order=True, | |||
) | |||
def test_online_to_online(self): | |||
wheel_timer = Mock() | |||
@@ -79,14 +77,11 @@ class PresenceUpdateTestCase(unittest.TestCase): | |||
prev_state = UserPresenceState.default(user_id) | |||
prev_state = prev_state.copy_and_replace( | |||
state=PresenceState.ONLINE, | |||
last_active_ts=now, | |||
currently_active=True, | |||
state=PresenceState.ONLINE, last_active_ts=now, currently_active=True | |||
) | |||
new_state = prev_state.copy_and_replace( | |||
state=PresenceState.ONLINE, | |||
last_active_ts=now, | |||
state=PresenceState.ONLINE, last_active_ts=now | |||
) | |||
state, persist_and_notify, federation_ping = handle_update( | |||
@@ -101,23 +96,22 @@ class PresenceUpdateTestCase(unittest.TestCase): | |||
self.assertEquals(state.last_federation_update_ts, now) | |||
self.assertEquals(wheel_timer.insert.call_count, 3) | |||
wheel_timer.insert.assert_has_calls([ | |||
call( | |||
now=now, | |||
obj=user_id, | |||
then=new_state.last_active_ts + IDLE_TIMER | |||
), | |||
call( | |||
now=now, | |||
obj=user_id, | |||
then=new_state.last_user_sync_ts + SYNC_ONLINE_TIMEOUT | |||
), | |||
call( | |||
now=now, | |||
obj=user_id, | |||
then=new_state.last_active_ts + LAST_ACTIVE_GRANULARITY | |||
), | |||
], any_order=True) | |||
wheel_timer.insert.assert_has_calls( | |||
[ | |||
call(now=now, obj=user_id, then=new_state.last_active_ts + IDLE_TIMER), | |||
call( | |||
now=now, | |||
obj=user_id, | |||
then=new_state.last_user_sync_ts + SYNC_ONLINE_TIMEOUT, | |||
), | |||
call( | |||
now=now, | |||
obj=user_id, | |||
then=new_state.last_active_ts + LAST_ACTIVE_GRANULARITY, | |||
), | |||
], | |||
any_order=True, | |||
) | |||
def test_online_to_online_last_active_noop(self): | |||
wheel_timer = Mock() | |||
@@ -132,8 +126,7 @@ class PresenceUpdateTestCase(unittest.TestCase): | |||
) | |||
new_state = prev_state.copy_and_replace( | |||
state=PresenceState.ONLINE, | |||
last_active_ts=now, | |||
state=PresenceState.ONLINE, last_active_ts=now | |||
) | |||
state, persist_and_notify, federation_ping = handle_update( | |||
@@ -148,23 +141,22 @@ class PresenceUpdateTestCase(unittest.TestCase): | |||
self.assertEquals(state.last_federation_update_ts, now) | |||
self.assertEquals(wheel_timer.insert.call_count, 3) | |||
wheel_timer.insert.assert_has_calls([ | |||
call( | |||
now=now, | |||
obj=user_id, | |||
then=new_state.last_active_ts + IDLE_TIMER | |||
), | |||
call( | |||
now=now, | |||
obj=user_id, | |||
then=new_state.last_user_sync_ts + SYNC_ONLINE_TIMEOUT | |||
), | |||
call( | |||
now=now, | |||
obj=user_id, | |||
then=new_state.last_active_ts + LAST_ACTIVE_GRANULARITY | |||
), | |||
], any_order=True) | |||
wheel_timer.insert.assert_has_calls( | |||
[ | |||
call(now=now, obj=user_id, then=new_state.last_active_ts + IDLE_TIMER), | |||
call( | |||
now=now, | |||
obj=user_id, | |||
then=new_state.last_user_sync_ts + SYNC_ONLINE_TIMEOUT, | |||
), | |||
call( | |||
now=now, | |||
obj=user_id, | |||
then=new_state.last_active_ts + LAST_ACTIVE_GRANULARITY, | |||
), | |||
], | |||
any_order=True, | |||
) | |||
def test_online_to_online_last_active(self): | |||
wheel_timer = Mock() | |||
@@ -178,9 +170,7 @@ class PresenceUpdateTestCase(unittest.TestCase): | |||
currently_active=True, | |||
) | |||
new_state = prev_state.copy_and_replace( | |||
state=PresenceState.ONLINE, | |||
) | |||
new_state = prev_state.copy_and_replace(state=PresenceState.ONLINE) | |||
state, persist_and_notify, federation_ping = handle_update( | |||
prev_state, new_state, is_mine=True, wheel_timer=wheel_timer, now=now | |||
@@ -193,18 +183,17 @@ class PresenceUpdateTestCase(unittest.TestCase): | |||
self.assertEquals(state.last_federation_update_ts, now) | |||
self.assertEquals(wheel_timer.insert.call_count, 2) | |||
wheel_timer.insert.assert_has_calls([ | |||
call( | |||
now=now, | |||
obj=user_id, | |||
then=new_state.last_active_ts + IDLE_TIMER | |||
), | |||
call( | |||
now=now, | |||
obj=user_id, | |||
then=new_state.last_user_sync_ts + SYNC_ONLINE_TIMEOUT | |||
) | |||
], any_order=True) | |||
wheel_timer.insert.assert_has_calls( | |||
[ | |||
call(now=now, obj=user_id, then=new_state.last_active_ts + IDLE_TIMER), | |||
call( | |||
now=now, | |||
obj=user_id, | |||
then=new_state.last_user_sync_ts + SYNC_ONLINE_TIMEOUT, | |||
), | |||
], | |||
any_order=True, | |||
) | |||
def test_remote_ping_timer(self): | |||
wheel_timer = Mock() | |||
@@ -213,13 +202,10 @@ class PresenceUpdateTestCase(unittest.TestCase): | |||
prev_state = UserPresenceState.default(user_id) | |||
prev_state = prev_state.copy_and_replace( | |||
state=PresenceState.ONLINE, | |||
last_active_ts=now, | |||
state=PresenceState.ONLINE, last_active_ts=now | |||
) | |||
new_state = prev_state.copy_and_replace( | |||
state=PresenceState.ONLINE, | |||
) | |||
new_state = prev_state.copy_and_replace(state=PresenceState.ONLINE) | |||
state, persist_and_notify, federation_ping = handle_update( | |||
prev_state, new_state, is_mine=False, wheel_timer=wheel_timer, now=now | |||
@@ -232,13 +218,16 @@ class PresenceUpdateTestCase(unittest.TestCase): | |||
self.assertEquals(new_state.status_msg, state.status_msg) | |||
self.assertEquals(wheel_timer.insert.call_count, 1) | |||
wheel_timer.insert.assert_has_calls([ | |||
call( | |||
now=now, | |||
obj=user_id, | |||
then=new_state.last_federation_update_ts + FEDERATION_TIMEOUT | |||
), | |||
], any_order=True) | |||
wheel_timer.insert.assert_has_calls( | |||
[ | |||
call( | |||
now=now, | |||
obj=user_id, | |||
then=new_state.last_federation_update_ts + FEDERATION_TIMEOUT, | |||
) | |||
], | |||
any_order=True, | |||
) | |||
def test_online_to_offline(self): | |||
wheel_timer = Mock() | |||
@@ -247,14 +236,10 @@ class PresenceUpdateTestCase(unittest.TestCase): | |||
prev_state = UserPresenceState.default(user_id) | |||
prev_state = prev_state.copy_and_replace( | |||
state=PresenceState.ONLINE, | |||
last_active_ts=now, | |||
currently_active=True, | |||
state=PresenceState.ONLINE, last_active_ts=now, currently_active=True | |||
) | |||
new_state = prev_state.copy_and_replace( | |||
state=PresenceState.OFFLINE, | |||
) | |||
new_state = prev_state.copy_and_replace(state=PresenceState.OFFLINE) | |||
state, persist_and_notify, federation_ping = handle_update( | |||
prev_state, new_state, is_mine=True, wheel_timer=wheel_timer, now=now | |||
@@ -273,14 +258,10 @@ class PresenceUpdateTestCase(unittest.TestCase): | |||
prev_state = UserPresenceState.default(user_id) | |||
prev_state = prev_state.copy_and_replace( | |||
state=PresenceState.ONLINE, | |||
last_active_ts=now, | |||
currently_active=True, | |||
state=PresenceState.ONLINE, last_active_ts=now, currently_active=True | |||
) | |||
new_state = prev_state.copy_and_replace( | |||
state=PresenceState.UNAVAILABLE, | |||
) | |||
new_state = prev_state.copy_and_replace(state=PresenceState.UNAVAILABLE) | |||
state, persist_and_notify, federation_ping = handle_update( | |||
prev_state, new_state, is_mine=True, wheel_timer=wheel_timer, now=now | |||
@@ -293,13 +274,16 @@ class PresenceUpdateTestCase(unittest.TestCase): | |||
self.assertEquals(new_state.status_msg, state.status_msg) | |||
self.assertEquals(wheel_timer.insert.call_count, 1) | |||
wheel_timer.insert.assert_has_calls([ | |||
call( | |||
now=now, | |||
obj=user_id, | |||
then=new_state.last_user_sync_ts + SYNC_ONLINE_TIMEOUT | |||
) | |||
], any_order=True) | |||
wheel_timer.insert.assert_has_calls( | |||
[ | |||
call( | |||
now=now, | |||
obj=user_id, | |||
then=new_state.last_user_sync_ts + SYNC_ONLINE_TIMEOUT, | |||
) | |||
], | |||
any_order=True, | |||
) | |||
class PresenceTimeoutTestCase(unittest.TestCase): | |||
@@ -314,9 +298,7 @@ class PresenceTimeoutTestCase(unittest.TestCase): | |||
last_user_sync_ts=now, | |||
) | |||
new_state = handle_timeout( | |||
state, is_mine=True, syncing_user_ids=set(), now=now | |||
) | |||
new_state = handle_timeout(state, is_mine=True, syncing_user_ids=set(), now=now) | |||
self.assertIsNotNone(new_state) | |||
self.assertEquals(new_state.state, PresenceState.UNAVAILABLE) | |||
@@ -332,9 +314,7 @@ class PresenceTimeoutTestCase(unittest.TestCase): | |||
last_user_sync_ts=now - SYNC_ONLINE_TIMEOUT - 1, | |||
) | |||
new_state = handle_timeout( | |||
state, is_mine=True, syncing_user_ids=set(), now=now | |||
) | |||
new_state = handle_timeout(state, is_mine=True, syncing_user_ids=set(), now=now) | |||
self.assertIsNotNone(new_state) | |||
self.assertEquals(new_state.state, PresenceState.OFFLINE) | |||
@@ -369,9 +349,7 @@ class PresenceTimeoutTestCase(unittest.TestCase): | |||
last_federation_update_ts=now - FEDERATION_PING_INTERVAL - 1, | |||
) | |||
new_state = handle_timeout( | |||
state, is_mine=True, syncing_user_ids=set(), now=now | |||
) | |||
new_state = handle_timeout(state, is_mine=True, syncing_user_ids=set(), now=now) | |||
self.assertIsNotNone(new_state) | |||
self.assertEquals(new_state, new_state) | |||
@@ -388,9 +366,7 @@ class PresenceTimeoutTestCase(unittest.TestCase): | |||
last_federation_update_ts=now, | |||
) | |||
new_state = handle_timeout( | |||
state, is_mine=True, syncing_user_ids=set(), now=now | |||
) | |||
new_state = handle_timeout(state, is_mine=True, syncing_user_ids=set(), now=now) | |||
self.assertIsNone(new_state) | |||
@@ -425,9 +401,7 @@ class PresenceTimeoutTestCase(unittest.TestCase): | |||
last_federation_update_ts=now, | |||
) | |||
new_state = handle_timeout( | |||
state, is_mine=True, syncing_user_ids=set(), now=now | |||
) | |||
new_state = handle_timeout(state, is_mine=True, syncing_user_ids=set(), now=now) | |||
self.assertIsNotNone(new_state) | |||
self.assertEquals(state, new_state) |
@@ -54,9 +54,7 @@ class ProfileTestCase(unittest.TestCase): | |||
federation_client=self.mock_federation, | |||
federation_server=Mock(), | |||
federation_registry=self.mock_registry, | |||
ratelimiter=NonCallableMock(spec_set=[ | |||
"send_message", | |||
]) | |||
ratelimiter=NonCallableMock(spec_set=["send_message"]), | |||
) | |||
self.ratelimiter = hs.get_ratelimiter() | |||
@@ -74,9 +72,7 @@ class ProfileTestCase(unittest.TestCase): | |||
@defer.inlineCallbacks | |||
def test_get_my_name(self): | |||
yield self.store.set_profile_displayname( | |||
self.frank.localpart, "Frank" | |||
) | |||
yield self.store.set_profile_displayname(self.frank.localpart, "Frank") | |||
displayname = yield self.handler.get_displayname(self.frank) | |||
@@ -85,22 +81,18 @@ class ProfileTestCase(unittest.TestCase): | |||
@defer.inlineCallbacks | |||
def test_set_my_name(self): | |||
yield self.handler.set_displayname( | |||
self.frank, | |||
synapse.types.create_requester(self.frank), | |||
"Frank Jr." | |||
self.frank, synapse.types.create_requester(self.frank), "Frank Jr." | |||
) | |||
self.assertEquals( | |||
(yield self.store.get_profile_displayname(self.frank.localpart)), | |||
"Frank Jr." | |||
"Frank Jr.", | |||
) | |||
@defer.inlineCallbacks | |||
def test_set_my_name_noauth(self): | |||
d = self.handler.set_displayname( | |||
self.frank, | |||
synapse.types.create_requester(self.bob), | |||
"Frank Jr." | |||
self.frank, synapse.types.create_requester(self.bob), "Frank Jr." | |||
) | |||
yield self.assertFailure(d, AuthError) | |||
@@ -145,11 +137,12 @@ class ProfileTestCase(unittest.TestCase): | |||
@defer.inlineCallbacks | |||
def test_set_my_avatar(self): | |||
yield self.handler.set_avatar_url( | |||
self.frank, synapse.types.create_requester(self.frank), | |||
"http://my.server/pic.gif" | |||
self.frank, | |||
synapse.types.create_requester(self.frank), | |||
"http://my.server/pic.gif", | |||
) | |||
self.assertEquals( | |||
(yield self.store.get_profile_avatar_url(self.frank.localpart)), | |||
"http://my.server/pic.gif" | |||
"http://my.server/pic.gif", | |||
) |
@@ -46,7 +46,8 @@ class RegistrationTestCase(unittest.TestCase): | |||
profile_handler=Mock(), | |||
) | |||
self.macaroon_generator = Mock( | |||
generate_access_token=Mock(return_value='secret')) | |||
generate_access_token=Mock(return_value='secret') | |||
) | |||
self.hs.get_macaroon_generator = Mock(return_value=self.macaroon_generator) | |||
self.hs.handlers = RegistrationHandlers(self.hs) | |||
self.handler = self.hs.get_handlers().registration_handler | |||
@@ -62,7 +63,8 @@ class RegistrationTestCase(unittest.TestCase): | |||
user_id = "@someone:test" | |||
requester = create_requester("@as:test") | |||
result_user_id, result_token = yield self.handler.get_or_create_user( | |||
requester, local_part, display_name) | |||
requester, local_part, display_name | |||
) | |||
self.assertEquals(result_user_id, user_id) | |||
self.assertEquals(result_token, 'secret') | |||
@@ -73,13 +75,15 @@ class RegistrationTestCase(unittest.TestCase): | |||
yield store.register( | |||
user_id=frank.to_string(), | |||
token="jkv;g498752-43gj['eamb!-5", | |||
password_hash=None) | |||
password_hash=None, | |||
) | |||
local_part = "frank" | |||
display_name = "Frank" | |||
user_id = "@frank:test" | |||
requester = create_requester("@as:test") | |||
result_user_id, result_token = yield self.handler.get_or_create_user( | |||
requester, local_part, display_name) | |||
requester, local_part, display_name | |||
) | |||
self.assertEquals(result_user_id, user_id) | |||
self.assertEquals(result_token, 'secret') | |||
@@ -38,23 +38,19 @@ def _expect_edu(destination, edu_type, content, origin="test"): | |||
"origin": origin, | |||
"origin_server_ts": 1000000, | |||
"pdus": [], | |||
"edus": [ | |||
{ | |||
"edu_type": edu_type, | |||
"content": content, | |||
} | |||
], | |||
"edus": [{"edu_type": edu_type, "content": content}], | |||
} | |||
def _make_edu_json(origin, edu_type, content): | |||
return json.dumps( | |||
_expect_edu("test", edu_type, content, origin=origin) | |||
).encode('utf8') | |||
return json.dumps(_expect_edu("test", edu_type, content, origin=origin)).encode( | |||
'utf8' | |||
) | |||
class TypingNotificationsTestCase(unittest.TestCase): | |||
"""Tests typing notifications to rooms.""" | |||
@defer.inlineCallbacks | |||
def setUp(self): | |||
self.clock = MockClock() | |||
@@ -74,18 +70,20 @@ class TypingNotificationsTestCase(unittest.TestCase): | |||
"test", | |||
auth=self.auth, | |||
clock=self.clock, | |||
datastore=Mock(spec=[ | |||
# Bits that Federation needs | |||
"prep_send_transaction", | |||
"delivered_txn", | |||
"get_received_txn_response", | |||
"set_received_txn_response", | |||
"get_destination_retry_timings", | |||
"get_devices_by_remote", | |||
# Bits that user_directory needs | |||
"get_user_directory_stream_pos", | |||
"get_current_state_deltas", | |||
]), | |||
datastore=Mock( | |||
spec=[ | |||
# Bits that Federation needs | |||
"prep_send_transaction", | |||
"delivered_txn", | |||
"get_received_txn_response", | |||
"set_received_txn_response", | |||
"get_destination_retry_timings", | |||
"get_devices_by_remote", | |||
# Bits that user_directory needs | |||
"get_user_directory_stream_pos", | |||
"get_current_state_deltas", | |||
] | |||
), | |||
state_handler=self.state_handler, | |||
handlers=Mock(), | |||
notifier=mock_notifier, | |||
@@ -100,19 +98,16 @@ class TypingNotificationsTestCase(unittest.TestCase): | |||
self.event_source = hs.get_event_sources().sources["typing"] | |||
self.datastore = hs.get_datastore() | |||
retry_timings_res = { | |||
"destination": "", | |||
"retry_last_ts": 0, | |||
"retry_interval": 0, | |||
} | |||
self.datastore.get_destination_retry_timings.return_value = ( | |||
defer.succeed(retry_timings_res) | |||
retry_timings_res = {"destination": "", "retry_last_ts": 0, "retry_interval": 0} | |||
self.datastore.get_destination_retry_timings.return_value = defer.succeed( | |||
retry_timings_res | |||
) | |||
self.datastore.get_devices_by_remote.return_value = (0, []) | |||
def get_received_txn_response(*args): | |||
return defer.succeed(None) | |||
self.datastore.get_received_txn_response = get_received_txn_response | |||
self.room_id = "a-room" | |||
@@ -125,10 +120,12 @@ class TypingNotificationsTestCase(unittest.TestCase): | |||
def get_joined_hosts_for_room(room_id): | |||
return set(member.domain for member in self.room_members) | |||
self.datastore.get_joined_hosts_for_room = get_joined_hosts_for_room | |||
def get_current_user_in_room(room_id): | |||
return set(str(u) for u in self.room_members) | |||
self.state_handler.get_current_user_in_room = get_current_user_in_room | |||
self.datastore.get_user_directory_stream_pos.return_value = ( | |||
@@ -136,19 +133,13 @@ class TypingNotificationsTestCase(unittest.TestCase): | |||
defer.succeed(1) | |||
) | |||
self.datastore.get_current_state_deltas.return_value = ( | |||
None | |||
) | |||
self.datastore.get_current_state_deltas.return_value = None | |||
self.auth.check_joined_room = check_joined_room | |||
self.datastore.get_to_device_stream_token = lambda: 0 | |||
self.datastore.get_new_device_msgs_for_remote = ( | |||
lambda *args, **kargs: ([], 0) | |||
) | |||
self.datastore.delete_device_msgs_for_remote = ( | |||
lambda *args, **kargs: None | |||
) | |||
self.datastore.get_new_device_msgs_for_remote = lambda *args, **kargs: ([], 0) | |||
self.datastore.delete_device_msgs_for_remote = lambda *args, **kargs: None | |||
# Some local users to test with | |||
self.u_apple = UserID.from_string("@apple:test") | |||
@@ -170,24 +161,23 @@ class TypingNotificationsTestCase(unittest.TestCase): | |||
timeout=20000, | |||
) | |||
self.on_new_event.assert_has_calls([ | |||
call('typing_key', 1, rooms=[self.room_id]), | |||
]) | |||
self.on_new_event.assert_has_calls( | |||
[call('typing_key', 1, rooms=[self.room_id])] | |||
) | |||
self.assertEquals(self.event_source.get_current_key(), 1) | |||
events = yield self.event_source.get_new_events( | |||
room_ids=[self.room_id], | |||
from_key=0, | |||
room_ids=[self.room_id], from_key=0 | |||
) | |||
self.assertEquals( | |||
events[0], | |||
[ | |||
{"type": "m.typing", | |||
"room_id": self.room_id, | |||
"content": { | |||
"user_ids": [self.u_apple.to_string()], | |||
}}, | |||
] | |||
{ | |||
"type": "m.typing", | |||
"room_id": self.room_id, | |||
"content": {"user_ids": [self.u_apple.to_string()]}, | |||
} | |||
], | |||
) | |||
@defer.inlineCallbacks | |||
@@ -206,13 +196,13 @@ class TypingNotificationsTestCase(unittest.TestCase): | |||
"room_id": self.room_id, | |||
"user_id": self.u_apple.to_string(), | |||
"typing": True, | |||
} | |||
}, | |||
), | |||
json_data_callback=ANY, | |||
long_retries=True, | |||
backoff_on_404=True, | |||
), | |||
defer.succeed((200, "OK")) | |||
defer.succeed((200, "OK")), | |||
) | |||
yield self.handler.started_typing( | |||
@@ -240,27 +230,29 @@ class TypingNotificationsTestCase(unittest.TestCase): | |||
"room_id": self.room_id, | |||
"user_id": self.u_onion.to_string(), | |||
"typing": True, | |||
} | |||
}, | |||
), | |||
federation_auth=True, | |||
) | |||
self.on_new_event.assert_has_calls([ | |||
call('typing_key', 1, rooms=[self.room_id]), | |||
]) | |||
self.on_new_event.assert_has_calls( | |||
[call('typing_key', 1, rooms=[self.room_id])] | |||
) | |||
self.assertEquals(self.event_source.get_current_key(), 1) | |||
events = yield self.event_source.get_new_events( | |||
room_ids=[self.room_id], | |||
from_key=0 | |||
room_ids=[self.room_id], from_key=0 | |||
) | |||
self.assertEquals( | |||
events[0], | |||
[ | |||
{ | |||
"type": "m.typing", | |||
"room_id": self.room_id, | |||
"content": {"user_ids": [self.u_onion.to_string()]}, | |||
} | |||
], | |||
) | |||
self.assertEquals(events[0], [{ | |||
"type": "m.typing", | |||
"room_id": self.room_id, | |||
"content": { | |||
"user_ids": [self.u_onion.to_string()], | |||
}, | |||
}]) | |||
@defer.inlineCallbacks | |||
def test_stopped_typing(self): | |||
@@ -278,17 +270,18 @@ class TypingNotificationsTestCase(unittest.TestCase): | |||
"room_id": self.room_id, | |||
"user_id": self.u_apple.to_string(), | |||
"typing": False, | |||
} | |||
}, | |||
), | |||
json_data_callback=ANY, | |||
long_retries=True, | |||
backoff_on_404=True, | |||
), | |||
defer.succeed((200, "OK")) | |||
defer.succeed((200, "OK")), | |||
) | |||
# Gut-wrenching | |||
from synapse.handlers.typing import RoomMember | |||
member = RoomMember(self.room_id, self.u_apple.to_string()) | |||
self.handler._member_typing_until[member] = 1002000 | |||
self.handler._room_typing[self.room_id] = set([self.u_apple.to_string()]) | |||
@@ -296,29 +289,29 @@ class TypingNotificationsTestCase(unittest.TestCase): | |||
self.assertEquals(self.event_source.get_current_key(), 0) | |||
yield self.handler.stopped_typing( | |||
target_user=self.u_apple, | |||
auth_user=self.u_apple, | |||
room_id=self.room_id, | |||
target_user=self.u_apple, auth_user=self.u_apple, room_id=self.room_id | |||
) | |||
self.on_new_event.assert_has_calls([ | |||
call('typing_key', 1, rooms=[self.room_id]), | |||
]) | |||
self.on_new_event.assert_has_calls( | |||
[call('typing_key', 1, rooms=[self.room_id])] | |||
) | |||
yield put_json.await_calls() | |||
self.assertEquals(self.event_source.get_current_key(), 1) | |||
events = yield self.event_source.get_new_events( | |||
room_ids=[self.room_id], | |||
from_key=0, | |||
room_ids=[self.room_id], from_key=0 | |||
) | |||
self.assertEquals( | |||
events[0], | |||
[ | |||
{ | |||
"type": "m.typing", | |||
"room_id": self.room_id, | |||
"content": {"user_ids": []}, | |||
} | |||
], | |||
) | |||
self.assertEquals(events[0], [{ | |||
"type": "m.typing", | |||
"room_id": self.room_id, | |||
"content": { | |||
"user_ids": [], | |||
}, | |||
}]) | |||
@defer.inlineCallbacks | |||
def test_typing_timeout(self): | |||
@@ -333,42 +326,46 @@ class TypingNotificationsTestCase(unittest.TestCase): | |||
timeout=10000, | |||
) | |||
self.on_new_event.assert_has_calls([ | |||
call('typing_key', 1, rooms=[self.room_id]), | |||
]) | |||
self.on_new_event.assert_has_calls( | |||
[call('typing_key', 1, rooms=[self.room_id])] | |||
) | |||
self.on_new_event.reset_mock() | |||
self.assertEquals(self.event_source.get_current_key(), 1) | |||
events = yield self.event_source.get_new_events( | |||
room_ids=[self.room_id], | |||
from_key=0, | |||
room_ids=[self.room_id], from_key=0 | |||
) | |||
self.assertEquals( | |||
events[0], | |||
[ | |||
{ | |||
"type": "m.typing", | |||
"room_id": self.room_id, | |||
"content": {"user_ids": [self.u_apple.to_string()]}, | |||
} | |||
], | |||
) | |||
self.assertEquals(events[0], [{ | |||
"type": "m.typing", | |||
"room_id": self.room_id, | |||
"content": { | |||
"user_ids": [self.u_apple.to_string()], | |||
}, | |||
}]) | |||
self.clock.advance_time(16) | |||
self.on_new_event.assert_has_calls([ | |||
call('typing_key', 2, rooms=[self.room_id]), | |||
]) | |||
self.on_new_event.assert_has_calls( | |||
[call('typing_key', 2, rooms=[self.room_id])] | |||
) | |||
self.assertEquals(self.event_source.get_current_key(), 2) | |||
events = yield self.event_source.get_new_events( | |||
room_ids=[self.room_id], | |||
from_key=1, | |||
room_ids=[self.room_id], from_key=1 | |||
) | |||
self.assertEquals( | |||
events[0], | |||
[ | |||
{ | |||
"type": "m.typing", | |||
"room_id": self.room_id, | |||
"content": {"user_ids": []}, | |||
} | |||
], | |||
) | |||
self.assertEquals(events[0], [{ | |||
"type": "m.typing", | |||
"room_id": self.room_id, | |||
"content": { | |||
"user_ids": [], | |||
}, | |||
}]) | |||
# SYN-230 - see if we can still set after timeout | |||
@@ -379,20 +376,22 @@ class TypingNotificationsTestCase(unittest.TestCase): | |||
timeout=10000, | |||
) | |||
self.on_new_event.assert_has_calls([ | |||
call('typing_key', 3, rooms=[self.room_id]), | |||
]) | |||
self.on_new_event.assert_has_calls( | |||
[call('typing_key', 3, rooms=[self.room_id])] | |||
) | |||
self.on_new_event.reset_mock() | |||
self.assertEquals(self.event_source.get_current_key(), 3) | |||
events = yield self.event_source.get_new_events( | |||
room_ids=[self.room_id], | |||
from_key=0, | |||
room_ids=[self.room_id], from_key=0 | |||
) | |||
self.assertEquals( | |||
events[0], | |||
[ | |||
{ | |||
"type": "m.typing", | |||
"room_id": self.room_id, | |||
"content": {"user_ids": [self.u_apple.to_string()]}, | |||
} | |||
], | |||
) | |||
self.assertEquals(events[0], [{ | |||
"type": "m.typing", | |||
"room_id": self.room_id, | |||
"content": { | |||
"user_ids": [self.u_apple.to_string()], | |||
}, | |||
}]) |
@@ -39,15 +39,13 @@ class ServerNameTestCase(unittest.TestCase): | |||
"[1234", | |||
"underscore_.com", | |||
"percent%65.com", | |||
"1234:5678:80", # too many colons | |||
"1234:5678:80", # too many colons | |||
] | |||
for i in test_data: | |||
try: | |||
parse_and_validate_server_name(i) | |||
self.fail( | |||
"Expected parse_and_validate_server_name('%s') to throw" % ( | |||
i, | |||
), | |||
"Expected parse_and_validate_server_name('%s') to throw" % (i,) | |||
) | |||
except ValueError: | |||
pass |
@@ -31,6 +31,7 @@ from tests.utils import setup_test_homeserver | |||
class TestReplicationClientHandler(ReplicationClientHandler): | |||
"""Overrides on_rdata so that we can wait for it to happen""" | |||
def __init__(self, store): | |||
super(TestReplicationClientHandler, self).__init__(store) | |||
self._rdata_awaiters = [] | |||
@@ -56,9 +57,7 @@ class BaseSlavedStoreTestCase(unittest.TestCase): | |||
"blue", | |||
http_client=None, | |||
federation_client=Mock(), | |||
ratelimiter=NonCallableMock(spec_set=[ | |||
"send_message", | |||
]), | |||
ratelimiter=NonCallableMock(spec_set=["send_message"]), | |||
) | |||
self.hs.get_ratelimiter().send_message.return_value = (True, 0) | |||
@@ -29,20 +29,14 @@ class SlavedAccountDataStoreTestCase(BaseSlavedStoreTestCase): | |||
@defer.inlineCallbacks | |||
def test_user_account_data(self): | |||
yield self.master_store.add_account_data_for_user( | |||
USER_ID, TYPE, {"a": 1} | |||
) | |||
yield self.master_store.add_account_data_for_user(USER_ID, TYPE, {"a": 1}) | |||
yield self.replicate() | |||
yield self.check( | |||
"get_global_account_data_by_type_for_user", | |||
[TYPE, USER_ID], {"a": 1} | |||
"get_global_account_data_by_type_for_user", [TYPE, USER_ID], {"a": 1} | |||
) | |||
yield self.master_store.add_account_data_for_user( | |||
USER_ID, TYPE, {"a": 2} | |||
) | |||
yield self.master_store.add_account_data_for_user(USER_ID, TYPE, {"a": 2}) | |||
yield self.replicate() | |||
yield self.check( | |||
"get_global_account_data_by_type_for_user", | |||
[TYPE, USER_ID], {"a": 2} | |||
"get_global_account_data_by_type_for_user", [TYPE, USER_ID], {"a": 2} | |||
) |
@@ -38,6 +38,7 @@ def patch__eq__(cls): | |||
def unpatch(): | |||
if eq is not None: | |||
cls.__eq__ = eq | |||
return unpatch | |||
@@ -48,10 +49,7 @@ class SlavedEventStoreTestCase(BaseSlavedStoreTestCase): | |||
def setUp(self): | |||
# Patch up the equality operator for events so that we can check | |||
# whether lists of events match using assertEquals | |||
self.unpatches = [ | |||
patch__eq__(_EventInternalMetadata), | |||
patch__eq__(FrozenEvent), | |||
] | |||
self.unpatches = [patch__eq__(_EventInternalMetadata), patch__eq__(FrozenEvent)] | |||
return super(SlavedEventStoreTestCase, self).setUp() | |||
def tearDown(self): | |||
@@ -61,33 +59,27 @@ class SlavedEventStoreTestCase(BaseSlavedStoreTestCase): | |||
def test_get_latest_event_ids_in_room(self): | |||
create = yield self.persist(type="m.room.create", key="", creator=USER_ID) | |||
yield self.replicate() | |||
yield self.check( | |||
"get_latest_event_ids_in_room", (ROOM_ID,), [create.event_id] | |||
) | |||
yield self.check("get_latest_event_ids_in_room", (ROOM_ID,), [create.event_id]) | |||
join = yield self.persist( | |||
type="m.room.member", key=USER_ID, membership="join", | |||
type="m.room.member", | |||
key=USER_ID, | |||
membership="join", | |||
prev_events=[(create.event_id, {})], | |||
) | |||
yield self.replicate() | |||
yield self.check( | |||
"get_latest_event_ids_in_room", (ROOM_ID,), [join.event_id] | |||
) | |||
yield self.check("get_latest_event_ids_in_room", (ROOM_ID,), [join.event_id]) | |||
@defer.inlineCallbacks | |||
def test_redactions(self): | |||
yield self.persist(type="m.room.create", key="", creator=USER_ID) | |||
yield self.persist(type="m.room.member", key=USER_ID, membership="join") | |||
msg = yield self.persist( | |||
type="m.room.message", msgtype="m.text", body="Hello" | |||
) | |||
msg = yield self.persist(type="m.room.message", msgtype="m.text", body="Hello") | |||
yield self.replicate() | |||
yield self.check("get_event", [msg.event_id], msg) | |||
redaction = yield self.persist( | |||
type="m.room.redaction", redacts=msg.event_id | |||
) | |||
redaction = yield self.persist(type="m.room.redaction", redacts=msg.event_id) | |||
yield self.replicate() | |||
msg_dict = msg.get_dict() | |||
@@ -102,9 +94,7 @@ class SlavedEventStoreTestCase(BaseSlavedStoreTestCase): | |||
yield self.persist(type="m.room.create", key="", creator=USER_ID) | |||
yield self.persist(type="m.room.member", key=USER_ID, membership="join") | |||
msg = yield self.persist( | |||
type="m.room.message", msgtype="m.text", body="Hello" | |||
) | |||
msg = yield self.persist(type="m.room.message", msgtype="m.text", body="Hello") | |||
yield self.replicate() | |||
yield self.check("get_event", [msg.event_id], msg) | |||
@@ -127,10 +117,19 @@ class SlavedEventStoreTestCase(BaseSlavedStoreTestCase): | |||
type="m.room.member", key=USER_ID_2, membership="invite" | |||
) | |||
yield self.replicate() | |||
yield self.check("get_invited_rooms_for_user", [USER_ID_2], [RoomsForUser( | |||
ROOM_ID, USER_ID, "invite", event.event_id, | |||
event.internal_metadata.stream_ordering | |||
)]) | |||
yield self.check( | |||
"get_invited_rooms_for_user", | |||
[USER_ID_2], | |||
[ | |||
RoomsForUser( | |||
ROOM_ID, | |||
USER_ID, | |||
"invite", | |||
event.event_id, | |||
event.internal_metadata.stream_ordering, | |||
) | |||
], | |||
) | |||
@defer.inlineCallbacks | |||
def test_push_actions_for_user(self): | |||
@@ -146,40 +145,55 @@ class SlavedEventStoreTestCase(BaseSlavedStoreTestCase): | |||
yield self.check( | |||
"get_unread_event_push_actions_by_room_for_user", | |||
[ROOM_ID, USER_ID_2, event1.event_id], | |||
{"highlight_count": 0, "notify_count": 0} | |||
{"highlight_count": 0, "notify_count": 0}, | |||
) | |||
yield self.persist( | |||
type="m.room.message", msgtype="m.text", body="world", | |||
type="m.room.message", | |||
msgtype="m.text", | |||
body="world", | |||
push_actions=[(USER_ID_2, ["notify"])], | |||
) | |||
yield self.replicate() | |||
yield self.check( | |||
"get_unread_event_push_actions_by_room_for_user", | |||
[ROOM_ID, USER_ID_2, event1.event_id], | |||
{"highlight_count": 0, "notify_count": 1} | |||
{"highlight_count": 0, "notify_count": 1}, | |||
) | |||
yield self.persist( | |||
type="m.room.message", msgtype="m.text", body="world", | |||
push_actions=[(USER_ID_2, [ | |||
"notify", {"set_tweak": "highlight", "value": True} | |||
])], | |||
type="m.room.message", | |||
msgtype="m.text", | |||
body="world", | |||
push_actions=[ | |||
(USER_ID_2, ["notify", {"set_tweak": "highlight", "value": True}]) | |||
], | |||
) | |||
yield self.replicate() | |||
yield self.check( | |||
"get_unread_event_push_actions_by_room_for_user", | |||
[ROOM_ID, USER_ID_2, event1.event_id], | |||
{"highlight_count": 1, "notify_count": 2} | |||
{"highlight_count": 1, "notify_count": 2}, | |||
) | |||
event_id = 0 | |||
@defer.inlineCallbacks | |||
def persist( | |||
self, sender=USER_ID, room_id=ROOM_ID, type={}, key=None, internal={}, | |||
state=None, reset_state=False, backfill=False, | |||
depth=None, prev_events=[], auth_events=[], prev_state=[], redacts=None, | |||
self, | |||
sender=USER_ID, | |||
room_id=ROOM_ID, | |||
type={}, | |||
key=None, | |||
internal={}, | |||
state=None, | |||
reset_state=False, | |||
backfill=False, | |||
depth=None, | |||
prev_events=[], | |||
auth_events=[], | |||
prev_state=[], | |||
redacts=None, | |||
push_actions=[], | |||
**content | |||
): | |||
@@ -219,34 +233,23 @@ class SlavedEventStoreTestCase(BaseSlavedStoreTestCase): | |||
self.event_id += 1 | |||
if state is not None: | |||
state_ids = { | |||
key: e.event_id for key, e in state.items() | |||
} | |||
state_ids = {key: e.event_id for key, e in state.items()} | |||
context = EventContext.with_state( | |||
state_group=None, | |||
current_state_ids=state_ids, | |||
prev_state_ids=state_ids | |||
state_group=None, current_state_ids=state_ids, prev_state_ids=state_ids | |||
) | |||
else: | |||
state_handler = self.hs.get_state_handler() | |||
context = yield state_handler.compute_event_context(event) | |||
yield self.master_store.add_push_actions_to_staging( | |||
event.event_id, { | |||
user_id: actions | |||
for user_id, actions in push_actions | |||
}, | |||
event.event_id, {user_id: actions for user_id, actions in push_actions} | |||
) | |||
ordering = None | |||
if backfill: | |||
yield self.master_store.persist_events( | |||
[(event, context)], backfilled=True | |||
) | |||
yield self.master_store.persist_events([(event, context)], backfilled=True) | |||
else: | |||
ordering, _ = yield self.master_store.persist_event( | |||
event, context, | |||
) | |||
ordering, _ = yield self.master_store.persist_event(event, context) | |||
if ordering: | |||
event.internal_metadata.stream_ordering = ordering | |||
@@ -34,6 +34,6 @@ class SlavedReceiptTestCase(BaseSlavedStoreTestCase): | |||
ROOM_ID, "m.read", USER_ID, [EVENT_ID], {} | |||
) | |||
yield self.replicate() | |||
yield self.check("get_receipts_for_user", [USER_ID, "m.read"], { | |||
ROOM_ID: EVENT_ID | |||
}) | |||
yield self.check( | |||
"get_receipts_for_user", [USER_ID, "m.read"], {ROOM_ID: EVENT_ID} | |||
) |
@@ -11,7 +11,6 @@ from tests.utils import MockClock | |||
class HttpTransactionCacheTestCase(unittest.TestCase): | |||
def setUp(self): | |||
self.clock = MockClock() | |||
self.hs = Mock() | |||
@@ -24,9 +23,7 @@ class HttpTransactionCacheTestCase(unittest.TestCase): | |||
@defer.inlineCallbacks | |||
def test_executes_given_function(self): | |||
cb = Mock( | |||
return_value=defer.succeed(self.mock_http_response) | |||
) | |||
cb = Mock(return_value=defer.succeed(self.mock_http_response)) | |||
res = yield self.cache.fetch_or_execute( | |||
self.mock_key, cb, "some_arg", keyword="arg" | |||
) | |||
@@ -35,9 +32,7 @@ class HttpTransactionCacheTestCase(unittest.TestCase): | |||
@defer.inlineCallbacks | |||
def test_deduplicates_based_on_key(self): | |||
cb = Mock( | |||
return_value=defer.succeed(self.mock_http_response) | |||
) | |||
cb = Mock(return_value=defer.succeed(self.mock_http_response)) | |||
for i in range(3): # invoke multiple times | |||
res = yield self.cache.fetch_or_execute( | |||
self.mock_key, cb, "some_arg", keyword="arg", changing_args=i | |||
@@ -120,29 +115,18 @@ class HttpTransactionCacheTestCase(unittest.TestCase): | |||
@defer.inlineCallbacks | |||
def test_cleans_up(self): | |||
cb = Mock( | |||
return_value=defer.succeed(self.mock_http_response) | |||
) | |||
yield self.cache.fetch_or_execute( | |||
self.mock_key, cb, "an arg" | |||
) | |||
cb = Mock(return_value=defer.succeed(self.mock_http_response)) | |||
yield self.cache.fetch_or_execute(self.mock_key, cb, "an arg") | |||
# should NOT have cleaned up yet | |||
self.clock.advance_time_msec(CLEANUP_PERIOD_MS / 2) | |||
yield self.cache.fetch_or_execute( | |||
self.mock_key, cb, "an arg" | |||
) | |||
yield self.cache.fetch_or_execute(self.mock_key, cb, "an arg") | |||
# still using cache | |||
cb.assert_called_once_with("an arg") | |||
self.clock.advance_time_msec(CLEANUP_PERIOD_MS) | |||
yield self.cache.fetch_or_execute( | |||
self.mock_key, cb, "an arg" | |||
) | |||
yield self.cache.fetch_or_execute(self.mock_key, cb, "an arg") | |||
# no longer using cache | |||
self.assertEqual(cb.call_count, 2) | |||
self.assertEqual( | |||
cb.call_args_list, | |||
[call("an arg",), call("an arg",)] | |||
) | |||
self.assertEqual(cb.call_args_list, [call("an arg"), call("an arg")]) |
@@ -215,6 +215,7 @@ class UserRegisterTestCase(unittest.TestCase): | |||
mac. Admin is optional. Additional checks are done for length and | |||
type. | |||
""" | |||
def nonce(): | |||
request, channel = make_request("GET", self.url) | |||
render(request, self.resource, self.clock) | |||
@@ -289,7 +290,9 @@ class UserRegisterTestCase(unittest.TestCase): | |||
self.assertEqual('Invalid password', channel.json_body["error"]) | |||
# Must not have null bytes | |||
body = json.dumps({"nonce": nonce(), "username": "a", "password": u"abcd\u0000"}) | |||
body = json.dumps( | |||
{"nonce": nonce(), "username": "a", "password": u"abcd\u0000"} | |||
) | |||
request, channel = make_request("POST", self.url, body.encode('utf8')) | |||
render(request, self.resource, self.clock) | |||
@@ -43,9 +43,7 @@ class EventStreamPermissionsTestCase(RestTestCase): | |||
hs = yield setup_test_homeserver( | |||
http_client=None, | |||
federation_client=Mock(), | |||
ratelimiter=NonCallableMock(spec_set=[ | |||
"send_message", | |||
]), | |||
ratelimiter=NonCallableMock(spec_set=["send_message"]), | |||
) | |||
self.ratelimiter = hs.get_ratelimiter() | |||
self.ratelimiter.send_message.return_value = (True, 0) | |||
@@ -83,7 +81,7 @@ class EventStreamPermissionsTestCase(RestTestCase): | |||
# behaviour is used instead to be consistent with the r0 spec. | |||
# see issue #2602 | |||
(code, response) = yield self.mock_resource.trigger_get( | |||
"/events?access_token=%s" % ("invalid" + self.token, ) | |||
"/events?access_token=%s" % ("invalid" + self.token,) | |||
) | |||
self.assertEquals(401, code, msg=str(response)) | |||
@@ -98,18 +96,12 @@ class EventStreamPermissionsTestCase(RestTestCase): | |||
@defer.inlineCallbacks | |||
def test_stream_room_permissions(self): | |||
room_id = yield self.create_room_as( | |||
self.other_user, | |||
tok=self.other_token | |||
) | |||
room_id = yield self.create_room_as(self.other_user, tok=self.other_token) | |||
yield self.send(room_id, tok=self.other_token) | |||
# invited to room (expect no content for room) | |||
yield self.invite( | |||
room_id, | |||
src=self.other_user, | |||
targ=self.user_id, | |||
tok=self.other_token | |||
room_id, src=self.other_user, targ=self.user_id, tok=self.other_token | |||
) | |||
(code, response) = yield self.mock_resource.trigger_get( | |||
@@ -120,13 +112,16 @@ class EventStreamPermissionsTestCase(RestTestCase): | |||
# We may get a presence event for ourselves down | |||
self.assertEquals( | |||
0, | |||
len([ | |||
c for c in response["chunk"] | |||
if not ( | |||
c.get("type") == "m.presence" | |||
and c["content"].get("user_id") == self.user_id | |||
) | |||
]) | |||
len( | |||
[ | |||
c | |||
for c in response["chunk"] | |||
if not ( | |||
c.get("type") == "m.presence" | |||
and c["content"].get("user_id") == self.user_id | |||
) | |||
] | |||
), | |||
) | |||
# joined room (expect all content for room) | |||
@@ -36,12 +36,14 @@ class ProfileTestCase(unittest.TestCase): | |||
@defer.inlineCallbacks | |||
def setUp(self): | |||
self.mock_resource = MockHttpResource(prefix=PATH_PREFIX) | |||
self.mock_handler = Mock(spec=[ | |||
"get_displayname", | |||
"set_displayname", | |||
"get_avatar_url", | |||
"set_avatar_url", | |||
]) | |||
self.mock_handler = Mock( | |||
spec=[ | |||
"get_displayname", | |||
"set_displayname", | |||
"get_avatar_url", | |||
"set_avatar_url", | |||
] | |||
) | |||
hs = yield setup_test_homeserver( | |||
"test", | |||
@@ -49,7 +51,7 @@ class ProfileTestCase(unittest.TestCase): | |||
resource_for_client=self.mock_resource, | |||
federation=Mock(), | |||
federation_client=Mock(), | |||
profile_handler=self.mock_handler | |||
profile_handler=self.mock_handler, | |||
) | |||
def _get_user_by_req(request=None, allow_guest=False): | |||
@@ -78,9 +80,7 @@ class ProfileTestCase(unittest.TestCase): | |||
mocked_set.return_value = defer.succeed(()) | |||
(code, response) = yield self.mock_resource.trigger( | |||
"PUT", | |||
"/profile/%s/displayname" % (myid), | |||
b'{"displayname": "Frank Jr."}' | |||
"PUT", "/profile/%s/displayname" % (myid), b'{"displayname": "Frank Jr."}' | |||
) | |||
self.assertEquals(200, code) | |||
@@ -94,14 +94,12 @@ class ProfileTestCase(unittest.TestCase): | |||
mocked_set.side_effect = AuthError(400, "message") | |||
(code, response) = yield self.mock_resource.trigger( | |||
"PUT", "/profile/%s/displayname" % ("@4567:test"), | |||
b'{"displayname": "Frank Jr."}' | |||
"PUT", | |||
"/profile/%s/displayname" % ("@4567:test"), | |||
b'{"displayname": "Frank Jr."}', | |||
) | |||
self.assertTrue( | |||
400 <= code < 499, | |||
msg="code %d is in the 4xx range" % (code) | |||
) | |||
self.assertTrue(400 <= code < 499, msg="code %d is in the 4xx range" % (code)) | |||
@defer.inlineCallbacks | |||
def test_get_other_name(self): | |||
@@ -121,14 +119,12 @@ class ProfileTestCase(unittest.TestCase): | |||
mocked_set.side_effect = SynapseError(400, "message") | |||
(code, response) = yield self.mock_resource.trigger( | |||
"PUT", "/profile/%s/displayname" % ("@opaque:elsewhere"), | |||
b'{"displayname":"bob"}' | |||
"PUT", | |||
"/profile/%s/displayname" % ("@opaque:elsewhere"), | |||
b'{"displayname":"bob"}', | |||
) | |||
self.assertTrue( | |||
400 <= code <= 499, | |||
msg="code %d is in the 4xx range" % (code) | |||
) | |||
self.assertTrue(400 <= code <= 499, msg="code %d is in the 4xx range" % (code)) | |||
@defer.inlineCallbacks | |||
def test_get_my_avatar(self): | |||
@@ -151,7 +147,7 @@ class ProfileTestCase(unittest.TestCase): | |||
(code, response) = yield self.mock_resource.trigger( | |||
"PUT", | |||
"/profile/%s/avatar_url" % (myid), | |||
b'{"avatar_url": "http://my.server/pic.gif"}' | |||
b'{"avatar_url": "http://my.server/pic.gif"}', | |||
) | |||
self.assertEquals(200, code) | |||
@@ -32,6 +32,7 @@ class CreateUserServletTestCase(unittest.TestCase): | |||
""" | |||
Tests for CreateUserRestServlet. | |||
""" | |||
if PY3: | |||
skip = "Not ported to Python 3." | |||
@@ -31,6 +31,7 @@ PATH_PREFIX = "/_matrix/client/api/v1" | |||
class RoomTypingTestCase(RestTestCase): | |||
""" Tests /rooms/$room_id/typing/$user_id REST API. """ | |||
user_id = "@sid:red" | |||
user = UserID.from_string(user_id) | |||
@@ -47,9 +48,7 @@ class RoomTypingTestCase(RestTestCase): | |||
clock=self.clock, | |||
http_client=None, | |||
federation_client=Mock(), | |||
ratelimiter=NonCallableMock(spec_set=[ | |||
"send_message", | |||
]), | |||
ratelimiter=NonCallableMock(spec_set=["send_message"]), | |||
) | |||
self.hs = hs | |||
@@ -71,6 +70,7 @@ class RoomTypingTestCase(RestTestCase): | |||
def _insert_client_ip(*args, **kwargs): | |||
return defer.succeed(None) | |||
hs.get_datastore().insert_client_ip = _insert_client_ip | |||
def get_room_members(room_id): | |||
@@ -94,6 +94,7 @@ class RoomTypingTestCase(RestTestCase): | |||
else: | |||
if remotedomains is not None: | |||
remotedomains.add(member.domain) | |||
hs.get_room_member_handler().fetch_room_distributions_into = ( | |||
fetch_room_distributions_into | |||
) | |||
@@ -107,37 +108,42 @@ class RoomTypingTestCase(RestTestCase): | |||
@defer.inlineCallbacks | |||
def test_set_typing(self): | |||
(code, _) = yield self.mock_resource.trigger( | |||
"PUT", "/rooms/%s/typing/%s" % (self.room_id, self.user_id), | |||
'{"typing": true, "timeout": 30000}' | |||
"PUT", | |||
"/rooms/%s/typing/%s" % (self.room_id, self.user_id), | |||
'{"typing": true, "timeout": 30000}', | |||
) | |||
self.assertEquals(200, code) | |||
self.assertEquals(self.event_source.get_current_key(), 1) | |||
events = yield self.event_source.get_new_events( | |||
from_key=0, | |||
room_ids=[self.room_id], | |||
from_key=0, room_ids=[self.room_id] | |||
) | |||
self.assertEquals( | |||
events[0], | |||
[ | |||
{ | |||
"type": "m.typing", | |||
"room_id": self.room_id, | |||
"content": {"user_ids": [self.user_id]}, | |||
} | |||
], | |||
) | |||
self.assertEquals(events[0], [{ | |||
"type": "m.typing", | |||
"room_id": self.room_id, | |||
"content": { | |||
"user_ids": [self.user_id], | |||
} | |||
}]) | |||
@defer.inlineCallbacks | |||
def test_set_not_typing(self): | |||
(code, _) = yield self.mock_resource.trigger( | |||
"PUT", "/rooms/%s/typing/%s" % (self.room_id, self.user_id), | |||
'{"typing": false}' | |||
"PUT", | |||
"/rooms/%s/typing/%s" % (self.room_id, self.user_id), | |||
'{"typing": false}', | |||
) | |||
self.assertEquals(200, code) | |||
@defer.inlineCallbacks | |||
def test_typing_timeout(self): | |||
(code, _) = yield self.mock_resource.trigger( | |||
"PUT", "/rooms/%s/typing/%s" % (self.room_id, self.user_id), | |||
'{"typing": true, "timeout": 30000}' | |||
"PUT", | |||
"/rooms/%s/typing/%s" % (self.room_id, self.user_id), | |||
'{"typing": true, "timeout": 30000}', | |||
) | |||
self.assertEquals(200, code) | |||
@@ -148,8 +154,9 @@ class RoomTypingTestCase(RestTestCase): | |||
self.assertEquals(self.event_source.get_current_key(), 2) | |||
(code, _) = yield self.mock_resource.trigger( | |||
"PUT", "/rooms/%s/typing/%s" % (self.room_id, self.user_id), | |||
'{"typing": true, "timeout": 30000}' | |||
"PUT", | |||
"/rooms/%s/typing/%s" % (self.room_id, self.user_id), | |||
'{"typing": true, "timeout": 30000}', | |||
) | |||
self.assertEquals(200, code) | |||
@@ -55,25 +55,39 @@ class RestTestCase(unittest.TestCase): | |||
@defer.inlineCallbacks | |||
def invite(self, room=None, src=None, targ=None, expect_code=200, tok=None): | |||
yield self.change_membership(room=room, src=src, targ=targ, tok=tok, | |||
membership=Membership.INVITE, | |||
expect_code=expect_code) | |||
yield self.change_membership( | |||
room=room, | |||
src=src, | |||
targ=targ, | |||
tok=tok, | |||
membership=Membership.INVITE, | |||
expect_code=expect_code, | |||
) | |||
@defer.inlineCallbacks | |||
def join(self, room=None, user=None, expect_code=200, tok=None): | |||
yield self.change_membership(room=room, src=user, targ=user, tok=tok, | |||
membership=Membership.JOIN, | |||
expect_code=expect_code) | |||
yield self.change_membership( | |||
room=room, | |||
src=user, | |||
targ=user, | |||
tok=tok, | |||
membership=Membership.JOIN, | |||
expect_code=expect_code, | |||
) | |||
@defer.inlineCallbacks | |||
def leave(self, room=None, user=None, expect_code=200, tok=None): | |||
yield self.change_membership(room=room, src=user, targ=user, tok=tok, | |||
membership=Membership.LEAVE, | |||
expect_code=expect_code) | |||
yield self.change_membership( | |||
room=room, | |||
src=user, | |||
targ=user, | |||
tok=tok, | |||
membership=Membership.LEAVE, | |||
expect_code=expect_code, | |||
) | |||
@defer.inlineCallbacks | |||
def change_membership(self, room, src, targ, membership, tok=None, | |||
expect_code=200): | |||
def change_membership(self, room, src, targ, membership, tok=None, expect_code=200): | |||
temp_id = self.auth_user_id | |||
self.auth_user_id = src | |||
@@ -81,16 +95,15 @@ class RestTestCase(unittest.TestCase): | |||
if tok: | |||
path = path + "?access_token=%s" % tok | |||
data = { | |||
"membership": membership | |||
} | |||
data = {"membership": membership} | |||
(code, response) = yield self.mock_resource.trigger( | |||
"PUT", path, json.dumps(data) | |||
) | |||
self.assertEquals( | |||
expect_code, code, | |||
msg="Expected: %d, got: %d, resp: %r" % (expect_code, code, response) | |||
expect_code, | |||
code, | |||
msg="Expected: %d, got: %d, resp: %r" % (expect_code, code, response), | |||
) | |||
self.auth_user_id = temp_id | |||
@@ -100,17 +113,15 @@ class RestTestCase(unittest.TestCase): | |||
(code, response) = yield self.mock_resource.trigger( | |||
"POST", | |||
"/register", | |||
json.dumps({ | |||
"user": user_id, | |||
"password": "test", | |||
"type": "m.login.password" | |||
})) | |||
json.dumps( | |||
{"user": user_id, "password": "test", "type": "m.login.password"} | |||
), | |||
) | |||
self.assertEquals(200, code, msg=response) | |||
defer.returnValue(response) | |||
@defer.inlineCallbacks | |||
def send(self, room_id, body=None, txn_id=None, tok=None, | |||
expect_code=200): | |||
def send(self, room_id, body=None, txn_id=None, tok=None, expect_code=200): | |||
if txn_id is None: | |||
txn_id = "m%s" % (str(time.time())) | |||
if body is None: | |||
@@ -132,8 +143,9 @@ class RestTestCase(unittest.TestCase): | |||
actual (dict): The test result. Extra keys will not be checked. | |||
""" | |||
for key in required: | |||
self.assertEquals(required[key], actual[key], | |||
msg="%s mismatch. %s" % (key, actual)) | |||
self.assertEquals( | |||
required[key], actual[key], msg="%s mismatch. %s" % (key, actual) | |||
) | |||
@attr.s | |||
@@ -156,7 +168,9 @@ class RestHelper(object): | |||
if tok: | |||
path = path + "?access_token=%s" % tok | |||
request, channel = make_request("POST", path, json.dumps(content).encode('utf8')) | |||
request, channel = make_request( | |||
"POST", path, json.dumps(content).encode('utf8') | |||
) | |||
request.render(self.resource) | |||
wait_until_result(self.hs.get_reactor(), channel) | |||
@@ -204,9 +218,7 @@ class RestHelper(object): | |||
data = {"membership": membership} | |||
request, channel = make_request( | |||
"PUT", path, json.dumps(data).encode('utf8') | |||
) | |||
request, channel = make_request("PUT", path, json.dumps(data).encode('utf8')) | |||
request.render(self.resource) | |||
wait_until_result(self.hs.get_reactor(), channel) | |||
@@ -101,9 +101,7 @@ class RegisterRestServletTestCase(unittest.TestCase): | |||
wait_until_result(self.clock, channel) | |||
self.assertEquals(channel.result["code"], b"400", channel.result) | |||
self.assertEquals( | |||
channel.json_body["error"], "Invalid password" | |||
) | |||
self.assertEquals(channel.json_body["error"], "Invalid password") | |||
def test_POST_bad_username(self): | |||
request_data = json.dumps({"username": 777, "password": "monkey"}) | |||
@@ -112,9 +110,7 @@ class RegisterRestServletTestCase(unittest.TestCase): | |||
wait_until_result(self.clock, channel) | |||
self.assertEquals(channel.result["code"], b"400", channel.result) | |||
self.assertEquals( | |||
channel.json_body["error"], "Invalid username" | |||
) | |||
self.assertEquals(channel.json_body["error"], "Invalid username") | |||
def test_POST_user_valid(self): | |||
user_id = "@kermit:muppet" | |||
@@ -157,10 +153,7 @@ class RegisterRestServletTestCase(unittest.TestCase): | |||
wait_until_result(self.clock, channel) | |||
self.assertEquals(channel.result["code"], b"403", channel.result) | |||
self.assertEquals( | |||
channel.json_body["error"], | |||
"Registration has been disabled", | |||
) | |||
self.assertEquals(channel.json_body["error"], "Registration has been disabled") | |||
def test_POST_guest_registration(self): | |||
user_id = "a@b" | |||
@@ -188,6 +181,4 @@ class RegisterRestServletTestCase(unittest.TestCase): | |||
wait_until_result(self.clock, channel) | |||
self.assertEquals(channel.result["code"], b"403", channel.result) | |||
self.assertEquals( | |||
channel.json_body["error"], "Guest access is disabled" | |||
) | |||
self.assertEquals(channel.json_body["error"], "Guest access is disabled") |
@@ -41,13 +41,11 @@ class MediaStorageTests(unittest.TestCase): | |||
hs.get_reactor = Mock(return_value=reactor) | |||
hs.config.media_store_path = self.primary_base_path | |||
storage_providers = [FileStorageProviderBackend( | |||
hs, self.secondary_base_path | |||
)] | |||
storage_providers = [FileStorageProviderBackend(hs, self.secondary_base_path)] | |||
self.filepaths = MediaFilePaths(self.primary_base_path) | |||
self.media_storage = MediaStorage( | |||
hs, self.primary_base_path, self.filepaths, storage_providers, | |||
hs, self.primary_base_path, self.filepaths, storage_providers | |||
) | |||
def tearDown(self): | |||
@@ -136,6 +136,7 @@ class ThreadedMemoryReactorClock(MemoryReactorClock): | |||
""" | |||
A MemoryReactorClock that supports callFromThread. | |||
""" | |||
def callFromThread(self, callback, *args, **kwargs): | |||
""" | |||
Make the callback fire in the next reactor iteration. | |||
@@ -184,6 +185,7 @@ def setup_test_homeserver(*args, **kwargs): | |||
""" | |||
Threadless thread pool. | |||
""" | |||
def start(self): | |||
pass | |||
@@ -25,7 +25,6 @@ from tests import unittest | |||
class CacheTestCase(unittest.TestCase): | |||
def setUp(self): | |||
self.cache = Cache("test") | |||
@@ -97,7 +96,6 @@ class CacheTestCase(unittest.TestCase): | |||
class CacheDecoratorTestCase(unittest.TestCase): | |||
@defer.inlineCallbacks | |||
def test_passthrough(self): | |||
class A(object): | |||
@@ -180,8 +178,7 @@ class CacheDecoratorTestCase(unittest.TestCase): | |||
yield a.func(k) | |||
self.assertTrue( | |||
callcount[0] >= 14, | |||
msg="Expected callcount >= 14, got %d" % (callcount[0]) | |||
callcount[0] >= 14, msg="Expected callcount >= 14, got %d" % (callcount[0]) | |||
) | |||
def test_prefill(self): | |||
@@ -34,7 +34,6 @@ from tests.utils import setup_test_homeserver | |||
class ApplicationServiceStoreTestCase(unittest.TestCase): | |||
@defer.inlineCallbacks | |||
def setUp(self): | |||
self.as_yaml_files = [] | |||
@@ -44,20 +43,14 @@ class ApplicationServiceStoreTestCase(unittest.TestCase): | |||
password_providers=[], | |||
) | |||
hs = yield setup_test_homeserver( | |||
config=config, | |||
federation_sender=Mock(), | |||
federation_client=Mock(), | |||
config=config, federation_sender=Mock(), federation_client=Mock() | |||
) | |||
self.as_token = "token1" | |||
self.as_url = "some_url" | |||
self.as_id = "as1" | |||
self._add_appservice( | |||
self.as_token, | |||
self.as_id, | |||
self.as_url, | |||
"some_hs_token", | |||
"bob" | |||
self.as_token, self.as_id, self.as_url, "some_hs_token", "bob" | |||
) | |||
self._add_appservice("token2", "as2", "some_url", "some_hs_token", "bob") | |||
self._add_appservice("token3", "as3", "some_url", "some_hs_token", "bob") | |||
@@ -73,8 +66,14 @@ class ApplicationServiceStoreTestCase(unittest.TestCase): | |||
pass | |||
def _add_appservice(self, as_token, id, url, hs_token, sender): | |||
as_yaml = dict(url=url, as_token=as_token, hs_token=hs_token, | |||
id=id, sender_localpart=sender, namespaces={}) | |||
as_yaml = dict( | |||
url=url, | |||
as_token=as_token, | |||
hs_token=hs_token, | |||
id=id, | |||
sender_localpart=sender, | |||
namespaces={}, | |||
) | |||
# use the token as the filename | |||
with open(as_token, 'w') as outfile: | |||
outfile.write(yaml.dump(as_yaml)) | |||
@@ -85,24 +84,13 @@ class ApplicationServiceStoreTestCase(unittest.TestCase): | |||
self.assertEquals(service, None) | |||
def test_retrieval_of_service(self): | |||
stored_service = self.store.get_app_service_by_token( | |||
self.as_token | |||
) | |||
stored_service = self.store.get_app_service_by_token(self.as_token) | |||
self.assertEquals(stored_service.token, self.as_token) | |||
self.assertEquals(stored_service.id, self.as_id) | |||
self.assertEquals(stored_service.url, self.as_url) | |||
self.assertEquals( | |||
stored_service.namespaces[ApplicationService.NS_ALIASES], | |||
[] | |||
) | |||
self.assertEquals( | |||
stored_service.namespaces[ApplicationService.NS_ROOMS], | |||
[] | |||
) | |||
self.assertEquals( | |||
stored_service.namespaces[ApplicationService.NS_USERS], | |||
[] | |||
) | |||
self.assertEquals(stored_service.namespaces[ApplicationService.NS_ALIASES], []) | |||
self.assertEquals(stored_service.namespaces[ApplicationService.NS_ROOMS], []) | |||
self.assertEquals(stored_service.namespaces[ApplicationService.NS_USERS], []) | |||
def test_retrieval_of_all_services(self): | |||
services = self.store.get_app_services() | |||
@@ -110,7 +98,6 @@ class ApplicationServiceStoreTestCase(unittest.TestCase): | |||
class ApplicationServiceTransactionStoreTestCase(unittest.TestCase): | |||
@defer.inlineCallbacks | |||
def setUp(self): | |||
self.as_yaml_files = [] | |||
@@ -121,33 +108,15 @@ class ApplicationServiceTransactionStoreTestCase(unittest.TestCase): | |||
password_providers=[], | |||
) | |||
hs = yield setup_test_homeserver( | |||
config=config, | |||
federation_sender=Mock(), | |||
federation_client=Mock(), | |||
config=config, federation_sender=Mock(), federation_client=Mock() | |||
) | |||
self.db_pool = hs.get_db_pool() | |||
self.as_list = [ | |||
{ | |||
"token": "token1", | |||
"url": "https://matrix-as.org", | |||
"id": "id_1" | |||
}, | |||
{ | |||
"token": "alpha_tok", | |||
"url": "https://alpha.com", | |||
"id": "id_alpha" | |||
}, | |||
{ | |||
"token": "beta_tok", | |||
"url": "https://beta.com", | |||
"id": "id_beta" | |||
}, | |||
{ | |||
"token": "gamma_tok", | |||
"url": "https://gamma.com", | |||
"id": "id_gamma" | |||
}, | |||
{"token": "token1", "url": "https://matrix-as.org", "id": "id_1"}, | |||
{"token": "alpha_tok", "url": "https://alpha.com", "id": "id_alpha"}, | |||
{"token": "beta_tok", "url": "https://beta.com", "id": "id_beta"}, | |||
{"token": "gamma_tok", "url": "https://gamma.com", "id": "id_gamma"}, | |||
] | |||
for s in self.as_list: | |||
yield self._add_service(s["url"], s["token"], s["id"]) | |||
@@ -157,8 +126,14 @@ class ApplicationServiceTransactionStoreTestCase(unittest.TestCase): | |||
self.store = TestTransactionStore(None, hs) | |||
def _add_service(self, url, as_token, id): | |||
as_yaml = dict(url=url, as_token=as_token, hs_token="something", | |||
id=id, sender_localpart="a_sender", namespaces={}) | |||
as_yaml = dict( | |||
url=url, | |||
as_token=as_token, | |||
hs_token="something", | |||
id=id, | |||
sender_localpart="a_sender", | |||
namespaces={}, | |||
) | |||
# use the token as the filename | |||
with open(as_token, 'w') as outfile: | |||
outfile.write(yaml.dump(as_yaml)) | |||
@@ -168,21 +143,21 @@ class ApplicationServiceTransactionStoreTestCase(unittest.TestCase): | |||
return self.db_pool.runQuery( | |||
"INSERT INTO application_services_state(as_id, state, last_txn) " | |||
"VALUES(?,?,?)", | |||
(id, state, txn) | |||
(id, state, txn), | |||
) | |||
def _insert_txn(self, as_id, txn_id, events): | |||
return self.db_pool.runQuery( | |||
"INSERT INTO application_services_txns(as_id, txn_id, event_ids) " | |||
"VALUES(?,?,?)", | |||
(as_id, txn_id, json.dumps([e.event_id for e in events])) | |||
(as_id, txn_id, json.dumps([e.event_id for e in events])), | |||
) | |||
def _set_last_txn(self, as_id, txn_id): | |||
return self.db_pool.runQuery( | |||
"INSERT INTO application_services_state(as_id, last_txn, state) " | |||
"VALUES(?,?,?)", | |||
(as_id, txn_id, ApplicationServiceState.UP) | |||
(as_id, txn_id, ApplicationServiceState.UP), | |||
) | |||
@defer.inlineCallbacks | |||
@@ -193,24 +168,16 @@ class ApplicationServiceTransactionStoreTestCase(unittest.TestCase): | |||
@defer.inlineCallbacks | |||
def test_get_appservice_state_up(self): | |||
yield self._set_state( | |||
self.as_list[0]["id"], ApplicationServiceState.UP | |||
) | |||
yield self._set_state(self.as_list[0]["id"], ApplicationServiceState.UP) | |||
service = Mock(id=self.as_list[0]["id"]) | |||
state = yield self.store.get_appservice_state(service) | |||
self.assertEquals(ApplicationServiceState.UP, state) | |||
@defer.inlineCallbacks | |||
def test_get_appservice_state_down(self): | |||
yield self._set_state( | |||
self.as_list[0]["id"], ApplicationServiceState.UP | |||
) | |||
yield self._set_state( | |||
self.as_list[1]["id"], ApplicationServiceState.DOWN | |||
) | |||
yield self._set_state( | |||
self.as_list[2]["id"], ApplicationServiceState.DOWN | |||
) | |||
yield self._set_state(self.as_list[0]["id"], ApplicationServiceState.UP) | |||
yield self._set_state(self.as_list[1]["id"], ApplicationServiceState.DOWN) | |||
yield self._set_state(self.as_list[2]["id"], ApplicationServiceState.DOWN) | |||
service = Mock(id=self.as_list[1]["id"]) | |||
state = yield self.store.get_appservice_state(service) | |||
self.assertEquals(ApplicationServiceState.DOWN, state) | |||
@@ -225,34 +192,22 @@ class ApplicationServiceTransactionStoreTestCase(unittest.TestCase): | |||
@defer.inlineCallbacks | |||
def test_set_appservices_state_down(self): | |||
service = Mock(id=self.as_list[1]["id"]) | |||
yield self.store.set_appservice_state( | |||
service, | |||
ApplicationServiceState.DOWN | |||
) | |||
yield self.store.set_appservice_state(service, ApplicationServiceState.DOWN) | |||
rows = yield self.db_pool.runQuery( | |||
"SELECT as_id FROM application_services_state WHERE state=?", | |||
(ApplicationServiceState.DOWN,) | |||
(ApplicationServiceState.DOWN,), | |||
) | |||
self.assertEquals(service.id, rows[0][0]) | |||
@defer.inlineCallbacks | |||
def test_set_appservices_state_multiple_up(self): | |||
service = Mock(id=self.as_list[1]["id"]) | |||
yield self.store.set_appservice_state( | |||
service, | |||
ApplicationServiceState.UP | |||
) | |||
yield self.store.set_appservice_state( | |||
service, | |||
ApplicationServiceState.DOWN | |||
) | |||
yield self.store.set_appservice_state( | |||
service, | |||
ApplicationServiceState.UP | |||
) | |||
yield self.store.set_appservice_state(service, ApplicationServiceState.UP) | |||
yield self.store.set_appservice_state(service, ApplicationServiceState.DOWN) | |||
yield self.store.set_appservice_state(service, ApplicationServiceState.UP) | |||
rows = yield self.db_pool.runQuery( | |||
"SELECT as_id FROM application_services_state WHERE state=?", | |||
(ApplicationServiceState.UP,) | |||
(ApplicationServiceState.UP,), | |||
) | |||
self.assertEquals(service.id, rows[0][0]) | |||
@@ -319,14 +274,13 @@ class ApplicationServiceTransactionStoreTestCase(unittest.TestCase): | |||
res = yield self.db_pool.runQuery( | |||
"SELECT last_txn FROM application_services_state WHERE as_id=?", | |||
(service.id,) | |||
(service.id,), | |||
) | |||
self.assertEquals(1, len(res)) | |||
self.assertEquals(txn_id, res[0][0]) | |||
res = yield self.db_pool.runQuery( | |||
"SELECT * FROM application_services_txns WHERE txn_id=?", | |||
(txn_id,) | |||
"SELECT * FROM application_services_txns WHERE txn_id=?", (txn_id,) | |||
) | |||
self.assertEquals(0, len(res)) | |||
@@ -340,17 +294,15 @@ class ApplicationServiceTransactionStoreTestCase(unittest.TestCase): | |||
yield self.store.complete_appservice_txn(txn_id=txn_id, service=service) | |||
res = yield self.db_pool.runQuery( | |||
"SELECT last_txn, state FROM application_services_state WHERE " | |||
"as_id=?", | |||
(service.id,) | |||
"SELECT last_txn, state FROM application_services_state WHERE " "as_id=?", | |||
(service.id,), | |||
) | |||
self.assertEquals(1, len(res)) | |||
self.assertEquals(txn_id, res[0][0]) | |||
self.assertEquals(ApplicationServiceState.UP, res[0][1]) | |||
res = yield self.db_pool.runQuery( | |||
"SELECT * FROM application_services_txns WHERE txn_id=?", | |||
(txn_id,) | |||
"SELECT * FROM application_services_txns WHERE txn_id=?", (txn_id,) | |||
) | |||
self.assertEquals(0, len(res)) | |||
@@ -382,12 +334,8 @@ class ApplicationServiceTransactionStoreTestCase(unittest.TestCase): | |||
@defer.inlineCallbacks | |||
def test_get_appservices_by_state_single(self): | |||
yield self._set_state( | |||
self.as_list[0]["id"], ApplicationServiceState.DOWN | |||
) | |||
yield self._set_state( | |||
self.as_list[1]["id"], ApplicationServiceState.UP | |||
) | |||
yield self._set_state(self.as_list[0]["id"], ApplicationServiceState.DOWN) | |||
yield self._set_state(self.as_list[1]["id"], ApplicationServiceState.UP) | |||
services = yield self.store.get_appservices_by_state( | |||
ApplicationServiceState.DOWN | |||
@@ -397,18 +345,10 @@ class ApplicationServiceTransactionStoreTestCase(unittest.TestCase): | |||
@defer.inlineCallbacks | |||
def test_get_appservices_by_state_multiple(self): | |||
yield self._set_state( | |||
self.as_list[0]["id"], ApplicationServiceState.DOWN | |||
) | |||
yield self._set_state( | |||
self.as_list[1]["id"], ApplicationServiceState.UP | |||
) | |||
yield self._set_state( | |||
self.as_list[2]["id"], ApplicationServiceState.DOWN | |||
) | |||
yield self._set_state( | |||
self.as_list[3]["id"], ApplicationServiceState.UP | |||
) | |||
yield self._set_state(self.as_list[0]["id"], ApplicationServiceState.DOWN) | |||
yield self._set_state(self.as_list[1]["id"], ApplicationServiceState.UP) | |||
yield self._set_state(self.as_list[2]["id"], ApplicationServiceState.DOWN) | |||
yield self._set_state(self.as_list[3]["id"], ApplicationServiceState.UP) | |||
services = yield self.store.get_appservices_by_state( | |||
ApplicationServiceState.DOWN | |||
@@ -416,20 +356,17 @@ class ApplicationServiceTransactionStoreTestCase(unittest.TestCase): | |||
self.assertEquals(2, len(services)) | |||
self.assertEquals( | |||
set([self.as_list[2]["id"], self.as_list[0]["id"]]), | |||
set([services[0].id, services[1].id]) | |||
set([services[0].id, services[1].id]), | |||
) | |||
# required for ApplicationServiceTransactionStoreTestCase tests | |||
class TestTransactionStore(ApplicationServiceTransactionStore, | |||
ApplicationServiceStore): | |||
class TestTransactionStore(ApplicationServiceTransactionStore, ApplicationServiceStore): | |||
def __init__(self, db_conn, hs): | |||
super(TestTransactionStore, self).__init__(db_conn, hs) | |||
class ApplicationServiceStoreConfigTestCase(unittest.TestCase): | |||
def _write_config(self, suffix, **kwargs): | |||
vals = { | |||
"id": "id" + suffix, | |||
@@ -452,8 +389,7 @@ class ApplicationServiceStoreConfigTestCase(unittest.TestCase): | |||
f2 = self._write_config(suffix="2") | |||
config = Mock( | |||
app_service_config_files=[f1, f2], event_cache_size=1, | |||
password_providers=[] | |||
app_service_config_files=[f1, f2], event_cache_size=1, password_providers=[] | |||
) | |||
hs = yield setup_test_homeserver( | |||
config=config, | |||
@@ -470,8 +406,7 @@ class ApplicationServiceStoreConfigTestCase(unittest.TestCase): | |||
f2 = self._write_config(id="id", suffix="2") | |||
config = Mock( | |||
app_service_config_files=[f1, f2], event_cache_size=1, | |||
password_providers=[] | |||
app_service_config_files=[f1, f2], event_cache_size=1, password_providers=[] | |||
) | |||
hs = yield setup_test_homeserver( | |||
config=config, | |||
@@ -494,8 +429,7 @@ class ApplicationServiceStoreConfigTestCase(unittest.TestCase): | |||
f2 = self._write_config(as_token="as_token", suffix="2") | |||
config = Mock( | |||
app_service_config_files=[f1, f2], event_cache_size=1, | |||
password_providers=[] | |||
app_service_config_files=[f1, f2], event_cache_size=1, password_providers=[] | |||
) | |||
hs = yield setup_test_homeserver( | |||
config=config, | |||
@@ -7,7 +7,6 @@ from tests.utils import setup_test_homeserver | |||
class BackgroundUpdateTestCase(unittest.TestCase): | |||
@defer.inlineCallbacks | |||
def setUp(self): | |||
hs = yield setup_test_homeserver() # type: synapse.server.HomeServer | |||
@@ -51,9 +50,7 @@ class BackgroundUpdateTestCase(unittest.TestCase): | |||
yield self.store.start_background_update("test_update", {"my_key": 1}) | |||
self.update_handler.reset_mock() | |||
result = yield self.store.do_next_background_update( | |||
duration_ms * desired_count | |||
) | |||
result = yield self.store.do_next_background_update(duration_ms * desired_count) | |||
self.assertIsNotNone(result) | |||
self.update_handler.assert_called_once_with( | |||
{"my_key": 1}, self.store.DEFAULT_BACKGROUND_BATCH_SIZE | |||
@@ -67,18 +64,12 @@ class BackgroundUpdateTestCase(unittest.TestCase): | |||
self.update_handler.side_effect = update | |||
self.update_handler.reset_mock() | |||
result = yield self.store.do_next_background_update( | |||
duration_ms * desired_count | |||
) | |||
result = yield self.store.do_next_background_update(duration_ms * desired_count) | |||
self.assertIsNotNone(result) | |||
self.update_handler.assert_called_once_with( | |||
{"my_key": 2}, desired_count | |||
) | |||
self.update_handler.assert_called_once_with({"my_key": 2}, desired_count) | |||
# third step: we don't expect to be called any more | |||
self.update_handler.reset_mock() | |||
result = yield self.store.do_next_background_update( | |||
duration_ms * desired_count | |||
) | |||
result = yield self.store.do_next_background_update(duration_ms * desired_count) | |||
self.assertIsNone(result) | |||
self.assertFalse(self.update_handler.called) |
@@ -40,10 +40,12 @@ class SQLBaseStoreTestCase(unittest.TestCase): | |||
def runInteraction(func, *args, **kwargs): | |||
return defer.succeed(func(self.mock_txn, *args, **kwargs)) | |||
self.db_pool.runInteraction = runInteraction | |||
def runWithConnection(func, *args, **kwargs): | |||
return defer.succeed(func(self.mock_conn, *args, **kwargs)) | |||
self.db_pool.runWithConnection = runWithConnection | |||
config = Mock() | |||
@@ -63,8 +65,7 @@ class SQLBaseStoreTestCase(unittest.TestCase): | |||
self.mock_txn.rowcount = 1 | |||
yield self.datastore._simple_insert( | |||
table="tablename", | |||
values={"columname": "Value"} | |||
table="tablename", values={"columname": "Value"} | |||
) | |||
self.mock_txn.execute.assert_called_with( | |||
@@ -78,12 +79,11 @@ class SQLBaseStoreTestCase(unittest.TestCase): | |||
yield self.datastore._simple_insert( | |||
table="tablename", | |||
# Use OrderedDict() so we can assert on the SQL generated | |||
values=OrderedDict([("colA", 1), ("colB", 2), ("colC", 3)]) | |||
values=OrderedDict([("colA", 1), ("colB", 2), ("colC", 3)]), | |||
) | |||
self.mock_txn.execute.assert_called_with( | |||
"INSERT INTO tablename (colA, colB, colC) VALUES(?, ?, ?)", | |||
(1, 2, 3,) | |||
"INSERT INTO tablename (colA, colB, colC) VALUES(?, ?, ?)", (1, 2, 3) | |||
) | |||
@defer.inlineCallbacks | |||
@@ -92,9 +92,7 @@ class SQLBaseStoreTestCase(unittest.TestCase): | |||
self.mock_txn.__iter__ = Mock(return_value=iter([("Value",)])) | |||
value = yield self.datastore._simple_select_one_onecol( | |||
table="tablename", | |||
keyvalues={"keycol": "TheKey"}, | |||
retcol="retcol" | |||
table="tablename", keyvalues={"keycol": "TheKey"}, retcol="retcol" | |||
) | |||
self.assertEquals("Value", value) | |||
@@ -110,13 +108,12 @@ class SQLBaseStoreTestCase(unittest.TestCase): | |||
ret = yield self.datastore._simple_select_one( | |||
table="tablename", | |||
keyvalues={"keycol": "TheKey"}, | |||
retcols=["colA", "colB", "colC"] | |||
retcols=["colA", "colB", "colC"], | |||
) | |||
self.assertEquals({"colA": 1, "colB": 2, "colC": 3}, ret) | |||
self.mock_txn.execute.assert_called_with( | |||
"SELECT colA, colB, colC FROM tablename WHERE keycol = ?", | |||
["TheKey"] | |||
"SELECT colA, colB, colC FROM tablename WHERE keycol = ?", ["TheKey"] | |||
) | |||
@defer.inlineCallbacks | |||
@@ -128,7 +125,7 @@ class SQLBaseStoreTestCase(unittest.TestCase): | |||
table="tablename", | |||
keyvalues={"keycol": "Not here"}, | |||
retcols=["colA"], | |||
allow_none=True | |||
allow_none=True, | |||
) | |||
self.assertFalse(ret) | |||
@@ -137,20 +134,15 @@ class SQLBaseStoreTestCase(unittest.TestCase): | |||
def test_select_list(self): | |||
self.mock_txn.rowcount = 3 | |||
self.mock_txn.__iter__ = Mock(return_value=iter([(1,), (2,), (3,)])) | |||
self.mock_txn.description = ( | |||
("colA", None, None, None, None, None, None), | |||
) | |||
self.mock_txn.description = (("colA", None, None, None, None, None, None),) | |||
ret = yield self.datastore._simple_select_list( | |||
table="tablename", | |||
keyvalues={"keycol": "A set"}, | |||
retcols=["colA"], | |||
table="tablename", keyvalues={"keycol": "A set"}, retcols=["colA"] | |||
) | |||
self.assertEquals([{"colA": 1}, {"colA": 2}, {"colA": 3}], ret) | |||
self.mock_txn.execute.assert_called_with( | |||
"SELECT colA FROM tablename WHERE keycol = ?", | |||
["A set"] | |||
"SELECT colA FROM tablename WHERE keycol = ?", ["A set"] | |||
) | |||
@defer.inlineCallbacks | |||
@@ -160,12 +152,12 @@ class SQLBaseStoreTestCase(unittest.TestCase): | |||
yield self.datastore._simple_update_one( | |||
table="tablename", | |||
keyvalues={"keycol": "TheKey"}, | |||
updatevalues={"columnname": "New Value"} | |||
updatevalues={"columnname": "New Value"}, | |||
) | |||
self.mock_txn.execute.assert_called_with( | |||
"UPDATE tablename SET columnname = ? WHERE keycol = ?", | |||
["New Value", "TheKey"] | |||
["New Value", "TheKey"], | |||
) | |||
@defer.inlineCallbacks | |||
@@ -175,13 +167,12 @@ class SQLBaseStoreTestCase(unittest.TestCase): | |||
yield self.datastore._simple_update_one( | |||
table="tablename", | |||
keyvalues=OrderedDict([("colA", 1), ("colB", 2)]), | |||
updatevalues=OrderedDict([("colC", 3), ("colD", 4)]) | |||
updatevalues=OrderedDict([("colC", 3), ("colD", 4)]), | |||
) | |||
self.mock_txn.execute.assert_called_with( | |||
"UPDATE tablename SET colC = ?, colD = ? WHERE" | |||
" colA = ? AND colB = ?", | |||
[3, 4, 1, 2] | |||
"UPDATE tablename SET colC = ?, colD = ? WHERE" " colA = ? AND colB = ?", | |||
[3, 4, 1, 2], | |||
) | |||
@defer.inlineCallbacks | |||
@@ -189,8 +180,7 @@ class SQLBaseStoreTestCase(unittest.TestCase): | |||
self.mock_txn.rowcount = 1 | |||
yield self.datastore._simple_delete_one( | |||
table="tablename", | |||
keyvalues={"keycol": "Go away"}, | |||
table="tablename", keyvalues={"keycol": "Go away"} | |||
) | |||
self.mock_txn.execute.assert_called_with( | |||
@@ -37,8 +37,7 @@ class ClientIpStoreTestCase(tests.unittest.TestCase): | |||
self.clock.now = 12345678 | |||
user_id = "@user:id" | |||
yield self.store.insert_client_ip( | |||
user_id, | |||
"access_token", "ip", "user_agent", "device_id", | |||
user_id, "access_token", "ip", "user_agent", "device_id" | |||
) | |||
result = yield self.store.get_last_client_ip_by_device(user_id, "device_id") | |||
@@ -53,7 +52,7 @@ class ClientIpStoreTestCase(tests.unittest.TestCase): | |||
"user_agent": "user_agent", | |||
"last_seen": 12345678000, | |||
}, | |||
r | |||
r, | |||
) | |||
@defer.inlineCallbacks | |||
@@ -62,7 +61,7 @@ class ClientIpStoreTestCase(tests.unittest.TestCase): | |||
self.hs.config.max_mau_value = 50 | |||
user_id = "@user:server" | |||
yield self.store.insert_client_ip( | |||
user_id, "access_token", "ip", "user_agent", "device_id", | |||
user_id, "access_token", "ip", "user_agent", "device_id" | |||
) | |||
active = yield self.store._user_last_seen_monthly_active(user_id) | |||
self.assertFalse(active) | |||
@@ -78,7 +77,7 @@ class ClientIpStoreTestCase(tests.unittest.TestCase): | |||
return_value=defer.succeed(lots_of_users) | |||
) | |||
yield self.store.insert_client_ip( | |||
user_id, "access_token", "ip", "user_agent", "device_id", | |||
user_id, "access_token", "ip", "user_agent", "device_id" | |||
) | |||
active = yield self.store._user_last_seen_monthly_active(user_id) | |||
self.assertFalse(active) | |||
@@ -92,7 +91,7 @@ class ClientIpStoreTestCase(tests.unittest.TestCase): | |||
self.assertFalse(active) | |||
yield self.store.insert_client_ip( | |||
user_id, "access_token", "ip", "user_agent", "device_id", | |||
user_id, "access_token", "ip", "user_agent", "device_id" | |||
) | |||
active = yield self.store._user_last_seen_monthly_active(user_id) | |||
self.assertTrue(active) | |||
@@ -107,10 +106,10 @@ class ClientIpStoreTestCase(tests.unittest.TestCase): | |||
self.assertFalse(active) | |||
yield self.store.insert_client_ip( | |||
user_id, "access_token", "ip", "user_agent", "device_id", | |||
user_id, "access_token", "ip", "user_agent", "device_id" | |||
) | |||
yield self.store.insert_client_ip( | |||
user_id, "access_token", "ip", "user_agent", "device_id", | |||
user_id, "access_token", "ip", "user_agent", "device_id" | |||
) | |||
active = yield self.store._user_last_seen_monthly_active(user_id) | |||
self.assertTrue(active) |
@@ -34,62 +34,58 @@ class DeviceStoreTestCase(tests.unittest.TestCase): | |||
@defer.inlineCallbacks | |||
def test_store_new_device(self): | |||
yield self.store.store_device( | |||
"user_id", "device_id", "display_name" | |||
) | |||
yield self.store.store_device("user_id", "device_id", "display_name") | |||
res = yield self.store.get_device("user_id", "device_id") | |||
self.assertDictContainsSubset({ | |||
"user_id": "user_id", | |||
"device_id": "device_id", | |||
"display_name": "display_name", | |||
}, res) | |||
self.assertDictContainsSubset( | |||
{ | |||
"user_id": "user_id", | |||
"device_id": "device_id", | |||
"display_name": "display_name", | |||
}, | |||
res, | |||
) | |||
@defer.inlineCallbacks | |||
def test_get_devices_by_user(self): | |||
yield self.store.store_device( | |||
"user_id", "device1", "display_name 1" | |||
) | |||
yield self.store.store_device( | |||
"user_id", "device2", "display_name 2" | |||
) | |||
yield self.store.store_device( | |||
"user_id2", "device3", "display_name 3" | |||
) | |||
yield self.store.store_device("user_id", "device1", "display_name 1") | |||
yield self.store.store_device("user_id", "device2", "display_name 2") | |||
yield self.store.store_device("user_id2", "device3", "display_name 3") | |||
res = yield self.store.get_devices_by_user("user_id") | |||
self.assertEqual(2, len(res.keys())) | |||
self.assertDictContainsSubset({ | |||
"user_id": "user_id", | |||
"device_id": "device1", | |||
"display_name": "display_name 1", | |||
}, res["device1"]) | |||
self.assertDictContainsSubset({ | |||
"user_id": "user_id", | |||
"device_id": "device2", | |||
"display_name": "display_name 2", | |||
}, res["device2"]) | |||
self.assertDictContainsSubset( | |||
{ | |||
"user_id": "user_id", | |||
"device_id": "device1", | |||
"display_name": "display_name 1", | |||
}, | |||
res["device1"], | |||
) | |||
self.assertDictContainsSubset( | |||
{ | |||
"user_id": "user_id", | |||
"device_id": "device2", | |||
"display_name": "display_name 2", | |||
}, | |||
res["device2"], | |||
) | |||
@defer.inlineCallbacks | |||
def test_update_device(self): | |||
yield self.store.store_device( | |||
"user_id", "device_id", "display_name 1" | |||
) | |||
yield self.store.store_device("user_id", "device_id", "display_name 1") | |||
res = yield self.store.get_device("user_id", "device_id") | |||
self.assertEqual("display_name 1", res["display_name"]) | |||
# do a no-op first | |||
yield self.store.update_device( | |||
"user_id", "device_id", | |||
) | |||
yield self.store.update_device("user_id", "device_id") | |||
res = yield self.store.get_device("user_id", "device_id") | |||
self.assertEqual("display_name 1", res["display_name"]) | |||
# do the update | |||
yield self.store.update_device( | |||
"user_id", "device_id", | |||
new_display_name="display_name 2", | |||
"user_id", "device_id", new_display_name="display_name 2" | |||
) | |||
# check it worked | |||
@@ -100,7 +96,6 @@ class DeviceStoreTestCase(tests.unittest.TestCase): | |||
def test_update_unknown_device(self): | |||
with self.assertRaises(synapse.api.errors.StoreError) as cm: | |||
yield self.store.update_device( | |||
"user_id", "unknown_device_id", | |||
new_display_name="display_name 2", | |||
"user_id", "unknown_device_id", new_display_name="display_name 2" | |||
) | |||
self.assertEqual(404, cm.exception.code) |
@@ -24,7 +24,6 @@ from tests.utils import setup_test_homeserver | |||
class DirectoryStoreTestCase(unittest.TestCase): | |||
@defer.inlineCallbacks | |||
def setUp(self): | |||
hs = yield setup_test_homeserver() | |||
@@ -37,38 +36,29 @@ class DirectoryStoreTestCase(unittest.TestCase): | |||
@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"], | |||
room_alias=self.alias, room_id=self.room.to_string(), servers=["test"] | |||
) | |||
self.assertEquals( | |||
["#my-room:test"], | |||
(yield self.store.get_aliases_for_room(self.room.to_string())) | |||
(yield self.store.get_aliases_for_room(self.room.to_string())), | |||
) | |||
@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"], | |||
room_alias=self.alias, room_id=self.room.to_string(), servers=["test"] | |||
) | |||
self.assertObjectHasAttributes( | |||
{ | |||
"room_id": self.room.to_string(), | |||
"servers": ["test"], | |||
}, | |||
(yield self.store.get_association_from_room_alias(self.alias)) | |||
{"room_id": self.room.to_string(), "servers": ["test"]}, | |||
(yield self.store.get_association_from_room_alias(self.alias)), | |||
) | |||
@defer.inlineCallbacks | |||
def test_delete_alias(self): | |||
yield self.store.create_room_alias_association( | |||
room_alias=self.alias, | |||
room_id=self.room.to_string(), | |||
servers=["test"], | |||
room_alias=self.alias, room_id=self.room.to_string(), servers=["test"] | |||
) | |||
room_id = yield self.store.delete_room_alias(self.alias) | |||
@@ -35,70 +35,49 @@ class EndToEndKeyStoreTestCase(tests.unittest.TestCase): | |||
now = 1470174257070 | |||
json = {"key": "value"} | |||
yield self.store.store_device( | |||
"user", "device", None | |||
) | |||
yield self.store.store_device("user", "device", None) | |||
yield self.store.set_e2e_device_keys( | |||
"user", "device", now, json) | |||
yield self.store.set_e2e_device_keys("user", "device", now, json) | |||
res = yield self.store.get_e2e_device_keys((("user", "device"),)) | |||
self.assertIn("user", res) | |||
self.assertIn("device", res["user"]) | |||
dev = res["user"]["device"] | |||
self.assertDictContainsSubset({ | |||
"keys": json, | |||
"device_display_name": None, | |||
}, dev) | |||
self.assertDictContainsSubset({"keys": json, "device_display_name": None}, dev) | |||
@defer.inlineCallbacks | |||
def test_get_key_with_device_name(self): | |||
now = 1470174257070 | |||
json = {"key": "value"} | |||
yield self.store.set_e2e_device_keys( | |||
"user", "device", now, json) | |||
yield self.store.store_device( | |||
"user", "device", "display_name" | |||
) | |||
yield self.store.set_e2e_device_keys("user", "device", now, json) | |||
yield self.store.store_device("user", "device", "display_name") | |||
res = yield self.store.get_e2e_device_keys((("user", "device"),)) | |||
self.assertIn("user", res) | |||
self.assertIn("device", res["user"]) | |||
dev = res["user"]["device"] | |||
self.assertDictContainsSubset({ | |||
"keys": json, | |||
"device_display_name": "display_name", | |||
}, dev) | |||
self.assertDictContainsSubset( | |||
{"keys": json, "device_display_name": "display_name"}, dev | |||
) | |||
@defer.inlineCallbacks | |||
def test_multiple_devices(self): | |||
now = 1470174257070 | |||
yield self.store.store_device( | |||
"user1", "device1", None | |||
) | |||
yield self.store.store_device( | |||
"user1", "device2", None | |||
) | |||
yield self.store.store_device( | |||
"user2", "device1", None | |||
) | |||
yield self.store.store_device( | |||
"user2", "device2", None | |||
) | |||
yield self.store.store_device("user1", "device1", None) | |||
yield self.store.store_device("user1", "device2", None) | |||
yield self.store.store_device("user2", "device1", None) | |||
yield self.store.store_device("user2", "device2", None) | |||
yield self.store.set_e2e_device_keys( | |||
"user1", "device1", now, 'json11') | |||
yield self.store.set_e2e_device_keys( | |||
"user1", "device2", now, 'json12') | |||
yield self.store.set_e2e_device_keys( | |||
"user2", "device1", now, 'json21') | |||
yield self.store.set_e2e_device_keys( | |||
"user2", "device2", now, 'json22') | |||
res = yield self.store.get_e2e_device_keys((("user1", "device1"), | |||
("user2", "device2"))) | |||
yield self.store.set_e2e_device_keys("user1", "device1", now, 'json11') | |||
yield self.store.set_e2e_device_keys("user1", "device2", now, 'json12') | |||
yield self.store.set_e2e_device_keys("user2", "device1", now, 'json21') | |||
yield self.store.set_e2e_device_keys("user2", "device2", now, 'json22') | |||
res = yield self.store.get_e2e_device_keys( | |||
(("user1", "device1"), ("user2", "device2")) | |||
) | |||
self.assertIn("user1", res) | |||
self.assertIn("device1", res["user1"]) | |||
self.assertNotIn("device2", res["user1"]) | |||
@@ -33,23 +33,32 @@ class EventFederationWorkerStoreTestCase(tests.unittest.TestCase): | |||
def insert_event(txn, i): | |||
event_id = '$event_%i:local' % i | |||
txn.execute(( | |||
"INSERT INTO events (" | |||
" room_id, event_id, type, depth, topological_ordering," | |||
" content, processed, outlier) " | |||
"VALUES (?, ?, 'm.test', ?, ?, 'test', ?, ?)" | |||
), (room_id, event_id, i, i, True, False)) | |||
txn.execute( | |||
( | |||
"INSERT INTO events (" | |||
" room_id, event_id, type, depth, topological_ordering," | |||
" content, processed, outlier) " | |||
"VALUES (?, ?, 'm.test', ?, ?, 'test', ?, ?)" | |||
), | |||
(room_id, event_id, i, i, True, False), | |||
) | |||
txn.execute(( | |||
'INSERT INTO event_forward_extremities (room_id, event_id) ' | |||
'VALUES (?, ?)' | |||
), (room_id, event_id)) | |||
txn.execute( | |||
( | |||
'INSERT INTO event_forward_extremities (room_id, event_id) ' | |||
'VALUES (?, ?)' | |||
), | |||
(room_id, event_id), | |||
) | |||
txn.execute(( | |||
'INSERT INTO event_reference_hashes ' | |||
'(event_id, algorithm, hash) ' | |||
"VALUES (?, 'sha256', ?)" | |||
), (event_id, b'ffff')) | |||
txn.execute( | |||
( | |||
'INSERT INTO event_reference_hashes ' | |||
'(event_id, algorithm, hash) ' | |||
"VALUES (?, 'sha256', ?)" | |||
), | |||
(event_id, b'ffff'), | |||
) | |||
for i in range(0, 11): | |||
yield self.store.runInteraction("insert", insert_event, i) | |||
@@ -24,12 +24,13 @@ USER_ID = "@user:example.com" | |||
PlAIN_NOTIF = ["notify", {"set_tweak": "highlight", "value": False}] | |||
HIGHLIGHT = [ | |||
"notify", {"set_tweak": "sound", "value": "default"}, {"set_tweak": "highlight"} | |||
"notify", | |||
{"set_tweak": "sound", "value": "default"}, | |||
{"set_tweak": "highlight"}, | |||
] | |||
class EventPushActionsStoreTestCase(tests.unittest.TestCase): | |||
@defer.inlineCallbacks | |||
def setUp(self): | |||
hs = yield tests.utils.setup_test_homeserver() | |||
@@ -55,12 +56,11 @@ class EventPushActionsStoreTestCase(tests.unittest.TestCase): | |||
@defer.inlineCallbacks | |||
def _assert_counts(noitf_count, highlight_count): | |||
counts = yield self.store.runInteraction( | |||
"", self.store._get_unread_counts_by_pos_txn, | |||
room_id, user_id, 0 | |||
"", self.store._get_unread_counts_by_pos_txn, room_id, user_id, 0 | |||
) | |||
self.assertEquals( | |||
counts, | |||
{"notify_count": noitf_count, "highlight_count": highlight_count} | |||
{"notify_count": noitf_count, "highlight_count": highlight_count}, | |||
) | |||
@defer.inlineCallbacks | |||
@@ -72,11 +72,13 @@ class EventPushActionsStoreTestCase(tests.unittest.TestCase): | |||
event.depth = stream | |||
yield self.store.add_push_actions_to_staging( | |||
event.event_id, {user_id: action}, | |||
event.event_id, {user_id: action} | |||
) | |||
yield self.store.runInteraction( | |||
"", self.store._set_push_actions_for_event_and_users_txn, | |||
[(event, None)], [(event, None)], | |||
"", | |||
self.store._set_push_actions_for_event_and_users_txn, | |||
[(event, None)], | |||
[(event, None)], | |||
) | |||
def _rotate(stream): | |||
@@ -86,8 +88,11 @@ class EventPushActionsStoreTestCase(tests.unittest.TestCase): | |||
def _mark_read(stream, depth): | |||
return self.store.runInteraction( | |||
"", self.store._remove_old_push_actions_before_txn, | |||
room_id, user_id, stream | |||
"", | |||
self.store._remove_old_push_actions_before_txn, | |||
room_id, | |||
user_id, | |||
stream, | |||
) | |||
yield _assert_counts(0, 0) | |||
@@ -112,9 +117,7 @@ class EventPushActionsStoreTestCase(tests.unittest.TestCase): | |||
yield _rotate(7) | |||
yield self.store._simple_delete( | |||
table="event_push_actions", | |||
keyvalues={"1": 1}, | |||
desc="", | |||
table="event_push_actions", keyvalues={"1": 1}, desc="" | |||
) | |||
yield _assert_counts(1, 0) | |||
@@ -132,18 +135,21 @@ class EventPushActionsStoreTestCase(tests.unittest.TestCase): | |||
@defer.inlineCallbacks | |||
def test_find_first_stream_ordering_after_ts(self): | |||
def add_event(so, ts): | |||
return self.store._simple_insert("events", { | |||
"stream_ordering": so, | |||
"received_ts": ts, | |||
"event_id": "event%i" % so, | |||
"type": "", | |||
"room_id": "", | |||
"content": "", | |||
"processed": True, | |||
"outlier": False, | |||
"topological_ordering": 0, | |||
"depth": 0, | |||
}) | |||
return self.store._simple_insert( | |||
"events", | |||
{ | |||
"stream_ordering": so, | |||
"received_ts": ts, | |||
"event_id": "event%i" % so, | |||
"type": "", | |||
"room_id": "", | |||
"content": "", | |||
"processed": True, | |||
"outlier": False, | |||
"topological_ordering": 0, | |||
"depth": 0, | |||
}, | |||
) | |||
# start with the base case where there are no events in the table | |||
r = yield self.store.find_first_stream_ordering_after_ts(11) | |||
@@ -160,31 +166,27 @@ class EventPushActionsStoreTestCase(tests.unittest.TestCase): | |||
# add a bunch of dummy events to the events table | |||
for (stream_ordering, ts) in ( | |||
(3, 110), | |||
(4, 120), | |||
(5, 120), | |||
(10, 130), | |||
(20, 140), | |||
(3, 110), | |||
(4, 120), | |||
(5, 120), | |||
(10, 130), | |||
(20, 140), | |||
): | |||
yield add_event(stream_ordering, ts) | |||
r = yield self.store.find_first_stream_ordering_after_ts(110) | |||
self.assertEqual(r, 3, | |||
"First event after 110ms should be 3, was %i" % r) | |||
self.assertEqual(r, 3, "First event after 110ms should be 3, was %i" % r) | |||
# 4 and 5 are both after 120: we want 4 rather than 5 | |||
r = yield self.store.find_first_stream_ordering_after_ts(120) | |||
self.assertEqual(r, 4, | |||
"First event after 120ms should be 4, was %i" % r) | |||
self.assertEqual(r, 4, "First event after 120ms should be 4, was %i" % r) | |||
r = yield self.store.find_first_stream_ordering_after_ts(129) | |||
self.assertEqual(r, 10, | |||
"First event after 129ms should be 10, was %i" % r) | |||
self.assertEqual(r, 10, "First event after 129ms should be 10, was %i" % r) | |||
# check we can get the last event | |||
r = yield self.store.find_first_stream_ordering_after_ts(140) | |||
self.assertEqual(r, 20, | |||
"First event after 14ms should be 20, was %i" % r) | |||
self.assertEqual(r, 20, "First event after 14ms should be 20, was %i" % r) | |||
# off the end | |||
r = yield self.store.find_first_stream_ordering_after_ts(160) | |||
@@ -39,15 +39,12 @@ class KeyStoreTestCase(tests.unittest.TestCase): | |||
key2 = signedjson.key.decode_verify_key_base64( | |||
"ed25519", "key2", "Noi6WqcDj0QmPxCNQqgezwTlBKrfqehY1u2FyWP9uYw" | |||
) | |||
yield self.store.store_server_verify_key( | |||
"server1", "from_server", 0, key1 | |||
) | |||
yield self.store.store_server_verify_key( | |||
"server1", "from_server", 0, key2 | |||
) | |||
yield self.store.store_server_verify_key("server1", "from_server", 0, key1) | |||
yield self.store.store_server_verify_key("server1", "from_server", 0, key2) | |||
res = yield self.store.get_server_verify_keys( | |||
"server1", ["ed25519:key1", "ed25519:key2", "ed25519:key3"]) | |||
"server1", ["ed25519:key1", "ed25519:key2", "ed25519:key3"] | |||
) | |||
self.assertEqual(len(res.keys()), 2) | |||
self.assertEqual(res["ed25519:key1"].version, "key1") | |||
@@ -40,19 +40,13 @@ class MonthlyActiveUsersTestCase(tests.unittest.TestCase): | |||
user2_email = "user2@matrix.org" | |||
threepids = [ | |||
{'medium': 'email', 'address': user1_email}, | |||
{'medium': 'email', 'address': user2_email} | |||
{'medium': 'email', 'address': user2_email}, | |||
] | |||
user_num = len(threepids) | |||
yield self.store.register( | |||
user_id=user1, | |||
token="123", | |||
password_hash=None) | |||
yield self.store.register(user_id=user1, token="123", password_hash=None) | |||
yield self.store.register( | |||
user_id=user2, | |||
token="456", | |||
password_hash=None) | |||
yield self.store.register(user_id=user2, token="456", password_hash=None) | |||
now = int(self.hs.get_clock().time_msec()) | |||
yield self.store.user_add_threepid(user1, "email", user1_email, now, now) | |||
@@ -24,7 +24,6 @@ from tests.utils import MockClock, setup_test_homeserver | |||
class PresenceStoreTestCase(unittest.TestCase): | |||
@defer.inlineCallbacks | |||
def setUp(self): | |||
hs = yield setup_test_homeserver(clock=MockClock()) | |||
@@ -38,16 +37,19 @@ class PresenceStoreTestCase(unittest.TestCase): | |||
def test_presence_list(self): | |||
self.assertEquals( | |||
[], | |||
(yield self.store.get_presence_list( | |||
observer_localpart=self.u_apple.localpart, | |||
)) | |||
( | |||
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.get_presence_list( | |||
observer_localpart=self.u_apple.localpart, accepted=True | |||
) | |||
), | |||
) | |||
yield self.store.add_presence_list_pending( | |||
@@ -57,16 +59,19 @@ class PresenceStoreTestCase(unittest.TestCase): | |||
self.assertEquals( | |||
[{"observed_user_id": "@banana:test", "accepted": 0}], | |||
(yield self.store.get_presence_list( | |||
observer_localpart=self.u_apple.localpart, | |||
)) | |||
( | |||
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.get_presence_list( | |||
observer_localpart=self.u_apple.localpart, accepted=True | |||
) | |||
), | |||
) | |||
yield self.store.set_presence_list_accepted( | |||
@@ -76,16 +81,19 @@ class PresenceStoreTestCase(unittest.TestCase): | |||
self.assertEquals( | |||
[{"observed_user_id": "@banana:test", "accepted": 1}], | |||
(yield self.store.get_presence_list( | |||
observer_localpart=self.u_apple.localpart, | |||
)) | |||
( | |||
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.get_presence_list( | |||
observer_localpart=self.u_apple.localpart, accepted=True | |||
) | |||
), | |||
) | |||
yield self.store.del_presence_list( | |||
@@ -95,14 +103,17 @@ class PresenceStoreTestCase(unittest.TestCase): | |||
self.assertEquals( | |||
[], | |||
(yield self.store.get_presence_list( | |||
observer_localpart=self.u_apple.localpart, | |||
)) | |||
( | |||
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.get_presence_list( | |||
observer_localpart=self.u_apple.localpart, accepted=True | |||
) | |||
), | |||
) |
@@ -24,7 +24,6 @@ from tests.utils import setup_test_homeserver | |||
class ProfileStoreTestCase(unittest.TestCase): | |||
@defer.inlineCallbacks | |||
def setUp(self): | |||
hs = yield setup_test_homeserver() | |||
@@ -35,24 +34,17 @@ class ProfileStoreTestCase(unittest.TestCase): | |||
@defer.inlineCallbacks | |||
def test_displayname(self): | |||
yield self.store.create_profile( | |||
self.u_frank.localpart | |||
) | |||
yield self.store.create_profile(self.u_frank.localpart) | |||
yield self.store.set_profile_displayname( | |||
self.u_frank.localpart, "Frank" | |||
) | |||
yield self.store.set_profile_displayname(self.u_frank.localpart, "Frank") | |||
self.assertEquals( | |||
"Frank", | |||
(yield self.store.get_profile_displayname(self.u_frank.localpart)) | |||
"Frank", (yield self.store.get_profile_displayname(self.u_frank.localpart)) | |||
) | |||
@defer.inlineCallbacks | |||
def test_avatar_url(self): | |||
yield self.store.create_profile( | |||
self.u_frank.localpart | |||
) | |||
yield self.store.create_profile(self.u_frank.localpart) | |||
yield self.store.set_profile_avatar_url( | |||
self.u_frank.localpart, "http://my.site/here" | |||
@@ -60,5 +52,5 @@ class ProfileStoreTestCase(unittest.TestCase): | |||
self.assertEquals( | |||
"http://my.site/here", | |||
(yield self.store.get_profile_avatar_url(self.u_frank.localpart)) | |||
(yield self.store.get_profile_avatar_url(self.u_frank.localpart)), | |||
) |
@@ -26,12 +26,10 @@ from tests.utils import setup_test_homeserver | |||
class RedactionTestCase(unittest.TestCase): | |||
@defer.inlineCallbacks | |||
def setUp(self): | |||
hs = yield setup_test_homeserver( | |||
resource_for_federation=Mock(), | |||
http_client=None, | |||
resource_for_federation=Mock(), http_client=None | |||
) | |||
self.store = hs.get_datastore() | |||
@@ -46,17 +44,20 @@ class RedactionTestCase(unittest.TestCase): | |||
self.depth = 1 | |||
@defer.inlineCallbacks | |||
def inject_room_member(self, room, user, membership, replaces_state=None, | |||
extra_content={}): | |||
def inject_room_member( | |||
self, room, user, membership, replaces_state=None, extra_content={} | |||
): | |||
content = {"membership": membership} | |||
content.update(extra_content) | |||
builder = self.event_builder_factory.new({ | |||
"type": EventTypes.Member, | |||
"sender": user.to_string(), | |||
"state_key": user.to_string(), | |||
"room_id": room.to_string(), | |||
"content": content, | |||
}) | |||
builder = self.event_builder_factory.new( | |||
{ | |||
"type": EventTypes.Member, | |||
"sender": user.to_string(), | |||
"state_key": user.to_string(), | |||
"room_id": room.to_string(), | |||
"content": content, | |||
} | |||
) | |||
event, context = yield self.event_creation_handler.create_new_client_event( | |||
builder | |||
@@ -70,13 +71,15 @@ class RedactionTestCase(unittest.TestCase): | |||
def inject_message(self, room, user, body): | |||
self.depth += 1 | |||
builder = self.event_builder_factory.new({ | |||
"type": EventTypes.Message, | |||
"sender": user.to_string(), | |||
"state_key": user.to_string(), | |||
"room_id": room.to_string(), | |||
"content": {"body": body, "msgtype": u"message"}, | |||
}) | |||
builder = self.event_builder_factory.new( | |||
{ | |||
"type": EventTypes.Message, | |||
"sender": user.to_string(), | |||
"state_key": user.to_string(), | |||
"room_id": room.to_string(), | |||
"content": {"body": body, "msgtype": u"message"}, | |||
} | |||
) | |||
event, context = yield self.event_creation_handler.create_new_client_event( | |||
builder | |||
@@ -88,14 +91,16 @@ class RedactionTestCase(unittest.TestCase): | |||
@defer.inlineCallbacks | |||
def inject_redaction(self, room, event_id, user, reason): | |||
builder = self.event_builder_factory.new({ | |||
"type": EventTypes.Redaction, | |||
"sender": user.to_string(), | |||
"state_key": user.to_string(), | |||
"room_id": room.to_string(), | |||
"content": {"reason": reason}, | |||
"redacts": event_id, | |||
}) | |||
builder = self.event_builder_factory.new( | |||
{ | |||
"type": EventTypes.Redaction, | |||
"sender": user.to_string(), | |||
"state_key": user.to_string(), | |||
"room_id": room.to_string(), | |||
"content": {"reason": reason}, | |||
"redacts": event_id, | |||
} | |||
) | |||
event, context = yield self.event_creation_handler.create_new_client_event( | |||
builder | |||
@@ -105,9 +110,7 @@ class RedactionTestCase(unittest.TestCase): | |||
@defer.inlineCallbacks | |||
def test_redact(self): | |||
yield self.inject_room_member( | |||
self.room1, self.u_alice, Membership.JOIN | |||
) | |||
yield self.inject_room_member(self.room1, self.u_alice, Membership.JOIN) | |||
msg_event = yield self.inject_message(self.room1, self.u_alice, u"t") | |||
@@ -157,13 +160,10 @@ class RedactionTestCase(unittest.TestCase): | |||
@defer.inlineCallbacks | |||
def test_redact_join(self): | |||
yield self.inject_room_member( | |||
self.room1, self.u_alice, Membership.JOIN | |||
) | |||
yield self.inject_room_member(self.room1, self.u_alice, Membership.JOIN) | |||
msg_event = yield self.inject_room_member( | |||
self.room1, self.u_bob, Membership.JOIN, | |||
extra_content={"blue": "red"}, | |||
self.room1, self.u_bob, Membership.JOIN, extra_content={"blue": "red"} | |||
) | |||
event = yield self.store.get_event(msg_event.event_id) | |||
@@ -21,7 +21,6 @@ from tests.utils import setup_test_homeserver | |||
class RegistrationStoreTestCase(unittest.TestCase): | |||
@defer.inlineCallbacks | |||
def setUp(self): | |||
hs = yield setup_test_homeserver() | |||
@@ -30,10 +29,7 @@ class RegistrationStoreTestCase(unittest.TestCase): | |||
self.store = hs.get_datastore() | |||
self.user_id = "@my-user:test" | |||
self.tokens = [ | |||
"AbCdEfGhIjKlMnOpQrStUvWxYz", | |||
"BcDeFgHiJkLmNoPqRsTuVwXyZa" | |||
] | |||
self.tokens = ["AbCdEfGhIjKlMnOpQrStUvWxYz", "BcDeFgHiJkLmNoPqRsTuVwXyZa"] | |||
self.pwhash = "{xx1}123456789" | |||
self.device_id = "akgjhdjklgshg" | |||
@@ -51,34 +47,26 @@ class RegistrationStoreTestCase(unittest.TestCase): | |||
"consent_server_notice_sent": None, | |||
"appservice_id": None, | |||
}, | |||
(yield self.store.get_user_by_id(self.user_id)) | |||
(yield self.store.get_user_by_id(self.user_id)), | |||
) | |||
result = yield self.store.get_user_by_access_token(self.tokens[0]) | |||
self.assertDictContainsSubset( | |||
{ | |||
"name": self.user_id, | |||
}, | |||
result | |||
) | |||
self.assertDictContainsSubset({"name": self.user_id}, result) | |||
self.assertTrue("token_id" in result) | |||
@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.device_id) | |||
yield self.store.add_access_token_to_user( | |||
self.user_id, self.tokens[1], self.device_id | |||
) | |||
result = yield self.store.get_user_by_access_token(self.tokens[1]) | |||
self.assertDictContainsSubset( | |||
{ | |||
"name": self.user_id, | |||
"device_id": self.device_id, | |||
}, | |||
result | |||
{"name": self.user_id, "device_id": self.device_id}, result | |||
) | |||
self.assertTrue("token_id" in result) | |||
@@ -87,12 +75,13 @@ class RegistrationStoreTestCase(unittest.TestCase): | |||
def test_user_delete_access_tokens(self): | |||
# add some tokens | |||
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.device_id) | |||
yield self.store.add_access_token_to_user( | |||
self.user_id, self.tokens[1], self.device_id | |||
) | |||
# now delete some | |||
yield self.store.user_delete_access_tokens( | |||
self.user_id, device_id=self.device_id, | |||
self.user_id, device_id=self.device_id | |||
) | |||
# check they were deleted | |||
@@ -107,8 +96,7 @@ class RegistrationStoreTestCase(unittest.TestCase): | |||
yield self.store.user_delete_access_tokens(self.user_id) | |||
user = yield self.store.get_user_by_access_token(self.tokens[0]) | |||
self.assertIsNone(user, | |||
"access token was not deleted without device_id") | |||
self.assertIsNone(user, "access token was not deleted without device_id") | |||
class TokenGenerator: | |||
@@ -117,4 +105,4 @@ class TokenGenerator: | |||
def generate(self, user_id): | |||
self._last_issued_token += 1 | |||
return u"%s-%d" % (user_id, self._last_issued_token,) | |||
return u"%s-%d" % (user_id, self._last_issued_token) |
@@ -24,7 +24,6 @@ from tests.utils import setup_test_homeserver | |||
class RoomStoreTestCase(unittest.TestCase): | |||
@defer.inlineCallbacks | |||
def setUp(self): | |||
hs = yield setup_test_homeserver() | |||
@@ -40,7 +39,7 @@ class RoomStoreTestCase(unittest.TestCase): | |||
yield self.store.store_room( | |||
self.room.to_string(), | |||
room_creator_user_id=self.u_creator.to_string(), | |||
is_public=True | |||
is_public=True, | |||
) | |||
@defer.inlineCallbacks | |||
@@ -49,14 +48,13 @@ class RoomStoreTestCase(unittest.TestCase): | |||
{ | |||
"room_id": self.room.to_string(), | |||
"creator": self.u_creator.to_string(), | |||
"is_public": True | |||
"is_public": True, | |||
}, | |||
(yield self.store.get_room(self.room.to_string())) | |||
(yield self.store.get_room(self.room.to_string())), | |||
) | |||
class RoomEventsStoreTestCase(unittest.TestCase): | |||
@defer.inlineCallbacks | |||
def setUp(self): | |||
hs = setup_test_homeserver() | |||
@@ -69,18 +67,13 @@ class RoomEventsStoreTestCase(unittest.TestCase): | |||
self.room = RoomID.from_string("!abcde:test") | |||
yield self.store.store_room( | |||
self.room.to_string(), | |||
room_creator_user_id="@creator:text", | |||
is_public=True | |||
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 | |||
) | |||
self.event_factory.create_event(room_id=self.room.to_string(), **kwargs) | |||
) | |||
@defer.inlineCallbacks | |||
@@ -88,22 +81,15 @@ class RoomEventsStoreTestCase(unittest.TestCase): | |||
name = u"A-Room-Name" | |||
yield self.inject_room_event( | |||
etype=EventTypes.Name, | |||
name=name, | |||
content={"name": name}, | |||
depth=1, | |||
etype=EventTypes.Name, name=name, content={"name": name}, depth=1 | |||
) | |||
state = yield self.store.get_current_state( | |||
room_id=self.room.to_string() | |||
) | |||
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] | |||
{"type": "m.room.name", "room_id": self.room.to_string(), "name": name}, | |||
state[0], | |||
) | |||
@defer.inlineCallbacks | |||
@@ -111,22 +97,15 @@ class RoomEventsStoreTestCase(unittest.TestCase): | |||
topic = u"A place for things" | |||
yield self.inject_room_event( | |||
etype=EventTypes.Topic, | |||
topic=topic, | |||
content={"topic": topic}, | |||
depth=1, | |||
etype=EventTypes.Topic, topic=topic, content={"topic": topic}, depth=1 | |||
) | |||
state = yield self.store.get_current_state( | |||
room_id=self.room.to_string() | |||
) | |||
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] | |||
{"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 | |||
@@ -26,12 +26,10 @@ from tests.utils import setup_test_homeserver | |||
class RoomMemberStoreTestCase(unittest.TestCase): | |||
@defer.inlineCallbacks | |||
def setUp(self): | |||
hs = yield setup_test_homeserver( | |||
resource_for_federation=Mock(), | |||
http_client=None, | |||
resource_for_federation=Mock(), http_client=None | |||
) | |||
# We can't test the RoomMemberStore on its own without the other event | |||
# storage logic | |||
@@ -49,13 +47,15 @@ class RoomMemberStoreTestCase(unittest.TestCase): | |||
@defer.inlineCallbacks | |||
def inject_room_member(self, room, user, membership, replaces_state=None): | |||
builder = self.event_builder_factory.new({ | |||
"type": EventTypes.Member, | |||
"sender": user.to_string(), | |||
"state_key": user.to_string(), | |||
"room_id": room.to_string(), | |||
"content": {"membership": membership}, | |||
}) | |||
builder = self.event_builder_factory.new( | |||
{ | |||
"type": EventTypes.Member, | |||
"sender": user.to_string(), | |||
"state_key": user.to_string(), | |||
"room_id": room.to_string(), | |||
"content": {"membership": membership}, | |||
} | |||
) | |||
event, context = yield self.event_creation_handler.create_new_client_event( | |||
builder | |||
@@ -71,9 +71,12 @@ class RoomMemberStoreTestCase(unittest.TestCase): | |||
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] | |||
[ | |||
m.room_id | |||
for m in ( | |||
yield self.store.get_rooms_for_user_where_membership_is( | |||
self.u_alice.to_string(), [Membership.JOIN] | |||
) | |||
) | |||
)] | |||
], | |||
) |
@@ -45,20 +45,20 @@ class StateStoreTestCase(tests.unittest.TestCase): | |||
self.room = RoomID.from_string("!abc123:test") | |||
yield self.store.store_room( | |||
self.room.to_string(), | |||
room_creator_user_id="@creator:text", | |||
is_public=True | |||
self.room.to_string(), room_creator_user_id="@creator:text", is_public=True | |||
) | |||
@defer.inlineCallbacks | |||
def inject_state_event(self, room, sender, typ, state_key, content): | |||
builder = self.event_builder_factory.new({ | |||
"type": typ, | |||
"sender": sender.to_string(), | |||
"state_key": state_key, | |||
"room_id": room.to_string(), | |||
"content": content, | |||
}) | |||
builder = self.event_builder_factory.new( | |||
{ | |||
"type": typ, | |||
"sender": sender.to_string(), | |||
"state_key": state_key, | |||
"room_id": room.to_string(), | |||
"content": content, | |||
} | |||
) | |||
event, context = yield self.event_creation_handler.create_new_client_event( | |||
builder | |||
@@ -80,27 +80,31 @@ class StateStoreTestCase(tests.unittest.TestCase): | |||
# this defaults to a linear DAG as each new injection defaults to whatever | |||
# forward extremities are currently in the DB for this room. | |||
e1 = yield self.inject_state_event( | |||
self.room, self.u_alice, EventTypes.Create, '', {}, | |||
self.room, self.u_alice, EventTypes.Create, '', {} | |||
) | |||
e2 = yield self.inject_state_event( | |||
self.room, self.u_alice, EventTypes.Name, '', { | |||
"name": "test room" | |||
}, | |||
self.room, self.u_alice, EventTypes.Name, '', {"name": "test room"} | |||
) | |||
e3 = yield self.inject_state_event( | |||
self.room, self.u_alice, EventTypes.Member, self.u_alice.to_string(), { | |||
"membership": Membership.JOIN | |||
}, | |||
self.room, | |||
self.u_alice, | |||
EventTypes.Member, | |||
self.u_alice.to_string(), | |||
{"membership": Membership.JOIN}, | |||
) | |||
e4 = yield self.inject_state_event( | |||
self.room, self.u_bob, EventTypes.Member, self.u_bob.to_string(), { | |||
"membership": Membership.JOIN | |||
}, | |||
self.room, | |||
self.u_bob, | |||
EventTypes.Member, | |||
self.u_bob.to_string(), | |||
{"membership": Membership.JOIN}, | |||
) | |||
e5 = yield self.inject_state_event( | |||
self.room, self.u_bob, EventTypes.Member, self.u_bob.to_string(), { | |||
"membership": Membership.LEAVE | |||
}, | |||
self.room, | |||
self.u_bob, | |||
EventTypes.Member, | |||
self.u_bob.to_string(), | |||
{"membership": Membership.LEAVE}, | |||
) | |||
# check we get the full state as of the final event | |||
@@ -110,65 +114,66 @@ class StateStoreTestCase(tests.unittest.TestCase): | |||
self.assertIsNotNone(e4) | |||
self.assertStateMapEqual({ | |||
(e1.type, e1.state_key): e1, | |||
(e2.type, e2.state_key): e2, | |||
(e3.type, e3.state_key): e3, | |||
# e4 is overwritten by e5 | |||
(e5.type, e5.state_key): e5, | |||
}, state) | |||
self.assertStateMapEqual( | |||
{ | |||
(e1.type, e1.state_key): e1, | |||
(e2.type, e2.state_key): e2, | |||
(e3.type, e3.state_key): e3, | |||
# e4 is overwritten by e5 | |||
(e5.type, e5.state_key): e5, | |||
}, | |||
state, | |||
) | |||
# check we can filter to the m.room.name event (with a '' state key) | |||
state = yield self.store.get_state_for_event( | |||
e5.event_id, [(EventTypes.Name, '')], filtered_types=None | |||
) | |||
self.assertStateMapEqual({ | |||
(e2.type, e2.state_key): e2, | |||
}, state) | |||
self.assertStateMapEqual({(e2.type, e2.state_key): e2}, state) | |||
# check we can filter to the m.room.name event (with a wildcard None state key) | |||
state = yield self.store.get_state_for_event( | |||
e5.event_id, [(EventTypes.Name, None)], filtered_types=None | |||
) | |||
self.assertStateMapEqual({ | |||
(e2.type, e2.state_key): e2, | |||
}, state) | |||
self.assertStateMapEqual({(e2.type, e2.state_key): e2}, state) | |||
# check we can grab the m.room.member events (with a wildcard None state key) | |||
state = yield self.store.get_state_for_event( | |||
e5.event_id, [(EventTypes.Member, None)], filtered_types=None | |||
) | |||
self.assertStateMapEqual({ | |||
(e3.type, e3.state_key): e3, | |||
(e5.type, e5.state_key): e5, | |||
}, state) | |||
self.assertStateMapEqual( | |||
{(e3.type, e3.state_key): e3, (e5.type, e5.state_key): e5}, state | |||
) | |||
# check we can use filter_types to grab a specific room member | |||
# without filtering out the other event types | |||
state = yield self.store.get_state_for_event( | |||
e5.event_id, [(EventTypes.Member, self.u_alice.to_string())], | |||
e5.event_id, | |||
[(EventTypes.Member, self.u_alice.to_string())], | |||
filtered_types=[EventTypes.Member], | |||
) | |||
self.assertStateMapEqual({ | |||
(e1.type, e1.state_key): e1, | |||
(e2.type, e2.state_key): e2, | |||
(e3.type, e3.state_key): e3, | |||
}, state) | |||
self.assertStateMapEqual( | |||
{ | |||
(e1.type, e1.state_key): e1, | |||
(e2.type, e2.state_key): e2, | |||
(e3.type, e3.state_key): e3, | |||
}, | |||
state, | |||
) | |||
# check that types=[], filtered_types=[EventTypes.Member] | |||
# doesn't return all members | |||
state = yield self.store.get_state_for_event( | |||
e5.event_id, [], filtered_types=[EventTypes.Member], | |||
e5.event_id, [], filtered_types=[EventTypes.Member] | |||
) | |||
self.assertStateMapEqual({ | |||
(e1.type, e1.state_key): e1, | |||
(e2.type, e2.state_key): e2, | |||
}, state) | |||
self.assertStateMapEqual( | |||
{(e1.type, e1.state_key): e1, (e2.type, e2.state_key): e2}, state | |||
) | |||
####################################################### | |||
# _get_some_state_from_cache tests against a full cache | |||
@@ -184,10 +189,13 @@ class StateStoreTestCase(tests.unittest.TestCase): | |||
) | |||
self.assertEqual(is_all, True) | |||
self.assertDictEqual({ | |||
(e1.type, e1.state_key): e1.event_id, | |||
(e2.type, e2.state_key): e2.event_id, | |||
}, state_dict) | |||
self.assertDictEqual( | |||
{ | |||
(e1.type, e1.state_key): e1.event_id, | |||
(e2.type, e2.state_key): e2.event_id, | |||
}, | |||
state_dict, | |||
) | |||
# test _get_some_state_from_cache correctly filters in members with wildcard types | |||
(state_dict, is_all) = yield self.store._get_some_state_from_cache( | |||
@@ -195,25 +203,33 @@ class StateStoreTestCase(tests.unittest.TestCase): | |||
) | |||
self.assertEqual(is_all, True) | |||
self.assertDictEqual({ | |||
(e1.type, e1.state_key): e1.event_id, | |||
(e2.type, e2.state_key): e2.event_id, | |||
(e3.type, e3.state_key): e3.event_id, | |||
# e4 is overwritten by e5 | |||
(e5.type, e5.state_key): e5.event_id, | |||
}, state_dict) | |||
self.assertDictEqual( | |||
{ | |||
(e1.type, e1.state_key): e1.event_id, | |||
(e2.type, e2.state_key): e2.event_id, | |||
(e3.type, e3.state_key): e3.event_id, | |||
# e4 is overwritten by e5 | |||
(e5.type, e5.state_key): e5.event_id, | |||
}, | |||
state_dict, | |||
) | |||
# test _get_some_state_from_cache correctly filters in members with specific types | |||
(state_dict, is_all) = yield self.store._get_some_state_from_cache( | |||
group, [(EventTypes.Member, e5.state_key)], filtered_types=[EventTypes.Member] | |||
group, | |||
[(EventTypes.Member, e5.state_key)], | |||
filtered_types=[EventTypes.Member], | |||
) | |||
self.assertEqual(is_all, True) | |||
self.assertDictEqual({ | |||
(e1.type, e1.state_key): e1.event_id, | |||
(e2.type, e2.state_key): e2.event_id, | |||
(e5.type, e5.state_key): e5.event_id, | |||
}, state_dict) | |||
self.assertDictEqual( | |||
{ | |||
(e1.type, e1.state_key): e1.event_id, | |||
(e2.type, e2.state_key): e2.event_id, | |||
(e5.type, e5.state_key): e5.event_id, | |||
}, | |||
state_dict, | |||
) | |||
# test _get_some_state_from_cache correctly filters in members with specific types | |||
# and no filtered_types | |||
@@ -222,24 +238,27 @@ class StateStoreTestCase(tests.unittest.TestCase): | |||
) | |||
self.assertEqual(is_all, True) | |||
self.assertDictEqual({ | |||
(e5.type, e5.state_key): e5.event_id, | |||
}, state_dict) | |||
self.assertDictEqual({(e5.type, e5.state_key): e5.event_id}, state_dict) | |||
####################################################### | |||
# deliberately remove e2 (room name) from the _state_group_cache | |||
(is_all, known_absent, state_dict_ids) = self.store._state_group_cache.get(group) | |||
(is_all, known_absent, state_dict_ids) = self.store._state_group_cache.get( | |||
group | |||
) | |||
self.assertEqual(is_all, True) | |||
self.assertEqual(known_absent, set()) | |||
self.assertDictEqual(state_dict_ids, { | |||
(e1.type, e1.state_key): e1.event_id, | |||
(e2.type, e2.state_key): e2.event_id, | |||
(e3.type, e3.state_key): e3.event_id, | |||
# e4 is overwritten by e5 | |||
(e5.type, e5.state_key): e5.event_id, | |||
}) | |||
self.assertDictEqual( | |||
state_dict_ids, | |||
{ | |||
(e1.type, e1.state_key): e1.event_id, | |||
(e2.type, e2.state_key): e2.event_id, | |||
(e3.type, e3.state_key): e3.event_id, | |||
# e4 is overwritten by e5 | |||
(e5.type, e5.state_key): e5.event_id, | |||
}, | |||
) | |||
state_dict_ids.pop((e2.type, e2.state_key)) | |||
self.store._state_group_cache.invalidate(group) | |||
@@ -252,22 +271,32 @@ class StateStoreTestCase(tests.unittest.TestCase): | |||
(e1.type, e1.state_key), | |||
(e3.type, e3.state_key), | |||
(e5.type, e5.state_key), | |||
) | |||
), | |||
) | |||
(is_all, known_absent, state_dict_ids) = self.store._state_group_cache.get(group) | |||
(is_all, known_absent, state_dict_ids) = self.store._state_group_cache.get( | |||
group | |||
) | |||
self.assertEqual(is_all, False) | |||
self.assertEqual(known_absent, set([ | |||
(e1.type, e1.state_key), | |||
(e3.type, e3.state_key), | |||
(e5.type, e5.state_key), | |||
])) | |||
self.assertDictEqual(state_dict_ids, { | |||
(e1.type, e1.state_key): e1.event_id, | |||
(e3.type, e3.state_key): e3.event_id, | |||
(e5.type, e5.state_key): e5.event_id, | |||
}) | |||
self.assertEqual( | |||
known_absent, | |||
set( | |||
[ | |||
(e1.type, e1.state_key), | |||
(e3.type, e3.state_key), | |||
(e5.type, e5.state_key), | |||
] | |||
), | |||
) | |||
self.assertDictEqual( | |||
state_dict_ids, | |||
{ | |||
(e1.type, e1.state_key): e1.event_id, | |||
(e3.type, e3.state_key): e3.event_id, | |||
(e5.type, e5.state_key): e5.event_id, | |||
}, | |||
) | |||
############################################ | |||
# test that things work with a partial cache | |||
@@ -279,9 +308,7 @@ class StateStoreTestCase(tests.unittest.TestCase): | |||
) | |||
self.assertEqual(is_all, False) | |||
self.assertDictEqual({ | |||
(e1.type, e1.state_key): e1.event_id, | |||
}, state_dict) | |||
self.assertDictEqual({(e1.type, e1.state_key): e1.event_id}, state_dict) | |||
# test _get_some_state_from_cache correctly filters in members wildcard types | |||
(state_dict, is_all) = yield self.store._get_some_state_from_cache( | |||
@@ -289,23 +316,31 @@ class StateStoreTestCase(tests.unittest.TestCase): | |||
) | |||
self.assertEqual(is_all, False) | |||
self.assertDictEqual({ | |||
(e1.type, e1.state_key): e1.event_id, | |||
(e3.type, e3.state_key): e3.event_id, | |||
# e4 is overwritten by e5 | |||
(e5.type, e5.state_key): e5.event_id, | |||
}, state_dict) | |||
self.assertDictEqual( | |||
{ | |||
(e1.type, e1.state_key): e1.event_id, | |||
(e3.type, e3.state_key): e3.event_id, | |||
# e4 is overwritten by e5 | |||
(e5.type, e5.state_key): e5.event_id, | |||
}, | |||
state_dict, | |||
) | |||
# test _get_some_state_from_cache correctly filters in members with specific types | |||
(state_dict, is_all) = yield self.store._get_some_state_from_cache( | |||
group, [(EventTypes.Member, e5.state_key)], filtered_types=[EventTypes.Member] | |||
group, | |||
[(EventTypes.Member, e5.state_key)], | |||
filtered_types=[EventTypes.Member], | |||
) | |||
self.assertEqual(is_all, False) | |||
self.assertDictEqual({ | |||
(e1.type, e1.state_key): e1.event_id, | |||
(e5.type, e5.state_key): e5.event_id, | |||
}, state_dict) | |||
self.assertDictEqual( | |||
{ | |||
(e1.type, e1.state_key): e1.event_id, | |||
(e5.type, e5.state_key): e5.event_id, | |||
}, | |||
state_dict, | |||
) | |||
# test _get_some_state_from_cache correctly filters in members with specific types | |||
# and no filtered_types | |||
@@ -314,6 +349,4 @@ class StateStoreTestCase(tests.unittest.TestCase): | |||
) | |||
self.assertEqual(is_all, True) | |||
self.assertDictEqual({ | |||
(e5.type, e5.state_key): e5.event_id, | |||
}, state_dict) | |||
self.assertDictEqual({(e5.type, e5.state_key): e5.event_id}, state_dict) |
@@ -39,20 +39,12 @@ class UserDirectoryStoreTestCase(unittest.TestCase): | |||
{ | |||
ALICE: ProfileInfo(None, "alice"), | |||
BOB: ProfileInfo(None, "bob"), | |||
BOBBY: ProfileInfo(None, "bobby") | |||
BOBBY: ProfileInfo(None, "bobby"), | |||
}, | |||
) | |||
yield self.store.add_users_to_public_room( | |||
"!room:id", | |||
[ALICE, BOB], | |||
) | |||
yield self.store.add_users_to_public_room("!room:id", [ALICE, BOB]) | |||
yield self.store.add_users_who_share_room( | |||
"!room:id", | |||
False, | |||
( | |||
(ALICE, BOB), | |||
(BOB, ALICE), | |||
), | |||
"!room:id", False, ((ALICE, BOB), (BOB, ALICE)) | |||
) | |||
@defer.inlineCallbacks | |||
@@ -62,11 +54,9 @@ class UserDirectoryStoreTestCase(unittest.TestCase): | |||
r = yield self.store.search_user_dir(ALICE, "bob", 10) | |||
self.assertFalse(r["limited"]) | |||
self.assertEqual(1, len(r["results"])) | |||
self.assertDictEqual(r["results"][0], { | |||
"user_id": BOB, | |||
"display_name": "bob", | |||
"avatar_url": None, | |||
}) | |||
self.assertDictEqual( | |||
r["results"][0], {"user_id": BOB, "display_name": "bob", "avatar_url": None} | |||
) | |||
@defer.inlineCallbacks | |||
def test_search_user_dir_all_users(self): | |||
@@ -75,15 +65,13 @@ class UserDirectoryStoreTestCase(unittest.TestCase): | |||
r = yield self.store.search_user_dir(ALICE, "bob", 10) | |||
self.assertFalse(r["limited"]) | |||
self.assertEqual(2, len(r["results"])) | |||
self.assertDictEqual(r["results"][0], { | |||
"user_id": BOB, | |||
"display_name": "bob", | |||
"avatar_url": None, | |||
}) | |||
self.assertDictEqual(r["results"][1], { | |||
"user_id": BOBBY, | |||
"display_name": "bobby", | |||
"avatar_url": None, | |||
}) | |||
self.assertDictEqual( | |||
r["results"][0], | |||
{"user_id": BOB, "display_name": "bob", "avatar_url": None}, | |||
) | |||
self.assertDictEqual( | |||
r["results"][1], | |||
{"user_id": BOBBY, "display_name": "bobby", "avatar_url": None}, | |||
) | |||
finally: | |||
self.hs.config.user_directory_search_all_users = False |
@@ -22,7 +22,6 @@ from . import unittest | |||
class DistributorTestCase(unittest.TestCase): | |||
def setUp(self): | |||
self.dist = Distributor() | |||
@@ -44,18 +43,14 @@ class DistributorTestCase(unittest.TestCase): | |||
observers[0].side_effect = Exception("Awoogah!") | |||
with patch( | |||
"synapse.util.distributor.logger", spec=["warning"] | |||
) as mock_logger: | |||
with patch("synapse.util.distributor.logger", spec=["warning"]) as mock_logger: | |||
self.dist.fire("alarm", "Go") | |||
observers[0].assert_called_once_with("Go") | |||
observers[1].assert_called_once_with("Go") | |||
self.assertEquals(mock_logger.warning.call_count, 1) | |||
self.assertIsInstance( | |||
mock_logger.warning.call_args[0][0], str | |||
) | |||
self.assertIsInstance(mock_logger.warning.call_args[0][0], str) | |||
def test_signal_prereg(self): | |||
observer = Mock() | |||
@@ -69,4 +64,5 @@ class DistributorTestCase(unittest.TestCase): | |||
def test_signal_undeclared(self): | |||
def code(): | |||
self.dist.fire("notification") | |||
self.assertRaises(KeyError, code) |
@@ -27,7 +27,6 @@ from . import unittest | |||
@unittest.DEBUG | |||
class DnsTestCase(unittest.TestCase): | |||
@defer.inlineCallbacks | |||
def test_resolve(self): | |||
dns_client_mock = Mock() | |||
@@ -36,14 +35,11 @@ class DnsTestCase(unittest.TestCase): | |||
host_name = "example.com" | |||
answer_srv = dns.RRHeader( | |||
type=dns.SRV, | |||
payload=dns.Record_SRV( | |||
target=host_name, | |||
) | |||
type=dns.SRV, payload=dns.Record_SRV(target=host_name) | |||
) | |||
dns_client_mock.lookupService.return_value = defer.succeed( | |||
([answer_srv], None, None), | |||
([answer_srv], None, None) | |||
) | |||
cache = {} | |||
@@ -68,9 +64,7 @@ class DnsTestCase(unittest.TestCase): | |||
entry = Mock(spec_set=["expires"]) | |||
entry.expires = 0 | |||
cache = { | |||
service_name: [entry] | |||
} | |||
cache = {service_name: [entry]} | |||
servers = yield resolve_service( | |||
service_name, dns_client=dns_client_mock, cache=cache | |||
@@ -93,12 +87,10 @@ class DnsTestCase(unittest.TestCase): | |||
entry = Mock(spec_set=["expires"]) | |||
entry.expires = 999999999 | |||
cache = { | |||
service_name: [entry] | |||
} | |||
cache = {service_name: [entry]} | |||
servers = yield resolve_service( | |||
service_name, dns_client=dns_client_mock, cache=cache, clock=clock, | |||
service_name, dns_client=dns_client_mock, cache=cache, clock=clock | |||
) | |||
self.assertFalse(dns_client_mock.lookupService.called) | |||
@@ -117,9 +109,7 @@ class DnsTestCase(unittest.TestCase): | |||
cache = {} | |||
with self.assertRaises(error.DNSServerError): | |||
yield resolve_service( | |||
service_name, dns_client=dns_client_mock, cache=cache | |||
) | |||
yield resolve_service(service_name, dns_client=dns_client_mock, cache=cache) | |||
@defer.inlineCallbacks | |||
def test_name_error(self): | |||
@@ -35,10 +35,7 @@ class EventAuthTestCase(unittest.TestCase): | |||
} | |||
# creator should be able to send state | |||
event_auth.check( | |||
_random_state_event(creator), auth_events, | |||
do_sig_check=False, | |||
) | |||
event_auth.check(_random_state_event(creator), auth_events, do_sig_check=False) | |||
# joiner should not be able to send state | |||
self.assertRaises( | |||
@@ -61,13 +58,9 @@ class EventAuthTestCase(unittest.TestCase): | |||
auth_events = { | |||
("m.room.create", ""): _create_event(creator), | |||
("m.room.member", creator): _join_event(creator), | |||
("m.room.power_levels", ""): _power_levels_event(creator, { | |||
"state_default": "30", | |||
"users": { | |||
pleb: "29", | |||
king: "30", | |||
}, | |||
}), | |||
("m.room.power_levels", ""): _power_levels_event( | |||
creator, {"state_default": "30", "users": {pleb: "29", king: "30"}} | |||
), | |||
("m.room.member", pleb): _join_event(pleb), | |||
("m.room.member", king): _join_event(king), | |||
} | |||
@@ -82,10 +75,7 @@ class EventAuthTestCase(unittest.TestCase): | |||
), | |||
# king should be able to send state | |||
event_auth.check( | |||
_random_state_event(king), auth_events, | |||
do_sig_check=False, | |||
) | |||
event_auth.check(_random_state_event(king), auth_events, do_sig_check=False) | |||
# helpers for making events | |||
@@ -94,52 +84,54 @@ TEST_ROOM_ID = "!test:room" | |||
def _create_event(user_id): | |||
return FrozenEvent({ | |||
"room_id": TEST_ROOM_ID, | |||
"event_id": _get_event_id(), | |||
"type": "m.room.create", | |||
"sender": user_id, | |||
"content": { | |||
"creator": user_id, | |||
}, | |||
}) | |||
return FrozenEvent( | |||
{ | |||
"room_id": TEST_ROOM_ID, | |||
"event_id": _get_event_id(), | |||
"type": "m.room.create", | |||
"sender": user_id, | |||
"content": {"creator": user_id}, | |||
} | |||
) | |||
def _join_event(user_id): | |||
return FrozenEvent({ | |||
"room_id": TEST_ROOM_ID, | |||
"event_id": _get_event_id(), | |||
"type": "m.room.member", | |||
"sender": user_id, | |||
"state_key": user_id, | |||
"content": { | |||
"membership": "join", | |||
}, | |||
}) | |||
return FrozenEvent( | |||
{ | |||
"room_id": TEST_ROOM_ID, | |||
"event_id": _get_event_id(), | |||
"type": "m.room.member", | |||
"sender": user_id, | |||
"state_key": user_id, | |||
"content": {"membership": "join"}, | |||
} | |||
) | |||
def _power_levels_event(sender, content): | |||
return FrozenEvent({ | |||
"room_id": TEST_ROOM_ID, | |||
"event_id": _get_event_id(), | |||
"type": "m.room.power_levels", | |||
"sender": sender, | |||
"state_key": "", | |||
"content": content, | |||
}) | |||
return FrozenEvent( | |||
{ | |||
"room_id": TEST_ROOM_ID, | |||
"event_id": _get_event_id(), | |||
"type": "m.room.power_levels", | |||
"sender": sender, | |||
"state_key": "", | |||
"content": content, | |||
} | |||
) | |||
def _random_state_event(sender): | |||
return FrozenEvent({ | |||
"room_id": TEST_ROOM_ID, | |||
"event_id": _get_event_id(), | |||
"type": "test.state", | |||
"sender": sender, | |||
"state_key": "", | |||
"content": { | |||
"membership": "join", | |||
}, | |||
}) | |||
return FrozenEvent( | |||
{ | |||
"room_id": TEST_ROOM_ID, | |||
"event_id": _get_event_id(), | |||
"type": "test.state", | |||
"sender": sender, | |||
"state_key": "", | |||
"content": {"membership": "join"}, | |||
} | |||
) | |||
event_count = 0 | |||
@@ -149,4 +141,4 @@ def _get_event_id(): | |||
global event_count | |||
c = event_count | |||
event_count += 1 | |||
return "!%i:example.com" % (c, ) | |||
return "!%i:example.com" % (c,) |
@@ -22,7 +22,6 @@ from . import unittest | |||
class PreviewTestCase(unittest.TestCase): | |||
def test_long_summarize(self): | |||
example_paras = [ | |||
u"""Tromsø (Norwegian pronunciation: [ˈtrʊmsœ] ( listen); Northern Sami: | |||
@@ -32,7 +31,6 @@ class PreviewTestCase(unittest.TestCase): | |||
alternative spellings of the city.Tromsø is considered the northernmost | |||
city in the world with a population above 50,000. The most populous town | |||
north of it is Alta, Norway, with a population of 14,272 (2013).""", | |||
u"""Tromsø lies in Northern Norway. The municipality has a population of | |||
(2015) 72,066, but with an annual influx of students it has over 75,000 | |||
most of the year. It is the largest urban area in Northern Norway and the | |||
@@ -46,7 +44,6 @@ class PreviewTestCase(unittest.TestCase): | |||
Sandnessund Bridge. Tromsø Airport connects the city to many destinations | |||
in Europe. The city is warmer than most other places located on the same | |||
latitude, due to the warming effect of the Gulf Stream.""", | |||
u"""The city centre of Tromsø contains the highest number of old wooden | |||
houses in Northern Norway, the oldest house dating from 1789. The Arctic | |||
Cathedral, a modern church from 1965, is probably the most famous landmark | |||
@@ -67,7 +64,7 @@ class PreviewTestCase(unittest.TestCase): | |||
u" the city of Tromsø. Outside of Norway, Tromso and Tromsö are" | |||
u" alternative spellings of the city.Tromsø is considered the northernmost" | |||
u" city in the world with a population above 50,000. The most populous town" | |||
u" north of it is Alta, Norway, with a population of 14,272 (2013)." | |||
u" north of it is Alta, Norway, with a population of 14,272 (2013).", | |||
) | |||
desc = summarize_paragraphs(example_paras[1:], min_size=200, max_size=500) | |||
@@ -80,7 +77,7 @@ class PreviewTestCase(unittest.TestCase): | |||
u" third largest north of the Arctic Circle (following Murmansk and Norilsk)." | |||
u" Most of Tromsø, including the city centre, is located on the island of" | |||
u" Tromsøya, 350 kilometres (217 mi) north of the Arctic Circle. In 2012," | |||
u" Tromsøya had a population of 36,088. Substantial parts of the urban…" | |||
u" Tromsøya had a population of 36,088. Substantial parts of the urban…", | |||
) | |||
def test_short_summarize(self): | |||
@@ -88,11 +85,9 @@ class PreviewTestCase(unittest.TestCase): | |||
u"Tromsø (Norwegian pronunciation: [ˈtrʊmsœ] ( listen); Northern Sami:" | |||
u" Romsa; Finnish: Tromssa[2] Kven: Tromssa) is a city and municipality in" | |||
u" Troms county, Norway.", | |||
u"Tromsø lies in Northern Norway. The municipality has a population of" | |||
u" (2015) 72,066, but with an annual influx of students it has over 75,000" | |||
u" most of the year.", | |||
u"The city centre of Tromsø contains the highest number of old wooden" | |||
u" houses in Northern Norway, the oldest house dating from 1789. The Arctic" | |||
u" Cathedral, a modern church from 1965, is probably the most famous landmark" | |||
@@ -109,7 +104,7 @@ class PreviewTestCase(unittest.TestCase): | |||
u"\n" | |||
u"Tromsø lies in Northern Norway. The municipality has a population of" | |||
u" (2015) 72,066, but with an annual influx of students it has over 75,000" | |||
u" most of the year." | |||
u" most of the year.", | |||
) | |||
def test_small_then_large_summarize(self): | |||
@@ -117,7 +112,6 @@ class PreviewTestCase(unittest.TestCase): | |||
u"Tromsø (Norwegian pronunciation: [ˈtrʊmsœ] ( listen); Northern Sami:" | |||
u" Romsa; Finnish: Tromssa[2] Kven: Tromssa) is a city and municipality in" | |||
u" Troms county, Norway.", | |||
u"Tromsø lies in Northern Norway. The municipality has a population of" | |||
u" (2015) 72,066, but with an annual influx of students it has over 75,000" | |||
u" most of the year." | |||
@@ -138,7 +132,7 @@ class PreviewTestCase(unittest.TestCase): | |||
u" (2015) 72,066, but with an annual influx of students it has over 75,000" | |||
u" most of the year. The city centre of Tromsø contains the highest number" | |||
u" of old wooden houses in Northern Norway, the oldest house dating from" | |||
u" 1789. The Arctic Cathedral, a modern church from…" | |||
u" 1789. The Arctic Cathedral, a modern church from…", | |||
) | |||
@@ -155,10 +149,7 @@ class PreviewUrlTestCase(unittest.TestCase): | |||
og = decode_and_calc_og(html, "http://example.com/test.html") | |||
self.assertEquals(og, { | |||
u"og:title": u"Foo", | |||
u"og:description": u"Some text." | |||
}) | |||
self.assertEquals(og, {u"og:title": u"Foo", u"og:description": u"Some text."}) | |||
def test_comment(self): | |||
html = u""" | |||
@@ -173,10 +164,7 @@ class PreviewUrlTestCase(unittest.TestCase): | |||
og = decode_and_calc_og(html, "http://example.com/test.html") | |||
self.assertEquals(og, { | |||
u"og:title": u"Foo", | |||
u"og:description": u"Some text." | |||
}) | |||
self.assertEquals(og, {u"og:title": u"Foo", u"og:description": u"Some text."}) | |||
def test_comment2(self): | |||
html = u""" | |||
@@ -194,10 +182,13 @@ class PreviewUrlTestCase(unittest.TestCase): | |||
og = decode_and_calc_og(html, "http://example.com/test.html") | |||
self.assertEquals(og, { | |||
u"og:title": u"Foo", | |||
u"og:description": u"Some text.\n\nSome more text.\n\nText\n\nMore text" | |||
}) | |||
self.assertEquals( | |||
og, | |||
{ | |||
u"og:title": u"Foo", | |||
u"og:description": u"Some text.\n\nSome more text.\n\nText\n\nMore text", | |||
}, | |||
) | |||
def test_script(self): | |||
html = u""" | |||
@@ -212,10 +203,7 @@ class PreviewUrlTestCase(unittest.TestCase): | |||
og = decode_and_calc_og(html, "http://example.com/test.html") | |||
self.assertEquals(og, { | |||
u"og:title": u"Foo", | |||
u"og:description": u"Some text." | |||
}) | |||
self.assertEquals(og, {u"og:title": u"Foo", u"og:description": u"Some text."}) | |||
def test_missing_title(self): | |||
html = u""" | |||
@@ -228,10 +216,7 @@ class PreviewUrlTestCase(unittest.TestCase): | |||
og = decode_and_calc_og(html, "http://example.com/test.html") | |||
self.assertEquals(og, { | |||
u"og:title": None, | |||
u"og:description": u"Some text." | |||
}) | |||
self.assertEquals(og, {u"og:title": None, u"og:description": u"Some text."}) | |||
def test_h1_as_title(self): | |||
html = u""" | |||
@@ -245,10 +230,7 @@ class PreviewUrlTestCase(unittest.TestCase): | |||
og = decode_and_calc_og(html, "http://example.com/test.html") | |||
self.assertEquals(og, { | |||
u"og:title": u"Title", | |||
u"og:description": u"Some text." | |||
}) | |||
self.assertEquals(og, {u"og:title": u"Title", u"og:description": u"Some text."}) | |||
def test_missing_title_and_broken_h1(self): | |||
html = u""" | |||
@@ -262,7 +244,4 @@ class PreviewUrlTestCase(unittest.TestCase): | |||
og = decode_and_calc_og(html, "http://example.com/test.html") | |||
self.assertEquals(og, { | |||
u"og:title": None, | |||
u"og:description": u"Some text." | |||
}) | |||
self.assertEquals(og, {u"og:title": None, u"og:description": u"Some text."}) |
@@ -29,8 +29,15 @@ from .utils import MockClock | |||
_next_event_id = 1000 | |||
def create_event(name=None, type=None, state_key=None, depth=2, event_id=None, | |||
prev_events=[], **kwargs): | |||
def create_event( | |||
name=None, | |||
type=None, | |||
state_key=None, | |||
depth=2, | |||
event_id=None, | |||
prev_events=[], | |||
**kwargs | |||
): | |||
global _next_event_id | |||
if not event_id: | |||
@@ -39,9 +46,9 @@ def create_event(name=None, type=None, state_key=None, depth=2, event_id=None, | |||
if not name: | |||
if state_key is not None: | |||
name = "<%s-%s, %s>" % (type, state_key, event_id,) | |||
name = "<%s-%s, %s>" % (type, state_key, event_id) | |||
else: | |||
name = "<%s, %s>" % (type, event_id,) | |||
name = "<%s, %s>" % (type, event_id) | |||
d = { | |||
"event_id": event_id, | |||
@@ -80,8 +87,9 @@ class StateGroupStore(object): | |||
return defer.succeed(groups) | |||
def store_state_group(self, event_id, room_id, prev_group, delta_ids, | |||
current_state_ids): | |||
def store_state_group( | |||
self, event_id, room_id, prev_group, delta_ids, current_state_ids | |||
): | |||
state_group = self._next_group | |||
self._next_group += 1 | |||
@@ -91,7 +99,8 @@ class StateGroupStore(object): | |||
def get_events(self, event_ids, **kwargs): | |||
return { | |||
e_id: self._event_id_to_event[e_id] for e_id in event_ids | |||
e_id: self._event_id_to_event[e_id] | |||
for e_id in event_ids | |||
if e_id in self._event_id_to_event | |||
} | |||
@@ -129,9 +138,7 @@ class Graph(object): | |||
prev_events = [] | |||
events[event_id] = create_event( | |||
event_id=event_id, | |||
prev_events=prev_events, | |||
**fields | |||
event_id=event_id, prev_events=prev_events, **fields | |||
) | |||
self._leaves = clobbered | |||
@@ -147,10 +154,15 @@ class Graph(object): | |||
class StateTestCase(unittest.TestCase): | |||
def setUp(self): | |||
self.store = StateGroupStore() | |||
hs = Mock(spec_set=[ | |||
"get_datastore", "get_auth", "get_state_handler", "get_clock", | |||
"get_state_resolution_handler", | |||
]) | |||
hs = Mock( | |||
spec_set=[ | |||
"get_datastore", | |||
"get_auth", | |||
"get_state_handler", | |||
"get_clock", | |||
"get_state_resolution_handler", | |||
] | |||
) | |||
hs.get_datastore.return_value = self.store | |||
hs.get_state_handler.return_value = None | |||
hs.get_clock.return_value = MockClock() | |||
@@ -164,35 +176,13 @@ class StateTestCase(unittest.TestCase): | |||
def test_branch_no_conflict(self): | |||
graph = Graph( | |||
nodes={ | |||
"START": DictObj( | |||
type=EventTypes.Create, | |||
state_key="", | |||
depth=1, | |||
), | |||
"A": DictObj( | |||
type=EventTypes.Message, | |||
depth=2, | |||
), | |||
"B": DictObj( | |||
type=EventTypes.Message, | |||
depth=3, | |||
), | |||
"C": DictObj( | |||
type=EventTypes.Name, | |||
state_key="", | |||
depth=3, | |||
), | |||
"D": DictObj( | |||
type=EventTypes.Message, | |||
depth=4, | |||
), | |||
"START": DictObj(type=EventTypes.Create, state_key="", depth=1), | |||
"A": DictObj(type=EventTypes.Message, depth=2), | |||
"B": DictObj(type=EventTypes.Message, depth=3), | |||
"C": DictObj(type=EventTypes.Name, state_key="", depth=3), | |||
"D": DictObj(type=EventTypes.Message, depth=4), | |||
}, | |||
edges={ | |||
"A": ["START"], | |||
"B": ["A"], | |||
"C": ["A"], | |||
"D": ["B", "C"] | |||
} | |||
edges={"A": ["START"], "B": ["A"], "C": ["A"], "D": ["B", "C"]}, | |||
) | |||
self.store.register_events(graph.walk()) | |||
@@ -224,27 +214,11 @@ class StateTestCase(unittest.TestCase): | |||
membership=Membership.JOIN, | |||
depth=2, | |||
), | |||
"B": DictObj( | |||
type=EventTypes.Name, | |||
state_key="", | |||
depth=3, | |||
), | |||
"C": DictObj( | |||
type=EventTypes.Name, | |||
state_key="", | |||
depth=4, | |||
), | |||
"D": DictObj( | |||
type=EventTypes.Message, | |||
depth=5, | |||
), | |||
"B": DictObj(type=EventTypes.Name, state_key="", depth=3), | |||
"C": DictObj(type=EventTypes.Name, state_key="", depth=4), | |||
"D": DictObj(type=EventTypes.Message, depth=5), | |||
}, | |||
edges={ | |||
"A": ["START"], | |||
"B": ["A"], | |||
"C": ["A"], | |||
"D": ["B", "C"] | |||
} | |||
edges={"A": ["START"], "B": ["A"], "C": ["A"], "D": ["B", "C"]}, | |||
) | |||
self.store.register_events(graph.walk()) | |||
@@ -259,8 +233,7 @@ class StateTestCase(unittest.TestCase): | |||
prev_state_ids = yield context_store["D"].get_prev_state_ids(self.store) | |||
self.assertSetEqual( | |||
{"START", "A", "C"}, | |||
{e_id for e_id in prev_state_ids.values()} | |||
{"START", "A", "C"}, {e_id for e_id in prev_state_ids.values()} | |||
) | |||
@defer.inlineCallbacks | |||
@@ -280,11 +253,7 @@ class StateTestCase(unittest.TestCase): | |||
membership=Membership.JOIN, | |||
depth=2, | |||
), | |||
"B": DictObj( | |||
type=EventTypes.Name, | |||
state_key="", | |||
depth=3, | |||
), | |||
"B": DictObj(type=EventTypes.Name, state_key="", depth=3), | |||
"C": DictObj( | |||
type=EventTypes.Member, | |||
state_key="@user_id_2:example.com", | |||
@@ -298,18 +267,9 @@ class StateTestCase(unittest.TestCase): | |||
depth=4, | |||
sender="@user_id_2:example.com", | |||
), | |||
"E": DictObj( | |||
type=EventTypes.Message, | |||
depth=5, | |||
), | |||
"E": DictObj(type=EventTypes.Message, depth=5), | |||
}, | |||
edges={ | |||
"A": ["START"], | |||
"B": ["A"], | |||
"C": ["B"], | |||
"D": ["B"], | |||
"E": ["C", "D"] | |||
} | |||
edges={"A": ["START"], "B": ["A"], "C": ["B"], "D": ["B"], "E": ["C", "D"]}, | |||
) | |||
self.store.register_events(graph.walk()) | |||
@@ -324,8 +284,7 @@ class StateTestCase(unittest.TestCase): | |||
prev_state_ids = yield context_store["E"].get_prev_state_ids(self.store) | |||
self.assertSetEqual( | |||
{"START", "A", "B", "C"}, | |||
{e for e in prev_state_ids.values()} | |||
{"START", "A", "B", "C"}, {e for e in prev_state_ids.values()} | |||
) | |||
@defer.inlineCallbacks | |||
@@ -357,30 +316,17 @@ class StateTestCase(unittest.TestCase): | |||
state_key="", | |||
content={ | |||
"events": {"m.room.name": 50}, | |||
"users": {userid1: 100, | |||
userid2: 60}, | |||
"users": {userid1: 100, userid2: 60}, | |||
}, | |||
), | |||
"A5": DictObj( | |||
type=EventTypes.Name, | |||
state_key="", | |||
), | |||
"A5": DictObj(type=EventTypes.Name, state_key=""), | |||
"B": DictObj( | |||
type=EventTypes.PowerLevels, | |||
state_key="", | |||
content={ | |||
"events": {"m.room.name": 50}, | |||
"users": {userid2: 30}, | |||
}, | |||
), | |||
"C": DictObj( | |||
type=EventTypes.Name, | |||
state_key="", | |||
sender=userid2, | |||
), | |||
"D": DictObj( | |||
type=EventTypes.Message, | |||
content={"events": {"m.room.name": 50}, "users": {userid2: 30}}, | |||
), | |||
"C": DictObj(type=EventTypes.Name, state_key="", sender=userid2), | |||
"D": DictObj(type=EventTypes.Message), | |||
} | |||
edges = { | |||
"A2": ["A1"], | |||
@@ -389,7 +335,7 @@ class StateTestCase(unittest.TestCase): | |||
"A5": ["A4"], | |||
"B": ["A5"], | |||
"C": ["A5"], | |||
"D": ["B", "C"] | |||
"D": ["B", "C"], | |||
} | |||
self._add_depths(nodes, edges) | |||
graph = Graph(nodes, edges) | |||
@@ -406,8 +352,7 @@ class StateTestCase(unittest.TestCase): | |||
prev_state_ids = yield context_store["D"].get_prev_state_ids(self.store) | |||
self.assertSetEqual( | |||
{"A1", "A2", "A3", "A5", "B"}, | |||
{e for e in prev_state_ids.values()} | |||
{"A1", "A2", "A3", "A5", "B"}, {e for e in prev_state_ids.values()} | |||
) | |||
def _add_depths(self, nodes, edges): | |||
@@ -432,9 +377,7 @@ class StateTestCase(unittest.TestCase): | |||
create_event(type="test2", state_key=""), | |||
] | |||
context = yield self.state.compute_event_context( | |||
event, old_state=old_state | |||
) | |||
context = yield self.state.compute_event_context(event, old_state=old_state) | |||
current_state_ids = yield context.get_current_state_ids(self.store) | |||
@@ -454,9 +397,7 @@ class StateTestCase(unittest.TestCase): | |||
create_event(type="test2", state_key=""), | |||
] | |||
context = yield self.state.compute_event_context( | |||
event, old_state=old_state | |||
) | |||
context = yield self.state.compute_event_context(event, old_state=old_state) | |||
prev_state_ids = yield context.get_prev_state_ids(self.store) | |||
@@ -468,8 +409,7 @@ class StateTestCase(unittest.TestCase): | |||
def test_trivial_annotate_message(self): | |||
prev_event_id = "prev_event_id" | |||
event = create_event( | |||
type="test_message", name="event2", | |||
prev_events=[(prev_event_id, {})], | |||
type="test_message", name="event2", prev_events=[(prev_event_id, {})] | |||
) | |||
old_state = [ | |||
@@ -479,7 +419,10 @@ class StateTestCase(unittest.TestCase): | |||
] | |||
group_name = self.store.store_state_group( | |||
prev_event_id, event.room_id, None, None, | |||
prev_event_id, | |||
event.room_id, | |||
None, | |||
None, | |||
{(e.type, e.state_key): e.event_id for e in old_state}, | |||
) | |||
self.store.register_event_id_state_group(prev_event_id, group_name) | |||
@@ -489,8 +432,7 @@ class StateTestCase(unittest.TestCase): | |||
current_state_ids = yield context.get_current_state_ids(self.store) | |||
self.assertEqual( | |||
set([e.event_id for e in old_state]), | |||
set(current_state_ids.values()) | |||
set([e.event_id for e in old_state]), set(current_state_ids.values()) | |||
) | |||
self.assertEqual(group_name, context.state_group) | |||
@@ -499,8 +441,7 @@ class StateTestCase(unittest.TestCase): | |||
def test_trivial_annotate_state(self): | |||
prev_event_id = "prev_event_id" | |||
event = create_event( | |||
type="state", state_key="", name="event2", | |||
prev_events=[(prev_event_id, {})], | |||
type="state", state_key="", name="event2", prev_events=[(prev_event_id, {})] | |||
) | |||
old_state = [ | |||
@@ -510,7 +451,10 @@ class StateTestCase(unittest.TestCase): | |||
] | |||
group_name = self.store.store_state_group( | |||
prev_event_id, event.room_id, None, None, | |||
prev_event_id, | |||
event.room_id, | |||
None, | |||
None, | |||
{(e.type, e.state_key): e.event_id for e in old_state}, | |||
) | |||
self.store.register_event_id_state_group(prev_event_id, group_name) | |||
@@ -520,8 +464,7 @@ class StateTestCase(unittest.TestCase): | |||
prev_state_ids = yield context.get_prev_state_ids(self.store) | |||
self.assertEqual( | |||
set([e.event_id for e in old_state]), | |||
set(prev_state_ids.values()) | |||
set([e.event_id for e in old_state]), set(prev_state_ids.values()) | |||
) | |||
self.assertIsNotNone(context.state_group) | |||
@@ -531,13 +474,12 @@ class StateTestCase(unittest.TestCase): | |||
prev_event_id1 = "event_id1" | |||
prev_event_id2 = "event_id2" | |||
event = create_event( | |||
type="test_message", name="event3", | |||
type="test_message", | |||
name="event3", | |||
prev_events=[(prev_event_id1, {}), (prev_event_id2, {})], | |||
) | |||
creation = create_event( | |||
type=EventTypes.Create, state_key="" | |||
) | |||
creation = create_event(type=EventTypes.Create, state_key="") | |||
old_state_1 = [ | |||
creation, | |||
@@ -557,7 +499,7 @@ class StateTestCase(unittest.TestCase): | |||
self.store.register_events(old_state_2) | |||
context = yield self._get_context( | |||
event, prev_event_id1, old_state_1, prev_event_id2, old_state_2, | |||
event, prev_event_id1, old_state_1, prev_event_id2, old_state_2 | |||
) | |||
current_state_ids = yield context.get_current_state_ids(self.store) | |||
@@ -571,13 +513,13 @@ class StateTestCase(unittest.TestCase): | |||
prev_event_id1 = "event_id1" | |||
prev_event_id2 = "event_id2" | |||
event = create_event( | |||
type="test4", state_key="", name="event", | |||
type="test4", | |||
state_key="", | |||
name="event", | |||
prev_events=[(prev_event_id1, {}), (prev_event_id2, {})], | |||
) | |||
creation = create_event( | |||
type=EventTypes.Create, state_key="" | |||
) | |||
creation = create_event(type=EventTypes.Create, state_key="") | |||
old_state_1 = [ | |||
creation, | |||
@@ -599,7 +541,7 @@ class StateTestCase(unittest.TestCase): | |||
self.store.get_events = store.get_events | |||
context = yield self._get_context( | |||
event, prev_event_id1, old_state_1, prev_event_id2, old_state_2, | |||
event, prev_event_id1, old_state_1, prev_event_id2, old_state_2 | |||
) | |||
current_state_ids = yield context.get_current_state_ids(self.store) | |||
@@ -613,29 +555,25 @@ class StateTestCase(unittest.TestCase): | |||
prev_event_id1 = "event_id1" | |||
prev_event_id2 = "event_id2" | |||
event = create_event( | |||
type="test4", name="event", | |||
type="test4", | |||
name="event", | |||
prev_events=[(prev_event_id1, {}), (prev_event_id2, {})], | |||
) | |||
member_event = create_event( | |||
type=EventTypes.Member, | |||
state_key="@user_id:example.com", | |||
content={ | |||
"membership": Membership.JOIN, | |||
} | |||
content={"membership": Membership.JOIN}, | |||
) | |||
power_levels = create_event( | |||
type=EventTypes.PowerLevels, state_key="", | |||
content={"users": { | |||
"@foo:bar": "100", | |||
"@user_id:example.com": "100", | |||
}} | |||
type=EventTypes.PowerLevels, | |||
state_key="", | |||
content={"users": {"@foo:bar": "100", "@user_id:example.com": "100"}}, | |||
) | |||
creation = create_event( | |||
type=EventTypes.Create, state_key="", | |||
content={"creator": "@foo:bar"} | |||
type=EventTypes.Create, state_key="", content={"creator": "@foo:bar"} | |||
) | |||
old_state_1 = [ | |||
@@ -658,14 +596,12 @@ class StateTestCase(unittest.TestCase): | |||
self.store.get_events = store.get_events | |||
context = yield self._get_context( | |||
event, prev_event_id1, old_state_1, prev_event_id2, old_state_2, | |||
event, prev_event_id1, old_state_1, prev_event_id2, old_state_2 | |||
) | |||
current_state_ids = yield context.get_current_state_ids(self.store) | |||
self.assertEqual( | |||
old_state_2[3].event_id, current_state_ids[("test1", "1")] | |||
) | |||
self.assertEqual(old_state_2[3].event_id, current_state_ids[("test1", "1")]) | |||
# Reverse the depth to make sure we are actually using the depths | |||
# during state resolution. | |||
@@ -688,25 +624,30 @@ class StateTestCase(unittest.TestCase): | |||
store.register_events(old_state_2) | |||
context = yield self._get_context( | |||
event, prev_event_id1, old_state_1, prev_event_id2, old_state_2, | |||
event, prev_event_id1, old_state_1, prev_event_id2, old_state_2 | |||
) | |||
current_state_ids = yield context.get_current_state_ids(self.store) | |||
self.assertEqual( | |||
old_state_1[3].event_id, current_state_ids[("test1", "1")] | |||
) | |||
self.assertEqual(old_state_1[3].event_id, current_state_ids[("test1", "1")]) | |||
def _get_context(self, event, prev_event_id_1, old_state_1, prev_event_id_2, | |||
old_state_2): | |||
def _get_context( | |||
self, event, prev_event_id_1, old_state_1, prev_event_id_2, old_state_2 | |||
): | |||
sg1 = self.store.store_state_group( | |||
prev_event_id_1, event.room_id, None, None, | |||
prev_event_id_1, | |||
event.room_id, | |||
None, | |||
None, | |||
{(e.type, e.state_key): e.event_id for e in old_state_1}, | |||
) | |||
self.store.register_event_id_state_group(prev_event_id_1, sg1) | |||
sg2 = self.store.store_state_group( | |||
prev_event_id_2, event.room_id, None, None, | |||
prev_event_id_2, | |||
event.room_id, | |||
None, | |||
None, | |||
{(e.type, e.state_key): e.event_id for e in old_state_2}, | |||
) | |||
self.store.register_event_id_state_group(prev_event_id_2, sg2) | |||
@@ -18,7 +18,6 @@ from tests.utils import MockClock | |||
class MockClockTestCase(unittest.TestCase): | |||
def setUp(self): | |||
self.clock = MockClock() | |||
@@ -34,10 +33,12 @@ class MockClockTestCase(unittest.TestCase): | |||
def _cb0(): | |||
invoked[0] = 1 | |||
self.clock.call_later(10, _cb0) | |||
def _cb1(): | |||
invoked[1] = 1 | |||
self.clock.call_later(20, _cb1) | |||
self.assertFalse(invoked[0]) | |||
@@ -56,10 +57,12 @@ class MockClockTestCase(unittest.TestCase): | |||
def _cb0(): | |||
invoked[0] = 1 | |||
t0 = self.clock.call_later(10, _cb0) | |||
def _cb1(): | |||
invoked[1] = 1 | |||
self.clock.call_later(20, _cb1) | |||
self.clock.cancel_call_later(t0) | |||
@@ -69,10 +69,7 @@ class GroupIDTestCase(unittest.TestCase): | |||
self.assertEqual("my.domain", group_id.domain) | |||
def test_validate(self): | |||
bad_ids = [ | |||
"$badsigil:domain", | |||
"+:empty", | |||
] + [ | |||
bad_ids = ["$badsigil:domain", "+:empty"] + [ | |||
"+group" + c + ":domain" for c in "A%?æ£" | |||
] | |||
for id_string in bad_ids: | |||
@@ -54,14 +54,12 @@ class FilterEventsForServerTestCase(tests.unittest.TestCase): | |||
events_to_filter = [] | |||
for i in range(0, 10): | |||
user = "@user%i:%s" % ( | |||
i, "test_server" if i == 5 else "other_server" | |||
) | |||
user = "@user%i:%s" % (i, "test_server" if i == 5 else "other_server") | |||
evt = yield self.inject_room_member(user, extra_content={"a": "b"}) | |||
events_to_filter.append(evt) | |||
filtered = yield filter_events_for_server( | |||
self.store, "test_server", events_to_filter, | |||
self.store, "test_server", events_to_filter | |||
) | |||
# the result should be 5 redacted events, and 5 unredacted events. | |||
@@ -100,19 +98,21 @@ class FilterEventsForServerTestCase(tests.unittest.TestCase): | |||
# ... and the filtering happens. | |||
filtered = yield filter_events_for_server( | |||
self.store, "test_server", events_to_filter, | |||
self.store, "test_server", events_to_filter | |||
) | |||
for i in range(0, len(events_to_filter)): | |||
self.assertEqual( | |||
events_to_filter[i].event_id, filtered[i].event_id, | |||
"Unexpected event at result position %i" % (i, ) | |||
events_to_filter[i].event_id, | |||
filtered[i].event_id, | |||
"Unexpected event at result position %i" % (i,), | |||
) | |||
for i in (0, 3): | |||
self.assertEqual( | |||
events_to_filter[i].content["body"], filtered[i].content["body"], | |||
"Unexpected event content at result position %i" % (i,) | |||
events_to_filter[i].content["body"], | |||
filtered[i].content["body"], | |||
"Unexpected event content at result position %i" % (i,), | |||
) | |||
for i in (1, 4): | |||
@@ -121,13 +121,15 @@ class FilterEventsForServerTestCase(tests.unittest.TestCase): | |||
@defer.inlineCallbacks | |||
def inject_visibility(self, user_id, visibility): | |||
content = {"history_visibility": visibility} | |||
builder = self.event_builder_factory.new({ | |||
"type": "m.room.history_visibility", | |||
"sender": user_id, | |||
"state_key": "", | |||
"room_id": TEST_ROOM_ID, | |||
"content": content, | |||
}) | |||
builder = self.event_builder_factory.new( | |||
{ | |||
"type": "m.room.history_visibility", | |||
"sender": user_id, | |||
"state_key": "", | |||
"room_id": TEST_ROOM_ID, | |||
"content": content, | |||
} | |||
) | |||
event, context = yield self.event_creation_handler.create_new_client_event( | |||
builder | |||
@@ -139,13 +141,15 @@ class FilterEventsForServerTestCase(tests.unittest.TestCase): | |||
def inject_room_member(self, user_id, membership="join", extra_content={}): | |||
content = {"membership": membership} | |||
content.update(extra_content) | |||
builder = self.event_builder_factory.new({ | |||
"type": "m.room.member", | |||
"sender": user_id, | |||
"state_key": user_id, | |||
"room_id": TEST_ROOM_ID, | |||
"content": content, | |||
}) | |||
builder = self.event_builder_factory.new( | |||
{ | |||
"type": "m.room.member", | |||
"sender": user_id, | |||
"state_key": user_id, | |||
"room_id": TEST_ROOM_ID, | |||
"content": content, | |||
} | |||
) | |||
event, context = yield self.event_creation_handler.create_new_client_event( | |||
builder | |||
@@ -158,12 +162,14 @@ class FilterEventsForServerTestCase(tests.unittest.TestCase): | |||
def inject_message(self, user_id, content=None): | |||
if content is None: | |||
content = {"body": "testytest"} | |||
builder = self.event_builder_factory.new({ | |||
"type": "m.room.message", | |||
"sender": user_id, | |||
"room_id": TEST_ROOM_ID, | |||
"content": content, | |||
}) | |||
builder = self.event_builder_factory.new( | |||
{ | |||
"type": "m.room.message", | |||
"sender": user_id, | |||
"room_id": TEST_ROOM_ID, | |||
"content": content, | |||
} | |||
) | |||
event, context = yield self.event_creation_handler.create_new_client_event( | |||
builder | |||
@@ -192,56 +198,54 @@ class FilterEventsForServerTestCase(tests.unittest.TestCase): | |||
# history_visibility event. | |||
room_state = [] | |||
history_visibility_evt = FrozenEvent({ | |||
"event_id": "$history_vis", | |||
"type": "m.room.history_visibility", | |||
"sender": "@resident_user_0:test.com", | |||
"state_key": "", | |||
"room_id": TEST_ROOM_ID, | |||
"content": {"history_visibility": "joined"}, | |||
}) | |||
history_visibility_evt = FrozenEvent( | |||
{ | |||
"event_id": "$history_vis", | |||
"type": "m.room.history_visibility", | |||
"sender": "@resident_user_0:test.com", | |||
"state_key": "", | |||
"room_id": TEST_ROOM_ID, | |||
"content": {"history_visibility": "joined"}, | |||
} | |||
) | |||
room_state.append(history_visibility_evt) | |||
test_store.add_event(history_visibility_evt) | |||
for i in range(0, 100000): | |||
user = "@resident_user_%i:test.com" % (i, ) | |||
evt = FrozenEvent({ | |||
"event_id": "$res_event_%i" % (i, ), | |||
"type": "m.room.member", | |||
"state_key": user, | |||
"sender": user, | |||
"room_id": TEST_ROOM_ID, | |||
"content": { | |||
"membership": "join", | |||
"extra": "zzz," | |||
}, | |||
}) | |||
user = "@resident_user_%i:test.com" % (i,) | |||
evt = FrozenEvent( | |||
{ | |||
"event_id": "$res_event_%i" % (i,), | |||
"type": "m.room.member", | |||
"state_key": user, | |||
"sender": user, | |||
"room_id": TEST_ROOM_ID, | |||
"content": {"membership": "join", "extra": "zzz,"}, | |||
} | |||
) | |||
room_state.append(evt) | |||
test_store.add_event(evt) | |||
events_to_filter = [] | |||
for i in range(0, 10): | |||
user = "@user%i:%s" % ( | |||
i, "test_server" if i == 5 else "other_server" | |||
user = "@user%i:%s" % (i, "test_server" if i == 5 else "other_server") | |||
evt = FrozenEvent( | |||
{ | |||
"event_id": "$evt%i" % (i,), | |||
"type": "m.room.member", | |||
"state_key": user, | |||
"sender": user, | |||
"room_id": TEST_ROOM_ID, | |||
"content": {"membership": "join", "extra": "zzz"}, | |||
} | |||
) | |||
evt = FrozenEvent({ | |||
"event_id": "$evt%i" % (i, ), | |||
"type": "m.room.member", | |||
"state_key": user, | |||
"sender": user, | |||
"room_id": TEST_ROOM_ID, | |||
"content": { | |||
"membership": "join", | |||
"extra": "zzz", | |||
}, | |||
}) | |||
events_to_filter.append(evt) | |||
room_state.append(evt) | |||
test_store.add_event(evt) | |||
test_store.set_state_ids_for_event(evt, { | |||
(e.type, e.state_key): e.event_id for e in room_state | |||
}) | |||
test_store.set_state_ids_for_event( | |||
evt, {(e.type, e.state_key): e.event_id for e in room_state} | |||
) | |||
pr = cProfile.Profile() | |||
pr.enable() | |||
@@ -249,7 +253,7 @@ class FilterEventsForServerTestCase(tests.unittest.TestCase): | |||
logger.info("Starting filtering") | |||
start = time.time() | |||
filtered = yield filter_events_for_server( | |||
test_store, "test_server", events_to_filter, | |||
test_store, "test_server", events_to_filter | |||
) | |||
logger.info("Filtering took %f seconds", time.time() - start) | |||
@@ -275,6 +279,7 @@ class _TestStore(object): | |||
filter_events_for_server | |||
""" | |||
def __init__(self): | |||
# data for get_events: a map from event_id to event | |||
self.events = {} | |||
@@ -298,8 +303,8 @@ class _TestStore(object): | |||
continue | |||
if type != "m.room.member" or state_key is not None: | |||
raise RuntimeError( | |||
"Unimplemented: get_state_ids with type (%s, %s)" % | |||
(type, state_key), | |||
"Unimplemented: get_state_ids with type (%s, %s)" | |||
% (type, state_key) | |||
) | |||
include_memberships = True | |||
@@ -316,9 +321,7 @@ class _TestStore(object): | |||
return succeed(res) | |||
def get_events(self, events): | |||
return succeed({ | |||
event_id: self.events[event_id] for event_id in events | |||
}) | |||
return succeed({event_id: self.events[event_id] for event_id in events}) | |||
def are_users_erased(self, users): | |||
return succeed({u: False for u in users}) |
@@ -56,6 +56,7 @@ def around(target): | |||
def method_name(orig, *args, **kwargs): | |||
return orig(*args, **kwargs) | |||
""" | |||
def _around(code): | |||
name = code.__name__ | |||
orig = getattr(target, name) | |||
@@ -89,6 +90,7 @@ class TestCase(unittest.TestCase): | |||
old_level = logging.getLogger().level | |||
if old_level != level: | |||
@around(self) | |||
def tearDown(orig): | |||
ret = orig() | |||
@@ -117,8 +119,9 @@ class TestCase(unittest.TestCase): | |||
actual (dict): The test result. Extra keys will not be checked. | |||
""" | |||
for key in required: | |||
self.assertEquals(required[key], actual[key], | |||
msg="%s mismatch. %s" % (key, actual)) | |||
self.assertEquals( | |||
required[key], actual[key], msg="%s mismatch. %s" % (key, actual) | |||
) | |||
def DEBUG(target): | |||
@@ -67,12 +67,8 @@ class CacheTestCase(unittest.TestCase): | |||
self.assertIsNone(cache.get("key2", None)) | |||
# both callbacks should have been callbacked | |||
self.assertTrue( | |||
callback_record[0], "Invalidation callback for key1 not called", | |||
) | |||
self.assertTrue( | |||
callback_record[1], "Invalidation callback for key2 not called", | |||
) | |||
self.assertTrue(callback_record[0], "Invalidation callback for key1 not called") | |||
self.assertTrue(callback_record[1], "Invalidation callback for key2 not called") | |||
# letting the other lookup complete should do nothing | |||
d1.callback("result1") | |||
@@ -168,8 +164,7 @@ class DescriptorTestCase(unittest.TestCase): | |||
with logcontext.LoggingContext() as c1: | |||
c1.name = "c1" | |||
r = yield obj.fn(1) | |||
self.assertEqual(logcontext.LoggingContext.current_context(), | |||
c1) | |||
self.assertEqual(logcontext.LoggingContext.current_context(), c1) | |||
defer.returnValue(r) | |||
def check_result(r): | |||
@@ -179,14 +174,18 @@ class DescriptorTestCase(unittest.TestCase): | |||
# set off a deferred which will do a cache lookup | |||
d1 = do_lookup() | |||
self.assertEqual(logcontext.LoggingContext.current_context(), | |||
logcontext.LoggingContext.sentinel) | |||
self.assertEqual( | |||
logcontext.LoggingContext.current_context(), | |||
logcontext.LoggingContext.sentinel, | |||
) | |||
d1.addCallback(check_result) | |||
# and another | |||
d2 = do_lookup() | |||
self.assertEqual(logcontext.LoggingContext.current_context(), | |||
logcontext.LoggingContext.sentinel) | |||
self.assertEqual( | |||
logcontext.LoggingContext.current_context(), | |||
logcontext.LoggingContext.sentinel, | |||
) | |||
d2.addCallback(check_result) | |||
# let the lookup complete | |||
@@ -224,15 +223,16 @@ class DescriptorTestCase(unittest.TestCase): | |||
except SynapseError: | |||
pass | |||
self.assertEqual(logcontext.LoggingContext.current_context(), | |||
c1) | |||
self.assertEqual(logcontext.LoggingContext.current_context(), c1) | |||
obj = Cls() | |||
# set off a deferred which will do a cache lookup | |||
d1 = do_lookup() | |||
self.assertEqual(logcontext.LoggingContext.current_context(), | |||
logcontext.LoggingContext.sentinel) | |||
self.assertEqual( | |||
logcontext.LoggingContext.current_context(), | |||
logcontext.LoggingContext.sentinel, | |||
) | |||
return d1 | |||
@@ -288,14 +288,10 @@ class CachedListDescriptorTestCase(unittest.TestCase): | |||
@descriptors.cachedList("fn", "args1", inlineCallbacks=True) | |||
def list_fn(self, args1, arg2): | |||
assert ( | |||
logcontext.LoggingContext.current_context().request == "c1" | |||
) | |||
assert logcontext.LoggingContext.current_context().request == "c1" | |||
# we want this to behave like an asynchronous function | |||
yield run_on_reactor() | |||
assert ( | |||
logcontext.LoggingContext.current_context().request == "c1" | |||
) | |||
assert logcontext.LoggingContext.current_context().request == "c1" | |||
defer.returnValue(self.mock(args1, arg2)) | |||
with logcontext.LoggingContext() as c1: | |||
@@ -308,10 +304,7 @@ class CachedListDescriptorTestCase(unittest.TestCase): | |||
logcontext.LoggingContext.sentinel, | |||
) | |||
r = yield d1 | |||
self.assertEqual( | |||
logcontext.LoggingContext.current_context(), | |||
c1 | |||
) | |||
self.assertEqual(logcontext.LoggingContext.current_context(), c1) | |||
obj.mock.assert_called_once_with([10, 20], 2) | |||
self.assertEqual(r, {10: 'fish', 20: 'chips'}) | |||
obj.mock.reset_mock() | |||
@@ -337,6 +330,7 @@ class CachedListDescriptorTestCase(unittest.TestCase): | |||
@defer.inlineCallbacks | |||
def test_invalidate(self): | |||
"""Make sure that invalidation callbacks are called.""" | |||
class Cls(object): | |||
def __init__(self): | |||
self.mock = mock.Mock() | |||
@@ -20,7 +20,6 @@ from tests import unittest | |||
class DictCacheTestCase(unittest.TestCase): | |||
def setUp(self): | |||
self.cache = DictionaryCache("foobar") | |||
@@ -41,9 +40,7 @@ class DictCacheTestCase(unittest.TestCase): | |||
key = "test_simple_cache_hit_partial" | |||
seq = self.cache.sequence | |||
test_value = { | |||
"test": "test_simple_cache_hit_partial" | |||
} | |||
test_value = {"test": "test_simple_cache_hit_partial"} | |||
self.cache.update(seq, key, test_value) | |||
c = self.cache.get(key, ["test"]) | |||
@@ -53,9 +50,7 @@ class DictCacheTestCase(unittest.TestCase): | |||
key = "test_simple_cache_miss_partial" | |||
seq = self.cache.sequence | |||
test_value = { | |||
"test": "test_simple_cache_miss_partial" | |||
} | |||
test_value = {"test": "test_simple_cache_miss_partial"} | |||
self.cache.update(seq, key, test_value) | |||
c = self.cache.get(key, ["test2"]) | |||
@@ -79,15 +74,11 @@ class DictCacheTestCase(unittest.TestCase): | |||
key = "test_simple_cache_hit_miss_partial" | |||
seq = self.cache.sequence | |||
test_value_1 = { | |||
"test": "test_simple_cache_hit_miss_partial", | |||
} | |||
test_value_1 = {"test": "test_simple_cache_hit_miss_partial"} | |||
self.cache.update(seq, key, test_value_1, fetched_keys=set("test")) | |||
seq = self.cache.sequence | |||
test_value_2 = { | |||
"test2": "test_simple_cache_hit_miss_partial2", | |||
} | |||
test_value_2 = {"test2": "test_simple_cache_hit_miss_partial2"} | |||
self.cache.update(seq, key, test_value_2, fetched_keys=set("test2")) | |||
c = self.cache.get(key) | |||
@@ -96,5 +87,5 @@ class DictCacheTestCase(unittest.TestCase): | |||
"test": "test_simple_cache_hit_miss_partial", | |||
"test2": "test_simple_cache_hit_miss_partial2", | |||
}, | |||
c.value | |||
c.value, | |||
) |
@@ -22,7 +22,6 @@ from .. import unittest | |||
class ExpiringCacheTestCase(unittest.TestCase): | |||
def test_get_set(self): | |||
clock = MockClock() | |||
cache = ExpiringCache("test", clock, max_len=1) | |||
@@ -27,7 +27,6 @@ from tests import unittest | |||
class FileConsumerTests(unittest.TestCase): | |||
@defer.inlineCallbacks | |||
def test_pull_consumer(self): | |||
string_file = StringIO() | |||
@@ -87,7 +86,9 @@ class FileConsumerTests(unittest.TestCase): | |||
producer = NonCallableMock(spec_set=["pauseProducing", "resumeProducing"]) | |||
resume_deferred = defer.Deferred() | |||
producer.resumeProducing.side_effect = lambda: resume_deferred.callback(None) | |||
producer.resumeProducing.side_effect = lambda: resume_deferred.callback( | |||
None | |||
) | |||
consumer.registerProducer(producer, True) | |||
@@ -26,7 +26,6 @@ from tests import unittest | |||
class LinearizerTestCase(unittest.TestCase): | |||
@defer.inlineCallbacks | |||
def test_linearizer(self): | |||
linearizer = Linearizer() | |||
@@ -54,13 +53,11 @@ class LinearizerTestCase(unittest.TestCase): | |||
def func(i, sleep=False): | |||
with logcontext.LoggingContext("func(%s)" % i) as lc: | |||
with (yield linearizer.queue("")): | |||
self.assertEqual( | |||
logcontext.LoggingContext.current_context(), lc) | |||
self.assertEqual(logcontext.LoggingContext.current_context(), lc) | |||
if sleep: | |||
yield Clock(reactor).sleep(0) | |||
self.assertEqual( | |||
logcontext.LoggingContext.current_context(), lc) | |||
self.assertEqual(logcontext.LoggingContext.current_context(), lc) | |||
func(0, sleep=True) | |||
for i in range(1, 100): | |||
@@ -8,11 +8,8 @@ from .. import unittest | |||
class LoggingContextTestCase(unittest.TestCase): | |||
def _check_test_key(self, value): | |||
self.assertEquals( | |||
LoggingContext.current_context().request, value | |||
) | |||
self.assertEquals(LoggingContext.current_context().request, value) | |||
def test_with_context(self): | |||
with LoggingContext() as context_one: | |||
@@ -50,6 +47,7 @@ class LoggingContextTestCase(unittest.TestCase): | |||
self._check_test_key("one") | |||
callback_completed[0] = True | |||
return res | |||
d.addCallback(cb) | |||
return d | |||
@@ -74,8 +72,7 @@ class LoggingContextTestCase(unittest.TestCase): | |||
# make sure that the context was reset before it got thrown back | |||
# into the reactor | |||
try: | |||
self.assertIs(LoggingContext.current_context(), | |||
sentinel_context) | |||
self.assertIs(LoggingContext.current_context(), sentinel_context) | |||
d2.callback(None) | |||
except BaseException: | |||
d2.errback(twisted.python.failure.Failure()) | |||
@@ -104,9 +101,7 @@ class LoggingContextTestCase(unittest.TestCase): | |||
# a function which returns a deferred which looks like it has been | |||
# called, but is actually paused | |||
def testfunc(): | |||
return logcontext.make_deferred_yieldable( | |||
_chained_deferred_function() | |||
) | |||
return logcontext.make_deferred_yieldable(_chained_deferred_function()) | |||
return self._test_run_in_background(testfunc) | |||
@@ -175,5 +170,6 @@ def _chained_deferred_function(): | |||
d2 = defer.Deferred() | |||
reactor.callLater(0, d2.callback, res) | |||
return d2 | |||
d.addCallback(cb) | |||
return d |
@@ -23,7 +23,6 @@ from .. import unittest | |||
class LruCacheTestCase(unittest.TestCase): | |||
def test_get_set(self): | |||
cache = LruCache(1) | |||
cache["key"] = "value" | |||
@@ -235,7 +234,6 @@ class LruCacheCallbacksTestCase(unittest.TestCase): | |||
class LruCacheSizedTestCase(unittest.TestCase): | |||
def test_evict(self): | |||
cache = LruCache(5, size_callback=len) | |||
cache["key1"] = [0] | |||
@@ -20,7 +20,6 @@ from tests import unittest | |||
class ReadWriteLockTestCase(unittest.TestCase): | |||
def _assert_called_before_not_after(self, lst, first_false): | |||
for i, d in enumerate(lst[:first_false]): | |||
self.assertTrue(d.called, msg="%d was unexpectedly false" % i) | |||
@@ -36,12 +35,12 @@ class ReadWriteLockTestCase(unittest.TestCase): | |||
key = object() | |||
ds = [ | |||
rwlock.read(key), # 0 | |||
rwlock.read(key), # 1 | |||
rwlock.read(key), # 0 | |||
rwlock.read(key), # 1 | |||
rwlock.write(key), # 2 | |||
rwlock.write(key), # 3 | |||
rwlock.read(key), # 4 | |||
rwlock.read(key), # 5 | |||
rwlock.read(key), # 4 | |||
rwlock.read(key), # 5 | |||
rwlock.write(key), # 6 | |||
] | |||
@@ -22,7 +22,6 @@ from .. import unittest | |||
class SnapshotCacheTestCase(unittest.TestCase): | |||
def setUp(self): | |||
self.cache = SnapshotCache() | |||
self.cache.DURATION_MS = 1 | |||
@@ -181,17 +181,8 @@ class StreamChangeCacheTests(unittest.TestCase): | |||
# Query a subset of the entries mid-way through the stream. We should | |||
# only get back the subset. | |||
self.assertEqual( | |||
cache.get_entities_changed( | |||
[ | |||
"bar@baz.net", | |||
], | |||
stream_pos=2, | |||
), | |||
set( | |||
[ | |||
"bar@baz.net", | |||
] | |||
), | |||
cache.get_entities_changed(["bar@baz.net"], stream_pos=2), | |||
set(["bar@baz.net"]), | |||
) | |||
def test_max_pos(self): | |||
@@ -38,8 +38,9 @@ USE_POSTGRES_FOR_TESTS = False | |||
@defer.inlineCallbacks | |||
def setup_test_homeserver(name="test", datastore=None, config=None, reactor=None, | |||
**kargs): | |||
def setup_test_homeserver( | |||
name="test", datastore=None, config=None, reactor=None, **kargs | |||
): | |||
"""Setup a homeserver suitable for running tests against. Keyword arguments | |||
are passed to the Homeserver constructor. If no datastore is supplied a | |||
datastore backed by an in-memory sqlite db will be given to the HS. | |||
@@ -96,20 +97,12 @@ def setup_test_homeserver(name="test", datastore=None, config=None, reactor=None | |||
if USE_POSTGRES_FOR_TESTS: | |||
config.database_config = { | |||
"name": "psycopg2", | |||
"args": { | |||
"database": "synapse_test", | |||
"cp_min": 1, | |||
"cp_max": 5, | |||
}, | |||
"args": {"database": "synapse_test", "cp_min": 1, "cp_max": 5}, | |||
} | |||
else: | |||
config.database_config = { | |||
"name": "sqlite3", | |||
"args": { | |||
"database": ":memory:", | |||
"cp_min": 1, | |||
"cp_max": 1, | |||
}, | |||
"args": {"database": ":memory:", "cp_min": 1, "cp_max": 1}, | |||
} | |||
db_engine = create_engine(config.database_config) | |||
@@ -121,7 +114,8 @@ def setup_test_homeserver(name="test", datastore=None, config=None, reactor=None | |||
if datastore is None: | |||
hs = HomeServer( | |||
name, config=config, | |||
name, | |||
config=config, | |||
db_config=config.database_config, | |||
version_string="Synapse/tests", | |||
database_engine=db_engine, | |||
@@ -143,7 +137,10 @@ def setup_test_homeserver(name="test", datastore=None, config=None, reactor=None | |||
hs.setup() | |||
else: | |||
hs = HomeServer( | |||
name, db_pool=None, datastore=datastore, config=config, | |||
name, | |||
db_pool=None, | |||
datastore=datastore, | |||
config=config, | |||
version_string="Synapse/tests", | |||
database_engine=db_engine, | |||
room_list_handler=object(), | |||
@@ -158,8 +155,9 @@ def setup_test_homeserver(name="test", datastore=None, config=None, reactor=None | |||
# because AuthHandler's constructor requires the HS, so we can't make one | |||
# beforehand and pass it in to the HS's constructor (chicken / egg) | |||
hs.get_auth_handler().hash = lambda p: hashlib.md5(p.encode('utf8')).hexdigest() | |||
hs.get_auth_handler().validate_hash = lambda p, h: hashlib.md5( | |||
p.encode('utf8')).hexdigest() == h | |||
hs.get_auth_handler().validate_hash = ( | |||
lambda p, h: hashlib.md5(p.encode('utf8')).hexdigest() == h | |||
) | |||
fed = kargs.get("resource_for_federation", None) | |||
if fed: | |||
@@ -173,7 +171,7 @@ def setup_test_homeserver(name="test", datastore=None, config=None, reactor=None | |||
sleep_limit=hs.config.federation_rc_sleep_limit, | |||
sleep_msec=hs.config.federation_rc_sleep_delay, | |||
reject_limit=hs.config.federation_rc_reject_limit, | |||
concurrent_requests=hs.config.federation_rc_concurrent | |||
concurrent_requests=hs.config.federation_rc_concurrent, | |||
), | |||
) | |||
@@ -199,7 +197,6 @@ def mock_getRawHeaders(headers=None): | |||
# This is a mock /resource/ not an entire server | |||
class MockHttpResource(HttpServer): | |||
def __init__(self, prefix=""): | |||
self.callbacks = [] # 3-tuple of method/pattern/function | |||
self.prefix = prefix | |||
@@ -263,15 +260,9 @@ class MockHttpResource(HttpServer): | |||
matcher = pattern.match(path) | |||
if matcher: | |||
try: | |||
args = [ | |||
urlparse.unquote(u) | |||
for u in matcher.groups() | |||
] | |||
(code, response) = yield func( | |||
mock_request, | |||
*args | |||
) | |||
args = [urlparse.unquote(u) for u in matcher.groups()] | |||
(code, response) = yield func(mock_request, *args) | |||
defer.returnValue((code, response)) | |||
except CodeMessageException as e: | |||
defer.returnValue((e.code, cs_error(e.msg, code=e.errcode))) | |||
@@ -372,8 +363,7 @@ class MockClock(object): | |||
def _format_call(args, kwargs): | |||
return ", ".join( | |||
["%r" % (a) for a in args] + | |||
["%s=%r" % (k, v) for k, v in kwargs.items()] | |||
["%r" % (a) for a in args] + ["%s=%r" % (k, v) for k, v in kwargs.items()] | |||
) | |||
@@ -391,8 +381,9 @@ class DeferredMockCallable(object): | |||
self.calls.append((args, kwargs)) | |||
if not self.expectations: | |||
raise ValueError("%r has no pending calls to handle call(%s)" % ( | |||
self, _format_call(args, kwargs)) | |||
raise ValueError( | |||
"%r has no pending calls to handle call(%s)" | |||
% (self, _format_call(args, kwargs)) | |||
) | |||
for (call, result, d) in self.expectations: | |||
@@ -400,9 +391,9 @@ class DeferredMockCallable(object): | |||
d.callback(None) | |||
return result | |||
failure = AssertionError("Was not expecting call(%s)" % ( | |||
_format_call(args, kwargs) | |||
)) | |||
failure = AssertionError( | |||
"Was not expecting call(%s)" % (_format_call(args, kwargs)) | |||
) | |||
for _, _, d in self.expectations: | |||
try: | |||
@@ -418,17 +409,19 @@ class DeferredMockCallable(object): | |||
@defer.inlineCallbacks | |||
def await_calls(self, timeout=1000): | |||
deferred = defer.DeferredList( | |||
[d for _, _, d in self.expectations], | |||
fireOnOneErrback=True | |||
[d for _, _, d in self.expectations], fireOnOneErrback=True | |||
) | |||
timer = reactor.callLater( | |||
timeout / 1000, | |||
deferred.errback, | |||
AssertionError("%d pending calls left: %s" % ( | |||
len([e for e in self.expectations if not e[2].called]), | |||
[e for e in self.expectations if not e[2].called] | |||
)) | |||
AssertionError( | |||
"%d pending calls left: %s" | |||
% ( | |||
len([e for e in self.expectations if not e[2].called]), | |||
[e for e in self.expectations if not e[2].called], | |||
) | |||
), | |||
) | |||
yield deferred | |||
@@ -443,7 +436,6 @@ class DeferredMockCallable(object): | |||
self.calls = [] | |||
raise AssertionError( | |||
"Expected not to received any calls, got:\n" + "\n".join([ | |||
"call(%s)" % _format_call(c[0], c[1]) for c in calls | |||
]) | |||
"Expected not to received any calls, got:\n" | |||
+ "\n".join(["call(%s)" % _format_call(c[0], c[1]) for c in calls]) | |||
) |