Mock Data & Stubs (Fake it till you make it)
Tags: beginners, programming, career, coding
Published: 2023-05-07 12:00:00

## Mock Data & Stubs (Fake it till you make it)

<figure>
  <img src="https://dev-to-uploads.s3.amazonaws.com/uploads/articles/2wcaux0lolzbwb68kqw9.gif"><figcaption>This is you before implementing mock data to your workflow</figcaption>
</figure>

Developing new features can be a total blast, but it can also be a slow and frustrating process. One of the most significant contributors to this frustration is the time it takes to iterate through each development cycle. The longer it takes to develop, test, and refine each feature, the more time is wasted, and the slower progress becomes.

But what if I told you there's a way to reduce your iteration times significantly? Today, we'll explore a technique that can help you "fake it till you make it" when it comes to developing features: using **mock data, stubs, and fakers**. This approach will help you eliminate the dependency on external code or resources that aren't necessary at the moment and allow you to focus on the task at hand.

---
### Why Reducing Iteration Time is Crucial

<figure>
  <img src="https://dev-to-uploads.s3.amazonaws.com/uploads/articles/lli8lwsaw50786tzt6x3.png"><figcaption>Time actually IS money</figcaption>
</figure>

Reducing iteration time is crucial for several reasons:

1. **Faster MVP:** By quickly developing a working Minimum Viable Product (MVP), you can gather real-world feedback and make data-driven decisions about which features are essential and which are not. This way, you can adapt and change your product according to *actual* feedback from your experience with the feature, instead of wasting time on unnecessary additions without ensuring the core functionality works.
2. **Increased productivity:** When you spend less time waiting for external dependencies, you can focus on what really matters: writing and refining your code.
3. **Greater flexibility:** When you're not reliant on external code or resources, you can make changes and improvements more easily, allowing you to pivot when necessary and adapt to new requirements.
4. **Improved morale:** There's nothing worse than being stuck in a never-ending development cycle. By reducing iteration times, you can maintain momentum and keep your team motivated.

Now that we've covered why it's essential to reduce iteration times, let's dive into what mock data, stubs, and fakers actually are.

---
### Mock Data, Stubs, and Fakers: The Building Blocks of Rapid Development

Let's break down these three essential concepts and clarify their differences and interactions.

#### Mock Data

Mock data is a set of fake data points that you can use to simulate the behavior of your application. It helps you avoid relying on real data sources, which can be slow or unavailable during development. By using mock data, you can develop and test your application's logic independently from any external dependencies.

#### Stubs

Stubs are simplified versions of components or functions that return a predetermined response. They help you isolate specific parts of your application and focus on the functionality you're currently developing. Stubs can be used to define the structure of your code, allowing you to move forward without getting stuck on implementing every single function. They're also helpful when collaborating with other team members who are responsible for developing certain functionalities.

#### Fakers

Fakers are libraries or tools that generate realistic-looking data for testing purposes. They can create data that resembles real-world information, such as names, addresses, and dates, without using actual data points.

---
### Understanding the Interaction Between Mock Data, Stubs, and Fakers

<figure>
  <img src="https://dev-to-uploads.s3.amazonaws.com/uploads/articles/3oa30lx1l9idlw4cpfwc.png"><figcaption>Essentially all we're doing is connecting empty boxes to other empty boxes</figcaption>
</figure>

Now that we know what mock data, stubs, and fakers are, let's discuss how they interact and complement each other in the development process.

- Mock data represents the data structure and provides a way to simulate application behavior. It is the foundation for building test scenarios and understanding how your application should respond to various inputs.
- Stubs replace parts of your application that depend on external components or services. They help you focus on the functionality you're currently developing by providing predictable behavior.
- Fakers generate realistic data to populate your mock data and stubs. This allows you to create more diverse and complex test scenarios without manually crafting every single data point.

By combining these three techniques, you can create a flexible and efficient development environment that allows you to quickly iterate on your features while focusing on the actual logic at hand.

