Dependencies

• Working knowledge of your CI pipeline - Automated testing should be integrated into your CI pipeline and you should be able to improve your pipelines as needed. We recommend using GitHub Actions.
• Working knowledge of Docker - We use Docker for builds and test runs. You should be able to run Docker containers and ideally work with Dockerfiles for advanced use cases.

Overview

Tests give you confidence that your game will run as expected whenever new code is introduced or existing code is changed. Usually, you introduce code changes yourself, but sometimes the changes may come from external sources such as the Metaplay SDK or third-party libraries being updated. Either way, you need to ensure your game still functions as it should after making changes.

If you find yourself testing something over and over again before a release, it's a good sign it's time to automate it!

We rely extensively on automated testing to ensure the quality of the Metaplay SDK. Since the SDK ships as source code and is meant to be extended by game teams, we also ship our testing tools and test suites for you to help with your testing efforts.

If you just want to run all of our tests, take a look at the Integration Testing page for instructions on how to run them locally or in your CI.

Writing Your Own Tests

To start adding more test coverage, you first need to decide what you want to test and then pick the appropriate tool for the job. Here are some common testing objectives and the approaches we recommend for each:

Objective	How to test	Further reading
I want to know if my game logic works correctly.	Write game logic unit tests with NUnit and cover the game features with BotClient.	.NET Unit Testing and BotClient Testing
I want to know if my custom game server features work correctly.	Write C# unit and system tests with NUnit and Playwright.NET.	.NET Unit Testing and Advanced System Testing
I want to know how my game performs at scale.	Use BotClients to simulate representative load.	BotClient Testing
I want to know my LiveOps Dashboard customizations work correctly.	Write functional tests with Playwright.	Advanced Playwright Dashboard Testing
I want to have confidence that my game has no regressions before a new release.	Run the integration_tests.py in your CI.	Integration Testing
I want to have confidence that publishing a new game config does not harm the game.	Implement custom validation into your game config pipeline.	Custom Game Config Build Pipelines
I want to run complex test scenarios on my game to avoid manual testing.	Write system tests that target the game server and LiveOps Dashboard from the outside.	Advanced System Testing

You can jump to the dedicated testing guides if you know exactly what you want or continue reading to get a better understanding of the different types of tests and tools we provide.

Built-in Testing Methods

There are many strategies for automated testing that each give confidence in different aspects of the game or the underlying technology.

Here is a high-level list of the testing methods we ship with the Metaplay SDK:

• Integration tests - Integration tests verify that all aspects of your game work together. This is most similar to manual testing by humans and is the slowest to run. These are sometimes called end-to-end tests.
• Performance tests - Performance tests verify that your game can handle the expected load. This is especially important for games that are expected to have a high number of concurrent users.
• System tests - System tests verify that the game server as a whole operates correctly through functional tests that target the server using simulated clients, HTTP requests and a headless browser for the LiveOps Dashboard.
• Functional tests - Functional tests verify that the game's actions work as expected. We need different tools to functionally test different systems, such as the Unity client, the game server, and the LiveOps dashboard.
• Unit tests - Unit tests verify that individual snippets of code work as expected. These are great for ensuring important code stays stable over time but are usually not very useful for game logic that keeps changing regularly.
• Component tests - Component tests verify that individual components, like UI components, of the game work as expected. They are like a more complex version of unit tests.
• Static validation - Static validation tools like linters and code analyzers help you catch common programming mistakes before they become a problem.
• Data validation - Data validation tools help you validate that the data and configurations you use in your game are technically correct and pass content validation.

As a game developer, you are most interested in the integration, performance and functional tests. However, as your game gets more complex and you end up extending the Metaplay SDK, you may also find other kinds of test coverage useful.

You should adopt test coverage incrementally, starting from the most error-prone or critical parts of your game.

Built-in Testing Tools

Now that you are familiar with the different types of tests, let's take a look at the tools we use to run these tests. You do not have to become an expert or even use all of these tools, but it's good to know what is available to you.

Game Server

• Roslyn code analyzers - We use Roslyn code analyzers to statically validate the game server code for quality and maintainability.
• .NET Test Runner (NUnit) - We use NUnit to run tests that interact directly with the game server. These range from integration tests to unit tests.
• Playwright.NET - In addition to NUnit, we also use Playwright.NET in the game server tests to write integration tests that interact with external services like the LiveOps Dashboard.
• BotClient - BotClient Testing uses a headless game client to run game logic like a real player would. You can use it for both functional tests and complex simulations.
• Game config validation - Our game config build pipeline includes build and validation steps to ensure that the config is safe to publish into production.

LiveOps Dashboard

• Eslint - We use Eslint to statically validate code in the dashboard project for quality and maintainability.
• TypeScript - TypeScript is a superset of JavaScript that adds static types to the language, making it statically checkable for correctness.
• Vitest - Vitest is a test runner for the LiveOps Dashboard that we use for unit tests in both the dashboard and the underlying libraries.
• Storybook - Storybook is a tool for developing and documenting UI components. We use it to write component tests for the LiveOps Dashboard's UI library, MetaUI.
• Playwright - We also use the TypeScript version of Playwright to write functional tests for the LiveOps Dashboard. These tests are run in a headless browser and verify that the various dashboard actions work as expected.

Integration & Performance Tests

• BotClient Testing - Since the BotClient can be used to simulate players in the game, we can also use it to generate a representative load on the game server for performance testing.
• Integration Testing - Integration tests allow running all the various types of tests a single run, either locally or in your CI.

You can use the above-mentioned testing tools to write your game-specific tests. By utilizing the same tools and utilities to create your own test projects you avoid having to build your own test harnesses from scratch.

Further Reading

You should now have a high-level understanding of the different types of tests and tools that help with automated testing in the Metaplay SDK.

To start adding your own tests, take a look at the table in Writing Your Own Tests for guidance on which tools to use.