Fixture Monkey

https://naver.github.io/fixture-monkey/
Admin
Fixture Monkey is a Java & Kotlin library designed to generate controllable arbitrary test objects...
Tokens:86,912
Snippets:1,005
Trust Score:9.7
Update:4 months ago
Show doc for...
Tokens:
Raw
### Example Product Object Output

Source: https://naver.github.io/fixture-monkey/docs/get-started/creating-objects

An example of a generated Product object. Actual values will vary.

```java
Product(
    id=42,
    productName="product-value-1",
    price=1000,
    options=["option1", "option2"],
    createdAt=2024-03-21T10:15:30Z,
    productType=ELECTRONICS,
    merchantInfo={1="merchant1", 2="merchant2"}
)

```

--------------------------------

### Setup SimpleValueJqwikPlugin

Source: https://naver.github.io/fixture-monkey/docs/plugins/simple-value-plugin/features

Basic setup for integrating the SimpleValueJqwikPlugin into Fixture Monkey.

```kotlin
val fixtureMonkey = FixtureMonkey.builder()  
    .plugin(SimpleValueJqwikPlugin())  
    .build()  

```

--------------------------------

### Recommended Setup with FailoverIntrospector

Source: https://naver.github.io/fixture-monkey/docs/generating-objects/introspector

This setup combines multiple strategies to handle different class types, making it suitable for most real-world projects without additional configuration.

```java
// given  
FixtureMonkey fixtureMonkey = FixtureMonkey.builder()  
	.objectIntrospector(new FailoverIntrospector(  
		Arrays.asList(  
			ConstructorPropertiesArbitraryIntrospector.INSTANCE,  
			BuilderArbitraryIntrospector.INSTANCE,  
			FieldReflectionArbitraryIntrospector.INSTANCE,  
			BeanArbitraryIntrospector.INSTANCE  
		),  
		false  
	))  
	.build();  
  
// when  
Customer customer = fixtureMonkey.giveMeOne(Customer.class);  
  
// then  
then(customer).isNotNull();  

```

--------------------------------

### Setup Jackson Plugin (Kotlin)

Source: https://naver.github.io/fixture-monkey/docs/plugins/jackson-plugin/features

Initialize Fixture Monkey with the Jackson and Kotlin plugins for Kotlin projects.

```kotlin
val fixtureMonkey = FixtureMonkey.builder()  
    .plugin(KotlinPlugin())  
    .plugin(JacksonPlugin())  
    .build()  

```

--------------------------------

### Setup Jackson Plugin (Java)

Source: https://naver.github.io/fixture-monkey/docs/plugins/jackson-plugin/features

Initialize Fixture Monkey with the Jackson plugin for Java projects.

```java
FixtureMonkey fixtureMonkey = FixtureMonkey.builder()  
    .plugin(new JacksonPlugin())  
    .build();  

```

--------------------------------

### Java: Encapsulate Fixture Setup with Helper Methods

Source: https://naver.github.io/fixture-monkey/docs/cheat-sheet/best-practices

Use helper methods to return ArbitraryBuilder instances for common fixture setups. This allows for flexible customization within tests and promotes code reuse. Customize specific fields using .set() and define collection sizes with .size().

```java
import org.junit.jupiter.api.Test;
import com.navercorp.fixturemonkey.ArbitraryBuilder;
import com.navercorp.fixturemonkey.FixtureMonkey;
import com.navercorp.fixturemonkey.api.int.IntegerArbitraryBuilder;
import static org.assertj.core.api.Assertions.assertThat;

class OrderServiceTest {

    private final FixtureMonkey fixtureMonkey = FixtureMonkey.create();
    private final OrderService orderService = new OrderService();

    @Test
    void testOrderProcessing() {
        // Helper methods returning ArbitraryBuilder for more flexibility
        Order standardOrder = standardOrderBuilder()
            .set("customerNote", "Please deliver quickly")  // Test-specific customization
            .sample();

        Customer premiumCustomer = premiumCustomerBuilder()
            .set("membershipYears", 5)  // Test-specific customization
            .sample();

        OrderResult result = orderService.process(standardOrder, premiumCustomer);

        assertThat(result.hasDiscount()).isTrue();
        assertThat(result.getDiscount()).isGreaterThanOrEqualTo(standardOrder.getTotalAmount() * 0.1);
    }

    // Helper methods return ArbitraryBuilder instead of instances
    private ArbitraryBuilder<Order> standardOrderBuilder() {
        return fixtureMonkey.giveMeBuilder(Order.class)
            .size("items", 3, 5)
            .set("totalAmount", Arbitraries.integers().between(100, 500));
    }

    private ArbitraryBuilder<Customer> premiumCustomerBuilder() {
        return fixtureMonkey.giveMeBuilder(Customer.class)
            .set("premiumMember", true)
            .set("membershipYears", 2);
    }

    @Test
    void testOrderWithSpecialDiscount() {
        // Reuse the same builder with different customizations
        Order bulkOrder = standardOrderBuilder()
            .size("items", 10, 20)  // Different configuration for this test
            .set("totalAmount", Arbitraries.integers().between(500, 1000))
            .sample();

        Customer vipCustomer = premiumCustomerBuilder()
            .set("membershipYears", 10)  // Different configuration for this test
            .set("vipStatus", true)
            .sample();

        OrderResult result = orderService.processWithSpecialDiscount(bulkOrder, vipCustomer);

        assertThat(result.getDiscount()).isGreaterThanOrEqualTo(bulkOrder.getTotalAmount() * 0.2);
    }
}

// Dummy classes for compilation
class Order {
    private String customerNote;
    private int totalAmount;
    private java.util.List<String> items;

    public String getCustomerNote() { return customerNote; }
    public void setCustomerNote(String customerNote) { this.customerNote = customerNote; }
    public int getTotalAmount() { return totalAmount; }
    public void setTotalAmount(int totalAmount) { this.totalAmount = totalAmount; }
    public java.util.List<String> getItems() { return items; }
    public void setItems(java.util.List<String> items) { this.items = items; }
}

class Customer {
    private int membershipYears;
    private boolean premiumMember;
    private boolean vipStatus;

    public int getMembershipYears() { return membershipYears; }
    public void setMembershipYears(int membershipYears) { this.membershipYears = membershipYears; }
    public boolean isPremiumMember() { return premiumMember; }
    public void setPremiumMember(boolean premiumMember) { this.premiumMember = premiumMember; }
    public boolean isVipStatus() { return vipStatus; }
    public void setVipStatus(boolean vipStatus) { this.vipStatus = vipStatus; }
}

class OrderResult {
    private boolean discount;
    private double discountAmount;

    public boolean hasDiscount() { return discount; }
    public void setDiscount(boolean discount) { this.discount = discount; }
    public double getDiscount() { return discountAmount; }
    public void setDiscount(double discountAmount) { this.discountAmount = discountAmount; }
}

class OrderService {
    public OrderResult process(Order order, Customer customer) { return new OrderResult(); }
    public OrderResult processWithSpecialDiscount(Order order, Customer customer) { return new OrderResult(); }
}

class Arbitraries {
    public static IntegerArbitraryBuilder integers() { return null; }
    public static class IntegerArbitraryBuilder {
        public IntegerArbitraryBuilder between(int min, int max) { return this; }
    }
}

```

