Add mockapi source files and tests

src/mockapi/core/generators.py

@@ -11,12 +11,7 @@ class DataGenerator:
     """Generates realistic random test data from JSON schemas."""
 
     def __init__(self, seed: Optional[int] = None, schemas: Optional[Dict[str, Any]] = None):
-        """Initialize the data generator.
-
-        Args:
-            seed: Random seed for reproducible data generation
-            schemas: Dictionary of schemas for $ref resolution
-        """
+        """Initialize the data generator."""
         self.seed = seed
         self.faker = Faker()
         if seed is not None:
@@ -46,8 +41,8 @@ class DataGenerator:
             "text": lambda: self.faker.text(),
             "username": lambda: self.faker.user_name(),
             "password": lambda: self.faker.password(),
-            "ip_v4": lambda: self.faker.ipv4(),
-            "ip_v6": lambda: self.faker.ipv6(),
+            "ipv4": lambda: self.faker.ipv4(),
+            "ipv6": lambda: self.faker.ipv6(),
             "slug": lambda: self.faker.slug(),
             "color": lambda: self.faker.color_name(),
             "currency": lambda: self.faker.currency()[0],
@@ -55,14 +50,7 @@ class DataGenerator:
         }
 
     def generate(self, schema: Dict[str, Any]) -> Any:
-        """Generate data from a JSON schema.
-
-        Args:
-            schema: JSON schema definition
-
-        Returns:
-            Generated data matching the schema
-        """
+        """Generate data from a JSON schema."""
         if not schema or not isinstance(schema, dict):
             return None
 
@@ -89,16 +77,8 @@ class DataGenerator:
         return None
 
     def _resolve_ref(self, ref: str) -> Any:
-        """Resolve a $ref reference.
-
-        Args:
-            ref: Reference string like #/components/schemas/User
-
-        Returns:
-            Resolved schema or None
-        """
+        """Resolve a $ref reference."""
         parts = ref.lstrip("#/").split("/")
-        
         skip_prefixes = ["components", "schemas"]
         start_idx = 0
         for i, part in enumerate(parts):
@@ -106,23 +86,17 @@ class DataGenerator:
                 start_idx = i + 1
             else:
                 break
-        
         parts = parts[start_idx:]
-        
         if not parts:
             return None
-            
         current = self._schemas_dict
-
         for part in parts:
             if isinstance(current, dict):
                 current = current.get(part, {})
             else:
                 return None
-
         if isinstance(current, dict):
             return self.generate(current)
-
         return current
 
     def _generate_boolean(self, schema: Dict[str, Any]) -> bool:
@@ -135,7 +109,6 @@ class DataGenerator:
         """Generate a random integer."""
         if "enum" in schema:
             return random.choice(schema["enum"])
-
         minimum = schema.get("minimum", 0)
         maximum = schema.get("maximum", 10000)
         return random.randint(int(minimum), int(maximum))
@@ -144,7 +117,6 @@ class DataGenerator:
         """Generate a random number."""
         if "enum" in schema:
             return random.choice(schema["enum"])
-
         minimum = schema.get("minimum", 0.0)
         maximum = schema.get("maximum", 10000.0)
         return random.uniform(float(minimum), float(maximum))
@@ -153,46 +125,33 @@ class DataGenerator:
         """Generate a random string."""
         if "enum" in schema:
             return random.choice(schema["enum"])
-
         format_type = schema.get("format", "")
-
         if format_type in self._faker_providers:
             return self._faker_providers[format_type]()
-
         if "pattern" in schema:
             return self._generate_by_pattern(schema["pattern"])
-
         min_length = schema.get("minLength", 1)
         max_length = schema.get("maxLength", 255)
-
         return self.faker.text(max_nb_chars=random.randint(min_length, max_length))
 
     def _generate_by_pattern(self, pattern: str) -> str:
-        """Generate a string matching a regex pattern.
-
-        This is a simplified implementation.
-        """
+        """Generate a string matching a regex pattern."""
         return self.faker.word()
 
     def _generate_array(self, schema: Dict[str, Any]) -> List[Any]:
         """Generate a random array."""
         items = schema.get("items", {})
-
         min_items = schema.get("minItems", 1)
         max_items = schema.get("maxItems", 10)
         count = random.randint(int(min_items), int(max_items))
-
         return [self.generate(items) for _ in range(count)]
 
     def _generate_object(self, schema: Dict[str, Any]) -> Dict[str, Any]:
         """Generate a random object."""
         properties = schema.get("properties", {})
-
         result = {}
-
         for prop_name, prop_schema in properties.items():
             result[prop_name] = self.generate(prop_schema)
-
         additional_props = schema.get("additionalProperties")
         if additional_props and isinstance(additional_props, dict):
             min_props = schema.get("minProperties", 0)
@@ -200,5 +159,4 @@ class DataGenerator:
             count = random.randint(int(min_props), int(max_props))
             for _ in range(count):
                 result[self.faker.word()] = self.generate(additional_props)
-
-        return result
+        return result