---
### Putting It All Together: A Practical Example

Now we'll look at a practical example of how each of these techniques can be implemented. We chose JavaScript for simplicity, but you can treat this example as pseudo-code for now.

Let's assume we're building a simple application that displays a list of users and their details. We'll use mock data, stubs, and fakers to create a rapid development environment for this scenario.

#### Step 1: Creating Mock Data

First, we need to create some mock data to represent the user information. For this example, we'll define a simple JSON object with user details:

```json
[
  {
    "id": 1,
    "name": "John Doe",
    "email": "john.doe@example.com",
    "address": "123 Main St, Anytown, USA"
  },
  {
    "id": 2,
    "name": "Jane Doe",
    "email": "jane.doe@example.com",
    "address": "456 Oak St, Anytown, USA"
  }
]
```

#### Step 2: Implementing Stubs

Now that we have our mock data, we can create a stub function that simulates fetching user data from a server:

```javascript
function fetchUsers() {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve([
        {
          "id": 1,
          "name": "John Doe",
          "email": "john.doe@example.com",
          "address": "123 Main St, Anytown, USA"
        },
        {
          "id": 2,
          "name": "Jane Doe",
          "email": "jane.doe@example.com",
          "address": "456 Oak St, Anytown, USA"
        }
      ]);
    }, 1000);
  });
}
```

In this example, the `fetchUsers()` function returns a Promise that resolves with the mock data after a 1-second delay. This simulates an asynchronous API call, allowing us to develop and test our application without relying on a real server.

#### Example: Using the `fetchUsers()` Stub

To demonstrate using the `fetchUsers()` stub function, let's create a simple function that displays the fetched user data:

```javascript
async function displayUsers() {
  const users = await fetchUsers();

  users.forEach((user) => {
    console.log(`${user.name} (${user.email}): ${user.address}`);
  });
}

displayUsers();
```

This example calls the `fetchUsers()` stub function and then logs the user details to the console.

Imagine if we had to wait for a server or a database to respond in order to test our `displayUsers()` function, and suddenly the data source is unresponsive, or your internet connection goes out. 
Good thing we don't rely on stuff like that anymore (:

#### Step 3: Using Fakers

To make our example more realistic, we can use a faker library to generate a larger set of user data. Here's how we can use the popular `Faker.js` library to create a more diverse set of mock users:

```javascript
import faker from 'faker';

function generateUsers(count) {
  const users = [];

  for (let i = 0; i < count; i++) {
    users.push({
      id: i + 1,
      name: faker.name.findName(),
      email: faker.internet.email(),
      address: faker.address.streetAddress()
    });
  }

  return users;
}

const mockUsers = generateUsers(50);
```

Now our application has a more realistic set of user data to work with, allowing us to test various scenarios and edge cases.

By combining mock data, stubs, and fakers, we can create a rapid development environment that focuses on the **functionality** we're currently developing.

---
### Best Practices and Potential Pitfalls

Let's dive into some best practices and potential pitfalls you should be aware of while working with these techniques.

#### Keep Your Mock Data Realistic

When creating mock data, it's essential to keep it as realistic as possible. This helps ensure that your tests and development experience closely resemble real-world scenarios. For example, if you're working on a project that deals with user profiles, create mock data that includes a variety of names, ages, and other relevant information, rather than using generic placeholders like "John Doe" or "12345."

```javascript
const realisticUsers = [
  { name: 'Alice', age: 28, email: 'alice@example.com' },
  { name: 'Bob', age: 34, email: 'bob@example.com' },
  { name: 'Carol', age: 22, email: 'carol@example.com' },
];
```

#### Don't Overuse Stubs

Stubs can be incredibly useful when it comes to speeding up your development process and isolating different parts of your code. However, it's crucial not to overuse them. Overusing stubs can lead to overly rigid code that's difficult to maintain and refactor. Remember that stubs are a means to an end – they should help you focus on the most critical parts of your code and avoid getting bogged down in implementation details.

