From 28af7b9bb7b2cc832c3cbb83a4512af80696f5c6 Mon Sep 17 00:00:00 2001 From: huguenindo Date: Sat, 19 Nov 2022 14:16:19 +0100 Subject: [PATCH 1/5] refactor: ajout de constant pour la personne de DEFRERE --- src/main/java/personne/domain/DemoData.java | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/src/main/java/personne/domain/DemoData.java b/src/main/java/personne/domain/DemoData.java index 8ee0517..e2eb7ce 100644 --- a/src/main/java/personne/domain/DemoData.java +++ b/src/main/java/personne/domain/DemoData.java @@ -23,12 +23,12 @@ public class DemoData { private void initPersonnes() { - String uuid = "DEMO0000-0000-0000-0002-000000000001"; + String uuid = PERNONNE_DEFRERE_UUID; Personne p = PersonneBase.builder() .uuid(uuid) - .nom("DEFRERE") - .prenom("Marc") + .nom(PERNONNE_DEFRERE_NOM) + .prenom(PERSONNE_DEFRERE_PRENOM) .build(); this.personnes.put(uuid, p); @@ -182,6 +182,9 @@ public class DemoData { this.personnes.put(uuid, p); } + public static final String PERSONNE_DEFRERE_PRENOM = "Marc"; + public static final String PERNONNE_DEFRERE_NOM = "DEFRERE"; + public static final String PERNONNE_DEFRERE_UUID = "DEMO0000-0000-0000-0002-000000000001"; public Map getPersonnes() { return personnes; -- GitLab From 1c41f32ce3345596ec2a895c94fbfde8cfffdd40 Mon Sep 17 00:00:00 2001 From: huguenindo Date: Sat, 19 Nov 2022 14:16:57 +0100 Subject: [PATCH 2/5] =?UTF-8?q?feat:=20ajout=20de=20la=20d=C3=A9pendance?= =?UTF-8?q?=20=C3=A0=20la=20librairie=20postgreql?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- pom.xml | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/pom.xml b/pom.xml index cf5af30..1fa0f89 100644 --- a/pom.xml +++ b/pom.xml @@ -33,6 +33,12 @@ 7.0 provided + + org.postgresql + postgresql + 42.3.1 + + -- GitLab From e402c7a80a4a38e12dd8a36ae9594af48f2eadae Mon Sep 17 00:00:00 2001 From: huguenindo Date: Sat, 19 Nov 2022 14:17:48 +0100 Subject: [PATCH 3/5] =?UTF-8?q?feat:=20impl=C3=A9mentation=20de=20la=20per?= =?UTF-8?q?sistence=20de=20la=20personne?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../personne/datasource/DatabaseSetup.java | 15 ++ .../EntiteInconnuePersistenceException.java | 34 +++ src/main/java/personne/datasource/Mapper.java | 20 ++ .../personne/datasource/MapperManager.java | 15 ++ .../datasource/PersistenceException.java | 35 +++ .../personne/datasource/PersonneMapper.java | 11 + .../datasource/db/DataSourceFactory.java | 33 +++ .../datasource/db/DatabaseSetupImpl.java | 90 +++++++ .../datasource/db/DbMapperManagerImpl.java | 51 ++++ .../datasource/db/PersonneMapperImpl.java | 246 ++++++++++++++++++ src/main/java/personne/datasource/db/SQL.java | 66 +++++ .../datasource/db/DatabaseSetupImplTest.java | 55 ++++ .../datasource/db/PersonneMapperImplTest.java | 168 ++++++++++++ .../datasource/db/TestDataSourceFactory.java | 22 ++ 14 files changed, 861 insertions(+) create mode 100644 src/main/java/personne/datasource/DatabaseSetup.java create mode 100644 src/main/java/personne/datasource/EntiteInconnuePersistenceException.java create mode 100644 src/main/java/personne/datasource/Mapper.java create mode 100644 src/main/java/personne/datasource/MapperManager.java create mode 100644 src/main/java/personne/datasource/PersistenceException.java create mode 100644 src/main/java/personne/datasource/PersonneMapper.java create mode 100644 src/main/java/personne/datasource/db/DataSourceFactory.java create mode 100644 src/main/java/personne/datasource/db/DatabaseSetupImpl.java create mode 100644 src/main/java/personne/datasource/db/DbMapperManagerImpl.java create mode 100644 src/main/java/personne/datasource/db/PersonneMapperImpl.java create mode 100644 src/main/java/personne/datasource/db/SQL.java create mode 100644 src/test/java/personne/datasource/db/DatabaseSetupImplTest.java create mode 100644 src/test/java/personne/datasource/db/PersonneMapperImplTest.java create mode 100644 src/test/java/personne/datasource/db/TestDataSourceFactory.java diff --git a/src/main/java/personne/datasource/DatabaseSetup.java b/src/main/java/personne/datasource/DatabaseSetup.java new file mode 100644 index 0000000..e3a8cc1 --- /dev/null +++ b/src/main/java/personne/datasource/DatabaseSetup.java @@ -0,0 +1,15 @@ +package personne.datasource; + +/** + * + * @author dominique huguenin (dominique.huguenin@rpn.ch) + */ +public interface DatabaseSetup { + + void createTables() throws PersistenceException; + + void dropTables() throws PersistenceException; + + void insertData() throws PersistenceException; + +} diff --git a/src/main/java/personne/datasource/EntiteInconnuePersistenceException.java b/src/main/java/personne/datasource/EntiteInconnuePersistenceException.java new file mode 100644 index 0000000..e0ff2d8 --- /dev/null +++ b/src/main/java/personne/datasource/EntiteInconnuePersistenceException.java @@ -0,0 +1,34 @@ +package personne.datasource; + +/** + * + * @author dominique huguenin (dominique.huguenin AT rpn.ch) + */ +public class EntiteInconnuePersistenceException extends PersistenceException { + + public EntiteInconnuePersistenceException() { + } + + public EntiteInconnuePersistenceException( + final String message) { + super(message); + } + + public EntiteInconnuePersistenceException( + final String message, final Throwable cause) { + super(message, cause); + } + + public EntiteInconnuePersistenceException( + final Throwable cause) { + super(cause); + } + + public EntiteInconnuePersistenceException( + final String message, + final Throwable cause, final boolean enableSuppression, + final boolean writableStackTrace) { + super(message, cause, enableSuppression, writableStackTrace); + } + +} diff --git a/src/main/java/personne/datasource/Mapper.java b/src/main/java/personne/datasource/Mapper.java new file mode 100644 index 0000000..5105ac4 --- /dev/null +++ b/src/main/java/personne/datasource/Mapper.java @@ -0,0 +1,20 @@ +package personne.datasource; + +import java.util.List; + +/** + * + * @author dominique huguenin (dominique.huguenin@rpn.ch) + */ +public interface Mapper { + + E create(E entite) throws PersistenceException; + + E retrieveByUUID(String uuid) throws PersistenceException; + + List retrieve(String filtre) throws PersistenceException; + + void update(E entite) throws PersistenceException; + + void delete(E entite) throws PersistenceException; +} diff --git a/src/main/java/personne/datasource/MapperManager.java b/src/main/java/personne/datasource/MapperManager.java new file mode 100644 index 0000000..8b937f6 --- /dev/null +++ b/src/main/java/personne/datasource/MapperManager.java @@ -0,0 +1,15 @@ +package personne.datasource; + +/** + * + * @author dominique huguenin (dominique.huguenin@rpn.ch) + */ +public interface MapperManager { + + PersonneMapper getPersonneMapper() + throws PersistenceException; + + DatabaseSetup getDatabaseSetup() + throws PersistenceException; + +} diff --git a/src/main/java/personne/datasource/PersistenceException.java b/src/main/java/personne/datasource/PersistenceException.java new file mode 100644 index 0000000..506f5fe --- /dev/null +++ b/src/main/java/personne/datasource/PersistenceException.java @@ -0,0 +1,35 @@ +package personne.datasource; + +/** + * + * @author dominique huguenin (dominique.huguenin AT rpn.ch) + */ +public class PersistenceException extends Exception { + + public PersistenceException() { + } + + public PersistenceException( + final String message) { + super(message); + } + + public PersistenceException( + final String message, final Throwable cause) { + super(message, cause); + } + + public PersistenceException( + final Throwable cause) { + super(cause); + } + + public PersistenceException( + final String message, + final Throwable cause, + final boolean enableSuppression, + final boolean writableStackTrace) { + super(message, cause, enableSuppression, writableStackTrace); + } + +} diff --git a/src/main/java/personne/datasource/PersonneMapper.java b/src/main/java/personne/datasource/PersonneMapper.java new file mode 100644 index 0000000..eea43fc --- /dev/null +++ b/src/main/java/personne/datasource/PersonneMapper.java @@ -0,0 +1,11 @@ +package personne.datasource; + +import personne.domain.Personne; + +/** + * + * @author dom + */ +public interface PersonneMapper extends Mapper{ + +} diff --git a/src/main/java/personne/datasource/db/DataSourceFactory.java b/src/main/java/personne/datasource/db/DataSourceFactory.java new file mode 100644 index 0000000..3ea03af --- /dev/null +++ b/src/main/java/personne/datasource/db/DataSourceFactory.java @@ -0,0 +1,33 @@ +package personne.datasource.db; + +import javax.sql.DataSource; +import org.postgresql.ds.PGPoolingDataSource; + +/** + * + * @author dominique huguenin (dominique.huguenin@rpn.ch) + */ +public final class DataSourceFactory { + + private DataSourceFactory() { + } + + public static DataSource getPostgreSQLDataSource( + final String serverName, + final int portNumber, + final String databaseName, + final String user, + final String password) { + + PGPoolingDataSource ds = new PGPoolingDataSource(); + ds.setServerName(serverName); + ds.setPortNumber(portNumber); + ds.setDatabaseName(databaseName); + ds.setUser(user); + ds.setPassword(password); + ds.setMaxConnections(MAX_CONNECTION); + + return ds; + } + private static final int MAX_CONNECTION = 10; +} diff --git a/src/main/java/personne/datasource/db/DatabaseSetupImpl.java b/src/main/java/personne/datasource/db/DatabaseSetupImpl.java new file mode 100644 index 0000000..3864584 --- /dev/null +++ b/src/main/java/personne/datasource/db/DatabaseSetupImpl.java @@ -0,0 +1,90 @@ +package personne.datasource.db; + +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.SQLException; +import java.sql.Statement; +import java.util.logging.Level; +import java.util.logging.Logger; +import personne.datasource.DatabaseSetup; +import personne.datasource.PersistenceException; +import personne.domain.DemoData; +import personne.domain.Personne; + +/** + * + * @author dominique huguenin (dominique.huguenin@rpn.ch) + */ +public class DatabaseSetupImpl implements DatabaseSetup { +//CHECKSTYLE.OFF: MagicNumber + + private final DbMapperManagerImpl mapperManager; + private static final Logger LOG = Logger.getLogger( + DatabaseSetupImpl.class.getName()); + + public DatabaseSetupImpl(final DbMapperManagerImpl mm) { + this.mapperManager = mm; + } + + @Override + public void createTables() throws PersistenceException { + + try (Connection conn = mapperManager.getConnection()) { + try (Statement requete = conn.createStatement();) { + requete.addBatch(SQL.PERSONNES.CREATE_TABLE); + + requete.executeBatch(); + } + } catch (SQLException ex) { + LOG.log(Level.SEVERE, null, ex); + throw new PersistenceException(ex); + } + + } + + @Override + public void dropTables() throws PersistenceException { + try (Connection conn = mapperManager.getConnection()) { + try (Statement requete = conn.createStatement();) { + + requete.addBatch(SQL.PERSONNES.DROP_TABLE); + requete.executeBatch(); + } + } catch (SQLException ex) { + LOG.log(Level.SEVERE, null, ex); + throw new PersistenceException(ex); + } + + } + + @Override + public void insertData() throws PersistenceException { + DemoData data = new DemoData(); + data.initialisation(); + try (Connection conn + = this.mapperManager.getConnection()) { + conn.setAutoCommit(false); + + try (PreparedStatement rc + = conn.prepareStatement(SQL.PERSONNES.INSERT)) { + + for (Personne e : data.getPersonnes().values()) { + + rc.setString(1, e.getUUID()); + rc.setString(2, e.getNom()); + rc.setString(3, e.getPrenom()); + rc.addBatch(); + } + rc.executeBatch(); + } + + conn.commit(); + + } catch (SQLException ex) { + throw new PersistenceException(ex); + } + + } +//CHECKSTYLE.ON: MagicNumber + +} diff --git a/src/main/java/personne/datasource/db/DbMapperManagerImpl.java b/src/main/java/personne/datasource/db/DbMapperManagerImpl.java new file mode 100644 index 0000000..cabb974 --- /dev/null +++ b/src/main/java/personne/datasource/db/DbMapperManagerImpl.java @@ -0,0 +1,51 @@ +package personne.datasource.db; + +import java.sql.Connection; +import java.sql.SQLException; +import javax.sql.DataSource; +import personne.datasource.DatabaseSetup; +import personne.datasource.MapperManager; +import personne.datasource.PersistenceException; +import personne.datasource.PersonneMapper; + +/** + * + * @author dominique huguenin (dominique.huguenin AT rpn.ch) + */ +public class DbMapperManagerImpl implements MapperManager { + + private final DataSource datasource; + private DatabaseSetup databaseSetup; + private PersonneMapper personneMapper; + + public DbMapperManagerImpl(final DataSource datasource) { + this.datasource = datasource; + } + + Connection getConnection() throws PersistenceException { + try { + return this.datasource.getConnection(); + } catch (SQLException ex) { + throw new PersistenceException(ex); + } + } + + @Override + public PersonneMapper getPersonneMapper() { + if (this.personneMapper == null) { + this.personneMapper = new PersonneMapperImpl(this); + } + return this.personneMapper; + } + + + @Override + public DatabaseSetup getDatabaseSetup() { + if (this.databaseSetup == null) { + this.databaseSetup = new DatabaseSetupImpl(this); + } + return this.databaseSetup; + + } + +} diff --git a/src/main/java/personne/datasource/db/PersonneMapperImpl.java b/src/main/java/personne/datasource/db/PersonneMapperImpl.java new file mode 100644 index 0000000..b4648a0 --- /dev/null +++ b/src/main/java/personne/datasource/db/PersonneMapperImpl.java @@ -0,0 +1,246 @@ +package personne.datasource.db; + +import java.sql.Connection; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.sql.Types; +import java.util.ArrayList; +import java.util.List; +import java.util.UUID; +import personne.datasource.EntiteInconnuePersistenceException; +import personne.datasource.PersistenceException; +import personne.datasource.PersonneMapper; +import personne.domain.Personne; +import personne.domain.PersonneBase; + +/** + * + * @author dominique huguenin (dominique.huguenin AT rpn.ch) + */ +public class PersonneMapperImpl implements PersonneMapper { + + private final DbMapperManagerImpl mapperManager; + + public PersonneMapperImpl(DbMapperManagerImpl mm) { + this.mapperManager = mm; + } + + @Override + public Personne create(Personne entite) throws PersistenceException { + if (entite == null) { + return null; + } + Personne nouvelleEntite = null; + + String uuid = entite.getUUID(); + if (uuid == null) { + uuid = UUID.randomUUID().toString(); + } + + try (Connection conn + = this.mapperManager.getConnection()) { + conn.setAutoCommit(false); + + try (PreparedStatement ps + = conn.prepareStatement(SQL.PERSONNES.INSERT)) { + ps.setString(1, + uuid); + if (entite.getNom() != null) { + ps.setString(2, + entite.getNom()); + } else { + ps.setNull(2, + Types.VARCHAR); + } + + if (entite.getPrenom() != null) { + ps.setString(3, + entite.getPrenom()); + } else { + ps.setNull(3, + Types.VARCHAR); + } + + ps.executeUpdate(); + } + + nouvelleEntite = retrieveEntite(conn, uuid); + + conn.commit(); + } catch (SQLException ex) { + throw new PersistenceException(ex); + } + + return nouvelleEntite; + } + + @Override + public Personne retrieveByUUID(String uuid) throws PersistenceException { + if (uuid == null) { + return null; + } + Personne entite = null; + + try (Connection conn + = this.mapperManager.getConnection()) { + conn.setAutoCommit(false); + + entite = retrieveEntite(conn, uuid); + + conn.commit(); + } catch (SQLException ex) { + throw new PersistenceException(ex); + } + return entite; + } + + private Personne retrieveEntite(final Connection conn, String uuid) throws SQLException { + Personne entite = null; + try (PreparedStatement ps + = conn.prepareStatement(SQL.PERSONNES.SELECT_BY_UUID)) { + ps.setString(1, uuid); + ResultSet rs = ps.executeQuery(); + while (rs.next()) { + entite = readEntite(rs); + } + + } + return entite; + } + + @Override + public List retrieve(String filtre) throws PersistenceException { + List entites = new ArrayList<>(); + + if (filtre == null) { + return entites; + } + try (Connection conn + = this.mapperManager.getConnection()) { + + conn.setAutoCommit(false); + + try (PreparedStatement ps + = conn.prepareStatement(SQL.PERSONNES.SELECT_BY_FILTRE)) { + ps.setString(1, + filtre); + ResultSet rs = ps.executeQuery(); + while (rs.next()) { + Personne entite = readEntite(rs); + if (entite != null) { + entites.add(entite); + } + } + + } + + conn.commit(); + } catch (SQLException ex) { + throw new PersistenceException(ex); + } + return entites; + + } + + @Override + public void update(Personne entite) throws PersistenceException { + if (entite == null) { + return; + } + if (entite.getUUID() == null) { + return; + } + try (Connection conn + = this.mapperManager.getConnection()) { + + conn.setAutoCommit(false); + + Personne entiteTrouvee + = this.retrieveEntite(conn, + entite.getUUID()); + if (entiteTrouvee == null) { + throw new EntiteInconnuePersistenceException( + String.format("Erreur: l'entitée (%s) " + + "n'est pas connue!", + entite.toString())); + } + + try (PreparedStatement ps + = conn.prepareStatement( + SQL.PERSONNES.UPDATE)) { + if (entite.getNom() != null) { + ps.setString(1, + entite.getNom()); + } else { + ps.setNull(1, + Types.VARCHAR); + } + + if (entite.getPrenom() != null) { + ps.setString(2, + entite.getPrenom()); + } else { + ps.setNull(2, + Types.VARCHAR); + } + + ps.setString(3, + entite.getUUID()); + + ps.executeUpdate(); + } + + + conn.commit(); + + } catch (SQLException ex) { + throw new PersistenceException(ex); + } + + } + + @Override + public void delete(Personne entite) throws PersistenceException { + if (entite == null) { + return; + } + if (entite.getUUID() == null) { + return; + } + try (Connection conn = this.mapperManager.getConnection()) { + conn.setAutoCommit(false); + Personne entiteTrouvee + = this.retrieveEntite(conn, entite.getUUID()); + if (entiteTrouvee == null) { + throw new EntiteInconnuePersistenceException( + String.format("Erreur: l'entitée (%s) " + + "n'est pas connue!", entite.toString())); + } + try (PreparedStatement ps = conn.prepareStatement(SQL.PERSONNES.DELETE_BY_UUID)) { + ps.setString(1, entite.getUUID()); + ps.executeUpdate(); + } + conn.commit(); + } catch (SQLException ex) { + throw new PersistenceException(ex); + } + + } + + protected Personne readEntite(final ResultSet rs) + throws SQLException { + String uuid = rs.getString(SQL.PERSONNES.ATTRIBUTS.UUID); + String nom = rs.getString(SQL.PERSONNES.ATTRIBUTS.NOM); + String prenom = rs.getString(SQL.PERSONNES.ATTRIBUTS.PRENOM); + + Personne entite = PersonneBase.builder() + .uuid(uuid) + .nom(nom) + .prenom(prenom) + .build(); + + return entite; + } + +} diff --git a/src/main/java/personne/datasource/db/SQL.java b/src/main/java/personne/datasource/db/SQL.java new file mode 100644 index 0000000..99d0b57 --- /dev/null +++ b/src/main/java/personne/datasource/db/SQL.java @@ -0,0 +1,66 @@ +package personne.datasource.db; + +/** + * + * @author dominique huguenin (dominique.huguenin AT rpn.ch) + */ +public final class SQL { + + public static final class PERSONNES { + + public static final String CREATE_TABLE + = "CREATE TABLE IF NOT EXISTS personnes (\n" + + " uuid VARCHAR, -- aid\n" + + " nom TEXT NOT NULL,\n" + + " prenom TEXT NOT NULL,\n" + + "\n" + + " CONSTRAINT pk_personnes\n" + + " PRIMARY KEY (uuid)\n" + + ")"; + + public static final String DROP_TABLE + = "DROP TABLE IF EXISTS personnes CASCADE"; + + public static final String INSERT + = "INSERT INTO personnes (uuid, nom, prenom)\n" + + "VALUES (?,?,?)"; + + public static final String SELECTION + = "SELECT p.uuid,\n" + + " p.nom,\n" + + " p.prenom\n"; + + public static final String SELECT_BY_UUID + = SELECTION + + "FROM personnes p\n" + + "WHERE p.uuid = ?\n"; + + public static final String SELECT_BY_FILTRE + = SELECTION + + "FROM personnes p\n" + + "WHERE p.nom || ' ' || p. prenom ~* ?\n" + + "ORDER BY p.nom"; + + public static final String UPDATE + = "UPDATE personnes \n" + + "SET nom = ?,\n" + + " prenom = ?\n" + + "WHERE uuid = ?\n"; + + public static final String DELETE + = "DELETE FROM personnes\n"; + + public static final String DELETE_BY_UUID + = DELETE + + "WHERE uuid = ?\n"; + + public static final class ATTRIBUTS { + + public static final String UUID = "uuid"; + public static final String NOM = "nom"; + public static final String PRENOM = "prenom"; + + } + } + +} diff --git a/src/test/java/personne/datasource/db/DatabaseSetupImplTest.java b/src/test/java/personne/datasource/db/DatabaseSetupImplTest.java new file mode 100644 index 0000000..eb95ea2 --- /dev/null +++ b/src/test/java/personne/datasource/db/DatabaseSetupImplTest.java @@ -0,0 +1,55 @@ +package personne.datasource.db; + +import javax.sql.DataSource; +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import personne.datasource.DatabaseSetup; +import personne.datasource.MapperManager; +import personne.domain.DemoData; + +/** + * + * @author dominique huguenin (dominique.huguenin AT rpn.ch) + */ +public class DatabaseSetupImplTest { + + private final MapperManager mapperManager; + private final DemoData demoData; + + public DatabaseSetupImplTest() { + this.demoData = new DemoData(); + this.demoData.initialisation(); + + DataSource datasource = TestDataSourceFactory.getInstance(); + this.mapperManager = new DbMapperManagerImpl(datasource); + + } + + @Before + public void setUp() { + } + + @After + public void tearDown() { + } + + @Test + public void testDropCreateTables() throws Exception { + DatabaseSetup setup = mapperManager.getDatabaseSetup(); + setup.dropTables(); + setup.createTables(); + } + + /** + * + * @throws Exception + */ + @Test + public void testInsertData() throws Exception { + DatabaseSetup setup = mapperManager.getDatabaseSetup(); + setup.dropTables(); + setup.createTables(); + setup.insertData(); + } +} diff --git a/src/test/java/personne/datasource/db/PersonneMapperImplTest.java b/src/test/java/personne/datasource/db/PersonneMapperImplTest.java new file mode 100644 index 0000000..10d7f2d --- /dev/null +++ b/src/test/java/personne/datasource/db/PersonneMapperImplTest.java @@ -0,0 +1,168 @@ +package personne.datasource.db; + +import java.time.Instant; +import java.util.List; +import java.util.UUID; +import java.util.regex.Pattern; +import javax.sql.DataSource; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import personne.datasource.DatabaseSetup; +import personne.datasource.EntiteInconnuePersistenceException; +import personne.datasource.MapperManager; +import personne.datasource.PersistenceException; +import personne.domain.DemoData; +import personne.domain.Personne; +import personne.domain.PersonneBase; + +/** + * + * @author dominique huguenin (dominique.huguenin AT rpn.ch) + */ +public class PersonneMapperImplTest { + + protected MapperManager mm; + protected DemoData demoData; + protected String uuidDrefrere; + protected Personne personneDefrere; + protected Personne nouvellePersonneRef; + + public PersonneMapperImplTest() throws PersistenceException { + demoData = new DemoData(); + demoData.initialisation(); + + DataSource datasource = TestDataSourceFactory.getInstance(); + mm = new DbMapperManagerImpl(datasource); + + DatabaseSetup setup = mm.getDatabaseSetup(); + setup.dropTables(); + setup.createTables(); + setup.insertData(); + + } + + @Before + public void setUp() { + uuidDrefrere = DemoData.PERNONNE_DEFRERE_UUID; + personneDefrere = PersonneBase.builder() + .uuid(uuidDrefrere) + .nom(DemoData.PERNONNE_DEFRERE_NOM) + .prenom(DemoData.PERSONNE_DEFRERE_PRENOM) + .build(); + nouvellePersonneRef = PersonneBase.builder() + .nom("nouveau nom " + Instant.now().toString()) + .prenom("nouveau prenom " + Instant.now().toString()) + .build(); + } + + @Test + public void testRetrieve_Identifiant() throws Exception { + Personne entite = mm.getPersonneMapper().retrieveByUUID(uuidDrefrere); + Assert.assertNotNull(entite); + Assert.assertEquals(personneDefrere, entite); + Assert.assertEquals(personneDefrere.getNom(), entite.getNom()); + Assert.assertEquals(personneDefrere.getPrenom(), entite.getPrenom()); + } + + @Test + public void testRetrieve_IdentifiantNull() throws Exception { + String uuid = null; + Personne entite = mm.getPersonneMapper().retrieveByUUID(uuid); + Assert.assertNull(entite); + } + + @Test + public void testRetrieve_String() throws Exception { + String regex = "^.*(DEF).*$"; + Pattern pattern = Pattern.compile(regex); + List entites1 = mm.getPersonneMapper().retrieve(regex); + Assert.assertEquals(5, entites1.size()); + for (Personne i : entites1) { + Assert.assertTrue( + pattern.matcher( + String.format("%s %s", i.getNom(), i.getPrenom()) + ).find()); + } + } + + @Test + public void testRetrieve_StringNull() throws Exception { + String regex = null; + List entites1 = mm.getPersonneMapper().retrieve(regex); + Assert.assertEquals(0, entites1.size()); + } + + + @Test + public void testCreate() throws Exception { + Personne nouvelleEntite = mm.getPersonneMapper().create(nouvellePersonneRef); + Assert.assertNotNull(nouvelleEntite.getUUID()); + Assert.assertEquals(nouvellePersonneRef.getNom(), nouvelleEntite.getNom()); + Assert.assertEquals(nouvellePersonneRef.getPrenom(), nouvelleEntite.getPrenom()); + Personne entite = mm.getPersonneMapper().retrieveByUUID(nouvelleEntite.getUUID()); + Assert.assertNotNull(entite); + Assert.assertEquals(nouvelleEntite, entite); + Assert.assertNotSame(nouvelleEntite, entite); + Assert.assertEquals(nouvelleEntite.getNom(), entite.getNom()); + Assert.assertEquals(nouvelleEntite.getNom(), entite.getNom()); + } + + + @Test + public void testUpdate() throws Exception { + Personne nouvelleEntite = mm.getPersonneMapper().create(nouvellePersonneRef); + Personne entite = mm.getPersonneMapper().retrieveByUUID(nouvelleEntite.getUUID()); + Assert.assertNotNull(nouvelleEntite.getUUID()); + Assert.assertEquals(nouvellePersonneRef.getNom(), nouvelleEntite.getNom()); + Assert.assertEquals(nouvellePersonneRef.getPrenom(), nouvelleEntite.getPrenom()); + Personne entiteMod = PersonneBase.builder() + .personne(entite) + .build(); + entiteMod.setNom(entite.getNom() + " update"); + entiteMod.setPrenom(entite.getPrenom() + " update"); + mm.getPersonneMapper().update(entiteMod); + + Personne entiteModifie = mm.getPersonneMapper().retrieveByUUID(nouvelleEntite.getUUID()); + Assert.assertEquals(entiteMod, entiteModifie); + Assert.assertEquals(entiteMod.getNom(), entiteModifie.getNom()); + Assert.assertEquals(entiteMod.getPrenom(), entiteModifie.getPrenom()); + } + + /** + * + * @throws Exception + */ + @Test(expected = EntiteInconnuePersistenceException.class) + public void testUpdateEntiteInconnu() throws Exception { + Personne entiteMod = PersonneBase.builder() + .personne(this.nouvellePersonneRef) + .uuid(UUID.randomUUID().toString()) + .build(); + mm.getPersonneMapper().update(entiteMod); + } + + + @Test + public void testDelete() throws Exception { + Personne nouvelleEntite = mm.getPersonneMapper().create(nouvellePersonneRef); + Personne entite = mm.getPersonneMapper() + .retrieveByUUID(nouvelleEntite.getUUID()); + Assert.assertNotNull(entite); + mm.getPersonneMapper().delete(entite); + Personne entiteNull = mm.getPersonneMapper() + .retrieveByUUID(nouvelleEntite.getUUID()); + Assert.assertNull(entiteNull); + } + + + @Test(expected = EntiteInconnuePersistenceException.class) + public void testDeleteEntiteInconnu() throws Exception { + Personne entite = PersonneBase.builder() + .personne(this.nouvellePersonneRef) + .uuid(UUID.randomUUID().toString()) + .build(); + mm.getPersonneMapper().delete(entite); + } + +} diff --git a/src/test/java/personne/datasource/db/TestDataSourceFactory.java b/src/test/java/personne/datasource/db/TestDataSourceFactory.java new file mode 100644 index 0000000..b4f9f50 --- /dev/null +++ b/src/test/java/personne/datasource/db/TestDataSourceFactory.java @@ -0,0 +1,22 @@ +package personne.datasource.db; + +import javax.sql.DataSource; + +/** + * + * @author dominique huguenin + */ +public class TestDataSourceFactory { + + /** + * + * @return + */ + public static DataSource getInstance() { + return DataSourceFactory.getPostgreSQLDataSource( + "postgres", 5432, + "personneTestDB", + "personne", "personnepass"); + } + +} -- GitLab From 04ab2ec74a1197a4c7fd4a87fc255fc01a345d8b Mon Sep 17 00:00:00 2001 From: huguenindo Date: Sat, 19 Nov 2022 14:24:34 +0100 Subject: [PATCH 4/5] feat: configuration de la DB and la CI --- .gitlab-ci.yml | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index 4dccc35..434d57c 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -2,3 +2,27 @@ include: - project: 'dhu.projets/ci-include' ref: v1.0.3 file: 'ci-verify-deploy-release.yml' + +default: + before_script: + - | + sudo -u postgres psql << EOF + CREATE ROLE ${TEST_DB_USER} WITH login PASSWORD $(echo "'"${TEST_DB_PASSWORD}"'"); + CREATE DATABASE "${TEST_DB_NAME}" OWNER ${TEST_DB_USER}; + \l + EOF + + - sudo echo "127.0.1.2 ${TEST_DB_HOST}" >> /etc/hosts + - cat /etc/hosts + + - | + PGPASSWORD="${TEST_DB_PASSWORD}" psql -h ${TEST_DB_HOST} -p ${TEST_DB_PORT} -U "${TEST_DB_USER}" "${TEST_DB_NAME}" << EOF + \d + EOF + + - | + export DATABASE_HOST=${TEST_DB_HOST} + export DATABASE_PORT=${TEST_DB_PORT} + export DATABASE_NAME=${TEST_DB_NAME} + export DATABASE_USER=${TEST_DB_USER} + export DATABASE_PASSWORD=${TEST_DB_PASSWORD} \ No newline at end of file -- GitLab From 77e98c48f11f16a99b63b205e328803860321ed1 Mon Sep 17 00:00:00 2001 From: huguenindo Date: Sat, 19 Nov 2022 14:29:58 +0100 Subject: [PATCH 5/5] fix: convention de codage --- .../personne/datasource/PersonneMapper.java | 6 +- .../datasource/db/PersonneMapperImpl.java | 59 ++++++++++--------- src/main/java/personne/datasource/db/SQL.java | 2 +- 3 files changed, 34 insertions(+), 33 deletions(-) diff --git a/src/main/java/personne/datasource/PersonneMapper.java b/src/main/java/personne/datasource/PersonneMapper.java index eea43fc..f2d256c 100644 --- a/src/main/java/personne/datasource/PersonneMapper.java +++ b/src/main/java/personne/datasource/PersonneMapper.java @@ -4,8 +4,8 @@ import personne.domain.Personne; /** * - * @author dom + * @author dominique huguenin (dominique.huguenin AT rpn.ch) */ -public interface PersonneMapper extends Mapper{ - +public interface PersonneMapper extends Mapper { + } diff --git a/src/main/java/personne/datasource/db/PersonneMapperImpl.java b/src/main/java/personne/datasource/db/PersonneMapperImpl.java index b4648a0..d6aa068 100644 --- a/src/main/java/personne/datasource/db/PersonneMapperImpl.java +++ b/src/main/java/personne/datasource/db/PersonneMapperImpl.java @@ -19,15 +19,16 @@ import personne.domain.PersonneBase; * @author dominique huguenin (dominique.huguenin AT rpn.ch) */ public class PersonneMapperImpl implements PersonneMapper { +//CHECKSTYLE.OFF: MagicNumber private final DbMapperManagerImpl mapperManager; - public PersonneMapperImpl(DbMapperManagerImpl mm) { + public PersonneMapperImpl(final DbMapperManagerImpl mm) { this.mapperManager = mm; } @Override - public Personne create(Personne entite) throws PersistenceException { + public Personne create(final Personne entite) throws PersistenceException { if (entite == null) { return null; } @@ -76,7 +77,7 @@ public class PersonneMapperImpl implements PersonneMapper { } @Override - public Personne retrieveByUUID(String uuid) throws PersistenceException { + public Personne retrieveByUUID(final String uuid) throws PersistenceException { if (uuid == null) { return null; } @@ -95,7 +96,7 @@ public class PersonneMapperImpl implements PersonneMapper { return entite; } - private Personne retrieveEntite(final Connection conn, String uuid) throws SQLException { + private Personne retrieveEntite(final Connection conn, final String uuid) throws SQLException { Personne entite = null; try (PreparedStatement ps = conn.prepareStatement(SQL.PERSONNES.SELECT_BY_UUID)) { @@ -110,7 +111,7 @@ public class PersonneMapperImpl implements PersonneMapper { } @Override - public List retrieve(String filtre) throws PersistenceException { + public List retrieve(final String filtre) throws PersistenceException { List entites = new ArrayList<>(); if (filtre == null) { @@ -144,7 +145,7 @@ public class PersonneMapperImpl implements PersonneMapper { } @Override - public void update(Personne entite) throws PersistenceException { + public void update(final Personne entite) throws PersistenceException { if (entite == null) { return; } @@ -166,31 +167,30 @@ public class PersonneMapperImpl implements PersonneMapper { entite.toString())); } - try (PreparedStatement ps - = conn.prepareStatement( - SQL.PERSONNES.UPDATE)) { - if (entite.getNom() != null) { - ps.setString(1, - entite.getNom()); - } else { - ps.setNull(1, - Types.VARCHAR); - } + try (PreparedStatement ps + = conn.prepareStatement( + SQL.PERSONNES.UPDATE)) { + if (entite.getNom() != null) { + ps.setString(1, + entite.getNom()); + } else { + ps.setNull(1, + Types.VARCHAR); + } - if (entite.getPrenom() != null) { - ps.setString(2, - entite.getPrenom()); - } else { - ps.setNull(2, - Types.VARCHAR); - } - - ps.setString(3, - entite.getUUID()); + if (entite.getPrenom() != null) { + ps.setString(2, + entite.getPrenom()); + } else { + ps.setNull(2, + Types.VARCHAR); + } - ps.executeUpdate(); - } + ps.setString(3, + entite.getUUID()); + ps.executeUpdate(); + } conn.commit(); @@ -201,7 +201,7 @@ public class PersonneMapperImpl implements PersonneMapper { } @Override - public void delete(Personne entite) throws PersistenceException { + public void delete(final Personne entite) throws PersistenceException { if (entite == null) { return; } @@ -242,5 +242,6 @@ public class PersonneMapperImpl implements PersonneMapper { return entite; } +//CHECKSTYLE.ON: MagicNumber } diff --git a/src/main/java/personne/datasource/db/SQL.java b/src/main/java/personne/datasource/db/SQL.java index 99d0b57..9ab3deb 100644 --- a/src/main/java/personne/datasource/db/SQL.java +++ b/src/main/java/personne/datasource/db/SQL.java @@ -62,5 +62,5 @@ public final class SQL { } } - + } -- GitLab