Example Production Code and Test (Wicket, Spring, Hibernate, Junit, EasyMock)

2025-01-07



Page Layer

Html Java Test 
<!DOCTYPE html>
<html xmlns:wicket="http://wicket.apache.org">
<head>
    <title>Employee Management</title>
</head>
<body>
    <h1>Employee Management</h1>

    <h2>Employee List</h2>
    <ul wicket:id="employeeList">
        <li>
            <span wicket:id="name"></span> - 
            <span wicket:id="department"></span> - 
            <span wicket:id="salary"></span>
        </li>
    </ul>

    <h2>Add/Update Employee</h2>
    <form wicket:id="employeeForm">
        <label>Name: <input type="text" wicket:id="name"/></label><br/>
        <label>Department: <input type="text" wicket:id="department"/></label><br/>
        <label>Salary: <input type="text" wicket:id="salary"/></label><br/>
        <button type="submit">Submit</button>
    </form>
</body>
</html>

 

 
package com.example.page;

import com.example.model.Employee;
import com.example.service.EmployeeService;
import org.apache.wicket.markup.html.WebPage;
import org.apache.wicket.markup.html.basic.Label;
import org.apache.wicket.markup.html.form.Form;
import org.apache.wicket.markup.html.form.TextField;
import org.apache.wicket.markup.html.list.ListItem;
import org.apache.wicket.markup.html.list.ListView;
import org.apache.wicket.model.Model;
import org.apache.wicket.model.PropertyModel;

import java.util.List;

public class EmployeePage extends WebPage {

    @SpringBean
    private final EmployeeService employeeService;
    private final Employee employee = new Employee(); // Backing object for the form
    private List<Employee> employees;

    public EmployeePage(EmployeeService employeeService) {
        this.employeeService = employeeService;
        this.employees = employeeService.getAllEmployees();

        // Add Employee List
        add(new ListView<Employee>("employeeList", employees) {
            @Override
            protected void populateItem(ListItem<Employee> item) {
                Employee employee = item.getModelObject();
                item.add(new Label("name", Model.of(employee.getName())));
                item.add(new Label("department", Model.of(employee.getDepartment())));
                item.add(new Label("salary", Model.of(employee.getSalary())));
            }
        });

        // Add Employee Form
        Form<Employee> form = new Form<Employee>("employeeForm") {
            @Override
            protected void onSubmit() {
                super.onSubmit();
                employeeService.saveEmployee(employee); // Save employee to the database
                employees = employeeService.getAllEmployees(); // Refresh the list
                setResponsePage(new EmployeePage(employeeService)); // Reload the page
            }
        };

        form.add(new TextField<>("name", new PropertyModel<>(employee, "name")));
        form.add(new TextField<>("department", new PropertyModel<>(employee, "department")));
        form.add(new TextField<>("salary", new PropertyModel<>(employee, "salary")));
        add(form);
    }
}

 

 
package com.example.test.page;

import com.example.model.Employee;
import com.example.page.EmployeePage;
import com.example.service.EmployeeService;
import com.example.test.util.EmployeeObjectMother;
import org.apache.wicket.util.tester.FormTester;
import org.apache.wicket.util.tester.WicketTester;
import org.easymock.EasyMock;
import org.junit.Before;
import org.junit.Test;

import java.util.List;

public class EmployeePageTest {

    private WicketTester tester;
    private EmployeeService mockEmployeeService;

    @Before
    public void setup() {
        mockEmployeeService = EasyMock.createMock(EmployeeService.class);
        tester = new WicketTester();
    }

    @Test
    public void testEmployeePageRendering() {
        List<Employee> mockEmployees = EmployeeObjectMother.createEmployeeList();
        EasyMock.expect(mockEmployeeService.getAllEmployees()).andReturn(mockEmployees);
        EasyMock.replay(mockEmployeeService);

        tester.startPage(() -> new EmployeePage(mockEmployeeService));
        tester.assertRenderedPage(EmployeePage.class);
        tester.assertLabel("employeeList:0:name", "John Doe");
        EasyMock.verify(mockEmployeeService);
    }

    @Test
    public void testEmployeeFormSubmission() {
        List<Employee> mockEmployees = EmployeeObjectMother.createEmployeeList();
        EasyMock.expect(mockEmployeeService.getAllEmployees()).andReturn(mockEmployees).anyTimes();
        mockEmployeeService.saveEmployee(EasyMock.anyObject(Employee.class));
        EasyMock.expectLastCall();
        EasyMock.replay(mockEmployeeService);

        tester.startPage(() -> new EmployeePage(mockEmployeeService));
        FormTester formTester = tester.newFormTester("employeeForm");
        formTester.setValue("name", "Alice Walker");
        formTester.setValue("department", "HR");
        formTester.setValue("salary", "55000");

        formTester.submit();
        tester.assertRenderedPage(EmployeePage.class); // Ensure page reloads
        EasyMock.verify(mockEmployeeService);
    }
}

 

Service Layer

Production Code Test 
package com.example.service;

