StroevVladimir/Internet_Programming_2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Остались тесты

Browse Source
This commit is contained in:
DyCTaTOR 2024-04-15 16:56:13 +04:00
parent c4eb1070e1
commit 9d53595074
13 changed files with 9357 additions and 79 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
data.mv.db
View File

Binary file not shown.

9156
data.trace.db Normal file
View File

File diff suppressed because it is too large Load Diff

62
src/main/java/com/example/demo/DemoApplication.java
View File

@ -9,30 +9,58 @@ import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import com.example.demo.department.model.DepartmentEntity;
import com.example.demo.directions.model.DirectionsEntity;
import com.example.demo.news.model.NewsEntity;
import com.example.demo.entrysData.model.EntrysDataEntity;
import com.example.demo.department.service.DepartmentService;
import com.example.demo.directions.service.DirectionsService;
import com.example.demo.entrysData.service.EntrysDataService;
import com.example.demo.news.service.NewsService;
@SpringBootApplication
public class DemoApplication implements CommandLineRunner {
private final Logger log = LoggerFactory.getLogger(DemoApplication.class);
private final Logger log = LoggerFactory.getLogger(DemoApplication.class);
private final EntrysDataService entrysDataService;
private final EntrysDataService entrysDataService;
private final DepartmentService departmentService;
private final NewsService newsService;
private final DirectionsService directionsService;
public DemoApplication(EntrysDataService entrysDataService) {
this.entrysDataService = entrysDataService;
}
public DemoApplication(EntrysDataService entrysDataService, DepartmentService departmentService,
NewsService newsService, DirectionsService directionsService) {
this.entrysDataService = entrysDataService;
this.departmentService = departmentService;
this.directionsService = directionsService;
this.newsService = newsService;
}
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
@Override
public void run(String... args) throws Exception {
if (args.length > 0 && Objects.equals("--populate", args[0])) {
log.info("Start work");
entrysDataService.create(
new EntrysDataEntity(null, "login", "password", "role",
new DepartmentEntity(null, "test")));
}
}
@Override
public void run(String... args) throws Exception {
if (args.length > 0 && Objects.equals("--populate", args[0])) {
log.info("Create departments");
final var dep1 = departmentService.create(new DepartmentEntity("ГУМ"));
final var dep2 = departmentService.create(new DepartmentEntity("ИСТ"));
final var dep3 = departmentService.create(new DepartmentEntity("ИЯ"));
log.info("Create entrysData");
entrysDataService.create(new EntrysDataEntity("login", "password", "user", dep2));
entrysDataService.create(new EntrysDataEntity("login1", "password", "user", dep3));
entrysDataService.create(new EntrysDataEntity("login2", "password", "user", dep1));
log.info("Create directions");
directionsService.create(new DirectionsEntity("09.02.23", "Программная инженерия", dep1, "Информатика"));
directionsService.create(new DirectionsEntity("09.03.24", "ИВТ", dep2, "Информатика, математика"));
directionsService.create(new DirectionsEntity("02.05.20", "ИСТ", dep3, "Информатика, иностранный языкы"));
log.info("Create news");
newsService.create(new NewsEntity("2024-04-15", "new1", "description1", dep2));
newsService.create(new NewsEntity("2024-02-23", "new2", "description2", dep3));
newsService.create(new NewsEntity("2024-03-17", "new3", "description3", dep1));
}
}
}

2
src/main/java/com/example/demo/department/api/DepartmentController.java
View File

@ -10,10 +10,12 @@ import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import com.example.demo.core.configuration.Constants;
import com.example.demo.department.service.DepartmentService;
import com.example.demo.directions.model.DirectionsEntity;
import com.example.demo.department.model.DepartmentEntity;
import jakarta.validation.Valid;

2
src/main/java/com/example/demo/department/service/DepartmentService.java
View File

