Skip to content
Snippets Groups Projects
Commit 9e0f5b08 authored by jez04's avatar jez04
Browse files

feat: :tada: solution

parent a5cbb3ea
Branches
No related merge requests found
......@@ -2,9 +2,14 @@ package lab;
import java.io.IOException;
import java.sql.SQLException;
import java.util.List;
import org.h2.tools.Server;
import lab.data.Game;
import lab.data.Player;
import lab.data.Score;
import lab.data.Score.Difficult;
import lab.storage.JpaConnector;
import lombok.extern.log4j.Log4j2;
......@@ -23,12 +28,50 @@ public class App {
Server server = startDBWebServer();
JpaConnector connector = new JpaConnector();
//TODO
for (int i = 0; i < 10; i++) {
connector.save(Game.generateAny());
}
for (int i = 0; i < 10; i++) {
connector.save(Player.generate());
}
List<Player> players = connector.getAll(Player.class);
List<Game> games = connector.getAll(Game.class);
for (int i = 0; i < 10; i++) {
connector.save(Score.generate(players, games));
}
connector.getEntityManager().clear();
connector.getAll(Score.class).forEach(System.out::println);
connector.getAll(Player.class).forEach(App::printPlayer);
connector.getAll(Game.class).forEach(App::printGame);
System.out.println("-----------null,null-----------------------------");
connector.findBy(null, null).forEach(System.out::println);
System.out.println("----------- ,null-----------------------------");
connector.findBy(" ", null).forEach(System.out::println);
System.out.println("-----------'ea',null-----------------------------");
connector.findBy("ea", null).forEach(System.out::println);
System.out.println("-----------'ea',medium-----------------------------");
connector.findBy("ea", Difficult.MEDIUM).forEach(System.out::println);
System.out.println("-----------'Java',null-----------------------------");
connector.findBy("Java", Difficult.MEDIUM).forEach(System.out::println);
waitForKeyPress();
stopDBWebServer(server);
}
private static void printPlayer(Player player) {
System.out.println(player);
for (Score score : player.getScores()) {
System.out.println(" -> " + score);
}
}
private static void printGame(Game game) {
System.out.println(game);
for (Score score : game.getScores()) {
System.out.println(" -> " + score);
}
}
private static Server startDBWebServer() {
// Start HTTP server for access H2 DB for look inside
......
......@@ -11,8 +11,10 @@ import lombok.NoArgsConstructor;
import lombok.Setter;
import lombok.ToString;
@Entity
@Getter
@Setter
@NoArgsConstructor
@ToString(callSuper = true)
public class FirstPersonShooter extends Game{
......
......@@ -2,20 +2,37 @@ package lab.data;
import java.util.List;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.OneToMany;
import lab.Tools;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import lombok.ToString;
@Entity
@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
@EqualsAndHashCode(onlyExplicitlyIncluded = true)
@ToString
@Builder(toBuilder = true)
public class Game implements MyEntity{
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
@EqualsAndHashCode.Include
private Long id;
private String name;
@OneToMany(mappedBy = Score_.GAME)
@ToString.Exclude
private List<Score> scores;
public static Game generate() {
......
......@@ -2,13 +2,19 @@ package lab.data;
import java.util.List;
import jakarta.persistence.Entity;
import lab.Tools;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import lombok.ToString;
@Entity
@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
@ToString(callSuper = true)
public class PlatformGame extends Game{
......
......@@ -2,23 +2,42 @@ package lab.data;
import java.util.List;
import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.ManyToOne;
import jakarta.persistence.OneToMany;
import lab.Tools;
import lab.data.Score.Difficult;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import lombok.ToString;
@Entity
@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
@EqualsAndHashCode(onlyExplicitlyIncluded = true)
@ToString
@Builder(toBuilder = true)
public class Player implements MyEntity{
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
@EqualsAndHashCode.Include
private Long id;
private String firstName;
private String lastName;
private String nick;
@OneToMany(mappedBy = Score_.PLAYER)
@ToString.Exclude
private List<Score> scores;
public static Player generate() {
......
package lab.data;
import java.util.List;
import java.util.Random;
import jakarta.persistence.Entity;
import jakarta.persistence.EnumType;
import jakarta.persistence.Enumerated;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.ManyToOne;
import jakarta.persistence.OneToMany;
import lab.Tools;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;
import lombok.ToString;
@Entity
@Getter
@Setter
@AllArgsConstructor
@NoArgsConstructor
@EqualsAndHashCode(onlyExplicitlyIncluded = true)
@ToString
@Builder(toBuilder = true)
public class Score implements MyEntity{
@EqualsAndHashCode.Include
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long id;
private int points;
@Enumerated(EnumType.STRING)
private Difficult level;
private Difficult difficult;
@ManyToOne
private Player player;
@ManyToOne
private Game game;
......
package lab.storage;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
import jakarta.persistence.EntityManager;
import jakarta.persistence.EntityManagerFactory;
import jakarta.persistence.Persistence;
import jakarta.persistence.criteria.CriteriaBuilder;
import jakarta.persistence.criteria.CriteriaQuery;
import jakarta.persistence.criteria.Predicate;
import jakarta.persistence.criteria.Root;
import lab.data.Game_;
import lab.data.MyEntity;
import lab.data.Score;
import lab.data.Score_;
public class JpaConnector {
......@@ -19,18 +26,29 @@ public class JpaConnector {
em = emf.createEntityManager();
}
public<T extends MyEntity> List<T> getAll(Class<T> clazz) {
return null;
public <T extends MyEntity> List<T> getAll(Class<T> clazz) {
return em.createQuery("select e from " + clazz.getSimpleName() + " e", clazz).getResultList();
}
public void init() {
}
public<T extends MyEntity> T save(T score) {
return null;
public <T extends MyEntity> T save(T entity) {
T result;
em.getTransaction().begin();
if (entity.getId() == null || entity.getId() == 0) {
em.persist(entity);
result = entity;
} else {
result = em.merge(entity);
}
em.getTransaction().commit();
return result;
}
public void delete(List<? extends MyEntity> e) {
public void delete(List<? extends MyEntity> entities) {
em.getTransaction().begin();
for (MyEntity entity : entities) {
em.remove(entity);
}
em.getTransaction().commit();
}
public void stop() {
......@@ -39,24 +57,36 @@ public class JpaConnector {
}
public EntityManager getEntityManager() {
//return entity manager. Type Object is there because of compilation of empty task assignment
return em;
}
public<T> T find(long id, Class<T> clazz) {
public <T> T find(long id, Class<T> clazz) {
return em.find(clazz, id);
}
public void modifyNoPersistOrMerge(long id, Consumer<Score> motificator) {
public void modifyNoPersistOrMerge(long id, Consumer<Score> modificator) {
em.getTransaction().begin();
Score score = em.find(Score.class, id);
motificator.accept(score);
modificator.accept(score);
em.getTransaction().commit();
}
public List<Score> findBy(String partialName, Score.Difficult difficult){
return null;
public List<Score> findBy(String partialName, Score.Difficult difficult) {
CriteriaBuilder criteriaBuilder = em.getCriteriaBuilder();
CriteriaQuery<Score> criteriaQuery = criteriaBuilder.createQuery(Score.class);
Root<Score> root = criteriaQuery.from(Score.class);
List<Predicate> predicates = new ArrayList<>();
if (partialName != null && !partialName.isBlank()) {
predicates.add(
criteriaBuilder.like(root.get(Score_.game).get(Game_.name), String.format("%%%s%%", partialName)));
}
if (difficult != null) {
predicates.add(criteriaBuilder.equal(root.get(Score_.difficult), difficult));
}
if (!predicates.isEmpty()) {
criteriaQuery.where(predicates.toArray(new Predicate[predicates.size()]));
}
return em.createQuery(criteriaQuery).getResultList();
}
}
......@@ -5,7 +5,7 @@ module cz.vsb.fei.java2.lab06_module {
requires jakarta.persistence;
requires com.h2database;
requires org.hibernate.orm.core;
requires jakarta.annotation;
requires static jakarta.annotation;
opens lab.data;
......
package jez04.structure.test;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.net.URISyntaxException;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
import org.hamcrest.Matchers;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.MethodOrderer.OrderAnnotation;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Order;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestMethodOrder;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;
import cz.vsb.fei.kelvin.unittest.ProjectContains;
import cz.vsb.fei.kelvin.unittest.StructureHelper;
import cz.vsb.fei.kelvin.unittest.TextFileContains;
import cz.vsb.fei.kelvin.unittest.XmlFileContains;
import lab.data.FirstPersonShooter;
import lab.data.Game;
import lab.data.MyEntity;
import lab.data.PlatformGame;
import lab.data.Player;
import lab.data.Score;
import lab.data.Score.Difficult;
import lab.storage.JpaConnector;
class ClassStructureTest {
StructureHelper helper = StructureHelper.getInstance(ClassStructureTest.class);
@ParameterizedTest
@CsvSource({
"Score.java,@Entity",
"Score.java,@NoArgsConstructor",
"Score.java,@EqualsAndHashCode",
"Score.java,@EqualsAndHashCode\\(onlyExplicitlyIncluded\\s*=\\s*true\\)",
"Score.java,@EqualsAndHashCode\\.Include",
"Score.java,@ManyToOne",
"Game.java,@Entity",
"Game.java,@NoArgsConstructor",
"Game.java,@EqualsAndHashCode",
"Game.java,@EqualsAndHashCode\\(onlyExplicitlyIncluded\\s*=\\s*true\\)",
"Game.java,@EqualsAndHashCode\\.Include",
"Game.java,@OneToMany\\(mappedBy",
"Game.java,@ToString\\.Exclude",
"Player.java,@Entity",
"Player.java,@NoArgsConstructor",
"Player.java,@EqualsAndHashCode",
"Player.java,@EqualsAndHashCode\\(onlyExplicitlyIncluded\\s*=\\s*true\\)",
"Player.java,@EqualsAndHashCode\\.Include",
"Player.java,@OneToMany\\(mappedBy",
"Player.java,@ToString\\.Exclude",
"FirstPersonShooter.java,@Entity",
"FirstPersonShooter.java,@NoArgsConstructor",
"PlatformGame.java,@Entity",
"PlatformGame.java,@NoArgsConstructor",
})
void anotaceTest(String file, String annotation) throws URISyntaxException {
assertThat(TextFileContains.getProjectRoot(getClass()),
new TextFileContains(file, annotation));
}
@ParameterizedTest
@CsvSource({
"Game.java,Score_.GAME",
"Player.java, Score_.PLAYER",
})
void mappedByTest(String file, String annotation) throws URISyntaxException {
assertThat(TextFileContains.getProjectRoot(getClass()),
new TextFileContains(file, annotation));
}
@Test
void jakartaAndHibernateAsDependencyTest() throws URISyntaxException {
assertThat(TextFileContains.getProjectRoot(getClass()), new XmlFileContains("pom.xml",
......@@ -44,10 +108,262 @@ class ClassStructureTest {
Matchers.endsWith(Paths.get("resources", "META-INF", "persistence.xml").toString()));
}
@Test
void useEnumeratedTest() throws URISyntaxException {
assertThat(TextFileContains.getProjectRoot(getClass()),
new TextFileContains("Score.java", "@Enumerated\\(\\s*EnumType.STRING\\s*\\)"));
@TestMethodOrder(OrderAnnotation.class)
@Nested
class JpaConnectorTests {
private Player player;
private Game game;
private PlatformGame platformGame;
private FirstPersonShooter firstPersonShooter;
private static JpaConnector connector;
@BeforeAll
static void initAll() {
try {
connector = new JpaConnector();
} catch (Exception e) {
e.printStackTrace();
}
}
@BeforeEach
void init() {
player = Player.generate();
game = Game.generate();
platformGame = PlatformGame.generate();
firstPersonShooter = FirstPersonShooter.generate();
connector.getEntityManager().clear();
if(connector.getEntityManager().getTransaction().isActive()) {
connector.getEntityManager().getTransaction().rollback();
}
}
@AfterAll
static void cleanUpAll() {
connector.stop();
}
boolean same(MyEntity e1, MyEntity e2) {
if(e1 instanceof Player p1 && e2 instanceof Player p2) {
return same(p1, p2);
} else if(e1 instanceof PlatformGame pg1 && e2 instanceof PlatformGame pg2) {
return same(pg1, pg2);
} else if(e1 instanceof FirstPersonShooter fps1 && e2 instanceof FirstPersonShooter fps2) {
return same(fps1, fps2);
} else if(e1 instanceof Game g1 && e2 instanceof Game g2) {
return same(g1, g2);
} else if(e1 instanceof Score s1 && e2 instanceof Score s2) {
return same(s1, s2);
}
return false;
}
private boolean same(Score s1, Score s2) {
return s1.getDifficult() == s2.getDifficult()
&& s1.getPoints() == s2.getPoints()
&& Objects.equals(s1.getId(), s2.getId())
&& Objects.equals(s1.getPlayer().getId(), s2.getPlayer().getId())
&& Objects.equals(s1.getGame().getId(), s2.getGame().getId());
}
private boolean same(Player p1, Player p2) {
return Objects.equals(p1.getId(), p2.getId())
&& Objects.equals(p1.getFirstName(), p2.getFirstName())
&& Objects.equals(p1.getLastName(), p2.getLastName())
&& Objects.equals(p1.getNick(), p2.getNick())
&& same(p1.getScores(), p2.getScores());
}
private boolean same(Game g1, Game g2) {
return Objects.equals(g1.getId(), g2.getId())
&& Objects.equals(g1.getName(), g2.getName())
&& same(g1.getScores(), g2.getScores());
}
private boolean same(PlatformGame g1, PlatformGame g2) {
return same((Game)g1, (Game)g2)
&& Objects.equals(g1.getPlatformType(), g2.getPlatformType())
&& g1.isRetro() == g2.isRetro();
}
private boolean same(FirstPersonShooter g1, FirstPersonShooter g2) {
return same((Game)g1, (Game)g2)
&& Objects.equals(g1.getFpsType(), g2.getFpsType())
&& g1.getPlayersCount() == g2.getPlayersCount();
}
private boolean same(List<?> l1, List<?> l2) {
if(l1 == null) {
l1 = Collections.emptyList();
}
if(l2 == null) {
l2 = Collections.emptyList();
}
return Objects.equals(l1, l2);
}
private void saveAndReadSame(MyEntity original) {
MyEntity result = connector.save(original);
assertThat(result.getId(), Matchers.notNullValue());
connector.getEntityManager().clear();
MyEntity saved = connector.getEntityManager().find(result.getClass(), result.getId());
assertTrue(same(result, saved), "Saved and readed entities are not same.");
}
@Test
@Order(100)
void jpaPlayerInsertTest() {
saveAndReadSame(player);
}
@Test
@Order(120)
void jpaGameInsertTest() {
saveAndReadSame(game);
}
@Test
@Order(130)
void jpaPlatformGameInsertTest() {
saveAndReadSame(platformGame);
}
@Test
@Order(140)
void jpaFirstPersonShooterInsertTest() {
saveAndReadSame(firstPersonShooter);
}
@Test
@Order(150)
void jpaScoreInsertTest() {
saveAndReadSame(Score.generate(connector.getAll(Player.class), connector.getAll(Game.class)));
}
@Test
@Order(200)
void jpaPlayerReadTest() {
List<Player> savedEntities = connector.getAll(Player.class).stream().toList();
assertThat(savedEntities, Matchers.not(Matchers.hasSize(0)));
}
@Test
@Order(210)
void jpaGameReadTest() {
List<Game> savedEntities = connector.getAll(Game.class).stream().toList();
assertThat(savedEntities, Matchers.not(Matchers.hasSize(0)));
}
@Test
@Order(220)
void jpaPlatformGameReadTest() {
List<PlatformGame> savedEntities = connector.getAll(PlatformGame.class).stream().toList();
assertThat(savedEntities, Matchers.not(Matchers.hasSize(0)));
}
@Test
@Order(230)
void jpaFirstPersonShooterReadTest() {
List<FirstPersonShooter> savedEntities = connector.getAll(FirstPersonShooter.class).stream().toList();
assertThat(savedEntities, Matchers.not(Matchers.hasSize(0)));
}
@Test
@Order(240)
void jpaScoreReadTest() {
List<Score> savedEntities = connector.getAll(Score.class).stream().toList();
assertThat(savedEntities, Matchers.not(Matchers.hasSize(0)));
}
@Test
@Order(250)
void jpaGameScoresContainScoreTest() {
List<Score> savedEntities = connector.getAll(Score.class).stream().toList();
for (Score score : savedEntities) {
assertThat(score.getGame().getScores(), Matchers.containsInRelativeOrder(score));
}
}
@Test
@Order(260)
void jpaPlayerScoresContainScoreTest() {
List<Score> savedEntities = connector.getAll(Score.class).stream().toList();
for (Score score : savedEntities) {
assertThat(score.getPlayer().getScores(), Matchers.containsInRelativeOrder(score));
}
}
@Test
@Order(270)
void jpaScoreToStringTest() {
List<Score> savedEntities = connector.getAll(Score.class);
for (Score score : savedEntities) {
assertThat(score.toString(), Matchers.notNullValue());
}
}
@Test
@Order(280)
void jpaPlayerToStringTest() {
List<Player> savedEntities = connector.getAll(Player.class);
for (Player p : savedEntities) {
assertThat(p.toString(), Matchers.notNullValue());
}
}
private void deleteAllAndAssert(Class<? extends MyEntity> clazz) {
List<? extends MyEntity> savedEntities = connector.getAll(clazz);
assertThat(savedEntities, Matchers.not(Matchers.hasSize(0)));
connector.delete(savedEntities);
List<? extends MyEntity> modifiedEntities = connector.getAll(clazz);
assertThat(modifiedEntities, Matchers.hasSize(0));
}
@Test
@Order(300)
void jpaScoreDeleteTest() {
deleteAllAndAssert(Score.class);
}
@Test
@Order(310)
void jpaPlayerDeleteTest() {
deleteAllAndAssert(Player.class);
}
@Test
@Order(320)
void jpaGameDeleteTest() {
deleteAllAndAssert(Game.class);
}
@Test
@Order(400)
void jpaFindByNullNUllTest() {
connector.save(player);
game.setName("aa-test-bb");
connector.save(game);
Game g2 = new Game(null, "aa--bb", null);
connector.save(g2);
connector.save(new Score(null, 100, Difficult.EASY, player, game));
connector.save(new Score(null, 100, Difficult.HARD, player, game));
connector.save(new Score(null, 100, Difficult.EASY, player, g2));
connector.save(new Score(null, 100, Difficult.HARD, player, g2));
assertThat(connector.findBy(null, null), Matchers.hasSize(4));
}
@Test
@Order(410)
void jpaFindByDiffTest() {
assertThat(connector.findBy(null, Difficult.HARD), Matchers.hasSize(2));
}
@Test
@Order(420)
void jpaFindByNameTest() {
assertThat(connector.findBy("test", null), Matchers.hasSize(2));
}
@Test
@Order(430)
void jpaFindByNameAndDiffTest() {
assertThat(connector.findBy("test", Difficult.EASY), Matchers.hasSize(1));
}
@Test
@Order(440)
void jpaFindByNameAndDiff2Test() {
assertThat(connector.findBy("--", Difficult.HARD), Matchers.hasSize(1));
}
}
}
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment