How to set up test environment for your future project?

Arrange-Act-Assert

Automated tests are usually written in accordance with AAA methodology (Arrange-Act-Assert) when first the necessary data for the test is prepared (e.g., the test database is filled). Some action is performed on this data (e.g., an HTTP request is executed), and then it is checked that the result of the action corresponds to the expected one (e.g., the record in the database is updated).

Database selection

Usually, a separate database is created for test data preparation on the project. The selection of this database is configured when launching tests. Then seeds are created (a set of data that will be written to the database), and utility functions are created that will write these data from seeds directly into the test database.

Preparation of states

At this stage of the setup testing, an important step is to prepare the states that are necessary only for this test. For example, in a test that checks the output of the list of items in the shopping cart, it makes no sense to call the functionality of adding items to the cart beforehand. This is simply unnecessary, as there is a separate test to test adding items to the cart, which will check only that. The correct approach here would be to create an already filled list of products in the database so that the test will check only the functionality of giving the list.

Independent check

Correspondence of the setup testing result to the expected one can be checked independently and with the help of libraries. One of the most popular ones for Go is `github.com/stretchr/testify`. Just compare two implementations of the same code status checker, where one is written independently and the other using a library - how much easier it makes development:

```
	w := httptest.NewRecorder()
	req, err := http.NewRequest("GET", "/subscribers", nil)
	if err != nil {
		t.Fatalf(fmt.Sprintf("Failed to build test request, got error: %s", err))
	}
	
	handler(w, req)

	if w.Code != http.StatusOK {
		t.Fatalf(fmt.Sprintf("Expected HTTP status code 200 but received %d", w.Code))
	}
```

and using the library:

```
	assert.HTTPStatusCode(t, handler, "GET", "/subscribers", nil, http.StatusOK)
```

‍

Automated tests are usually written completely isolated and independent of each other. Thus, tests are easy to read and quick to execute, and it is possible to run only a certain set of tests separately.

If the functionality works with third-party services, interaction with them should be brought to the level of interfaces. This way, it will be possible to easily replace implementation with imitation. Here is an example on Go, where there is interaction via HTTP:

1. An interface is described for interacting with the network:

```
type Subscriber interface {
	SubscribersCount(city string) (int, error)
}
	```

2. An implementation of this interface is being written:

```
type HttpClient struct{}
func (c *HttpClient) SubscribersCount(city string) (int, error) {
	// do HTTP request and return subscribers count
}
	```

3. For the test, another implementation is substituted, which does not actually send an HTTP request but only simulates it:

```
type MockClient struct{}
func (c *MockClient) SubscribersCount(city string) (int, error) {
	// mock returned values
	return 256, nil
}

Code review

After the test and the main functionality code is written, the task is sent for code review to other team members. Here, we should mention static code analyzers. Static analyzers can highlight potential problems in code security, code optimization, etc., to the developer in advance. It is a good practice to include them in your CI process.

Manual tests

After the review, the task should be tested manually according to the acceptance criteria. For this purpose, there is usually a closed test environment where the task is deployed for testing.

Usually, each version control system has its own CI/CD implementation, which is used to set up the analysis and deployment process, e.g. Github has Github Actions, and GitLab has Pipelines. There is a step built into this process that automatically runs all tests on the project. Upon successful completion, we can safely say that the new functionality has been tested, and the existing functionality is not broken. But, if bugs are found during this test, the developer returns to this task for fixing. It is also good practice to first write a test to cover a specific case that will fail initially, but after making edits to the main code, this test should pass successfully.

Report on code coverage

We would also like to mention the report on code coverage by tests. This report can be generated in all popular programming languages. The only difference is in details. Some tools allow you to customize the report output in the form of detailed information on a web page where you can see which parts of the code are covered by tests and which are not. Based on this report, you can understand what percentage of lines or functions are entirely covered by tests and what you should consider to test the application even better regarding all the cases. The main goal is to cover the maximum amount of functionality with tests.

We know how to make it faster, here’s why

Our estimations

Axon takes pride in offering cutting-edge solutions and services underpinned by agile project management methodologies. We recognize the paramount significance of precise estimations in meeting client expectations and project deadlines.

Our approach to estimations revolves around close collaboration with our clients. We understand that every project is unique, and client preferences play a crucial role in defining the scope and scale of software development initiatives. By actively engaging with our clients, we gain deep insights into their specific requirements, priorities, and budgetary constraints. Leave your contacts, and we will provide you with estimations in 24 hours.

Our experience

Axon’s skilled team of software engineers is well-versed in the entire software development process. We take ideas and turn them into practical, user-friendly, and scalable software solutions. Our expertise covers everything from initial concept and design through development, testing, and ongoing maintenance. We're not just about writing code; we're about making technology work for you.

With 8+ years of experience, we've gained valuable insights into industry-specific challenges. This knowledge allows us to customize our services to fit the unique needs of each client.

Our team

Throughout the software engineering process, our team has demonstrated a well-established track record of collaboration and professionalism when working with our esteemed partners and their businesses.

Our team's agility enables us to embrace change and tackle complex challenges with confidence. We approach each project with a flexible mindset, tailoring our methodologies to suit the unique requirements and goals of our clients. Through agile project management, we ensure that our solutions are scalable, maintainable, and adaptable to future needs.

Conclusion

Thus, implementing robust testing procedures is an indispensable aspect of any successful software development project. As we've explored throughout this article, setting up testing not only ensures the quality and reliability of your software but also saves time and resources by identifying and addressing issues early in the development cycle. To set up test environment effectively, you need a reliable team of professionals.

A well-structured testing strategy, encompassing unit, integration, system, and user acceptance testing, among others, provides a comprehensive view of your software's functionality and performance.

It allows you to maintain a high level of confidence in your product and ensures that it meets both the technical specifications and user expectations. Moreover, the integration of automated testing tools and continuous integration practices can streamline the testing process, enabling faster development cycles without compromising quality.

So, remember that testing is not just a phase—it's a critical pillar of your project's success. To set up test environment effectively, you need a reliable team of professionals. If you want to ensure perfect testing for your project, don't hesitate to reach out to our team of dedicated professionals.