Java interview questions and answers on code quality

Open-ended interview questions can tell a lot about a candidate.Code quality starts when you
interview someone. You need the right people with the right skills and most importantly the
right attitude. If you don't know how to achieve good code quality or don't care about it then
your chances of job interview success will be very slim if not zero. The open-ended job
interview questions give you a great opportunity to sell not only your technical skills, but also
your soft-skills and personal traits. Impressive answers in open-ended questions can motivate
your prospective interviewers to overlook any short-comings in your resume like not knowing a
particular framework or tool or not having any experience with a particular application server.
The following questions are very frequently asked, and your answers will be drilled down. So,
don't just rely only on memorizing the answers given below, but apply it.

Q. How do you ensure code quality in your application?

A. code quality means writing readable and robust code, that conforms as much as possible to
the style-guideline that is used, and that has as little as possible defects. It also means writing
maintainable code with proper automated and manual tests.

1. Write a number of automated tests

 Unit tests using JUnit or TestNG. For unit tests use mock objects to ensure that your
tests don't fail due to volatility of the data changes. There are mocking frameworks like
EasyMock, Mockito, and PowerMock.

 Integration testing of your services with JUnit or TestNG. Your integration tests are
only as good as the quality of the data. You could either use dedicated test databases or
use frameworks like DBUnit to manage extraction and insertion of data.

 Web testing using Selenium + WebDriver. Selenium + WebDriver ( Selenium

interview questions and answers) allows you to reenact web user experience and run it as
an automated unit test using JUnit or TestNG.Your tests are only as good as the quality of
the data. You could either use dedicated system test databases or use frameworks like
DBUnit. DBUnit allows you to extract the data from databases into flat XML files, and
then refresh (i.e. insert or update) the data into the database during setup phase of running
the unit tests. There are handy proxy JDBC driver tool called P6SPY, which logs the
SQL queries that are executed against the database by the DBUnit. This P6SPY also very
handy in debugging Hibernate’s generated SQL by acting as a proxy driver between
JDBC and the real driver so that all generated SQL will be logged. There are other Web
testing tools like Badboy.

 Load testing your application with tools like JMeter, OpenSTA, etc. The Badboy
compliments JMeter by allowing you to record scripts and then exporting the scripts as a
JMeter file to be used in JMeter.JMeter Interview Questions and Answers

2. Have regular code reviews. There are tools like Crucible from Atlassian that gives your

1
team an efficient way to benefit from the power of constant code review with features like inline
commenting, simple workflow, asynchronous reviews, email and RSS notifications, JIRA
integration and much more.

3. Using a number of code quality tools.

 Checkstyle ensures the style of your Java code is standardized and "nice". It checks
white spaces, new lines, formatting, etc. (i.e. it looks on the code line by line). This only
ensure style of your code.
 On the other hand there is PMD which not necessarily checks the style of your code but
it checks the structure of the whole code. PMD scans Java source code and looks for
potential problems like possible bugs, dead code, suboptimal code, overcomplicated
expressions, duplicate code, etc.
 FindBugs is a static analysis tool to look for bugs in Java code. It discovers possible
NullPointerExceptions and a lot more bugs.
 Sonar is a very powerful tool covering 7 axes of code quality as shown below.

(The diagram is from the Sonar website)

4. Using continuous integration servers (on a clean separate machine) like Bamboo, Hudson,
CruiseControl, etc to continuously integrate and test your code.

5. Not stopping to code once the code works. Too many developers feel their job stops at
making something happen. It is a best practice to constantly refactor code with proper unit tests
in place.

Q. Do you use test driven development? Why / Why not?

A. [Hint] Yes.

 Gives you a better understanding of what you're going to write. Gets you to clearly think
what the inputs are and what the output is. Helps you separate the concerns by getting
you to think about the single responsibility principle (SRP).
 Enforces a better test coverage. This gives you the confidence to refactor your code in the
future, since you have a good coverage.
 You won't waste time writing features you don't need.

2
Q. How do you keep your knowledge up to date about writing quality code?
A. Mainly through good books and online resources.

Through good books

 Code Complete: A Practical Handbook of Software Construction by Steve McConnel

 Clean Code: A Handbook of Agile Software Craftsmanship by Robert. C. Martin

Through good articles and quick tips at online resources like

 JavaLobby (java.dzone.com)
 TheServerside.com
 InfoQ.com
 handy blogs on Mockito, PowerMock, Easy mock, DBUnit, Selenium, JUnit, TestNG,
