Tag Archives: Java

JUnit Tests for Spring 3 Rest Services

March 16, 2010 Ralf Schäftlein

SpringSource has recently released 3.0.1 of their Spring Framework. Spring 3 extended the REST functionalities inside the Web MVC part of the Framework. Rest Service are defined as Controller and can be tested with the new Resttemplate. In this little sample project is Spring 3 combined with JUnit 4, Maven, Hibernate 3.2, Jetty, MySQL, JPA, JAXB and AspectJ. Additional tests was made with Poster as a Firefox Plugin to test REST bases Webservices. Jetty 6.1 is used as embedded container for the web application as backend for the seperated maven integration tests. Jetty can be started with mvn jetty:run for tests with Poster or will be started before the integration tests runs with mvn integration-test. The Project is configured via Maven pom.xml as seen later in this post. Via mvn eclipse:eclipse will the eclipse settings generated to use the project as WTP project. I used Maven 2.2.1 in combination with eclipse 3.5.2.. As backend infrastructure runs inside Ubuntu 9.1 Server a Bugzilla 3, Artifactory 2.2.1, Subversion 1.6 and a Hudson 1.348.

REST as representational state transferr has less protocol overhead as SOAP. It heavily depends on HTTP mechanism like PUT, GET, DELETE or POST method calls or HTTP accept header definition of the mime type like ‘text/xml’, ‘text/plain’ or ‘image/jpeg’ to define delivered and expected content. So you make a HTTP GET request with an accept header ‘image/jpeg’ with a url like http://myserver/restservice/1 in firefox to see their a picture of catalog item with id 1. A HTTP Post send data to the server as new data and a PUT override existing data. HTTP 1.1 defines a list of methods to use in your REST based Service.

The whole project is Java annotation driven and use JDK 1.6 but can easily switched to run with JDK 1.5 as well. Configuration is Spring based as IOC pattern and as annotations inside the Java classes. XML content is converted by JAXB Marshaller to use only domain objects inside your business logic. Persistence is defined as JPA annotations with Hibernate as implementation against a MySQL 5 database. The code was inspired by a blog from Solomon Duskis.

The Java Source files

The controller RestServiceController

package de.schaeftlein.dev.spring.rest.controller;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;

import de.schaeftlein.dev.spring.rest.dao.PersonDao;
import de.schaeftlein.dev.spring.rest.domain.People;
import de.schaeftlein.dev.spring.rest.domain.Person;

@Controller
@RequestMapping("/people")
public class RestServiceController
{
  @Autowired
  private PersonDao personDao;
  

  @RequestMapping(method = RequestMethod.GET)
  @Transactional(readOnly = true)
  @ResponseBody
  public People getAll() {
    List persons = personDao.getPeople();
    People people = new People(persons);
    return people;
  }
  
  @RequestMapping(value = "/person/{id}", method = RequestMethod.GET)
  @ResponseBody
  @Transactional(readOnly = true)
  public Person getPerson(@PathVariable("id") Long personId) {
    return personDao.getPerson(personId);
  }
  
  @RequestMapping(method = RequestMethod.POST)
  @Transactional(readOnly = false)
  @ResponseBody
  public Person savePerson(@RequestBody Person person) {
    personDao.savePerson(person);
    return person;
  }
}

The Interface for the DAO PersonDAO

package de.schaeftlein.dev.spring.rest.dao;

import java.util.List;

import de.schaeftlein.dev.spring.rest.domain.Person;

public interface PersonDao {

  public Person getPerson(Long personId);

  public void savePerson(Person person);

  public List getPeople();

  public Person getPersonByUsername(String username);

}

The DAO implementation PersonDAOHibernate

package de.schaeftlein.dev.spring.rest.dao.hibernate;

import java.util.List;

import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DataAccessException;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;

import de.schaeftlein.dev.spring.rest.dao.PersonDao;
import de.schaeftlein.dev.spring.rest.domain.Person;

@Repository
@Transactional
@SuppressWarnings("unchecked")
public class PersonDaoHibernate extends HibernateDaoSupport implements
    PersonDao {

  @Autowired
  public void setupSessionFactory(SessionFactory sessionFactory) {
    this.setSessionFactory(sessionFactory);
  }

  public Person getPerson(Long personId) throws DataAccessException {
    return this.getHibernateTemplate().get(Person.class, personId);
  }

  @Transactional(readOnly = false, propagation = Propagation.REQUIRED)
  public void savePerson(Person person) throws DataAccessException {
    this.getHibernateTemplate().saveOrUpdate(person);
  }

  public List getPeople() throws DataAccessException {
    return this.getHibernateTemplate().find("select people from Person people");
  }

  public Person getPersonByUsername(String username) {
    List people = this.getHibernateTemplate().findByNamedParam(
        "select people from Person people "
            + "where people.username = :username", "username", username);
    Person person = getFirst(people);
    if (person != null)
      getHibernateTemplate().evict(person);
    return person;
  }


  private static  T getFirst(List list) {
    return CollectionUtils.isEmpty(list) ? null : list.get(0);
  }
}

The JAXB domain object People

package de.schaeftlein.dev.spring.rest.domain;

