Alice

Alice is a PHP test data generator and fixture library used to automate the creation of large sets of fake objects and entities. It functions as an object hydrator and random data provider, allowing users to define the structure and attributes of dummy test data in markup or arrays to simulate specific application states.

The library distinguishes itself through a template-based system that supports fixture inheritance to reduce data duplication. It utilizes a flexible instantiation model that allows for custom factory integration, method invocation, and property hydration via reflection or custom setters to control how objects are born and populated.

Its capabilities cover relational mapping to establish dependencies between fixtures, bulk generation of data collections, and the use of probabilistic value assignment to simulate variability. The system also integrates random data providers to ensure localized values and unique constraints across datasets.

Features

Test Data Generators - Generates large sets of fake objects and entities using configurable templates and random providers.

Complex Test Data Fixtures - Creates large sets of fake test data using expressive definitions to simulate complex application states.

Fixture Libraries - Provides a framework for defining the structure and attributes of dummy test entities to automate state creation.

Object Factories - Acts as an object hydrator and factory to generate test data and object fixtures.

Entity Relationship Definitions - Defines associations between data entities using references and properties to simulate complex dependencies.

Relational Data Generation - Generates interdependent entity graphs by referencing other objects via IDs or wildcards.

Instance Linking - Connects fixtures to one another by referencing specific object names or the current instance.

Fixture Blueprint Templates - Creates non-persisted base fixtures that serve as blueprints to reduce value duplication.

Template Inheritance - Implements a hierarchy of fixture templates where child definitions inherit and override base attributes.

Random Provider Integrations - Integrates external libraries to generate realistic random values with support for unique constraints and seeds.

Test Data Generators - Produces realistic, localized test values such as addresses and phone numbers using data providers.

Dynamic Object Instantiation - Instantiates class instances directly from hierarchical fixture configuration values.

Automated Test Data Generation - Dynamically generates large sets of fake objects and entities as an alternative to static fixtures.

Test Fixture Management - Manages the definition and loading of complex test data with relational dependencies to simulate application states.

Randomized Data Simulation - Produces varied and realistic test values using data providers and probability to simulate real-world user input and edge cases.

Relational Fixture Linking - Enables the creation of complex relational dependencies between generated test entities.

Random Value Generators - Uses a registry of pluggable providers to generate localized and constrained random values for test inputs.

Fixture Definitions - Describes the structure and attributes of test entities in markup or arrays to automate state creation.

Uniqueness Enforcement - Ensures generated values for specific properties remain unique across all instances to satisfy database constraints.

Property Extraction - Retrieves specific property values from referenced fixtures to populate dependent fields.

Data Generation Expression Evaluation - Computes object field values at runtime using arithmetic operations and property references.

Custom Generation Provider Registration - Allows the registration of user-defined provider classes to extend the random value generation logic.

Bulk Property Assignments - Assigns values to fields using direct property access, custom setters, or reflection for private members.

Expression Evaluators - Computes values during generation using arithmetic operations and references to collection indices.

Internal Property References - Ensures logical consistency by allowing properties to reference other values within the same generated object.

Probabilistic Assignments - Simulates variability by assigning one of multiple possible values based on defined percentage chances.

Custom Object Hydration - Supports custom accessors and hydrators to control exactly how values are assigned to object properties.

Custom Object Instantiation - Allows replacing default instantiation logic with custom factories to control how test objects are created.

Fixture Reference Injection - Injects references of existing fixtures into custom data providers to create dynamic, interrelated test data.

Lifecycle Method Execution - Triggers specific non-setter methods on generated objects during the data hydration process.

Dynamic Property Mapping - Uses reflection to map and assign values to object properties regardless of visibility or setter availability.

State-Triggering Method Invocations - Calls specific methods on generated objects with defined arguments to set state or trigger logic.

Bulk Test Record Generation - Generates multiple copies of objects using numeric ranges or value lists to avoid manual duplication.

Collection Generation - Creates arrays of values using fixed lists, repeated patterns, or evaluated expressions.

Database Object Mocking - Generates objects with specific properties and method calls to establish known states for integration tests.

Dynamic Value Generation - Evaluates parameters, functions, and expressions to populate object fields with variable data during generation.

Data Pattern Definitions - Uses notation and expression language to specify ranges and sets for generating multiple related objects.

Optional Value Generators - Simulates missing or optional data by generating values based on weighted percentage chances.

Testing and Quality - Expressive fixture generation library.

nelmioalice

Features

Star history