Treat stubs as "empty boxes", when the time comes you still have to fill them up with their contents.

#### Keep Your Fakers Consistent

When using fakers to generate random data, it's essential to maintain consistency across your tests and development environment. Inconsistent faker data can lead to false negatives or positives in your tests, making it challenging to determine whether your code is functioning correctly. To ensure consistency, consider using seed values when initializing your fakers, so the same data is generated every time you run your tests.

```javascript
const faker = require('faker');

faker.seed(12345); // Seed the random number generator

const firstName = faker.name.firstName(); // This will always generate the same first name
const lastName = faker.name.lastName(); // This will always generate the same last name
```

---
### Popular Libraries and Tools for Mock Data, Stubs, and Fakers

We've discussed the importance of these techniques, and now it's time to see some examples of libraries and tools you can use in different programming languages to help you achieve this. The purpose is to show how these concepts are applicable across various programming environments. However, we'll put more emphasis on C# and Unity3D since these are the main tools used by my team at [Magnifica VR](https://magnifica.io).

#### C# and Unity3D

- **NSubstitute**: A friendly substitute for .NET mocking libraries, NSubstitute is designed as a more straightforward and more concise alternative to other mocking libraries, making it easier to create substitutes for interfaces and classes in your tests.

- **Moq**: A popular and easy-to-use mocking library for .NET that allows you to create mock objects, set expectations on them, and verify interactions with them in your tests.

- **Unity Test Framework**: Unity3D provides a built-in testing framework that supports unit, integration, and end-to-end testing. It allows you to create test doubles, such as stubs and fakes, to isolate the code under test and remove dependencies.

#### JavaScript

- **Faker.js**: A popular library for generating fake data, such as names, addresses, and phone numbers. It can be used in combination with stubs to create realistic mock data for your tests.

- **Sinon.js**: A library that provides standalone test spies, stubs, and mocks for JavaScript. It works with any unit testing framework and is compatible with different browsers.

#### Python

- **Faker**: A Python library that generates fake data for you, similar to Faker.js for JavaScript. It's useful for creating mock data for testing or populating databases.

- **unittest.mock**: A built-in library in Python that allows you to create stubs and mocks for your tests. It's easy to use and doesn't require any external dependencies.

#### Ruby

- **Faker**: A Ruby library that generates fake data, such as names, addresses, and phone numbers. It's helpful for creating realistic mock data for your tests or seeding your database.

- **RSpec Mocks**: A library that provides a simple and flexible mocking framework for Ruby. It's part of the RSpec testing ecosystem and can be used with other RSpec libraries or as a standalone mocking solution.

As you can see, no matter what programming language you work with, there are libraries and tools available to help you create mock data, stubs, and fakers. Utilizing these tools will save you time and make your testing process more efficient.

Now that we've explored the available tools and libraries, let's see how all these concepts can be applied in a real-world scenario.

---
### Case Study: Implementing Mock Data, Stubs, and Fakers in a Unity3D Project

Let's explore a simple case study in a Unity3D project. We'll create a simple game that displays a list of players with their scores, and we'll use the concepts we have just discussed to speed up the development process and make it more efficient.

#### Setting Up the Project

To start, let's create a new Unity3D project and set up the basic structure. We'll need a script to handle the player data and another one to display it on the screen.

Create a new C# script called `PlayerData.cs` and add the following code:

```csharp
public class PlayerData
{
    public string Name;
    public int Score;
}
```

This simple class will hold the player's name and score. Now, let's create another script called `PlayerListDisplay.cs` to display the list of players on the screen. In this script, we'll need a function that takes a list of `PlayerData` objects and displays them:

```csharp
using UnityEngine;
using System.Collections.Generic;

public class PlayerListDisplay : MonoBehaviour
{
    public void DisplayPlayers(List<PlayerData> players)
    {
        foreach (PlayerData player in players)
        {
            Debug.Log($"{player.Name}: {player.Score}");
        }
    }
}
```

#### Creating a Stub for Player Data

