Integration testing is an essential part of any robust software development process, yet creating effective tests can be a daunting and time-consuming task for developers.
For those using GraphQL servers, the challenge is even more pronounced, as writing comprehensive tests requires understanding complex queries, mutations, and schemas.
In this blog post, we'll go through the easiest way to get started with automated tests for GraphQL server by using Pythagora - an open source tool that creates automated integration tests by analyzing server activity without you having to write a single line of code. We will explore how to get even 80% code coverage in just 30 minutes of playing around the server.
Getting started with Pythagora is a breeze, as it's designed to be a user-friendly tool for developers of all experience levels. To install Pythagora, simply run the following command in your project directory:
npm install pythagora
Once installed, there are two essential commands you need to know. The first one is to start capturing server activity and tests and the second one is to run the created tests.
Pythgora works by capturing API requests which it uses to determine the start and the end of an integration test. So, to get Pythagora to create tests, you need to start your app wrapped in Pythagora by running the following command:
npx pythagora --init-command "my start command" --mode capture
"my start command" is the command you're using to run your app. For example:
npm run start
nest start(if you're using a framework like NestJS)
When you execute the capture command, Pythagora will start your GraphQL server and monitor its activity. Now, you just need to make API requests to your server. To do this, you should use your application as you normally would. You can click around the frontend of your app or you can do it through the GraphQL playground.
As requests are made to your server, Pythagora captures the queries, mutations, and responses, generating corresponding integration tests automatically. You can see the captured tests in the
pythagora_tests folder in the root of your repository. Each file in this folder represents one endpoint (in the case of GraphQL, the majority of your tests will be in one file - eg.
graphql.json that represents
/graphql endpoint). In it, you will see an array where each item is one test and in it, you can see all the data that Pythagora has captured and that's being used to run a test.
You can continue making requests as long as you want. We were able to get to a 90% code coverage within an hour or making requests but this will obviously depend on the complexity of your app.
Once you've captured your integration tests using Pythagora's capture mode, it's time to run them. To do so, use the following command, again replacing
"my start command" with the appropriate command for your server:
npx pythagora --init-command "my start command" --mode test
By running the command, Pythagora will execute the generated integration tests, providing you with a summary of the test results, including passed tests, failed tests, and code coverage.
Ok, once you have your tests captured, you can go on with your development until you encounter a test failing. Then, you will want to debug the code.
To debug your code, the easiest way is to put breakpoints (or console.logs) around your app and rerun the failed tests. You have 2 different commands that you can use to rerun failed tests. If you want to rerun all tests, you can type:
npx pythagora --init-command "my start command" --rerun-all-failed
This command will start running all failed tests from the previous test run one by one. If you want to debug a specific test, you can type:
npx pythagora --init-command "my start command" --mode test --test <TEST_ID>
This command will run a single test that you specify by the test id. You can find the test id in the logs when a test fails. Here is an example of a failed test log in which the test id is a value inside
Finally, to make sure you have enough of your codebase covered with tests, Pythagora integrated nyc code coverage report. By default, you will get a summary of the code that's covered by tests each time you run the test command. It will look like this:
If you want to see all lines in your repository that are and aren't covered by tests, you can add an argument
--full-code-coverage-report to the test command. For example:
npx pythagora --init-command "my start command" --mode --full-code-coverage-report
This will generate a full nyc code coverage report which you can see by opening
pythagora_tests/lcov-report/index.html. This should open a static website in your browser and show you your entire repository along with files and lines that are covered with tests.
From here, you can run the Pythagora capture command again and create API requests that will trigger the uncovered lines until you get to 100% code coverage.
So, to summarize, in this post we went through the process of creating automated integration tests for a GraphQL server with Pythagora. This way, you can easily cover your entire backend with tests just by making API requests to your server while Pythagora is recording server activity.
Pythagora is open source so if you liked this post or Pythagora, it would mean a world to us if you star Pythagora Github repo here. To stay up-to-date on the latest features, enhancements, and news, you can add your email here. Your support will help us continue to develop and improve this powerful tool for the benefit of developers everywhere.
Thank you for reading and happy testing!