GeneralManager 0.3.2__tar.gz → 0.4.1__tar.gz

{generalmanager-0.3.2 → generalmanager-0.4.1}/GeneralManager.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.3.2
+Version: 0.4.1
 Summary: Kurzbeschreibung deines Pakets
 Author-email: Tim Kleindick <tkleindick@yahoo.de>
 License: Non-Commercial MIT License

{generalmanager-0.3.2 → generalmanager-0.4.1}/GeneralManager.egg-info/SOURCES.txt

@@ -25,7 +25,7 @@ src/general_manager/cache/modelDependencyCollector.py
 src/general_manager/cache/signals.py
 src/general_manager/factory/__init__.py
 src/general_manager/factory/factories.py
-src/general_manager/factory/lazy_methods.py
+src/general_manager/factory/factoryMethods.py
 src/general_manager/interface/__init__.py
 src/general_manager/interface/baseInterface.py
 src/general_manager/interface/calculationInterface.py
@@ -52,6 +52,8 @@ tests/test_basePermission.py
 tests/test_cacheDecorator.py
 tests/test_cacheTracker.py
 tests/test_dependencyIndex.py
+tests/test_factories.py
+tests/test_factoryMethods.py
 tests/test_filterParser.py
 tests/test_graph_ql.py
 tests/test_input.py

