Why Programmers Hate Unit Testing

Even though unit testing is extremely important it’s hated by many developers. In this video I’ll explain why.

#testing #programming

What is GEEK

Buddha Community

Software Testing 101: Regression Tests, Unit Tests, Integration Tests

Automation and segregation can help you build better software
If you write automated tests and deliver them to the customer, he can make sure the software is working properly. And, at the end of the day, he paid for it.

Ok. We can segregate or separate the tests according to some criteria. For example, “white box” tests are used to measure the internal quality of the software, in addition to the expected results. They are very useful to know the percentage of lines of code executed, the cyclomatic complexity and several other software metrics. Unit tests are white box tests.

#testing #software testing #regression tests #unit tests #integration tests

Testing Microservices Applications

The shift towards microservices and modular applications makes testing more important and more challenging at the same time. You have to make sure that the microservices running in containers perform well and as intended, but you can no longer rely on conventional testing strategies to get the job done.

This is where new testing approaches are needed. Testing your microservices applications require the right approach, a suitable set of tools, and immense attention to details. This article will guide you through the process of testing your microservices and talk about the challenges you will have to overcome along the way. Let’s get started, shall we?

A Brave New World

Traditionally, testing a monolith application meant configuring a test environment and setting up all of the application components in a way that matched the production environment. It took time to set up the testing environment, and there were a lot of complexities around the process.

Testing also requires the application to run in full. It is not possible to test monolith apps on a per-component basis, mainly because there is usually a base code that ties everything together, and the app is designed to run as a complete app to work properly.

Microservices running in containers offer one particular advantage: universal compatibility. You don’t have to match the testing environment with the deployment architecture exactly, and you can get away with testing individual components rather than the full app in some situations.

Of course, you will have to embrace the new cloud-native approach across the pipeline. Rather than creating critical dependencies between microservices, you need to treat each one as a semi-independent module.

The only monolith or centralized portion of the application is the database, but this too is an easy challenge to overcome. As long as you have a persistent database running on your test environment, you can perform tests at any time.

Keep in mind that there are additional things to focus on when testing microservices.

• Microservices rely on network communications to talk to each other, so network reliability and requirements must be part of the testing.
• Automation and infrastructure elements are now added as codes, and you have to make sure that they also run properly when microservices are pushed through the pipeline
• While containerization is universal, you still have to pay attention to specific dependencies and create a testing strategy that allows for those dependencies to be included

Test containers are the method of choice for many developers. Unlike monolith apps, which lets you use stubs and mocks for testing, microservices need to be tested in test containers. Many CI/CD pipelines actually integrate production microservices as part of the testing process.

Contract Testing as an Approach

As mentioned before, there are many ways to test microservices effectively, but the one approach that developers now use reliably is contract testing. Loosely coupled microservices can be tested in an effective and efficient way using contract testing, mainly because this testing approach focuses on contracts; in other words, it focuses on how components or microservices communicate with each other.

Syntax and semantics construct how components communicate with each other. By defining syntax and semantics in a standardized way and testing microservices based on their ability to generate the right message formats and meet behavioral expectations, you can rest assured knowing that the microservices will behave as intended when deployed.

Ways to Test Microservices

It is easy to fall into the trap of making testing microservices complicated, but there are ways to avoid this problem. Testing microservices doesn’t have to be complicated at all when you have the right strategy in place.

There are several ways to test microservices too, including:

• Unit testing: Which allows developers to test microservices in a granular way. It doesn’t limit testing to individual microservices, but rather allows developers to take a more granular approach such as testing individual features or runtimes.
• Integration testing: Which handles the testing of microservices in an interactive way. Microservices still need to work with each other when they are deployed, and integration testing is a key process in making sure that they do.
• End-to-end testing: Which⁠—as the name suggests⁠—tests microservices as a complete app. This type of testing enables the testing of features, UI, communications, and other components that construct the app.

What’s important to note is the fact that these testing approaches allow for asynchronous testing. After all, asynchronous development is what makes developing microservices very appealing in the first place. By allowing for asynchronous testing, you can also make sure that components or microservices can be updated independently to one another.

#blog #microservices #testing #caylent #contract testing #end-to-end testing #hoverfly #integration testing #microservices #microservices architecture #pact #testing #unit testing #vagrant #vcr

Unit test vs. Programmer test vs. Integration test

Almost anyone agrees about what is a Unit Test. QA engineers and developers usually give Integration Test different meanings. Extreme Programming defines the Programmer Test concept, whose objective is to create more useful tests. This article outlines the properties of each type of test and creates a common ground to speak about them.

Photo by Mike from Pexels

Unit test

You get the headlamp, place a sensor as a lightbulb, and connect the headlamp to a power source. The test passes if the sensor receives power.

Unit test: the lamp.

