move logic into register, fix room alias localpart bug, tests

synapse/handlers/register.py

@@ -220,8 +220,26 @@ class RegistrationHandler(BaseHandler):
 
         # auto-join the user to any rooms we're supposed to dump them into
         fake_requester = create_requester(user_id)
+
+        # try to create the room if we're the first user on the server
+        if self.hs.config.autocreate_auto_join_rooms:
+            count = yield self.store.count_all_users()
+            auto_create_rooms = count == 1
+
         for r in self.hs.config.auto_join_rooms:
             try:
+                if auto_create_rooms and RoomAlias.is_valid(r):
+                    room_creation_handler = self.hs.get_room_creation_handler()
+                    # create room expects the localpart of the room alias
+                    room_alias_localpart = RoomAlias.from_string(r).localpart
+                    yield room_creation_handler.create_room(
+                        fake_requester,
+                        config={
+                            "preset": "public_chat",
+                            "room_alias_name": room_alias_localpart
+                        },
+                        ratelimit=False,
+                    )
                 yield self._join_user_to_room(fake_requester, r)
             except Exception as e:
                 logger.error("Failed to join new user to %r: %r", r, e)
@@ -514,33 +532,6 @@ class RegistrationHandler(BaseHandler):
     @defer.inlineCallbacks
     def _join_user_to_room(self, requester, room_identifier):
 
-        # try to create the room if we're the first user on the server
-        if self.hs.config.autocreate_auto_join_rooms:
-            count = yield self.store.count_all_users()
-            if count == 1 and RoomAlias.is_valid(room_identifier):
-                room_creation_handler = self.hs.get_room_creation_handler()
-                info = yield room_creation_handler.create_room(
-                    requester,
-                    config={
-                        "preset": "public_chat",
-                    },
-                    ratelimit=False,
-                )
-                room_id = info["room_id"]
-
-                directory_handler = self.hs.get_handlers().directory_handler
-                room_alias = RoomAlias.from_string(room_identifier)
-                yield directory_handler.create_association(
-                    user_id=requester.user.to_string(),
-                    room_alias=room_alias,
-                    room_id=room_id,
-                    servers=[self.hs.hostname],
-                )
-
-                yield directory_handler.send_room_alias_update_event(
-                    requester, requester.user.to_string(), room_id
-                )
-
         room_id = None
         room_member_handler = self.hs.get_room_member_handler()
         if RoomID.is_valid(room_identifier):

tests/handlers/test_register.py

@@ -19,7 +19,7 @@ from twisted.internet import defer
 
 from synapse.api.errors import ResourceLimitError
 from synapse.handlers.register import RegistrationHandler
-from synapse.types import UserID, create_requester
+from synapse.types import RoomAlias, UserID, create_requester
 
 from tests.utils import setup_test_homeserver
 
@@ -41,30 +41,28 @@ class RegistrationTestCase(unittest.TestCase):
         self.mock_captcha_client = Mock()
         self.hs = yield setup_test_homeserver(
             self.addCleanup,
-            handlers=None,
-            http_client=None,
             expire_access_token=True,
-            profile_handler=Mock(),
         )
         self.macaroon_generator = Mock(
             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.hs.handlers = RegistrationHandlers(self.hs)
         self.handler = self.hs.get_handlers().registration_handler
         self.store = self.hs.get_datastore()
         self.hs.config.max_mau_value = 50
         self.lots_of_users = 100
         self.small_number_of_users = 1
 
+        self.requester = create_requester("@requester:test")
+
     @defer.inlineCallbacks
     def test_user_is_created_and_logged_in_if_doesnt_exist(self):
-        local_part = "someone"
+        frank = UserID.from_string("@frank:test")
-        display_name = "someone"
+        user_id = frank.to_string()
-        user_id = "@someone:test"
+        requester = create_requester(user_id)
-        requester = create_requester("@as:test")
         result_user_id, result_token = yield self.handler.get_or_create_user(
-            requester, local_part, display_name
+            requester, frank.localpart, "Frankie"
         )
         self.assertEquals(result_user_id, user_id)
         self.assertEquals(result_token, 'secret')
@@ -78,12 +76,11 @@ class RegistrationTestCase(unittest.TestCase):
             token="jkv;g498752-43gj['eamb!-5",
             password_hash=None,
         )