import java.io.Serializable;
import java.util.List;

import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement
public class People implements Serializable {
  private static final long serialVersionUID = 1L;

  private List person;

  public People() {
    // empty constructor required for JAXB
  }

  public People(List person) {
    this.person = person;
  }

  public List getPerson() {
    return person;
  }

  public void setPerson(List person) {
    this.person = person;
  }

}

The JAXB and JPA entity domain object Person

package de.schaeftlein.dev.spring.rest.domain;

import java.io.Serializable;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Version;
import javax.xml.bind.annotation.XmlRootElement;

@Entity
@XmlRootElement
public class Person implements Serializable
{
  private static final long serialVersionUID = 1L;

  @Id
  @GeneratedValue
  private Long id;
  private String firstName;
  private String lastName;
  private String username;
  private String password;
  private int roleLevel;

  @Version
  private Integer version;

  public Person()
  {

  }

  public Person(String firstName, String lastName, String username, String password, int roleLevel)
  {
    this.firstName = firstName;
    this.lastName = lastName;
    this.username = username;
    this.password = password;
    this.roleLevel = roleLevel;
  }

  public Long getId()
  {
    return id;
  }

  public void setId(Long id)
  {
    this.id = id;
  }

  public String getFirstName()
  {
    return firstName;
  }

  public void setFirstName(String firstName)
  {
    this.firstName = firstName;
  }

  public String getLastName()
  {
    return lastName;
  }

  public void setLastName(String lastName)
  {
    this.lastName = lastName;
  }

  public String getUsername()
  {
    return username;
  }

  public void setUsername(String username)
  {
    this.username = username;
  }

  public String getPassword()
  {
    return password;
  }

  public void setPassword(String password)
  {
    this.password = password;
  }

  public int getRoleLevel()
  {
    return roleLevel;
  }

  public void setRoleLevel(int roleLevel)
  {
    this.roleLevel = roleLevel;
  }

  public Integer getVersion()
  {
    return version == null ? 1 : version;
  }

  public void setVersion(Integer version)
  {
    this.version = version;
  }

  public enum RoleLevel {
    ADMIN(1), GUEST(2), PUBLIC(3);
    private final int level;

    RoleLevel(int value)
    {
      this.level = value;
    }

    public static RoleLevel getLevel(String roleName)
    {
      return RoleLevel.valueOf(roleName);
    }

    public int getLevel()
    {
      return this.level;
    }
  }

  @Override
  public boolean equals(Object obj)
  {
    if (obj == null)
    {
      return false;
    }
    else if (!(obj instanceof Person))
    {
      return false;
    }
    else
    {
      Person p = (Person) obj;
      if (p.getId().equals(getId()) && p.getUsername().equals(getUsername()) && 
          p.getVersion().equals(getVersion()) && 
          p.getLastName().equals(getLastName()) && p.getPassword().equals(getPassword())
          && p.getFirstName().equals(getFirstName()) && p.getRoleLevel() == getRoleLevel())
      {
        return true;
      }
    }
    return false;
  }

}

The DAO test PersonDAOTest

package de.schaeftlein.dev.spring.rest.dao;

import java.util.List;

import static junit.framework.Assert.*;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.transaction.TransactionConfiguration;

import de.schaeftlein.dev.spring.rest.domain.Person;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "classpath:spring-context.xml" })
@TransactionConfiguration(transactionManager = "transactionManager", defaultRollback = false)
public class PersonDaoTest {

  @Autowired
  PersonDao personDao;
  
  private Logger log = LoggerFactory.getLogger(PersonDaoTest.class);

  @Test
  public void testPerson() {
    String username = "jane.doe";
    Person person = new Person("Jane", "Doe", username, "password",
        Person.RoleLevel.ADMIN.getLevel());
    person.setVersion(1);
    personDao.savePerson(person);

    final List people = personDao.getPeople();
    assertEquals(1, people.size());
    assertEquals(person,people.get(0));
    
    Long personId = person.getId();
    Person savedPerson = personDao.getPerson(personId);
    assertEquals(username,savedPerson.getUsername());
  }

  @Test
  public void testVersion() {
    Person solomon = new Person("John", "Doe", "john.doe", "mypass",
        Person.RoleLevel.ADMIN.getLevel());
    // version 0
    personDao.savePerson(solomon);
    
    Integer version = solomon.getVersion();
    log.info("old version:"+solomon.getVersion());

    
    solomon = personDao.getPersonByUsername("john.doe");
    solomon.setPassword("password1");
    // version 1
    personDao.savePerson(solomon);
    
    log.info("new version:"+solomon.getVersion());
    
    assertTrue(!(version.equals(solomon.getVersion())));
  }
}

The Rest test RestClientTest

package de.schaeftlein.dev.spring.rest.itest.controller;

import static junit.framework.Assert.assertEquals;
import static junit.framework.Assert.assertNotNull;
import static junit.framework.Assert.assertNull;
import static junit.framework.Assert.assertTrue;

import java.util.Collections;
import java.util.Map;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.transaction.TransactionConfiguration;
import org.springframework.web.client.RestTemplate;