--------------------------------

### Start with Simple Objects

Source: https://naver.github.io/fixture-monkey/docs/get-started/tips

Begin generating test data with basic objects before progressing to more complex ones to simplify the learning curve.

```java
Product product = FIXTURE_MONKEY.giveMeBuilder(Product.class)  
	.set("name", "Test Product")  
	.sample();  
  
then(product).isNotNull();  
```

--------------------------------

### Basic Interface Implementation Example

Source: https://naver.github.io/fixture-monkey/docs/plugins/interface-plugin/features

Shows how to register implementations for an interface and then generate an instance of that interface. The generated instance will be one of the registered implementations.

```java
interface Animal {  
    String sound();  
}  
  
class Dog implements Animal {  
    @Override  
    public String sound() {  
        return "Woof";  
    }  
}  
  
class Cat implements Animal {  
    @Override  
    public String sound() {  
        return "Meow";  
    }  
}  
  
FixtureMonkey sut = FixtureMonkey.builder()  
    .plugin(new InterfacePlugin()  
        .interfaceImplements(Animal.class, Arrays.asList(Dog.class, Cat.class))  
    )  
    .build();  
  
// Returns either a Dog or Cat instance  
Animal animal = sut.giveMeOne(Animal.class);  

```

--------------------------------

### Setup Fixture Monkey with Kotest Plugin

Source: https://naver.github.io/fixture-monkey/docs/plugins/kotest-plugin/features

Initialize Fixture Monkey with the KotestPlugin and KotlinPlugin.

```kotlin
val fixtureMonkey = FixtureMonkey.builder()  
    .plugin(KotestPlugin())  
    .plugin(KotlinPlugin())  
    .build()  

```

--------------------------------

### Get Started with Fixture Monkey (Java)

Source: https://naver.github.io/fixture-monkey/docs/cheat-sheet/faq

Create a FixtureMonkey instance and generate a random object of a specified class.

```java
Create a FixtureMonkey instance  
FixtureMonkey fixtureMonkey = FixtureMonkey.create();  
  
Generate a random object  
Person person = fixtureMonkey.giveMeOne(Person.class);  

```

--------------------------------

### Get Started with Fixture Monkey (Kotlin)

Source: https://naver.github.io/fixture-monkey/docs/cheat-sheet/faq

Create a FixtureMonkey instance and generate a random object of a specified class using Kotlin.

```kotlin
Create a FixtureMonkey instance  
val fixtureMonkey = FixtureMonkey.create()  
  
Generate a random object  
val person = fixtureMonkey.giveMeOne<Person>()  

```

--------------------------------

### Setup with Validation Plugins

Source: https://naver.github.io/fixture-monkey/docs/plugins/simple-value-plugin/features

Integrate SimpleValueJqwikPlugin alongside validation plugins like JakartaValidationPlugin. Validation annotations take priority.

```kotlin
val fixtureMonkey = FixtureMonkey.builder()  
    .plugin(SimpleValueJqwikPlugin())  
    .plugin(JakartaValidationPlugin())  // Validation annotations override SimpleValue defaults  
    .build()  

```

--------------------------------

### Abstract Class Implementation Example

Source: https://naver.github.io/fixture-monkey/docs/plugins/interface-plugin/features

Demonstrates registering implementations for an abstract class and generating an instance. The generated instance will be one of the provided concrete subclasses.

```java
abstract class Vehicle {  
    abstract int getWheels();  
}  
  
class Car extends Vehicle {  
    @Override  
    int getWheels() {  
        return 4;  
    }  
}  
  
class Bike extends Vehicle {  
    @Override  
    int getWheels() {  
        return 2;  
    }  
}  
  
FixtureMonkey sut = FixtureMonkey.builder()  
    .plugin(new InterfacePlugin()  
        .abstractClassExtends(Vehicle.class, Arrays.asList(Car.class, Bike.class))  
    )  
    .build();  
  
// Returns either a Car or Bike instance  
Vehicle vehicle = sut.giveMeOne(Vehicle.class);  

```

--------------------------------

### Example Generated Product Object

Source: https://naver.github.io/fixture-monkey/docs/get-started/creating-objects-without-lombok

This is an example of a Product object generated by Fixture Monkey. The actual values will vary with each execution.

```java
Product(
    id=42,
    productName="product-value-1",
    price=1000,
    options=["option1", "option2"],
    createdAt=2024-03-21T10:15:30Z,
    productType=ELECTRONICS,
    merchantInfo={1="merchant1", 2="merchant2"}
)
```

--------------------------------

### Obtain Instances from ArbitraryBuilder (Java)

Source: https://naver.github.io/fixture-monkey/docs/generating-objects/fixture-monkey

Use sample(), sampleList(), and sampleStream() on an ArbitraryBuilder to get generated instances.

```Java
ArbitraryBuilder<Product> productBuilder = fixtureMonkey.giveMeBuilder(Product.class);  
  
Product product = productBuilder.sample();  
List<Product> productList = productBuilder.sampleList(3);  
Stream<Product> productStream = productBuilder.sampleStream();  
  
then(product).isNotNull();  
then(productList).hasSize(3);  
then(productStream).isNotNull();  


```

