Factory is a powerful tool for enhancing your unit testing workflow. By leveraging Factory’s AI capabilities, you can automatically generate relevant test cases, analyze existing tests, and significantly improve your test coverage. This guide will walk you through the process of using Factory for unit testing and share best practices to maximize its effectiveness.

​
Getting Started

Before diving into test generation, ensure you have:
  1. Access to Factory
  2. Your codebase ready for analysis
If you haven’t set up Factory yet, refer to our Quickstart Guide for quickstart instructions.

​
Importing Your Code

Factory works best when it has access to your codebase. There are two primary methods to provide this access:

Codebase Search

Use Factory’s codebase search feature to pull relevant code snippets directly into your session.

File Upload

Upload specific files or entire directories to give Factory a comprehensive view of your project structure.

​
Best Practices for Test Generation

​
1. Analyze Existing Code First

Before generating new tests, ask Factory to analyze your existing codebase and test suite. This provides valuable context for generating more relevant and effective tests. Example prompt: 
Analyze the uploaded code in the 'src' directory and the existing tests in the 'tests' directory. Provide an overview of the current test coverage and identify areas that need improvement.

​
2. Use Creative Prompting Techniques

To get the most out of Factory, use prompts that encourage thoughtful analysis and planning. Here are some effective techniques:

​
3. Iterate and Refine

Test generation is an iterative process. After Factory generates initial tests:
  1. Review the generated tests
  2. Provide feedback on what works well and what needs improvement
  3. Ask Factory to refine the tests based on your feedback
Example refinement prompt: 
The generated tests look good, but we need more coverage for edge cases. Can you add tests for null inputs, empty arrays, and very large numbers?

​
4. Leverage Factory’s Code Understanding

Factory can provide insights into your code structure and suggest improvements beyond just test generation. Use this capability to enhance both your tests and your main codebase. Example prompt: 
Analyze the structure of our test suite. Are there any patterns or anti-patterns you notice? How can we refactor our tests to be more maintainable and effective?

​
Practical Example: Generating Tests for a Utility Function

Let’s walk through a practical example of using Factory to generate tests for a utility function.
1

Import the Code

First, upload or use codebase search to bring your utility function into the Factory session.
2

Analyze the Function

Ask Factory to analyze the function:“Please analyze this utility function and provide an overview of its purpose and potential edge cases we should test for.”
3

Generate Initial Tests

Request test generation:“Based on your analysis, generate a comprehensive set of unit tests for this utility function. Include tests for normal operation and edge cases.”
4

Review and Refine

Review the generated tests and ask for refinements:“The tests look good, but we’re missing coverage for [specific scenario]. Can you add tests to cover this case and explain your reasoning?”
5

Integrate and Run

Once satisfied, integrate the generated tests into your test suite and run them to ensure they work as expected.

Explore More Use Cases

Discover other ways Factory can enhance your development workflow