etc.

Q. What do you look for when you are reviewing others' code?
A. Firstly, and most importantly look to see if the following key areas are properly adhered to
avoid any potential issues relating to thread-safety, performance, memory leak, scalability,
transaction management, exception handling, etc. Also, look for the key areas like best practices,
design concepts, and design patterns. Key Areas.

Secondly, ensure that proper test cases are written. Also, ensure that it has a good code coverage.

Here are a few finer points:

 Naming conventions.
 Existence of unused code and commenting code out. Delete unused code. Source control
is there for maintaining the history of your code.
 Unnecessary comments. The method and variable names must be self explanatory
without cluttering the code with excessive comments. The methods should do only one
thing with fewer lines of code. More than 15-20 lines of code is questionable. The
number of parameters passed in must also be small. The public methods must fail fast
with proper validations.
 Repeated code due to copy-paste. For example, same logic or hard coded values repeated
in a number of places.
 Favoring trivial performance optimization over readability and maintainability.
 Tightly copuled code. For example, not coding to interfaces, favoring inheritance over
composition, etc.
 Badly defined variable scopes or variable types. For example, using a data type double to
represent monetary values instead of BigDecimal. The variable scopes must be as narrow
as possible.

3
  Using mutable objects and read only varaibles where immutable objects make more
sense.
 Proper implementation of language contracts. For example, not properly implemented
equals and hashCode methods.
 Deeply nested loops or conditionals. Nested loops can be replaced with changing the
logic or through recursion. Nested if-else conditionals are a good candidate for applying
polymorphism.
 Not properly handling exceptions. For example, burying exceptions, exposing internal
exception details to the users without proper friendly messages at the Web layer, etc.
 Badly written unit tests.
 Not designing the classes and interfaces with proper design concepts and principles. For
example, strongly coupled classes, classes trying to do more things than it should,
modelling it as a class when it should be an attribute, etc.
 Not handling and testing non-functional scenarios. For example, not properly handling
service timeouts or using incorrect timeout values.
 Reinventing the wheel by writing your own implementation, when there is already a
proven and tested implementation provided by the API.

Note: The Core Java Career Essentials cover all the above in detail with examples.