• Runs fast; the scale is milliseconds.
• Test a unit in isolation; one failure implies one single unit.
• Mock internal dependencies; replace other components by mocks.
• Mock externals; avoid databases, network, and external APIs.
• Failure spots precisely the origin of failure; it is one unit.
• Refactor is difficult; changes in code usually implies changes in the test.
• No business value; the test does not explain the objective of the unit.
• Low confidence; do not test the relation between components.
• Discourage the use of TDD; test and units are too close.

The test is: does the headlamp powers the lightbulb outlet when it receives power? Complete the Use Case with additional tests for the lightbulb, the switch, the battery, and the wire.

Unit tests have no business value. Probably you are a car factory company, not a headlamp factory company. If you read all the tests, you know which parts you need to build a car, but no idea how to make a car. Changes are hard; if you change any piece, you have to rebuild your tests for that piece, and you do not know how it affects other parts.

Confidence is low. You are not checking if the headlamp socket is compatible with the lightbulb, or if the headlamp glass is black, and it does not allow light to pass; just to name a few.

Programmer test

You get the headlamp, a light bulb, a battery, a light switch, interconnect them. Turn the switch on. The test passes if the light bulb emits light.

Programmer test: the lamp lights.

• Runs fast; the scale is milliseconds.
• Test a business rule in isolation; do not build the whole application.
• Use internal components; avoid mocks, and use actual parts.
• Mock externals; avoid databases, network, and external APIs.
• Failure spots reasonably well the origin of failure; a few units involved.
• Refactor is easy; the test is resilient to changes in code.
• Documents the code; connects test and business rules.
• High confidence; it tests a business rule with relevant components.
• Use TDD; the most recent edit is vital.

The test is: does turning the switch on lighting the lamp?

Programmer tests have business value. You know what the headlamp does and how it works. Each test becomes a small manual about how to build a car part. You can switch lightbulbs, headlamps, and other pieces, and the test still passes if it works.

Confidence is high. You are not checking each part and also that everything is working well together.

Integration test

You build a car and place it in a dark street. Unlock the door, turn the key, and turn on the light switch. The test passes if it illumines the street correctly.

Integration test: the car lights the street.

• Faster than human; each test takes seconds or minutes.
• Test a business rule; imitate the human using the application.
• Use real internal components; mock nothing here.
• May use real external dependencies; some mocks are necessary.
• Failure gives the origin of failure vaguely; consider the whole system.
• Refactor is hard; test is slow, and failure give vague hints.
• High business value; document the exact behavior of the system.
• Highest confidence; the next step is real users.
• Not suitable for TDD; test-code-refactor cycle is too long.

The test is: does turning the switch on making the car light the road?

These tests are real business value. You know what the car must do. You can change any part and still check if everything works. The problem is that if something fails, you have to debug the full car.

Confidence is the highest. You have a real car. It is also slow because you need to build a new car for each test.

#testing #integration-testing #unit-testing

Ten Principles For Agile Testers

In the previous blog we saw that what exactly is Agile testing and in this blog we will see in introduction to Principles For Agile Testers.

What is an Agile tester?

• So get into the principles for Agile testers we first need to know what is an Agile tester? A professional tester who is not scared of change has knowledge about technical and business aspects as well and understands the concept of using tests to document requirements to drive development is an Agile tester.
• Now let’s see what are in ten principles for Agile testers:
• Provide continuous feedback.
• Deliver value to the customer.
• Enable face-to-face communication.
• Have courage.
• Keep it simple.
• Practice continuous improvement.
• Respond to change.
• Self-organize.
• Focus on people.
• Enjoy

Provide Continuous Feedback

• Continuous feedback is the key to agile testing success. By providing feedback we can improve and not make the same mistakes again and again. The main aim is to learn from your mistakes. Testers should help product owners or customers visualize requirements for the stories. Their feedbacks helps in designing the test cases early in the software life cycle. As retrospectives are an important part of the Agile process, providing feedback in it is also helpful. It is one of the most important principles for Agile testers.

Deliver Value to the Customer

• As a tester, it’s your responsibility to tell customers which really is an important function and which is not. The testers help them identify the main functionality instead of just some cool features. The main focus is to try and deliver critical functionality and enhance it later. Critical functionalities should be worked on first as after seeing them implemented, customers can see what enhancements they want. Testing should work on corner cases but should not forget about the happy path of the service. As we get involved in testing it is possible to get involved in corner cases so much that we miss the core functionality. So, we need to maintain a balance between them.

Enable Face-to-Face Communication

• Good communication is the key to success. Agile’s success is totally dependent upon communication. Whether it is between customer and developer or between developers and the testers all communication is very important. Testers should look for unique ways to communicate. Teams may be working in geographically divided. But it should not hinder communications between the teams.
• Testers should never get in the way of any direct customer-developer communication but should help to make sure that communication happens. If a tester finds out that the developer has some confusion regarding the requirements. It’s the responsibility of the tester to set up a meeting between the developer and the business.
• The testers understand the story from the customer’s perspective and from the developers’ technical angle as well. The tester should be able to communicate both ways, that’s why it’s in testers’ best interest to be good at communicating, as they need to do it more than any other team member. Testers act as a bridge between customers and developers.

