ECSE 321 Introduction to Software Engineering: Tutorial

CREATE DATABASE event_registration;

package ca.mcgill.ecse321.eventregistration.model;

.
├── EventRegistration-Backend
│   ├── build.gradle
│   ├── gradle
│   │   └── wrapper
│   │       ├── gradle-wrapper.jar
│   │       └── gradle-wrapper.properties
│   ├── gradlew
│   ├── gradlew.bat
│   ├── HELP.md
│   ├── settings.gradle
│   └── src
│       ├── main
│       │   ├── java
│       │   │   └── ca
│       │   │       └── mcgill
│       │   │           └── ecse321
│       │   │               └── eventregistration
│       │   │                   ├── EventregistrationApplication.java
│       │   │                   └── model
│       │   │                       ├── Event.java
│       │   │                       ├── Person.java
│       │   │                       └── Registration.java
│       │   └── resources
│       │       ├── application.properties
│       │       ├── static
│       │       └── templates
│       └── test
│           └── java
│               └── ca
│                   └── mcgill
│                       └── ecse321
│                           └── eventregistration
│                               └── EventregistrationApplicationTests.java
├── .git
│   └── [omitted...]
├── .gitignore
└── README.md

@SpringBootTest
public class PersonRepositoryTests {
	@Autowired
	private PersonRepository personRepository;

	@AfterEach
	public void clearDatabase() {
		personRepository.deleteAll();
	}

	@Test
	public void testPersistAndLoadPerson() {
		// Create person
		String name = "Muffin Man";
		String emailAddress = "muffin.man@gmail.com";
		String password = "i_love_muffins";
		Person muffinMan = new Person();
		muffinMan.setName(name);
		muffinMan.setEmailAddress(emailAddress);
		muffinMan.setPassword(password);

		// Save person
		muffinMan = personRepository.save(person);
		int id = muffinMan.getId();

		// Read person from database
		Person muffinManFromDb = personRepository.findPersonById(id);

		// Assert correct response
		assertNotNull(person);
		assertEquals(muffinManFromDb.getName(), name);
		assertEquals(muffinManFromDb.getEmailAddress(), emailAddress);
		assertEquals(muffinManFromDb.getPassword(), password);
	}
}

testLogging {
	exceptionFormat "full"
	//...other configurations
}

package ca.mcgill.ecse321.eventregistration.service;

import java.sql.Date;
import java.time.LocalDate;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import ca.mcgill.ecse321.eventregistration.model.Person;
import ca.mcgill.ecse321.eventregistration.repository.PersonRepository;
import jakarta.transaction.Transactional;

@Service
public class PersonService {
    @Autowired
    private PersonRepository personRepo;

    public Person findPersonById(int pid) {
        Person p = personRepo.findPersonById(pid);
        if (p == null) {
            throw new IllegalArgumentException("There is no person with ID " + pid + ".");
        }
        return p;
    }

    @Transactional
    public Person createPerson(String name, String email, String password) {
        if (password == null || password.length() < 8) {
            throw new IllegalArgumentException("Password too short.");
        }

        Date now = Date.valueOf(LocalDate.now());
        Person personToCreate = new Person(name, email, password, now);
        return personRepo.save(personToCreate);
    }
}

$ psql -U postgres --dbname event_registration
Password for user postgres:
psql (14.13 (Ubuntu 14.13-0ubuntu0.22.04.1))
Type "help" for help.

event_registration=# select * from person;
  id  | creation_date |    email_address     | name  |  password
------+---------------+----------------------+-------+------------
 1502 | 2024-10-24    | alice@mail.mcgill.ca | Alice | pass123456
(1 row)

event_registration=# begin transaction;
BEGIN
event_registration=*# insert into person values (1, '2024-10-25', 'bob@mail.mcgill.ca', 'Bob', 'pass123');
INSERT 0 1
event_registration=*# select * from person;
  id  | creation_date |    email_address     | name  |  password
------+---------------+----------------------+-------+------------
 1502 | 2024-10-24    | alice@mail.mcgill.ca | Alice | pass123456
    1 | 2024-10-25    | bob@mail.mcgill.ca   | Bob   | pass123
(2 rows)

event_registration=*# delete from person;
DELETE 2
event_registration=*# rollback transaction;
ROLLBACK
event_registration=# select * from person;
  id  | creation_date |    email_address     | name  |  password
------+---------------+----------------------+-------+------------
 1502 | 2024-10-24    | alice@mail.mcgill.ca | Alice | pass123456
(1 row)

event_registration=# begin transaction;
BEGIN
event_registration=*# insert into person values (1, '2024-10-25', 'bob@mail.mcgill.ca', 'Bob', 'pass123');
INSERT 0 1
event_registration=*# commit transaction;
COMMIT
event_registration=# select * from person;
  id  | creation_date |    email_address     | name  |  password
------+---------------+----------------------+-------+------------
 1502 | 2024-10-24    | alice@mail.mcgill.ca | Alice | pass123456
    1 | 2024-10-25    | bob@mail.mcgill.ca   | Bob   | pass123