Q. There are lots of advantages in writing tests, but in your experience, are there any
disadvantages?
A. [Hint: Everything has pros and cons. Discussing the cons demonstrates your experience, but
make it a point to mention how you overcome the cons to exemplify your problem solving,
researching, and analytical skills.

Tests need to be maintained. If a particular method signature or logic is changed, then all the
relevant tests need to be fixed. Many developers don't put lots of thoughts into writing quality
test cases through proper what if analysis. For example, what if new records are added to the
database? What if the data is missing?, etc. So, this continuous tweaking of test cases will require
time. Writing quality tests require experience and lots of analysis.you need to have an
enthusiastic team and at least one experienced developer who knows how to write good tests, and
also knows a few thing about good architecture

Requires some initial upfront investment in time and cost. But, this initial up front investment
will pay-off significantly in a long run through quality code and robust application.

Q. What is the difference between fake objects, mock objects, and stubs?
A.

 Fake objects build a very lightweight implementation of the same functionality as

provided by a component that you are faking. Since they take some shortcut, they are not
suitable for production.

4
  Mocks are objects pre-programmed with expectations which form a specification of the
calls they are expected to receive. You can use mocking frameworks like EasyMock,
Mockito, PowerMock, etc to achieve this.When an actual service is invoked, a mock
object is executed with a known outcome instead of the actual service. With mock
objects, you can verify if expected method calls were made and how many times. The
verify(mockOrderDao) shown below tells EasyMock to validate that all of the expected
method calls were executed and in the correct order.

?
1
2public void testOrderService() {
3 //....
4
5 expect(mockOrderDao.getOrders(...)) .andReturn(mockResults);
6 replay(mockDao);
assertTrue(service.login(userName, password));
7 verify(mockDao); //expected method calls were executed
8 }
9

 Stubs are like a mock class, except that they don't provide the ability to verify that
methods have been called or not called. Generally services that are not ready or currently
not stable are stubbed to make the test code more stable.

You use a Mock when it's an object that returns values that you set to the tested class. You use a
Stub to mimic an Interface or Abstract class to be tested. In fact, the difference is very subtle and
it doesn't really matter what you call it, fake, mock, or stub, they are all objects that aren't used in
production, and used for managing complexity to write quality tests.

Q. Can you list some of the key principles to remember while designing your classes?
A. Use design principles and patterns, but use them judiciously. Design for current requirements
without anticipating future requirements, and over complicating things. A well designed (i.e.
loosely coupled and more cohesive) system can easily lend itself to future changes, whilst
keeping the system less complex.

 Favor composition over inheritance.

 Don't Repeat Yourself (DRY principle). Code once and only once.
 Find what varies and encapsulate it.
 Code to an interface, and not to an implementation.
 Strive for loose coupling and high cohesion.

5
Q. In your experience, what are some of the common dilemmas you face when writing unit tests?
A. [Hint: provide the dilemma and the tips to overcome the dilemma]

 Whether to fix the code or the test. When you write unit tests, sometimes you feel
compelled to change your code just to facilitate the test. For example, when you need to
test a private method or attribute. Doing so is a bad idea. If you ever feel tempted to make
a private method public purely for testing purposes, don't do it. Testing is meant to
improve the quality of your code, not decrease it. Having said this, in most cases,
thinking about the test first in a TDD (.i.e. Test Driven Development) will help you
refactor and write better code. Also, mock frameworks like PowerMock, let you mock
private methods, static methods, constructors, final classes and methods, etc. Care must
be taken in testing private methods. Inside a class you can end up with a lot of private
methods manipulating instance or class variables without having them passed as
parameters. This leads to high method coupling, and something not recommended.
Instead use private methods that take explicit parameters and provide explicit return
values.

 Whether to use mocks or not. The quality unit tests need to be repeatable. Some non-
deterministic or environmental conditions can make your code fragile. Mocking these
scenarios can make your code more robust. For example, a CircusService class can use a
mock CircusDao to avoid test cases failing due to data related issues. Alternatively, the
test cases can use frameworks like DBUnit to insert data during test set up and remove
data during the test tear down to provide stable data for the test cases. Some test cases
rely on Web service calls, and availability of these services are non-deterministic, and it
makes more sense to mock those services.

 How to test non-functional requirements? For example, a non-functional requirement

like 95 percent of all Web-based transactions should complete within 2 seconds. Your
approach here would be to simply run the test code many times in a loop and compare the
transaction times with target time, and keeping track of the number of passes and fails. If
at the end of the test less than 95 percent of the transactions fail, then fail the test too.
There are scenarios where @Test(timeout=5) becomes handy to fail a test case that takes
longer than 5 seconds to execute.

 Testing multi-thread code. This can be quite challenging and sometimes an impossible
task. If the tests are too complex, then review your code and design. There are ways to
program for multi-threading that are more conducive for testing. For example, making
your objects immutable where possible, reducing the number of instances where multiple
threads interact with the same instance, and using the ExecutorService (e.g. having a
SerialExecutorService which is part of the jconch framework to execute the threads
serially) instead of the Thread class, etc. There are frameworks like GroboUtils and

6
 MultithreadedTC aiming to expand the testing possibilities of Java with support for
multi-threading and hierarchical unit testing. The goal of jconch project is to provide
safe set of implementations for common tasks in multi-threaded Java applications. The
SerialExecutorService class is one of them.

Q. Why use mock objects in unit testing?

A. Unit testing is widely accepted as a "best practice" for software development. When you write
an object, you must also provide an automated test class containing methods by calling its
various public methods with various parameters and making sure that the values returned are
appropriate.

When you're dealing with simple data or service objects, writing unit tests is straightforward.
However, in reality the object under test rely on other objects or layers of infrastructure, and it is
often expensive, impractical, or inefficient to instantiate these collaborators.

For example, to unit test an object that uses a database, it may be burdensome to install a local
copy of the database, run your tests, then tear the local database down again. Mock objects
provide a way out of this dilemma. A mock object conforms to the interface of the real object,
but has just enough code to simulate the tested object and track its behavior. For example, a
database connection for a particular unit test might record the query while always returning the
same hard coded result. As long as the class being tested behaves as expected, it won't notice the
difference, and the unit test can check that the proper query was emitted.

Here are some reasons why mock objects are handy:

 The unit tests as the name implies must test only a unit of the code and not all its
collaborating dependencies. You only have to worry about the class under test. Mock
objects allow you to achieve this by mocking external resource and coding dependencies.
The example in the next question demonstrates how we can mock reading from a file,
which is an external resource.

 The unit tests need to test for the proper boundary conditions. For example, positive
values, negative values, zero value, etc. The mock object make your life easier for
mimicking these boundary conditions.

 One of the biggest mistake one can make in writing quality unit tests is to have state
dependencies between unit tests. The unit tests must be able to run in any order. The
mock objects will help you isolate these state dependencies, and make your tests isolated
and independent.For example

7
 -- Test the DAO in isolation by mocking the calls to external resources like database, file,
etc.
-- Test your service in isolation by mocking the calls to your DAO.

Having said this, too much mocking can make your code hard to read and understand. So, it is
important to have the right balance without overdoing.

Q. How would you go about using mock objects in your unit tests?
A.

STEP 1:

Firstly, you need the relevant dependency jar files. A sample pom.xml file is shown below.

?
1 <properties>
<junit.version>4.8.1</junit.version>
2
<mockito.version>1.8.5</mockito.version>
3 <powermock.version>1.4.8</powermock.version>
4 </properties>
5
6
7
8 <dependencyManagement>
<dependencies>
9 ...
1 <dependency>
0 <groupId>junit</groupId>
1 <artifactId>junit</artifactId>
<version>${junit.version}</version>
1 <scope>test</scope>
1 </dependency>
2 <dependency>
1 <groupId>org.mockito</groupId>
3 <artifactId>mockito-all</artifactId>
<version>${mockito.version}</version>
1 <scope>test</scope>
4 </dependency>
1 <dependency>
5 <groupId>org.powermock</groupId>
1 <artifactId>powermock-module-junit4</artifactId>
<version>${powermock.version}</version>
6 <scope>test</scope>
1 </dependency>
7 <dependency>
1 <groupId>org.powermock</groupId>
<artifactId>powermock-api-mockito</artifactId>
8 <version>${powermock.version}</version>
1 <scope>test</scope>
9 </dependency>
2 ...
0 </dependencies>
<dependencyManagement>
2
8
1
2
2
2
3
2
4
2
5
2
6
2
7
2
8
2
9
3
0
3
1
3
2
3
3
3
4
3
5
3
6
3
7
3
8

STEP 2:

The UserDaoImpl is an implementation of the interface UserDao. The implementation read the
user names from a text file users.tx.

The user.txt

?
1Peter Smith
2Aaron Lachlan
Zara John
3
9
4Felix Chan

The UserDao interface

?
1package unittest;
2
3import java.util.List;
4
5public interface UserDao {
6
7 public List<string> readUsers() throws UsersException;
}
8

The UserDaoImpl class that reads from the user.txt file implements the interface UserDao

?
1 package unittest;
2
import java.io.InputStream;
3 import java.util.Arrays;
4 import java.util.Collections;
5 import java.util.List;
6 import java.util.Scanner;
7
8 public class UserDaoImpl implements UserDao {
9
private static final String DELIMITER =
1 System.getProperty("line.separator");
0
1 public UserDaoImpl(){}
1
1 @Override
public List<string> readUsers() throws UsersException {
2
1 InputStream is = getResource();
3
1 if (is == null) {
4 throw new UsersException("users file is not found");
1 }
5
Scanner sc = new Scanner(is);
1 String value = sc.useDelimiter(DELIMITER + "\r").next();
6
1 String[] users = value.split(DELIMITER);
7
1 return (users == null || users.length > 0 ? Arrays
8 .asList(users) : Collections.<string> emptyList());
}
1
9

10
2
0
2
1
2
2
2
3
2
4
2
5
2
6
2
7
2
8 private InputStream getResource() {
2 ClassLoader cl = Thread.currentThread() .getContextClassLoader();
InputStream is = cl.getResourceAsStream("unittest/users.txt");
9 return is;
3 }
0 }
3 </string></string>
1
3
2
3
3
3
4
3
5
3
6
3
7
3
8
3
9

STEP 3:

Finally the unit test that uses the Mockito framework to mock the actual loading of the user
names from text file. The user names will be supplied via the method getDummyIs(). The
UserDaoImpl is partially mocked with the spy method. This means the getResource() methods is

11
mocked by supplying some dummy data within the test itself. The readUsers() method is
executed from the class under test, which is UserDaoImpl. The getResource() method is mocked
to return a user name of "John Patrick" evey time it is invoked.

?
1 package unittest.test;
2
import java.io.ByteArrayInputStream;
3 import java.io.InputStream;
4 import java.util.List;
5
6 import junit.framework.Assert;
7
8 import org.junit.Test;
9 import org.junit.runner.RunWith;
import org.powermock.api.mockito.PowerMockito;
1 import org.powermock.core.classloader.annotations.PrepareForTest;
0 import org.powermock.modules.junit4.PowerMockRunner;
1
1 import unittest.UserDao;
1 import unittest.UserDaoImpl;
2
@RunWith(PowerMockRunner.class)
1 @PrepareForTest(UserDaoImpl.class)
3 public class UserDaoWithMockTest {
1
4 @Test
1 public void testGetUsers() throws Exception {
final UserDao partiallyMockedUserDao = PowerMockito
5
.spy(new UserDaoImpl());
1 PowerMockito.doReturn(getDummyIs()).when(
6 partiallyMockedUserDao, "getResource");
1 List<string> users = partiallyMockedUserDao.readUsers();
7 Assert.assertEquals(1, users.size());
}
1
8 @Test(expected = unittest.UsersException.class)
1 public void testGetUsersNegative() throws Exception {
9 final UserDao partiallyMockedUserDao = PowerMockito
2 .spy(new UserDaoImpl());
0 PowerMockito.doReturn(null).when(partiallyMockedUserDao,
"getResource");
2 partiallyMockedUserDao.readUsers();
1 }
2
2 @Test(expected = unittest.UsersException.class)
2 public void testGetUsers2() throws Exception {
final UserDao partiallyMockedUserDao = PowerMockito
3 .spy(new UserDaoImpl());
2 PowerMockito
4 .doReturn(new ByteArrayInputStream("".getBytes()))
2 .when(partiallyMockedUserDao, "getResource");
5 List<string> users = partiallyMockedUserDao.readUsers();
Assert.assertEquals(0, users.size());
2
12
6 }
2
public InputStream getDummyIs() {
7 String str = "John Patrick";
2 return new ByteArrayInputStream(str.getBytes());
8 }
2 }
9 </string>
3
0
3
1
3
2
3
3
3
4
3
5
3
6
3
7
3
8
3
9
4
0
4
1
4
2
4
3
4
4
4
5
4
6
4
7
4
8
4

13
9
5
0
5
1
5
2
5
3
5
4
5
5
5
6
5
7

Q. What mocking frameworks have you used?

A. Mockito, EasyMock, and PowerMock.

PowerMock is a framework that extends other mock libraries such as EasyMock and Mockito
with more powerful capabilities like mocking of static methods, constructors, final classes and
methods, private methods, removal of static initializers and more.

As Web application and RESTful web services

are very common in enterprise applications, it is
imperative to unit test the controllers. There are
a number of strategies to unit test your
controllers in an MVC framework. For example,
running an embedded web server like jetty, and
then run the unit tests against the web server,
etc. The spring-test-mvc project makes
testing your Spring MVC controllers very easy
without starting an embedded server. This blog
post will take you through the key steps
involved.

Step 1: You need to have the right third-party libraries. The key ones to take note are spring-
test-mvc, spring-test, json-path, hamcrest-library, hamcrest-core, and mockito-core.

?
1 <dependency>

14
2 <groupId>org.mockito</groupId>
3 <artifactId>mockito-core</artifactId>
<scope>test</scope>
4 <exclusions>
5 <exclusion>
6 <groupId>org.hamcrest</groupId>
7 <artifactId>hamcrest-core</artifactId>
</exclusion>
8 </exclusions>
9 </dependency>
10
11<dependency>
12 <groupId>org.hamcrest</groupId>
13 <artifactId>hamcrest-library</artifactId>
<version>1.3</version>
14</dependency>
15
16<dependency>
17 <groupId>org.codehaus.jackson</groupId>
18 <artifactId>jackson-mapper-asl</artifactId>
<version>1.9.8</version>
19 <scope>runtime</scope>
20</dependency>
21
22<dependency>
23 <groupId>javax.xml.bind</groupId>
24 <artifactId>jaxb-api</artifactId>
<version>2.2.6</version>
25 <scope>runtime</scope>
26</dependency>
27
28<!-- JSON XPATH library -->
29<dependency>
<groupId>com.jayway.jsonpath</groupId>
30 <artifactId>json-path</artifactId>
31 <version>0.5.6</version>
32</dependency>
33
34<!-- spring -->
35
36<dependency>
<groupId>org.springframework</groupId>
37 <artifactId>org.springframework.context</artifactId>
38 <version>3.1.0.RELEASE</version>
39 <exclusions>
40 <!-- Exclude Commons Logging in favour of SLF4j -->
<exclusion>
41 <groupId>org.apache.commons</groupId>
42 <artifactId>com.springsource.org.apache.commons.logging</artifactId>
43 </exclusion>
44 </exclusions>
45</dependency>
<dependency>
46 <groupId>org.springframework</groupId>
47 <artifactId>spring-aop</artifactId>

15
48 <version>3.1.0.RELEASE</version>
49</dependency>
<dependency>
50 <groupId>org.springframework</groupId>
51 <artifactId>spring-aspects</artifactId>
52 <version>3.1.0.RELEASE</version>
53</dependency>
<dependency>
54 <groupId>org.springframework</groupId>
55 <artifactId>spring-beans</artifactId>
56 <version>3.1.0.RELEASE</version>
57</dependency>
58<dependency>
<groupId>org.springframework</groupId>
59 <artifactId>spring-core</artifactId>
60 <version>3.1.0.RELEASE</version>
61 <exclusions>
62 <exclusion>
<artifactId>commons-logging</artifactId>
63 <groupId>commons-logging</groupId>
64 </exclusion>
65 </exclusions>
66</dependency>
67
68<!-- for tspring testing -->
<dependency>
69 <groupId>org.springframework</groupId>
70 <artifactId>spring-test</artifactId>
71 <version>3.1.0.RELEASE</version>
72</dependency>
73
74<dependency>
<groupId>org.springframework</groupId>
75 <artifactId>spring-test-mvc</artifactId>
76 <version>1.0.0.M1</version>
77</dependency>
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93

16
94
95
Step 2: The next step is to define a Spring MVC controller that we will be writing unit test for.

?
1 package com.myapp.accounting.aes.securities.pricehistory.controller;
2
import java.sql.SQLException;
3 import java.util.Date;
4 import java.util.List;
5
6 import javax.annotation.Resource;
7 import javax.servlet.http.HttpServletResponse;
8
9 import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
1 import org.springframework.format.annotation.DateTimeFormat;
0 import org.springframework.http.HttpStatus;
1 import org.springframework.jdbc.CannotGetJdbcConnectionException;
1 import org.springframework.security.authentication.LockedException;
import org.springframework.stereotype.Controller;
1 import org.springframework.web.bind.annotation.ExceptionHandler;
2 import org.springframework.web.bind.annotation.RequestMapping;
1 import org.springframework.web.bind.annotation.RequestMethod;
3 import org.springframework.web.bind.annotation.RequestParam;
1 import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.ResponseStatus;
4
1 import com.myapp.accounting.securities.pricehistory.model.PriceHistory;
5 import
1 com.myapp.accounting.securities.pricehistory.service.PriceHistoryService;
6 import
com.myapp.accounting.dm.model.refdata.securities.MarketDataSecurityPriceHist
1 ;
7
1
8 @Controller
1 public class PriceHistoryController {
9
/**
2 * Service for accessing the Market Data repository. Contains the
0 business logic.
2 */
1 @Resource(name = "aes_priceHistoryService")
private PriceHistoryService securityPriceService;
2
2
2 @RequestMapping(value = "/pricehistory",
3 method = RequestMethod.GET)
2 @ResponseBody
4 public List<MarketDataSecurityPriceHist>
2 getPriceHistory(@RequestParam(value="latestUpdatedTimeStamp", required=true)
@DateTimeFormat(pattern="dd MMM yyyy HH:mm:ss") Date latestUpdatedTimeStamp,
5 @RequestParam(value="ma
2
17
6 xRecords", required=false, defaultValue="100") int maxRecords) throws
2 Exception
7 {
// call the business service
2 PriceHistory result = securityPriceService.getPriceHistory(maxRecords,
8 latestUpdatedTimeStamp);
2
9 return result.getHistory();
}
3 }
0
3
1
3
2
3
3
3
4
3
5
3
6
3
7
3
8
3
9
4
0
4
1
4
2
4
3
4
4
4
5
4
6
4
7
4
8
4

18
9
5
0

Step 3: The PriceHistory object that holds a list of "MarketDataSecurityPriceHist" objects.

?
1 package com.myapp.accounting.aes.securities.pricehistory.model;
2
3 import
com.myapp.accounting.dm.model.refdata.securities.MarketDataSecurityPriceHist
4;
5 import java.io.Serializable;
6 import java.util.ArrayList;
7 import java.util.List;
8
import javax.xml.bind.annotation.XmlElement;
9 import javax.xml.bind.annotation.XmlElementWrapper;
1 import javax.xml.bind.annotation.XmlRootElement;
0
1 @XmlRootElement
1 public class PriceHistory implements Serializable
1{ private static final long serialVersionUID = 1L;
2
1
3 private List<marketdatasecuritypricehist> history = new
1 ArrayList<marketdatasecuritypricehist>();
4
1 @XmlElementWrapper(name = "historicalprices")
@XmlElement(name = "price")
5 public List<marketdatasecuritypricehist> getHistory()
1 {
6 return history;
1 }
7
public void setHistory(List<marketdatasecuritypricehist> history) {
1 this.history = history;
8 }
1}
9 </marketdatasecuritypricehist></marketdatasecuritypricehist></
2 marketdatasecuritypricehist></marketdatasecuritypricehist>
0
2
1
2
2
2
3
2
4
2
19
5
2
6
2
7
2
8
2
9
3
0
3
1

Step 4: Define the MarketDataSecurityPriceHist class that holds the relevant attributes.

?
1 package com.myapp.accounting.dm.model.refdata.securities;
2
import java.io.Serializable;
3 import java.math.BigDecimal;
4 import java.util.Date;
5
6 import javax.persistence.Entity;
7 import javax.xml.bind.annotation.XmlElement;
8
9 @Entity //persistence entity
public class MarketDataSecurityPriceHist implements Serializable
1 {
0 private static final long serialVersionUID = 1444498748039607997L;
1
1 private String securityCd;
1 private Date priceDttm;
private BigDecimal bidPrice;
2 private BigDecimal closePrice;
1 private BigDecimal lastPrice;
3 private BigDecimal askPrice;
1 private String lastUpdatedAction;
4 private String LastUpdatedDetailUser;
private Date lastUpdatedTimeStamp;
1 private Date loadTimeStamp;
5 private String pricecondition;
1 private String recordType;
6 private String priceTime;
private String source;
1
7 public MarketDataSecurityPriceHist() {}
1
8 @XmlElement
1 public String getSecurityCd()
9 {

20
2 return securityCd;
}
0
2 public void setSecurityCd(String securityCd)
1 {
2 this.securityCd = securityCd;
2 }
2
3 @XmlElement
public Date getPriceDttm() {
2 return priceDttm;
4 }
2
5 public void setPriceDttm(Date priceDttm) {
2 this.priceDttm = priceDttm;
}
6
2 @XmlElement
7 public BigDecimal getBidPrice() {
2 return bidPrice;
8 }
2
public void setBidPrice(BigDecimal bidPrice) {
9 this.bidPrice = bidPrice;
3 }
0
3 //other setters and getters are omitted
1 }
3
2
3
3
3
4
3
5
3
6
3
7
3
8
3
9
4
0
4
1
4
2

21
4
3
4
4
4
5
4
6
4
7
4
8
4
9
5
0
5
1
5
2
5
3
5
4
5
5
5
6
5
7
5
8
5
9
6
0
6
1
6
2
Step 5: Finally, and most importantly the unit test class that uses mockito to mock the
PriceHistoryService implementation and spring-test-mvc to mock the controller that returns a
json response.

?
1 package com.myapp.accounting.aes.securities.pricehistory;
2
22
3 import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
4
import static
5 org.springframework.test.web.server.request.MockMvcRequestBuilders.get;
6 import static
7 org.springframework.test.web.server.setup.MockMvcBuilders.standaloneSetup;
8 import static
org.springframework.test.web.server.result.MockMvcResultMatchers.*;
9
1 import java.math.BigDecimal;
0 import java.util.ArrayList;
1 import java.util.Calendar;
1 import java.util.Date;
import java.util.List;
1
2 import org.junit.Before;
1 import org.junit.Test;
3 import org.mockito.Mockito;
1 import org.springframework.http.MediaType;
4
1 import
com.myapp.accounting.aes.securities.pricehistory.controller.PriceHistoryCont
5 roller;
1 import com.myapp.accounting.aes.securities.pricehistory.model.PriceHistory;
6 import
1 com.myapp.accounting.aes.securities.pricehistory.service.PriceHistoryService
;
7
import
1 com.myapp.accounting.aes.securities.pricehistory.service.impl.PriceHistorySe
8 rviceImpl;
1 import
9 com.myapp.accounting.dm.model.refdata.securities.MarketDataSecurityPriceHist
;
2
0 public class PriceHistoryController2Test {
2
1 private PriceHistoryService mockSecurityPriceService;
2 private PriceHistoryController controller;
2
2 @Before
public void setup() {
3 controller = new PriceHistoryController();
2 mockSecurityPriceService = mock(PriceHistoryServiceImpl.class);
4 controller.setSecurityPriceService(mockSecurityPriceService);
2 }
5
2 @Test
public void getPriceHistory() throws Exception {
6
2 when(
7 mockSecurityPriceService.getPriceHistory(
2 (Integer) Mockito.any(), (Date) Mockito.any()))
8 .thenReturn(getPriceHistoryTestData());
2
standaloneSetup(controller)

23
9 .build()
.perform(
3
get(
0 "/pricehistory?latestUpdatedTimeStamp=26 Jul 211
3 12:00:00&maxRecords=3000")
1 .accept(MediaType.APPLICATION_JSON))
3 .andExpect(status().isOk())
.andExpect(content().type("application/json"))
2 .andExpect(jsonPath("$.[0].securityCd").value("test"))
3 .andExpect(jsonPath("$.[0].bidPrice").value(12.50))
3 .andExpect(jsonPath("$.[0].closePrice").value(12.50));
3
4 }
3
//mock data that gets returned when getPriceHistory(...) method is called
5 private static PriceHistory getPriceHistoryTestData() {
3
6 PriceHistory ph = new PriceHistory();
3 List<marketdatasecuritypricehist> history = new
7 ArrayList<marketdatasecuritypricehist>();
MarketDataSecurityPriceHist md = new MarketDataSecurityPriceHist();
3 md.setSecurityCd("test");
8 BigDecimal price = new BigDecimal("12.50");
3 md.setAskPrice(price);
9 md.setBidPrice(price);
4 md.setClosePrice(price);
md.setLastUpdatedAction("SOME_ACTION");
0 md.setRecordType("RECORD_TYPE");
4 md.setLastUpdatedDetailUser("tesr");
1 Calendar cal = Calendar.getInstance();
4 cal.set(2010, 01, 01, 00, 00, 00);
Date date = cal.getTime();
2 md.setLastUpdatedTimeStamp(date);
4 md.setPriceDttm(date);
3 System.out.println(date);
4
4 history.add(md);
ph.setHistory(history);
4
5 return ph;
4 }
6
4 }
7
4
8
4
9
5
0
5
1
5

24
2
5
3
5
4
5
5
5
6
5
7
5
8
5
9
6
0
6
1
6
2
6
3
6
4
6
5
6
6
6
7
6
8
6
9
7
0
7
1
7
2
7
3
7
4
7

25
5
7
6
7
7
7
8
7
9
8
0
8
1
8
2
8
3
8
4
8
5
8
6
8
7

That's all to it for testing an MVC controller. The URL for above JSON RESTful web service
will be something like

?
http://localhost:8080/accounting-server/securities/pricehistory?
1latestUpdatedTimeStamp=26+Jul+2010+12:00:00&maxRecords=3000

and the JSON data returned will be something like

?
[{"securityCd":"XX123","priceDttm":"2012-01-
28","bidPrice":125.50,"closePrice":126.60,"lastPrice":124.50,"askPrice":123.8
0,"lastUpdatedAction":"NO
ACTION","lastUpdatedTimeStamp":1327705288015,"loadTimeStamp":88150,"pricecond
ition":"NO_CONDITION","recordType":null,"priceTime":"10:01:28.150
1AM","source":"HiPort","lastUpdatedDetailUser":"arul"},
2{"securityCd":"YY321","priceDttm":"2012-01-
28","bidPrice":125.50,"closePrice":126.60,"lastPrice":124.50,"askPrice":123.8
0,"lastUpdatedAction":"NO
ACTION","lastUpdatedTimeStamp":1327705288015,"loadTimeStamp":88150,"pricecond
ition":"NO_CONDITION","recordType":null,"priceTime":"10:01:28.150
AM","source":"HiPort","lastUpdatedDetailUser":"arul"}]

26