import de.schaeftlein.dev.spring.rest.domain.People;
import de.schaeftlein.dev.spring.rest.domain.Person;

@RunWith(SpringJUnit4ClassRunner.class)  
@ContextConfiguration(locations={"classpath:spring-context.xml"}) 
@TransactionConfiguration(transactionManager = "transactionManager", defaultRollback = false)
public class RestClientTest
{
  
  private static final String BASE_URL = "http://localhost:9090/spring3-rest-sample/people";
  
  private Logger log = LoggerFactory.getLogger(RestClientTest.class);
  
  @Autowired
  private RestTemplate restTemplate;

  @Test
  public void saveAndGet() throws Exception{
    // save
    Person input = new Person("jane","doe","jane.doe","pw",Person.RoleLevel.ADMIN.getLevel());
    assertNull(input.getId());
    Person output = restTemplate.postForObject(BASE_URL, input, Person.class, new Object[]{});
    assertNotNull("no person",output);
    assertNotNull(output.getId());
    assertEquals(input.getUsername(), output.getUsername());
    log.info("Saved jane.doe with id "+output.getId());
    // get all
    People people = restTemplate.getForObject(BASE_URL, People.class,new Object[]{});
    assertNotNull("no people",people);
    assertNotNull("no persons in people",people.getPerson());
    assertTrue("empty persons in people",!people.getPerson().isEmpty());
    assertEquals("no one person in people",input.getUsername(),people.getPerson().get(0).getUsername());
    log.info("Peple size "+people.getPerson().size());
    // get id
    Map vars = Collections.singletonMap("id", output.getId()+"");
    Person idPerson = restTemplate.getForObject(BASE_URL+"/person/{id}", Person.class,vars);
    assertNotNull("no person",idPerson);
    assertNotNull(idPerson.getId());
    assertEquals(input.getUsername(), idPerson.getUsername());
    log.info("Get person by id <"+output.getId()+"> : "+idPerson.getUsername());
  }
  
}

The configuration files

The Spring annotation.xml

The JDBC settings jdbc.properties

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/test
jdbc.username=test
jdbc.password=test
jdbc.initialPoolSize=5
jdbc.maxPoolSize=100
jdbc.minPoolSize=5
jdbc.maxStatementsPerConnection=25
jdbc.maxStatements=50
jpa.databasePlatform=org.hibernate.dialect.MySQL5InnoDBDialect
jpa.showSql=true
jdbc.schema=test
jdbc.dataTypeFactory=org.dbunit.ext.mysql.MySqlDataTypeFactory
jdbc.autoCommitOnClose=true
jdbc.autoCommit=true
hibernate.release_mode=after_transaction
hibernate.hbm2ddl=create
hibernate.auto_close_session=true
hibernate.current_session_context_class=thread
hibernate.flush_before_completion=true

The JAXB marshalling.xml




  

  
    
      
        de.schaeftlein.dev.spring.rest.domain.Person
        de.schaeftlein.dev.spring.rest.domain.People

The AOP based transactionAdvices.xml

The spring-dispatcher.xml

The spring-context.xml



	
	
	

   

    
      
    

	
		
			${jdbc.driverClassName}
		
		
			${jdbc.url}
		
		
			${jdbc.username}
		
		
			${jdbc.password}
		
		
			${jdbc.autoCommitOnClose}
		
		
			${jdbc.initialPoolSize}
		
		
			${jdbc.maxPoolSize}
		
		
			${jdbc.minPoolSize}
		
		
			${jdbc.maxStatementsPerConnection}
		
		
			${jdbc.maxStatements}
		
	

	

	
		
			
				${jdbc.url} 
				${jdbc.driverClassName}
				${jdbc.username} 
				${jdbc.password}
				${jdbc.autoCommit}
				${hibernate.release_mode}
				${hibernate.hbm2ddl}
				${hibernate.auto_close_session}
				${hibernate.current_session_context_class}
				false
				false
				javassist
				${hibernate.flush_before_completion}