(2 rows)

package ca.mcgill.ecse321.eventregistration.service;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import java.sql.Date;
import java.time.LocalDate;

import org.junit.jupiter.api.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.springframework.boot.test.context.SpringBootTest;

import ca.mcgill.ecse321.eventregistration.exception.EventRegistrationException;
import ca.mcgill.ecse321.eventregistration.model.Person;
import ca.mcgill.ecse321.eventregistration.repository.PersonRepository;

@SpringBootTest
public class PersonServiceTests {
    @Mock
    private PersonRepository repo;
    @InjectMocks
    private PersonService service;

    @SuppressWarnings("null")
    @Test
    public void testCreateValidPerson() {
        // Arrange
        String name = "Bob";
        String email = "bob@mail.mcgill.ca";
        String password = "12345678";
        Person bob = new Person(name, email, password, Date.valueOf(LocalDate.now()));
        when(repo.save(any(Person.class))).thenReturn(bob);
        // You could also do it with thenAnswer(), which is more flexible but more
        // verbose
        // when(repo.save(notNull(Person.class))).thenAnswer((InvocationOnMock iom) ->
        // iom.getArgument(0));

        // Act
        Person createdPerson = service.createPerson(name, email, password);

        // Assert
        assertNotNull(createdPerson);
        assertEquals(name, createdPerson.getName());
        assertEquals(email, createdPerson.getEmail());
        assertEquals(password, createdPerson.getPassword());
        assertEquals(Date.valueOf(LocalDate.now()), createdPerson.getCreationDate());
        verify(repo, times(1)).save(bob);
    }

    @Test
    public void testReadPersonByValidId() {
        // Arrange
        int id = 42;
        Person charlie = new Person("Charlie", "charlie@mail.mcgill.ca", "password123", Date.valueOf("2024-03-01"));
        when(repo.findPersonById(id)).thenReturn(charlie);

        // Act
        Person person = service.findPersonById(id);

        // Assert
        assertNotNull(person);
        assertEquals(charlie.getName(), person.getName());
        assertEquals(charlie.getEmail(), person.getEmail());
        assertEquals(charlie.getPassword(), person.getPassword());
        assertEquals(charlie.getCreationDate(), person.getCreationDate());
    }

    @Test
    public void testReadPersonByInvalidId() {
        // Set up
        int id = 42;
        // Default is to return null, so you could omit this
        when(repo.findPersonById(id)).thenReturn(null);

        // Act
        // Assert
        EventRegistrationException e = assertThrows(EventRegistrationException.class, () -> service.findPersonById(id));
        assertEquals("There is no person with ID " + id + ".", e.getMessage());
        // assertThrows is basically like the following:
        // try {
        // service.findPersonById(id);
        // fail("No exception was thrown.");
        // } catch (IllegalArgumentException e) {
        // assertEquals("There is no person with ID " + id + ".", e.getMessage());
        // }
    }
}

package ca.mcgill.ecse321.eventregistration.integration;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;

import java.time.LocalDate;

import org.junit.jupiter.api.MethodOrderer;
import org.junit.jupiter.api.Order;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestInstance;
import org.junit.jupiter.api.TestInstance.Lifecycle;
import org.junit.jupiter.api.TestMethodOrder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.context.SpringBootTest.WebEnvironment;
import org.springframework.boot.test.web.client.TestRestTemplate;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;

import ca.mcgill.ecse321.eventregistration.dto.ErrorDto;
import ca.mcgill.ecse321.eventregistration.dto.PersonRequestDto;
import ca.mcgill.ecse321.eventregistration.dto.PersonResponseDto;

@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
@TestInstance(Lifecycle.PER_CLASS)
public class PersonIntegrationTests {
    @Autowired
    private TestRestTemplate client;

    private final String VALID_NAME = "Alice";
    private final String VALID_EMAIL = "alice@mail.mcgill.ca";
    private final String VALID_PASSWORD = "password123";
    private final String INVALID_PASSWORD = "123";
    private final int INVALID_ID = 0;
    private int validId;

    @Test
    @Order(1)
    public void testCreateValidPerson() {
        // Arrange
        PersonRequestDto request = new PersonRequestDto(VALID_NAME, VALID_EMAIL, VALID_PASSWORD);

        // Act
        ResponseEntity<PersonResponseDto> response = client.postForEntity("/people", request, PersonResponseDto.class);

        // Assert
        assertNotNull(response);
        assertEquals(HttpStatus.CREATED, response.getStatusCode());
        PersonResponseDto createdPerson = response.getBody();
        assertNotNull(createdPerson);
        assertEquals(VALID_NAME, createdPerson.getName());
        assertEquals(VALID_EMAIL, createdPerson.getEmail());
        assertNotNull(createdPerson.getId());
        assertTrue(createdPerson.getId() > 0, "Response should have a positive ID.");
        assertEquals(LocalDate.now(), createdPerson.getCreationDate());

        this.validId = createdPerson.getId();
    }

