devkuma – Testing

Test Overview

kc@example.com (kc kim) — Thu, 15 Sep 2022 20:08:00 +0900

Types of Tests

Unit Test

A unit test is a program test performed at the class or function level. It mainly checks whether units behave as designed and whether their logical structure is appropriate.

Functional confirmation test
- A test that checks whether a module behaves according to its design or specification.
Control flow test
- A test that checks whether commands, branches, and similar elements work according to the program’s logical structure.
Data flow test
- A test that checks whether data or variables are executed in the order of definition, use, and disposal.

Integration Testing

Integration testing combines and runs programs that have been verified by unit tests.

State transition test
- A test that checks behavior based on a state transition diagram.

Functional Testing

Functional testing tests integrated programs as a single feature.

Functional confirmation test

System Testing

System testing verifies whether a program made by combining individual programs or features behaves according to the specification.

Confirmation testing
- Regression testing
  - A test that checks whether changed parts work correctly after a program feature has been modified or changed.
- Degrade testing
  - A test that checks whether existing behavior continues to work after a program feature is added or changed.
Evaluation testing
- Security Test
  - A test that checks whether the system can respond to malicious external attacks and whether vulnerabilities exist.
- Usability Test
  - A test that checks whether the system is visually easy to read and easy for users to operate, learn, and understand.
- Fault tolerance test
  - A test that checks whether specified functions are maintained when a failure occurs.
Load testing
- Performance Test
  - A test that checks whether processing capacity satisfies the specification.
  - A test that measures how much performance a system element shows under a specific condition.
- Long-run test
  - A test that checks whether processing capacity or uptime remains healthy during long continuous operation.
- Load Test
  - A test that checks whether the system can keep operating even under extremely heavy load.
  - A test that applies a specific load for a limited time and checks whether a web application has any problems.
- Endurance Test
  - A test similar to a load test, performed by applying load over a long period. It is also called an aging test.
- Stress Test
  - A test that gradually increases load to find the load threshold.
- Peak Test
  - A test that applies an unsustainable load for a short moment and checks whether the web application keeps running, works correctly, and recovers.

User Testing

Acceptance testing
- A test that checks whether the target system satisfies user requirements.
Operational testing
- A test that checks whether the system works normally in the real operating environment.
Alpha testing
- A test in which people other than developers operate the system and check for defects.
Beta testing
- A test in which general users other than developers operate a product before development is complete or before release and check for defects.

Test Techniques

White-Box Testing

White-box testing means testing while understanding and consciously considering the contents of the system. It is mainly used in unit testing and is classified into the following tests.

Control flow test
Data flow test

When performing white-box testing, the logical structure, such as the processing flow and execution order, must be visualized. One way to do this is with a flowchart.

Test Coverage

Test coverage indicates how sufficient testing is when discussing tests for a system or software. In other words, it expresses as a ratio how much the executed tests cover the test target.

Representative code coverage types are as follows.

Statement Coverage
- This is also called line coverage. It is satisfied when each line of code is executed at least once.
Decision Coverage
- This is also called branch coverage. It is satisfied when every conditional expression has both true and false outcomes.
Condition Coverage
- Here, conditions mean all conditional expressions. This checks whether each internal condition satisfies both true and false cases.

Other forms of code coverage also exist.

Condition/Decision Coverage
Modified Condition/Decision Coverage
Multiple Condition Coverage
All Path Coverage

Black-Box Testing

Black-box testing is a method of inspecting behavior without knowing the internal structure or operating principles of the software.

After unit testing with white-box testing is complete, testing proceeds without considering the internal structure of the system.
It is mainly classified as functional testing and system testing.

In black-box testing, tests are performed in the following order.

Define the purpose of the test.
Identify the functions.
Extract test viewpoints. For example, checking values submitted from a form.
Assign the test viewpoints to functions.

Normal cases
Abnormal cases
Combined cases
etc.

Decide the test technique.

References

Applying a Code Analysis Tool - Part 1, What Is Code Coverage?

Unit Testing

kc@example.com (kc kim) — Thu, 15 Sep 2022 20:08:00 +0900

Unit Testing

Write unit tests according to the basic guidelines below.