The web.xml





  spring3-rest-sample
  Spring 3 Rest sample
  

  
    contextConfigLocation
    classpath:spring-context.xml
  

  
    org.springframework.web.context.ContextLoaderListener
    
  

  
    springDispatcher
    org.springframework.web.servlet.DispatcherServlet
    
      contextConfigLocation
      classpath:spring-dispatcher.xml
    
    2
  

  
  
    springDispatcher
    /*

The Maven pom.xml


	4.0.0
	de.schaeftlein.dev.spring.rest
	spring3-rest-sample
	war
	1.0-SNAPSHOT
	spring3-rest-sample Maven Webapp
	A sample project for showing how to write JUnit Test against Spring 3 Rest Services
    
     
       Ralf Schäftlein
       http://ralf.schaeftlein.com
     
    
    2010
    
      bugzilla
      http://ubuntu-vm.localdomain/cgi-bin/bugzilla3/index.cgi
    
    http://ralf.schaeftlein.de/2010/03/05/junit-tests-for-spring-3-rest-spring-3-rest-services

	
		
			
				org.apache.maven.plugins
				maven-surefire-report-plugin
				2.5
			
			
				org.apache.maven.plugins
				maven-checkstyle-plugin
				2.5
			
			
				org.apache.maven.plugins
				maven-javadoc-plugin
				2.6.1
			
			
				org.codehaus.mojo
				cobertura-maven-plugin
				2.3
			
			
				org.apache.maven.plugins
				maven-pmd-plugin
				2.4
				
					utf-8
					1.6
				
			
			
				org.apache.maven.plugins
				maven-jxr-plugin
				2.1
				
					UTF-8
					UTF-8
				
			
			
				org.codehaus.mojo
				taglist-maven-plugin
				2.4
			
			
				org.apache.maven.plugins
				maven-changes-plugin
				2.3
				
					
						
							changes-report
						
					
				
			
		
	
	
		
			internal
			
				dav:http://ubuntu-vm.localdomain:8081/artifactory/internal
			
		
		
			snapshots
			
				dav:http://ubuntu-vm.localdomain:8081/artifactory/snapshots
			
		
	
	
		
           scm:svn:http://ubuntu-vm.localdomain/svn/
       
		
           scm:svn:http://ubuntu-vm.localdomain/svn/
       
		http://ubuntu-vm.localdomain/svn/
	
	
		Hudson
		http://ubuntu-vm.localdomain/hudson/job/spring3-rest-sample
	
	
		spring3-rest-sample
		
			
				org.apache.maven.plugins
				maven-surefire-report-plugin
				2.5
			
			
				org.apache.maven.plugins
				maven-deploy-plugin
				2.5
			
			
				org.apache.maven.plugins
				maven-surefire-plugin
				2.5
				
					true
				
				
					
						surefire-test
						test
						
							test
						
						
							false
							
								**/itest/**
							
						
					

					
						surefire-itest
						integration-test
						
							test
						
						
							false
							
								**/itest/**
							
						
					
				
			
			
				org.apache.maven.plugins
				maven-pmd-plugin
				2.4
				
					utf-8
					1.6
				
				
					
						
							check
							cpd-check
						
					
				
			
			
				org.codehaus.mojo
				cobertura-maven-plugin
				2.3
				
					
						html
						xml
					
				
			
			
				org.apache.maven.plugins
				maven-jxr-plugin
				2.1
			
			
				org.apache.maven.plugins
				maven-checkstyle-plugin
				2.5
			
			
				maven-compiler-plugin
				2.1
				
					1.6
					1.6
				
			
			
				org.mortbay.jetty
				maven-jetty-plugin
				6.1.22
				
					10
					foo
					9999
					/${artifactId}
					
						
							9090
							60000
						
					
				
				
					
						start-jetty
						pre-integration-test
						
							run
						
						
							0
							true
						
					
					
						stop-jetty
						post-integration-test
						
							stop
						
					
				
			

			
				org.apache.maven.plugins
				maven-eclipse-plugin
				2.8
				
					true
					true
					2.0
				
			
			
			
				org.apache.maven.plugins
				maven-jar-plugin
				2.3
				
					
						
							true
						
					
				
			
			
			
				org.apache.maven.plugins
				maven-source-plugin
				2.1.1
				
					
						attach-sources
						verify
						
							jar
						
					
				
			
			
				org.apache.maven.plugins
				maven-scm-plugin
				1.3
				
					${svn_username}
					${svn_password}
				
			
			
				org.apache.maven.plugins
				maven-war-plugin
				2.1-beta-1
				
					src/main/webapp
					src/main/webapp/WEB-INF/web.xml
					
					
						
					
						
							true
							lib/
						
					
				
			
		
		
		
			
				src/main/resources
				
					**/.svn
					**/.svn/**
					**/_svn
					_svn
					**/_svn/**
				
			
		
		
			
				src/test/resources
				
					**/.svn
					**/.svn/**
					**/_svn
					_svn
					**/_svn/**
				
			
		
	



	
		3.0.1.RELEASE
		1.5.2
		UTF-8
	

	
		
		
			org.aspectj
			aspectjweaver
			1.6.2
		
		
			org.aspectj
			aspectjrt
			1.6.2
			
		
		
			org.springframework
			spring-beans
			${spring.framework.version}
		
		
			org.springframework
			spring-context-support
			${spring.framework.version}
			
				
					quartz
					quartz
				
			
		
		
			org.springframework
			spring-core
			${spring.framework.version}
		
		
			org.springframework
			spring-aspects
			${spring.framework.version}
		
		
			org.springframework
			spring-jdbc
			${spring.framework.version}
		
		
			org.springframework
			spring-test
			${spring.framework.version}
			test
		
		
			org.springframework
			spring-orm
			${spring.framework.version}
		
		
			org.springframework
			spring-oxm
			${spring.framework.version}
		
		
			org.springframework
			spring-tx
			${spring.framework.version}
		
		
			org.springframework
			spring-web
			${spring.framework.version}
		
		
			org.springframework
			spring-webmvc
			${spring.framework.version}
		

		
		
			cglib
			cglib-nodep
			2.1_3
		
		
			org.hibernate
			hibernate-annotations
			3.2.0.ga
		
		
			org.hibernate
			hibernate
			3.2.6.ga
		
		
			javax.persistence
			persistence-api
			1.0
		
		
			javassist
			javassist
			3.11.0.GA
		

		
		
			mysql
			mysql-connector-java
			5.1.12
			jar
			compile
		
		
			c3p0
			c3p0
			0.9.1.2
			jar
			compile
		
		
			commons-dbcp
			commons-dbcp
			1.4
		
		
			commons-collections
			commons-collections
			3.2.1
		
		
			javax.transaction
			jta
			1.1
		

		
		
			javax.xml.bind
			jaxb-api
			2.0
		

		
		
			junit
			junit
			4.8.1
			test
		
		
		
			org.slf4j
			slf4j-api
			${org.slf4j.version}
		
		
			org.slf4j
			slf4j-simple
			${org.slf4j.version}
		
		
		
			org.mortbay.jetty
			maven-jetty-plugin
			6.1.15
			test

Sample Content for Poster

The person.xml



    Jane
    Doe
    jane.doe
    bar
    2

Java

ide for testing JDK 7 features (Milestone 5: Build b76)

December 4, 2009 Ralf Schäftlein

Sun has published milestone 5 (b76) of the upcoming Java JDK 7. JDK 7 release is currently scheduled for September 2010. My standard IDE is eclipse but the current production version 3.5 SR 1 support only Java up to JDK 6. I tried the new eclipse e4 1.0 milestone 2 (status: technical preview) which has JDK support up to JDK 7. You can define a JDK 7 as new JRE and create a new Java project with that JRE and compiler compliance level JDK 1.7. According to Joseph Darcy from SUN is a developer build of Netbeans available with support for JDK 7. I tested with code from CertPal which includes several features of JDK 7. Eclipse e4 still complain about compiler errors but the developer build of netbeans can compile and run the sample code. Check in netbeans under tools -> Java platform the availability of JDK 7 and create a new java project. Set in the java project under properties the source/binary format to jdk 1.7 (sources tab) and choose as java platform JDK 1.7 (libraries tab). On OpenJDK is a overview of the current implemented features of JDK 7 in the M5 version. Mark Reinhold from sun blogs as well about the new features. A more complete list of features which was formerly planned shows Alex Miller in his blog.

Java

Spring 3.0 RC 2 and JSR-330 (Dependency Injection for Java)

November 19, 2009 Ralf Schäftlein

SpringSource has published release candidate 2 of the upcoming 3.0 release of their Spring Framework. New Feature is the compliance with JSR-330 (“Dependency Injection for Java”). The JSR was developed together by Google (for their Guice Framework and SpringSource (for their Spring Framework) and is finally approved since 14.10.2009.

A little example shows how to develop services with interfaces and implementations without dependencies to Spring Framework or Google Guice:

The Maven pom.xml


	4.0.0
	de.schaeftlein.dev
	jsr330-sample
	jar
	jsr330-sample
	0.0.1-SNAPSHOT
	Sample App with Spring 3.0 RC 2 and JSR330
	
		3.0.0.RC2
	

	
		
			org.springframework
			spring-core
			${springVersion}
		
		
			org.springframework
			spring-beans
			${springVersion}
		
		
			org.springframework
			spring-context
			${springVersion}
		
		
			org.springframework
			spring-asm
			${springVersion}
		
		
			org.springframework
			spring-expression
			${springVersion}
		
		
			junit
			junit
			4.7
			test
		
		
			javax.inject
			javax.inject
			1
		
	
	
		jsr330-sample
		src/main/java
		${basedir}/src/test/java

		
		
			
				src/main/resources
				
					**/.svn
					**/.svn/**
					**/_svn
					_svn
					**/_svn/**
				
			
		
		
			
				src/test/resources
				
					**/.svn
					**/.svn/**
					**/_svn
					_svn
					**/_svn/**
				
			
		
		
			
				org.apache.maven.plugins
				maven-compiler-plugin
				
					1.6
					1.6
				
			
			
				org.apache.maven.plugins
				maven-eclipse-plugin
				
					true
					true
					
						_svn
						.svn
					
				
			
			
				org.apache.maven.plugins
				maven-jar-plugin
				
					
						
							true
						
					
				
			
			
			
				org.apache.maven.plugins
				maven-source-plugin
				
					
						attach-sources
						verify
						
							jar

a simple encode/decode interface

package de.schaeftlein.dev.spring;

public interface Encryption
{
  String encode(String value);
  String decode(String value);
}

a simple implementation for Encryption

package de.schaeftlein.dev.spring;

import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.net.URLEncoder;

import javax.inject.Named;

@Named // service name is the name of the class
public class URLEncoderEncyrption implements Encryption
{

  @Override
  public String decode(String value)
  {
    try
    {
      return URLDecoder.decode(value, "UTF-8");
    }
    catch (UnsupportedEncodingException e)
    {
      return null; // never happen
    }
  }

  @Override
  public String encode(String value)
  {
    try
    {
      return URLEncoder.encode(value, "UTF-8");
    }
    catch (UnsupportedEncodingException e)
    {
      return null; // never happen
    }
  }

}

a more secure implementation for Encryption

package de.schaeftlein.dev.spring;

import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;
import javax.inject.Named;

import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

import com.sun.org.apache.xml.internal.security.utils.Base64;

@Named("secure") // named service bean
public class Base64Encyption implements Encryption
{
  private sun.misc.BASE64Encoder base64encoder;
  private SecretKey key;

  public Base64Encyption()
  {
    try
    {
      DESKeySpec keySpec = new DESKeySpec("Your secret Key phrase".getBytes("UTF8"));
      SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
      key = keyFactory.generateSecret(keySpec);
      base64encoder = new BASE64Encoder();
    }
    catch (Exception e)
    {
      e.printStackTrace();
    }
  }

  @Override
  public String decode(String input)
  {
    try
    {
      Cipher cipher = Cipher.getInstance("DES"); // cipher is not thread safe
      cipher.init(Cipher.DECRYPT_MODE, key);
      byte[] bOut = cipher.doFinal(Base64.decode(input.getBytes("UTF-8")));
      return new String(bOut, "UTF-8");
    }
    catch (Exception e)
    {
      e.printStackTrace();
    }
    return null;
  }

  @Override
  public String encode(String plainTextPassword)
  {
    try
    {
      byte[] cleartext = plainTextPassword.getBytes("UTF8");

      Cipher cipher = Cipher.getInstance("DES"); // cipher is not thread safe
      cipher.init(Cipher.ENCRYPT_MODE, key);
      return base64encoder.encode(cipher.doFinal(cleartext));
    }
    catch (Exception e)
    {
      e.printStackTrace();
    }
    return null;
  }

}

a small interface for a service

package de.schaeftlein.dev.spring;

public interface SecureUtil
{
  void compareEncryption(String input);
}

a implementation for our service

package de.schaeftlein.dev.spring;

import javax.inject.Inject;
import javax.inject.Named;

@Named("SecureUtil")
public class SecureUtilImpl implements SecureUtil
{
  @Inject // automatically set by DI framework
  @Named("secure") // get the namend bean
  private Encryption secureEncryption;
  
  @Inject // automatically set by DI framework
  @Named("URLEncoderEncyrption") // get the bean by its classname
  private Encryption unsecureEncryption;
  
  public void compareEncryption(String input){
    
    String encodedSecure = secureEncryption.encode(input);
    System.out.println("Secure encoded: "+encodedSecure);
    String encodeUnsecure = unsecureEncryption.encode(input);
    System.out.println("Unsecure encoded: "+encodeUnsecure);
    System.out.println("Secure decoded: "+secureEncryption.decode(encodedSecure));
    System.out.println("Unsecure decoded: "+unsecureEncryption.decode(encodeUnsecure));
  }
}

finally a main class for testing

package de.schaeftlein.dev.spring;

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Main
{

  /**
   * main method
   */
  public static void main(String[] args)
  {
    ApplicationContext ctx = new AnnotationConfigApplicationContext(Main.class.getPackage().getName()); // new way to get Application context without applicationContext.xml available
    SecureUtil util = ctx.getBean("SecureUtil", SecureUtil.class); // get bean with new generics method
    util.compareEncryption("an sample input string 1234567890");
  }

}

