Project: Course Enrolment REST API

spring.application.name=enrolment

spring.datasource.url=jdbc:h2:mem:enrolment
spring.jpa.hibernate.ddl-auto=create-drop
spring.jpa.defer-datasource-initialization=true
spring.jpa.open-in-view=false

spring.mvc.problemdetails.enabled=true
management.endpoints.web.exposure.include=health,info

@Entity
@Table(name = "enrolments")
public class Enrolment {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @ManyToOne(fetch = FetchType.LAZY, optional = false)
    @JoinColumn(name = "student_id")
    private Student student;

    @ManyToOne(fetch = FetchType.LAZY, optional = false)
    @JoinColumn(name = "course_id")
    private Course course;

    @Column(nullable = false)
    private LocalDate enrolledOn;

    @Enumerated(EnumType.STRING)
    @Column(nullable = false, length = 10)
    private EnrolmentStatus status = EnrolmentStatus.ACTIVE;

    protected Enrolment() {
    }

    public Enrolment(Student student, Course course, LocalDate enrolledOn) {
        this.student = student;
        this.course = course;
        this.enrolledOn = enrolledOn;
    }

    public void cancel() {
        this.status = EnrolmentStatus.CANCELLED;
    }

    // getters
}

insert into courses (code, title, fee, seats) values
  ('JAVA-101', 'Core Java', 12000, 30),
  ('SPRING-201', 'Spring Boot APIs', 15000, 2),
  ('SQL-101', 'SQL and MySQL', 8500, 25);

insert into students (name, email) values
  ('Aarav Mehta', 'aarav@student.example'),
  ('Priya Nair', 'priya@student.example'),
  ('Kabir Singh', 'kabir@student.example');

public interface EnrolmentRepository extends JpaRepository<Enrolment, Long> {

    long countByCourseIdAndStatus(Long courseId, EnrolmentStatus status);

    boolean existsByStudentIdAndCourseIdAndStatus(Long studentId, Long courseId, EnrolmentStatus status);

    @Query("""
            select e from Enrolment e
            join fetch e.course
            join fetch e.student
            where e.student.id = :studentId
            order by e.enrolledOn, e.id
            """)
    List<Enrolment> findForStudent(@Param("studentId") long studentId);
}

public record EnrolmentRequest(
        @NotNull @Positive Long studentId,
        @NotBlank String courseCode) {}

public record EnrolmentResponse(Long id, String student, String courseCode, String courseTitle,
                                int fee, LocalDate enrolledOn, EnrolmentStatus status) {

    public static EnrolmentResponse from(Enrolment e) {
        return new EnrolmentResponse(e.getId(), e.getStudent().getName(), e.getCourse().getCode(),
                e.getCourse().getTitle(), e.getCourse().getFee(), e.getEnrolledOn(), e.getStatus());
    }
}

@Service
@Transactional(readOnly = true)
public class EnrolmentService {

    private static final Logger log = LoggerFactory.getLogger(EnrolmentService.class);

    // constructor injection of EnrolmentRepository, StudentRepository, CourseRepository and Clock

    @Transactional
    public EnrolmentResponse enrol(EnrolmentRequest request) {
        Student student = students.findById(request.studentId())
                .orElseThrow(() -> new NotFoundException("No student with id " + request.studentId()));
        Course course = courses.findByCode(request.courseCode())
                .orElseThrow(() -> new NotFoundException("No course with code " + request.courseCode()));

        if (enrolments.existsByStudentIdAndCourseIdAndStatus(student.getId(), course.getId(), EnrolmentStatus.ACTIVE)) {
            throw new ConflictException(student.getName() + " is already enrolled in " + course.getCode());
        }
        long taken = enrolments.countByCourseIdAndStatus(course.getId(), EnrolmentStatus.ACTIVE);
        if (taken >= course.getSeats()) {
            throw new ConflictException("Course " + course.getCode() + " is full (" + course.getSeats() + " seats)");
        }

        Enrolment saved = enrolments.save(new Enrolment(student, course, LocalDate.now(clock)));
        log.info("Enrolled student {} in {} ({} of {} seats taken)",
                student.getId(), course.getCode(), taken + 1, course.getSeats());
        return EnrolmentResponse.from(saved);
    }

    @Transactional
    public void cancel(long enrolmentId) {
        Enrolment enrolment = enrolments.findById(enrolmentId)
                .orElseThrow(() -> new NotFoundException("No enrolment with id " + enrolmentId));
        enrolment.cancel();
    }
}

@RestController
@RequestMapping("/api/enrolments")
public class EnrolmentController {

    private final EnrolmentService service;

    public EnrolmentController(EnrolmentService service) {
        this.service = service;
    }

    @PostMapping
    public ResponseEntity<EnrolmentResponse> enrol(@Valid @RequestBody EnrolmentRequest request) {
        EnrolmentResponse created = service.enrol(request);
        return ResponseEntity.created(URI.create("/api/enrolments/" + created.id())).body(created);
    }

    @DeleteMapping("/{id}")
    public ResponseEntity<Void> cancel(@PathVariable long id) {
        service.cancel(id);
        return ResponseEntity.noContent().build();
    }
}

curl -X POST http://localhost:8080/api/courses -H "Content-Type: application/json" -d '{"code": "react-301", "title": "React", "fee": 14000, "seats": 0}'

@Test
void refusesWhenCourseIsFull() {
    when(enrolments.countByCourseIdAndStatus(2L, EnrolmentStatus.ACTIVE)).thenReturn(2L);

    assertThatThrownBy(() -> service.enrol(new EnrolmentRequest(2L, "SPRING-201")))
            .isInstanceOf(ConflictException.class)
            .hasMessage("Course SPRING-201 is full (2 seats)");
    verify(enrolments, never()).save(any());
}

@Test
void secondSeatFillsTheCourseAndThirdStudentIsRefused() {
    assertThat(enrol(1, "SPRING-201")).hasStatus(HttpStatus.CREATED);
    assertThat(enrol(2, "SPRING-201")).hasStatus(HttpStatus.CREATED);

    assertThat(enrol(3, "SPRING-201"))
            .hasStatus(HttpStatus.CONFLICT)
            .bodyJson().extractingPath("$.detail").isEqualTo("Course SPRING-201 is full (2 seats)");

    assertThat(mvc.get().uri("/api/courses"))
            .hasStatusOk()
            .bodyJson().extractingPath("$[1].seatsLeft").isEqualTo(0);
}

./mvnw test