Java: Spock Framework with spring , spring boot , hsql in memory db

To Start with disclaimer , I am new to Groovy so the syntax I used in this might not be the best practice but that shouldn't be problem as that is the not the problem statement.

Sample Project

The sample project is available on git.

Code is self explanatory . Basically I have tried to test a repository ( inserts data in in memory hsql db which is injected through Spring boot ) and stub a LDAP service which is normally called as part of authentication.

Version of frameworks used

The best way to explain this section is to specify the pom I used

			
<project xmlns="http://maven.apache.org/POM/4.0.0"
	 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

	<modelversion>4.0.0</modelVersion>
	<groupid>SpockTest</groupId>
	<artifactid>SpockSpringTest</artifactId>
	<version>0.0.1-SNAPSHOT</version>

	<parent>
		<groupid>org.springframework.boot</groupId>
		<artifactid>spring-boot-starter-parent</artifactId>
		<version>1.2.6.RELEASE</version>
	</parent>

	<build>
		<sourcedirectory>src</sourceDirectory>
		<plugins>
			<plugin>
				<artifactid>maven-compiler-plugin</artifactId>
				<version>3.1</version>
				<configuration>
					<source>1.8</source>
					<target>1.8</target>
				</configuration>
			</plugin>
		</plugins>
	</build>
	<dependencies>
		<dependency>
			<groupid>org.springframework.boot</groupId>
			<artifactid>spring-boot-starter</artifactId>
		</dependency>

		<dependency>
			<groupid>org.hibernate</groupId>
			<artifactid>hibernate-core</artifactId>
			<version>4.3.11.Final</version>
		</dependency>

		<dependency>
			<groupid>org.spockframework</groupId>
			<artifactid>spock-spring</artifactId>
		</dependency>

		<dependency>
			<groupid>org.springframework</groupId>
			<artifactid>spring-jdbc</artifactId>
			<version>4.1.7.RELEASE</version>
		</dependency>

		<dependency>
			<groupid>org.springframework.boot</groupId>
			<artifactid>spring-boot-starter-data-jpa</artifactId>
		</dependency>
		<dependency>
			<groupid>org.hsqldb</groupId>
			<artifactid>hsqldb</artifactId>
			<scope>runtime</scope>
		</dependency>

		<dependency>
			<groupid>org.spockframework</groupId>
			<artifactid>spock-maven</artifactId>
			<version>0.7-groovy-2.0</version>
		</dependency>

		<dependency>
			<groupid>org.springframework</groupId>
			<artifactid>spring-test</artifactId>
		</dependency>
	</dependencies>

	<dependencymanagement>
		<dependencies>
			<dependency>
				<groupid>org.springframework.boot</groupId>
				<artifactid>spring-boot-starter-test</artifactId>
				<version>1.2.6.RELEASE</version>
				<scope>import</scope>
			</dependency>

		</dependencies>

	</dependencyManagement>

</project>

Integration with spring boot

It was smooth . The only hurdle was we can't use @SpringApplicationConfiguration but need to use @ContextConfiguration directly as shown in the below code . This is the groovy specification which is used for testing.

I have tried to cover

Simple Test case of null check
Data Driven Test (DDT)
And usage of mock

A small hack which was needed to be done in case of DDT specially when using DataTables . It didn't allow for cases in which exceptions do occur . Its again self explanatory in the code.

	

package com.springSpockTest.test;

import static org.junit.Assert.*;
import spock.lang.Shared;
import spock.lang.Specification;
import spock.lang.Unroll;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.SpringApplicationConfiguration;
import org.springframework.boot.test.SpringApplicationContextLoader;
import org.springframework.context.ApplicationContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import com.springSpockTest.SpringBootApp;
import com.springSpockTest.dao.EmployeeLDAPVerifyService;
import com.springSpockTest.dao.RepositoryTest;
import com.springSpockTest.bean.EmployeeBean;



//@SpringApplicationConfiguration(classes = SpringBootApp.class)
@ContextConfiguration(loader = SpringApplicationContextLoader.class,classes = SpringBootApp.class)
class SpringSpockTest extends Specification {

	@Autowired
	RepositoryTest test;

	@Autowired
	ApplicationContext ctx;


	@Shared isTablesInitialized=false;

	def setup(){


		"initialize Table is they havent" ();
	}



	def "initialize Table is they havent" ()
	{
		if(!isTablesInitialized)
		{
			test.createTables();
			isTablesInitialized=true;
		}
		else
			print "table has laready been initialized";
	}

	def "this is to test if jdbc is not null"()
	{


		when:
		def result1=false;
		result1=test.isJdbcTemplateSet();

		then:
		result1==false;
	}

	def "test for employee id"()
	{
		expect: test.getEmployeeName(2)=="Abh jeet";

	}

	def "test for no employee id exist"()
	{
		when:
		test.getEmployeeName(4);

		then:
		RuntimeException e=thrown();
		e.getMessage()=="No Such employee Id exist"	;
	}

	@Unroll
	def "test data driven Syntaxes for #a and #b" (int emplyeeId,String name)
	{
		when:
		def returnedName="doesnt exist"
		try {
			returnedName=test.getEmployeeName(emplyeeId);
		} catch (Exception e) {
			print "exception occured";

		}
		then:
			returnedName==name;
		where:
			emplyeeId||name
			2||new String("Abh jeet");
			4|| new String("doesnt exist");
	}
	
	
	def "test the employee service with stub"()
	{
		
		setup:
			EmployeeBean bean=new EmployeeBean(2,"abhi","jeet");
			
			EmployeeLDAPVerifyService ldapVerifcatorService=Mock();
			1 * ldapVerifcatorService.verifyEmployee(bean) >> true;
			
			bean=new EmployeeBean(4,"abhi","jeet");
			
			1* ldapVerifcatorService.verifyEmployee(bean) >> false;
			
		when:
			bean=new EmployeeBean(3,"abhi","jeet");
			assert ldapVerifcatorService.verifyEmployee(bean) ==false;
			
			bean=new EmployeeBean(4,"abhi","jeet");
			assert ldapVerifcatorService.verifyEmployee(bean) ==false;
			
			bean=new EmployeeBean(2,"abhi","jeet");
			assert ldapVerifcatorService.verifyEmployee(bean) ==true;
				
		then:
			print 'nothing to do';
		
	}





}

Conclusion

I personally found using spock with spring seamless . It was not only easy but due to its groovy influence it was much easier to write .

It incorporates the ease of mockito and brings in new features specially when it comes to mocking like the use of regular expression .

Loved the verbose nature of the failure scenarios which was pretty self explanatory.