--------------------------------

### Obtain Instances from ArbitraryBuilder (Kotlin)

Source: https://naver.github.io/fixture-monkey/docs/generating-objects/fixture-monkey

Use sample(), sampleList(), and sampleStream() on an ArbitraryBuilder in Kotlin to get generated instances.

```Kotlin
val productBuilder = fixtureMonkey.giveMeBuilder<Product>()  
  
val product = productBuilder.sample()  
val productList = productBuilder.sampleList(3)  
val productStream = productBuilder.sampleStream()  
  
then(product).isNotNull  
then(productList).hasSize(3)  
then(productStream).isNotNull  


```

--------------------------------

### Complete Test Example with FixtureMonkey (Java)

Source: https://naver.github.io/fixture-monkey/docs/generating-objects/fixture-monkey

Demonstrates a complete test case using FixtureMonkey in Java, including creating an instance, generating a customized object, and asserting the result.

```java
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;

class ProductServiceTest {

    // Assume Product and ProductService are defined elsewhere
    // Product product = new Product();
    // ProductService productService = new ProductService();

    @Test  
    void testProductDiscount() {
        // 1. Create a FixtureMonkey instance  
        FixtureMonkey fixtureMonkey = FixtureMonkey.create();  
          
        // 2. Generate a test object with specific properties  
        Product product = fixtureMonkey.giveMeBuilder(Product.class)  
            .set("price", 100.0)  
            .sample();  
          
        // 3. Use the object in your test  
        double discountedPrice = productService.applyDiscount(product, 10);  
          
        // 4. Assert the expected outcome  
        assertEquals(90.0, discountedPrice);
    }
}
```

--------------------------------

### Product Class Definition

Source: https://naver.github.io/fixture-monkey/docs/get-started/customizing-objects

Defines the Product class used in the examples.

```java
@Value  
public class Product {  
    long id;  
    String productName;  
    long price;  
    List<String> options;  
    Instant createdAt;  
}  
```

--------------------------------

### Example Generated Product Object

Source: https://naver.github.io/fixture-monkey/docs/get-started/adding-bean-validation

Illustrates a sample Product object generated by Fixture Monkey, showing how values satisfy the Bean Validation constraints.

```java
Product(
    id=42,                   // Satisfies @Min(1)
    productName="product-1", // Satisfies @NotBlank
    price=75000,            // Satisfies @Max(100000)
    options=[
        "option1",          // Each string satisfies @NotBlank
        "option2",
        "option3"
    ],
    createdAt=2024-03-20T10:15:30Z  // Satisfies @Past
)
```

--------------------------------

### Complete Test Example with FixtureMonkey (Kotlin)

Source: https://naver.github.io/fixture-monkey/docs/generating-objects/fixture-monkey

Demonstrates a complete test case using FixtureMonkey in Kotlin, including creating an instance with the Kotlin plugin, generating a customized object, and asserting the result.

```kotlin
import com.navercorp.fixturemonkey.kotlin.KotlinPlugin
import org.junit.jupiter.api.Test
import static org.junit.jupiter.api.Assertions.assertEquals

class ProductServiceTest {

    // Assume Product and ProductService are defined elsewhere
    // val product = Product()
    // val productService = ProductService()

    @Test  
    fun testProductDiscount() {
        // 1. Create a FixtureMonkey instance  
        val fixtureMonkey = FixtureMonkey.plugin(KotlinPlugin()).build()  
          
        // 2. Generate a test object with specific properties  
        val product: Product = fixtureMonkey.giveMeBuilder<Product>()  
            .set("price", 100.0)  
            .sample()  
          
        // 3. Use the object in your test  
        val discountedPrice = productService.applyDiscount(product, 10)
          
        // 4. Assert the expected outcome  
        assertEquals(90.0, discountedPrice)
    }
}
```

--------------------------------

### Setup Java Node Tree Adapter Plugin

Source: https://naver.github.io/fixture-monkey/docs/plugins/node-tree-adapter-plugin/features

Configure Fixture Monkey with the Java Node Tree Adapter Plugin for object generation.

```java
FixtureMonkey fixtureMonkey = FixtureMonkey.builder()  
    .plugin(new JavaNodeTreeAdapterPlugin())  
    .build();  

```

--------------------------------

### Quick Example with Jackson Annotations (Java)

Source: https://naver.github.io/fixture-monkey/docs/plugins/jackson-plugin/features

Demonstrates using @JsonProperty and @JsonIgnore with Fixture Monkey in Java. The plugin respects these annotations during object generation.

```java
@Value  
public class Product {  
    long id;  
  
    @JsonProperty("name")  
    String productName;  
  
    long price;  
  
    @JsonIgnore  
    List<String> options;  
}  
  
@Test  
void test() {  
    FixtureMonkey fixtureMonkey = FixtureMonkey.builder()  
        .plugin(new JacksonPlugin())  
        .build();  
  
    Product product = fixtureMonkey.giveMeBuilder(Product.class)  
        .set("name", "book")  // uses @JsonProperty name  
        .sample();  
  
    then(product.getProductName()).isEqualTo("book");  
    then(product.getOptions()).isNull();  // @JsonIgnore  
}  

```

--------------------------------

### Quick Example with Jackson Annotations (Kotlin)

Source: https://naver.github.io/fixture-monkey/docs/plugins/jackson-plugin/features

Demonstrates using @JsonProperty and @JsonIgnore with Fixture Monkey in Kotlin. The plugin respects these annotations during object generation.

```kotlin
data class Product(  
    val id: Long,  
    @JsonProperty("name")  
    val productName: String,  
    val price: Long,  
    @JsonIgnore  
    val options: List<String>? = null  
)  
  
@Test  
fun test() {  
    val fixtureMonkey = FixtureMonkey.builder()  
        .plugin(KotlinPlugin())  
        .plugin(JacksonPlugin())  
        .build()  
  
    val product = fixtureMonkey.giveMeBuilder<Product>()  
        .set("name", "book")  // uses @JsonProperty name  
        .sample()  
  
    then(product.productName).isEqualTo("book")  
    then(product.options).isNull()  // @JsonIgnore  
}  

```

--------------------------------

### Basic Kotest forAll Example