output of our Main class

19.11.2009 18:56:03 org.springframework.context.support.AbstractApplicationContext prepareRefresh
INFO: Refreshing org.springframework.context.annotation.AnnotationConfigApplicationContext@c1b531: startup date [Thu Nov 19 18:56:03 CET 2009]; root of context hierarchy
19.11.2009 18:56:03 org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor 
INFO: JSR-330 'javax.inject.Inject' annotation found and supported for autowiring
19.11.2009 18:56:03 org.springframework.beans.factory.support.DefaultListableBeanFactory preInstantiateSingletons
INFO: Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@a83b8a: defining beans [org.springframework.context.annotation.internalConfigurationAnnotationProcessor,org.springframework.context.annotation.internalAutowiredAnnotationProcessor,org.springframework.context.annotation.internalRequiredAnnotationProcessor,org.springframework.context.annotation.internalCommonAnnotationProcessor,secure,SecureUtil,URLEncoderEncyrption]; root of factory hierarchy
Secure encoded: QDQvd4uK14YNUQ4uoqhqsZEMDDxUqJAMyisvZr2wsA2GyMC5tSEIiw==
Unsecure encoded: an+sample+input+string+1234567890
Secure decoded: an sample input string 1234567890
Unsecure decoded: an sample input string 1234567890

