What kind of tests I should implement?

Nuno Neves — Thu, 02 May 2019 13:55:37 +0000

What kind of tests I should implement?

Tests...tests and more tests! So, what kind of tests I should implement? How many tests do I need? These are common questions normally a developer ask himself when he needs to implement a use case, a new feature, create a library or a service.

First of all, there are several software testing tactics/techniques which you can apply. They can be conjugated and normally you have more than one of these techniques in your development cycle.

Automated testing
Box approach
Software performance testing
Usability testing
Security testing

The levels

The four basic levels of testing - (professionalqa.com 2019)

Now we will analyze the levels. It is important to keep in mind that some of these levels sometimes have other names or other designations. (this list doesn't have all the type of tests):

Unit testing: This is a small part, the first part, of the testing ecosystem. With unit tests, you can evaluate the code implemented. It is very chipper and it allows the detection of simple defects, such as exceptions or calculation problems.
Component testing: In this part of testing you can test functionality or flows but all external dependencies are simulated/mocked. In this level, we don't want to know if the dependency X or Y returned the correct result, we have to forget the external results and test our components behaviour and internal communications.
Integration testing: Testing the behaviour with the real results from external dependencies. This level of tests sometimes becomes hard to maintain because other dependencies should be available all the time. You should discuss if this level of tests it will add benefits for your project.
System testing: Sometimes called end-to-end testing, it is where you test the full integration. This type of test ensures that software works in all intended target system. This means you should have a system configured and the test needs to run in an application deployed outside from your local environment.
Acceptance testing: Also called user acceptance testing, this type of testing is used to obtain the customer approved. After approved the software can be delivered.

In general, I'm using the unit tests, component tests, system tests and acceptance tests. I believe that with these four levels you can achieve a nice test coverage and they will prevent you for a couple for issues.

What kind of levels do you normally use? Do you have any negative experience about one of these levels? Copy past the bullets below and let's share our opinion :)

What is my favourite test level and why:
What was my worst experience and why:

Original Post

References:

Vavr’s Either Tutorial

Nuno Neves — Mon, 29 Apr 2019 14:49:31 +0000

What is Vavr?

It is an open source library for Java 8+ which provides data type persistence and functional control structures apparently missed at Java. This tutorial will show you one of the data types available (Value->Either) at Vavr. You should go to the Vavr documentation and see the other functionalities and examples.

**Figure 1:** Vavr three basic blocks (Vavr 2019)

What is functional programming?

Functional programming is a programming paradigm that treats computation as the evaluation of mathematical functions and avoids stats or mutable data. This paradigm was introduced at Java 8 with lambda expressions since 2014.

This kind of programming has a number of concepts you should explore and read more, such as First-class and higher-order functions, Pure functions, Recursion, Strict versus non-strict evaluation, Type systems, Referential Transparency, Data Structures.

How can use Vavr in my project?

You can use Vavr in your project by maven, gradle or standalone. You need to target Java 1.8 minimum. More info.

Either

Either is a control structure that represents two possible types. By default, the Left side represents the error and the Right side corresponds to the success side but you can change this behaviour.

This structure has some functional operations such as map, flatMap, filter, fold, etc … I will show you a simple use case with Either (take into consideration this is only to show the functionality of Either), but you should also be able to use it in other complex contexts.

Use case: Divide two numbers. Take into consideration that the user can insert the denominator zero and you should return the following message: “Can’t divide a number per zero!”. If for other reason the division fails you should return “Problem when trying to divide the numbers! Reason: X”, X is the reason why it failed.

Implementing the use case using pure java:

public static Map<String, Object> divideNumber(int num1, int num2) {
    Map<String, Object> result = new HashMap<>();

    try {
        result.put("SUCCESS", num1 / num2);
    } catch (ArithmeticException ex) {
        result.put("FAIL", "Can't divide a number per zero!");
    } catch (Exception ex) {
        result.put("FAIL", "Problem when trying to divide the numbers! Reason: " + ex.getMessage());
    }

    return result;
}

The solution using the Either control structure:

public static Either<String, Integer> divideNumber(int num1, int num2) {
    try {
        return Either.right(num1 / num2);
    } catch (ArithmeticException ex) {
        return Either.left("Can't divide a number per zero!");
    } catch (Exception ex) {
        return Either.left("Problem when try to divide the numbers! Reason: " + ex.getMessage());
    }
}

The code using Either seems more intuitive and you don’t need to add the success/fail logic because you can use the right/left side. I created a few unit tests to show operations you can call and compare to pure java (using map structure).

@Test
void testShouldDivideNumberPerZero() {

    Either<String, Integer> eitherResult = EitherDivisionUseCase.divideNumber(10, 0);

    //You can use isRight or isLeft to check if the value is available
    assertFalse(eitherResult.isRight());
    assertTrue(eitherResult.isLeft());

    //The left side contains the error message (using default behaviour)
    assertEquals(eitherResult.getLeft(), "Can't divide a number per zero!");

    //If you call the get() method when there is no value you will receive a NoSuchElementException exception
    assertThrows(NoSuchElementException.class, eitherResult::get);

    //Comparing to pure java using map
    Map<String, Object> javaResult = JavaDivisionUseCase.divideNumber(10, 0);
    assertNull(javaResult.get("SUCCESS"));
    assertNotNull(javaResult.get("FAIL"));
    assertEquals(javaResult.get("FAIL"), "Can't divide a number per zero!");

}

As you can see, you only need to use the isRight or isLeft to check if there are values inside the Either structure instead of trying to get a valid key from the mapping.

@Test
void testShouldDivideNumberExceptPerZeroUsingFunctionalOperations() {

    Either<String, Integer> eitherResult = EitherDivisionUseCase.divideNumber(10, 2);

    //You can call functional operations such as map, flatmap, filter, etc
    assertFalse(eitherResult
            .map(integer -> integer)
            .collect(Collectors.toList())
            .isEmpty());

    //Comparing to pure java using map
    Map<String, Object> javaResult = JavaDivisionUseCase.divideNumber(10, 2);
    assertFalse(javaResult.entrySet()
            .stream()
            .noneMatch(entry -> "SUCCESS".equals(entry.getKey())));
}

Using the pure java, if you want to operate functions like map, filter, etc you need to use Streams from Java. In the case of Either you don’t need it, the library only needs to receive a Function. It will evaluate the right side and if it exists it will call the apply() method from the Function. You can see the code for Either#map below:

/**
 * Maps the value of this Either if it is a Right, performs no operation if this is a Left.
 *
 * <pre><code>
 * import static io.vavr.API.*;
 *
 * class Example {{
 *
 *     // = Right("A")
 *     Right("a").map(String::toUpperCase);
 *
 *     // = Left(1)
 *     Left(1).map(String::toUpperCase);
 *
 * }}
 * </code></pre>
 *
 * @param mapper A mapper
 * @param <U>    Component type of the mapped right value
 * @return a mapped {@code Monad}
 * @throws NullPointerException if {@code mapper} is null
 */
@SuppressWarnings("unchecked")
@Override
default <U> Either<L, U> map(Function<? super R, ? extends U> mapper) {
    Objects.requireNonNull(mapper, "mapper is null");
    if (isRight()) {
        return Either.right(mapper.apply(get()));
    } else {
        return (Either<L, U>) this;
    }
}

I hope with this quick use case you were able to catch up with Either. You can consult the Vavr API Either Interface for more information.

Please feel free to comment and give your opinion! :)

Git Vavr-Tutorial use case Division two numbers: https://github.com/nbentoneves/simple-java-tutorial/tree/master/vavr-tutorial

Original Post: http://mydevlife.azurewebsites.net/2019/04/19/vavr-either-tutorial/

References:

DEV Community: Nuno Neves

What kind of tests I should implement?

What kind of tests I should implement?

The levels

Vavr’s Either Tutorial

What is Vavr?

What is functional programming?

How can use Vavr in my project?

Either