Geraint is a Core and Enterprise Java contractor who has been working with the language since 2002, primarily on the server-side. Geraint is a DZone MVB and is not an employee of DZone and has posted 13 posts at DZone. You can read more from them at their website. View Full User Profile

Using Spock to Test Spring Classes

10.22.2012
| 4242 views |
  • submit to reddit

As the previous post mentioned, Spock is a powerful DSL built on Groovy ideal for TDD and BDD testing and this post will describe how easy it is to use Spock to test Spring classes, in this case the CustomerService class from the post Using Spring Data to access MongoDB. It will also cover using Spock for mocking.

Spock relies heavily on the Spring's TestContext framework and does this via the @ContextConfiguration annotation. This allows the test specification class to load an application context from one or more locations.

This will then allow the test specification to access beans either via the annotation @Autowired or @Resource. The test below shows how an injected CusotmerService instance can be tested using Spock and the Spring TestContext: (This is a slightly contrived example as to properly unit test the CustomerService class as you would create a CustomerService class in the test as opposed to one created and injected by Spring.)

package com.city81.mongodb.springdata.dao
 
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.test.context.ContextConfiguration
 
import spock.lang.*
 
import com.city81.mongodb.springdata.entity.Account
import com.city81.mongodb.springdata.entity.Address
import com.city81.mongodb.springdata.entity.Customer
 
@ContextConfiguration(locations = "classpath:spring/applicationContext.xml")
class CustomerServiceTest extends Specification {
 
 @Autowired
 CustomerService customerService
  
  
 def setup() {
  customerService.dropCustomerCollection()
 }
  
 def "insert customer"() {
   
  setup:
   
  // setup test class args
  Address address = new Address()
  address.setNumber("81")
  address.setStreet("Mongo Street")
  address.setTown("City")
  address.setPostcode("CT81 1DB")
  
  Account account = new Account()
  account.setAccountName("Personal Account")
  List<Account> accounts = new ArrayList<Account>()
  accounts.add(account)
   
  Customer customer = new Customer()
  customer.setAddress(address)
  customer.setName("Mr Bank Customer")
  customer.setAccounts(accounts)
 
  when:
  customerService.insertCustomer(customer)
   
  then:
  def customers = customerService.findAllCustomers()
  customers.size == 1
  customers.get(0).name == "Mr Bank Customer"
  customers.get(0).address.street == "Mongo Street"
   
 }
}

The problem though with the above test is that MongoDB needs to be up and running so to remove this dependency we can Mock out the interaction the database. Spock's mocking framework provides many of the features you'd find in similar frameworks like Mockito.

The enhanced CustomerServiceTest mocks the CustomerRepository and sets the mocked object on the CustomerService. 

package com.city81.mongodb.springdata.dao
 
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.test.context.ContextConfiguration
 
import spock.lang.*
 
import com.city81.mongodb.springdata.entity.Account
import com.city81.mongodb.springdata.entity.Address
import com.city81.mongodb.springdata.entity.Customer
 
@ContextConfiguration(locations = "classpath:spring/applicationContext.xml")
class CustomerServiceTest extends Specification {
 
 @Autowired
 CustomerService customerService
  
 CustomerRepository customerRepository = Mock()
  
 def setup() {
  customerService.customerRepository = customerRepository
  customerService.dropCustomerCollection()
 }
  
 def "insert customer"() {
   
  setup:
     
  // setup test class args
  Address address = new Address()
  address.setNumber("81")
  address.setStreet("Mongo Street")
  address.setTown("City")
  address.setPostcode("CT81 1DB")
  
  Account account = new Account()
  account.setAccountName("Personal Account")
  List<Account> accounts = new ArrayList<Account>()
  accounts.add(account)
   
  Customer customer = new Customer()
  customer.setAddress(address)
  customer.setName("Mr Bank Customer")
  customer.setAccounts(accounts)
   
  when:
  customerService.insertCustomer(customer)
   
  then:
  1 * customerRepository.save(customer)
   
 }
  
 def "find all customers"() {
  
  setup:
   
  // setup test class args
  Address address = new Address()
  address.setStreet("Mongo Street")
   
  Customer customer = new Customer()
  customer.setAddress(address)
  customer.setName("Mr Bank Customer")
   
  // setup mocking 
  def mockCustomers = []
  mockCustomers << customer
  customerRepository.findAll() >> mockCustomers
   
  when:
  def customers = customerService.findAllCustomers()
   
  then:
  customers.size() == 1 
  customers.get(0).name == "Mr Bank Customer"
   
 }
  
}

The CustomerRepository is by way of name and type although it could be inferred by just the name eg

def customerRepository = Mock(CustomerRepository)

The injected customerRepository is overwritten by the mocked instance and then in the test setup, functionality can be mocked.

In the then block of the insert customer feature, the number of interactions with the save method of customerRepository is tested and in the find all customers feature, the return list of customers from the findAll call is a mocked List,as opposed to one retrieved from the database.

More detail on Spock's mocking capabilities can be found on the project's home page.

 

Published at DZone with permission of Geraint Jones, author and DZone MVB. (source)

(Note: Opinions expressed in this article and its replies are the opinions of their respective authors and not those of DZone, Inc.)