Source: https://naver.github.io/fixture-monkey/docs/plugins/kotest-plugin/property-based-testing

Demonstrates a basic property test using Kotest's forAll function with String arguments to test string concatenation length.

```kotlin
class PropertyExample: StringSpec({"  
   "String size" {  
      forAll<String, String> { a, b ->  
         (a + b).length == a.length + b.length  
      }  
   }
})

```

--------------------------------

### Define a Kotlin Data Class

Source: https://naver.github.io/fixture-monkey/docs/plugins/kotlin-plugin/introspectors-for-kotlin

Example of a Kotlin data class named Product with various property types.

```kotlin
data class Product (
  val id: Long?,
  
  val productName: String,
  
  val price: Long,
  
  val options: List<String>,
  
  val createdAt: Instant
)

```

--------------------------------

### String Configuration Overriding Example (Java)

Source: https://naver.github.io/fixture-monkey/docs/customizing-objects/arbitrary

Shows how character set methods override other configuration methods. When a character set method is called, it ignores previous configurations like length.

```java
// The withLength(5, 10) is ignored when alphabetic() is called
CombinableArbitrary.strings().withLength(5, 10).alphabetic()
```

--------------------------------

### Setup Kotlin Node Tree Adapter Plugin

Source: https://naver.github.io/fixture-monkey/docs/plugins/node-tree-adapter-plugin/features

Configure Fixture Monkey with the Kotlin Node Tree Adapter Plugin, ensuring the KotlinPlugin is also registered.

```kotlin
val fixtureMonkey = FixtureMonkey.builder()  
    .plugin(KotlinPlugin())  
    .plugin(KotlinNodeTreeAdapterPlugin())  
    .build()  

```

--------------------------------

### Integrate Jackson and Kotlin Plugins (Kotlin)

Source: https://naver.github.io/fixture-monkey/docs/fixture-monkey-options/overview

This Kotlin example demonstrates adding multiple plugins, including `KotlinPlugin` and `JacksonPlugin`, to Fixture Monkey for enhanced generation capabilities.

```kotlin
@Test  
fun testPluginOption() {  
    // Create a FixtureMonkey with Jackson plugin for JSON support  
    val fixtureMonkey = FixtureMonkey.builder()  
        .plugin(KotlinPlugin())  // Support for Kotlin features  
        .plugin(JacksonPlugin())  // Add support for Jackson annotations  
        .build()  
      
    // Now you can create objects with proper Jackson annotation support  
    val product = fixtureMonkey.giveMeOne<JsonProduct>()  
      
    // Jackson annotations on JsonProduct will be respected  
    // (e.g., @JsonProperty, @JsonIgnore, etc.)  
}  


```

--------------------------------

### Simple InnerSpec Example

Source: https://naver.github.io/fixture-monkey/docs/customizing-objects/innerspec

Demonstrates basic InnerSpec usage to set specific values for properties of a Product object. Use this for straightforward, one-off customizations of nested fields.

```Java
InnerSpec productSpec = new InnerSpec()  
	.property("id", 1000L)  
	.property("name", "Smartphone")  
	.property("price", new BigDecimal("499.99"));  
  
Product product = fixtureMonkey.giveMeBuilder(Product.class)  
	.setInner(productSpec)  
	.sample();  
  
then(product.getId()).isEqualTo(1000L);  
then(product.getName()).isEqualTo("Smartphone");  
```

--------------------------------

### Integer Constraint Chaining Example (Java)

Source: https://naver.github.io/fixture-monkey/docs/customizing-objects/arbitrary

Demonstrates how method chaining works for integer constraints. The last method called determines the final constraint, overriding previous ones.

```java
// This will generate negative integers, ignoring the positive() call
CombinableArbitrary.integers().positive().negative()

// This will generate integers in range 10-50, ignoring the positive() call
CombinableArbitrary.integers().positive().withRange(10, 50)
```

--------------------------------

### Simplest Approach with Default Introspector

Source: https://naver.github.io/fixture-monkey/docs/generating-objects/introspector

This basic setup uses the default configuration and works well with simple JavaBean classes that have a no-arguments constructor and setter methods.

```java
// given  
FixtureMonkey fixtureMonkey = FixtureMonkey.builder()  
	.build();  
  
// when  
Customer customer = fixtureMonkey.giveMeOne(Customer.class);  
  
// then  
then(customer).isNotNull();  

```

--------------------------------

### Simpler Approach for Sealed Classes (1.1.x)

Source: https://naver.github.io/fixture-monkey/docs/migration-guide

This example shows the simplified approach in Fixture Monkey 1.1.x for handling sealed classes using CandidateConcretePropertyResolver, focusing only on implementation classes.

```java
public final class SealedTypeCandidateConcretePropertyResolver implements CandidateConcretePropertyResolver {
	@Override
	public List<Property> resolve(Property property) {
		Class<?> actualType = Types.getActualType(property.getType());
		Set<Class<?>> permittedSubclasses = collectPermittedSubclasses(actualType);

		return permittedSubclasses.stream()
			.map(PropertyUtils::toProperty)
			.toList();
	}

	private static Set<Class<?>> collectPermittedSubclasses(Class<?> type) {
		Set<Class<?>> subclasses = new HashSet<>();
		doCollectPermittedSubclasses(type, subclasses);
		return subclasses;
	}

	private static void doCollectPermittedSubclasses(Class<?> type, Set<Class<?>> subclasses) {
		if (type.isSealed()) {
			for (Class<?> subclass : type.getPermittedSubclasses()) {
				doCollectPermittedSubclasses(subclass, subclasses);
			}
		} else {
			subclasses.add(type);
		}
	}
}
```

--------------------------------

### Apply Kotlin and Jackson Plugins

Source: https://naver.github.io/fixture-monkey/docs/fixture-monkey-options/concepts

Integrate common functionalities by applying pre-configured plugins like KotlinPlugin and JacksonPlugin. These plugins simplify setup for specific ecosystems.

```java
FixtureMonkey monkey = FixtureMonkey.builder()  
    .plugin(new KotlinPlugin())  
    .plugin(new JacksonPlugin())  
    .build();  

```

--------------------------------

### Java: Instantiate Product using Constructor with Options