Test public methods.
Mock dependency objects that affect test results.
Avoid using disk-related dependencies where possible.
Do not use network-related dependencies.

Unit Testing Frameworks by Language

Java: JUnit
Kotlin: MockK

Personal Thoughts on Test Code

I think test code is a kind of insurance.
- This means that when code changes and there is no test code, you become uncertain whether the code really works correctly. If tests exist, that anxiety disappears.
- Since people write code, everyone makes mistakes. When you write test code, you think through all possible cases and can prove behavior by running them.
- The system can operate without tests, but I think having them makes it more dependable.
I think writing test code is proof that the logic works correctly.
- It proves that the code is implemented to behave correctly.
Test code can become a requirements specification.
- It helps you understand under what requirements the source code behaves and how it works.

References

JUnit Best Practices Guide | HowToDoInJava

TDD(Test Driven Development)

kc@example.com (kc kim) — Thu, 30 Sep 2021 14:47:00 +0900

What Is TDD(Test Driven Development)?

Test-driven development.
It is a development method in which you first write test code, run tests with it, and proceed while receiving feedback on whether the code works correctly.
It is a development process that depends on repeating short development cycles. Developers first write test cases for the required feature, write code that satisfies them, pass the tests, and then refactor as appropriate.
Because developers must clearly understand the requirements of a feature in order to write tests, TDD helps them focus on requirements before development. However, the entry barrier for testing and the increase in code that must be written are considered disadvantages.

What Is a Mock?

A mock is a fake object created when using a real object is costly or when high dependency between objects makes implementation difficult.

Examples of Mock Usage

Building an environment for writing tests
When a test depends on a specific case or moment
When a test takes a long time
When operation may take a long time because of performance limitations on a personal PC or server

What Is Mockito?

Mockito is a Java mocking framework for unit testing.
It is a test framework that supports mock objects in Java unit tests.
In other words, it is a framework that creates mocks for unit testing.
It can create mock objects, define mock object behavior, and verify whether the logic under test was performed correctly.
In general, when developing a web application such as one based on Spring, dependencies exist between multiple objects. These dependencies make unit tests difficult to write, and Mockito can be used to inject fake objects to solve this problem.
By using Mockito, you can stub the desired results on fake objects and perform unit testing.

Dependency Injection for Mock Objects

Mockito mainly uses three annotations for dependency injection of mock objects.
- @Mock
  - An annotation that creates and returns a mock object.
- @Spy
  - An annotation that uses the original methods as-is for methods that have not been stubbed.
- @InjectMocks
  - An annotation that automatically injects fake objects created with @Mock or @Spy.
  - For example, when writing a unit test for UserController, if it uses UserService, you can create a fake UserService with the @Mock annotation and inject it into UserController with @InjectMocks.

BDD(Behavior Driven Development)

kc@example.com (kc kim) — Wed, 29 Sep 2021 14:51:00 +0900

What Is BDD?

BDD(Behavior Driven Development) is behavior-driven development.

BDD is a development method derived from TDD.
It goes one step further than TDD(Test Driven Development) and makes the test cases themselves serve as requirements.

Basic BDD Pattern

BDD writes test cases based on scenarios and does not recommend function-level unit tests. Scenarios should be written at a level that even non-developers can understand.

Feature: Specifies the function or responsibility of the test target.
Scenario: Describes the situation for the test objective.
Given: Sets the values needed to proceed with the scenario.
When: Specifies the conditions needed to proceed with the scenario.
Then: Specifies the result that must be guaranteed when the scenario is complete.

Example

@Test
fun `aliases for behavior driven development`() {
    // given
    given(calculatorService.add(20.0, 10.0)).willReturn(30.0)

    // when
    val result = calculatorService.add(20.0, 10.0)

    // then
    Assert.assertThat(30.0, CoreMatchers.`is`(result))
}

Kakao if - “If You Have Kotest, Ask About TDD and Go with BDD!”

F.I.R.S.T Principles

kc@example.com (kc kim) — Thu, 30 Sep 2021 14:47:00 +0900

What Are the F.I.R.S.T Principles?