-        local_part = "frank"
+        local_part = frank.localpart
-        display_name = "Frank"
+        user_id = frank.to_string()
-        user_id = "@frank:test"
+        requester = create_requester(user_id)
-        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, None
         )
         self.assertEquals(result_user_id, user_id)
         self.assertEquals(result_token, 'secret')
@@ -92,7 +89,7 @@ class RegistrationTestCase(unittest.TestCase):
     def test_mau_limits_when_disabled(self):
         self.hs.config.limit_usage_by_mau = False
         # Ensure does not throw exception
-        yield self.handler.get_or_create_user("requester", 'a', "display_name")
+        yield self.handler.get_or_create_user(self.requester, 'a', "display_name")
 
     @defer.inlineCallbacks
     def test_get_or_create_user_mau_not_blocked(self):
@@ -101,7 +98,7 @@ class RegistrationTestCase(unittest.TestCase):
             return_value=defer.succeed(self.hs.config.max_mau_value - 1)
         )
         # Ensure does not throw exception
-        yield self.handler.get_or_create_user("@user:server", 'c', "User")
+        yield self.handler.get_or_create_user(self.requester, 'c', "User")
 
     @defer.inlineCallbacks
     def test_get_or_create_user_mau_blocked(self):
@@ -110,13 +107,13 @@ class RegistrationTestCase(unittest.TestCase):
             return_value=defer.succeed(self.lots_of_users)
         )
         with self.assertRaises(ResourceLimitError):
-            yield self.handler.get_or_create_user("requester", 'b', "display_name")
+            yield self.handler.get_or_create_user(self.requester, 'b', "display_name")
 
         self.store.get_monthly_active_count = Mock(
             return_value=defer.succeed(self.hs.config.max_mau_value)
         )
         with self.assertRaises(ResourceLimitError):
-            yield self.handler.get_or_create_user("requester", 'b', "display_name")
+            yield self.handler.get_or_create_user(self.requester, 'b', "display_name")
 
     @defer.inlineCallbacks
     def test_register_mau_blocked(self):
@@ -147,3 +144,30 @@ class RegistrationTestCase(unittest.TestCase):
         )
         with self.assertRaises(ResourceLimitError):
             yield self.handler.register_saml2(localpart="local_part")
+
+    @defer.inlineCallbacks
+    def test_auto_create_auto_join_rooms(self):
+        room_alias_str = "#room:test"
+        self.hs.config.autocreate_auto_join_rooms = True
+        self.hs.config.auto_join_rooms = [room_alias_str]
+
+        res = yield self.handler.register(localpart='jeff')
+        rooms = yield self.store.get_rooms_for_user(res[0])
+
+        directory_handler = self.hs.get_handlers().directory_handler
+        room_alias = RoomAlias.from_string(room_alias_str)
+        room_id = yield directory_handler.get_association(room_alias)
+
+        self.assertTrue(room_id['room_id'] in rooms)
+        self.assertEqual(len(rooms), 1)
+
+    @defer.inlineCallbacks
+    def test_auto_create_auto_join_rooms_with_no_rooms(self):
+        self.hs.config.autocreate_auto_join_rooms = True
+        self.hs.config.auto_join_rooms = []
+        frank = UserID.from_string("@frank:test")
+        res = yield self.handler.register(frank.localpart)
+        self.assertEqual(res[0], frank.to_string())
+        rooms = yield self.store.get_rooms_for_user(res[0])
+
+        self.assertEqual(len(rooms), 0)

tests/utils.py

@@ -149,6 +149,7 @@ def setup_test_homeserver(
         config.block_events_without_consent_error = None
         config.media_storage_providers = []
         config.auto_join_rooms = []
+        config.autocreate_auto_join_rooms = True
         config.limit_usage_by_mau = False
         config.hs_disabled = False
         config.hs_disabled_message = ""