AutoFaker

AutoFaker is a Python library designed to minimize the setup/arrange phase of your unit tests by removing the need to manually write code to create anonymous variables as part of a test cases setup/arrange phase.

This library is heavily inspired by AutoFixture and was initially created for simplifying how to write unit tests for ETL (Extract-Transform-Load) code running from a python library on an Apache Spark cluster in Big Data solutions.

When writing unit tests you normally start with creating objects that represent the initial state of the test. This phase is called the arrange or setup phase of the test. In most cases, the system you want to test will force you to specify much more information than you really care about, so you frequently end up creating objects with no influence on the test itself just simply to satisfy the compiler/interpreter

AutoFaker is available from PyPI and should be installed using pip

pip install autofaker

AutoFaker can help by creating such anonymous variables for you. Here's a simple example:

import unittest
from autofaker import Autodata

class Calculator:
  def add(self, number1: int, number2: int):
    return number1 + number2

class CalculatorTests(unittest.TestCase):
    def test_can_add_two_numbers(self):      
        # arrange
        numbers = Autodata.create_many(int, 2)
        sut = Autodata.create(Calculator)        
        # act
        result = sut.add(numbers[0], numbers[1])        
        # assert
        self.assertEqual(numbers[0] + numbers[1], result)

Since the point of this library is to simplify the arrange step of writing unit tests, we can use the @autodata and @fakedata are available to explicitly state whether to use anonymous variables or fake data and construct our system under test. To use this you can either define the types or the arguments as function arguments to the decorator, or specify argument annotations

import unittest
from autofaker import autodata

class Calculator:
  def add(self, number1: int, number2: int):
    return number1 + number2

class CalculatorTests(unittest.TestCase):
    @autodata(Calculator, int, int)
    def test_can_add_two_numbers_using_test_arguments(self, sut, number1, number2):
        result = sut.add(number1, number2)
        self.assertEqual(number1 + number2, result)

    @autodata()
    def test_can_add_two_numbers_using_annotated_arguments(self, 
                                                           sut: Calculator, 
                                                           number1: int, 
                                                           number2: int):
        result = sut.add(number1, number2)
        self.assertEqual(number1 + number2, result)

There are times when completely anonymous variables don't make much sense, especially in data centric scenarios. For these use cases this library uses Faker for generating fake data. This option is enabled by setting use_fake_data to True when calling the Autodata.create() function

from dataclasses import dataclass
from autofaker import Autodata

@dataclass
class DataClass:
    id: int
    first_name: str
    last_name: str
    job: str

data = Autodata.create(DataClass, use_fake_data=True)

print(f'id:     {data.id}')
print(f'name:   {data.first_name} {data.last_name}')
print(f'job:    {data.job}\n')

The following code above might output something like:

id:     8952
name:   Justin Wise
job:    Chief Operating Officer

Supported OS and Python versions

Windows	MacOS	Linux

Supported data types

Currently autofaker supports creating anonymous variables for the following data types:

Built-in types:

int
float
str
complex
range
bytes
bytearray
tuple
set
frozenset
dict
decimal.Decimal
uuid.UUID
pathlib.Path

Datetime types:

datetime
date
time
timedelta

Typing generics:

typing.Tuple[T, ...]
typing.Set[T]
typing.FrozenSet[T]
typing.Dict[K, V]
typing.Optional[T]
typing.List[T]

Classes:

Simple classes
@dataclass
Nested classes (and recursion)
Classes containing lists of other types
Enum classes
typing.Literal types

Dataframes:

Pandas dataframe

Example usages

Create anonymous built-in types like int, float, str and datetime types like datetime and date

print(f'anonymous string:    {Autodata.create(str)}')
print(f'anonymous int:       {Autodata.create(int)}')
print(f'anonymous float:     {Autodata.create(float)}')
print(f'anonymous complex:   {Autodata.create(complex)}')
print(f'anonymous range:     {Autodata.create(range)}')
print(f'anonymous bytes:     {Autodata.create(bytes)}')
print(f'anonymous bytearray: {Autodata.create(bytearray)}')
print(f'anonymous datetime:  {Autodata.create(datetime)}')
print(f'anonymous date:      {Autodata.create(datetime.date)}')