    @Test
    @Order(2)
    public void testReadPersonByValidId() {
        // Arrange
        String url = "/people/" + this.validId;

        // Act
        ResponseEntity<PersonResponseDto> response = client.getForEntity(url, PersonResponseDto.class);

        // Assert
        assertNotNull(response);
        assertEquals(HttpStatus.OK, response.getStatusCode());
        PersonResponseDto person = response.getBody();
        assertNotNull(person);
        assertEquals(VALID_NAME, person.getName());
        assertEquals(VALID_EMAIL, person.getEmail());
        assertEquals(this.validId, person.getId());
        assertEquals(LocalDate.now(), person.getCreationDate());
    }
}

plugins {
	id 'org.springframework.boot' version '2.2.4.RELEASE'
	id 'io.spring.dependency-management' version '1.0.9.RELEASE'
	id 'java'
	id 'jacoco'
}

//...other configurations

tasks.named('test') {
	useJUnitPlatform()
	testLogging {
		exceptionFormat "full"
		events "passed", "failed"
 	}
	finalizedBy jacocoTestReport
}

tasks.named('jacocoTestReport') {
    dependsOn test // tests are required to run before generating the report
}

tasks.named('test') {
	//...other configurations
	finalizedBy jacocoTestCoverageVerification
}

tasks.named('jacocoTestCoverageVerification') {
	violationRules {
		rule {
			limit {
				minimum = 0.6
			}
		}
	}
	dependsOn test // tests are required to run before checking code coverage.
}

export default defineConfig({
  plugins: [
    vue(),
    vueDevTools(),
  ],
  resolve: {
    alias: {
      '@': fileURLToPath(new URL('./src', import.meta.url))
    },
  },
  // Added
  server: {
    port: 8087
  }
})

<template>
</template>

<script>
</script>

<style>
</style>

<template>
    <main>
        <h1>Event Registration</h1>
        <h2>New Event</h2>
        <div>
            <select>
                <option value="IN_PERSON">In person</option>
                <option value="ONLINE">Online</option>
            </select>
            <input type="text" placeholder="Name" />
            <input type="date" placeholder="Date" />
            <input type="time" placeholder="Start Time" />
            <input type="time" placeholder="End Time" />
            <input type="text" placeholder="Registration Limit" />
            <input type="text" placeholder="Location" />
            <button>Create Event</button>
            <button class="danger-btn">Clear</button>
        </div>
        <h2>Events</h2>
        <table>
            <tbody>
                <tr>
                    <th>Name</th>
                    <th>Date</th>
                    <th>Type</th>
                </tr>
                <tr>
                    <td>My In-Person Event</td>
                    <td>2024-11-15</td>
                    <td>In person</td>
                </tr>
                <tr>
                    <td>My Online Event</td>
                    <td>2024-11-15</td>
                    <td>Online</td>
                </tr>
            </tbody>
        </table>
    </main>
</template>

<style>
main {
    display: flex;
    flex-direction: column;
    align-items: stretch;
}

h2 {
    padding-top: 1em;
    text-decoration: underline;
}

table {
    border-collapse: collapse;
}

td, th {
	border: 1px solid var(--color-border);
	padding: 0.25em;
}

.danger-btn {
    border: 1px solid red;
    color: red;
}
</style>

import EventsView from '@/views/EventsView.vue'
import { createRouter, createWebHistory } from 'vue-router'
import HomeView from '../views/HomeView.vue'

const router = createRouter({
  history: createWebHistory(import.meta.env.BASE_URL),
  routes: [
    {
      path: '/',
      name: 'events',
      component: EventsView,
    },
    {
      path: '/hello',
      name: 'home',
      component: HomeView
    },
    // etc.
  ],
})

export default router

npm install axios@1.5

<script>
import axios from "axios";

const axiosClient = axios.create({
	// NOTE: it's baseURL, not baseUrl
	baseURL: "http://localhost:8080"
});

export default {
  // ...
}
</script>

<script>
// ...

export default {
  // ...
  async created() {
    try {
      const response = await axiosClient.get("/events");
    } catch (e) {
      // TODO: Show a message to the user or something
      console.error(e);
    }
  }
  // ...
};
</script>

<script>
// ...

export default {
  // ...
  methods: {
    async createEvent() {
      const newEvent = {
        type: this.newEventType,
        name: this.newEventName,
        date: this.newEventDate,
        startTime: this.newEventStartTime,
        endTime: this.newEventEndTime,
        registrationLimit: this.newEventRegLimit,
        location: this.newEventLocation
      };
      try {
        const response = await axiosClient.post("/events", newEvent);
      } catch (e) {
        // TODO: show a message to the user or something
        console.error(e);
      }
      this.events.push(response.data);
      this.clearInputs();
    },
    // ...
  }
};
</script>

package ca.mcgill.ecse321.eventregistration.controller;

import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.RestController;

@RestController
@CrossOrigin(origins = "http://localhost:8087")
public class EventController {
  // ...
}