Have Courage

• The testers should have the courage to speak their minds. They should not be intimidated by anyone. If they find any issue they should report it. If they see any gap in the business requirements they should discuss it.
• The testers should be comfortable in asking customers for examples or developers for help. Asking for examples is the best way for getting the real-world use case of the services. In Agile anyone can perform any task. So, a developer can help a tester in testing some particular scenario. And a tester can help the developers in debugging an issue ass well.
• Testers should not be scared to fail but should learn from their mistake. It’s natural to make some mistakes but we should always learn from them and improve ourselves.

#api testing #integration testing #quality assurance (qa) #testing #unit testing #agile #agile teams #agile transformation #agiledeveloper #automation #automation testing #testing skills

Agile Testing: An introduction

When we talk about Agile the first thing that pops into our mind is Agile development. But here we are going to see and learn about an introduction to Agile Testing that how testers work in Agile, the contrast between Agile Testing and development, and traditional vs. Agile approach.

What is Agile Testing?

• In the world of software development, there are two very common terminologies, Developers (programmers) and testers. When we hear programmer we think of a person whose main task is to write production code. And when you hear tester you think of a person whose main task in testing and quality assurance.
• In Agile no one has only one task to perform, here everyone works on it with one aim in the mind that is to deliver the quality their customers need. In a traditional approach, this would have been the primary concern of the tester or the QA of the team. But in Agile even the development team tries to deliver quality end product to the customer.
• Agile is an iterative development methodology, where requirements evolve through collaboration between the customer and self-organizing teams. Agile aligns development with customer needs. Several core practices used by agile teams relate to testing.
• Test-driven development (TDD) is used for the development of the services. Where the programmer writes the tiny piece of test which fails. Then tries to write the code around it to make the test pass. It is an approach that many teams follows as it is a smart technique to avoid any bugs.

ROLES AND ACTIVITIES ON AN AGILE TEAM

The roles are divided into mainly two teams:

• Customer team
• Developer team

Customer team

• The customer team comprises business experts, product owners, domain experts, product managers, business analysts, etc. The customer team writes the stories for the development to work on. They provide examples and logic behind the requirements. Their main task is to clear any doubts and give clarification with real world use cases or examples. They are available in each iteration for guiding the Dev and QA teams as well.
• In a customer team, the testers have a crucial role to play. They help the customers express their requirements as tests.

Developer team

• The developer team comprises of Developer team includes programmers,system administrators, architects, database administrators, technical writers,security specialists. Each person in the team can be responsible for multiple roles. A developer can also be helping out in testing related activities and a tester could be helping the developers in debugging a issue.
• Testers are in the developer team as well because testing is one of the core tasks in Agile. Both the testers and the developers help each other in achieving the best quality end product for the customer.

Interaction between Customer and Developer Teams

• The customer and developer teams work closely together with a common goal to deliver value to the organisation. Testers does not have the sole responsibility for the quality of the product under development. The developer also helps them achieve this by trying to maintain the quality from the first phase of the development.
• The customer team with developer team prioritise stories which are crucial and are to delivered in each sprint. It’s totally up to the customer that what they want the developer team to work on. They can even request changes in between the sprint and the developer can work on it. If it does not affect the current scope of the story too much. Even if it does they can pick it up in the next upcoming sprint.
• It is not totally in the hands of the customer team to dictate how much work they want the development team to work on. The developer picks up work according to there bandwidth, estimates it and then starts working on it.
• Testers have a foot in each world, understanding the customer viewpoint as well as the complexities of the technical implementation. The testers or the QA team acts as a bridge between the customer and the developers. They don’t just understands the customer requirements but also looks at it from a technical viewpoint. and tries to see if it is feasible or not from the developers point of view as well.

**HOW IS AGILE TESTING DIFFERENT? **

• By now you must be wondering how is Agile testing different from the the other traditional approach? Let’s see how it is like to work on a traditional team vs. an Agile team.

Working on Traditional Teams

• In traditional team or approach the testers are not involved with developers from the starting phases of the software. Testers are involved in the last phases of the development where they get very little time to test the services on which the developers works for months.
• Each release cycle is for around 6 months where all the tasks are to be completed and released to the customer. Testers are involved in release planning and requirements definition.But after that they are involved in the end with rushed testing phase and sometimes a delayed release as well.
• The quality is the sole responsibility of the QA team only. If any of the requirements were missing or any other issue was found the testers were responsible. They didn’t even have the control over if the developer has even tested there code or not.
• The testers have the power to stop or postpone the release of they find any major issues in the release or if it is not according to the requirements.
• 6 months seems like a very long time but is not as even after this time the end result is not according to the customers expectations. Things gets deviated from the path and the end result is not covering all the requirements.
• The testers create there test plans according to the API specs but if the end product is not according to the defined requirements then the whole test plan simply fails.

#agile #api testing #integration testing #quality assurance (qa) #scaled agile #scrum #testing #unit testing #agile teams #agile transformation #test automation