import com.example.dao.EmployeeDAO;
import com.example.model.Employee;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class EmployeeService {

    @Autowired
    private final EmployeeDAO employeeDAO;

    public EmployeeService(EmployeeDAO employeeDAO) {
        this.employeeDAO = employeeDAO;
    }

    public List<Employee> getAllEmployees() {
        return employeeDAO.getAllEmployees();
    }

    public void saveEmployee(Employee employee) {
        employeeDAO.saveEmployee(employee);
    }
}

 

 
package com.example.test.service;

import com.example.dao.EmployeeDAO;
import com.example.model.Employee;
import com.example.service.EmployeeService;
import com.example.test.util.EmployeeObjectMother;
import org.easymock.EasyMock;
import org.junit.Before;
import org.junit.Test;

import java.util.List;

import static org.junit.Assert.assertEquals;

public class EmployeeServiceTest {

    // inject mock
    private EmployeeService employeeService;
    // create mock
    private EmployeeDAO mockEmployeeDAO;

    @Before
    public void setup() {
        mockEmployeeDAO = EasyMock.createMock(EmployeeDAO.class);
        employeeService = new EmployeeService(mockEmployeeDAO);
    }

    @Test
    public void testGetAllEmployees() {
        List<Employee> mockEmployees = EmployeeObjectMother.createEmployeeList();
        EasyMock.expect(mockEmployeeDAO.getAllEmployees()).andReturn(mockEmployees);
        EasyMock.replay(mockEmployeeDAO);

        List<Employee> employees = employeeService.getAllEmployees();
        assertEquals(3, employees.size());
        EasyMock.verify(mockEmployeeDAO);
    }
}

 

DAO Layer

Production Code Test 
package com.example.dao;

import com.example.model.Employee;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.stereotype.Repository;

import javax.transaction.Transactional;
import java.util.List;

@Repository
@Transactional
public class EmployeeDAO {

    private final SessionFactory sessionFactory;

    public EmployeeDAO(SessionFactory sessionFactory) {
        this.sessionFactory = sessionFactory;
    }

    public List<Employee> getAllEmployees() {
        Session session = sessionFactory.getCurrentSession();
        return session.createQuery("from Employee", Employee.class).list();
    }

    public void saveEmployee(Employee employee) {
        Session session = sessionFactory.getCurrentSession();
        session.saveOrUpdate(employee);
    }
}

 

 
package com.example.test.dao;

import com.example.dao.EmployeeDAO;
import com.example.model.Employee;
import com.example.test.util.EmployeeObjectMother;
import org.easymock.EasyMock;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.junit.Before;
import org.junit.Test;

import java.util.List;

import static org.junit.Assert.*;

public class EmployeeDAOTest {

    private EmployeeDAO employeeDAO;
    private SessionFactory mockSessionFactory;
    private Session mockSession;

    @Before
    public void setup() {
        mockSessionFactory = EasyMock.createMock(SessionFactory.class);
        mockSession = EasyMock.createMock(Session.class);
        EasyMock.expect(mockSessionFactory.getCurrentSession()).andReturn(mockSession).anyTimes();
        employeeDAO = new EmployeeDAO(mockSessionFactory);
    }

    @Test
    public void testGetAllEmployees() {
        List<Employee> mockEmployees = EmployeeObjectMother.createEmployeeList();
        EasyMock.expect(mockSession.createQuery("from Employee", Employee.class).list()).andReturn(mockEmployees);
        EasyMock.replay(mockSessionFactory, mockSession);

        List<Employee> employees = employeeDAO.getAllEmployees();
        assertNotNull(employees);
        assertEquals(3, employees.size());
        assertEquals("John Doe", employees.get(0).getName());
        EasyMock.verify(mockSessionFactory, mockSession);
    }
}

 

Entity / ObjectMother

Entity Object Mother 
package com.example.model;

import javax.persistence.*;

@Entity
@Table(name = "employees")
public class Employee {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    private String department;

    private Double salary;

    // Getters and setters
    public Long getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getDepartment() {
        return department;
    }

    public void setDepartment(String department) {
        this.department = department;
    }

    public Double getSalary() {
        return salary;
    }

    public void setSalary(Double salary) {
        this.salary = salary;
    }
}

 

 
package com.example.test.util;

import com.example.model.Employee;

import java.util.ArrayList;
import java.util.List;

public class EmployeeObjectMother {

    public static Employee createEmployee(Long id, String name, String department, Double salary) {
        Employee employee = new Employee();
        employee.setId(id);
        employee.setName(name);
        employee.setDepartment(department);
        employee.setSalary(salary);
        return employee;
    }

    public static List<Employee> createEmployeeList() {
        List<Employee> employees = new ArrayList<>();
        employees.add(createEmployee(1L, "John Doe", "Engineering", 75000.0));
        employees.add(createEmployee(2L, "Jane Smith", "Marketing", 65000.0));
        employees.add(createEmployee(3L, "Bob Brown", "Sales", 60000.0));
        return employees;
    }
}

 

 

Additional articles






Login to like - 0 Likes



Comments...


No Comments Yet...



Add Comment...



shumin

A graduated biotechnology engineer. Now is a software engineer

Latest Posts

Categories


Footer with Icons