Source: https://naver.github.io/fixture-monkey/docs/generating-objects/instantiate-methods

Selects and instantiates a Product object using the constructor that takes String, long, and List<String> parameters. Verifies that the options list is not null.

```java
Product product = fixtureMonkey.giveMeBuilder(Product.class)
	.instantiate(
		constructor()
			.parameter(String.class)
			.parameter(long.class)
			.parameter(new TypeReference<List<String>>() {})
	)
	.sample();
  
then(product.getOptions()).isNotNull();

```

--------------------------------

### Generate Anonymous Interface Implementation

Source: https://naver.github.io/fixture-monkey/docs/generating-objects/generating-interface

Use `giveMeOne` with the interface class to get an anonymous implementation for simple cases. No special setup is required.

```java
fixture.giveMeOne(YourInterface.class)
```

--------------------------------

### Manual Object Creation (Before Fixture Monkey)

Source: https://naver.github.io/fixture-monkey/docs/get-started/customizing-objects

Illustrates the traditional, verbose way to create a Product object with specific options before using Fixture Monkey.

```java
// Creating a product with specific options  
List<String> options = new ArrayList<>();  
options.add("option1");  
options.add("red");  
options.add("option3");  
Product product = new Product(1, "Test Product", 1000, options, Instant.now());  

```

--------------------------------

### Complex Configuration for Sealed Classes (1.0.x)

Source: https://naver.github.io/fixture-monkey/docs/migration-guide

This example demonstrates the complex configuration required in Fixture Monkey 1.0.x to handle sealed classes using ObjectPropertyGenerator.

```java
public final class SealedTypeObjectPropertyGenerator implements ObjectPropertyGenerator {
	@Override
	public ObjectProperty generate(ObjectPropertyGeneratorContext context) {
		Property sealedTypeProperty = context.getProperty();
		double nullInject = context.getNullInjectGenerator().generate(context);
		Class<?> actualType = Types.getActualType(sealedTypeProperty.getType());
		Set<Class<?>> permittedSubclasses = collectPermittedSubclasses(actualType);

		Map<Property, List<Property>> childPropertiesByProperty = 
			permittedSubclasses.stream() 
				.collect(
					toUnmodifiableMap(
						Function.identity(),
						it -> context.getPropertyGenerator().generateChildProperties(it)
					)
				);

		return new ObjectProperty(
			sealedTypeProperty,
			context.getPropertyNameResolver(),
			nullInject,
			context.getElementIndex(),
			childPropertiesByProperty
		);
	}

	private static Set<Class<?>> collectPermittedSubclasses(Class<?> type) {
		Set<Class<?>> subclasses = new HashSet<>();
		doCollectPermittedSubclasses(type, subclasses);
		return subclasses;
	}

	private static void doCollectPermittedSubclasses(Class<?> type, Set<Class<?>> subclasses) {
		if (type.isSealed()) {
			for (Class<?> subclass : type.getPermittedSubclasses()) {
				doCollectPermittedSubclasses(subclass, subclasses);
			}
		} else {
			subclasses.add(type);
		}
	}
}
```

--------------------------------

### Avoid Over-Specification in Java Tests

Source: https://naver.github.io/fixture-monkey/docs/cheat-sheet/best-practices

Demonstrates how to write concise tests by only setting the required fields. The 'bad' example over-specifies details not relevant to the test, while the 'good' example sets only the email, which is the sole focus of the validation.

```java
// Bad - overspecified test with unnecessary details  
@Test  
void badTestTooManyDetails() {  
    User user = fixtureMonkey.giveMeBuilder(User.class)  
        .set("id", 1L)  
        .set("name", "John")  
        .set("email", "john@example.com")  
        .set("address.street", "123 Main St")  
        .set("address.city", "New York")  
        .set("address.zipCode", "10001")  
        .set("registrationDate", LocalDate.of(2023, 1, 1))  
        .sample();  
      
    // Test is just checking if email is valid  
    assertThat(userValidator.isEmailValid(user)).isTrue();  
}  
  
// Good - only specify what's needed for the test  
@Test  
void goodTestOnlyNeededDetails() {  
    User user = fixtureMonkey.giveMeBuilder(User.class)  
        .set("email", "john@example.com")  // Only email matters for this test  
        .sample();  
      
    assertThat(userValidator.isEmailValid(user)).isTrue();  
}
```

--------------------------------

### Custom Resolution Implementation Example

Source: https://naver.github.io/fixture-monkey/docs/generating-objects/generating-interface

Implement the CandidateConcretePropertyResolver interface for advanced scenarios to define custom logic for resolving implementations. This allows full control over the generation process.

```java
class YourCustomCandidateConcretePropertyResolver implements CandidateConcretePropertyResolver {
	@Override
	public List<Property> resolveCandidateConcreteProperties(Property property) {
		// Your custom logic to resolve implementations
		return List.of(...);
	}
}
```

--------------------------------

### Real Test Example: Order Processing

Source: https://naver.github.io/fixture-monkey/docs/introduction/overview

A complete test case demonstrating how to use Fixture Monkey to set specific values within a complex object graph for an order.

```java
@Test  
void testOrderProcessing() {  
    // Given  
    Order order = fixtureMonkey.giveMeBuilder(Order.class)  
        .set("items[*].quantity", 2)  
        .set("items[*].product.price", 1000)  
        .sample();  
      
    OrderProcessor processor = new OrderProcessor();  
      
    // When  
    OrderResult result = processor.process(order);  
      
    // Then  
    assertThat(result.getTotalAmount()).isEqualTo(4000); // 2 items * 2 quantity * 1000 price  
    assertThat(result.getStatus()).isEqualTo(OrderStatus.COMPLETED);  
}  


```

--------------------------------

### Real-world Example: Range Class with Instant Type

Source: https://naver.github.io/fixture-monkey/docs/generating-objects/custom-introspector

An example of a custom introspector for a generic `Range<C>` class, specifically handling `Instant` as the generic type. It generates a random date range around the current date.