Java, Linux

Howto setup a OpenLDAP Server for Ubuntu 8.10

June 22, 2009 Ralf Schäftlein

Most enterprises use LDAP as interface to their company structure database. In the Microsoft world is Active Directory the implementation for LDAP. Under Linux is OpenLDAP the common choice for admins. Such LDAP directories are tree based. OpenLDAP is the reference implementation for LDAP v3.

The JNDI API inside the Java SDK is usable as implementation to access such LDAP directories. With Spring LDAP is more sophisticated API available.

My first code sample works in the company against their OpenLDAP server. For security reasons is the access not possible from outside. So my JUNIT Tests was code red after running in my homeoffice. Maven standard is to run all test prior to build a package like a J2EE war or ear file. So i decided to setup a OpenLDAP server inside my ubuntu 8.10 server vmware server vm.

First step is to retrieve and install the openldap package as root:

sudo su –
apt-get install slapd ldap-utils nmap php5-ldap db4.2-util

You have to set a password during installation for the OpenLDAP server. Keep that in mind!
Now run the configuration assistant:

dpkg-reconfigure slapd

Wizard steps:

omit openldap server configuration? – no
dns domain name? vm.example.org
organization name? myCompany
database backend to use? hdb
do you want the database to be removed when slapd is purged? yes
may be the question: move old database? yes
administrator password? the same one as entered during installation
confirm password? see last step
allow LDAPv2 protocol? no

