In today’s fast-paced agile environments, API mocking is an essential tool for simulating the responses of dependencies for development or testing purposes. Efficient mock servers are key components of creating an agile environment as the complexity and the number of dependencies increase.
Imagine an engineer working on a new feature that requires making API calls to an API that’s under development. Rather than wait, the engineer creates a mock server based on the API schema and can now finish their feature, allowing the business to ship features faster.
However, things broke down when it was time to deploy the new features and use the real API because the engineer failed to update the mock server, not realizing that the API schema had undergone slight changes.
API mocking has numerous benefits, but an agile development environment requires important considerations like automatic mock server updates. Considerations like this and others are covered in this post, letting you know what a successful mock implementation looks like.
Generating Mocks From User Traffic
User traffic is one of the most effective ways of creating mock servers. Given the ability to record traffic from any environment—like production—developers can build mock servers that accurately simulate the behavior of real users and, more importantly, do it automatically.
Combining user traffic and automatic mock creation is the only way to create mocks quickly because it eliminates manual work, which is time-consuming and error-prone. And it avoids the scenario in the introduction, where engineers develop features using outdated mocks.
Given the importance of these two factors—user traffic and automatic creation—they’re key elements when choosing a tool for your team. However, to perform in agile environments, there’s another important factor to consider: is the tool language-agnostic?
If you’re developing a Golang application, there are many frameworks that’ll integrate into your codebase directly. This has a few benefits, like the ability to write tests in the same language as your application. But using different languages for separate parts of an application is becoming common in modern agile cloud environments. An example is using Golang for the backend and React for the frontend.
Using language-specific tools requires developers to switch between different usage patterns depending on what they’re working on. Or it creates an environment where different teams are working in different ways. While it may not be an issue, it decreases the likelihood of creating a truly agile environment.
This is why modern software teams will benefit from using a language-agnostic tool—it allows multiple teams to work in similar ways and developers to switch between testing in different languages easily.
The Hazards of Mocking
In the introduction, you saw how mock servers can increase developer efficiency. But it also led to unexpected failures during deployment, which is the issue mock servers should prevent. Although mock servers are beneficial in several ways, poor implementation has severe consequences:
Increased development time
As ironic as it sounds, mock servers may increase the development time of new features. Some companies have expressed that new mock servers took 5 times the effort to maintain. Again, this highlights the importance of automatic mock creation.
Risk turning off developers from mocking altogether
A bad first experience can shape someone’s opinion significantly, which is true for mocks too. If your mock servers are difficult to use, or consistently introduces errors when integrating different features because of missing maintenance, developers will likely believe mocks are bad in general.
Given how instrumental mock servers are in an agile environment, this can be catastrophic when trying to encourage fast-paced development.
Increased time to market
Bad mock servers may slow the development of new features because of the time developers spend on mock maintenance.
Impact on deployment times
Teams are likely more optimistic during sprint planning because they expect new features will be thoroughly tested and require less troubleshooting time. Given a proper mock server implementation, this is perfectly reasonable.
But setting ambitious goals without meeting underlying prerequisites—i.e. no bugs present during deployment—will impact the development process. It’ll skew the timeline of the deployment of new features, which may affect business operations if users are already aware of the feature and the release date. Besides, it’ll create a stressful environment where teams feel behind schedule, even though they’re developing at the same or faster pace without mock servers.
As a business grows, the backend needs to follow. Engineers know that scaling applications is a complex process, and mock servers shouldn’t increase this complexity.
Imagine using load testing to prepare for future growth or generating double or triple the current load in production. Your mock server needs to handle this increased load too. If you’re manually managing the deployment of your mock servers, this is another task your infrastructure team has to handle before implementing load testing. Typically, mock servers are based on static responses and don’t require the same processing power as a full application, but that doesn’t equal zero resources.
Reduced test coverage
In some cases, a bad mocking experience may stop teams from using mock servers. But in some scenarios, using mock servers is the management’s decision.
If developers are required to use mock servers and are frustrated with the implementation, they may be discouraged from writing tests, lowering code coverage.
The Importance of Realistic, Efficient & Automatic Mocks
Besides impacting business metrics like time-to-market, not resolving mocking issues affects customer satisfaction, revenue, and other important metrics.
To create an agile environment, avoid these mocking issues by using realistic and efficient mock servers. In the “Generating Mocks from User Traffic” section, we mentioned how user traffic is the only way to create fast mocks, but it’s worth revisiting that statement.
Realistic mocks should reflect the behavior of a real API, ensuring that developers work in an environment that accurately reflects the conditions of real-world usage—this is only possible if they’re created automatically.
Even if updating a mock is as simple as clicking a button, it still requires too much manual intervention. What happens when a developer forgets to click the button? You can eliminate the possibility of developers using outdated dependencies by continuously recording traffic from the real-world usage of an API and creating the API from that.
With proper implementation, this should prevent any possibility of experiencing integration errors during deployment.
There are several tools available for generating realistic and efficient mocks, but consider whether it fits your environment. For example, there’s only one tool that focuses solely on mocking APIs in Kubernetes.
Faster Mocks Leads to Agile Environments
We’ve discussed the potential hazards of a bad mock implementation with few mentions of how a good implementation actively encourages an agile environment. This is not to paint mock servers in a bad light—quite the opposite; mock servers have many benefits.
The reason for focusing on the downsides so far is to highlight the importance of researching available options and choosing the tool and implementation that fits your team properly because good mock servers greatly increase the chances of getting agile environments. So, how does it do that?
Like the example in the introduction, mock servers allow developers to work on new features even when dependencies aren’t finished yet. Teams can now work in parallel, potentially halving the time it takes to develop new features.
Mocking unfinished dependencies is only possible if developers and teams are collaborating fully. A frontend team can only create a mock server for the backend if both teams have fully agreed on a schema for API requests.
Essentially, collaboration is a prerequisite for good mock implementations ensuring all teams are aware of other teams’ actions.
Higher test coverage
While a bad mock implementation may cause decreased test coverage—as covered in the previous section—a good implementation with user traffic and automatic mock creation will greatly increase test coverage. By using real-world traffic, you’ll cover edge cases that you likely wouldn’t have considered otherwise.
No tool can guarantee automatic 100% coverage, but production traffic replication might be the approach that gets you the closest. As you test larger parts of your code, fewer bugs need fixing, and more time is spent on new features or optimizations.
The innovation rate is a good measurement of the agility of an environment. Although correlation doesn’t imply causation, the correlation between agile development—the ability to work fast and efficiently—and innovation is high.
The Growing Need For Fast Mock Servers
Agile environments are critical in modern software development where companies are using advanced tools like preview environments, AI, and no-code platforms to develop new features and collect feedback. The ability to launch these features—while maintaining a high-quality standard— determines a company’s success.
Mock servers may only be one component, but don’t underestimate the potential impact.