```java
// External library - Class Range<C> using Instant as generic type  
public class RangeInstantArbitraryIntrospector implements ArbitraryIntrospector {  
  
    @Override  
    public ArbitraryIntrospectorResult introspect(ArbitraryGeneratorContext context) {  
        Property property = context.getResolvedProperty();  
        Class<?> type = Types.getActualType(property.getType());  
        List<AnnotatedType> typeArguments = Types.getGenericsTypes(property.getAnnotatedType());  
        Class<?> genericType = typeArguments.isEmpty() ? null : Types.getActualType(typeArguments.getFirst());  
        if (!type.equals(Range.class)  
                || typeArguments.size() != 1  
                || !genericType.equals(Instant.class)) {  
            return ArbitraryIntrospectorResult.NOT_INTROSPECTED;  
        }  
  
        // ===== Random generation example =====  
        int randomInt = (int)(Math.random() * 365) + 1;  
  
        Instant startTime = Instant.now().minus(randomInt, ChronoUnit.DAYS);  
        Instant endTime = Instant.now().plus(randomInt, ChronoUnit.DAYS);  
  
        Range<Instant> rangeValue = Range.closed(startTime, endTime);  
  
        return new ArbitraryIntrospectorResult(  
                CombinableArbitrary.from(rangeValue)  
        );  
    }  
}  
```

--------------------------------

### Direct DataFaker String Generation Examples

Source: https://naver.github.io/fixture-monkey/docs/plugins/datafaker-plugin/features

Demonstrates direct usage of DataFaker arbitrary generators for various string types like names, addresses, internet, phone, and finance.

```java
// Name generation  
String fullName = DataFakerStringArbitrary.name().fullName();  
String firstName = DataFakerStringArbitrary.name().firstName();  
String lastName = DataFakerStringArbitrary.name().lastName();  
  
// Address generation  
String city = DataFakerStringArbitrary.address().city();  
String streetName = DataFakerStringArbitrary.address().streetName();  
String streetAddress = DataFakerStringArbitrary.address().streetAddress();  
String fullAddress = DataFakerStringArbitrary.address().fullAddress();  
String zipCode = DataFakerStringArbitrary.address().zipCode();  
String state = DataFakerStringArbitrary.address().state();  
String country = DataFakerStringArbitrary.address().country();  
  
// Internet-related generation  
String email = DataFakerStringArbitrary.internet().emailAddress();  
String url = DataFakerStringArbitrary.internet().url();  
String domainName = DataFakerStringArbitrary.internet().domainName();  
String password = DataFakerStringArbitrary.internet().password();  
String ipV4 = DataFakerStringArbitrary.internet().ipV4Address();  
String ipV6 = DataFakerStringArbitrary.internet().ipV6Address();  
  
// Phone number generation  
String phone = DataFakerStringArbitrary.phoneNumber().phoneNumber();  
String cellPhone = DataFakerStringArbitrary.phoneNumber().cellPhone();  
String extension = DataFakerStringArbitrary.phoneNumber().extension();  
  
// Finance-related generation  
String creditCard = DataFakerStringArbitrary.finance().creditCard();  
String iban = DataFakerStringArbitrary.finance().iban();  
String bic = DataFakerStringArbitrary.finance().bic();  

```

--------------------------------

### Avoid Over-Specification in Kotlin Tests

Source: https://naver.github.io/fixture-monkey/docs/cheat-sheet/best-practices

Illustrates concise testing practices in Kotlin using Fixture Monkey. The 'bad' example includes excessive details, whereas the 'good' example focuses solely on setting the email, which is the only relevant piece of information for the email validation test.

```kotlin
// Bad - overspecified test with unnecessary details  
@Test  
fun badTestTooManyDetails() {  
    val user = fixtureMonkey.giveMeBuilder<User>()  
        .setExpGetter(User::getId, 1L)  
        .setExpGetter(User::getName, "John")  
        .setExpGetter(User::getEmail, "john@example.com")  
        .setExpGetter(User::getAddress, { address ->  
            address.setExpGetter(Address::getStreet, "123 Main St")  
                .setExpGetter(Address::getCity, "New York")  
                .setExpGetter(Address::getZipCode, "10001")  
        })  
        .setExpGetter(User::getRegistrationDate, LocalDate.of(2023, 1, 1))  
        .sample()  
      
    // Test is just checking if email is valid  
    assertThat(userValidator.isEmailValid(user)).isTrue()  
}  
  
// Good - only specify what's needed for the test  
@Test  
fun goodTestOnlyNeededDetails() {  
    val user = fixtureMonkey.giveMeBuilder<User>()  
        .setExpGetter(User::getEmail, "john@example.com")  // Only email matters for this test  
        .sample()  
      
    assertThat(userValidator.isEmailValid(user)).isTrue()  
}
```

--------------------------------

### Get ArbitraryBuilder

Source: https://naver.github.io/fixture-monkey/docs/generating-objects/instantiate-methods

An `ArbitraryBuilder` is used to configure object creation settings before generating an object.

```java
ArbitraryBuilder<Product> builder = fixtureMonkey.giveMeBuilder(Product.class);
```

--------------------------------

### Kotlin: Instantiate Product using Constructor with Options

Source: https://naver.github.io/fixture-monkey/docs/generating-objects/instantiate-methods

Selects and instantiates a Product object using the constructor that takes String, Long, and List<String> parameters. Verifies that the options list is not null.

```kotlin
val product = fixtureMonkey.giveMeBuilder<Product>()
	.instantiateBy {
		constructor<Product> {
			parameter<String>()
			parameter<Long>()
			parameter<List<String>>()
		}
	}
	.sample()
  
then(product.options).isNotNull

```

--------------------------------

### Object Creation with Fixture Monkey

Source: https://naver.github.io/fixture-monkey/docs/get-started/customizing-objects

Shows how to achieve the same Product object creation with Fixture Monkey's fluent API, reducing code significantly.

```java
// Same result with much less code  
Product product = fixtureMonkey.giveMeBuilder(Product.class)  
    .size("options", 3)  
    .set("options[1]", "red")  
    .sample();  

```

--------------------------------

### Correctly setting collection size before adding entries (Java)

Source: https://naver.github.io/fixture-monkey/docs/customizing-objects/innerspec

Ensure the size of a collection is set before adding entries to avoid potential issues. This example shows the wrong and correct way to set map entries.

