Styjun

I was trying to do j-unit test for project which insert values into database using hibernate classes. The program is creating tables and inserting values into database. but i am not able to do the j-unit part for the test?

I have attached the java table, but the value that i inserting using the test file is not display when i debugged it?

Sample.java

@Entity
public class Sample 

	@Id
	private int sid;
	private String name;
	public void set_sid(int sid)
	
		this.sid=sid;
	
	public void set_name(String name)
	
		this.name=name;
	
	public int get_sid()
	
		return sid;
	
	public String get_name()
	
		return name;
	
	

SampleInsert.java

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class SampleInsert 

	private Sample s;
	private static SessionFactory sf; 

	
	public void insert() 
		sf = new Configuration().configure(new File("C:/Users/ns068002/eclipse-workspace/JAXRS-HelloWorld1/src/main/java/com/javacodegeeks/enterprise/rest/jersey/hibernate.cfg.xml")).buildSessionFactory();
		Session session = sf.getCurrentSession();
 session.beginTransaction(); 
 Sample s=(Sample) session.get(Sample.class, 1);
 System.out.println(s+"2");
 System.out.println(s.get_name());
 session.getTransaction().commit();
	

SampleInsertTest.java

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class SampleTest 

	Session session;
	SampleInsert st;
	
	@Before
	public void setUp() 

	 session=mock(Session.class);
		st=new SampleInsert();
	
	
	@Test
	public void test() 
		Sample s=new Sample();
		s.set_sid(1);
		s.set_name("gopal");
		Mockito.when(session.get(Sample.class,1)).thenReturn(s);
		System.out.println(s+"1");
		st.insert();
	

Looking at your code, I can not see how you would be able to mock/stub the Session or SessionFactory as neither of these things are "injected" into the class SampleInsert.

By "injected" I mean that the values are not passed into the class in some way, this is usually done using annotation with a framework like Spring, or via constructors.

It should be remembered that we are not testing the thing we are mocking, we are replacing the thing being mocked with a representation that is much simpler in order to test a component that makes use of the thing being mocked.

As an example of how you might use Mockito:

public interface SomethingToMock 
 int returnSomeValueFor(int value);


public class ToBeTested 
 private SomethingToMock session;

 public ToBeTested(SomethingToMock session) 
 this.session = session;
 

 public void methodToTestA(int value) 
 returnSomeValueFor(value);
 

 public int methodToTestB(int value) 
 int i = returnSomeValueFor(value);
 return i * i;
 


@RunWith(MockitoJUnitRunner.class)
public class SomeTests 
 @Mock
 private SomethingToMock aMock;

 private ToBeTested underTest;

 @Before
 public void setUp() 
 underTest = new ToBeTested(aMock);
 

 @Test
 public void testOne() 
 underTest.MethodToTestA(3);

 verify(aMock).returnSomeValueFor(3);
 

 @Test
 public void testTwo() 
 when(aMock.returnSomeValueFor(3)).thenReturn(2);

 int r = underTest.methodToTestB(3);

 assertEqual(r, 4);
 

In the example above we create an interface, this represents the thing to be mocked, we should aim to only mock interfaces and only those we or our team has created.

We then have a class that we need to test that uses the interface ToBeTested we can assume that concrete implementation of the interface are tested elsewhere in the project.
ToBeTested has two methods to test, one that has no return so has no side effects that we can see. The second method does some processing and has a side effect.

We then create a test class to test both methods, we insure it is setup to use Mockito (@RunWith(MockitoJUnitRunner.class) we then setup a mock using @Mock, the final setup step is to ensure our class has the mock "injected" into it, this is done in the setUp() method.

Finally we create two tests the first verifies that the mocked method is called, we don't have to set up a when for this in this case as no value will be returned from the method we are testing, just from the method being mocked I believe Mockito will return the default for an int.

The second test tests that a value is returned, thus we setup a when, when the mocked method is called in the way specified in the when the given value is returned and we can assert that the correct value is returned from the method under test, in this case using assertThat

This is the general layout of testing with Mockito. Effective testing is a huge topic, I would suggest you do some research on the web. The Mockito and JUnit docs are very good, and of course GitHub has many projects using both; one idea might be to look at the Mockito and Unit on Github and look at their testing.

Also the Mockito documentation does a very good job of explaining how, why and when to use mocking: http://static.javadoc.io/org.mockito/mockito-core/2.25.1/org/mockito/Mockito.html

I hope this helps.