At this point, we need some data to display on the screen. In a real-world scenario, we might retrieve this data from a server or a database. However, we don't want to depend on an external source while developing and testing our display function. Instead, let's create a stub that generates a list of fake players with random scores.

Create a new C# script called `PlayerDataStub.cs` and add the following code:

```csharp
using System.Collections.Generic;

public class PlayerDataStub
{
    public List<PlayerData> GenerateFakePlayers(int count)
    {
        List<PlayerData> fakePlayers = new List<PlayerData>();

        for (int i = 0; i < count; i++)
        {
            PlayerData player = new PlayerData
            {
                Name = $"Player {i + 1}",
                Score = Random.Range(0, 100)
            };

            fakePlayers.Add(player);
        }

        return fakePlayers;
    }
}
```

With this stub in place, we can generate a list of fake players to test our `DisplayPlayers` function without relying on external data sources.

#### Testing the Display Function

Now, let's test the `DisplayPlayers` function by providing it with the fake data generated by our stub. Modify the `PlayerListDisplay.cs` script as follows:

```csharp
using UnityEngine;
using System.Collections.Generic;

public class PlayerListDisplay : MonoBehaviour
{
    private PlayerDataStub _playerDataStub;

    private void Start()
    {
        _playerDataStub = new PlayerDataStub();
        
        List<PlayerData> fakePlayers = _playerDataStub.GenerateFakePlayers(10);
        DisplayPlayers(fakePlayers);
    }

    public void DisplayPlayers(List<PlayerData> players)
    {
        foreach (PlayerData player in players)
        {
            Debug.Log($"{player.Name}: {player.Score}");
        }
    }
}
```

With this setup, we can quickly test and iterate on our `DisplayPlayers` function without worrying about external dependencies.

#### Introducing a Faker for More Realistic Data

While our stub generates fake player data, the names and scores might not be very realistic. To improve the quality of our test data, we can introduce a faker library like `Bogus`. This library can generate more realistic names and other data, making our tests more representative of real-world scenarios.

First, add the `Bogus` package to your Unity3D project using the package manager. Then, modify the `PlayerDataStub.cs` script to use the `Bogus` library:

```csharp
using System.Collections.Generic;
using Bogus;

public class PlayerDataStub
{
    private Faker _faker;

    public PlayerDataStub()
    {
        _faker = new Faker();
    }

    public List<PlayerData> GenerateFakePlayers(int count)
    {
        List<PlayerData> fakePlayers = new List<PlayerData>();

        for (int i = 0; i < count; i++)
        {
            PlayerData player = new PlayerData
            {
                Name = _faker.Name.FullName(),
                Score = _faker.Random.Number(0, 100)
            };

            fakePlayers.Add(player);
        }

        return fakePlayers;
    }
}
```

Now our stub generates more realistic player data, allowing us to test our `DisplayPlayers` function under more accurate conditions.

#### Conclusion

In this case study, we demonstrated how to use mock data, stubs, and fakers in a Unity3D project. By creating a stub for player data and using a faker library to generate more realistic test data, we were able to quickly iterate on our `DisplayPlayers` function without relying on external data sources.

Implementing these techniques in your projects can help you save time and reduce dependencies, allowing you to focus on building the core functionality of your application.

---
### Wrapping Up

Throughout this post, we've discussed the importance of reducing iteration times when developing new features. We've looked at how using mock data, stubs, and fakers can help you achieve that by minimizing dependencies on external data sources or code that's not yet implemented.

By understanding and applying these techniques, you can focus on building the core functionality of your application, iterate faster, and adapt to real feedback sooner. Remember, it's essential to have a working MVP as fast as possible, so you can modify and improve your product based on actual experience and feedback.

Don't be afraid to fake it till you make it, and happy coding!

<figure>
  <img src="https://dev-to-uploads.s3.amazonaws.com/uploads/articles/2a6f2il6vkpt7610iiru.png"><figcaption>Remember to create your boxes and fill them later, not the other way around</figcaption>
</figure>