@ -5,10 +5,12 @@ import java.util.stream.StreamSupport;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.RequestParam;
import com.example.demo.core.error.NotFoundException;
import com.example.demo.department.model.DepartmentEntity;
import com.example.demo.department.repository.DepartmentRepository;
import com.example.demo.directions.model.DirectionsEntity;
@Service
public class DepartmentService {

1
src/main/java/com/example/demo/directions/service/DirectionsService.java
View File

@ -7,6 +7,7 @@ import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.example.demo.core.error.NotFoundException;
import com.example.demo.department.model.DepartmentEntity;
import com.example.demo.directions.model.DirectionsEntity;
import com.example.demo.directions.repository.DirectionsRepository;

4
src/main/java/com/example/demo/entrysData/api/EntrysDataController.java
View File

@ -69,8 +69,8 @@ public class EntrysDataController {
return toDto(entrysDataService.delete(id));
}
@PutMapping("/{id}")
public EntrysDataDto updatePassword(@PathVariable(name = "password") Long id,
@PutMapping("/{id}/password")
public EntrysDataDto updatePassword(@PathVariable(name = "id") Long id,
@RequestParam(name = "newPassword") String newPas,
@RequestParam(name = "oldPassword") String oldPas) {
return toDto(entrysDataService.updatePassword(id, newPas, oldPas));

10
src/main/java/com/example/demo/entrysData/api/EntrysDataDto.java
View File

@ -2,7 +2,6 @@ package com.example.demo.entrysData.api;
import com.fasterxml.jackson.annotation.JsonProperty;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.Min;
import jakarta.validation.constraints.NotNull;
@ -10,14 +9,14 @@ public class EntrysDataDto {
@JsonProperty(access = JsonProperty.Access.READ_ONLY)
private Long id;
@NotNull
@Min(1)
private Long departmentId;
@NotBlank
private String login;
@NotNull
private String role;
@NotBlank
@NotNull
private String password;
@NotNull
@Min(1)
private Long departmentId;
public Long getId() {
return id;
@ -41,7 +40,6 @@ public class EntrysDataDto {
}
public void setRole(String role) {
role = "user";
this.role = role;
}

4
src/main/resources/application.properties
View File

@ -13,8 +13,8 @@ spring.datasource.password=password
spring.datasource.driver-class-name=org.h2.Driver
spring.jpa.hibernate.ddl-auto=create
spring.jpa.open-in-view=false
# spring.jpa.show-sql=true
# spring.jpa.properties.hibernate.format_sql=true
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.format_sql=true
# H2 console
spring.h2.console.enabled=true

10
src/test/java/com/example/demo/java/DepartmentsTests.java
View File

@ -67,7 +67,7 @@ class DepartmentsTests {
final DepartmentEntity newEntity = departmentService.update(department.getId(),
new DepartmentEntity(testName));
Assertions.assertEquals(3, departmentService.getAll().size());
Assertions.assertEquals(newEntity, departmentService.get(3L));
Assertions.assertEquals(newEntity, departmentService.get(department.getId()));
Assertions.assertEquals(testName, newEntity.getName());
Assertions.assertNotEquals(oldName, newEntity.getName());
@ -75,14 +75,12 @@ class DepartmentsTests {
@Test
void deleteTest() {
departmentService.delete(3L);
departmentService.delete(department.getId());
Assertions.assertEquals(2, departmentService.getAll().size());
final DepartmentEntity last = departmentService.get(2L);
Assertions.assertEquals(2L, last.getId());
final DepartmentEntity newEntity = departmentService
.create(new DepartmentEntity("testtt"));
.create(new DepartmentEntity(department.getName()));
Assertions.assertEquals(3, departmentService.getAll().size());
Assertions.assertEquals(4L, newEntity.getId());
Assertions.assertNotEquals(department.getId(), newEntity.getId());
}
}

72
src/test/java/com/example/demo/java/DirectionsTests.java
View File

@ -1,15 +1,19 @@
package com.example.demo.java;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.MethodOrderer.OrderAnnotation;
import org.junit.jupiter.api.Order;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestMethodOrder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.dao.DataIntegrityViolationException;
import com.example.demo.core.error.NotFoundException;
import com.example.demo.department.model.DepartmentEntity;
import com.example.demo.department.service.DepartmentService;
import com.example.demo.directions.model.DirectionsEntity;
import com.example.demo.directions.service.DirectionsService;
@ -18,32 +22,68 @@ import com.example.demo.directions.service.DirectionsService;
class DirectionsTests {
@Autowired
private DirectionsService directionsService;
@Autowired
private DepartmentService departmentService;
@Test
void getTest() {
Assertions.assertThrows(NotFoundException.class, () -> directionsService.get(0L));
private DepartmentEntity dep1;
private DepartmentEntity dep2;
private DirectionsEntity direct1;
private DirectionsEntity direct2;
private DirectionsEntity direct3;
@BeforeEach
void createData() {
removeData();
dep1 = departmentService.create(new DepartmentEntity("GUM"));
dep2 = departmentService.create(new DepartmentEntity("IST"));
direct1 = directionsService
.create(new DirectionsEntity("09.03.23", "Программная инженерия", dep2, "Инф"));
direct2 = directionsService.create(
new DirectionsEntity("09.04.24", "Про", dep1, "Рус"));
direct3 = directionsService.create(
new DirectionsEntity("09.05.25", "Прогdcя", dep1, "Мат"));
}
@AfterEach
void removeData() {
directionsService.getAll(0L).forEach(item -> directionsService.delete(item.getId()));
departmentService.getAll().forEach(item -> departmentService.delete(item.getId()));
}
@Test
@Order(1)
void createTest() {
directionsService.create(new DirectionsEntity(null, "09.03.01", "Программная инженерия",
new DepartmentEntity(null, "ИСТ"), "Информатика"));
directionsService.create(new DirectionsEntity(null, "09.03.02", "ИВТ", new DepartmentEntity(null,
"ИСТ"),
"Русский язык"));
final DirectionsEntity last = directionsService.create(new DirectionsEntity(null, "09.03.03",
"АиСД", new DepartmentEntity(null, "Гум"), "Математика"));
Assertions.assertEquals(3, directionsService.getAll(0L).size());
Assertions.assertEquals(last, directionsService.get(3L));
Assertions.assertEquals(2, directionsService.getAll(dep1.getId()).size());
Assertions.assertEquals(1, directionsService.getAll(dep2.getId()).size());
}
@Test
@Order(2)
void createNotUniqueTest() {
final DirectionsEntity nonUniquedirection = new DirectionsEntity("09.04.24", "Про", new DepartmentEntity("ИЯ"),
"Рус");
Assertions.assertThrows(IllegalArgumentException.class, () -> directionsService.create(nonUniquedirection));
}
@Test
@Order(3)
void createNullableTest() {
final DirectionsEntity nullabledirection = new DirectionsEntity(null, null, null, null);
Assertions.assertThrows(
DataIntegrityViolationException.class,
() -> directionsService.create(nullabledirection));
}
@Test
@Order(4)
void updateTest() {
final String testCode = "TESTCODE";
final String testName = "TESTNAME";
final DepartmentEntity testDep = new DepartmentEntity(null, "TESTDEP");
final DepartmentEntity testDep = new DepartmentEntity("TESTDEP");
final String testThin = "TESTTHIN";
final DirectionsEntity entity = directionsService.get(3L);
final String oldCode = entity.getCode();
@ -51,7 +91,7 @@ class DirectionsTests {
final DepartmentEntity oldDep = entity.getDepartment();
final String oldThin = entity.getThings();
final DirectionsEntity newEntity = directionsService.update(3L,
new DirectionsEntity(1L, testCode, testName, testDep, testThin));
new DirectionsEntity(testCode, testName, testDep, testThin));
Assertions.assertEquals(3, directionsService.getAll(0L).size());
Assertions.assertEquals(newEntity, directionsService.get(3L));
Assertions.assertEquals(testCode, newEntity.getCode());
@ -68,7 +108,7 @@ class DirectionsTests {
}
@Test
@Order(3)
@Order(5)
void deleteTest() {
directionsService.delete(3L);
Assertions.assertEquals(2, directionsService.getAll(0L).size());
@ -76,8 +116,8 @@ class DirectionsTests {
Assertions.assertEquals(2L, last.getId());
final DirectionsEntity newEntity = directionsService
.create(new DirectionsEntity(null, "test1", "test2",
new DepartmentEntity(null, "test3"), "test4"));
.create(new DirectionsEntity("test1", "test2",
new DepartmentEntity("test3"), "test4"));
Assertions.assertEquals(3, directionsService.getAll(0L).size());
Assertions.assertEquals(4L, newEntity.getId());
}

58
src/test/java/com/example/demo/java/EntrysDataTests.java
View File

@ -1,12 +1,14 @@
package com.example.demo.java;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.MethodOrderer.OrderAnnotation;
import org.junit.jupiter.api.Order;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestMethodOrder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.dao.DataIntegrityViolationException;
import com.example.demo.core.error.NotFoundException;
import com.example.demo.department.model.DepartmentEntity;
@ -19,36 +21,62 @@ class EntrysDataTests {
@Autowired
private EntrysDataService entrysDataService;
private EntrysDataEntity entrysData;
@BeforeEach
void createData() {
removeData();
entrysData = entrysDataService
.create(new EntrysDataEntity("login1", "pass1", "user", new DepartmentEntity("ГУМ")));
entrysDataService.create(
new EntrysDataEntity("login2", "pass2", "user", new DepartmentEntity("IST")));
entrysDataService.create(
new EntrysDataEntity("login3", "pass3", "user", new DepartmentEntity("IYA")));
}
@AfterEach
void removeData() {
entrysDataService.getAll(0L).forEach(item -> entrysDataService.delete(item.getId()));
}
@Test
void getTest() {
Assertions.assertThrows(NotFoundException.class, () -> entrysDataService.get(0L));
}
@Test
@Order(1)
void createTest() {
entrysDataService
.create(new EntrysDataEntity(null, "dyctator", "12345", "user", new DepartmentEntity(null, "ИСТ")));
entrysDataService.create(new EntrysDataEntity(null, "user2", "12345", "user",
new DepartmentEntity(null, "ИСТ")));
final EntrysDataEntity last = entrysDataService.create(new EntrysDataEntity(null, "user3", "12345", "user",
new DepartmentEntity(null, "Гум")));
Assertions.assertEquals(3, entrysDataService.getAll(0L).size());
Assertions.assertEquals(last, entrysDataService.get(3L));
Assertions.assertEquals(entrysData, entrysDataService.get(entrysData.getId()));
}
@Test
void createNotUniqueTest() {
final EntrysDataEntity nonUniquedirection = new EntrysDataEntity("login4", "pass4", "user",
new DepartmentEntity("IYA"));
Assertions.assertThrows(IllegalArgumentException.class, () -> entrysDataService.create(nonUniquedirection));
}
@Test
void createNullableTest() {
final EntrysDataEntity nullabledirection = new EntrysDataEntity(null, null, null, null);
Assertions.assertThrows(
DataIntegrityViolationException.class,
() -> entrysDataService.create(nullabledirection));
}
@Test
@Order(2)
void updateTest() {
final String testLog = "TESTLOG";
final String testPas = "TESTPAS";
final DepartmentEntity testDep = new DepartmentEntity(null, "TESTDEP");
final DepartmentEntity testDep = new DepartmentEntity("TESTDEP");
final EntrysDataEntity entity = entrysDataService.get(3L);
final String oldLog = entity.getLogin();
final String oldPas = entity.getLogin();
final DepartmentEntity oldDep = entity.getDepartment();
final EntrysDataEntity newEntity = entrysDataService.update(3L,
new EntrysDataEntity(1L, testLog, testPas, entity.getRole(), testDep));
new EntrysDataEntity(testLog, testPas, entity.getRole(), testDep));
Assertions.assertEquals(3, entrysDataService.getAll(0L).size());
Assertions.assertEquals(newEntity, entrysDataService.get(3L));
@ -63,7 +91,6 @@ class EntrysDataTests {
}
@Test
@Order(3)
void deleteTest() {
entrysDataService.delete(3L);
Assertions.assertEquals(2, entrysDataService.getAll(0L).size());
@ -71,14 +98,13 @@ class EntrysDataTests {
Assertions.assertEquals(2L, last.getId());
final EntrysDataEntity newEntity = entrysDataService
.create(new EntrysDataEntity(null, "user4", "12345", "user",
new DepartmentEntity(null, "testtt")));
.create(new EntrysDataEntity("user4", "12345", "user",
new DepartmentEntity("testtt")));
Assertions.assertEquals(3, entrysDataService.getAll(0L).size());
Assertions.assertEquals(4L, newEntity.getId());
}
@Test
@Order(4)
void updatePasswordTest() {
final String newPas = "TESTPAS";
final EntrysDataEntity entity = entrysDataService.get(1L);

55
src/test/java/com/example/demo/java/NewsTests.java
View File

@ -1,12 +1,14 @@
package com.example.demo.java;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.MethodOrderer.OrderAnnotation;
import org.junit.jupiter.api.Order;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestMethodOrder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.dao.DataIntegrityViolationException;
import com.example.demo.core.error.NotFoundException;
import com.example.demo.department.model.DepartmentEntity;
@ -19,38 +21,64 @@ class NewsTests {
@Autowired
private NewsService newsService;
private NewsEntity news;
@BeforeEach
void createData() {
removeData();
news = newsService
.create(new NewsEntity("2024-04-13", "new1", "description1", new DepartmentEntity("ГУМ")));
newsService.create(
new NewsEntity("2024-05-14", "new2", "description2", new DepartmentEntity("IST")));
newsService.create(
new NewsEntity("2024-02-10", "new3", "description3", new DepartmentEntity("JUV")));
}
@AfterEach
void removeData() {
newsService.getAll(0L).forEach(item -> newsService.delete(item.getId()));
}
@Test
void getTest() {
Assertions.assertThrows(NotFoundException.class, () -> newsService.get(0L));
}
@Test
@Order(1)
void createTest() {
newsService.create(new NewsEntity(null, "2023-12-23", "Новость0",
"УлГТУ000", new DepartmentEntity(null, "ИСТ")));
newsService.create(new NewsEntity(null, "2023-12-24", "Новость1", "УлГТУ111",
new DepartmentEntity(null, "ИСТ")));
final NewsEntity last = newsService.create(new NewsEntity(null, "2023-12-25",
"Новость2", "УлГТУ222", new DepartmentEntity(null, "Гум")));
Assertions.assertEquals(3, newsService.getAll(0L).size());
Assertions.assertEquals(last, newsService.get(3L));
Assertions.assertEquals(news, newsService.get(news.getId()));
}
@Test
void createNotUniqueTest() {
final NewsEntity nonUniquedirection = new NewsEntity("2024-02-10", "new4", "description4",
new DepartmentEntity("JUV"));
Assertions.assertThrows(IllegalArgumentException.class, () -> newsService.create(nonUniquedirection));
}
@Test
void createNullableTest() {
final NewsEntity nullabledirection = new NewsEntity(null, null, null, null);
Assertions.assertThrows(
DataIntegrityViolationException.class,
() -> newsService.create(nullabledirection));
}
@Test
@Order(2)
void updateTest() {
final String testDate = "TESTDATE";
final String testName = "TESTNAME";
final String testDes = "TESTDES";
final DepartmentEntity testDep = new DepartmentEntity(null, "TESTDEP");
final DepartmentEntity testDep = new DepartmentEntity("TESTDEP");
final NewsEntity entity = newsService.get(3L);
final String oldDate = entity.getDate();
final String oldName = entity.getName();
final String oldDes = entity.getDescription();
final DepartmentEntity oldDep = entity.getDepartment();
final NewsEntity newEntity = newsService.update(3L,
new NewsEntity(1L, testDate, testName, testDes, testDep));
new NewsEntity(testDate, testName, testDes, testDep));
Assertions.assertEquals(3, newsService.getAll(0L).size());
Assertions.assertEquals(newEntity, newsService.get(3L));
@ -68,7 +96,6 @@ class NewsTests {
}
@Test
@Order(3)
void deleteTest() {
newsService.delete(3L);
Assertions.assertEquals(2, newsService.getAll(0L).size());
@ -76,7 +103,7 @@ class NewsTests {
Assertions.assertEquals(2L, last.getId());
final NewsEntity newEntity = newsService
.create(new NewsEntity(null, "test1", "test2", "test3", new DepartmentEntity(null, "testtt")));
.create(new NewsEntity("test1", "test2", "test3", new DepartmentEntity("testtt")));
Assertions.assertEquals(3, newsService.getAll(0L).size());
Assertions.assertEquals(4L, newEntity.getId());
}