Now edit the /etc/ldap/ldap.conf file for the client side configuration:

ldap_version 3
URI ldap://localhost:389
SIZELIMIT 0
TIMELIMIT 0
DEREF never
BASE dc=vm,dc=example, dc=org

With the command “ldapsearch -x” you should see the following output:

# extended LDIF
#
# LDAPv3
# base  (default) with scope subtree
# filter: (objectclass=*)
# requesting: ALL
#

# vm.example.org
dn: dc=vm,dc=example,dc=org
objectClass: top
objectClass: dcObject
objectClass: organization
o: myCompany
dc: vm

# admin, vm.example.org
dn: cn=admin,dc=vm,dc=example,dc=org
objectClass: simpleSecurityObject
objectClass: organizationalRole
cn: admin
description: LDAP administrator

# search result
search: 2
result: 0 Success

# numResponses: 3
# numEntries: 2

For easier admininstration exist a php admin ui called phpldapadmin and can be installed with:

apt-get install phpldapadmin
ln -s /usr/share/phpldapadmin/ /var/www/phpldapadmin

Open now the config file /etc/phpldapadmin/config.php with joe (a editor) and change the line with the ldap node info to:


/* Array of base DNs of your LDAP server. Leave this blank to have phpLDAPadmin
   auto-detect it for you. */
$ldapservers->SetValue($i,'server','base',array('dc=vm,dc=example,dc=org'));
...
$ldapservers->SetValue($i,'login','dn','cn=admin,dc=vm,dc=example,dc=org');

Check your PHP5 memory settings in /etc/php5/apache2/php.ini:

memory_limit = 64M      ; Maximum amount of memory a script may consume (16MB)

Restart the apache to use this changed configuration

/etc/init.d/apache2 restart

and go to:

http://your.vm.ip/phpldapadmin

Click on the login link on the left side and enter as “login dn”:

cn=admin,dc=vm,dc=example,dc=org

and your password in mind. First step is now to enter a “organisational unit”:

click on the left side on the link beside the world icon “dc=vm…”
click on “create a child entry here”
choose “organisational unit” as template
enter “people” and click on “create object”
click on this new orginsational unit people in the tree
click on “create a child entry here”
choose “Address Book Entry (mozillaOrgPerson)” as template
enter “John” as “first name”
enter “Doe” as “last name”
go to common name (cn) and enter “John Doe”
click on “create object”

Now check with “ldapsearch -x” if everything is ok:

# extended LDIF
#
# LDAPv3
# base  (default) with scope subtree
# filter: (objectclass=*)
# requesting: ALL
#

# vm.example.org
dn: dc=vm,dc=example,dc=org
objectClass: top
objectClass: dcObject
objectClass: organization
o: myCompany
dc: vm

# admin, vm.example.org
dn: cn=admin,dc=vm,dc=example,dc=org
objectClass: simpleSecurityObject
objectClass: organizationalRole
cn: admin
description: LDAP administrator

# people, vm.example.org
dn: ou=people,dc=vm,dc=example,dc=org
objectClass: organizationalUnit
objectClass: top
ou: people

# John Doe, people, vm.example.org
dn: cn=John Doe,ou=people,dc=vm,dc=example,dc=org
objectClass: inetOrgPerson
objectClass: top
givenName: John
sn: Doe
cn: John Doe

# search result
search: 2
result: 0 Success

# numResponses: 5
# numEntries: 4

Your LDAP server is now running and you can easily configure it inside your favorite browser

LDAP Tree

Java

Dbunit with JUnit 4.x and Spring for testing Oracle DB Application

January 5, 2009 Ralf Schäftlein

DBUnit is very nice for testing database content changes made by an application. You define in XML the data including the structure of your tables (dataset.xml).

Simple_Data is the name of the table and each column is a attribute in the xml doc with the content value e.g. id with value 1.

The Getting Started of DBUnit work with JUnit 3.8 and self handling of the JDBC Connection.

JUnit 4.x are more comfortable with annotations based test methods and Spring comes with dependency injection for separating
configuration from implementation code.

The following approach combines DBUnit with JUnit 4.4 and Spring 2.5.6 to test comfortable a Oracle 10g database.