The FIRST principles were first proposed by Bob Martin, the author of the well-known book “Clean Code”. Unit tests are organized according to the F.I.R.S.T principles.

Fast

Unit tests should run quickly and produce results quickly.
Therefore, the unit of work should be as small as possible. To make tests fast, they should not use real servers or databases; instead, they should use fake data, or mock data.

Isolated / Independent

Unit tests should be executable on their own.
In other words, they must be independent and must not depend on or affect other tests.

Repeatable

Unit tests must be repeatable.
No matter where, how, or how many times a test is run, it should produce the same result.

Self-validating

Unit tests must be self-validating.
The test itself should produce a pass or fail result, and this should happen automatically.

Thorough / Timely

Unit tests must be thorough and written at the right time.
Being thorough means testing all data. Tests should include the range from minimum to maximum, cover data that changes by role, such as user and administrator cases, and also test which cases fail through exceptions or errors.

References

FIRST Principles for Writing Good Unit Tests | HowToDoInJava

WebClient Testing - Testing External API Calls with MockWebServer

kc@example.com (kc kim) — Sat, 17 Dec 2022 16:31:28 +0900

Overview

Most modern services are expected to call REST APIs. Spring provides several options for building REST clients and recommends WebClient.

This page explains how to unit test a service that calls an API by using WebClient.

What Is MockWebServer?

MockWebServer from Square is a small, simple web server that receives HTTP requests and returns responses.

When testing methods that call HTTP through clients such as WebClient or RestTemplate, you can point the client to MockWebServer and write tests more easily. The Spring team also recommends using MockWebServer for this kind of test.

Creating a Simple WebClient Project

Before using MockWebServer, create a simple project that uses WebClient as the test target. The sample project can be generated from Spring Initializr with Java 11, Gradle, Spring Boot 2.7.6, and the webflux dependency.

Create a DTO object to receive data, then create service code that uses WebClient to call /users/{id} and returns Mono<User>.

Applying MockWebServer

Adding the Dependency

Add the MockWebServer test dependency.

dependencies {
    testImplementation 'com.squareup.okhttp3:mockwebserver'
}

Adding MockWebServer to Test Code

In test code, create a MockWebServer object in @BeforeAll, start it, and shut it down in @AfterAll.

Passing WebClient to the Service

Create a WebClient with a base URL that uses the MockWebServer port and pass it to the service.

@BeforeEach
void initialize() {
    final String baseUrl = String.format("http://localhost:%s", mockWebServer.getPort());
    final WebClient webClient = WebClient.create(baseUrl);
    userService = new UserService(webClient);
}

With this setup, the test calls MockWebServer instead of a real external URL.

Creating an Arbitrary Response

Create a MockResponse, set the body and headers, and put it into enqueue. MockWebServer returns responses in the order they were enqueued.

Checking the Request

Besides checking the response value, you can also inspect the request with takeRequest().

final RecordedRequest recordedRequest = mockWebServer.takeRequest();
assertAll(
        () -> assertEquals("GET", recordedRequest.getMethod()),
        () -> assertEquals("/users/3", recordedRequest.getPath())
);

References

The example code above is available on GitHub.

devkuma – Testing

Test Overview

Types of Tests

Unit Test

Integration Testing

Functional Testing

System Testing

User Testing

Test Techniques

White-Box Testing

Test Coverage

Black-Box Testing

References

Unit Testing

Unit Testing

Unit Testing Frameworks by Language

Personal Thoughts on Test Code

References

TDD(Test Driven Development)

What Is TDD(Test Driven Development)?

What Is a Mock?

Examples of Mock Usage

What Is Mockito?

Dependency Injection for Mock Objects

BDD(Behavior Driven Development)

What Is BDD?

Basic BDD Pattern

Example

Related Video

F.I.R.S.T Principles

What Are the F.I.R.S.T Principles?

Fast

Isolated / Independent

Repeatable

Self-validating

Thorough / Timely

References

WebClient Testing - Testing External API Calls with MockWebServer

Overview

What Is MockWebServer?

Creating a Simple WebClient Project

Applying MockWebServer

Adding the Dependency

Adding MockWebServer to Test Code

Passing WebClient to the Service

Creating an Arbitrary Response

Checking the Request

References