How do you test and mock scala objects that depend on external services or resources?

1 Association and dependency

Association and dependency are two types of relationships that can exist between scala objects. Association means that one object has a reference to another object as a field or parameter, and can use its methods or properties. Dependency means that one object uses another object only within a method or block, and does not store a reference to it. For example, a Customer object may have an association with an Account object, and a dependency with a BankService object.

2 Testing with scalatest

Scalatest is a popular testing framework for scala that supports different styles and features for writing and running tests. You can use scalatest to write unit tests, integration tests, functional tests, or any other kind of tests you need for your scala objects. You can also use scalatest to write assertions, matchers, fixtures, and test scopes. To use scalatest, you need to add it as a dependency in your build tool, such as sbt or maven, and import the relevant packages in your test files.

3 Mocking with mockito

Mockito is a mocking library for java and scala that allows you to create and manipulate mock objects that simulate the behavior of real objects. You can use mockito to isolate your scala objects from their external dependencies, and control how they interact with them. You can also use mockito to verify the interactions between your objects and their mocks, and check the arguments and results of the calls. To use mockito, you need to add it as a dependency in your build tool, and import the relevant packages in your test files.

4 Creating mocks

To create a mock object with mockito, you can use the mock() function, which takes a class or trait as a parameter, and returns an instance of that type. You can also use the @mock annotation, which creates a mock object as a field in your test class. You can then use the when() function to specify the behavior of the mock object when a certain method is called, and the thenReturn() or thenThrow() functions to indicate the result or exception that should be returned or thrown.

5 Using mocks

To use a mock object in your tests, you need to inject it into the object under test, either by passing it as a parameter, or by setting it as a field. You can also use the @injectMocks annotation, which automatically injects the mock objects into the fields of the object under test. You can then use the verify() function to check how many times a method was called on the mock object, and with what arguments. You can also use the argumentCaptor() function to capture the arguments passed to the mock object, and assert on them.

6 Best practices

Testing and mocking Scala objects can be made easier with some best practices. To begin, give descriptive and meaningful names to your tests, mocks, and variables. Additionally, use the given-when-then pattern to structure your tests, which sets up the initial state, executes the action under test, and verifies the outcome. Furthermore, utilize the @before and @after annotations to set up and tear down common fixtures for your tests. The @rule annotation is also useful for applying common rules for tests, such as handling exceptions or timeouts. Moreover, spy() is a great way to create partial mocks that delegate some calls to the real object and mock only the ones you need to control. Finally, don't forget to use the @mockitoScalaSession annotation to enable scala-specific features such as mocking final classes or traits or using implicit parameters.

7 Here’s what else to consider

This is a space to share examples, stories, or insights that don’t fit into any of the previous sections. What else would you like to add?