```Java
// Wrong: entry might not be added  
InnerSpec innerSpec = new InnerSpec()  
    .property("merchantInfo", merchantInfo -> merchantInfo.entry(1000, "ABC Store"));  
  
// Correct: set size first  
InnerSpec innerSpec = new InnerSpec()  
    .property("merchantInfo", merchantInfo -> merchantInfo  
        .size(1)  
        .entry(1000, "ABC Store")  
    );  
```

--------------------------------

### Fixture Monkey: Applying Domain Rules Through Options

Source: https://naver.github.io/fixture-monkey/docs/fixture-monkey-options/overview

Shows how to apply domain-specific business rules, such as calculating the total amount of order items, using Fixture Monkey options.

```java
// Applying domain rules through options
FixtureMonkey fixtureMonkey = FixtureMonkey.builder()
    .register(Order.class, fm -> fm.giveMeBuilder(Order.class)
        .thenApply((order, b) -> {
            b.set("totalAmount", order.getItems().stream()
                .mapToInt(Item::getPrice)
                .sum()
            );
        })
    )
    .build();
```

--------------------------------

### Java: Instantiate Product using Constructor without Options

Source: https://naver.github.io/fixture-monkey/docs/generating-objects/instantiate-methods

Selects and instantiates a Product object using the constructor that takes String and long parameters, but no options. Verifies that the options list is empty.

```java
Product product = fixtureMonkey.giveMeBuilder(Product.class)
	.instantiate(
		constructor()
			.parameter(String.class)
			.parameter(long.class)
	)
	.sample();
  
then(product.getOptions()).isEmpty();

```

--------------------------------

### Fixture Monkey Plugin Setup with DataFaker

Source: https://naver.github.io/fixture-monkey/docs/plugins/datafaker-plugin/features

Configure Fixture Monkey to use the DataFaker plugin during its initialization.

```java
FixtureMonkey fixtureMonkey = FixtureMonkey.builder()  
    .plugin(new DataFakerPlugin())  
    .build();  

```

--------------------------------

### Define a Java Object Class

Source: https://naver.github.io/fixture-monkey/docs/plugins/kotlin-plugin/introspectors-for-kotlin

Example of a Java class with properties, getters, setters, and a default constructor.

```java
public class JavaObject {
    private String value;
    private Map<String, String> map;

    public JavaObject() {
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    public Map<String, String> getMap() {
        return map;
    }

    public void setMap(Map<String, String> map) {
        this.map = map;
    }
}

```

--------------------------------

### Define a Kotlin Class with a Java Object

Source: https://naver.github.io/fixture-monkey/docs/plugins/kotlin-plugin/introspectors-for-kotlin

Example of a Kotlin class that holds an instance of a Java object.

```kotlin
class KotlinClassWithJavaClass(val javaObject: JavaObject)

```

--------------------------------

### Configure Instance-Scoped Options (Java)

Source: https://naver.github.io/fixture-monkey/docs/fixture-monkey-options/overview

Demonstrates how to create separate FixtureMonkey instances with different option configurations. This allows for distinct settings between test and development environments.

```java
// Test settings  
FixtureMonkey testFixture = FixtureMonkey.builder()  
    .defaultNotNull(true)  
    .build();  
  
// Development settings  
FixtureMonkey devFixture = FixtureMonkey.builder()  
    .defaultNotNull(false)  
    .build();  

```

--------------------------------

### Example: Default Anonymous Introspector Behavior

Source: https://naver.github.io/fixture-monkey/docs/plugins/interface-plugin/features

Demonstrates enabling the anonymous arbitrary introspector, which is the default behavior.

```java
// Default behavior (anonymous introspector enabled)  
FixtureMonkey sut = FixtureMonkey.builder()  
    .plugin(new InterfacePlugin()  
        .interfaceImplements(MyInterface.class, Arrays.asList(MyInterfaceImpl.class))  
        .useAnonymousArbitraryIntrospector(true)  
    )  
    .build();  
  
// Anonymous introspector disabled  
FixtureMonkey sut2 = FixtureMonkey.builder()  
    .plugin(new InterfacePlugin()  
        .interfaceImplements(MyInterface.class, Arrays.asList(MyInterfaceImpl.class))  
        .useAnonymousArbitraryIntrospector(false)  
    )  
    .build();  

```

--------------------------------

### Java: Instantiate Product using Default Constructor

Source: https://naver.github.io/fixture-monkey/docs/generating-objects/instantiate-methods

Instantiates a Product object using its default constructor. Verifies that the default values for id and name are set.

```java
Product product = fixtureMonkey.giveMeBuilder(Product.class)
	.instantiate(constructor())
	.sample();
  
then(product.getId()).isEqualTo(0);
then(product.getName()).isEqualTo("defaultProduct");

```

--------------------------------

### Payment Class with Credit Card Field

Source: https://naver.github.io/fixture-monkey/docs/plugins/datafaker-plugin/features

Example Payment class with a creditCard field that DataFaker can generate.

```java
public class Payment {  
    private String creditCard;   // "4532-1234-5678-9012"  
}  
  
Payment payment = fixtureMonkey.giveMeOne(Payment.class);  

```

--------------------------------

### Use PrimaryConstructorArbitraryIntrospector

Source: https://naver.github.io/fixture-monkey/docs/plugins/kotlin-plugin/introspectors-for-kotlin

Demonstrates generating an instance of a Kotlin Product class using Fixture Monkey with the Kotlin plugin applied.

```kotlin
@Test
fun test() {
  val fixtureMonkey = FixtureMonkey.builder()
      .plugin(KotlinPlugin())
      .build()

  val product: Product = fixtureMonkey.giveMeOne()
}

```

--------------------------------

### Contact Class with PhoneNumber Field

Source: https://naver.github.io/fixture-monkey/docs/plugins/datafaker-plugin/features

Example Contact class demonstrating a phoneNumber field that DataFaker can populate.

```java
public class Contact {  
    private String phoneNumber;  // "555-123-4567"  
}  
  
Contact contact = fixtureMonkey.giveMeOne(Contact.class);  

```

--------------------------------

### Kotlin: Encapsulate Fixture Setup with Helper Methods

Source: https://naver.github.io/fixture-monkey/docs/cheat-sheet/best-practices