I use Maven 2.x to define the depending libraries used by the example (pom.xml):



	4.0.0
	de.schaeftlein.dev.dbunit
	test-dbunit
	test-dbunit
	0.0.1-SNAPSHOT
	
	
		
			org.dbunit
			dbunit
			2.4.2
		
		
			org.springframework
			spring
			2.5.6
			jar
			compile
		
		
			junit
			junit
			4.4
		
		
			commons-dbcp
			commons-dbcp
			1.2.2
		
		
			org.springframework
			spring-test
			2.5.6
		
		
			org.slf4j
			slf4j-api
			1.5.6
		
		
			org.slf4j
			log4j-over-slf4j
			1.5.6
		
		
			log4j
			log4j
			1.2.14
		
		
			org.slf4j
			slf4j-log4j12
			1.5.6
		
		
			com.oracle
			ojdbc14
			10.2.0.2.0

Keep in mind that the Oracle JDBC Driver has to be downloaded manually.
The public maven repos include only the Pom definition for the oracle driver. Generate with maven command line tool the eclipse project files:

mvn clean eclipse:clean eclipse:eclipse

The JDBC datasource is defined via Spring (applicationContext.xml):

Additionally we define the expected data as well in XML for DBUnit (expectedDataSet.xml):

Now we can code our JUnit 4.x Test to

load data before the test method
change the data via JDBC to emulate a application
compare the changed data with expected data
clean up the database

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={"classpath:applicationContext.xml"}) 
public class TestDBUnitWithSpring {

	@Autowired
	private DataSource dataSource;
	
	@Before
	public void init() throws Exception{
		// insert data into db
		DatabaseOperation.CLEAN_INSERT.execute(getConnection(), getDataSet());
	}
	
	@After
	public void after() throws Exception{
		// insert data into db
		DatabaseOperation.DELETE_ALL.execute(getConnection(), getDataSet());
	}
	
	private IDatabaseConnection getConnection() throws Exception{
	// get connection
		Connection con = dataSource.getConnection();
		DatabaseMetaData  databaseMetaData = con.getMetaData();
		// oracle schema name is the user name
		IDatabaseConnection connection = new DatabaseConnection(con,databaseMetaData.getUserName().toUpperCase());
		DatabaseConfig config = connection.getConfig();
		// oracle 10g 
		config.setProperty(DatabaseConfig.PROPERTY_DATATYPE_FACTORY, new Oracle10DataTypeFactory());
		// receycle bin
		config.setFeature(DatabaseConfig.FEATURE_SKIP_ORACLE_RECYCLEBIN_TABLES, Boolean.TRUE);
		return connection;
	}
	
	private IDataSet getDataSet() throws Exception{
		// get insert data
		File file = new File("src/test/resources/dataset.xml");
		return new FlatXmlDataSet(file);
	}
	
	@Test
	public void testSQLUpdate() throws Exception{
		Connection con = dataSource.getConnection();
		Statement stmt = con.createStatement();
		// get current data
		ResultSet rst = stmt.executeQuery("select * from simple_data where id = 1");
		if(rst.next()){
			// from dataset.xml
			assertEquals("value_before", rst.getString("content"));
			rst.close();
			
			// update via sql
			int count = stmt.executeUpdate("update simple_data set content='value_after' where id=1");

			stmt.close();
			con.close();

			// expect only one row to be updated
			assertEquals("one row should be updated", 1, count);

			// Fetch database data after executing the code
			QueryDataSet databaseSet = new QueryDataSet(getConnection());
			// filter data
			databaseSet.addTable("simple_data", "select * from simple_data where id = 1");
			ITable actualTable = databaseSet.getTables()[0];

			// Load expected data from an XML dataset
			IDataSet expectedDataSet = new FlatXmlDataSet(new File("src/test/resources/expectedDataSet.xml"));
			ITable expectedTable = expectedDataSet.getTable("simple_data");

			// filter unnecessary columns of current data by xml definition
			actualTable = DefaultColumnFilter.includedColumnsTable(actualTable, expectedTable.getTableMetaData().getColumns());

			// Assert actual database table match expected table
			assertEquals(1,expectedTable.getRowCount());
			assertEquals(expectedTable.getRowCount(), actualTable.getRowCount());
			assertEquals(expectedTable.getValue(0, "content"), actualTable.getValue(0, "content"));
			
		} else {
			fail("no rows");
			rst.close();
			stmt.close();
			con.close();
		}

	}
}

Ralf Schäftlein's Blog

Tag Archives: Java

JUnit Tests for Spring 3 Rest Services

ide for testing JDK 7 features (Milestone 5: Build b76)

Spring 3.0 RC 2 and JSR-330 (Dependency Injection for Java)

Howto setup a OpenLDAP Server for Ubuntu 8.10

Dbunit with JUnit 4.x and Spring for testing Oracle DB Application

tech stuff, development news…

May 2024
M	T	W	T	F	S	S
« Jun
		1	2	3	4	5
6	7	8	9	10	11	12
13	14	15	16	17	18	19
20	21	22	23	24	25	26
27	28	29	30	31

May 2024
M	T	W	T	F	S	S
« Jun
		1	2	3	4	5
6	7	8	9	10	11	12
13	14	15	16	17	18	19
20	21	22	23	24	25	26
27	28	29	30	31