ass2-service/courseplan/src/test/java/dst/ass2/service/courseplan/tests/CoursePlanServiceTest.java

   1 package dst.ass2.service.courseplan.tests;
   2
   3 import dst.ass1.jpa.dao.IDAOFactory;
   4 import dst.ass1.jpa.dao.IParticipantDAO;
   5 import dst.ass1.jpa.model.*;
   6 import dst.ass1.jpa.tests.TestData;
   7 import dst.ass2.service.api.courseplan.CourseNotAvailableException;
   8 import dst.ass2.service.api.courseplan.CoursePlan;
   9 import dst.ass2.service.api.courseplan.EntityNotFoundException;
  10 import dst.ass2.service.api.courseplan.ICoursePlanService;
  11 import dst.ass2.service.courseplan.CoursePlanApplication;
  12 import org.junit.Before;
  13 import org.junit.Test;
  14 import org.junit.runner.RunWith;
  15 import org.slf4j.Logger;
  16 import org.slf4j.LoggerFactory;
  17 import org.springframework.beans.BeansException;
  18 import org.springframework.boot.test.context.SpringBootTest;
  19 import org.springframework.context.ApplicationContext;
  20 import org.springframework.context.ApplicationContextAware;
  21 import org.springframework.test.context.ActiveProfiles;
  22 import org.springframework.test.context.junit4.SpringRunner;
  23
  24 import javax.persistence.EntityManager;
  25 import javax.persistence.PersistenceContext;
  26 import java.util.Collection;
  27 import java.util.Optional;
  28
  29 import static org.junit.Assert.*;
  30
  31 @RunWith(SpringRunner.class)
  32 @SpringBootTest(classes = CoursePlanApplication.class, webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
  33 @org.springframework.transaction.annotation.Transactional
  34 @ActiveProfiles("testdata")
  35 public class CoursePlanServiceTest implements ApplicationContextAware {
  36
  37     private static final Logger LOG = LoggerFactory.getLogger(CoursePlanServiceTest.class);
  38
  39     private ApplicationContext ctx;
  40
  41     @PersistenceContext
  42     private EntityManager em;
  43
  44     private ICoursePlanService service;
  45     private IDAOFactory daoFactory;
  46     private IModelFactory modelFactory;
  47     private TestData testData;
  48     private IParticipantDAO participantDAO;
  49
  50     private Long p1cp1p;
  51     private Long p1cp2np;
  52     private Long p2cp1np;
  53     private Long p2cp2p;
  54     private Long course4Id;
  55
  56     @Override
  57     public void setApplicationContext(ApplicationContext ctx) throws BeansException {
  58         this.ctx = ctx;
  59     }
  60
  61     @Before
  62     public void setUp() {
  63         LOG.info("Test resolving beans from application context");
  64         daoFactory = ctx.getBean(IDAOFactory.class);
  65         modelFactory = ctx.getBean(IModelFactory.class);
  66         service = ctx.getBean(ICoursePlanService.class);
  67         testData = ctx.getBean(TestData.class);
  68         participantDAO = daoFactory.createParticipantDAO();
  69
  70         // course4Id is wrong in TestData, find out the correct ID
  71         course4Id = daoFactory.createCourseDAO().findAll().stream()
  72                 .filter(c -> c.getName().equals(TestData.COURSE_4_NAME)).findFirst().get().getId();
  73
  74         // Create an additional membership for tests
  75         IMembership membership4 = modelFactory.createMembership();
  76         membership4.setDiscount(10.0);
  77         membership4.setPremium(true);
  78         membership4.setParticipant(participantDAO.findById(testData.participant2Id));
  79         membership4.setCoursePlatform(daoFactory.createCoursePlatformDAO().findById(testData.coursePlatform2Id));
  80         IParticipant participant2 = participantDAO.findById(testData.participant2Id);
  81         participant2.getMemberships().add(membership4);
  82         em.persist(membership4);
  83         em.persist(participant2);
  84
  85         // find the IDs of the memberships
  86         Collection<IMembership> memberships1 = participantDAO.findById(testData.participant1Id).getMemberships();
  87         Collection<IMembership> memberships2 = participantDAO.findById(testData.participant2Id).getMemberships();
  88
  89         // participant 1, course platform 1, premium
  90         p1cp1p = memberships1.stream().filter(m -> m.getPremium()).findFirst().get().getId();
  91
  92         // participant 1, course platform 2, non-premium
  93         p1cp2np = memberships1.stream().filter(m -> !m.getPremium()).findFirst().get().getId();
  94
  95         // participant 2, course platform 1, non-premium
  96         p2cp1np = memberships2.stream().filter(m -> !m.getPremium()).findFirst().get().getId();
  97
  98         // participant 2, course platform 2, premium
  99         p2cp2p = memberships2.stream().filter(m -> m.getPremium()).findFirst().get().getId();
 100     }
 101
 102     @Test
 103     public void testCreateWithValidMembership_returnsNewCoursePlan() throws EntityNotFoundException {
 104         CoursePlan plan = service.create(p1cp1p);
 105         assertNotNull(plan);
 106         assertNotNull(plan.getId());
 107         assertEquals(p1cp1p, plan.getMembershipId());
 108     }
 109
 110     @Test(expected = EntityNotFoundException.class)
 111     public void testCreateWithInvalidMembership_throwsException() throws EntityNotFoundException {
 112         service.create(1337L);
 113     }
 114
 115     @Test(expected = EntityNotFoundException.class)
 116     public void testDeleteInvalidId_throwsException() throws EntityNotFoundException {
 117         service.delete(1337L);
 118     }
 119
 120     @Test
 121     public void testDelete_findReturnsNull() throws EntityNotFoundException {
 122         CoursePlan plan = service.create(p1cp1p);
 123         assertNotNull(plan);
 124         assertNotNull(plan.getId());
 125         service.delete(plan.getId());
 126         assertNull(service.find(plan.getId()));
 127     }
 128
 129     @Test
 130     public void testFind_returnsCorrectPlan() throws EntityNotFoundException {
 131         CoursePlan plan = service.create(p1cp1p);
 132         CoursePlan plan1 = service.find(plan.getId());
 133         assertEquals(plan, plan1);
 134     }
 135
 136     @Test
 137     public void testFindInvalidId_returnsNull() {
 138         assertNull(service.find(1337L));
 139     }
 140
 141     @Test
 142     public void testAdd_courseAdded() throws EntityNotFoundException, CourseNotAvailableException {
 143         CoursePlan plan = service.create(p1cp2np);
 144         assertTrue(service.addCourse(plan, testData.course2Id));
 145         assertFalse(plan.getCourses().isEmpty());
 146         assertEquals(testData.course2Id, plan.getCourses().get(0));
 147     }
 148
 149     @Test
 150     public void testAddPremiumCourseWithPremium_courseAdded() throws EntityNotFoundException, CourseNotAvailableException {
 151         CoursePlan plan = service.create(p2cp2p);
 152         assertTrue(service.addCourse(plan, course4Id));
 153         assertFalse(plan.getCourses().isEmpty());
 154         assertEquals(course4Id, plan.getCourses().get(0));
 155     }
 156
 157     @Test(expected = CourseNotAvailableException.class)
 158     public void testAddCourseFromDifferentPlatform_throwsException() throws EntityNotFoundException, CourseNotAvailableException {
 159         CoursePlan plan = service.create(p2cp1np);
 160         service.addCourse(plan, course4Id);
 161     }
 162
 163     @Test
 164     public void testAddExistingCourse_returnsFalse() throws EntityNotFoundException, CourseNotAvailableException {
 165         CoursePlan plan = service.create(p1cp2np);
 166         assertTrue(service.addCourse(plan, testData.course2Id));
 167         assertFalse(service.addCourse(plan, testData.course2Id));
 168     }
 169
 170     @Test(expected = EntityNotFoundException.class)
 171     public void testAddInvalidCourse_throwsException() throws EntityNotFoundException, CourseNotAvailableException {
 172         CoursePlan plan = service.create(p2cp1np);
 173         service.addCourse(plan, 1337L);
 174     }
 175
 176     @Test(expected = EntityNotFoundException.class)
 177     public void testAddInvalidMembership_throwsException() throws EntityNotFoundException {
 178         service.create(1337L);
 179     }
 180
 181     @Test(expected = CourseNotAvailableException.class)
 182     public void testAddPremiumCourseWithoutPremium_throwsException() throws EntityNotFoundException, CourseNotAvailableException {
 183         CoursePlan plan = service.create(p2cp1np);
 184         service.addCourse(plan, testData.course1Id);
 185     }
 186
 187     @Test(expected = CourseNotAvailableException.class)
 188     public void testAddCourseWithoutCapacity_throwsException() throws EntityNotFoundException, CourseNotAvailableException {
 189         CoursePlan plan = service.create(p1cp1p);
 190         service.addCourse(plan, testData.course3Id);
 191     }
 192
 193     @Test(expected = CourseNotAvailableException.class)
 194     public void testAddCourseAlreadyInDB_throwsException() throws CourseNotAvailableException, EntityNotFoundException {
 195         CoursePlan plan = service.create(p1cp1p);
 196         service.addCourse(plan, testData.course1Id);
 197     }
 198
 199     @Test
 200     public void testRemoveCourse_courseRemoved() throws EntityNotFoundException, CourseNotAvailableException {
 201         CoursePlan plan = service.create(p2cp2p);
 202         assertTrue(service.addCourse(plan, course4Id));
 203         assertTrue(service.removeCourse(plan, course4Id));
 204         CoursePlan plan1 = service.find(plan.getId());
 205         assertTrue(plan1.getCourses().isEmpty());
 206     }
 207
 208     @Test
 209     public void testRemoveNotAddedCourse_returnsFalse() throws EntityNotFoundException {
 210         CoursePlan plan = service.create(p1cp1p);
 211         assertFalse(service.removeCourse(plan, testData.course1Id));
 212     }
 213
 214     @Test
 215     public void testCommit_committed() throws EntityNotFoundException, CourseNotAvailableException {
 216         CoursePlan plan = service.create(p1cp2np);
 217         assertTrue(service.addCourse(plan, testData.course2Id));
 218         service.commit(plan);
 219         assertTrue(isEnrolled(testData.participant1Id, testData.course2Id));
 220     }
 221
 222     @Test
 223     public void testCommitPremiumCourseWithPremium_committed() throws EntityNotFoundException, CourseNotAvailableException {
 224         CoursePlan plan = service.create(p2cp2p);
 225         assertTrue(service.addCourse(plan, course4Id));
 226         service.commit(plan);
 227         assertTrue(isEnrolled(testData.participant2Id, course4Id));
 228     }
 229
 230     @Test(expected = EntityNotFoundException.class)
 231     public void testCommitWithInvalidMembership_throwsException() throws CourseNotAvailableException, EntityNotFoundException {
 232         CoursePlan plan = service.create(p1cp2np);
 233         assertTrue(service.addCourse(plan, testData.course2Id));
 234         em.remove(daoFactory.createMembershipDAO().findById(p1cp2np));
 235         service.commit(plan);
 236     }
 237
 238     @Test(expected = EntityNotFoundException.class)
 239     public void testCommitWithInvalidCourse_throwsException() throws CourseNotAvailableException, EntityNotFoundException {
 240         CoursePlan plan = service.create(p1cp2np);
 241         assertTrue(service.addCourse(plan, testData.course2Id));
 242         em.remove(daoFactory.createCourseDAO().findById(testData.course2Id));
 243         service.commit(plan);
 244     }
 245
 246     @Test(expected = CourseNotAvailableException.class)
 247     public void testCommitPremiumCourseWithoutPremium_throwsException() throws CourseNotAvailableException, EntityNotFoundException {
 248         CoursePlan plan = service.create(p2cp2p);
 249         assertTrue(service.addCourse(plan, course4Id));
 250         IMembership membership = daoFactory.createMembershipDAO().findById(p2cp2p);
 251         membership.setPremium(false);
 252         em.persist(membership);
 253         service.commit(plan);
 254     }
 255
 256     @Test(expected = CourseNotAvailableException.class)
 257     public void testCommitCourseFromDifferentPlatform_throwsException() throws CourseNotAvailableException, EntityNotFoundException {
 258         CoursePlan plan = service.create(p2cp2p);
 259         assertTrue(service.addCourse(plan, course4Id));
 260         IMembership membership = daoFactory.createMembershipDAO().findById(p2cp2p);
 261         membership.setCoursePlatform(daoFactory.createCoursePlatformDAO().findById(testData.coursePlatform1Id));
 262         em.persist(membership);
 263         service.commit(plan);
 264     }
 265
 266     @Test(expected = CourseNotAvailableException.class)
 267     public void testCommitCourseWithoutCapacity_throwsException() throws CourseNotAvailableException, EntityNotFoundException {
 268         CoursePlan plan = service.create(p1cp2np);
 269         assertTrue(service.addCourse(plan, testData.course2Id));
 270         ICourse course = daoFactory.createCourseDAO().findById(testData.course2Id);
 271         course.setCapacity(0);
 272         em.persist(course);
 273         service.commit(plan);
 274     }
 275
 276     @Test(expected = CourseNotAvailableException.class)
 277     public void testCommitCourseAlreadyInDB_throwsException() throws CourseNotAvailableException, EntityNotFoundException {
 278         CoursePlan plan = service.create(p1cp2np);
 279         service.addCourse(plan, testData.course2Id);
 280         service.commit(plan);
 281         service.commit(plan);
 282     }
 283
 284     private boolean isEnrolled(Long participantId, Long courseId) {
 285         Optional<IEnrollment> first = participantDAO.findById(participantId).getEnrollments().stream().filter(e -> e.getId().getCourse().getId().equals(courseId)).findFirst();
 286         return first.isPresent();
 287     }
 288 }