A few more tests

Author: grigi

tortoise/__init__.py

@@ -84,7 +84,8 @@ def _init_relations(cls) -> None:
 
                     backward_relation_name = field_mobject.related_name
                     if not backward_relation_name:
-                        backward_relation_name = '{}s'.format(model._meta.table)
+                        backward_relation_name = field_mobject.related_name = \
+                            '{}_through'.format(model._meta.table)
                     if backward_relation_name in related_model._meta.fields:
                         raise ConfigurationError(
                             'backward relation "{}" duplicates in model {}'.format(

tortoise/fields.py

@@ -323,17 +323,15 @@ def __init__(
         through: Optional[str] = None,
         forward_key: Optional[str] = None,
         backward_key: str = '',
-        related_name: Optional[str] = None,
+        related_name: str = '',
         **kwargs
     ) -> None:
         super().__init__(**kwargs)
         if len(model_name.split(".")) != 2:
             raise ConfigurationError('Foreign key accepts model name in format "app.Model"')
         self.model_name = model_name
-        self.related_name = related_name or '{}_through'.format(model_name)
-        self.forward_key = forward_key if forward_key else '{}_id'.format(
-            model_name.split(".")[1].lower()
-        )
+        self.related_name = related_name
+        self.forward_key = forward_key or '{}_id'.format(model_name.split(".")[1].lower())
         self.backward_key = backward_key
         self.through = through
         self._generated = False
@@ -342,7 +340,7 @@ def __init__(
 class BackwardFKRelation(Field):
     __slots__ = ('type', 'relation_field')
 
-    def __init__(self, type, relation_field: str) -> None:
+    def __init__(self, type, relation_field: str) -> None:  # pylint: disable=W0622
         super().__init__(type=type)
         self.relation_field = relation_field
 

tortoise/tests/test_init.py

@@ -47,6 +47,34 @@ async def test_basic_init(self):
         self.assertIn('models', Tortoise.apps)
         self.assertIsNotNone(Tortoise.get_connection('default'))
 
+    async def test_unknown_connection(self):
+        with self.assertRaisesRegexp(ConfigurationError, 'Unknown connection "fioop"'):
+            await Tortoise.init({
+                "connections": {
+                    "default": {
+                        "engine": "tortoise.backends.sqlite",
+                        "credentials": {
+                            "file_path": self.db_file_path,
+                        }
+                    }
+                },
+                "apps": {
+                    "models": {
+                        "models": [
+                            "tortoise.tests.testmodels",
+                        ],
+                        "default_connection": "fioop"
+                    }
+                }
+            })
+
+    async def test_url_without_modules(self):
+        with self.assertRaisesRegexp(ConfigurationError,
+                                     'You must specify "db_url" and "modules" together'):
+            await Tortoise.init(
+                db_url="sqlite://{}".format(self.db_file_path),
+            )
+
     async def test_default_connection_init(self):
         await Tortoise.init({
             "connections": {

tortoise/tests/testmodels.py

@@ -21,10 +21,19 @@ def __str__(self):
         return self.name
 
 
+class Reporter(Model):
+    id = fields.IntField(pk=True)
+    name = fields.TextField()
+
+    def __str__(self):
+        return self.name
+
+
 class Event(Model):
     id = fields.IntField(pk=True)
     name = fields.TextField()
     tournament = fields.ForeignKeyField('models.Tournament', related_name='events')
+    reporter = fields.ForeignKeyField('models.Reporter', null=True)
     participants = fields.ManyToManyField(
         'models.Team', related_name='events', through='event_team'
     )
@@ -48,9 +57,7 @@ class EventTwo(Model):
     name = fields.TextField()
     tournament_id = fields.IntField()
     # Here we make link to events.Team, not models.Team
-    participants = fields.ManyToManyField(
-        'events.TeamTwo', related_name='events', through='eventtwo_teamtwo'
-    )
+    participants = fields.ManyToManyField('events.TeamTwo')
 
     class Meta:
         app = 'events'