Utilize helper functions to return ArbitraryBuilder instances for common fixture configurations in Kotlin. This approach enhances test flexibility and code reuse. Customize properties using .setExpGetter() and define collection sizes with .setExpSize().

```kotlin
import org.junit.jupiter.api.Test
import com.navercorp.fixturemonkey.ArbitraryBuilder
import com.navercorp.fixturemonkey.FixtureMonkey
import com.navercorp.fixturemonkey.api.int.IntegerArbitraryBuilder
import kotlin.reflect.KProperty1
import static org.assertj.core.api.Assertions.assertThat

class OrderServiceTest {

    private val fixtureMonkey = FixtureMonkey.create()
    private val orderService = OrderService()

    @Test
    fun testOrderProcessing() {
        // Helper methods returning ArbitraryBuilder for more flexibility
        val standardOrder = standardOrderBuilder()
            .setExpGetter(Order::getCustomerNote, "Please deliver quickly")  // Test-specific customization
            .sample()

        val premiumCustomer = premiumCustomerBuilder()
            .setExpGetter(Customer::getMembershipYears, 5)  // Test-specific customization
            .sample()

        val result = orderService.process(standardOrder, premiumCustomer)

        assertThat(result.hasDiscount()).isTrue()
        assertThat(result.discount).isGreaterThanOrEqualTo(standardOrder.totalAmount * 0.1)
    }

    // Helper methods return ArbitraryBuilder instead of instances
    private fun standardOrderBuilder(): ArbitraryBuilder<Order> {
        return fixtureMonkey.giveMeBuilder<Order>()
            .setExpSize(Order::getItems, 3, 5)
            .setExpGetter(Order::getTotalAmount, Arbitraries.integers().between(100, 500))
    }

    private fun premiumCustomerBuilder(): ArbitraryBuilder<Customer> {
        return fixtureMonkey.giveMeBuilder<Customer>()
            .setExpGetter(Customer::isPremiumMember, true)
            .setExpGetter(Customer::getMembershipYears, 2)
    }

    @Test
    fun testOrderWithSpecialDiscount() {
        // Reuse the same builder with different customizations
        val bulkOrder = standardOrderBuilder()
            .setExpSize(Order::getItems, 10, 20)  // Different configuration for this test
            .setExpGetter(Order::getTotalAmount, Arbitraries.integers().between(500, 1000))
            .sample()

        val vipCustomer = premiumCustomerBuilder()
            .setExpGetter(Customer::getMembershipYears, 10)  // Different configuration for this test
            .setExpGetter(Customer::isVipStatus, true)
            .sample()

        val result = orderService.processWithSpecialDiscount(bulkOrder, vipCustomer)

        assertThat(result.discount).isGreaterThanOrEqualTo(bulkOrder.totalAmount * 0.2)
    }
}

// Dummy classes for compilation
class Order {
    var customerNote: String? = null
    var totalAmount: Int = 0
    var items: List<String>? = null

    fun getCustomerNote(): String? = customerNote
    fun setCustomerNote(customerNote: String?) { this.customerNote = customerNote }
    fun getTotalAmount(): Int = totalAmount
    fun setTotalAmount(totalAmount: Int) { this.totalAmount = totalAmount }
    fun getItems(): List<String>? = items
    fun setItems(items: List<String>?) { this.items = items }
}

class Customer {
    var membershipYears: Int = 0
    var premiumMember: Boolean = false
    var vipStatus: Boolean = false

    fun getMembershipYears(): Int = membershipYears
    fun setMembershipYears(membershipYears: Int) { this.membershipYears = membershipYears }
    fun isPremiumMember(): Boolean = premiumMember
    fun setPremiumMember(premiumMember: Boolean) { this.premiumMember = premiumMember }
    fun isVipStatus(): Boolean = vipStatus
    fun setVipStatus(vipStatus: Boolean) { this.vipStatus = vipStatus }
}

class OrderResult {
    var discount: Boolean = false
    var discountAmount: Double = 0.0

    fun hasDiscount(): Boolean = discount
    fun setDiscount(discount: Boolean) { this.discount = discount }
    fun getDiscount(): Double = discountAmount
    fun setDiscount(discountAmount: Double) { this.discountAmount = discountAmount }
}

class OrderService {
    fun process(order: Order, customer: Customer): OrderResult = OrderResult()
    fun processWithSpecialDiscount(order: Order, customer: Customer): OrderResult = OrderResult()
}

class Arbitraries {
    companion object {
        fun integers(): IntegerArbitraryBuilder = IntegerArbitraryBuilder()
    }
    class IntegerArbitraryBuilder {
        fun between(min: Int, max: Int): IntegerArbitraryBuilder = this
    }
}

```

--------------------------------

### Using Parameter Name Hints for Clarity in Java

Source: https://naver.github.io/fixture-monkey/docs/generating-objects/instantiate-methods

Parameter name hints in the instantiate method improve readability and simplify setting specific parameter values. This avoids ambiguity compared to using anonymous parameter indices.

```java
// Without parameter name hints  
.instantiate(constructor().parameter(String.class))  
.set("__ANONYMOUS_0", "value")  // Hard to understand which parameter this is  

// With parameter name hints  
.instantiate(constructor().parameter(String.class, "name"))  
.set("name", "John")  // Clearly indicates which parameter  
```

--------------------------------

### Applying Fixture Monkey Options with Builder Pattern

Source: https://naver.github.io/fixture-monkey/docs/fixture-monkey-options/concepts

Demonstrates how to configure Fixture Monkey using the builder pattern and option chaining. Options are applied sequentially, with later options potentially overriding earlier ones.

```java
FixtureMonkey monkey = FixtureMonkey.builder()  
    .plugin(new KotlinPlugin())           // Applied first  
    .nullableContainer(true)              // Applied second  
    .defaultArbitraryContainerSize(3, 5)  // Applied third  
    .build();  
```

--------------------------------

### Create Product without Fixture Monkey

Source: https://naver.github.io/fixture-monkey/docs/get-started/customizing-objects

Illustrates manual creation of test objects without using Fixture Monkey.

```java
// Without Fixture Monkey  
Product expensiveProduct = new Product(1, "Expensive Product", 2000, ...);  
Product cheapProduct = new Product(2, "Cheap Product", 500, ...);  
```
Tokens:
Raw