Rename ForeignKey provider to ColumnValue provider

sqlsynthgen/make.py

@@ -9,11 +9,11 @@
         '"""This file was auto-generated by sqlsynthgen but can be edited manually."""',
         "from mimesis import Generic",
         "from mimesis.locales import Locale",
-        "from sqlsynthgen.providers import BinaryProvider, ForeignKeyProvider",
+        "from sqlsynthgen.providers import BytesProvider, ColumnValueProvider",
         "",
         "generic = Generic(locale=Locale.EN)",
-        "generic.add_provider(ForeignKeyProvider)",
-        "generic.add_provider(BinaryProvider)",
+        "generic.add_provider(ColumnValueProvider)",
+        "generic.add_provider(BytesProvider)",
         "",
     )
 )
@@ -43,7 +43,7 @@ def make_generators_from_tables(tables_module: ModuleType) -> str:
         sqltypes.Integer: "generic.numeric.integer_number()",
         sqltypes.Text: "generic.text.color()",
         sqltypes.Float: "generic.numeric.float_number()",
-        sqltypes.LargeBinary: "generic.binary_provider.bytes()",
+        sqltypes.LargeBinary: "generic.bytes_provider.bytes()",
     }
 
     for table in tables_module.metadata.sorted_tables:
@@ -70,7 +70,7 @@ def make_generators_from_tables(tables_module: ModuleType) -> str:
                 fk_schema, fk_table, fk_column = fk_column_path.split(".")
                 new_content += (
                     f"{INDENTATION*2}self.{column.name} = "
-                    f"generic.foreign_key_provider.key(db_connection, "
+                    f"generic.column_value_provider.column_value(db_connection, "
                     f'"{fk_schema}", "{fk_table}", "{fk_column}"'
                     ")\n"
                 )

sqlsynthgen/providers.py

@@ -6,28 +6,30 @@
 from sqlalchemy.sql import text
 
 
-class ForeignKeyProvider(BaseProvider):
-    """A Mimesis provider of foreign keys."""
+class ColumnValueProvider(BaseProvider):
+    """A Mimesis provider of random values from the source database."""
 
     class Meta:
-        """Meta-class for ForeignKeyProvider settings."""
+        """Meta-class for ColumnValueProvider settings."""
 
-        name = "foreign_key_provider"
+        name = "column_value_provider"
 
-    def key(self, db_connection: Any, schema: str, table: str, column: str) -> Any:
-        """Return a random value from the table and column specified."""
+    def column_value(
+        self, db_connection: Any, schema: str, table: str, column: str
+    ) -> Any:
+        """Return a random value from the column specified."""
         query_str = f"SELECT {column} FROM {schema}.{table} ORDER BY random() LIMIT 1"
         key = db_connection.execute(text(query_str)).fetchone()[0]
         return key
 
 
-class BinaryProvider(BaseDataProvider):
+class BytesProvider(BaseDataProvider):
     """A Mimesis provider of binary data."""
 
     class Meta:
-        """Meta-class for ForeignKeyProvider settings."""
+        """Meta-class for BytesProvider settings."""
 
-        name = "binary_provider"
+        name = "bytes_provider"
 
     def bytes(self) -> bytes:
         """Return a UTF-8 encoded sentence."""

tests/examples/expected_ssg.py

@@ -1,11 +1,11 @@
 """This file was auto-generated by sqlsynthgen but can be edited manually."""
 from mimesis import Generic
 from mimesis.locales import Locale
-from sqlsynthgen.providers import BinaryProvider, ForeignKeyProvider
+from sqlsynthgen.providers import BytesProvider, ColumnValueProvider
 
 generic = Generic(locale=Locale.EN)
-generic.add_provider(ForeignKeyProvider)
-generic.add_provider(BinaryProvider)
+generic.add_provider(ColumnValueProvider)
+generic.add_provider(BytesProvider)
 
 
 class personGenerator:
@@ -19,11 +19,11 @@ def __init__(self, db_connection):
 
 class hospital_visitGenerator:
     def __init__(self, db_connection):
-        self.person_id = generic.foreign_key_provider.key(db_connection, "myschema", "person", "person_id")
+        self.person_id = generic.column_value_provider.column_value(db_connection, "myschema", "person", "person_id")
         self.visit_start = generic.datetime.datetime()
         self.visit_end = generic.datetime.date()
         self.visit_duration_seconds = generic.numeric.float_number()
-        self.visit_image = generic.binary_provider.bytes()
+        self.visit_image = generic.bytes_provider.bytes()
 
 
 sorted_generators = [

tests/test_providers.py

@@ -5,22 +5,39 @@
 from sqlalchemy import Column, Integer, Text, create_engine, insert
 from sqlalchemy.ext.declarative import declarative_base
 
-from sqlsynthgen.providers import BinaryProvider, ForeignKeyProvider
+from sqlsynthgen.providers import BytesProvider, ColumnValueProvider
 from tests.utils import run_psql
 
+# pylint: disable=invalid-name
+Base = declarative_base()
+# pylint: enable=invalid-name
+metadata = Base.metadata
+
+
+class Person(Base):  # type: ignore
+    """A SQLAlchemy table."""
+
+    __tablename__ = "person"
+    person_id = Column(
+        Integer,
+        primary_key=True,
+    )
+    # We don't actually need a foreign key constraint to test this
+    sex = Column(Text)
+
 
 class BinaryProviderTestCase(TestCase):
-    """Tests for the BinaryProvider class."""
+    """Tests for the BytesProvider class."""
 
     def test_bytes(self) -> None:
-        BinaryProvider().bytes().decode("utf-8")
+        BytesProvider().bytes().decode("utf-8")
 
 
 @skipUnless(
     os.environ.get("FUNCTIONAL_TESTS") == "1", "Set 'FUNCTIONAL_TESTS=1' to enable."
 )
-class ForeignKeyProviderTestCase(TestCase):
-    """Tests for the ForeignKeyProvider class."""
+class ColumnValueProviderTestCase(TestCase):
+    """Tests for the ColumnValueProvider class."""
 
     def setUp(self) -> None:
         """Pre-test setup."""
@@ -30,31 +47,17 @@ def setUp(self) -> None:
         self.engine = create_engine(
             "postgresql://postgres:password@localhost:5432/providers"
         )
+        metadata.create_all(self.engine)
 
-    def test_key(self) -> None:
+    def test_column_value(self) -> None:
         """Test the key method."""
         # pylint: disable=invalid-name
 
-        Base = declarative_base()
-        metadata = Base.metadata
-
-        class Person(Base):  # type: ignore
-            """A SQLAlchemy table."""
-
-            __tablename__ = "person"
-            person_id = Column(
-                Integer,
-                primary_key=True,
-            )
-            sex = Column(Text)
-
-        metadata.create_all(self.engine)
-
         with self.engine.connect() as conn:
             stmt = insert(Person).values(sex="M")
             conn.execute(stmt)
 
-            fkp = ForeignKeyProvider()
-            key = fkp.key(conn, "public", "person", "sex")
+            provider = ColumnValueProvider()
+            key = provider.column_value(conn, "public", "person", "sex")
 
         self.assertEqual("M", key)