Unit Testing for Java 8 Lambdas

Question

I was wondering if anybody find a way to stub/mock a logic inside a lambda without making the lambda's visibility?

public List<Item> processFile(String fileName) {
   // do some magic..
   Function<String, List<String>> reader = (fileName) -> {
       List<String> items = new ArrayList<>();
       try (BufferedReader br = new BufferedReader(new FileReader(fileName))) {
          String output;
          while ((output = br.readLine()) != null) {
             items.add(output);
          }
       } catch (IOException e) {
          e.printStackTrace();
       }
     return items;
   };

   List<String> lines = reader.apply("file.csv");
   // do some more magic..
}

Answer 1

I would say the rule is that if a lambda expression is so complex that you feel the need to mock out bits of it, that it's probably too complex. It should be broken into smaller pieces that are composed together, or perhaps the model needs to be adjusted to make it more amenable to composition.

I will say that Andrey Chaschev's answer which suggests parameterizing a dependency is a good one and probably is applicable in some situations. So, +1 for that. One could continue this process and break down the processing into smaller pieces, like so:

public List<Item> processFile(
    String fileName,
    Function<String, BufferedReader> toReader,
    Function<BufferedReader, List<String>> toStringList,
    Function<List<String>, List<Item>> toItemList)
{
    List<String> lines = null;
    try (BufferedReader br = toReader.apply(fileName)) {
        lines = toStringList.apply(br);
    } catch (IOException ioe) { /* ... */ }

    return toItemList.apply(lines);
}

A couple observations on this, though. First, this doesn't work as written, since the various lambdas throw pesky IOExceptions, which are checked, and the Function type isn't declared to throw that exception. The second is that the lambdas you have to pass to this function are monstrous. Even though this doesn't work (because of checked exceptions) I wrote it out:

void processAnActualFile() {
    List<Item> items = processFile(
        "file.csv",
        fname -> new BufferedReader(new FileReader(fname)),
                // ERROR: uncaught IOException
        br -> {
            List<String> result = new ArrayList<>();
            String line;
            while ((line = br.readLine()) != null) {
                result.add(line);
            }
            return result;
        },      // ERROR: uncaught IOException
        stringList -> {
            List<Item> result = new ArrayList<>();
            for (String line : stringList) {
                result.add(new Item(line));
            }
            return result;
        });
}

Ugh! I think I've discovered new code smell:

If you have to write a for-loop or while-loop inside a lambda, you're doing something wrong.

A few things are going on here. First, the I/O library is really composed of different pieces of implementation (InputStream, Reader, BufferedReader) that are tightly coupled. It's really not useful to try to break them apart. Indeed, the library has evolved so that there are some convenience utilities (such as the NIO Files.readAllLines) that handle a bunch of leg work for you.

The more significant point is that designing functions that pass aggregates (lists) of values among themselves, and composing these functions, is really the wrong way to go. It leads every function to have to write a loop inside of it. What we really want to do is write functions that each operate on a single value, and then let the new Streams library in Java 8 take care of the aggregation for us.

The key function to extract here from the code described by the comment "do some more magic" which converts List<String> into List<Item>. We want to extract the computation that converts one String into an Item, like this:

class Item {
    static Item fromString(String s) {
        // do a little bit of magic
    }
}

Once you have this, then you can let the Streams and NIO libraries do a bunch of the work for you:

public List<Item> processFile(String fileName) {
    try (Stream<String> lines = Files.lines(Paths.get(fileName))) {
        return lines.map(Item::fromString)
                    .collect(Collectors.toList());
    } catch (IOException ioe) {
        ioe.printStackTrace();
        return Collections.emptyList();
    }
}

(Note that more half of this short method is for dealing with the IOException.)

Now if you want to do some unit testing, what you really need to test is that little bit of magic. So you wrap it into a different stream pipeline, like this:

void testItemCreation() {
    List<Item> result =
        Arrays.asList("first", "second", "third")
              .stream()
              .map(Item::fromString)
              .collect(Collectors.toList());
    // make assertions over result
}

(Actually, even this isn't quite right. You'd want to write unit tests for converting a single line into a single Item. But maybe you have some test data somewhere, so you'd convert it to a list of items this way, and then make global assertions over the relationship of the resulting items in the list.)

---

I've wandered pretty far from your original question of how to break apart a lambda. Please forgive me for indulging myself.

The lambda in the original example is pretty unfortunate since the Java I/O libraries are quite cumbersome, and there are new APIs in the NIO library that turn the example into a one-liner.

Still, the lesson here is that instead of composing functions that process aggregates, compose functions that process individual values, and let streams handle the aggregation. This way, instead of testing by mocking out bits of a complex lambda, you can test by plugging together stream pipelines in different ways.

Answer 2

I'm not sure if that's what you're asking, but you could extract a lambda from lambda i.e. to another class or as is and pass it as a parameter. In an example below I mock reader creation:

public static void processFile(String fileName, Function<String, BufferedReader> readerSupplier) {
    // do some magic..
    Function<String, List<String>> reader = (name) -> {
        List<String> items = new ArrayList<>();
        try(BufferedReader br = readerSupplier.apply(name)){
            String output;
            while ((output = br.readLine()) != null) {
                items.add(output);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

        return items;
    };

    List<String> lines = reader.apply(fileName);
    // do some more magic..
}

public static void main(String[] args) {
    // mocked call
    processFile("file.csv", name -> new BufferedReader(new StringReader("line1\nline2\n")));

    //original call
    processFile("1.csv", name -> {
        try {
            return new BufferedReader(new FileReader(name));
        } catch (FileNotFoundException e) {
            throw new RuntimeException(e);
        }
    });
}