{generalmanager-0.3.2 → generalmanager-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.3.2
+Version: 0.4.1
 Summary: Kurzbeschreibung deines Pakets
 Author-email: Tim Kleindick <tkleindick@yahoo.de>
 License: Non-Commercial MIT License

{generalmanager-0.3.2 → generalmanager-0.4.1}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "GeneralManager"
-version = "0.3.2"
+version = "0.4.1"
 description = "Kurzbeschreibung deines Pakets"
 readme = "README.md"
 authors = [

{generalmanager-0.3.2 → generalmanager-0.4.1}/src/general_manager/factory/__init__.py

@@ -1,4 +1,4 @@
-from .lazy_methods import (
+from .factoryMethods import (
     LazyMeasurement,
     LazyDeltaDate,
     LazyProjectName,

{generalmanager-0.3.2 → generalmanager-0.4.1}/src/general_manager/factory/factories.py

@@ -1,17 +1,16 @@
 from __future__ import annotations
 from typing import TYPE_CHECKING, Type, Callable, Union, Any, TypeVar, Literal, cast
-from factory.declarations import LazyFunction, LazyAttribute, LazyAttributeSequence
+from factory.declarations import LazyFunction
 from factory.faker import Faker
 import exrex  # type: ignore
 from django.db import models
 from django.core.validators import RegexValidator
 from factory.django import DjangoModelFactory
-from django.utils import timezone
 import random
 from decimal import Decimal
 from general_manager.measurement.measurement import Measurement
 from general_manager.measurement.measurementField import MeasurementField
-from datetime import date, datetime, time
+from datetime import date, datetime, time, timezone
 
 if TYPE_CHECKING:
     from general_manager.interface.databaseInterface import (
@@ -33,7 +32,7 @@ class AutoFactory(DjangoModelFactory[modelsModel]):
     ) = None
 
     @classmethod
-    def _generate(  # type: ignore
+    def _generate(
         cls, strategy: Literal["build", "create"], params: dict[str, Any]
     ) -> models.Model | list[models.Model]:
         cls._original_params = params
@@ -64,7 +63,7 @@ class AutoFactory(DjangoModelFactory[modelsModel]):
                 continue  # Skip fields that are already set
             if isinstance(field, models.AutoField) or field.auto_created:
                 continue  # Skip auto fields
-            params[field.name] = get_field_value(field)
+            params[field.name] = getFieldValue(field)
 
         obj: list[models.Model] | models.Model = super()._generate(strategy, params)
         if isinstance(obj, list):
@@ -84,7 +83,7 @@ class AutoFactory(DjangoModelFactory[modelsModel]):
             if field.name in attrs:
                 m2m_values = attrs[field.name]
             else:
-                m2m_values = get_m2m_field_value(field)
+                m2m_values = getManyToManyFieldValue(field)
             if m2m_values:
                 getattr(obj, field.name).set(m2m_values)
 
@@ -98,7 +97,7 @@ class AutoFactory(DjangoModelFactory[modelsModel]):
         return kwargs
 
     @classmethod
-    def _create(  # type: ignore
+    def _create(
         cls, model_class: Type[models.Model], *args: list[Any], **kwargs: dict[str, Any]
     ) -> models.Model | list[models.Model]:
         kwargs = cls._adjust_kwargs(**kwargs)
@@ -107,7 +106,7 @@ class AutoFactory(DjangoModelFactory[modelsModel]):
         return cls._modelCreation(model_class, **kwargs)
 
     @classmethod
-    def _build(  # type: ignore
+    def _build(
         cls, model_class: Type[models.Model], *args: list[Any], **kwargs: dict[str, Any]
     ) -> models.Model | list[models.Model]:
         kwargs = cls._adjust_kwargs(**kwargs)
@@ -157,7 +156,7 @@ class AutoFactory(DjangoModelFactory[modelsModel]):
         return created_objects
 
 
-def get_field_value(field: models.Field[Any, Any] | models.ForeignObjectRel) -> object:
+def getFieldValue(field: models.Field[Any, Any] | models.ForeignObjectRel) -> object:
     """
     Returns a suitable value for a given Django model field.
     """
@@ -166,22 +165,12 @@ def get_field_value(field: models.Field[Any, Any] | models.ForeignObjectRel) ->
             return None
 
     if isinstance(field, MeasurementField):
-        base_unit = field.base_unit
-        value = Decimal(str(random.uniform(0, 10_000))[:10])
-        return LazyFunction(lambda: Measurement(value, base_unit))
-    elif isinstance(field, models.CharField):
-        max_length = field.max_length or 100
-        # Check for RegexValidator
-        regex = None
-        for validator in field.validators:
-            if isinstance(validator, RegexValidator):
-                regex = getattr(validator.regex, "pattern", None)
-                break
-        if regex:
-            # Use exrex to generate a string matching the regex
-            return LazyFunction(lambda: exrex.getone(regex))  # type: ignore
-        else:
-            return cast(str, Faker("text", max_nb_chars=max_length))
+
+        def _measurement():
+            value = Decimal(random.randrange(0, 10_000_000)) / Decimal("100")  # two dp
+            return Measurement(value, field.base_unit)
+
+        return LazyFunction(_measurement)
     elif isinstance(field, models.TextField):
         return cast(str, Faker("paragraph"))
     elif isinstance(field, models.IntegerField):
@@ -201,8 +190,6 @@ def get_field_value(field: models.Field[Any, Any] | models.ForeignObjectRel) ->
         )
     elif isinstance(field, models.FloatField):
         return cast(float, Faker("pyfloat", positive=True))
-    elif isinstance(field, models.DateField):
-        return cast(date, Faker("date_between", start_date="-1y", end_date="today"))
     elif isinstance(field, models.DateTimeField):
         return cast(
             datetime,
@@ -213,10 +200,11 @@ def get_field_value(field: models.Field[Any, Any] | models.ForeignObjectRel) ->
                 tzinfo=timezone.utc,
             ),
         )
+    elif isinstance(field, models.DateField):
+        return cast(date, Faker("date_between", start_date="-1y", end_date="today"))
     elif isinstance(field, models.BooleanField):
         return cast(bool, Faker("pybool"))
-    elif isinstance(field, models.ForeignKey):
-        # Create or get an instance of the related model
+    elif isinstance(field, models.OneToOneField):
         if hasattr(field.related_model, "_general_manager_class"):
             related_factory = field.related_model._general_manager_class.Factory
             return related_factory()
@@ -229,11 +217,19 @@ def get_field_value(field: models.Field[Any, Any] | models.ForeignObjectRel) ->
                 raise ValueError(
                     f"No factory found for {field.related_model.__name__} and no instances found"
                 )
-    elif isinstance(field, models.OneToOneField):
-        # Similar to ForeignKey
+    elif isinstance(field, models.ForeignKey):
+        # Create or get an instance of the related model
         if hasattr(field.related_model, "_general_manager_class"):
+            create_a_new_instance = random.choice([True, True, False])
+            if not create_a_new_instance:
+                existing_instances = list(field.related_model.objects.all())
+                if existing_instances:
+                    # Pick a random existing instance
+                    return LazyFunction(lambda: random.choice(existing_instances))
+
             related_factory = field.related_model._general_manager_class.Factory
             return related_factory()
+
         else:
             # If no factory exists, pick a random existing instance
             related_instances = list(field.related_model.objects.all())
@@ -253,35 +249,56 @@ def get_field_value(field: models.Field[Any, Any] | models.ForeignObjectRel) ->
         return cast(str, Faker("uuid4"))
     elif isinstance(field, models.DurationField):
         return cast(time, Faker("time_delta"))
+    elif isinstance(field, models.CharField):
+        max_length = field.max_length or 100
+        # Check for RegexValidator
+        regex = None
+        for validator in field.validators:
+            if isinstance(validator, RegexValidator):
+                regex = getattr(validator.regex, "pattern", None)
+                break
+        if regex:
+            # Use exrex to generate a string matching the regex
+            return LazyFunction(lambda: exrex.getone(regex))  # type: ignore
+        else:
+            return cast(str, Faker("text", max_nb_chars=max_length))
     else:
         return None  # For unsupported field types
 
 
-def get_m2m_field_value(field: models.ManyToManyField[Any, Any]) -> list[models.Model]:
+def getManyToManyFieldValue(
+    field: models.ManyToManyField,
+) -> list[models.Model]:
     """
     Returns a list of instances for a ManyToMany field.
     """
-    related_factory = globals().get(f"{field.related_model.__name__}Factory")
-    existing_instances = list(field.related_model.objects.all())
+    related_factory = None
+    related_instances = list(field.related_model.objects.all())
+    if hasattr(field.related_model, "_general_manager_class"):
+        related_factory = field.related_model._general_manager_class.Factory
 
-    if related_factory:
-        # Use existing instances if available, otherwise create new ones
-        if existing_instances:
-            max_instances = len(existing_instances)
-            num_instances = random.randint(0, min(max_instances, 15))
-            return random.sample(existing_instances, num_instances)
-        else:
-            # No existing instances, create a few
-            num_to_create = random.randint(1, 3)
-            new_instances = [related_factory() for _ in range(num_to_create)]
-            return new_instances
+    min_required = 0 if field.blank else 1
+    number_of_instances = random.randint(min_required, 10)
+    if related_factory and related_instances:
+        number_to_create = random.randint(min_required, number_of_instances)
+        number_to_pick = number_of_instances - number_to_create
+        if number_to_pick > len(related_instances):
+            number_to_pick = len(related_instances)
+        existing_instances = random.sample(related_instances, number_to_pick)
+        new_instances = [related_factory() for _ in range(number_to_create)]
+        return existing_instances + new_instances
+    elif related_factory:
+        number_to_create = number_of_instances
+        new_instances = [related_factory() for _ in range(number_to_create)]
+        return new_instances
+    elif related_instances:
+        number_to_create = 0
+        number_to_pick = number_of_instances
+        if number_to_pick > len(related_instances):
+            number_to_pick = len(related_instances)
+        existing_instances = random.sample(related_instances, number_to_pick)
+        return existing_instances
     else:
-        # No factory exists, use existing instances
-        if existing_instances:
-            max_instances = len(existing_instances)
-            num_instances = random.randint(0, max_instances)
-            return random.sample(existing_instances, num_instances)
-        else:
-            raise ValueError(
-                f"No factory found for {field.related_model.__name__} and no instances found"
-            )
+        raise ValueError(
+            f"No factory found for {field.related_model.__name__} and no instances found"
+        )

generalmanager-0.4.1/src/general_manager/factory/factoryMethods.py

@@ -0,0 +1,109 @@
+from typing import Any, Optional
+from factory.declarations import LazyFunction, LazyAttribute, LazyAttributeSequence
+import random
+from general_manager.measurement.measurement import Measurement
+from datetime import timedelta, date, datetime
+from faker import Faker
+import uuid
+from decimal import Decimal
+
+fake = Faker()
+
+
+def LazyMeasurement(
+    min_value: int | float, max_value: int | float, unit: str
+) -> LazyFunction:
+    return LazyFunction(
+        lambda: Measurement(str(random.uniform(min_value, max_value))[:10], unit)
+    )
+
+
+def LazyDeltaDate(avg_delta_days: int, base_attribute: str) -> LazyAttribute:
+    return LazyAttribute(
+        lambda obj: (getattr(obj, base_attribute) or date.today())
+        + timedelta(days=random.randint(avg_delta_days // 2, avg_delta_days * 3 // 2))
+    )
+
+
+def LazyProjectName() -> LazyFunction:
+    return LazyFunction(
+        lambda: (
+            f"{fake.word().capitalize()} "
+            f"{fake.word().capitalize()} "
+            f"{fake.random_element(elements=('X', 'Z', 'G'))}"
+            f"-{fake.random_int(min=1, max=1000)}"
+        )
+    )
+
+
+def LazyDateToday() -> LazyFunction:
+    return LazyFunction(lambda: date.today())
+
+
+def LazyDateBetween(start_date: date, end_date: date) -> LazyAttribute:
+    delta = (end_date - start_date).days
+    return LazyAttribute(
+        lambda obj: start_date + timedelta(days=random.randint(0, delta))
+    )
+
+
+def LazyDateTimeBetween(start: datetime, end: datetime) -> LazyAttribute:
+    span = (end - start).total_seconds()
+    return LazyAttribute(
+        lambda obj: start + timedelta(seconds=random.randint(0, int(span)))
+    )
+
+
+def LazyInteger(min_value: int, max_value: int) -> LazyFunction:
+    return LazyFunction(lambda: random.randint(min_value, max_value))
+
+
+def LazyDecimal(min_value: float, max_value: float, precision: int = 2) -> LazyFunction:
+    fmt = f"{{:.{precision}f}}"
+    return LazyFunction(
+        lambda: Decimal(fmt.format(random.uniform(min_value, max_value)))
+    )
+
+
+def LazyChoice(options: list[Any]) -> LazyFunction:
+    return LazyFunction(lambda: random.choice(options))
+
+
+def LazySequence(start: int = 0, step: int = 1) -> LazyAttributeSequence:
+    return LazyAttributeSequence(lambda obj, n: start + n * step)
+
+
+def LazyBoolean(trues_ratio: float = 0.5) -> LazyFunction:
+    return LazyFunction(lambda: random.random() < trues_ratio)
+
+
+def LazyUUID() -> LazyFunction:
+    return LazyFunction(lambda: str(uuid.uuid4()))
+
+
+def LazyFakerName() -> LazyFunction:
+    return LazyFunction(lambda: fake.name())
+
+
+def LazyFakerEmail(
+    name: Optional[str] = None, domain: Optional[str] = None
+) -> LazyFunction:
+    if not name and not domain:
+        return LazyFunction(lambda: fake.email(domain=domain))
+    if not name:
+        name = fake.name()
+    if not domain:
+        domain = fake.domain_name()
+    return LazyFunction(lambda: name.replace(" ", "_") + "@" + domain)
+
+
+def LazyFakerSentence(number_of_words: int = 6) -> LazyFunction:
+    return LazyFunction(lambda: fake.sentence(nb_words=number_of_words))
+
+
+def LazyFakerAddress() -> LazyFunction:
+    return LazyFunction(lambda: fake.address())
+
+
+def LazyFakerUrl() -> LazyFunction:
+    return LazyFunction(lambda: fake.url())

{generalmanager-0.3.2 → generalmanager-0.4.1}/src/general_manager/measurement/measurement.py

@@ -46,6 +46,14 @@ class Measurement:
     def quantity(self) -> pint.Quantity:
         return self.__quantity
 
+    @property
+    def magnitude(self) -> Decimal:
+        return self.__quantity.magnitude
+
+    @property
+    def unit(self) -> str:
+        return str(self.__quantity.units)
+
     @classmethod
     def from_string(cls, value: str) -> Measurement:
         value, unit = value.split(" ")

generalmanager-0.4.1/tests/test_factories.py

@@ -0,0 +1,350 @@
+# tests/test_factory_helpers.py
+from datetime import date, datetime, timedelta
+from decimal import Decimal
+
+from django.db import models
+from django.test import TestCase
+from django.core.validators import RegexValidator
+
+from factory.declarations import LazyFunction, LazyAttribute
+from factory.faker import Faker
+from general_manager.factory.factories import getFieldValue, getManyToManyFieldValue
+from general_manager.measurement.measurementField import MeasurementField
+from general_manager.measurement.measurement import Measurement
+from unittest.mock import patch
+
+
+class DummyForeignKey(models.Model):
+    """
+    Dummy ForeignKey model for testing purposes.
+    """
+
+    name = models.CharField(max_length=10, null=False)
+
+    class Meta:
+        app_label = "tests"
+        managed = False
+
+
+class DummyForeignKey2(models.Model):
+    """
+    Dummy ForeignKey model for testing purposes.
+    """
+
+    name = models.CharField(max_length=10, null=False)
+
+    class Meta:
+        app_label = "tests"
+        managed = False
+
+
+class DummyManyToMany(models.Model):
+    """
+    Dummy ManyToMany model for testing purposes.
+    """
+
+    name = models.CharField(max_length=10, null=False)
+
+    class Meta:
+        app_label = "tests"
+        managed = False
+
+
+class DummyModel(models.Model):
+    # String without Regex‐Validator
+    char_field = models.CharField(max_length=10, null=False)
+    text_field = models.TextField(null=False)
+    # String with Regex‐Validator
+    regex_field = models.CharField(
+        max_length=10, null=False, validators=[RegexValidator(r"[A-Z]{3}\d{2}")]
+    )
+    # number types
+    int_field = models.IntegerField(null=False)
+    dec_field = models.DecimalField(max_digits=5, decimal_places=2, null=False)
+    float_field = models.FloatField(null=False)
+    # date/time types
+    date_field = models.DateField(null=False)
+    datetime_field = models.DateTimeField(null=False)
+    duration_field = models.DurationField(null=False)
+    # etc
+    bool_field = models.BooleanField(null=False)
+    email_field = models.EmailField(null=False)
+    url_field = models.URLField(null=False)
+    ip_field = models.GenericIPAddressField(null=False)
+    uuid_field = models.UUIDField(null=False)
+    # MeasurementField
+    measurement_field = MeasurementField(base_unit="kg", null=False)
+    # special fields
+    test_none = models.CharField(max_length=10, null=True)
+    dummy_fk = models.ForeignKey(
+        DummyForeignKey,
+        on_delete=models.CASCADE,
+        null=False,
+    )
+    dummy_one_to_one = models.OneToOneField(
+        DummyForeignKey2,
+        on_delete=models.CASCADE,
+        null=False,
+    )
+    dummy_m2m = models.ManyToManyField(
+        DummyManyToMany,
+        related_name="dummy_m2m",
+        blank=True,
+    )
+
+    class Meta:
+        app_label = "tests"
+        managed = False
+
+
+class TestGetFieldValue(TestCase):
+    def _evaluate(self, declaration):
+        """
+        Evaluate a field declaration to get its value.
+        This is a helper method to handle different types of declarations.
+        """
+        obj = type("DummyModel", (object,), {})()
+        if isinstance(declaration, (LazyFunction, LazyAttribute, Faker)):
+            return declaration.evaluate(obj, None, {"locale": "en_US"})
+        return declaration
+
+    def test_all_not_relational_field_types(self):
+        field_expectations = [
+            # (fieldname, expected_type, optional: regex to match)
+            ("char_field", str, None),
+            ("text_field", str, None),
+            ("regex_field", str, r"^[A-Z]{3}\d{2}$"),
+            ("int_field", int, None),
+            ("dec_field", Decimal, None),
+            ("float_field", float, None),
+            ("date_field", date, None),
+            ("datetime_field", datetime, None),
+            ("duration_field", timedelta, None),
+            ("bool_field", bool, None),
+            ("email_field", str, r"^[^@]+@[^@]+\.[^@]+$"),
+            ("url_field", str, r"^https?://"),
+            ("ip_field", str, r"^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$"),
+            ("uuid_field", str, r"^[0-9a-fA-F-]{36}$"),
+        ]
+
+        for name, expected_type, pattern in field_expectations:
+            with self.subTest(field=name):
+                field = DummyModel._meta.get_field(name)
+                decl = getFieldValue(field)
+
+                self.assertIn(
+                    decl.__class__.__name__,
+                    ("LazyFunction", "LazyAttribute", "NoneType", "Faker"),
+                    msg=f"Unexpected declaration for {name}: {decl!r}",
+                )
+
+                value = self._evaluate(decl)
+
+                self.assertIsInstance(
+                    value,
+                    expected_type,
+                    msg=f"Field {name!r} returned {value!r} ({type(value)})",
+                )
+
+                if pattern:
+                    self.assertRegex(
+                        str(value),
+                        pattern,
+                        msg=f"Value for {name!r} does not match {pattern}",
+                    )
+
+    def test_nullable_field(self):
+        with patch(
+            "general_manager.factory.factories.random.choice",
+            return_value=True,
+        ):
+            field = DummyModel._meta.get_field("test_none")
+            decl = getFieldValue(field)
+            value = self._evaluate(decl)
+            self.assertIsNone(value, msg="Nullable field should return None")
+
+    def test_measurement_field(self):
+        field = DummyModel.measurement_field
+        decl = getFieldValue(field)
+        self.assertIsInstance(decl, LazyFunction)
+        value = decl.evaluate(None, None, None)  # type: ignore
+        self.assertIsInstance(value, Measurement)
+        self.assertIsInstance(value.magnitude, Decimal)
+        self.assertIsInstance(value.unit, str)
+
+
+class TestRelationFieldValue(TestCase):
+    def setUp(self):
+        # Aufräumen: kein _general_manager_class voraussetzen
+        for M in (DummyForeignKey, DummyForeignKey2):
+            if hasattr(M, "_general_manager_class"):
+                delattr(M, "_general_manager_class")
+
+    def test_fk_with_factory_new_instance(self):
+        # 1) _general_manager_class.Factory liefert direkt ein Objekt
+        dummy = DummyForeignKey(name="foo")
+
+        class GMC:
+            pass
+
+        GMC.Factory = lambda **kwargs: dummy  # type: ignore
+        DummyForeignKey._general_manager_class = GMC  # type: ignore
+        with patch(
+            "general_manager.factory.factoryMethods.random.choice", return_value=True
+        ):
+
+            field = DummyModel._meta.get_field("dummy_fk")
+            result = getFieldValue(field)
+            # Hier kommt kein LazyFunction, sondern direkt das factory-Ergebnis
+            self.assertIs(result, dummy)
+
+    def test_fk_with_factory_existing_instance(self):
+        dummy1 = DummyForeignKey(name="a")
+        dummy2 = DummyForeignKey(name="b")
+        field = DummyModel._meta.get_field("dummy_fk")
+
+        class GMC:
+            pass
+
+        GMC.Factory = lambda **kwargs: dummy1  # type: ignore
+        DummyForeignKey._general_manager_class = GMC  # type: ignore
+
+        with (
+            patch(
+                "general_manager.factory.factories.random.choice",
+                return_value=False,
+            ),
+            patch.object(DummyForeignKey.objects, "all", return_value=[dummy1, dummy2]),
+        ):
+            decl = getFieldValue(field)
+            self.assertIsInstance(decl, LazyFunction)
+        inst = decl.evaluate(None, None, None)  # type: ignore
+        self.assertIn(inst, (dummy1, dummy2))
+
+    def test_one_to_one_with_factory(self):
+        dummy = DummyForeignKey2(name="bar")
+
+        class GMC2:
+            pass
+
+        GMC2.Factory = lambda **kwargs: dummy  # type: ignore
+        DummyForeignKey2._general_manager_class = GMC2  # type: ignore
+
+        field = DummyModel._meta.get_field("dummy_one_to_one")
+        result = getFieldValue(field)
+        self.assertIs(result, dummy)
+
+    def test_fk_without_factory_with_existing_instances(self):
+        # 2) kein factory, aber vorhandene Objekte → LazyFunction
+        dummy1 = DummyForeignKey(name="a")
+        dummy2 = DummyForeignKey(name="b")
+        field = DummyModel._meta.get_field("dummy_fk")
+
+        with patch.object(
+            DummyForeignKey.objects, "all", return_value=[dummy1, dummy2]
+        ):
+            decl = getFieldValue(field)
+            self.assertIsInstance(decl, LazyFunction)
+            # beim Evaluieren sollte eins der beiden Objekte zurückkommen
+            inst = decl.evaluate(None, None, None)  # type: ignore
+            self.assertIn(inst, (dummy1, dummy2))
+
+    def test_one_to_one_without_factory_with_existing_instances(self):
+        dummy1 = DummyForeignKey2(name="x")
+        dummy2 = DummyForeignKey2(name="y")
+        field = DummyModel._meta.get_field("dummy_one_to_one")
+
+        with patch.object(
+            DummyForeignKey2.objects, "all", return_value=[dummy1, dummy2]
+        ):
+            decl = getFieldValue(field)
+            self.assertIsInstance(decl, LazyFunction)
+            inst = decl.evaluate(None, None, None)  # type: ignore
+            self.assertIn(inst, (dummy1, dummy2))
+
+    def test_fk_without_factory_and_no_instances_raises(self):
+        field = DummyModel._meta.get_field("dummy_fk")
+        with (
+            patch.object(DummyForeignKey.objects, "all", return_value=[]),
+            self.assertRaisesMessage(
+                ValueError, "No factory found for DummyForeignKey"
+            ),
+        ):
+            getFieldValue(field)
+
+    def test_one_to_one_without_factory_and_no_instances_raises(self):
+        field = DummyModel._meta.get_field("dummy_one_to_one")
+        with (
+            patch.object(DummyForeignKey2.objects, "all", return_value=[]),
+            self.assertRaisesMessage(
+                ValueError, "No factory found for DummyForeignKey2"
+            ),
+        ):
+            getFieldValue(field)
+
+
+class TestGetManyToManyFieldValue(TestCase):
+    def setUp(self):
+        # tidy up: no _general_manager_class assumed
+        for M in (DummyManyToMany, DummyModel):
+            if hasattr(M, "_general_manager_class"):
+                delattr(M, "_general_manager_class")
+
+    def test_m2m_with_factory_and_existing(self):
+        dummy1 = DummyManyToMany(name="foo", id=1)
+        dummy2 = DummyManyToMany(name="bar", id=2)
+
+        class GMC:
+            pass
+
+        GMC.Factory = lambda **kwargs: dummy1  # type: ignore
+        DummyManyToMany._general_manager_class = GMC  # type: ignore
+
+        field = DummyModel._meta.get_field("dummy_m2m")
+        with patch.object(
+            field.related_model.objects, "all", return_value=[dummy1, dummy2]  # type: ignore
+        ):
+            result = getManyToManyFieldValue(field)  # type: ignore
+        self.assertIsInstance(result, list)
+        self.assertTrue(
+            set(result).issubset({dummy1, dummy2}),
+            "Returned instances are not a subset of existing objects",
+        )
+
+    def test_m2m_with_factory(self):
+        dummy1 = DummyManyToMany(name="foo", id=1)
+
+        class GMC:
+            pass
+
+        GMC.Factory = lambda **kwargs: dummy1  # type: ignore
+        DummyManyToMany._general_manager_class = GMC  # type: ignore
+
+        field = DummyModel._meta.get_field("dummy_m2m")
+        with patch.object(field.related_model.objects, "all", return_value=[]):  # type: ignore
+            result = getManyToManyFieldValue(field)  # type: ignore
+        self.assertIsInstance(result, list)
+        self.assertIn(dummy1, result)
+
+    def test_m2m_without_factory(self):
+        dummy1 = DummyManyToMany(name="foo", id=1)
+        dummy2 = DummyManyToMany(name="bar", id=2)
+
+        field = DummyModel._meta.get_field("dummy_m2m")
+        with patch.object(
+            field.related_model.objects, "all", return_value=[dummy1, dummy2]  # type: ignore
+        ):
+            result = getManyToManyFieldValue(field)  # type: ignore
+        self.assertIsInstance(result, list)
+        self.assertTrue(
+            set(result).issubset({dummy1, dummy2}),
+            "Returned instances are not a subset of existing objects",
+        )
+
+    def test_m2m_without_factory_and_no_instances_raises(self):
+        field = DummyModel._meta.get_field("dummy_m2m")
+        with (
+            patch.object(field.related_model.objects, "all", return_value=[]),  # type: ignore
+            self.assertRaises(ValueError),
+        ):
+            getManyToManyFieldValue(field)  # type: ignore

generalmanager-0.4.1/tests/test_factoryMethods.py

@@ -0,0 +1,228 @@
+from django.test import SimpleTestCase
+from general_manager.factory.factoryMethods import (
+    LazyMeasurement,
+    LazyDeltaDate,
+    LazyProjectName,
+    LazyDateToday,
+    LazyDateBetween,
+    LazyDateTimeBetween,
+    LazyInteger,
+    LazyDecimal,
+    LazyUUID,
+    LazyBoolean,
+    LazyFakerName,
+    LazyFakerEmail,
+    LazyFakerSentence,
+    LazyFakerAddress,
+    LazyFakerUrl,
+    LazyChoice,
+    LazySequence,
+)
+from general_manager.measurement.measurement import Measurement
+from datetime import date, datetime
+from decimal import Decimal
+from types import SimpleNamespace
+
+
+class TestFactoryMethods(SimpleTestCase):
+    def test_LazyMeasurement(self):
+        min_value = 10.0
+        max_value = 30.5
+        unit = "kilogram"
+        obj = type("TestObject", (object,), {})()
+        for i in range(100):
+            with self.subTest(run=i):
+                measurement = LazyMeasurement(min_value, max_value, unit).evaluate(
+                    obj, 1, None
+                )
+                self.assertIsInstance(measurement, Measurement)
+                self.assertTrue(min_value <= float(measurement.magnitude) <= max_value)
+                self.assertEqual(measurement.unit, unit)
+
+    def test_LazyDeltaDate(self):
+        avg_delta_days = 5  # -> 2.5 to 7.5 days
+        base_attribute = "start_date"
+        obj = type("TestObject", (object,), {base_attribute: date(2023, 1, 1)})()
+        for i in range(100):
+            with self.subTest(run=i):
+                delta_date = LazyDeltaDate(avg_delta_days, base_attribute).evaluate(
+                    obj, 1, None
+                )
+                self.assertIsInstance(delta_date, date)
+                self.assertTrue(
+                    date(2023, 1, 1) <= delta_date <= date(2023, 1, 8),
+                    f"Run {i}: {delta_date} is not in the expected range.",
+                )
+
+    def test_LazyProjectName(self):
+        obj = type("TestObject", (object,), {})()
+        for i in range(100):
+            with self.subTest(run=i):
+                project_name = LazyProjectName().evaluate(obj, 1, None)
+                self.assertIsInstance(project_name, str)
+
+    def test_LazyDateToday(self):
+        obj = type("TestObject", (object,), {})()
+        for i in range(100):
+            with self.subTest(run=i):
+                date_today = LazyDateToday().evaluate(obj, 1, None)
+                self.assertIsInstance(date_today, date)
+                self.assertEqual(date_today, date.today())
+
+    def test_LazyDateBetween(self):
+        start_date = date(2023, 1, 1)
+        end_date = date(2023, 12, 31)
+        obj = type("TestObject", (object,), {})()
+        for i in range(100):
+            with self.subTest(run=i):
+                date_between = LazyDateBetween(start_date, end_date).evaluate(
+                    obj, 1, None
+                )
+                self.assertIsInstance(date_between, date)
+                self.assertTrue(
+                    start_date <= date_between <= end_date,
+                    f"Run {i}: {date_between} is not in the expected range.",
+                )
+
+    def test_LazyDateTimeBetween(self):
+        start = datetime(2023, 1, 1)
+        end = datetime(2023, 12, 31)
+        obj = type("TestObject", (object,), {})()
+        for i in range(100):
+            with self.subTest(run=i):
+                datetime_between = LazyDateTimeBetween(start, end).evaluate(
+                    obj, 1, None
+                )
+                self.assertIsInstance(datetime_between, datetime)
+                self.assertTrue(
+                    start <= datetime_between <= end,
+                    f"Run {i}: {datetime_between} is not in the expected range.",
+                )
+
+    def test_LazyInteger(self):
+        min_value = 1
+        max_value = 100
+        obj = type("TestObject", (object,), {})()
+        for i in range(100):
+            with self.subTest(run=i):
+                integer_value = LazyInteger(min_value, max_value).evaluate(obj, 1, None)
+                self.assertIsInstance(integer_value, int)
+                self.assertTrue(min_value <= integer_value <= max_value)
+
+    def test_LazyDecimal(self):
+        min_value = 1.0
+        max_value = 100.0
+        precision = 4
+        obj = type("TestObject", (object,), {})()
+        for i in range(100):
+            with self.subTest(run=i):
+                decimal_value = LazyDecimal(min_value, max_value, precision).evaluate(
+                    obj, 1, None
+                )
+                self.assertIsInstance(decimal_value, Decimal)
+                self.assertTrue(
+                    Decimal(min_value) <= decimal_value <= Decimal(max_value)
+                )
+                decimal_str = format(decimal_value, "f")
+                if "." in decimal_str:
+                    self.assertEqual(len(decimal_str.split(".")[1]), precision)
+
+    def test_LazyUUID(self):
+        obj = type("TestObject", (object,), {})()
+        for i in range(100):
+            with self.subTest(run=i):
+                uuid_value = LazyUUID().evaluate(obj, 1, None)
+                self.assertIsInstance(uuid_value, str)
+                self.assertRegex(
+                    uuid_value,
+                    r"^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$",
+                )
+
+    def test_LazyBoolean(self):
+        obj = type("TestObject", (object,), {})()
+        for i in range(100):
+            with self.subTest(run=i):
+                boolean_value = LazyBoolean().evaluate(obj, 1, None)
+                self.assertIsInstance(boolean_value, bool)
+
+    def test_LazyFakerName(self):
+        obj = type("TestObject", (object,), {})()
+        for i in range(100):
+            with self.subTest(run=i):
+                name_value = LazyFakerName().evaluate(obj, 1, None)
+                self.assertIsInstance(name_value, str)
+                self.assertTrue(len(name_value) > 0)
+
+    def test_LazyFakerEmail(self):
+        obj = type("TestObject", (object,), {})()
+        for i in range(100):
+            with self.subTest(run=i):
+                email_value = LazyFakerEmail().evaluate(obj, 1, None)
+                self.assertIsInstance(email_value, str)
+                self.assertRegex(email_value, r"^[\w\.-]+@[\w\.-]+\.\w+$")
+
+    def test_LazyFakerEmail_with_presets(self):
+        obj = type("TestObject", (object,), {})()
+        names = [
+            "John Doe",
+            "Jane Smith",
+            "Alice Johnson",
+            "Bob Brown",
+            "Charlie Davis Jr.",
+            None,
+            None,
+        ]
+        domains = ["example.com", None]
+        for i, name in enumerate(names):
+            domain = domains[i % len(domains)]
+            with self.subTest(run=i):
+                email_value = LazyFakerEmail(name, domain).evaluate(obj, 1, None)
+                self.assertIsInstance(email_value, str)
+                self.assertRegex(email_value, r"^[\w\.-]+@[\w\.-]+\.\w+$")
+
+    def test_LazyFakerSentence(self):
+        obj = type("TestObject", (object,), {})()
+        for i in range(100):
+            with self.subTest(run=i):
+                sentence_value = LazyFakerSentence().evaluate(obj, 1, None)
+                self.assertIsInstance(sentence_value, str)
+                self.assertTrue(len(sentence_value) > 0)
+
+    def test_LazyFakerAddress(self):
+        obj = type("TestObject", (object,), {})()
+        for i in range(100):
+            with self.subTest(run=i):
+                address_value = LazyFakerAddress().evaluate(obj, 1, None)
+                self.assertIsInstance(address_value, str)
+                self.assertTrue(len(address_value) > 0)
+
+    def test_LazyFakerUrl(self):
+        obj = type("TestObject", (object,), {})()
+        for i in range(100):
+            with self.subTest(run=i):
+                url_value = LazyFakerUrl().evaluate(obj, 1, None)
+                self.assertIsInstance(url_value, str)
+                self.assertRegex(url_value, r"^https?://[^\s/$.?#].[^\s]*$")
+                self.assertTrue(len(url_value) > 0)
+
+    def test_LazyChoice(self):
+        options = ["option1", "option2", "option3"]
+        obj = type("TestObject", (object,), {})()
+        for i in range(100):
+            with self.subTest(run=i):
+                choice_value = LazyChoice(options).evaluate(obj, 1, None)
+                self.assertIn(choice_value, options)
+                self.assertIsInstance(choice_value, str)
+                self.assertTrue(len(choice_value) > 0)
+
+    def test_LazySequence(self):
+        start = 0
+        step = 2
+        obj = type("TestObject", (object,), {})()
+
+        for i in range(100):
+            with self.subTest(run=i):
+                context = SimpleNamespace(sequence=i)
+                sequence_value = LazySequence(start, step).evaluate(obj, context, None)
+                self.assertEqual(sequence_value, start + i * step)
+                self.assertIsInstance(sequence_value, int)

{generalmanager-0.3.2 → generalmanager-0.4.1}/tests/test_noneToZero.py

@@ -1,9 +1,9 @@
-from django.test import TestCase
+from django.test import SimpleTestCase
 from general_manager.auxiliary.noneToZero import noneToZero
 from general_manager.measurement import Measurement
 
 
-class TestNoneToZero(TestCase):
+class TestNoneToZero(SimpleTestCase):
 
     def test_none_to_zero(self):
         """

generalmanager-0.3.2/src/general_manager/factory/lazy_methods.py

@@ -1,38 +0,0 @@
-from typing import Any
-from factory.declarations import LazyFunction, LazyAttribute, LazyAttributeSequence
-import random
-from general_manager.measurement.measurement import Measurement
-from datetime import timedelta, date
-from faker import Faker
-
-fake = Faker()
-
-
-def LazyMeasurement(
-    min_value: int | float, max_value: int | float, unit: str
-) -> LazyFunction:
-    return LazyFunction(
-        lambda: Measurement(str(random.uniform(min_value, max_value))[:10], unit)
-    )
-
-
-def LazyDeltaDate(avg_delta_days: int, base_attribute: str) -> LazyAttribute:
-    return LazyAttribute(
-        lambda obj: (getattr(obj, base_attribute) or date.today())
-        + timedelta(days=random.randint(avg_delta_days // 2, avg_delta_days * 3 // 2))
-    )
-
-
-def LazyProjectName() -> LazyFunction:
-    return LazyFunction(
-        lambda: (
-            f"{fake.word().capitalize()} "
-            f"{fake.word().capitalize()} "
-            f"{fake.random_element(elements=('X', 'Z', 'G'))}"
-            f"-{fake.random_int(min=1, max=1000)}"
-        )
-    )
-
-
-def LazySapNumber() -> LazyAttributeSequence:
-    return LazyAttributeSequence(lambda obj, n: f"60{n:04d}")