diff --git a/ass1-doc/pom.xml b/ass1-doc/pom.xml new file mode 100644 index 0000000..3edacf9 --- /dev/null +++ b/ass1-doc/pom.xml @@ -0,0 +1,36 @@ + + + + 4.0.0 + + + at.ac.tuwien.infosys.dst + dst + 2021.1 + .. + + + ass1-doc + + jar + + DST :: Assignment 1 :: Document DB + + + + at.ac.tuwien.infosys.dst + ass1-jpa + ${project.version} + + + + org.mongodb + mongodb-driver + + + de.flapdoodle.embed + de.flapdoodle.embed.mongo + + + diff --git a/ass1-doc/src/main/java/dst/ass1/doc/IDocumentQuery.java b/ass1-doc/src/main/java/dst/ass1/doc/IDocumentQuery.java new file mode 100644 index 0000000..c0bf921 --- /dev/null +++ b/ass1-doc/src/main/java/dst/ass1/doc/IDocumentQuery.java @@ -0,0 +1,15 @@ +package dst.ass1.doc; + +import org.bson.Document; + +import java.util.List; + +public interface IDocumentQuery { + + Document findLocationById(Long locationId); + + List findIdsByNameAndRadius(String name, double longitude, double latitude, double radius); + + List getDocumentStatistics(); + +} diff --git a/ass1-doc/src/main/java/dst/ass1/doc/IDocumentRepository.java b/ass1-doc/src/main/java/dst/ass1/doc/IDocumentRepository.java new file mode 100644 index 0000000..c2a8679 --- /dev/null +++ b/ass1-doc/src/main/java/dst/ass1/doc/IDocumentRepository.java @@ -0,0 +1,11 @@ +package dst.ass1.doc; + +import dst.ass1.jpa.model.ILocation; + +import java.util.Map; + +public interface IDocumentRepository { + + void insert(ILocation location, Map locationProperties); + +} diff --git a/ass1-doc/src/main/java/dst/ass1/doc/IDocumentServiceFactory.java b/ass1-doc/src/main/java/dst/ass1/doc/IDocumentServiceFactory.java new file mode 100644 index 0000000..1ab0da1 --- /dev/null +++ b/ass1-doc/src/main/java/dst/ass1/doc/IDocumentServiceFactory.java @@ -0,0 +1,11 @@ +package dst.ass1.doc; + +import com.mongodb.client.MongoDatabase; + +public interface IDocumentServiceFactory { + + IDocumentQuery createDocumentQuery(MongoDatabase db); + + IDocumentRepository createDocumentRepository(); + +} diff --git a/ass1-doc/src/main/java/dst/ass1/doc/impl/DocumentServiceFactory.java b/ass1-doc/src/main/java/dst/ass1/doc/impl/DocumentServiceFactory.java new file mode 100644 index 0000000..823f48e --- /dev/null +++ b/ass1-doc/src/main/java/dst/ass1/doc/impl/DocumentServiceFactory.java @@ -0,0 +1,21 @@ +package dst.ass1.doc.impl; + +import com.mongodb.client.MongoDatabase; +import dst.ass1.doc.IDocumentQuery; +import dst.ass1.doc.IDocumentRepository; +import dst.ass1.doc.IDocumentServiceFactory; + +public class DocumentServiceFactory implements IDocumentServiceFactory { + + @Override + public IDocumentQuery createDocumentQuery(MongoDatabase db) { + // TODO + return null; + } + + @Override + public IDocumentRepository createDocumentRepository() { + // TODO + return null; + } +} diff --git a/ass1-doc/src/test/java/dst/ass1/doc/DocumentTestData.java b/ass1-doc/src/test/java/dst/ass1/doc/DocumentTestData.java new file mode 100644 index 0000000..dd72ab4 --- /dev/null +++ b/ass1-doc/src/test/java/dst/ass1/doc/DocumentTestData.java @@ -0,0 +1,45 @@ +package dst.ass1.doc; + +import com.mongodb.client.MongoDatabase; +import dst.ass1.jpa.util.Constants; +import org.bson.Document; + +import java.io.IOException; +import java.net.URL; +import java.util.List; +import java.util.Objects; +import java.util.Scanner; + +public class DocumentTestData implements IDocumentTestData { + + private String documentResource; + + public DocumentTestData() { + this("documents.json"); + } + + public DocumentTestData(String documentResource) { + this.documentResource = documentResource; + } + + @SuppressWarnings("unchecked") + @Override + public void insertTestData(MongoDatabase db) throws IOException { + URL resource = Objects.requireNonNull(getDocumentsResource()); + + String testDataJson = readFully(resource); + List documents = Document.parse(testDataJson).get("documents", List.class); + db.getCollection(Constants.COLL_LOCATION_DATA).insertMany(documents); + } + + private URL getDocumentsResource() { + return getClass().getClassLoader().getResource(documentResource); + } + + private String readFully(URL resource) throws IOException { + try (Scanner scanner = new Scanner(resource.openStream())) { + return scanner.useDelimiter("\\Z").next(); + } + } + +} diff --git a/ass1-doc/src/test/java/dst/ass1/doc/EmbeddedMongo.java b/ass1-doc/src/test/java/dst/ass1/doc/EmbeddedMongo.java new file mode 100644 index 0000000..9d01b63 --- /dev/null +++ b/ass1-doc/src/test/java/dst/ass1/doc/EmbeddedMongo.java @@ -0,0 +1,56 @@ +package dst.ass1.doc; + +import de.flapdoodle.embed.mongo.config.MongodConfig; +import de.flapdoodle.embed.mongo.config.Net; +import de.flapdoodle.embed.mongo.distribution.IFeatureAwareVersion; +import de.flapdoodle.embed.mongo.distribution.Version; +import de.flapdoodle.embed.mongo.tests.MongodForTestsFactory; +import org.junit.rules.ExternalResource; + +import java.io.IOException; +import java.net.BindException; +import java.net.ServerSocket; + +/** + * JUnit rule that creates an in-memory instance of MongoDB using the flapdoodle Embedded MongoDB. + */ +public class EmbeddedMongo extends ExternalResource { + + private MongodForTestsFactory mongod; + + @Override + protected void before() throws Throwable { + requirePort(); + mongod = new MongodFactory(); // starts process in constructor + } + + @Override + protected void after() { + if (mongod != null) { + mongod.shutdown(); + } + } + + private void requirePort() throws IOException, IllegalStateException { + try (ServerSocket ignore = new ServerSocket(27017)) { + // ignore + } catch (BindException e) { + throw new IllegalStateException("Could not bind port 27017 which is necessary to run the MongoDB tests", e); + } + } + + public static class MongodFactory extends MongodForTestsFactory { + + public MongodFactory() throws IOException { + super(Version.Main.V3_5); + } + + @Override + protected MongodConfig newMongodConfig(IFeatureAwareVersion version) throws IOException { + return MongodConfig.builder() + .net(new Net(27017, false)) + .version(version) + .build(); + } + } +} diff --git a/ass1-doc/src/test/java/dst/ass1/doc/IDocumentTestData.java b/ass1-doc/src/test/java/dst/ass1/doc/IDocumentTestData.java new file mode 100644 index 0000000..f2a57a3 --- /dev/null +++ b/ass1-doc/src/test/java/dst/ass1/doc/IDocumentTestData.java @@ -0,0 +1,18 @@ +package dst.ass1.doc; + +import com.mongodb.client.MongoDatabase; + +// DO NOT MODIFY THIS CLASS. + +/** + * The IDocumentTestData interface works like the ITestData as introduced in ass1-jpa only for the {@link MongoService}. + */ +public interface IDocumentTestData { + /** + * Inserts the data into the given MongoDatabase instance. + * + * @param db the mongo database instance + * @throws Exception if the insertion failed for some reason + */ + void insertTestData(MongoDatabase db) throws Exception; +} diff --git a/ass1-doc/src/test/java/dst/ass1/doc/MockLocation.java b/ass1-doc/src/test/java/dst/ass1/doc/MockLocation.java new file mode 100644 index 0000000..4e2c79a --- /dev/null +++ b/ass1-doc/src/test/java/dst/ass1/doc/MockLocation.java @@ -0,0 +1,41 @@ +package dst.ass1.doc; + +import dst.ass1.jpa.model.ILocation; + +public class MockLocation implements ILocation { + + private Long id; + private String name; + private Long LocationId; + + + @Override + public Long getId() { + return id; + } + + @Override + public void setId(Long id) { + this.id = id; + } + + @Override + public String getName() { + return name; + } + + @Override + public void setName(String name) { + this.name = name; + } + + @Override + public Long getLocationId() { + return LocationId; + } + + @Override + public void setLocationId(Long locationId) { + LocationId = locationId; + } +} diff --git a/ass1-doc/src/test/java/dst/ass1/doc/MongoService.java b/ass1-doc/src/test/java/dst/ass1/doc/MongoService.java new file mode 100644 index 0000000..c242133 --- /dev/null +++ b/ass1-doc/src/test/java/dst/ass1/doc/MongoService.java @@ -0,0 +1,124 @@ +package dst.ass1.doc; + +import com.mongodb.MongoClient; +import com.mongodb.client.MongoCollection; +import com.mongodb.client.MongoDatabase; +import dst.ass1.doc.impl.DocumentServiceFactory; +import dst.ass1.jpa.util.Constants; +import org.bson.Document; +import org.junit.rules.ExternalResource; + +import java.util.Map; +import java.util.function.Function; +import java.util.stream.Collectors; +import java.util.stream.Stream; +import java.util.stream.StreamSupport; + +// DO NOT MODIFY THIS CLASS. + +/** + * The MongoService class is used as a JUnit rule, that fulfills the same tasks as the ORMService in ass1-jpa, and works + * very similarly. + */ +public class MongoService extends ExternalResource { + + private IDocumentTestData testData; + private boolean insertTestData; + private boolean clearTestData; + + private MongoClient mongoClient; + private MongoDatabase mongoDatabase; + + private IDocumentServiceFactory documentServiceFactory; + private IDocumentRepository documentRepository; + private IDocumentQuery documentQuery; + + public MongoService() { + this(null, false, true); + } + + public MongoService(IDocumentTestData testData) { + this(testData, true, true); + } + + public MongoService(IDocumentTestData testData, boolean insertTestData, boolean clearTestData) { + this.testData = testData; + this.insertTestData = insertTestData; + this.clearTestData = clearTestData; + } + + public static Stream stream(MongoCollection collection) { + return StreamSupport.stream(collection.find().spliterator(), false); + } + + public static Map idMap(MongoCollection collection, Function idFunction) { + return stream(collection).collect(Collectors.toMap(idFunction, Function.identity())); + } + + public MongoClient getMongoClient() { + return mongoClient; + } + + public MongoDatabase getMongoDatabase() { + return mongoDatabase; + } + + public IDocumentServiceFactory getDocumentServiceFactory() { + return documentServiceFactory; + } + + public IDocumentRepository getDocumentRepository() { + return documentRepository; + } + + public IDocumentQuery getDocumentQuery() { + return documentQuery; + } + + @Override + protected void before() throws Throwable { + setUpMongo(); + + if (insertTestData && testData != null) { + insertData(testData); + } + } + + @Override + protected void after() { + try { + if (clearTestData) { + clearData(); + } + } finally { + tearDownMongo(); + } + } + + private void setUpMongo() { + mongoClient = new MongoClient("127.0.0.1"); + mongoDatabase = mongoClient.getDatabase(Constants.MONGO_DB_NAME); + + documentServiceFactory = new DocumentServiceFactory(); + documentRepository = documentServiceFactory.createDocumentRepository(); + + if (documentRepository == null) { + throw new IllegalStateException("DocumentRepository returned from factory is null"); + } + + documentQuery = documentServiceFactory.createDocumentQuery(mongoDatabase); + } + + private void tearDownMongo() { + mongoClient.close(); + } + + private void insertData(IDocumentTestData testData) throws Exception { + testData.insertTestData(getMongoDatabase()); + } + + private void clearData() { + getMongoDatabase().drop(); + } + +} diff --git a/ass1-doc/src/test/java/dst/ass1/doc/tests/Ass1_4_1Test.java b/ass1-doc/src/test/java/dst/ass1/doc/tests/Ass1_4_1Test.java new file mode 100644 index 0000000..06c16e2 --- /dev/null +++ b/ass1-doc/src/test/java/dst/ass1/doc/tests/Ass1_4_1Test.java @@ -0,0 +1,128 @@ +package dst.ass1.doc.tests; + +import com.mongodb.client.MongoCollection; +import com.mongodb.client.MongoDatabase; +import dst.ass1.doc.EmbeddedMongo; +import dst.ass1.doc.IDocumentRepository; +import dst.ass1.doc.MockLocation; +import dst.ass1.doc.MongoService; +import dst.ass1.jpa.util.Constants; +import org.bson.Document; +import org.junit.Before; +import org.junit.ClassRule; +import org.junit.Rule; +import org.junit.Test; + +import java.util.Arrays; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import static org.hamcrest.CoreMatchers.hasItems; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.Assert.*; + +public class Ass1_4_1Test { + + public static final String LOCATION_NAME_1 = "testName1"; + public static final String LOCATION_NAME_2 = "testName2"; + public static final Long LOCATION_ID_1 = 1L; + public static final Long LOCATION_ID_2 = 2L; + public static final Double GEO_1_1 = 16.3699; + public static final Double GEO_1_2 = 48.199; + public static final Double GEO_2_1 = 16.368528; + public static final Double GEO_2_2 = 48.200939; + @ClassRule + public static EmbeddedMongo embeddedMongo = new EmbeddedMongo(); + @Rule + public MongoService mongo = new MongoService(); + private MockLocation l1; + private MockLocation l2; + private Map l1Properties; + private Map l2Properties; + private Map geo1; + private Map geo2; + + @Before + public void setUp() { + l1 = new MockLocation(); + l1.setName(LOCATION_NAME_1); + l1.setLocationId(LOCATION_ID_1); + + l2 = new MockLocation(); + l2.setName(LOCATION_NAME_2); + l2.setLocationId(LOCATION_ID_2); + + + l1Properties = new HashMap<>(); + + geo1 = new HashMap<>(); + geo1.put("type", "Point"); + geo1.put("coordinates", Arrays.asList(GEO_1_1, GEO_1_2)); + l1Properties.put("type", "place"); + l1Properties.put("geo", geo1); + l1Properties.put("1337", "7331"); + l1Properties.put("Foo", "Bar"); + l1Properties.put("Complex", Arrays.asList(1, 2, 3, 5, 8)); + + l2Properties = new HashMap<>(); + + geo2 = new HashMap<>(); + geo2.put("type", "Point"); + geo2.put("coordinates", Arrays.asList(GEO_2_1, GEO_2_2)); + l2Properties.put("type", "place"); + l2Properties.put("geo", geo2); + l2Properties.put("123456", "654321"); + l2Properties.put("F00", "B@r"); + l2Properties.put("Complex2", Arrays.asList(4, 6, 7, 9)); + } + + @Test + public void insert_insertsDocumentsCorrectly() throws Exception { + IDocumentRepository documentRepository = mongo.getDocumentRepository(); + MongoDatabase mongoDatabase = mongo.getMongoDatabase(); + + documentRepository.insert(l1, l1Properties); + documentRepository.insert(l2, l2Properties); + + MongoCollection collection = mongoDatabase.getCollection(Constants.COLL_LOCATION_DATA); + Map map = MongoService.idMap(collection, d -> d.getLong(Constants.I_LOCATION)); + + assertNotNull(map); + assertEquals(2, map.size()); + + Document document1 = map.get(1L); + assertEquals(LOCATION_ID_1, document1.get(Constants.I_LOCATION)); + assertEquals(LOCATION_NAME_1, document1.get(Constants.M_LOCATION_NAME)); + + assertEquals("7331", document1.get("1337")); + assertEquals("Bar", document1.get("Foo")); + assertEquals(Arrays.asList(1, 2, 3, 5, 8), document1.get("Complex")); + + assertEquals("place", document1.get("type")); + + Map geo1Retrieved = document1.get("geo", new HashMap<>()); + assertEquals(2, geo1Retrieved.size()); + assertEquals("Point", geo1Retrieved.get("type")); + List coordinates1 = (List) geo1Retrieved.get("coordinates"); + assertEquals(2, coordinates1.size()); + assertThat(coordinates1, hasItems(GEO_1_1, GEO_1_2)); + + Document document2 = map.get(2L); + assertEquals(LOCATION_ID_2, document2.get(Constants.I_LOCATION)); + assertEquals(LOCATION_NAME_2, document2.get(Constants.M_LOCATION_NAME)); + + assertEquals("654321", document2.get("123456")); + assertEquals("B@r", document2.get("F00")); + assertEquals(Arrays.asList(4, 6, 7, 9), document2.get("Complex2")); + + assertEquals("place", document2.get("type")); + + Map geo2Retrieved = document2.get("geo", new HashMap<>()); + assertEquals(2, geo2Retrieved.size()); + assertEquals("Point", geo2Retrieved.get("type")); + List coordinates2 = (List) geo2Retrieved.get("coordinates"); + assertEquals(2, coordinates2.size()); + assertThat(coordinates2, hasItems(GEO_2_1, GEO_2_2)); + } +} diff --git a/ass1-doc/src/test/java/dst/ass1/doc/tests/Ass1_4_2aTest.java b/ass1-doc/src/test/java/dst/ass1/doc/tests/Ass1_4_2aTest.java new file mode 100644 index 0000000..e9a60c9 --- /dev/null +++ b/ass1-doc/src/test/java/dst/ass1/doc/tests/Ass1_4_2aTest.java @@ -0,0 +1,53 @@ +package dst.ass1.doc.tests; + +import dst.ass1.doc.DocumentTestData; +import dst.ass1.doc.EmbeddedMongo; +import dst.ass1.doc.IDocumentQuery; +import dst.ass1.doc.MongoService; +import dst.ass1.jpa.util.Constants; +import org.bson.Document; +import org.junit.ClassRule; +import org.junit.Rule; +import org.junit.Test; + +import java.util.List; + +import static org.junit.Assert.*; + +public class Ass1_4_2aTest { + + @ClassRule + public static EmbeddedMongo embeddedMongo = new EmbeddedMongo(); + + @Rule + public MongoService mongo = new MongoService(new DocumentTestData()); + + @SuppressWarnings("unchecked") + @Test + public void findByLocationId_returnsCorrectDocument() { + IDocumentQuery documentQuery = mongo.getDocumentQuery(); + + Document location = documentQuery.findLocationById(2L); + assertNotNull(location); + assertEquals(2L, (long) location.getLong(Constants.I_LOCATION)); + assertEquals("McDonald's", location.getString(Constants.M_LOCATION_NAME)); + assertEquals("place", location.getString("type")); + assertEquals("Restaurant", location.getString("category")); + + Document geo = location.get("geo", Document.class); + assertNotNull(geo); + List coordinates = geo.getList("coordinates", Double.class); + assertNotNull(coordinates); + assertEquals(2, coordinates.size()); + assertEquals("Point", geo.getString("type")); + assertEquals(16.368528, coordinates.get(0), 0.0); + assertEquals(48.200939, coordinates.get(1), 0.0); + } + + @Test + public void findByLocationId_withInvalidId_returnsNull() throws Exception { + Document material = mongo.getDocumentQuery().findLocationById(1337L); + assertNull(material); + } + +} diff --git a/ass1-doc/src/test/java/dst/ass1/doc/tests/Ass1_4_2bTest.java b/ass1-doc/src/test/java/dst/ass1/doc/tests/Ass1_4_2bTest.java new file mode 100644 index 0000000..85a683f --- /dev/null +++ b/ass1-doc/src/test/java/dst/ass1/doc/tests/Ass1_4_2bTest.java @@ -0,0 +1,43 @@ +package dst.ass1.doc.tests; + +import dst.ass1.doc.DocumentTestData; +import dst.ass1.doc.EmbeddedMongo; +import dst.ass1.doc.MongoService; +import org.junit.ClassRule; +import org.junit.Rule; +import org.junit.Test; + +import java.util.List; + +import static org.hamcrest.Matchers.hasItems; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.Assert.*; + +public class Ass1_4_2bTest { + + @ClassRule + public static EmbeddedMongo embeddedMongo = new EmbeddedMongo(); + + @Rule + public MongoService mongo = new MongoService(new DocumentTestData()); + + @Test + public void findIdsByNameAndRadius_returnsCorrectLocationIds() throws Exception { + List locationIds = mongo.getDocumentQuery().findIdsByNameAndRadius("McD", 16.367873, 48.198763, 1000); + assertFalse(locationIds.isEmpty()); + assertThat(locationIds, hasItems(2L, 3L, 4L)); + } + + @Test + public void findIdsByType_withNonExistingType_returnsNoLocationIds() throws Exception { + List locationIds = mongo.getDocumentQuery().findIdsByNameAndRadius("McD", 16.367873, 48.198763, 5); + assertNotNull(locationIds); + assertTrue(locationIds.isEmpty()); + + locationIds = mongo.getDocumentQuery().findIdsByNameAndRadius("NONEXISTING", 16.367873, 48.198763, 2000); + + assertNotNull(locationIds); + assertTrue(locationIds.isEmpty()); + } + +} diff --git a/ass1-doc/src/test/java/dst/ass1/doc/tests/Ass1_4_3_01Test.java b/ass1-doc/src/test/java/dst/ass1/doc/tests/Ass1_4_3_01Test.java new file mode 100644 index 0000000..1809ffe --- /dev/null +++ b/ass1-doc/src/test/java/dst/ass1/doc/tests/Ass1_4_3_01Test.java @@ -0,0 +1,39 @@ +package dst.ass1.doc.tests; + +import dst.ass1.doc.EmbeddedMongo; +import dst.ass1.doc.MongoService; +import dst.ass1.jpa.util.Constants; +import org.bson.Document; +import org.junit.ClassRule; +import org.junit.Rule; +import org.junit.Test; + +import java.util.List; +import java.util.stream.StreamSupport; + +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; + +public class Ass1_4_3_01Test { + + @ClassRule + public static EmbeddedMongo embeddedMongo = new EmbeddedMongo(); + + @Rule + public MongoService mongo = new MongoService(db -> { + boolean exists = StreamSupport.stream(db.listCollectionNames().spliterator(), false) + .anyMatch(Constants.COLL_LOCATION_DATA::equalsIgnoreCase); + + if (!exists) { + db.createCollection(Constants.COLL_LOCATION_DATA); // make sure the empty collection exists + } + }); + + @Test + public void getDocumentStatistics_withEmptyData_returnsEmptyStatistics() throws Exception { + List documentStatistics = mongo.getDocumentQuery().getDocumentStatistics(); + assertNotNull(documentStatistics); + assertTrue(documentStatistics.isEmpty()); + } + +} diff --git a/ass1-doc/src/test/java/dst/ass1/doc/tests/Ass1_4_3_02Test.java b/ass1-doc/src/test/java/dst/ass1/doc/tests/Ass1_4_3_02Test.java new file mode 100644 index 0000000..d19d6b6 --- /dev/null +++ b/ass1-doc/src/test/java/dst/ass1/doc/tests/Ass1_4_3_02Test.java @@ -0,0 +1,46 @@ +package dst.ass1.doc.tests; + +import dst.ass1.doc.DocumentTestData; +import dst.ass1.doc.EmbeddedMongo; +import dst.ass1.doc.MongoService; +import org.bson.Document; +import org.junit.ClassRule; +import org.junit.Rule; +import org.junit.Test; + +import java.util.List; +import java.util.Map; +import java.util.stream.Collectors; + +import static org.hamcrest.CoreMatchers.hasItems; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.Assert.*; + +public class Ass1_4_3_02Test { + + @ClassRule + public static EmbeddedMongo embeddedMongo = new EmbeddedMongo(); + + @Rule + public MongoService mongo = new MongoService(new DocumentTestData()); + + @Test + public void getDocumentStatistics_returnsCorrectStatistics() throws Exception { + List documentStatistics = mongo.getDocumentQuery().getDocumentStatistics(); + assertNotNull(documentStatistics); + assertEquals(3, documentStatistics.size()); + + List types = documentStatistics.stream().map(d -> d.getString("_id")).collect(Collectors.toList()); + assertThat("expected three aggregation keys", types, hasItems("Restaurant", "Park", "University")); + + Map dsMap = documentStatistics.stream().collect(Collectors.toMap( + d -> d.getString("_id"), + d -> d.getDouble("value")) + ); + + assertEquals(4.0d, dsMap.get("Restaurant"), 0); + assertEquals(1.0d, dsMap.get("Park"), 0); + assertEquals(7.0d, dsMap.get("University"), 0); + } + +} diff --git a/ass1-doc/src/test/java/dst/ass1/doc/tests/Ass1_4_Suite.java b/ass1-doc/src/test/java/dst/ass1/doc/tests/Ass1_4_Suite.java new file mode 100644 index 0000000..4c3d1a2 --- /dev/null +++ b/ass1-doc/src/test/java/dst/ass1/doc/tests/Ass1_4_Suite.java @@ -0,0 +1,16 @@ +package dst.ass1.doc.tests; + +import org.junit.runner.RunWith; +import org.junit.runners.Suite; +import org.junit.runners.Suite.SuiteClasses; + +@RunWith(Suite.class) +@SuiteClasses( { + Ass1_4_1Test.class, + Ass1_4_2aTest.class, + Ass1_4_2bTest.class, + Ass1_4_3_01Test.class, + Ass1_4_3_02Test.class +}) +public class Ass1_4_Suite { +} diff --git a/ass1-doc/src/test/resources/documents.json b/ass1-doc/src/test/resources/documents.json new file mode 100644 index 0000000..e81c03c --- /dev/null +++ b/ass1-doc/src/test/resources/documents.json @@ -0,0 +1,184 @@ +{ + "documents": [ + { + "location_id": NumberLong(1), + "type": "place", + "name": "TU Wien", + "geo": { + "type": "Point", + "coordinates": [ + 16.3699, + 48.199 + ] + }, + "category": "University" + }, + { + "location_id": NumberLong(2), + "type": "place", + "name": "McDonald's", + "geo": { + "type": "Point", + "coordinates": [ + 16.368528, + 48.200939 + ] + }, + "category": "Restaurant" + }, + { + "location_id": NumberLong(3), + "type": "place", + "name": "McDonald's", + "geo": { + "type": "Point", + "coordinates": [ + 16.374138, + 48.201085 + ] + }, + "category": "Restaurant" + }, + { + "location_id": NumberLong(4), + "type": "place", + "name": "McDonald's", + "geo": { + "type": "Point", + "coordinates": [ + 16.371674, + 48.205241 + ] + }, + "category": "Restaurant" + }, + { + "location_id": NumberLong(5), + "type": "place", + "name": "McDonald's", + "geo": { + "type": "Point", + "coordinates": [ + 16.380754, + 48.219325 + ] + }, + "category": "Restaurant" + }, + { + "location_id": NumberLong(6), + "type": "address", + "name": "Zirkusgasse 1", + "geo": { + "type": "Point", + "coordinates": [ + 16.384230, + 48.216310 + ] + } + }, + { + "location_id": NumberLong(7), + "type": "address", + "name": "Handelskai 9", + "geo": { + "type": "Point", + "coordinates": [ + 16.406082, + 48.225571 + ] + } + }, + { + "location_id": NumberLong(8), + "type": "place", + "name": "Cairngorms National Park", + "geo": { + "type": "Point", + "coordinates": [ + -3.562790, + 57.046944 + ] + }, + "category": "Park" + }, + { + "location_id": NumberLong(9), + "type": "place", + "name": "Distributed Systems Group", + "geo": { + "type": "Point", + "coordinates": [ + 16.371425, + 48.197742 + ] + }, + "category": "University" + }, + { + "location_id": NumberLong(10), + "type": "place", + "name": "Computer Vision Lab", + "geo": { + "type": "Point", + "coordinates": [ + 16.369572, + 48.195244 + ] + }, + "category": "University" + }, + { + "location_id": NumberLong(11), + "type": "place", + "name": "Uni Wien", + "geo": { + "type": "Point", + "coordinates": [ + 16.360372, + 48.213069 + ] + }, + "category": "University" + }, + { + "location_id": NumberLong(12), + "type": "place", + "name": "BOKU Wien", + "geo": { + "type": "Point", + "coordinates": [ + 16.337443, + 48.236530 + ] + }, + "category": "University" + }, + { + "location_id": NumberLong(13), + "type": "place", + "name": "WU Wien", + "geo": { + "type": "Point", + "coordinates": [ + 16.408456, + 48.213561 + ] + }, + "category": "University" + }, + { + "location_id": NumberLong(14), + "type": "place", + "name": "Audimax TU Wien", + "geo": { + "type": "Point", + "coordinates": [ + 16.363949, + 48.200822 + ] + }, + "category": "University" + } + ] +} diff --git a/ass1-doc/src/test/resources/logback.xml b/ass1-doc/src/test/resources/logback.xml new file mode 100644 index 0000000..698878a --- /dev/null +++ b/ass1-doc/src/test/resources/logback.xml @@ -0,0 +1,17 @@ + + + + + + %d{yyyy-MM-dd HH:mm:ss.SSS} - %highlight(%5p) [%12.12thread] %cyan(%-40.40logger{39}): %m%n + + + + + + + + + + + diff --git a/ass1-jpa/pom.xml b/ass1-jpa/pom.xml new file mode 100644 index 0000000..66a7e17 --- /dev/null +++ b/ass1-jpa/pom.xml @@ -0,0 +1,35 @@ + + + + 4.0.0 + + + at.ac.tuwien.infosys.dst + dst + 2021.1 + .. + + + ass1-jpa + + jar + + DST :: Assignment 1 :: JPA + + + + org.hibernate + hibernate-core + + + org.hibernate + hibernate-validator + + + com.h2database + h2 + + + + diff --git a/ass1-jpa/src/main/java/dst/ass1/jpa/dao/GenericDAO.java b/ass1-jpa/src/main/java/dst/ass1/jpa/dao/GenericDAO.java new file mode 100644 index 0000000..4cb4180 --- /dev/null +++ b/ass1-jpa/src/main/java/dst/ass1/jpa/dao/GenericDAO.java @@ -0,0 +1,9 @@ +package dst.ass1.jpa.dao; + +import java.util.List; + +public interface GenericDAO { + T findById(Long id); + + List findAll(); +} diff --git a/ass1-jpa/src/main/java/dst/ass1/jpa/dao/IDAOFactory.java b/ass1-jpa/src/main/java/dst/ass1/jpa/dao/IDAOFactory.java new file mode 100644 index 0000000..4d3d233 --- /dev/null +++ b/ass1-jpa/src/main/java/dst/ass1/jpa/dao/IDAOFactory.java @@ -0,0 +1,23 @@ +package dst.ass1.jpa.dao; + +public interface IDAOFactory { + + IDriverDAO createDriverDAO(); + + IEmploymentDAO createEmploymentDAO(); + + ILocationDAO createLocationDAO(); + + IMatchDAO createMatchDAO(); + + IOrganizationDAO createOrganizationDAO(); + + IRiderDAO createRiderDAO(); + + ITripDAO createTripDAO(); + + ITripInfoDAO createTripInfoDAO(); + + IVehicleDAO createVehicleDAO(); + +} diff --git a/ass1-jpa/src/main/java/dst/ass1/jpa/dao/IDriverDAO.java b/ass1-jpa/src/main/java/dst/ass1/jpa/dao/IDriverDAO.java new file mode 100644 index 0000000..e4e0884 --- /dev/null +++ b/ass1-jpa/src/main/java/dst/ass1/jpa/dao/IDriverDAO.java @@ -0,0 +1,19 @@ +package dst.ass1.jpa.dao; + +import dst.ass1.jpa.model.IDriver; + +import java.util.Collection; + +public interface IDriverDAO extends GenericDAO { + + + /** + * Find all drivers that have active employments (active at least one month) in more than the given number + * of organizations + * + * @param numberOfOrganizations number of organizations + * @return a collection containing drivers + */ + Collection findActiveInMultipleOrganizationsDrivers(Long numberOfOrganizations); + +} diff --git a/ass1-jpa/src/main/java/dst/ass1/jpa/dao/IEmploymentDAO.java b/ass1-jpa/src/main/java/dst/ass1/jpa/dao/IEmploymentDAO.java new file mode 100644 index 0000000..6ebd976 --- /dev/null +++ b/ass1-jpa/src/main/java/dst/ass1/jpa/dao/IEmploymentDAO.java @@ -0,0 +1,6 @@ +package dst.ass1.jpa.dao; + +import dst.ass1.jpa.model.IEmployment; + +public interface IEmploymentDAO extends GenericDAO { +} diff --git a/ass1-jpa/src/main/java/dst/ass1/jpa/dao/ILocationDAO.java b/ass1-jpa/src/main/java/dst/ass1/jpa/dao/ILocationDAO.java new file mode 100644 index 0000000..ccdaf27 --- /dev/null +++ b/ass1-jpa/src/main/java/dst/ass1/jpa/dao/ILocationDAO.java @@ -0,0 +1,16 @@ +package dst.ass1.jpa.dao; + +import dst.ass1.jpa.model.ILocation; + +import java.util.Collection; + +public interface ILocationDAO extends GenericDAO { + + /** + * Finds all distinct Location.locationId that have been reached as a Trip destination or additional + * stops. Only takes completed trips in account. + * + * @return a list containing Location.locationIds + */ + Collection findReachedLocationIds(); +} diff --git a/ass1-jpa/src/main/java/dst/ass1/jpa/dao/IMatchDAO.java b/ass1-jpa/src/main/java/dst/ass1/jpa/dao/IMatchDAO.java new file mode 100644 index 0000000..bd1b113 --- /dev/null +++ b/ass1-jpa/src/main/java/dst/ass1/jpa/dao/IMatchDAO.java @@ -0,0 +1,6 @@ +package dst.ass1.jpa.dao; + +import dst.ass1.jpa.model.IMatch; + +public interface IMatchDAO extends GenericDAO { +} diff --git a/ass1-jpa/src/main/java/dst/ass1/jpa/dao/IOrganizationDAO.java b/ass1-jpa/src/main/java/dst/ass1/jpa/dao/IOrganizationDAO.java new file mode 100644 index 0000000..06ac881 --- /dev/null +++ b/ass1-jpa/src/main/java/dst/ass1/jpa/dao/IOrganizationDAO.java @@ -0,0 +1,6 @@ +package dst.ass1.jpa.dao; + +import dst.ass1.jpa.model.IOrganization; + +public interface IOrganizationDAO extends GenericDAO { +} diff --git a/ass1-jpa/src/main/java/dst/ass1/jpa/dao/IRiderDAO.java b/ass1-jpa/src/main/java/dst/ass1/jpa/dao/IRiderDAO.java new file mode 100644 index 0000000..54868f6 --- /dev/null +++ b/ass1-jpa/src/main/java/dst/ass1/jpa/dao/IRiderDAO.java @@ -0,0 +1,33 @@ +package dst.ass1.jpa.dao; + +import dst.ass1.jpa.model.IMoney; +import dst.ass1.jpa.model.IRider; + +import java.util.Map; + +public interface IRiderDAO extends GenericDAO { + + + /** + * Returns the rider associated with the given email. Returns null if the email does not exist. + * + * @param email the email address + * @return the rider or null + */ + IRider findByEmail(String email); + + /** + * Gets the total travel distance of the rider with the most recently completed trip + * + * @return the total distance the rider has travelled + */ + Double getTotalDistanceOfMostRecentRider(); + + /** + * Finds for each Rider, who has completed at least one trip in the past 30 days, the sum of their total + * spendings of the past 30 days. + * + * @return a map containing each rider, and the money grouped by their currency. + */ + Map> getRecentSpending(); +} diff --git a/ass1-jpa/src/main/java/dst/ass1/jpa/dao/ITripDAO.java b/ass1-jpa/src/main/java/dst/ass1/jpa/dao/ITripDAO.java new file mode 100644 index 0000000..2f896b7 --- /dev/null +++ b/ass1-jpa/src/main/java/dst/ass1/jpa/dao/ITripDAO.java @@ -0,0 +1,18 @@ +package dst.ass1.jpa.dao; + +import dst.ass1.jpa.model.ITrip; + +import java.util.Collection; +import java.util.Date; + +public interface ITripDAO extends GenericDAO { + + /** + * Find all canceled trips that were created in the given date range. + * + * @param start start of the date range + * @param end end of the date range + * @return the cancelled trips + */ + Collection findCancelledTrips(Date start, Date end); +} diff --git a/ass1-jpa/src/main/java/dst/ass1/jpa/dao/ITripInfoDAO.java b/ass1-jpa/src/main/java/dst/ass1/jpa/dao/ITripInfoDAO.java new file mode 100644 index 0000000..ba7d67b --- /dev/null +++ b/ass1-jpa/src/main/java/dst/ass1/jpa/dao/ITripInfoDAO.java @@ -0,0 +1,6 @@ +package dst.ass1.jpa.dao; + +import dst.ass1.jpa.model.ITripInfo; + +public interface ITripInfoDAO extends GenericDAO { +} diff --git a/ass1-jpa/src/main/java/dst/ass1/jpa/dao/IVehicleDAO.java b/ass1-jpa/src/main/java/dst/ass1/jpa/dao/IVehicleDAO.java new file mode 100644 index 0000000..92b4774 --- /dev/null +++ b/ass1-jpa/src/main/java/dst/ass1/jpa/dao/IVehicleDAO.java @@ -0,0 +1,6 @@ +package dst.ass1.jpa.dao; + +import dst.ass1.jpa.model.IVehicle; + +public interface IVehicleDAO extends GenericDAO { +} diff --git a/ass1-jpa/src/main/java/dst/ass1/jpa/dao/impl/DAOFactory.java b/ass1-jpa/src/main/java/dst/ass1/jpa/dao/impl/DAOFactory.java new file mode 100644 index 0000000..f254f94 --- /dev/null +++ b/ass1-jpa/src/main/java/dst/ass1/jpa/dao/impl/DAOFactory.java @@ -0,0 +1,74 @@ +package dst.ass1.jpa.dao.impl; + +import dst.ass1.jpa.dao.*; + +import javax.persistence.EntityManager; + +public class DAOFactory implements IDAOFactory { + + /* + * HINT: When using the org.hibernate.Session in your DAOs you can extract it from the EntityManager reference with + * e.g., em.unwrap(org.hibernate.Session.class). Do not store this org.hibernate.Session in your DAOs, but unwrap it + * every time you actually need it. + */ + + private EntityManager em; + + public DAOFactory(EntityManager em) { + this.em = em; + } + + @Override + public IDriverDAO createDriverDAO() { + // TODO + return null; + } + + @Override + public IEmploymentDAO createEmploymentDAO() { + // TODO + return null; + } + + @Override + public ILocationDAO createLocationDAO() { + // TODO + return null; + } + + @Override + public IMatchDAO createMatchDAO() { + // TODO + return null; + } + + @Override + public IOrganizationDAO createOrganizationDAO() { + // TODO + return null; + } + + @Override + public IRiderDAO createRiderDAO() { + // TODO + return null; + } + + @Override + public ITripDAO createTripDAO() { + // TODO + return null; + } + + @Override + public ITripInfoDAO createTripInfoDAO() { + // TODO + return null; + } + + @Override + public IVehicleDAO createVehicleDAO() { + // TODO + return null; + } +} diff --git a/ass1-jpa/src/main/java/dst/ass1/jpa/interceptor/SQLInterceptor.java b/ass1-jpa/src/main/java/dst/ass1/jpa/interceptor/SQLInterceptor.java new file mode 100644 index 0000000..4d21aa4 --- /dev/null +++ b/ass1-jpa/src/main/java/dst/ass1/jpa/interceptor/SQLInterceptor.java @@ -0,0 +1,33 @@ +package dst.ass1.jpa.interceptor; + +import org.hibernate.EmptyInterceptor; + +public class SQLInterceptor extends EmptyInterceptor { + + private static final long serialVersionUID = -3082243834965597947L; + + public static void resetCounter() { + // TODO + } + + public static int getSelectCount() { + // TODO + return -1; + } + + /** + * If the verbose argument is set, the interceptor prints the intercepted SQL statements to System.out. + * + * @param verbose whether or not to be verbose + */ + public static void setVerbose(boolean verbose) { + // TODO + } + + @Override + public String onPrepareStatement(String sql) { + // TODO + return sql; + } + +} diff --git a/ass1-jpa/src/main/java/dst/ass1/jpa/listener/DefaultListener.java b/ass1-jpa/src/main/java/dst/ass1/jpa/listener/DefaultListener.java new file mode 100644 index 0000000..bd3a7bf --- /dev/null +++ b/ass1-jpa/src/main/java/dst/ass1/jpa/listener/DefaultListener.java @@ -0,0 +1,44 @@ +package dst.ass1.jpa.listener; + + +public class DefaultListener { + + // TODO + + public static int getLoadOperations() { + // TODO + return -1; + } + + public static int getUpdateOperations() { + // TODO + return -1; + } + + public static int getRemoveOperations() { + // TODO + return -1; + } + + public static int getPersistOperations() { + // TODO + return -1; + } + + public static long getOverallTimeToPersist() { + // TODO + return -1; + } + + public static double getAverageTimeToPersist() { + // TODO + return -1; + } + + /** + * Clears the internal data structures that are used for storing the operations. + */ + public static void clear() { + // TODO + } +} diff --git a/ass1-jpa/src/main/java/dst/ass1/jpa/model/IDriver.java b/ass1-jpa/src/main/java/dst/ass1/jpa/model/IDriver.java new file mode 100644 index 0000000..d9d2b11 --- /dev/null +++ b/ass1-jpa/src/main/java/dst/ass1/jpa/model/IDriver.java @@ -0,0 +1,17 @@ +package dst.ass1.jpa.model; + +import java.util.Collection; + +public interface IDriver extends IPlatformUser { + + Collection getEmployments(); + + void setEmployments(Collection employments); + + void addEmployment(IEmployment employment); + + IVehicle getVehicle(); + + void setVehicle(IVehicle vehicle); + +} diff --git a/ass1-jpa/src/main/java/dst/ass1/jpa/model/IEmployment.java b/ass1-jpa/src/main/java/dst/ass1/jpa/model/IEmployment.java new file mode 100644 index 0000000..1c76271 --- /dev/null +++ b/ass1-jpa/src/main/java/dst/ass1/jpa/model/IEmployment.java @@ -0,0 +1,18 @@ +package dst.ass1.jpa.model; + +import java.util.Date; + +public interface IEmployment { + + IEmploymentKey getId(); + + void setId(IEmploymentKey employmentKey); + + Date getSince(); + + void setSince(Date since); + + Boolean isActive(); + + void setActive(Boolean active); +} diff --git a/ass1-jpa/src/main/java/dst/ass1/jpa/model/IEmploymentKey.java b/ass1-jpa/src/main/java/dst/ass1/jpa/model/IEmploymentKey.java new file mode 100644 index 0000000..ac06648 --- /dev/null +++ b/ass1-jpa/src/main/java/dst/ass1/jpa/model/IEmploymentKey.java @@ -0,0 +1,12 @@ +package dst.ass1.jpa.model; + +public interface IEmploymentKey { + + IDriver getDriver(); + + void setDriver(IDriver driver); + + IOrganization getOrganization(); + + void setOrganization(IOrganization organization); +} diff --git a/ass1-jpa/src/main/java/dst/ass1/jpa/model/ILocation.java b/ass1-jpa/src/main/java/dst/ass1/jpa/model/ILocation.java new file mode 100644 index 0000000..67deeae --- /dev/null +++ b/ass1-jpa/src/main/java/dst/ass1/jpa/model/ILocation.java @@ -0,0 +1,16 @@ +package dst.ass1.jpa.model; + +public interface ILocation { + + Long getId(); + + void setId(Long id); + + String getName(); + + void setName(String name); + + Long getLocationId(); + + void setLocationId(Long locationId); +} diff --git a/ass1-jpa/src/main/java/dst/ass1/jpa/model/IMatch.java b/ass1-jpa/src/main/java/dst/ass1/jpa/model/IMatch.java new file mode 100644 index 0000000..ae4b021 --- /dev/null +++ b/ass1-jpa/src/main/java/dst/ass1/jpa/model/IMatch.java @@ -0,0 +1,30 @@ +package dst.ass1.jpa.model; + +import java.util.Date; + +public interface IMatch { + + Long getId(); + + void setId(Long id); + + Date getDate(); + + void setDate(Date date); + + IMoney getFare(); + + void setFare(IMoney money); + + ITrip getTrip(); + + void setTrip(ITrip trip); + + IVehicle getVehicle(); + + void setVehicle(IVehicle vehicle); + + IDriver getDriver(); + + void setDriver(IDriver driver); +} diff --git a/ass1-jpa/src/main/java/dst/ass1/jpa/model/IModelFactory.java b/ass1-jpa/src/main/java/dst/ass1/jpa/model/IModelFactory.java new file mode 100644 index 0000000..8821d11 --- /dev/null +++ b/ass1-jpa/src/main/java/dst/ass1/jpa/model/IModelFactory.java @@ -0,0 +1,30 @@ +package dst.ass1.jpa.model; + +public interface IModelFactory { + + IModelFactory createModelFactory(); + + IDriver createDriver(); + + IEmployment createEmployment(); + + IEmploymentKey createEmploymentKey(); + + ILocation createLocation(); + + IMatch createMatch(); + + IMoney createMoney(); + + IOrganization createOrganization(); + + IRider createRider(); + + IPreferences createPreferences(); + + ITrip createTrip(); + + ITripInfo createTripInfo(); + + IVehicle createVehicle(); +} diff --git a/ass1-jpa/src/main/java/dst/ass1/jpa/model/IMoney.java b/ass1-jpa/src/main/java/dst/ass1/jpa/model/IMoney.java new file mode 100644 index 0000000..b255e6f --- /dev/null +++ b/ass1-jpa/src/main/java/dst/ass1/jpa/model/IMoney.java @@ -0,0 +1,14 @@ +package dst.ass1.jpa.model; + +import java.math.BigDecimal; + +public interface IMoney { + + String getCurrency(); + + void setCurrency(String currency); + + BigDecimal getValue(); + + void setValue(BigDecimal value); +} diff --git a/ass1-jpa/src/main/java/dst/ass1/jpa/model/IOrganization.java b/ass1-jpa/src/main/java/dst/ass1/jpa/model/IOrganization.java new file mode 100644 index 0000000..1a43f69 --- /dev/null +++ b/ass1-jpa/src/main/java/dst/ass1/jpa/model/IOrganization.java @@ -0,0 +1,38 @@ +package dst.ass1.jpa.model; + +import java.util.Collection; + +public interface IOrganization { + + Long getId(); + + void setId(Long id); + + String getName(); + + void setName(String name); + + Collection getParts(); + + void setParts(Collection parts); + + void addPart(IOrganization part); + + Collection getPartOf(); + + void setPartOf(Collection partOf); + + void addPartOf(IOrganization partOf); + + Collection getEmployments(); + + void setEmployments(Collection employments); + + void addEmployment(IEmployment employment); + + Collection getVehicles(); + + void setVehicles(Collection vehicles); + + void addVehicle(IVehicle vehicle); +} diff --git a/ass1-jpa/src/main/java/dst/ass1/jpa/model/IPlatformUser.java b/ass1-jpa/src/main/java/dst/ass1/jpa/model/IPlatformUser.java new file mode 100644 index 0000000..d60e965 --- /dev/null +++ b/ass1-jpa/src/main/java/dst/ass1/jpa/model/IPlatformUser.java @@ -0,0 +1,20 @@ +package dst.ass1.jpa.model; + +public interface IPlatformUser { + + Long getId(); + + void setId(Long id); + + String getName(); + + void setName(String name); + + String getTel(); + + void setTel(String tel); + + Double getAvgRating(); + + void setAvgRating(Double avgRating); +} diff --git a/ass1-jpa/src/main/java/dst/ass1/jpa/model/IPreferences.java b/ass1-jpa/src/main/java/dst/ass1/jpa/model/IPreferences.java new file mode 100644 index 0000000..6ce91a1 --- /dev/null +++ b/ass1-jpa/src/main/java/dst/ass1/jpa/model/IPreferences.java @@ -0,0 +1,16 @@ +package dst.ass1.jpa.model; + +import java.util.Map; + +public interface IPreferences { + + Long getId(); + + void setId(Long id); + + Map getData(); + + void setData(Map data); + + void putData(String key, String value); +} diff --git a/ass1-jpa/src/main/java/dst/ass1/jpa/model/IRider.java b/ass1-jpa/src/main/java/dst/ass1/jpa/model/IRider.java new file mode 100644 index 0000000..be561bf --- /dev/null +++ b/ass1-jpa/src/main/java/dst/ass1/jpa/model/IRider.java @@ -0,0 +1,32 @@ +package dst.ass1.jpa.model; + +import java.util.Collection; + +public interface IRider extends IPlatformUser { + + String getEmail(); + + void setEmail(String email); + + byte[] getPassword(); + + void setPassword(byte[] password); + + String getAccountNo(); + + void setAccountNo(String accountNo); + + String getBankCode(); + + void setBankCode(String bankCode); + + IPreferences getPreferences(); + + void setPreferences(IPreferences preferences); + + Collection getTrips(); + + void setTrips(Collection trips); + + void addTrip(ITrip trip); +} diff --git a/ass1-jpa/src/main/java/dst/ass1/jpa/model/ITrip.java b/ass1-jpa/src/main/java/dst/ass1/jpa/model/ITrip.java new file mode 100644 index 0000000..13792c0 --- /dev/null +++ b/ass1-jpa/src/main/java/dst/ass1/jpa/model/ITrip.java @@ -0,0 +1,49 @@ +package dst.ass1.jpa.model; + +import java.util.Collection; +import java.util.Date; + +public interface ITrip { + + Long getId(); + + void setId(Long id); + + Date getCreated(); + + void setCreated(Date created); + + Date getUpdated(); + + void setUpdated(Date updated); + + TripState getState(); + + void setState(TripState state); + + ILocation getPickup(); + + void setPickup(ILocation pickup); + + ILocation getDestination(); + + void setDestination(ILocation destination); + + Collection getStops(); + + void setStops(Collection stops); + + void addStop(ILocation stop); + + ITripInfo getTripInfo(); + + void setTripInfo(ITripInfo tripInfo); + + IMatch getMatch(); + + void setMatch(IMatch match); + + IRider getRider(); + + void setRider(IRider rider); +} diff --git a/ass1-jpa/src/main/java/dst/ass1/jpa/model/ITripInfo.java b/ass1-jpa/src/main/java/dst/ass1/jpa/model/ITripInfo.java new file mode 100644 index 0000000..2d9543d --- /dev/null +++ b/ass1-jpa/src/main/java/dst/ass1/jpa/model/ITripInfo.java @@ -0,0 +1,35 @@ +package dst.ass1.jpa.model; + +import java.util.Date; + +public interface ITripInfo { + + Long getId(); + + void setId(Long id); + + Date getCompleted(); + + void setCompleted(Date date); + + Double getDistance(); + + void setDistance(Double distance); + + IMoney getTotal(); + + void setTotal(IMoney money); + + Integer getDriverRating(); + + void setDriverRating(Integer driverRating); + + Integer getRiderRating(); + + void setRiderRating(Integer riderRating); + + ITrip getTrip(); + + void setTrip(ITrip trip); + +} diff --git a/ass1-jpa/src/main/java/dst/ass1/jpa/model/IVehicle.java b/ass1-jpa/src/main/java/dst/ass1/jpa/model/IVehicle.java new file mode 100644 index 0000000..7517a0d --- /dev/null +++ b/ass1-jpa/src/main/java/dst/ass1/jpa/model/IVehicle.java @@ -0,0 +1,20 @@ +package dst.ass1.jpa.model; + +public interface IVehicle { + + Long getId(); + + void setId(Long id); + + String getLicense(); + + void setLicense(String license); + + String getColor(); + + void setColor(String color); + + String getType(); + + void setType(String type); +} diff --git a/ass1-jpa/src/main/java/dst/ass1/jpa/model/TripState.java b/ass1-jpa/src/main/java/dst/ass1/jpa/model/TripState.java new file mode 100644 index 0000000..6fda2fa --- /dev/null +++ b/ass1-jpa/src/main/java/dst/ass1/jpa/model/TripState.java @@ -0,0 +1,5 @@ +package dst.ass1.jpa.model; + +public enum TripState { + CREATED, QUEUED, MATCHED, APPROACHING, IN_PROGRESS, CANCELLED, COMPLETED +} diff --git a/ass1-jpa/src/main/java/dst/ass1/jpa/model/impl/ModelFactory.java b/ass1-jpa/src/main/java/dst/ass1/jpa/model/impl/ModelFactory.java new file mode 100644 index 0000000..4fef967 --- /dev/null +++ b/ass1-jpa/src/main/java/dst/ass1/jpa/model/impl/ModelFactory.java @@ -0,0 +1,87 @@ +package dst.ass1.jpa.model.impl; + +import dst.ass1.jpa.model.*; + +/** + * Creates new instances of your model implementations. + */ +public class ModelFactory implements IModelFactory { + + @Override + public IModelFactory createModelFactory() { + // TODO + return null; + } + + @Override + public IDriver createDriver() { + // TODO + return null; + } + + @Override + public IEmployment createEmployment() { + // TODO + return null; + } + + @Override + public IEmploymentKey createEmploymentKey() { + // TODO + return null; + } + + @Override + public ILocation createLocation() { + // TODO + return null; + } + + @Override + public IMatch createMatch() { + // TODO + return null; + } + + @Override + public IMoney createMoney() { + // TODO + return null; + } + + @Override + public IOrganization createOrganization() { + // TODO + return null; + } + + @Override + public IRider createRider() { + // TODO + return null; + } + + @Override + public IPreferences createPreferences() { + // TODO + return null; + } + + @Override + public ITrip createTrip() { + // TODO + return null; + } + + @Override + public ITripInfo createTripInfo() { + // TODO + return null; + } + + @Override + public IVehicle createVehicle() { + // TODO + return null; + } +} diff --git a/ass1-jpa/src/main/java/dst/ass1/jpa/util/Constants.java b/ass1-jpa/src/main/java/dst/ass1/jpa/util/Constants.java new file mode 100644 index 0000000..1993980 --- /dev/null +++ b/ass1-jpa/src/main/java/dst/ass1/jpa/util/Constants.java @@ -0,0 +1,121 @@ +package dst.ass1.jpa.util; + +public final class Constants { + + public static final String JPA_PERSISTENCE_UNIT = "dst_pu"; + + /* TYPES (CLASSES) */ + public static final String T_DRIVER = "Driver"; + public static final String T_EMPLOYMENT = "Employment"; + public static final String T_LOCATION = "Location"; + public static final String T_MATCH = "Match"; + public static final String T_ORGANIZATION = "Organization"; + public static final String T_PREFERENCES = "Preferences"; + public static final String T_RIDER = "Rider"; + public static final String T_TRIP = "Trip"; + public static final String T_TRIP_INFO = "TripInfo"; + public static final String T_VEHICLE = "Vehicle"; + + /* IDs (FOREIGN KEYS) */ + public static final String I_DRIVER = "driver_id"; + public static final String I_EMPLOYMENT = "employment_id"; + public static final String I_LOCATION = "location_id"; + public static final String I_MATCH = "match_id"; + public static final String I_ORGANIZATION = "organization_id"; + public static final String I_ORGANIZATION_PART_OF = "partOfOrganization_id"; + public static final String I_ORGANIZATION_PARTS = "partsOrganization_id"; + public static final String I_PREFERENCES = "preferences_id"; + public static final String I_RIDER = "rider_id"; + public static final String I_TRIP = "trip_id"; + public static final String I_TRIP_INFO = "tripInfo_id"; + public static final String I_VEHICLE = "vehicle_id"; + public static final String I_VEHICLES = "vehicles_id"; + + public static final String I_DESTINATION = "destination_id"; + public static final String I_PICKUP = "pickup_id"; + public static final String I_STOPS = "stops_id"; + + + /* MEMBER ATTRIBUTES */ + + + public static final String M_DRIVER_TEL = "tel"; + public static final String M_DRIVER_ORGANIZATIONS = "organizations"; + public static final String M_DRIVER_EMPLOYMENTS = "employments"; + public static final String M_DRIVER_VEHICLE = "vehicle"; + public static final String M_DRIVER_NAME = "name"; + public static final String M_DRIVER_AVG_RATING = "avgRating"; + public static final String M_EMPLOYMENT_SINCE = "since"; + public static final String M_EMPLOYMENT_ACTIVE = "active"; + public static final String M_LOCATION_LOCATION_ID = "locationId"; + public static final String M_LOCATION_GEO = "geo"; + public static final String M_LOCATION_NAME = "name"; + public static final String M_MATCH_DATE = "date"; + public static final String M_MATCH_FARE = "fare"; + public static final String M_MATCH_TRIP = "trip"; + public static final String M_MATCH_VEHICLE = "vehicle"; + public static final String M_MATCH_DRIVER = "driver"; + public static final String M_ORGANIZATION_NAME = "name"; + public static final String M_ORGANIZATION_EMPLOYMENTS = "employments"; + public static final String M_ORGANIZATION_PARTS = "parts"; + public static final String M_ORGANIZATION_DRIVERS = "drivers"; + public static final String M_PREFERENCES_DATA = "data"; + public static final String M_RIDER_BANK_CODE = "bankCode"; + public static final String M_RIDER_EMAIL = "email"; + public static final String M_RIDER_PASSWORD = "password"; + public static final String M_RIDER_TEL = "tel"; + public static final String M_RIDER_ACCOUNT = "accountNo"; + public static final String M_RIDER_PREFERENCES = "preferences"; + public static final String M_RIDER_TRIPS = "trips"; + public static final String M_RIDER_NAME = "name"; + public static final String M_RIDER_AVG_RATING = "avgRating"; + public static final String M_TRIP_STOPS = "stops"; + public static final String M_TRIP_STATE = "state"; + public static final String M_TRIP_CREATED = "created"; + public static final String M_TRIP_UPDATED = "updated"; + public static final String M_TRIP_PICKUP = "pickup"; + public static final String M_TRIP_DESTINATION = "destination"; + public static final String M_TRIP_TRIP_INFO = "tripInfo"; + public static final String M_TRIP_MATCH = "match"; + public static final String M_TRIP_RIDER = "rider"; + public static final String M_TRIP_INFO_COMPLETED = "completed"; + public static final String M_TRIP_INFO_TOTAL = "total"; + public static final String M_TRIP_INFO_DISTANCE = "distance"; + public static final String M_TRIP_INFO_TRIP = "trip"; + public static final String M_TRIP_INFO_DRIVER_RATING = "driverRating"; + public static final String M_TRIP_INFO_RIDER_RATING = "riderRating"; + public static final String M_VEHICLE_LICENSE = "license"; + public static final String M_VEHICLE_COLOR = "color"; + public static final String M_VEHICLE_TYPE = "type"; + + + /* ASSOCIATION NAMES (FOR QUERIES) */ + public static final String A_TRIP_INFO = "tripInfo"; + public static final String A_TRIP = "trip"; + public static final String A_RIDER = "rider"; + + /* NAMED QUERIES */ + public static final String Q_RIDER_BY_EMAIL = "riderByEmail"; + public static final String Q_ACTIVE_IN_MULITIPLE_ORGANIZATIONS_DRIVERS = "activeInMultipleOrganizationsDrivers"; + public static final String Q_REACHED_LOCATIONS = "reachedLocations"; + public static final String Q_SUM_DISTANCE_MOST_RECENT_TRIP = "sumDistanceOfRiderWithMostRecentTrip"; + + /* JOIN TABLES */ + public static final String J_ORGANIZATION_VEHICLE = "organization_vehicle"; + public static final String J_ORGANIZATION_PARTS = "organization_parts"; + public static final String J_DRIVER_ORGANIZATION = "driver_organization"; + public static final String J_PREFERENCES_DATA = "preferences_data"; + public static final String J_DRIVER_EMPLOYMENT = "driver_employment"; + public static final String J_ORGANIZATION_EMPLOYMENT = "organization_employment"; + public static final String J_TRIP_LOCATION = "trip_location"; + public static final String J_DRIVER_VEHICLE = "driver_vehicle"; + + /* MONGODB */ + public static final String MONGO_DB_NAME = "dst"; + public static final String COLL_LOCATION_DATA = "LocationData"; + + + private Constants() { + // final + } +} diff --git a/ass1-jpa/src/main/resources/META-INF/Trip.xml b/ass1-jpa/src/main/resources/META-INF/Trip.xml new file mode 100644 index 0000000..1291bec --- /dev/null +++ b/ass1-jpa/src/main/resources/META-INF/Trip.xml @@ -0,0 +1,9 @@ + + + + + + diff --git a/ass1-jpa/src/main/resources/META-INF/orm.xml b/ass1-jpa/src/main/resources/META-INF/orm.xml new file mode 100644 index 0000000..1291bec --- /dev/null +++ b/ass1-jpa/src/main/resources/META-INF/orm.xml @@ -0,0 +1,9 @@ + + + + + + diff --git a/ass1-jpa/src/main/resources/META-INF/persistence.xml b/ass1-jpa/src/main/resources/META-INF/persistence.xml new file mode 100644 index 0000000..613080d --- /dev/null +++ b/ass1-jpa/src/main/resources/META-INF/persistence.xml @@ -0,0 +1,24 @@ + + + + org.hibernate.jpa.HibernatePersistenceProvider + META-INF/Trip.xml + META-INF/orm.xml + + + + + + + + + + + + + + + diff --git a/ass1-jpa/src/test/java/dst/ass1/jpa/CaseInsensitiveStringCollectionMatcher.java b/ass1-jpa/src/test/java/dst/ass1/jpa/CaseInsensitiveStringCollectionMatcher.java new file mode 100644 index 0000000..2954c6d --- /dev/null +++ b/ass1-jpa/src/test/java/dst/ass1/jpa/CaseInsensitiveStringCollectionMatcher.java @@ -0,0 +1,52 @@ +package dst.ass1.jpa; + +import org.hamcrest.Description; +import org.hamcrest.Factory; +import org.hamcrest.TypeSafeDiagnosingMatcher; + +import java.util.ArrayList; +import java.util.List; + +/** + * Matcher that finds items in string collections in a case-insensitive way. + */ +public class CaseInsensitiveStringCollectionMatcher extends TypeSafeDiagnosingMatcher> { + + private final String[] items; + + public CaseInsensitiveStringCollectionMatcher(String... items) { + this.items = items; + } + + @Factory + public static CaseInsensitiveStringCollectionMatcher hasItems(String... items) { + return new CaseInsensitiveStringCollectionMatcher(items); + } + + @Override + protected boolean matchesSafely(List collection, Description description) { + List missing = new ArrayList<>(); + + for (String item : items) { + if (collection.stream().noneMatch(i -> i.equalsIgnoreCase(item))) { + missing.add(item); + } + } + + if (!missing.isEmpty()) { + if (missing.size() == items.length) { + description.appendValueList("was [", ", ", "]", collection); + } else { + description.appendValueList("missing [", ", ", "]", missing) + .appendValueList(" in [", ", ", "]", collection); + } + } + + return missing.isEmpty(); + } + + @Override + public void describeTo(Description description) { + description.appendValueList("collection containing ", " and ", "", items); + } +} diff --git a/ass1-jpa/src/test/java/dst/ass1/jpa/DatabaseGateway.java b/ass1-jpa/src/test/java/dst/ass1/jpa/DatabaseGateway.java new file mode 100644 index 0000000..0c1d4df --- /dev/null +++ b/ass1-jpa/src/test/java/dst/ass1/jpa/DatabaseGateway.java @@ -0,0 +1,284 @@ +package dst.ass1.jpa; + +import org.hibernate.Session; +import org.hibernate.jdbc.ReturningWork; + +import javax.persistence.EntityManager; +import javax.persistence.metamodel.Type; +import java.sql.*; +import java.util.*; +import java.util.stream.Collectors; + +// DO NOT MODIFY THIS CLASS. + +/** + * Contains various methods for accessing the database underlying an EntityManager. + *

+ * Note that the caller is responsible for dealing with possible exceptions as well as doing the connection handling. A + * connection will not be closed even if a fatal error occurs. However, other SQL resources i.e., + * {@link Statement Statements} and {@link ResultSet ResultSets} created within the methods, which are not returned to + * the caller, are closed before the method returns. + */ +public class DatabaseGateway { + + private final EntityManager em; + + public DatabaseGateway(EntityManager em) { + this.em = em; + } + + /** + * Returns a list of all table-names for the given database/connection. + * + * @return List of table names + */ + public List getTables() { + return getSession().doReturningWork(new CollectionWork<>("show tables", rs -> rs.getString(1))); + } + + /** + * Returns a list of all column names in the given table. + * + * @param tableName the table + * @return a list of column names + */ + public List getColumns(String tableName) { + return getColumnsDefinitions(tableName).stream().map(m -> m.get("COLUMN_NAME")).collect(Collectors.toList()); + } + + public List> getColumnsDefinitions(String tableName) { + String sql = String.format("SELECT * FROM information_schema.columns " + + "WHERE table_name='%s'", tableName.toUpperCase()); + + return getSession().doReturningWork(new QueryWork>>(sql) { + @Override + protected List> execute(ResultSet rs) throws SQLException { + List> list = new ArrayList<>(); + while (rs.next()) { + ResultSetMetaData meta = rs.getMetaData(); + Map map = new HashMap<>(); + for (int i = 1; i <= meta.getColumnCount(); i++) { + String key = meta.getColumnName(i); + String value = rs.getString(key); + map.put(key, value); + } + list.add(map); + } + return list; + } + }); + } + + /** + * Returns the java types of all managed entity types. + * + * @return a list of java types + */ + public List> getManagedJavaTypes() { + return em.getMetamodel() + .getManagedTypes().stream() + .map(Type::getJavaType) + .collect(Collectors.toList()); + } + + /** + * Checks if the named table can be accessed via the given EntityManager. + * + * @param tableName the name of the table to find + * @return {@code true} if the database schema contains a table with the given name, {@code false} otherwise + */ + public boolean isTable(final String tableName) { + return getSession().doReturningWork(new QueryWork("show tables") { + @Override + public Boolean execute(ResultSet rs) throws SQLException { + while (rs.next()) { + String tbl = rs.getString(1); + if (tbl.equalsIgnoreCase(tableName)) { + return true; + } + } + return false; + } + + }); + } + + /** + * Checks whether a certain database table contains a column with the given + * name. + * + * @param tableName the name of the table to check + * @param column the name of the column to find + * @return {@code true} if the table contains the column, {@code false} otherwise + */ + public boolean isColumnInTable(String tableName, String column) { + String sql = String.format( + "SELECT * FROM information_schema.columns WHERE table_name='%s' and column_name='%s'", + tableName.toUpperCase(), column.toUpperCase() + ); + + return getSession().doReturningWork(new HasAtLeastOneEntry(sql)); + } + + /** + * Checks whether a table contains a column of the given type and length. + * + * @param tableName the table to look for + * @param column the expected column name + * @param type the expected column type + * @param length the expected column length + * @return true if the information schema has at least one such column + */ + public boolean isColumnInTableWithType(String tableName, String column, String type, String length) { + String sql = String.format("SELECT * FROM information_schema.columns " + + "WHERE table_name='%s' and column_name='%s' and " + + "type_name='%s' and character_maximum_length='%s'", + tableName.toUpperCase(), column.toUpperCase(), type.toUpperCase(), length); + + return getSession().doReturningWork(new HasAtLeastOneEntry(sql)); + } + + /** + * Checks whether a certain table contains an index for the given column + * name. + * + * @param tableName the name of the table to check + * @param indexName the name of the column the index is created for + * @param nonUnique {@code true} if the index is non unique, {@code false} otherwise + * @return {@code true} if the index exists, {@code false} otherwise + */ + public boolean isIndex(String tableName, String indexName, boolean nonUnique) { + + String sql = String.format( + "SELECT * FROM information_schema.indexes WHERE table_name='%s' and column_name='%s' and non_unique='%s'", + tableName.toUpperCase(), indexName.toUpperCase(), nonUnique ? "1" : "0" + ); + + return getSession().doReturningWork(new HasAtLeastOneEntry(sql)); + } + + public boolean isComposedIndex(String tableName, String columnName1, String columnName2) { + String indexName1 = getIndexName(tableName, columnName1); + String indexName2 = getIndexName(tableName, columnName2); + + return Objects.nonNull(indexName1) && Objects.equals(indexName1, indexName2); + } + + private String getIndexName(String tableName, String columnName) { + String sql = String.format( + "SELECT index_name FROM information_schema.indexes WHERE table_name='%s' and column_name='%s'", + tableName.toUpperCase(), columnName.toUpperCase() + ); + + return getSession().doReturningWork(new QueryWork(sql) { + @Override + protected String execute(ResultSet rs) throws SQLException { + return (rs.next()) ? rs.getString(1) : null; + } + }); + } + + /** + * Checks whether the given column of a certain table can contain {@code NULL} values. + * + * @param tableName the name of the table to check + * @param columnName the name of the column to check + * @return {@code true} if the column is nullable, {@code false} otherwise + */ + public boolean isNullable(String tableName, String columnName) { + String sql = String.format( + "SELECT * FROM information_schema.columns " + + "WHERE table_name='%s' and column_name='%s' and IS_NULLABLE=true", + tableName.toUpperCase(), columnName.toUpperCase() + ); + + return getSession().doReturningWork(new HasAtLeastOneEntry(sql)); + } + + /** + * Deletes all data from all tables that can be accessed via the given EntityManager. + */ + public void truncateTables() { + List tables = getTables(); + tables.removeIf(t -> t.toLowerCase().startsWith("hibernate")); + + getSession().doWork(connection -> { + try (Statement stmt = connection.createStatement()) { + stmt.addBatch("SET FOREIGN_KEY_CHECKS=0"); + for (String table : tables) { + stmt.addBatch("TRUNCATE TABLE " + table); + } + stmt.addBatch("SET FOREIGN_KEY_CHECKS=1"); + stmt.executeBatch(); + } + }); + } + + public Session getSession() { + return em.unwrap(Session.class); + } + + public interface StatementWork extends ReturningWork { + + default T execute(Connection connection) throws SQLException { + try (Statement stmt = connection.createStatement()) { + return execute(stmt); + } + } + + T execute(Statement stmt) throws SQLException; + } + + @FunctionalInterface + public interface CheckedFunction { + R apply(T t) throws E; + } + + public static abstract class QueryWork implements StatementWork { + private final String sql; + + public QueryWork(String sql) { + this.sql = sql; + } + + @Override + public T execute(Statement stmt) throws SQLException { + try (ResultSet rs = stmt.executeQuery(sql)) { + return execute(rs); + } + } + + protected abstract T execute(ResultSet rs) throws SQLException; + } + + public static class HasAtLeastOneEntry extends QueryWork { + + public HasAtLeastOneEntry(String sql) { + super(sql); + } + + @Override + protected Boolean execute(ResultSet rs) throws SQLException { + return rs.next(); + } + } + + public static class CollectionWork extends QueryWork> { + + private final CheckedFunction extractor; + + public CollectionWork(String sql, CheckedFunction extractor) { + super(sql); + this.extractor = extractor; + } + + @Override + protected List execute(ResultSet rs) throws SQLException { + List list = new ArrayList<>(); + while (rs.next()) { + list.add(extractor.apply(rs)); + } + return list; + } + } +} diff --git a/ass1-jpa/src/test/java/dst/ass1/jpa/ITestData.java b/ass1-jpa/src/test/java/dst/ass1/jpa/ITestData.java new file mode 100644 index 0000000..bc59ea0 --- /dev/null +++ b/ass1-jpa/src/test/java/dst/ass1/jpa/ITestData.java @@ -0,0 +1,21 @@ +package dst.ass1.jpa; + +import dst.ass1.jpa.model.IModelFactory; + +import javax.persistence.EntityManager; + +// DO NOT MODIFY THIS CLASS. + +/** + * The ITestData interface is used by the {@link ORMService} to insert test data before each test run. You can pass + * custom implementation of {@link ITestData} to the constructor of {@link ORMService} to create your own test fixture. + */ +public interface ITestData { + /** + * Creates test data using the model factory and inserts them into the entity manager. + * + * @param modelFactory the model factory + * @param em the entity manager + */ + void insert(IModelFactory modelFactory, EntityManager em); +} diff --git a/ass1-jpa/src/test/java/dst/ass1/jpa/ORMService.java b/ass1-jpa/src/test/java/dst/ass1/jpa/ORMService.java new file mode 100644 index 0000000..e5fb8b8 --- /dev/null +++ b/ass1-jpa/src/test/java/dst/ass1/jpa/ORMService.java @@ -0,0 +1,172 @@ +package dst.ass1.jpa; + +import dst.ass1.jpa.dao.IDAOFactory; +import dst.ass1.jpa.dao.impl.DAOFactory; +import dst.ass1.jpa.model.IModelFactory; +import dst.ass1.jpa.model.impl.ModelFactory; +import dst.ass1.jpa.util.Constants; +import org.junit.rules.ExternalResource; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import javax.persistence.EntityManager; +import javax.persistence.EntityManagerFactory; +import javax.persistence.EntityTransaction; +import javax.persistence.Persistence; + +// DO NOT MODIFY THIS CLASS. + +/** + * The ORMService class is used as a JUnit rule that, before each test run, + * a) creates an entity manager factory from the persistence unit referenced in {@link Constants#JPA_PERSISTENCE_UNIT}, + * b) creates an entity manager using the factory, + * c) creates dao and model factory instances, and + * d) creates a database gateway for the entity manager. + *

+ * It provides methods to access these services, and it closes the entity manager and corresponding factory after each + * test run. If you pass an {@link ITestData} instance to the constructor, the {@link ORMService} will also insert test + * data via a transaction before each run, and truncate tables after each run. + */ +public class ORMService extends ExternalResource { + + private static final Logger LOG = LoggerFactory.getLogger(ORMService.class); + + private static EntityManagerFactory emf; + private EntityManager em; + + private DatabaseGateway databaseGateway; + + private IModelFactory modelFactory; + private IDAOFactory daoFactory; + + private ITestData testData; + private boolean insertTestData; + private boolean truncateTables; + + /** + * Creates a new ORMService. By default, the ORMService rule only creates the database connection and other + * ORM facilities. If you want to also insert a test fixture, use {@link #ORMService(ITestData)}. + */ + public ORMService() { + this(null, false, false); + } + + /** + * Creates a new ORMService that also inserts the given {@link ITestData} before each run and truncates the tables + * afterwards. + * + * @param testData the test data to insert + */ + public ORMService(ITestData testData) { + this(testData, true, true); + } + + public ORMService(ITestData testData, boolean insertTestData, boolean truncateTables) { + this.testData = testData; + this.insertTestData = insertTestData; + this.truncateTables = truncateTables; + } + + private static EntityManagerFactory createEntityManagerFactory() { + return Persistence.createEntityManagerFactory(Constants.JPA_PERSISTENCE_UNIT); + } + + public EntityManager getEntityManager() { + return em; + } + + public EntityManager createEntityManager() { + return emf.createEntityManager(); + } + + public IModelFactory getModelFactory() { + return modelFactory; + } + + public IDAOFactory getDaoFactory() { + return daoFactory; + } + + public DatabaseGateway getDatabaseGateway() { + return databaseGateway; + } + + /** + * Alias for {@link #getEntityManager()}. + * + * @return an entity manager + */ + public EntityManager em() { + return getEntityManager(); + } + + @Override + protected void before() throws Throwable { + LOG.debug("Creating EntityManagerFactory"); + emf = createEntityManagerFactory(); + + LOG.debug("Creating EntityManager"); + em = emf.createEntityManager(); + databaseGateway = new DatabaseGateway(em); + + LOG.debug("Initializing factories"); + // initialize factories + modelFactory = new ModelFactory(); + daoFactory = new DAOFactory(em); + + if (testData != null && insertTestData) { + insertTestData(testData); + } + } + + @Override + protected void after() { + if (truncateTables) { + truncateTables(); + } + + try { + LOG.debug("Closing EntityManager"); + em.close(); + } catch (Exception e) { + LOG.error("Error while closing entity manager", e); + } + + try { + LOG.debug("Closing EntityManagerFactory"); + emf.close(); + } catch (Exception e) { + LOG.error("Error while closing entity manager factory", e); + } + } + + protected void insertTestData(ITestData data) { + EntityTransaction tx = getEntityManager().getTransaction(); + + tx.begin(); + try { + data.insert(getModelFactory(), getEntityManager()); + tx.commit(); + } catch (Exception e) { + try { + if (tx.isActive()) { + tx.rollback(); + } + } catch (Exception rollbackException) { + LOG.error("Error while rolling back transaction after exception", rollbackException); + } finally { + throw new IllegalStateException("Couldn't insert fixture. Can't proceed with tests", e); // rethrow original exception + } + } + } + + protected void truncateTables() { + try { + LOG.debug("Truncating database tables"); + getDatabaseGateway().truncateTables(); + } catch (Exception e) { + LOG.error("Error while trying to truncate tables after test", e); + } + } + +} diff --git a/ass1-jpa/src/test/java/dst/ass1/jpa/examples/ExampleTestWithCustomTestData.java b/ass1-jpa/src/test/java/dst/ass1/jpa/examples/ExampleTestWithCustomTestData.java new file mode 100644 index 0000000..e57bc44 --- /dev/null +++ b/ass1-jpa/src/test/java/dst/ass1/jpa/examples/ExampleTestWithCustomTestData.java @@ -0,0 +1,69 @@ +package dst.ass1.jpa.examples; + +import dst.ass1.jpa.ITestData; +import dst.ass1.jpa.ORMService; +import dst.ass1.jpa.dao.IVehicleDAO; +import dst.ass1.jpa.model.IModelFactory; +import dst.ass1.jpa.model.IVehicle; +import org.junit.Rule; +import org.junit.Test; + +import javax.persistence.EntityManager; +import java.util.List; + +import static org.hamcrest.CoreMatchers.is; +import static org.hamcrest.MatcherAssert.assertThat; + +/** + * This examples shows how you can write your own tests with custom fixtures that are injected it into the + * {@link ORMService} rule. Using rules instead of abstract tests is considered good practice as it follows the + * principle of composition over inheritance. + */ +public class ExampleTestWithCustomTestData { + + @Rule + public ORMService orm = new ORMService(new MyTestData()); + + @Test + public void vehicleDAO_findAll_returnsCorrectValues() throws Exception { + IVehicleDAO vehicleDAO = orm.getDaoFactory().createVehicleDAO(); + + List all = vehicleDAO.findAll(); + + assertThat(all.isEmpty(), is(false)); + assertThat(all.size(), is(2)); + + System.out.println(all); + } + + @Test + public void vehicleDAO_findById_returnsCorrectValue() throws Exception { + IVehicleDAO vehicleDAO = orm.getDaoFactory().createVehicleDAO(); + + IVehicle actual = vehicleDAO.findById(1L); + + assertThat(actual.getColor(), is("red")); + } + + public static class MyTestData implements ITestData { + + @Override + public void insert(IModelFactory modelFactory, EntityManager em) { + IVehicle vehicle1 = modelFactory.createVehicle(); + IVehicle vehicle2 = modelFactory.createVehicle(); + + vehicle1.setColor("red"); + vehicle1.setLicense("license1"); + vehicle1.setType("type_1"); + + vehicle2.setColor("blue"); + vehicle2.setLicense("license2"); + vehicle2.setType("type_2"); + + em.persist(vehicle1); + em.persist(vehicle2); + + em.flush(); // transaction is done through the ORMTestFixture + } + } +} diff --git a/ass1-jpa/src/test/java/dst/ass1/jpa/examples/ExampleTestWithDependencies.java b/ass1-jpa/src/test/java/dst/ass1/jpa/examples/ExampleTestWithDependencies.java new file mode 100644 index 0000000..d4fd5c9 --- /dev/null +++ b/ass1-jpa/src/test/java/dst/ass1/jpa/examples/ExampleTestWithDependencies.java @@ -0,0 +1,70 @@ +package dst.ass1.jpa.examples; + +import dst.ass1.jpa.ORMService; +import dst.ass1.jpa.dao.IDAOFactory; +import dst.ass1.jpa.dao.IVehicleDAO; +import dst.ass1.jpa.model.IModelFactory; +import dst.ass1.jpa.model.IVehicle; +import org.junit.ClassRule; +import org.junit.FixMethodOrder; +import org.junit.Test; +import org.junit.runners.MethodSorters; + +import javax.persistence.EntityManager; +import java.util.List; + +import static org.hamcrest.CoreMatchers.is; +import static org.hamcrest.CoreMatchers.notNullValue; +import static org.hamcrest.MatcherAssert.assertThat; + +/** + * This test has no test fixture and dependencies between tests. This is possible by declaring {@link ORMService} as a + * static class-level rule via {@link ClassRule}. + */ +@FixMethodOrder(MethodSorters.NAME_ASCENDING) +public class ExampleTestWithDependencies { + + @ClassRule + public static ORMService orm = new ORMService(); + + @Test + public void t01_insert() throws Exception { + EntityManager em = orm.getEntityManager(); + IModelFactory modelFactory = orm.getModelFactory(); + + IVehicle vehicle1 = modelFactory.createVehicle(); + IVehicle vehicle2 = modelFactory.createVehicle(); + + vehicle1.setColor("red"); + vehicle1.setLicense("license1"); + vehicle1.setType("type_1"); + + vehicle2.setColor("blue"); + vehicle2.setLicense("license2"); + vehicle2.setType("type_2"); + + em.persist(vehicle1); + em.persist(vehicle2); + + + em.getTransaction().begin(); + em.flush(); + em.getTransaction().commit(); + + assertThat(vehicle1.getId(), notNullValue()); + assertThat(vehicle2.getId(), notNullValue()); + } + + @Test + public void t02_query() throws Exception { + IDAOFactory daoFactory = orm.getDaoFactory(); + IVehicleDAO vehicleDAO = daoFactory.createVehicleDAO(); + + List all = vehicleDAO.findAll(); + + assertThat(all.isEmpty(), is(false)); + assertThat(all.size(), is(2)); + + System.out.println(all); + } +} diff --git a/ass1-jpa/src/test/java/dst/ass1/jpa/examples/package-info.java b/ass1-jpa/src/test/java/dst/ass1/jpa/examples/package-info.java new file mode 100644 index 0000000..90c2dc8 --- /dev/null +++ b/ass1-jpa/src/test/java/dst/ass1/jpa/examples/package-info.java @@ -0,0 +1,6 @@ +/** + * This package contains a couple of examples of how you can use JUnit and our simple ORM test framework to create your + * own tests. + */ + +package dst.ass1.jpa.examples; diff --git a/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_1_1_00Test.java b/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_1_1_00Test.java new file mode 100644 index 0000000..d3f8366 --- /dev/null +++ b/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_1_1_00Test.java @@ -0,0 +1,103 @@ +package dst.ass1.jpa.tests; + +import dst.ass1.jpa.ITestData; +import dst.ass1.jpa.ORMService; +import dst.ass1.jpa.dao.*; +import dst.ass1.jpa.model.*; +import org.junit.ClassRule; +import org.junit.FixMethodOrder; +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.ErrorCollector; +import org.junit.runners.MethodSorters; + +import javax.persistence.EntityTransaction; +import java.util.List; + +import static org.hamcrest.CoreMatchers.*; +import static org.hamcrest.object.IsCompatibleType.typeCompatibleWith; +import static org.hamcrest.MatcherAssert.assertThat; + +/** + * Tests the basic setup of the model and dao factory (makes sure they don't return null), and also tests whether all + * relevant entities have been mapped at all and test data can be inserted. + */ +@FixMethodOrder(MethodSorters.NAME_ASCENDING) +public class Ass1_1_1_00Test { + + + @ClassRule + public static ORMService orm = new ORMService(); + + @Rule + public ErrorCollector err = new ErrorCollector(); + + @Test + public void test01_modelFactoryReturnsThings() { + IModelFactory modelFactory = orm.getModelFactory(); + + err.checkThat(modelFactory.createDriver(), isA(IDriver.class)); + err.checkThat(modelFactory.createEmployment(), isA(IEmployment.class)); + err.checkThat(modelFactory.createEmploymentKey(), isA(IEmploymentKey.class)); + err.checkThat(modelFactory.createLocation(), isA(ILocation.class)); + err.checkThat(modelFactory.createMatch(), isA(IMatch.class)); + err.checkThat(modelFactory.createMoney(), isA(IMoney.class)); + err.checkThat(modelFactory.createOrganization(), isA(IOrganization.class)); + err.checkThat(modelFactory.createRider(), isA(IRider.class)); + err.checkThat(modelFactory.createPreferences(), isA(IPreferences.class)); + err.checkThat(modelFactory.createTrip(), isA(ITrip.class)); + err.checkThat(modelFactory.createTripInfo(), isA(ITripInfo.class)); + err.checkThat(modelFactory.createVehicle(), isA(IVehicle.class)); + } + + @Test + public void test02_daoFactoryReturnsThings() { + IDAOFactory daoFactory = orm.getDaoFactory(); + + err.checkThat(daoFactory.createDriverDAO(), isA(IDriverDAO.class)); + err.checkThat(daoFactory.createEmploymentDAO(), isA(IEmploymentDAO.class)); + err.checkThat(daoFactory.createLocationDAO(), isA(ILocationDAO.class)); + err.checkThat(daoFactory.createMatchDAO(), isA(IMatchDAO.class)); + err.checkThat(daoFactory.createOrganizationDAO(), isA(IOrganizationDAO.class)); + err.checkThat(daoFactory.createRiderDAO(), isA(IRiderDAO.class)); + err.checkThat(daoFactory.createTripDAO(), isA(ITripDAO.class)); + err.checkThat(daoFactory.createTripInfoDAO(), isA(ITripInfoDAO.class)); + err.checkThat(daoFactory.createVehicleDAO(), isA(IVehicleDAO.class)); + } + + @Test + public void test03_entityTypesManagedCorrectly() throws Exception { + List> types = orm.getDatabaseGateway().getManagedJavaTypes(); + + assertThat("No managed types found", types.isEmpty(), is(false)); + System.out.println("Managed types: " + types); + err.checkThat(types, hasItem(typeCompatibleWith(IDriver.class))); + err.checkThat(types, hasItem(typeCompatibleWith(IEmployment.class))); + err.checkThat(types, hasItem(typeCompatibleWith(IEmploymentKey.class))); + err.checkThat(types, hasItem(typeCompatibleWith(ILocation.class))); + err.checkThat(types, hasItem(typeCompatibleWith(IMoney.class))); + err.checkThat(types, hasItem(typeCompatibleWith(IOrganization.class))); + err.checkThat(types, hasItem(typeCompatibleWith(IRider.class))); + err.checkThat(types, hasItem(typeCompatibleWith(IPreferences.class))); + err.checkThat(types, hasItem(typeCompatibleWith(ITrip.class))); + err.checkThat(types, hasItem(typeCompatibleWith(ITripInfo.class))); + err.checkThat(types, hasItem(typeCompatibleWith(IVehicle.class))); + } + + @Test + public void test04_canInsertTestFixture() throws Exception { + ITestData testData = new TestData(); + + EntityTransaction tx = orm.em().getTransaction(); + tx.begin(); + try { + testData.insert(orm.getModelFactory(), orm.em()); + } catch (Exception e) { + throw new AssertionError("Exception while inserting test fixture.", e); + } finally { + tx.rollback(); + } + } + + +} diff --git a/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_1_1_01Test.java b/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_1_1_01Test.java new file mode 100644 index 0000000..a9930f0 --- /dev/null +++ b/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_1_1_01Test.java @@ -0,0 +1,179 @@ +package dst.ass1.jpa.tests; + +import dst.ass1.jpa.DatabaseGateway; +import dst.ass1.jpa.ORMService; +import org.junit.*; +import org.junit.rules.ErrorCollector; +import org.junit.runners.MethodSorters; + +import static dst.ass1.jpa.CaseInsensitiveStringCollectionMatcher.hasItems; +import static dst.ass1.jpa.util.Constants.*; +import static org.hamcrest.CoreMatchers.is; +import static org.hamcrest.CoreMatchers.not; + +/** + * Tests the basic object-relational mapping by examining the created database tables and constraints. + */ +@FixMethodOrder(MethodSorters.NAME_ASCENDING) +public class Ass1_1_1_01Test { + + @ClassRule + public static ORMService orm = new ORMService(); + + @Rule + public ErrorCollector err = new ErrorCollector(); + + private DatabaseGateway db; + + @Before + public void setUp() throws Exception { + db = orm.getDatabaseGateway(); + } + + @Test + public void printTables() throws Exception { + // not a test, just some systout output that may help you to gain insight into the created database schema + for (String table : db.getTables()) { + System.out.printf("%-30s %s%n", table, db.getColumns(table)); + } + } + + @Test + public void testBasicTablesJdbc() throws Exception { + // checks that all basic tables exist + err.checkThat(db.getTables(), hasItems( + T_RIDER, + T_TRIP, + T_LOCATION, + T_TRIP_INFO, + T_DRIVER, + T_EMPLOYMENT, + T_ORGANIZATION, + T_VEHICLE, + T_MATCH, + T_PREFERENCES + )); + } + + @Test + public void testRelation01Jdbc() throws Exception { + // driver -> vehicle + err.checkThat(db.getColumns(T_DRIVER), hasItems(I_VEHICLE)); + err.checkThat(db.isNullable(T_DRIVER, I_VEHICLE), is(false)); + + err.checkThat(db.getTables(), not(hasItems(J_DRIVER_VEHICLE))); + } + + @Test + public void testRelation02Jdbc() throws Exception { + // rider <-> trip + err.checkThat(db.getColumns(T_TRIP), hasItems(I_RIDER)); + } + + @Test + public void testRelation03Jdbc() throws Exception { + // driver <- employment -> organization + + err.checkThat(db.getColumns(T_EMPLOYMENT), hasItems( + I_DRIVER, + I_ORGANIZATION + )); + + } + + @Test + public void testRelation04Jdbc() throws Exception { + // trip <-> match -> vehicle + // | + // v + // driver + + err.checkThat(db.getColumns(T_MATCH), hasItems( + I_DRIVER, + I_TRIP, + I_VEHICLE + )); + err.checkThat(db.getColumns(T_DRIVER), not(hasItems(I_MATCH))); + err.checkThat(db.getColumns(T_TRIP), not(hasItems(I_MATCH))); + err.checkThat(db.getColumns(T_VEHICLE), not(hasItems(I_MATCH))); + + err.checkThat(db.getColumns(T_MATCH), hasItems(I_TRIP)); + } + + @Test + public void testRelation05Jdbc() throws Exception { + // organization <-> organization + + err.checkThat("join table should be explicitly renamed!", db.getTables(), not(hasItems( + T_ORGANIZATION + "_" + T_ORGANIZATION + ))); + err.checkThat(db.getTables(), hasItems( + J_ORGANIZATION_PARTS + )); + err.checkThat(db.getColumns(J_ORGANIZATION_PARTS), hasItems( + I_ORGANIZATION_PARTS, + I_ORGANIZATION_PART_OF + )); + } + + @Test + public void testRelation06Jdbc() throws Exception { + // trip -> location (stops) + err.checkThat(db.getTables(), hasItems(J_TRIP_LOCATION)); + err.checkThat(db.getColumns(J_TRIP_LOCATION), hasItems(I_TRIP)); + err.checkThat(db.getColumns(J_TRIP_LOCATION), hasItems(I_STOPS)); + } + + @Test + public void testRelation07Jdbc() throws Exception { + // trip -> location (pickup) + + err.checkThat(db.getColumns(T_TRIP), hasItems(I_PICKUP)); + err.checkThat(db.isIndex(T_TRIP, I_PICKUP, true), is(true)); + err.checkThat(db.isNullable(T_TRIP, I_PICKUP), is(false)); + } + + @Test + public void testRelation08Jdbc() throws Exception { + // trip -> location (destination) + err.checkThat(db.getColumns(T_TRIP), hasItems(I_DESTINATION)); + err.checkThat(db.isIndex(T_TRIP, I_DESTINATION, true), is(true)); + err.checkThat(db.isNullable(T_TRIP, I_DESTINATION), is(false)); + } + + @Test + public void testRelation09Jdbc() throws Exception { + // trip <-> tripinfo + + err.checkThat(db.getColumns(T_TRIP_INFO), hasItems(I_TRIP)); + err.checkThat(db.isNullable(T_TRIP_INFO, I_TRIP), is(false)); + } + + @Test + public void testRelation10Jdbc() throws Exception { + // organization -> vehicle + + err.checkThat(db.getTables(), hasItems(J_ORGANIZATION_VEHICLE)); + err.checkThat(db.getColumns(J_ORGANIZATION_VEHICLE), hasItems( + I_ORGANIZATION, + I_VEHICLES + )); + + } + + @Test + public void testRelation11Jdbc() throws Exception { + // rider -> preferences + + err.checkThat(db.getColumns(T_RIDER), hasItems(I_PREFERENCES)); + err.checkThat(db.isNullable(T_RIDER, I_PREFERENCES), is(false)); + + err.checkThat(db.getColumns(T_PREFERENCES), not(hasItems(I_RIDER))); + } + + @Test + public void testColumnType01Jdbc() { + err.checkThat(db.isColumnInTableWithType(T_RIDER, M_RIDER_PASSWORD, "VARBINARY", "20"), is(true)); + } + +} diff --git a/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_1_1_02Test.java b/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_1_1_02Test.java new file mode 100644 index 0000000..9c92aa6 --- /dev/null +++ b/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_1_1_02Test.java @@ -0,0 +1,30 @@ +package dst.ass1.jpa.tests; + +import dst.ass1.jpa.ORMService; +import dst.ass1.jpa.util.Constants; +import org.junit.Rule; +import org.junit.Test; + +import static org.junit.Assert.assertTrue; + +/** + * Tests the IVehicle license unique constraint. + */ +public class Ass1_1_1_02Test { + + @Rule + public ORMService orm = new ORMService(); + + @Test + public void testConstraint() { + new UniqueConstraintTester<>(() -> orm.getModelFactory().createVehicle(), e -> e.setLicense("uniquevalue")) + .run(orm.getEntityManager()); + } + + @Test + public void testConstraintJdbc() { + assertTrue(orm.getDatabaseGateway().isIndex(Constants.T_VEHICLE, Constants.M_VEHICLE_LICENSE, false)); + assertTrue(orm.getDatabaseGateway().isNullable(Constants.T_VEHICLE, Constants.M_VEHICLE_LICENSE)); + } + +} diff --git a/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_1_1_03Test.java b/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_1_1_03Test.java new file mode 100644 index 0000000..ae09623 --- /dev/null +++ b/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_1_1_03Test.java @@ -0,0 +1,48 @@ +package dst.ass1.jpa.tests; + +import dst.ass1.jpa.ORMService; +import dst.ass1.jpa.model.IPreferences; +import dst.ass1.jpa.model.IRider; +import dst.ass1.jpa.util.Constants; +import org.hibernate.PropertyValueException; +import org.junit.Rule; +import org.junit.Test; + +import javax.persistence.PersistenceException; + +import static org.hamcrest.CoreMatchers.*; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.core.StringContains.containsString; +import static org.junit.Assert.*; + +/** + * Tests the IRider tel not null constraint. + */ +public class Ass1_1_1_03Test { + + @Rule + public ORMService orm = new ORMService(); + + @Test + public void testConstraint() { + IRider e1 = orm.getModelFactory().createRider(); + e1.setEmail("email@example.com"); + e1.setTel(null); + IPreferences preferences = orm.getModelFactory().createPreferences(); + e1.setPreferences(preferences); + var e = assertThrows(PersistenceException.class, () -> { + orm.em().getTransaction().begin(); + orm.em().persist(preferences); + orm.em().persist(e1); + orm.em().flush(); + }); + assertThat(e.getMessage(), containsString("not-null property")); + assertThat(e.getCause(), is(instanceOf(PropertyValueException.class))); + + } + + @Test + public void testConstraintJdbc() { + assertFalse(orm.getDatabaseGateway().isNullable(Constants.T_RIDER, Constants.M_RIDER_TEL)); + } +} diff --git a/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_1_1_04Test.java b/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_1_1_04Test.java new file mode 100644 index 0000000..e864956 --- /dev/null +++ b/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_1_1_04Test.java @@ -0,0 +1,43 @@ +package dst.ass1.jpa.tests; + +import dst.ass1.jpa.ORMService; +import dst.ass1.jpa.model.IDriver; +import dst.ass1.jpa.util.Constants; +import org.hibernate.PropertyValueException; +import org.junit.Rule; +import org.junit.Test; + +import javax.persistence.PersistenceException; + +import static org.hamcrest.CoreMatchers.*; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertThrows; + +/** + * Tests the IDriver tel not null constraint. + */ +public class Ass1_1_1_04Test { + + @Rule + public ORMService orm = new ORMService(); + + @Test + public void testConstraint() { + IDriver e1 = orm.getModelFactory().createDriver(); + e1.setTel(null); + var e = assertThrows(PersistenceException.class, () -> { + orm.em().getTransaction().begin(); + orm.em().persist(e1); + orm.em().flush(); + }); + assertThat(e.getMessage(), containsString("not-null property")); + assertThat(e.getCause(), is(instanceOf(PropertyValueException.class))); + } + + @Test + public void testConstraintJdbc() { + assertFalse(orm.getDatabaseGateway().isNullable(Constants.T_DRIVER, Constants.M_DRIVER_TEL)); + } + +} diff --git a/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_1_1_05Test.java b/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_1_1_05Test.java new file mode 100644 index 0000000..d9c5ec1 --- /dev/null +++ b/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_1_1_05Test.java @@ -0,0 +1,52 @@ +package dst.ass1.jpa.tests; + +import dst.ass1.jpa.ORMService; +import dst.ass1.jpa.model.IMoney; +import org.junit.Rule; +import org.junit.Test; + +import javax.persistence.metamodel.ManagedType; +import javax.persistence.metamodel.Type; +import java.math.BigDecimal; + +import static org.hamcrest.CoreMatchers.is; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.Assert.*; + +/** + * Tests if IMoney is implemented correctly. + */ +public class Ass1_1_1_05Test { + + @Rule + public ORMService orm = new ORMService(); + + @Test + public void moneyEntityCannotBePersisted() { + IMoney money = orm.getModelFactory().createMoney(); + assertNotNull(money); + + money.setValue(BigDecimal.TEN); + money.setCurrency("EURO"); + + assertThrows(IllegalArgumentException.class, () -> { + orm.getEntityManager().persist(money); + }); + } + + @Test + public void moneyIsEmbeddableType() { + IMoney money = orm.getModelFactory().createMoney(); + assertNotNull(money); + + ManagedType type = orm.getEntityManager().getMetamodel().managedType(money.getClass()); + assertNotNull(type); + assertThat(type.getPersistenceType(), is(Type.PersistenceType.EMBEDDABLE)); + } + + @Test + public void moneyHasNoTable() throws Exception { + assertFalse(orm.getDatabaseGateway().isTable("MONEY")); + } + +} diff --git a/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_1_1_06Test.java b/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_1_1_06Test.java new file mode 100644 index 0000000..51c4fff --- /dev/null +++ b/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_1_1_06Test.java @@ -0,0 +1,58 @@ +package dst.ass1.jpa.tests; + +import dst.ass1.jpa.ORMService; +import dst.ass1.jpa.model.IPreferences; +import dst.ass1.jpa.util.Constants; +import org.junit.Rule; +import org.junit.Test; + +import javax.persistence.EntityManager; +import java.util.Map; + +import static org.hamcrest.CoreMatchers.hasItems; +import static org.hamcrest.CoreMatchers.is; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.Assert.assertTrue; + +/** + * Tests that IPreferences is persisted correctly. + */ +public class Ass1_1_1_06Test { + + @Rule + public ORMService orm = new ORMService(); + + @Test + public void testPreferencesMap() { + IPreferences pref1 = orm.getModelFactory().createPreferences(); + + pref1.putData("key1", "value1"); + pref1.putData("key2", "value2"); + + EntityManager em = orm.getEntityManager(); + em.getTransaction().begin(); + + em.persist(pref1); + em.flush(); + em.getTransaction().commit(); + + EntityManager em2 = orm.createEntityManager(); + IPreferences md2 = em2.find(pref1.getClass(), pref1.getId()); + + Map map = md2.getData(); + + assertThat(map.size(), is(2)); + assertThat(map.keySet(), hasItems("key1", "key2")); + assertThat(map.get("key1"), is("value1")); + assertThat(map.get("key2"), is("value2")); + } + + @Test + public void testPreferencesMapJdbc() { + assertTrue(orm.getDatabaseGateway().isTable(Constants.T_PREFERENCES)); + assertTrue(orm.getDatabaseGateway().isTable(Constants.J_PREFERENCES_DATA)); + assertTrue(orm.getDatabaseGateway().isColumnInTable(Constants.J_PREFERENCES_DATA, Constants.I_PREFERENCES)); + assertTrue(orm.getDatabaseGateway().isColumnInTable(Constants.J_PREFERENCES_DATA, Constants.M_PREFERENCES_DATA + "_KEY")); + } + +} diff --git a/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_1_1_07Test.java b/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_1_1_07Test.java new file mode 100644 index 0000000..c119bde --- /dev/null +++ b/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_1_1_07Test.java @@ -0,0 +1,91 @@ +package dst.ass1.jpa.tests; + +import dst.ass1.jpa.model.IPreferences; +import dst.ass1.jpa.model.IRider; +import dst.ass1.jpa.model.ITrip; +import org.hibernate.PropertyValueException; +import org.hibernate.exception.ConstraintViolationException; +import org.junit.Test; + +import javax.persistence.PersistenceException; + +import static org.hamcrest.CoreMatchers.*; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.Assert.*; + +/** + * Tests if the IRider and IPreferences relation is implemented correctly. + */ +public class Ass1_1_1_07Test extends Ass1_TestBase { + + @Test + public void testPreferencesAssociation() { + IRider rider1 = daoFactory.createRiderDAO().findById(testData.rider1Id); + assertNotNull(rider1); + assertEquals(testData.preferences1Id, rider1.getPreferences().getId()); + + IRider rider2 = daoFactory.createRiderDAO().findById(testData.rider2Id); + assertNotNull(rider2); + assertEquals(testData.preferences2Id, rider2.getPreferences().getId()); + } + + @Test + public void testPreferencesNonOptionalConstraint() { + + IRider rider1 = daoFactory.createRiderDAO().findById(testData.rider1Id); + assertNotNull(rider1); + rider1.setPreferences(null); + + var e = assertThrows(PersistenceException.class, () -> { + em.getTransaction().begin(); + em.persist(rider1); + em.flush(); + }); + assertThat(e.getMessage(), containsString("not-null property")); + assertThat(e.getCause(), is(instanceOf(PropertyValueException.class))); + } + + @Test + public void testPreferencesUniqueConstraint() throws Exception { + IRider rider1 = daoFactory.createRiderDAO().findById(testData.rider1Id); + IPreferences preferences1 = rider1.getPreferences(); + + IRider rider5 = modelFactory.createRider(); + rider5.setEmail("email@example.com"); + rider5.setName("rider5"); + rider5.setTel("tel"); + rider5.setPreferences(preferences1); + + em.getTransaction().begin(); + var missingException = "Persisting the same metadata object with a different course should result in a constraint violation"; + var e = assertThrows(missingException, PersistenceException.class, () -> { + em.persist(rider5); + em.flush(); + }); + assertThat(missingException, e.getCause(), is(instanceOf(ConstraintViolationException.class))); + } + + @Test + public void testRiderPreferencesDeleteCascade() throws Exception { + IRider rider = daoFactory.createRiderDAO().findById(testData.rider4Id); + Long preferencesId = rider.getPreferences().getId(); + + em.getTransaction().begin(); + try { + for (ITrip trip : rider.getTrips()) { + trip.setRider(null); + } + em.remove(rider); + em.flush(); + } catch (PersistenceException e) { + throw new AssertionError("Removing a rider should not result in a PersistenceException", e); + } + em.getTransaction().commit(); + + em.getTransaction().begin(); + IPreferences preferences = em.find(modelFactory.createPreferences().getClass(), preferencesId); + assertNull("Expected preferences to be null after associated rider was deleted", preferences); + } + + +} diff --git a/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_1_1_08Test.java b/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_1_1_08Test.java new file mode 100644 index 0000000..c52abc5 --- /dev/null +++ b/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_1_1_08Test.java @@ -0,0 +1,49 @@ +package dst.ass1.jpa.tests; + +import dst.ass1.jpa.model.IRider; +import dst.ass1.jpa.model.ITrip; +import dst.ass1.jpa.model.TripState; +import org.junit.Test; + +import java.util.List; + +import static org.hamcrest.CoreMatchers.hasItem; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.Assert.*; + +/** + * Tests the 1-N association between ITrip and IRider (its creator). + */ +public class Ass1_1_1_08Test extends Ass1_TestBase { + + @Test + public void testTripRiderAssociation() { + + IRider rider1 = daoFactory.createRiderDAO().findById(testData.rider4Id); + assertNotNull(rider1); + assertNotNull(rider1.getTrips()); + + List tripIds = map(rider1.getTrips(), ITrip::getId); + + assertEquals(1, tripIds.size()); + assertThat(tripIds, hasItem(testData.trip6Id)); + + ITrip trip1 = daoFactory.createTripDAO().findById(testData.trip6Id); + ITrip trip2 = daoFactory.createTripDAO().findById(testData.trip1Id); + + assertNotNull(trip1); + assertNotNull(trip2); + + assertEquals(testData.rider4Id, trip1.getRider().getId()); + assertEquals(testData.rider1Id, trip2.getRider().getId()); + } + + @Test + public void testTripStatus() { + ITrip trip1 = daoFactory.createTripDAO().findById(testData.trip1Id); + assertEquals(TripState.COMPLETED, trip1.getState()); + ITrip trip2 = daoFactory.createTripDAO().findById(testData.trip6Id); + assertEquals(TripState.CREATED, trip2.getState()); + } + +} diff --git a/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_1_1_09Test.java b/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_1_1_09Test.java new file mode 100644 index 0000000..6150ad0 --- /dev/null +++ b/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_1_1_09Test.java @@ -0,0 +1,84 @@ +package dst.ass1.jpa.tests; + +import dst.ass1.jpa.dao.IOrganizationDAO; +import dst.ass1.jpa.dao.IVehicleDAO; +import dst.ass1.jpa.dao.impl.DAOFactory; +import dst.ass1.jpa.model.IOrganization; +import dst.ass1.jpa.model.IVehicle; +import org.junit.Test; + +import javax.persistence.EntityManager; +import java.util.List; + +import static org.hamcrest.CoreMatchers.hasItems; +import static org.hamcrest.CoreMatchers.is; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.Assert.*; + +/** + * Tests the association between IOrganization and IVehicle. + */ +public class Ass1_1_1_09Test extends Ass1_TestBase { + + @Test + public void testOrganizationVehicleAssociation() { + EntityManager em = orm.createEntityManager(); + DAOFactory daoFactory = new DAOFactory(em); + + IOrganizationDAO organizationDAO = daoFactory.createOrganizationDAO(); + IVehicleDAO vehicleDAO = daoFactory.createVehicleDAO(); + + List vehicles = vehicleDAO.findAll(); + + assertNotNull(vehicles); + assertEquals(4, vehicles.size()); + + IVehicle vehicle1 = vehicleDAO.findById(testData.vehicle1Id); + IVehicle vehicle2 = vehicleDAO.findById(testData.vehicle2Id); + IVehicle vehicle3 = vehicleDAO.findById(testData.vehicle3Id); + IVehicle vehicle4 = vehicleDAO.findById(testData.vehicle4Id); + + assertEquals(testData.vehicle1Id, vehicle1.getId()); + assertEquals(testData.vehicle2Id, vehicle2.getId()); + assertEquals(testData.vehicle3Id, vehicle3.getId()); + assertEquals(testData.vehicle4Id, vehicle4.getId()); + + List organizations = organizationDAO.findAll(); + + assertNotNull(organizations); + assertEquals(5, organizations.size()); + + IOrganization organization1 = organizationDAO.findById(testData.organization1Id); + IOrganization organization2 = organizationDAO.findById(testData.organization2Id); + IOrganization organization3 = organizationDAO.findById(testData.organization3Id); + IOrganization organization4 = organizationDAO.findById(testData.organization4Id); + IOrganization organization5 = organizationDAO.findById(testData.organization5Id); + + assertEquals(testData.organization1Id, organization1.getId()); + assertNotNull(organization1.getVehicles()); + assertThat(organization1.getVehicles().size(), is(3)); + + List vehicleIds1 = map(organization1.getVehicles(), IVehicle::getId); + assertThat(vehicleIds1, hasItems(testData.vehicle1Id, testData.vehicle2Id, testData.vehicle3Id)); + + assertEquals(testData.organization2Id, organization2.getId()); + assertNotNull(organization2.getVehicles()); + assertThat(organization2.getVehicles().size(), is(1)); + + List vehicleIds2 = map(organization2.getVehicles(), IVehicle::getId); + assertThat(vehicleIds2, hasItems(testData.vehicle4Id)); + + assertEquals(testData.organization3Id, organization3.getId()); + assertNotNull(organization3.getVehicles()); + assertThat(organization3.getVehicles().size(), is(0)); + + assertEquals(testData.organization4Id, organization4.getId()); + assertNotNull(organization4.getVehicles()); + assertThat(organization4.getVehicles().size(), is(0)); + + assertEquals(testData.organization5Id, organization5.getId()); + assertNotNull(organization5.getVehicles()); + assertThat(organization5.getVehicles().size(), is(0)); + } + +} diff --git a/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_1_1_10Test.java b/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_1_1_10Test.java new file mode 100644 index 0000000..4186355 --- /dev/null +++ b/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_1_1_10Test.java @@ -0,0 +1,107 @@ +package dst.ass1.jpa.tests; + +import dst.ass1.jpa.dao.IOrganizationDAO; +import dst.ass1.jpa.dao.impl.DAOFactory; +import dst.ass1.jpa.model.IOrganization; +import dst.ass1.jpa.util.Constants; +import org.hibernate.Session; +import org.junit.Test; + +import javax.persistence.EntityManager; +import java.sql.ResultSet; +import java.sql.Statement; +import java.util.List; + +import static org.hamcrest.CoreMatchers.is; +import static org.hamcrest.core.IsCollectionContaining.hasItem; +import static org.hamcrest.core.IsCollectionContaining.hasItems; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.Assert.*; + +/** + * Tests the self reference of IOrganization. + */ +public class Ass1_1_1_10Test extends Ass1_TestBase { + + @Test + public void testOrganizationSelfAssociation() { + EntityManager em = orm.createEntityManager(); + IOrganizationDAO dao = new DAOFactory(em).createOrganizationDAO(); + + IOrganization organization1 = dao.findById(testData.organization1Id); + IOrganization organization2 = dao.findById(testData.organization2Id); + IOrganization organization3 = dao.findById(testData.organization3Id); + IOrganization organization4 = dao.findById(testData.organization4Id); + IOrganization organization5 = dao.findById(testData.organization5Id); + + assertNotNull(organization1.getParts()); + assertNotNull(organization1.getPartOf()); + assertNotNull(organization2.getParts()); + assertNotNull(organization2.getPartOf()); + assertNotNull(organization3.getParts()); + assertNotNull(organization3.getPartOf()); + assertNotNull(organization4.getParts()); + assertNotNull(organization4.getPartOf()); + assertNotNull(organization5.getParts()); + assertNotNull(organization5.getPartOf()); + + List organization1Parts = map(organization1.getParts(), IOrganization::getId); + List organization1PartOf = map(organization1.getPartOf(), IOrganization::getId); + List organization2Parts = map(organization2.getParts(), IOrganization::getId); + List organization2PartOf = map(organization2.getPartOf(), IOrganization::getId); + List organization3Parts = map(organization3.getParts(), IOrganization::getId); + List organization3PartOf = map(organization3.getPartOf(), IOrganization::getId); + List organization4Parts = map(organization4.getParts(), IOrganization::getId); + List organization4PartOf = map(organization4.getPartOf(), IOrganization::getId); + List organization5Parts = map(organization5.getParts(), IOrganization::getId); + List organization5PartOf = map(organization5.getPartOf(), IOrganization::getId); + + + assertThat(organization1Parts, hasItems(testData.organization4Id, testData.organization5Id)); + assertThat(organization1PartOf, hasItem(testData.organization2Id)); + assertThat(organization2Parts, hasItem(testData.organization1Id)); + assertThat(organization2PartOf, hasItems(testData.organization4Id)); + assertThat(organization3Parts.size(), is(0)); + assertThat(organization3PartOf.size(), is(0)); + assertThat(organization4Parts, hasItems(testData.organization2Id)); + assertThat(organization4PartOf, hasItems(testData.organization1Id)); + assertThat(organization5Parts.size(), is(0)); + assertThat(organization5PartOf, hasItems(testData.organization1Id)); + } + + @Test + public void testOrganizationSelfAssociationJdbc() { + String sql = "SELECT " + Constants.I_ORGANIZATION_PARTS + ", " + Constants.I_ORGANIZATION_PART_OF + + " FROM " + Constants.J_ORGANIZATION_PARTS + + " ORDER BY " + Constants.I_ORGANIZATION_PARTS + ", " + Constants.I_ORGANIZATION_PART_OF; + + em.unwrap(Session.class).doWork(connection -> { + + try (Statement stmt = connection.createStatement()) { + ResultSet rs = stmt.executeQuery(sql); + assertTrue(rs.next()); + + assertEquals((long) testData.organization1Id, rs.getLong(Constants.I_ORGANIZATION_PARTS)); + assertEquals((long) testData.organization4Id, rs.getLong(Constants.I_ORGANIZATION_PART_OF)); + + assertTrue(rs.next()); + + assertEquals((long) testData.organization1Id, rs.getLong(Constants.I_ORGANIZATION_PARTS)); + assertEquals((long) testData.organization5Id, rs.getLong(Constants.I_ORGANIZATION_PART_OF)); + + assertTrue(rs.next()); + + assertEquals((long) testData.organization2Id, rs.getLong(Constants.I_ORGANIZATION_PARTS)); + assertEquals((long) testData.organization1Id, rs.getLong(Constants.I_ORGANIZATION_PART_OF)); + + assertTrue(rs.next()); + + assertEquals((long) testData.organization4Id, rs.getLong(Constants.I_ORGANIZATION_PARTS)); + assertEquals((long) testData.organization2Id, rs.getLong(Constants.I_ORGANIZATION_PART_OF)); + + rs.close(); + } + }); + } + +} diff --git a/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_1_2_01Test.java b/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_1_2_01Test.java new file mode 100644 index 0000000..00899e8 --- /dev/null +++ b/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_1_2_01Test.java @@ -0,0 +1,52 @@ +package dst.ass1.jpa.tests; + +import dst.ass1.jpa.ORMService; +import dst.ass1.jpa.model.IPreferences; +import dst.ass1.jpa.model.IRider; +import dst.ass1.jpa.util.Constants; +import org.junit.Rule; +import org.junit.Test; + +import static org.junit.Assert.assertTrue; + +/** + * Tests the constraint for IRider bank data. + */ +public class Ass1_1_2_01Test { + + @Rule + public ORMService orm = new ORMService(); + + @Test + public void testRiderAccountNoBankCodeConstraint() { + IRider r1 = orm.getModelFactory().createRider(); + IRider r2 = orm.getModelFactory().createRider(); + IPreferences p1 = orm.getModelFactory().createPreferences(); + IPreferences p2 = orm.getModelFactory().createPreferences(); + orm.em().persist(p1); + orm.em().persist(p2); + + r1.setEmail("p1@example.com"); + r2.setEmail("p2@example.com"); + r1.setPreferences(p1); + r2.setPreferences(p2); + r1.setTel("tel1"); + r2.setTel("tel2"); + + new UniqueConstraintTester<>(r1, r2, e -> { + e.setAccountNo("uniqueVal1"); + e.setBankCode("uniqueVal2"); + }).run(orm.getEntityManager()); + } + + @Test + public void testRiderAccountNoBankCodeConstraintJdbc() { + assertTrue(orm.getDatabaseGateway().isIndex(Constants.T_RIDER, Constants.M_RIDER_ACCOUNT, false)); + assertTrue(orm.getDatabaseGateway().isIndex(Constants.T_RIDER, Constants.M_RIDER_BANK_CODE, false)); + assertTrue(orm.getDatabaseGateway().isComposedIndex(Constants.T_RIDER, Constants.M_RIDER_ACCOUNT, Constants.M_RIDER_BANK_CODE)); + + assertTrue(orm.getDatabaseGateway().isNullable(Constants.T_RIDER, Constants.M_RIDER_ACCOUNT)); + assertTrue(orm.getDatabaseGateway().isNullable(Constants.T_RIDER, Constants.M_RIDER_BANK_CODE)); + } + +} diff --git a/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_1_2_02Test.java b/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_1_2_02Test.java new file mode 100644 index 0000000..0d40c3e --- /dev/null +++ b/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_1_2_02Test.java @@ -0,0 +1,62 @@ +package dst.ass1.jpa.tests; + +import dst.ass1.jpa.ORMService; +import dst.ass1.jpa.model.IPreferences; +import dst.ass1.jpa.model.IRider; +import dst.ass1.jpa.util.Constants; +import org.hibernate.PropertyValueException; +import org.junit.Rule; +import org.junit.Test; + +import javax.persistence.PersistenceException; +import java.sql.SQLException; + +import static org.hamcrest.CoreMatchers.*; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertThrows; + +/** + * Tests the constraint for IRider email. + */ +public class Ass1_1_2_02Test { + + @Rule + public ORMService orm = new ORMService(); + + @Test + public void testUniqueConstraint() { + new UniqueConstraintTester<>(() -> { + IRider rider = orm.getModelFactory().createRider(); + rider.setTel("tel"); + IPreferences preferences = orm.getModelFactory().createPreferences(); + orm.getEntityManager().persist(preferences); + rider.setPreferences(preferences); + return rider; + }, e -> e.setEmail("unique@example.com")) + .run(orm.getEntityManager()); + } + + @Test + public void testNotNullConstraint() { + IRider e1 = orm.getModelFactory().createRider(); + e1.setEmail(null); + e1.setTel("tel"); + IPreferences preferences = orm.getModelFactory().createPreferences(); + e1.setPreferences(preferences); + var e = assertThrows(PersistenceException.class, () -> { + orm.em().getTransaction().begin(); + orm.em().persist(preferences); + orm.em().persist(e1); + orm.em().flush(); + }); + assertThat(e.getMessage(), containsString("not-null property")); + assertThat(e.getCause(), is(instanceOf(PropertyValueException.class))); + } + + @Test + public void testRiderEmailNotNullConstraintJdbc() throws SQLException { + assertFalse(orm.getDatabaseGateway().isNullable(Constants.T_RIDER, Constants.M_RIDER_EMAIL)); + } + +} diff --git a/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_2_1aTest.java b/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_2_1aTest.java new file mode 100644 index 0000000..c634fed --- /dev/null +++ b/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_2_1aTest.java @@ -0,0 +1,52 @@ +package dst.ass1.jpa.tests; + +import dst.ass1.jpa.dao.IRiderDAO; +import dst.ass1.jpa.model.IRider; +import dst.ass1.jpa.util.Constants; +import org.junit.Before; +import org.junit.Test; + +import javax.persistence.Query; + +import static org.junit.Assert.*; + +public class Ass1_2_1aTest extends Ass1_TestBase { + + private IRiderDAO dao; + private Class entityClass; + + @Before + public void setUp() throws Exception { + dao = daoFactory.createRiderDAO(); + entityClass = modelFactory.createRider().getClass(); + } + + @Test + public void namedQuery_withEmailParameter_returnsNonEmptyResultSet() throws Exception { + Query query = em.createNamedQuery(Constants.Q_RIDER_BY_EMAIL); + + try { + query.setParameter("email", TestData.RIDER_1_EMAIL); + } catch (IllegalArgumentException e) { + throw new AssertionError("Could not set parameter 'email' in named query " + Constants.Q_RIDER_BY_EMAIL, e); + } + + assertEquals("Expected exactly one result", 1, query.getResultList().size()); + } + + @Test + public void findByEmail_returnsCorrectResult() throws Exception { + Long riderId = testData.rider1Id; + + IRider actual = dao.findByEmail(TestData.RIDER_1_EMAIL); + IRider expected = em.find(entityClass, riderId); + + assertEquals(riderId, actual.getId()); + assertSame(expected, actual); // note that they should actually be the same object due EntityManager caching! + } + + @Test + public void findByEmail_withNonExistingEmail_returnsNull() throws Exception { + assertNull(dao.findByEmail("non@existing.com")); + } +} diff --git a/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_2_1bTest.java b/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_2_1bTest.java new file mode 100644 index 0000000..a67a072 --- /dev/null +++ b/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_2_1bTest.java @@ -0,0 +1,62 @@ +package dst.ass1.jpa.tests; + +import dst.ass1.jpa.dao.IDriverDAO; +import dst.ass1.jpa.model.IDriver; +import dst.ass1.jpa.util.Constants; +import org.junit.Test; + +import javax.persistence.TypedQuery; +import java.util.Collection; +import java.util.List; + +import static org.hamcrest.CoreMatchers.hasItems; +import static org.hamcrest.CoreMatchers.is; +import static org.hamcrest.MatcherAssert.assertThat; + +public class Ass1_2_1bTest extends Ass1_TestBase { + + @Test + public void namedQuery_returnsCorrectResult() throws Exception { + TypedQuery singleResultQuery = em.createNamedQuery(Constants.Q_ACTIVE_IN_MULITIPLE_ORGANIZATIONS_DRIVERS, IDriver.class); + singleResultQuery.setParameter("organizations", 2L); + + List resultList = singleResultQuery.getResultList(); + assertThat("Expected a single result", resultList.size(), is(1)); + + IDriver result = resultList.get(0); + assertThat(result.getName(), is(TestData.DRIVER_1_NAME)); + + TypedQuery twoResultsQuery = em.createNamedQuery(Constants.Q_ACTIVE_IN_MULITIPLE_ORGANIZATIONS_DRIVERS, IDriver.class); + twoResultsQuery.setParameter("organizations", 1L); + + List twoResults = twoResultsQuery.getResultList(); + assertThat("Expected two results", twoResults.size(), is(2)); + + List names = map(twoResults, IDriver::getName); + assertThat(names, hasItems(TestData.DRIVER_1_NAME, TestData.DRIVER_2_NAME)); + } + + @Test + public void daoFind_returnsCorrectResult() throws Exception { + IDriverDAO dao = daoFactory.createDriverDAO(); + Collection resultList; + + resultList = dao.findActiveInMultipleOrganizationsDrivers(3L); + assertThat("Expected an empty result for " + 3, resultList.isEmpty(), is(true)); + + resultList = dao.findActiveInMultipleOrganizationsDrivers(4L); + assertThat("Expected an empty result for " + 4, resultList.isEmpty(), is(true)); + + resultList = dao.findActiveInMultipleOrganizationsDrivers(2L); + assertThat("Expected a single results for " + 2, resultList.size(), is(1)); + IDriver result = resultList.iterator().next(); + assertThat(result.getName(), is(TestData.DRIVER_1_NAME)); + + resultList = dao.findActiveInMultipleOrganizationsDrivers(1L); + assertThat("Expected two results for " + 1, resultList.size(), is(2)); + List names = map(resultList, IDriver::getName); + assertThat(names, hasItems(TestData.DRIVER_1_NAME, TestData.DRIVER_2_NAME)); + + } + +} diff --git a/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_2_1cTest.java b/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_2_1cTest.java new file mode 100644 index 0000000..96e8885 --- /dev/null +++ b/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_2_1cTest.java @@ -0,0 +1,96 @@ +package dst.ass1.jpa.tests; + +import dst.ass1.jpa.dao.IDriverDAO; +import dst.ass1.jpa.dao.ILocationDAO; +import dst.ass1.jpa.model.*; +import dst.ass1.jpa.util.Constants; +import org.junit.Test; + +import javax.persistence.EntityTransaction; +import javax.persistence.TypedQuery; +import java.math.BigDecimal; +import java.util.Date; + +import static dst.ass1.jpa.tests.TestData.*; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; + +public class Ass1_2_1cTest extends Ass1_TestBase { + + + @Test + public void namedQuery_returnsCorrectResult() { + TypedQuery q = em.createNamedQuery(Constants.Q_SUM_DISTANCE_MOST_RECENT_TRIP, Double.class); + + Double result = q.getSingleResult(); + assertNotNull(result); + assertEquals(TRIP_2_DISTANCE + TRIP_4_DISTANCE, result, 0.0); + + } + + @Test + public void namedQuery_withAdditionalAssociation_returnsCorrectResult() throws Exception { + EntityTransaction tx = em.getTransaction(); + tx.begin(); + + ITrip trip = modelFactory.createTrip(); + ITripInfo tripInfo = modelFactory.createTripInfo(); + IMatch match = modelFactory.createMatch(); + IDriverDAO driverDAO = daoFactory.createDriverDAO(); + IDriver driver = driverDAO.findById(testData.driver2Id); + IRider rider = daoFactory.createRiderDAO().findById(testData.rider1Id); + ILocationDAO locationDAO = daoFactory.createLocationDAO(); + ILocation pickup = locationDAO.findById(testData.location1Id); + ILocation destination = locationDAO.findById(testData.location2Id); + IVehicle vehicle = daoFactory.createVehicleDAO().findById(testData.vehicle1Id); + IMoney fare = modelFactory.createMoney(); + fare.setCurrency(CURRENCY_1); + fare.setValue(BigDecimal.TEN); + IMoney total = modelFactory.createMoney(); + total.setCurrency(CURRENCY_1); + total.setValue(BigDecimal.TEN); + + match.setDate(new Date()); + match.setFare(fare); + match.setDriver(driver); + match.setVehicle(vehicle); + match.setTrip(trip); + + trip.setCreated(new Date()); + trip.setUpdated(new Date()); + trip.setState(TripState.COMPLETED); + trip.setPickup(pickup); + trip.setDestination(destination); + trip.setRider(rider); + trip.setMatch(match); + trip.setTripInfo(tripInfo); + + double distance = 22.22; + tripInfo.setDistance(distance); + tripInfo.setCompleted(new Date()); + tripInfo.setTotal(total); + tripInfo.setDriverRating(3); + tripInfo.setRiderRating(4); + tripInfo.setTrip(trip); + + em.persist(trip); + em.persist(match); + em.persist(tripInfo); + em.flush(); + tx.commit(); + + TypedQuery q = em.createNamedQuery(Constants.Q_SUM_DISTANCE_MOST_RECENT_TRIP, Double.class); + + Double resultList = q.getSingleResult(); + assertNotNull(resultList); + assertEquals(TRIP_1_DISTANCE + TRIP_5_DISTANCE + distance, resultList, 0.0); + } + + @Test + public void daoFind_returnsCorrectResult() { + double result = daoFactory.createRiderDAO().getTotalDistanceOfMostRecentRider(); + + assertEquals(TRIP_2_DISTANCE + TRIP_4_DISTANCE, result, 0.0); + } + +} diff --git a/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_2_2Test.java b/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_2_2Test.java new file mode 100644 index 0000000..c0cb919 --- /dev/null +++ b/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_2_2Test.java @@ -0,0 +1,132 @@ +package dst.ass1.jpa.tests; + +import dst.ass1.jpa.dao.IDAOFactory; +import dst.ass1.jpa.dao.IDriverDAO; +import dst.ass1.jpa.dao.ILocationDAO; +import dst.ass1.jpa.dao.impl.DAOFactory; +import dst.ass1.jpa.model.*; +import dst.ass1.jpa.util.Constants; +import org.junit.Before; +import org.junit.Test; + +import javax.persistence.EntityManager; +import javax.persistence.EntityTransaction; +import java.math.BigDecimal; +import java.util.Collection; +import java.util.Date; +import java.util.LinkedList; +import java.util.List; + +import static dst.ass1.jpa.tests.TestData.*; +import static org.hamcrest.CoreMatchers.hasItems; +import static org.hamcrest.CoreMatchers.is; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.Assert.assertTrue; + +public class Ass1_2_2Test extends Ass1_TestBase { + + private ILocationDAO locationDAO; + + @Before + public void setUp() throws Exception { + // makes sure there's no cache from creating entities + EntityManager em = orm.createEntityManager(); + IDAOFactory daoFactory = new DAOFactory(em); + + locationDAO = daoFactory.createLocationDAO(); + } + + @Test + public void testReachedLocationsExists() { + em.createNamedQuery(Constants.Q_REACHED_LOCATIONS); + } + + @Test + public void testReachedLocationsQuery() { + Collection ids = locationDAO.findReachedLocationIds(); + assertThat(ids.size(), is(5)); + assertThat(ids, hasItems(LOCATION_1_ID, LOCATION_2_ID, LOCATION_3_ID, LOCATION_4_ID, LOCATION_5_ID)); + } + + @Test + public void testReachedLocationsQuery_withAdditionalAssociations() { + EntityTransaction tx = em.getTransaction(); + tx.begin(); + final Long ADD_REACHED_1 = 12L; + final Long ADD_REACHED_2 = 13L; + ILocation location1 = modelFactory.createLocation(); + location1.setLocationId(11L); + location1.setName("location11"); + ILocation location2 = modelFactory.createLocation(); + location2.setLocationId(ADD_REACHED_1); + location2.setName("location12"); + ILocation location3 = modelFactory.createLocation(); + location3.setLocationId(ADD_REACHED_2); + location3.setName("location13"); + ILocation location4 = modelFactory.createLocation(); + location4.setLocationId(14L); + location4.setName("location14"); + + ITrip trip = modelFactory.createTrip(); + ITripInfo tripInfo = modelFactory.createTripInfo(); + IMatch match = modelFactory.createMatch(); + IDriverDAO driverDAO = daoFactory.createDriverDAO(); + IDriver driver = driverDAO.findById(testData.driver2Id); + IRider rider = daoFactory.createRiderDAO().findById(testData.rider1Id); + IVehicle vehicle = daoFactory.createVehicleDAO().findById(testData.vehicle1Id); + IMoney fare = modelFactory.createMoney(); + fare.setCurrency(CURRENCY_1); + fare.setValue(BigDecimal.TEN); + IMoney total = modelFactory.createMoney(); + total.setCurrency(CURRENCY_1); + total.setValue(BigDecimal.TEN); + + match.setDate(new Date()); + match.setFare(fare); + match.setDriver(driver); + match.setVehicle(vehicle); + match.setTrip(trip); + + trip.setCreated(new Date()); + trip.setUpdated(new Date()); + trip.setState(TripState.COMPLETED); + trip.setPickup(location1); + trip.setDestination(location2); + trip.setRider(rider); + trip.setMatch(match); + trip.setTripInfo(tripInfo); + List stops = new LinkedList<>(); + stops.add(location3); + trip.setStops(stops); + + tripInfo.setDistance(22.22); + tripInfo.setCompleted(createDate(2016, 2, 23, 2, 2)); + tripInfo.setTotal(total); + tripInfo.setDriverRating(3); + tripInfo.setRiderRating(4); + tripInfo.setTrip(trip); + + em.persist(location1); + em.persist(location2); + em.persist(location3); + em.persist(location4); + em.persist(trip); + em.persist(match); + em.persist(tripInfo); + em.flush(); + tx.commit(); + + Collection ids = locationDAO.findReachedLocationIds(); + + assertThat(ids, hasItems(LOCATION_1_ID, LOCATION_2_ID, LOCATION_3_ID, LOCATION_4_ID, LOCATION_5_ID, ADD_REACHED_1, ADD_REACHED_2)); + } + + @Test + public void testReachedLocationsQuery_onEmptyDatabase() { + db.truncateTables(); + Collection ids = locationDAO.findReachedLocationIds(); + assertTrue(ids.isEmpty()); + } + + +} diff --git a/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_2_3a_01Test.java b/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_2_3a_01Test.java new file mode 100644 index 0000000..10ba4d6 --- /dev/null +++ b/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_2_3a_01Test.java @@ -0,0 +1,97 @@ +package dst.ass1.jpa.tests; + +import dst.ass1.jpa.dao.IRiderDAO; +import dst.ass1.jpa.model.IMoney; +import dst.ass1.jpa.model.IRider; +import org.junit.Before; +import org.junit.Test; + +import java.math.BigDecimal; +import java.math.RoundingMode; +import java.util.Map; +import java.util.stream.Collectors; + +import static dst.ass1.jpa.tests.TestData.*; +import static org.hamcrest.CoreMatchers.is; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.Assert.*; + +public class Ass1_2_3a_01Test extends Ass1_TestBase { + + private IRiderDAO riderDAO; + + static Map> convertMapKeys(Map> result) { + return result.entrySet().stream().collect(Collectors.toMap( + kv -> kv.getKey().getId(), + kv -> kv.getValue() + )); + } + + @Before + public void setUp() throws Exception { + riderDAO = daoFactory.createRiderDAO(); + } + + @Test + public void testRecentspending() { + final IMoney spendingCurrency1Rider1 = modelFactory.createMoney(); + spendingCurrency1Rider1.setValue(TRIP_INFO_1_MONEY_VALUE); + spendingCurrency1Rider1.setCurrency(CURRENCY_1); + + final IMoney spendingCurrency2Rider1 = modelFactory.createMoney(); + spendingCurrency2Rider1.setValue(TRIP_INFO_5_MONEY_VALUE); + spendingCurrency2Rider1.setCurrency(CURRENCY_2); + + final IMoney spendingCurrency1Rider2 = modelFactory.createMoney(); + spendingCurrency1Rider2.setValue(TRIP_INFO_4_MONEY_VALUE); + spendingCurrency1Rider2.setCurrency(CURRENCY_1); + + final IMoney spendingCurrency2Rider2 = modelFactory.createMoney(); + spendingCurrency2Rider2.setValue(TRIP_INFO_2_MONEY_VALUE); + spendingCurrency2Rider2.setCurrency(CURRENCY_2); + + final IMoney spendingCurrency3Rider3 = modelFactory.createMoney(); + spendingCurrency3Rider3.setValue(TRIP_INFO_3_MONEY_VALUE); + spendingCurrency3Rider3.setCurrency(CURRENCY_3); + + Map> spending = riderDAO.getRecentSpending(); + + assertThat(spending.size(), is(3)); + + Map> mapped = convertMapKeys(spending); + + assertTrue(mapped.containsKey(testData.rider1Id)); + assertTrue(mapped.containsKey(testData.rider2Id)); + assertTrue(mapped.containsKey(testData.rider3Id)); + + assertThat(mapped.get(testData.rider1Id).size(), is(2)); + assertThat(mapped.get(testData.rider2Id).size(), is(2)); + assertThat(mapped.get(testData.rider3Id).size(), is(1)); + + assertTrue(mapped.get(testData.rider1Id).containsKey(CURRENCY_1)); + assertTrue(mapped.get(testData.rider1Id).containsKey(CURRENCY_2)); + assertTrue(mapped.get(testData.rider2Id).containsKey(CURRENCY_1)); + assertTrue(mapped.get(testData.rider2Id).containsKey(CURRENCY_2)); + assertTrue(mapped.get(testData.rider3Id).containsKey(CURRENCY_3)); + + assertEquals(spendingCurrency1Rider1.getValue(), scaleDown(mapped.get(testData.rider1Id).get(CURRENCY_1))); + assertEquals(spendingCurrency2Rider1.getValue(), scaleDown(mapped.get(testData.rider1Id).get(CURRENCY_2))); + assertEquals(spendingCurrency1Rider2.getValue(), scaleDown(mapped.get(testData.rider2Id).get(CURRENCY_1))); + assertEquals(spendingCurrency2Rider2.getValue(), scaleDown(mapped.get(testData.rider2Id).get(CURRENCY_2))); + assertEquals(spendingCurrency3Rider3.getValue(), scaleDown(mapped.get(testData.rider3Id).get(CURRENCY_3))); + + } + + @Test + public void testRecentSpending_onEmptyDatabase() { + db.truncateTables(); + Map> recentSpending = riderDAO.getRecentSpending(); + assertTrue(recentSpending.isEmpty()); + } + + private BigDecimal scaleDown(IMoney money) { + return money.getValue().setScale(0, RoundingMode.DOWN); + } + + +} diff --git a/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_2_3a_02Test.java b/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_2_3a_02Test.java new file mode 100644 index 0000000..b7c877e --- /dev/null +++ b/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_2_3a_02Test.java @@ -0,0 +1,122 @@ +package dst.ass1.jpa.tests; + +import dst.ass1.jpa.dao.IRiderDAO; +import dst.ass1.jpa.dao.ITripDAO; +import dst.ass1.jpa.model.*; +import org.junit.Before; +import org.junit.Test; + +import javax.persistence.EntityTransaction; +import java.math.BigDecimal; +import java.math.RoundingMode; +import java.util.Date; +import java.util.Map; +import java.util.stream.Collectors; + +import static dst.ass1.jpa.tests.TestData.*; +import static org.hamcrest.CoreMatchers.is; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.Assert.*; + +public class Ass1_2_3a_02Test extends Ass1_TestBase { + + private static final BigDecimal TRIP_INFO_9_VALUE = new BigDecimal(55.0); + private ITripDAO tripDAO; + private IRiderDAO riderDAO; + + static Map> convertMapKeys(Map> result) { + return result.entrySet().stream().collect(Collectors.toMap( + kv -> kv.getKey().getId(), + kv -> kv.getValue() + )); + } + + @Before + public void setUpDatabase() throws Exception { + tripDAO = daoFactory.createTripDAO(); + riderDAO = daoFactory.createRiderDAO(); + + IMoney total = modelFactory.createMoney(); + total.setValue(TRIP_INFO_9_VALUE); + total.setCurrency(CURRENCY_2); + + + EntityTransaction tx = em.getTransaction(); + tx.begin(); + ITrip trip = tripDAO.findById(testData.trip9Id); + trip.setState(TripState.COMPLETED); + ITripInfo tripInfo = modelFactory.createTripInfo(); + tripInfo.setTrip(trip); + tripInfo.setRiderRating(3); + tripInfo.setDriverRating(3); + tripInfo.setTotal(total); + tripInfo.setCompleted(new Date()); + tripInfo.setDistance(2.2); + trip.setTripInfo(tripInfo); + em.persist(tripInfo); + em.flush(); + tx.commit(); + } + + @Test + public void testRecentspending() { + final IMoney spendingCurrency1Rider1 = modelFactory.createMoney(); + spendingCurrency1Rider1.setValue(TRIP_INFO_1_MONEY_VALUE); + spendingCurrency1Rider1.setCurrency(CURRENCY_1); + + final IMoney spendingCurrency2Rider1 = modelFactory.createMoney(); + spendingCurrency2Rider1.setValue(TRIP_INFO_5_MONEY_VALUE.add(TRIP_INFO_9_VALUE)); + spendingCurrency2Rider1.setCurrency(CURRENCY_2); + + final IMoney spendingCurrency1Rider2 = modelFactory.createMoney(); + spendingCurrency1Rider2.setValue(TRIP_INFO_4_MONEY_VALUE); + spendingCurrency1Rider2.setCurrency(CURRENCY_1); + + final IMoney spendingCurrency2Rider2 = modelFactory.createMoney(); + spendingCurrency2Rider2.setValue(TRIP_INFO_2_MONEY_VALUE); + spendingCurrency2Rider2.setCurrency(CURRENCY_2); + + final IMoney spendingCurrency3Rider3 = modelFactory.createMoney(); + spendingCurrency3Rider3.setValue(TRIP_INFO_3_MONEY_VALUE); + spendingCurrency3Rider3.setCurrency(CURRENCY_3); + + Map> spending = riderDAO.getRecentSpending(); + + assertThat(spending.size(), is(3)); + + Map> mapped = convertMapKeys(spending); + + assertTrue(mapped.containsKey(testData.rider1Id)); + assertTrue(mapped.containsKey(testData.rider2Id)); + assertTrue(mapped.containsKey(testData.rider3Id)); + + assertThat(mapped.get(testData.rider1Id).size(), is(2)); + assertThat(mapped.get(testData.rider2Id).size(), is(2)); + assertThat(mapped.get(testData.rider3Id).size(), is(1)); + + assertTrue(mapped.get(testData.rider1Id).containsKey(CURRENCY_1)); + assertTrue(mapped.get(testData.rider1Id).containsKey(CURRENCY_2)); + assertTrue(mapped.get(testData.rider2Id).containsKey(CURRENCY_2)); + assertTrue(mapped.get(testData.rider2Id).containsKey(CURRENCY_2)); + assertTrue(mapped.get(testData.rider3Id).containsKey(CURRENCY_3)); + + assertEquals(spendingCurrency1Rider1.getValue(), scaleDown(mapped.get(testData.rider1Id).get(CURRENCY_1))); + assertEquals(spendingCurrency2Rider1.getValue(), scaleDown(mapped.get(testData.rider1Id).get(CURRENCY_2))); + assertEquals(spendingCurrency1Rider2.getValue(), scaleDown(mapped.get(testData.rider2Id).get(CURRENCY_1))); + assertEquals(spendingCurrency2Rider2.getValue(), scaleDown(mapped.get(testData.rider2Id).get(CURRENCY_2))); + assertEquals(spendingCurrency3Rider3.getValue(), scaleDown(mapped.get(testData.rider3Id).get(CURRENCY_3))); + } + + @Test + public void testRecentSpending_onEmptyDatabase() { + db.truncateTables(); + Map> recentSpending = riderDAO.getRecentSpending(); + assertTrue(recentSpending.isEmpty()); + } + + private BigDecimal scaleDown(IMoney money) { + return money.getValue().setScale(0, RoundingMode.DOWN); + } + + +} diff --git a/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_2_3b_01Test.java b/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_2_3b_01Test.java new file mode 100644 index 0000000..748c84f --- /dev/null +++ b/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_2_3b_01Test.java @@ -0,0 +1,86 @@ +package dst.ass1.jpa.tests; + +import dst.ass1.jpa.dao.ITripDAO; +import dst.ass1.jpa.model.ITrip; +import org.junit.Before; +import org.junit.Test; + +import java.util.Collection; +import java.util.Date; +import java.util.GregorianCalendar; + +import static org.hamcrest.CoreMatchers.is; +import static org.hamcrest.core.IsCollectionContaining.hasItems; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.Assert.assertTrue; + +public class Ass1_2_3b_01Test extends Ass1_TestBase { + + private ITripDAO dao; + + @Before + public void setUp() throws Exception { + dao = daoFactory.createTripDAO(); + } + + @Test + public void testFindCanceledTripsBetweenStartAndFinish() { + Collection trips = dao.findCancelledTrips(null, null); + Collection ids = map(trips, ITrip::getId); + + assertThat(ids.size(), is(7)); + assertThat(ids, hasItems(testData.trip8Id, testData.trip11Id, testData.trip12Id, testData.trip13Id, testData.trip14Id, testData.trip15Id, testData.trip16Id)); + } + + @Test + public void testFindCanceledTripsCreatedBetweenStartAndFinish2() { + Date start = createDate(2019, 1, 1, 1, 1); + Collection trips = dao.findCancelledTrips(start, null); + Collection ids = map(trips, ITrip::getId); + + assertThat(ids.size(), is(4)); + assertThat(ids, hasItems(testData.trip8Id, testData.trip13Id, testData.trip14Id, testData.trip15Id)); + } + + @Test + public void testFindCanceledTripsForStatusCreatedBetweenStartAndFinish3() { + Date start = dao.findById(testData.trip15Id).getCreated(); + Collection trips = dao.findCancelledTrips(start, null); + Collection ids = map(trips, ITrip::getId); + + assertThat(ids.size(), is(1)); + assertThat(ids, hasItems(testData.trip8Id)); + } + + @Test + public void testFindCanceledTripsForStatusCreatedBetweenStartAndFinish4() { + Date end = dao.findById(testData.trip11Id).getCreated(); + Collection trips = dao.findCancelledTrips(null, end); + + assertThat(trips.size(), is(1)); + assertThat(map(trips, ITrip::getId), hasItems(testData.trip12Id)); + } + + @Test + public void testFindCanceledEventsForStatusCreatedBetweenStartAndFinish5() { + Date start = dao.findById(testData.trip12Id).getCreated(); + Date end = dao.findById(testData.trip15Id).getCreated(); + Collection trips = dao.findCancelledTrips(start, end); + + assertThat(trips.size(), is(4)); + assertThat(map(trips, ITrip::getId), hasItems(testData.trip11Id, testData.trip13Id, testData.trip14Id, testData.trip16Id)); + } + + @Test + public void testFindCanceledEventsForStatusCreatedBetweenStartAndFinish6() { + Date start = dao.findById(testData.trip8Id).getCreated(); + Collection cancelledTrips = dao.findCancelledTrips(start, null); + + assertTrue(cancelledTrips.isEmpty()); + } + + private Date createDate(int year, int month, int day, int hours, int minutes) { + return new GregorianCalendar(year, month, day, hours, minutes).getTime(); + } + +} diff --git a/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_2_3b_02Test.java b/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_2_3b_02Test.java new file mode 100644 index 0000000..74910b2 --- /dev/null +++ b/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_2_3b_02Test.java @@ -0,0 +1,77 @@ +package dst.ass1.jpa.tests; + +import dst.ass1.jpa.dao.ITripDAO; +import dst.ass1.jpa.model.ITrip; +import dst.ass1.jpa.model.TripState; +import org.junit.Before; +import org.junit.Test; + +import javax.persistence.EntityTransaction; +import java.util.Collection; +import java.util.Date; +import java.util.GregorianCalendar; + +import static org.hamcrest.CoreMatchers.is; +import static org.hamcrest.core.IsCollectionContaining.hasItems; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.Assert.assertTrue; + +public class Ass1_2_3b_02Test extends Ass1_TestBase { + + private ITripDAO dao; + + @Before + public void setUp() throws Exception { + dao = daoFactory.createTripDAO(); + + EntityTransaction tx = em.getTransaction(); + tx.begin(); + ITrip trip = dao.findById(testData.trip6Id); + trip.setState(TripState.CANCELLED); + em.persist(trip); + em.flush(); + tx.commit(); + } + + @Test + public void testFindCanceledEventsForStatusCreatedBetweenStartAndFinish() { + Collection trips = dao.findCancelledTrips(null, null); + Collection ids = map(trips, ITrip::getId); + + assertThat(ids.size(), is(8)); + assertThat(ids, hasItems(testData.trip6Id, testData.trip8Id, testData.trip11Id, testData.trip12Id, testData.trip13Id, testData.trip14Id, testData.trip15Id, testData.trip16Id)); + } + + @Test + public void testFindCanceledEventsForStatusCreatedBetweenStartAndFinish2() { + Date start = createDate(2019, 1, 1, 1, 1); + Collection trips = dao.findCancelledTrips(start, null); + Collection ids = map(trips, ITrip::getId); + + assertThat(ids.size(), is(5)); + assertThat(ids, hasItems(testData.trip6Id, testData.trip8Id, testData.trip13Id, testData.trip14Id, testData.trip15Id)); + } + + @Test + public void testFindCanceledEventsForStatusCreatedBetweenStartAndFinish3() { + Date start = dao.findById(testData.trip12Id).getCreated(); + Date end = dao.findById(testData.trip15Id).getCreated(); + Collection trips = dao.findCancelledTrips(start, end); + + assertThat(trips.size(), is(5)); + assertThat(map(trips, ITrip::getId), hasItems(testData.trip6Id, testData.trip11Id, testData.trip13Id, testData.trip14Id, testData.trip16Id)); + } + + @Test + public void testFindCanceledEventsForStatusCreatedBetweenStartAndFinish4() { + Date start = dao.findById(testData.trip8Id).getCreated(); + Collection cancelledTrips = dao.findCancelledTrips(start, null); + + assertTrue(cancelledTrips.isEmpty()); + } + + private Date createDate(int year, int month, int day, int hours, int minutes) { + return new GregorianCalendar(year, month, day, hours, minutes).getTime(); + } + +} diff --git a/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_3_1Test.java b/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_3_1Test.java new file mode 100644 index 0000000..ee6ae53 --- /dev/null +++ b/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_3_1Test.java @@ -0,0 +1,109 @@ +package dst.ass1.jpa.tests; + +import dst.ass1.jpa.ORMService; +import dst.ass1.jpa.model.ILocation; +import dst.ass1.jpa.model.ITrip; +import dst.ass1.jpa.model.TripState; +import org.junit.Rule; +import org.junit.Test; + +import javax.persistence.EntityManager; +import javax.persistence.EntityTransaction; +import java.util.Date; + +import static org.hamcrest.Matchers.greaterThan; +import static org.junit.Assert.assertNotNull; +import static org.hamcrest.MatcherAssert.assertThat; + +public class Ass1_3_1Test { + + @Rule + public ORMService orm = new ORMService(); + + @Test + public void entityListener_prePersistSetsPropertiesCorrectly() throws InterruptedException { + Date then = new Date(); + Thread.sleep(50); + + EntityManager em = orm.getEntityManager(); + + ILocation pickup = orm.getModelFactory().createLocation(); + pickup.setName("name1"); + pickup.setLocationId(1L); + + ILocation destination = orm.getModelFactory().createLocation(); + destination.setName("name2"); + destination.setLocationId(2L); + + + ITrip trip = orm.getModelFactory().createTrip(); + trip.setState(TripState.CREATED); + trip.setPickup(pickup); + trip.setDestination(destination); + + + EntityTransaction tx; + // persist + tx = em.getTransaction(); + tx.begin(); + em.persist(pickup); + em.persist(destination); + em.persist(trip); + em.flush(); + tx.commit(); + + assertNotNull(trip.getCreated()); + assertNotNull(trip.getUpdated()); + + assertThat(trip.getCreated(), greaterThan(then)); + assertThat(trip.getUpdated(), greaterThan(then)); + } + + + @Test + public void entityListener_preUpdateSetsPropertiesCorrectly() throws InterruptedException { + EntityManager em = orm.getEntityManager(); + + ILocation pickup = orm.getModelFactory().createLocation(); + pickup.setName("name1"); + pickup.setLocationId(1L); + + ILocation destination = orm.getModelFactory().createLocation(); + destination.setName("name2"); + destination.setLocationId(2L); + + + ITrip trip = orm.getModelFactory().createTrip(); + trip.setCreated(new Date()); + trip.setUpdated(new Date()); + trip.setState(TripState.CREATED); + trip.setPickup(pickup); + trip.setDestination(destination); + + EntityTransaction tx; + // persist + tx = em.getTransaction(); + tx.begin(); + em.persist(pickup); + em.persist(destination); + em.persist(trip); + em.flush(); + tx.commit(); + + Date then = new Date(); + + Thread.sleep(2000); + + // update + tx = em.getTransaction(); + tx.begin(); + trip.setState(TripState.QUEUED); + em.persist(trip); + em.flush(); + tx.commit(); + + assertNotNull(trip.getUpdated()); + assertThat(trip.getUpdated(), greaterThan(then)); + } + +} diff --git a/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_3_2Test.java b/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_3_2Test.java new file mode 100644 index 0000000..018af74 --- /dev/null +++ b/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_3_2Test.java @@ -0,0 +1,69 @@ +package dst.ass1.jpa.tests; + +import dst.ass1.jpa.ORMService; +import dst.ass1.jpa.dao.IDAOFactory; +import dst.ass1.jpa.listener.DefaultListener; +import dst.ass1.jpa.model.IModelFactory; +import dst.ass1.jpa.model.IVehicle; +import org.junit.Rule; +import org.junit.Test; + +import javax.persistence.EntityManager; +import java.util.List; + +import static org.junit.Assert.*; + +public class Ass1_3_2Test { + + @Rule + public ORMService orm = new ORMService(); + + @Test + public void testDefaultListener() { + DefaultListener.clear(); + + IDAOFactory daoFactory = orm.getDaoFactory(); + IModelFactory modelFactory = orm.getModelFactory(); + EntityManager em = orm.getEntityManager(); + + em.getTransaction().begin(); + + // do some inserts + IVehicle vehicle = modelFactory.createVehicle(); + vehicle.setLicense(TestData.VEHICLE_1_LICENSE); + vehicle.setType(TestData.TYPE_1); + vehicle.setColor(TestData.COLOR_1); + em.persist(vehicle); + em.flush(); + em.remove(vehicle); + em.flush(); + + vehicle = modelFactory.createVehicle(); + vehicle.setLicense(TestData.VEHICLE_2_LICENSE); + vehicle.setType(TestData.TYPE_2); + vehicle.setColor(TestData.COLOR_2); + em.persist(vehicle); + + assertEquals(1, DefaultListener.getRemoveOperations()); + assertTrue(DefaultListener.getPersistOperations() > 0); + assertEquals((double) DefaultListener.getOverallTimeToPersist() / DefaultListener.getPersistOperations(), DefaultListener.getAverageTimeToPersist(), 0.6); + + List vehicles = daoFactory.createVehicleDAO().findAll(); + assertNotNull(vehicles); + assertFalse(vehicles.isEmpty()); + + int loadOperations = DefaultListener.getLoadOperations(); + em.refresh(vehicles.get(0)); + assertEquals(loadOperations + 1, DefaultListener.getLoadOperations()); + + vehicles = daoFactory.createVehicleDAO().findAll(); + assertNotNull(vehicles); + assertFalse(vehicles.isEmpty()); + + vehicles.get(0).setLicense("updated"); + em.persist(vehicles.get(0)); + em.flush(); + + assertEquals(1, DefaultListener.getUpdateOperations()); + } +} diff --git a/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_3_3Test.java b/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_3_3Test.java new file mode 100644 index 0000000..1aa0b4d --- /dev/null +++ b/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_3_3Test.java @@ -0,0 +1,38 @@ +package dst.ass1.jpa.tests; + +import dst.ass1.jpa.interceptor.SQLInterceptor; +import dst.ass1.jpa.util.Constants; +import org.junit.Test; + +import javax.persistence.Query; + +import static org.junit.Assert.assertEquals; + +public class Ass1_3_3Test extends Ass1_TestBase { + + @Test + public void sqlInterceptor_countsSelectsCorrectly() { + em.getTransaction().begin(); + SQLInterceptor.resetCounter(); + assertEquals(0, SQLInterceptor.getSelectCount()); + + Query c = em.createQuery("select v from " + Constants.T_VEHICLE + " v"); + c.getResultList(); + + assertEquals(0, SQLInterceptor.getSelectCount()); + + c = em.createQuery("select distinct l from " + Constants.T_LOCATION + " l"); + c.getResultList(); + + assertEquals(1, SQLInterceptor.getSelectCount()); + + c = em.createQuery("select t from " + Constants.T_TRIP + " t"); + c.getResultList(); + assertEquals(2, SQLInterceptor.getSelectCount()); + + c = em.createQuery("select distinct t from " + Constants.T_TRIP + " t"); + c.getResultList(); + assertEquals(3, SQLInterceptor.getSelectCount()); + } + +} diff --git a/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_Suite.java b/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_Suite.java new file mode 100644 index 0000000..43f5cbb --- /dev/null +++ b/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_Suite.java @@ -0,0 +1,12 @@ +package dst.ass1.jpa.tests; + +import org.junit.runner.RunWith; +import org.junit.runners.Suite; +import org.junit.runners.Suite.SuiteClasses; + +@RunWith(Suite.class) +@SuiteClasses( { + Ass1_1_1_00Test.class, Ass1_1_1_01Test.class, Ass1_1_1_02Test.class, Ass1_1_1_03Test.class, Ass1_1_1_04Test.class, Ass1_1_1_05Test.class, Ass1_1_1_06Test.class, Ass1_1_1_07Test.class, Ass1_1_1_08Test.class, Ass1_1_1_09Test.class, Ass1_1_1_10Test.class, Ass1_1_2_01Test.class, Ass1_1_2_02Test.class, Ass1_2_1aTest.class, Ass1_2_1bTest.class, Ass1_2_1cTest.class, Ass1_2_2Test.class, Ass1_2_3a_01Test.class, Ass1_2_3a_02Test.class, Ass1_2_3b_01Test.class, Ass1_2_3b_02Test.class, Ass1_3_1Test.class, Ass1_3_2Test.class, Ass1_3_3Test.class +}) +public class Ass1_Suite { +} diff --git a/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_TestBase.java b/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_TestBase.java new file mode 100644 index 0000000..54479f7 --- /dev/null +++ b/ass1-jpa/src/test/java/dst/ass1/jpa/tests/Ass1_TestBase.java @@ -0,0 +1,45 @@ +package dst.ass1.jpa.tests; + +import dst.ass1.jpa.DatabaseGateway; +import dst.ass1.jpa.ORMService; +import dst.ass1.jpa.dao.IDAOFactory; +import dst.ass1.jpa.model.IModelFactory; +import org.junit.Before; +import org.junit.Rule; +import org.junit.rules.ErrorCollector; + +import javax.persistence.EntityManager; +import java.util.Collection; +import java.util.List; +import java.util.function.Function; +import java.util.stream.Collectors; + +public class Ass1_TestBase { + + protected final TestData testData = new TestData(); + + @Rule + public ORMService orm = new ORMService(testData); + + @Rule + public ErrorCollector err = new ErrorCollector(); + + // commonly used classes unwrapped from ORMService + protected EntityManager em; + protected IModelFactory modelFactory; + protected IDAOFactory daoFactory; + protected DatabaseGateway db; + + public static List map(Collection collection, Function fn) { + return collection.stream().map(fn).collect(Collectors.toList()); + } + + @Before + public void setUpBase() throws Exception { + em = orm.getEntityManager(); + modelFactory = orm.getModelFactory(); + daoFactory = orm.getDaoFactory(); + db = orm.getDatabaseGateway(); + } + +} diff --git a/ass1-jpa/src/test/java/dst/ass1/jpa/tests/TestData.java b/ass1-jpa/src/test/java/dst/ass1/jpa/tests/TestData.java new file mode 100644 index 0000000..e4492c2 --- /dev/null +++ b/ass1-jpa/src/test/java/dst/ass1/jpa/tests/TestData.java @@ -0,0 +1,1055 @@ +package dst.ass1.jpa.tests; + +import dst.ass1.jpa.ITestData; +import dst.ass1.jpa.model.*; + +import javax.persistence.EntityManager; +import java.math.BigDecimal; +import java.security.MessageDigest; +import java.security.NoSuchAlgorithmException; +import java.time.LocalDate; +import java.time.ZoneId; +import java.util.*; + +public class TestData implements ITestData { + + public static final String RIDER_1_NAME = "rider1"; + public static final String RIDER_2_NAME = "rider2"; + public static final String RIDER_3_NAME = "rider3"; + public static final String RIDER_4_NAME = "rider4"; + + public static final String RIDER_1_EMAIL = "email1"; + public static final String RIDER_2_EMAIL = "email2"; + public static final String RIDER_3_EMAIL = "email3"; + public static final String RIDER_4_EMAIL = "email4"; + + public static final String RIDER_1_PW = "pw1"; + public static final String RIDER_2_PW = "pw2"; + public static final String RIDER_3_PW = "pw3"; + public static final String RIDER_4_PW = "pw4"; + + public static final String RIDER_1_ACCOUNT_NO = "account1"; + public static final String RIDER_2_ACCOUNT_NO = "account2"; + public static final String RIDER_3_ACCOUNT_NO = "account3"; + public static final String RIDER_4_ACCOUNT_NO = "account4"; + + public static final String RIDER_1_BANK_CODE = "bankcode1"; + public static final String RIDER_2_BANK_CODE = "bankcode2"; + public static final String RIDER_3_BANK_CODE = "bankcode3"; + public static final String RIDER_4_BANK_CODE = "bankcode4"; + + public static final Double RIDER_1_AVG_RATING = 4.3; + public static final Double RIDER_2_AVG_RATING = 5.0; + public static final Double RIDER_3_AVG_RATING = 1.0; + public static final Double RIDER_4_AVG_RATING = 2.1; + + public static final String RIDER_1_TEL = "+43000000001"; + public static final String RIDER_2_TEL = "+43000000002"; + public static final String RIDER_3_TEL = "+43000000003"; + public static final String RIDER_4_TEL = "+43000000004"; + + public static final String DRIVER_1_NAME = "driver1"; + public static final String DRIVER_2_NAME = "driver2"; + public static final String DRIVER_3_NAME = "driver3"; + public static final String DRIVER_4_NAME = "driver4"; + public static final String DRIVER_5_NAME = "driver5"; + + public static final String DRIVER_1_TEL = "+43000000011"; + public static final String DRIVER_2_TEL = "+43000000012"; + public static final String DRIVER_3_TEL = "+43000000013"; + public static final String DRIVER_4_TEL = "+43000000014"; + public static final String DRIVER_5_TEL = "+43000000015"; + + public static final Double DRIVER_1_AVG_RATING = 2.3; + public static final Double DRIVER_2_AVG_RATING = 2.0; + public static final Double DRIVER_3_AVG_RATING = 3.9; + public static final Double DRIVER_4_AVG_RATING = 4.09; + public static final Double DRIVER_5_AVG_RATING = 1.5; + + public static final String LOCATION_1_NAME = "location1"; + public static final String LOCATION_2_NAME = "location2"; + public static final String LOCATION_3_NAME = "location3"; + public static final String LOCATION_4_NAME = "location4"; + public static final String LOCATION_5_NAME = "location5"; + + public static final Long LOCATION_1_ID = 1L; + public static final Long LOCATION_2_ID = 2L; + public static final Long LOCATION_3_ID = 3L; + public static final Long LOCATION_4_ID = 4L; + public static final Long LOCATION_5_ID = 5L; + + public static final String ORGANIZATION_1_NAME = "organization1"; + public static final String ORGANIZATION_2_NAME = "organization2"; + public static final String ORGANIZATION_3_NAME = "organization3"; + public static final String ORGANIZATION_4_NAME = "organization4"; + public static final String ORGANIZATION_5_NAME = "organization5"; + public static final String ORGANIZATION_6_NAME = "organization"; + + public static final String PREFERENCES_1_KEY_1 = "key11"; + public static final String PREFERENCES_1_VALUE_1 = "preference11"; + public static final String PREFERENCES_1_KEY_2 = "key12"; + public static final String PREFERENCES_1_VALUE_2 = "preference12"; + public static final String PREFERENCES_2_KEY_1 = "key21"; + public static final String PREFERENCES_2_VALUE_1 = "preference21"; + + public static final String VEHICLE_1_LICENSE = "license1"; + public static final String VEHICLE_2_LICENSE = "license2"; + public static final String VEHICLE_3_LICENSE = "license3"; + public static final String VEHICLE_4_LICENSE = "license4"; + + public static final String COLOR_1 = "yellow"; + public static final String COLOR_2 = "red"; + public static final String COLOR_3 = "green"; + + public static final String TYPE_1 = "type1"; + public static final String TYPE_2 = "type2"; + + public static final String CURRENCY_1 = "currency1"; + public static final String CURRENCY_2 = "currency2"; + public static final String CURRENCY_3 = "currency3"; + + public static final BigDecimal TRIP_INFO_1_MONEY_VALUE = new BigDecimal(330.0); + public static final BigDecimal TRIP_INFO_2_MONEY_VALUE = new BigDecimal(10.0); + public static final BigDecimal TRIP_INFO_3_MONEY_VALUE = new BigDecimal(70.0); + public static final BigDecimal TRIP_INFO_4_MONEY_VALUE = new BigDecimal(23.0); + public static final BigDecimal TRIP_INFO_5_MONEY_VALUE = new BigDecimal(25.0); + public static final BigDecimal TRIP_INFO_17_MONEY_VALUE = new BigDecimal(22.0); + + public static final BigDecimal MATCH_FARE_1 = new BigDecimal(200.0); + public static final BigDecimal MATCH_FARE_2 = new BigDecimal(12.0); + public static final BigDecimal MATCH_FARE_3 = new BigDecimal(70.0); + public static final BigDecimal MATCH_FARE_4 = new BigDecimal(65.0); + public static final BigDecimal MATCH_FARE_5 = new BigDecimal(23.0); + public static final BigDecimal MATCH_FARE_6 = new BigDecimal(30.0); + public static final BigDecimal MATCH_FARE_7 = new BigDecimal(22.0); + public static final BigDecimal MATCH_FARE_17 = new BigDecimal(25.0); + + public static final double TRIP_1_DISTANCE = 33.2; + public static final double TRIP_2_DISTANCE = 0.9; + public static final double TRIP_3_DISTANCE = 2.12; + public static final double TRIP_4_DISTANCE = 10.0; + public static final double TRIP_5_DISTANCE = 8.3; + public static final double TRIP_17_DISTANCE = 11.0; + + public static final Date TRIP_6_CREATED = createDate(2019, 1, 2, 2, 2); + public static final Date TRIP_11_CREATED = createDate(2018, 4, 5, 5, 5); + public static final Date TRIP_12_CREATED = createDate(2017, 0, 2, 2, 2); + public static final Date TRIP_13_CREATED = createDate(2019, 1, 26, 3, 3); + public static final Date TRIP_14_CREATED = createDate(2019, 1, 27, 2, 2); + public static final Date TRIP_15_CREATED = createDate(2019, 1, 28, 8, 9); + public static final Date TRIP_16_CREATED = createDate(2018, 10, 11, 11, 11); + + public Long preferences1Id; + public Long preferences2Id; + public Long preferences3Id; + public Long preferences4Id; + public Long rider1Id; + public Long rider2Id; + public Long rider3Id; + public Long rider4Id; + public Long organization1Id; + public Long organization2Id; + public Long organization3Id; + public Long organization4Id; + public Long organization5Id; + public Long driver1Id; + public Long driver2Id; + public Long driver3Id; + public Long driver4Id; + public IEmploymentKey employmentId1; + public IEmploymentKey employmentId2; + public IEmploymentKey employmentId3; + public IEmploymentKey employmentId4; + public IEmploymentKey employmentId5; + public Long vehicle1Id; + public Long vehicle2Id; + public Long vehicle3Id; + public Long vehicle4Id; + public Long match1Id; + public Long match2Id; + public Long match3Id; + public Long match4Id; + public Long match5Id; + public Long match7Id; + public Long match9Id; + public Long match17Id; + public Long location1Id; + public Long location2Id; + public Long location3Id; + public Long location4Id; + public Long location5Id; + public Long trip1Id; + public Long trip2Id; + public Long trip3Id; + public Long trip4Id; + public Long trip5Id; + public Long trip6Id; + public Long trip7Id; + public Long trip8Id; + public Long trip9Id; + public Long trip10Id; + public Long trip11Id; + public Long trip12Id; + public Long trip13Id; + public Long trip14Id; + public Long trip15Id; + public Long trip16Id; + public Long trip17Id; + public Long tripInfo1Id; + public Long tripInfo2Id; + public Long tripInfo3Id; + public Long tripInfo4Id; + public Long tripInfo5Id; + public Long tripInfo17Id; + + public static Date createDate(int year, int month, int day, int hours, int minutes) { + GregorianCalendar cal = new GregorianCalendar(year, month, day, hours, minutes); + cal.setTimeZone(TimeZone.getTimeZone("UTC")); + return cal.getTime(); + } + + public static Date localDateToDate(LocalDate date) { + return Date.from(date.atStartOfDay(ZoneId.systemDefault()).toInstant()); + } + + @Override + public void insert(IModelFactory modelFactory, EntityManager em) { + MessageDigest md = getMessageDigest(); + + //Money + IMoney total1 = modelFactory.createMoney(); + IMoney total2 = modelFactory.createMoney(); + IMoney total3 = modelFactory.createMoney(); + IMoney total4 = modelFactory.createMoney(); + IMoney total5 = modelFactory.createMoney(); + IMoney total17 = modelFactory.createMoney(); + + total1.setValue(TRIP_INFO_1_MONEY_VALUE); + total2.setValue(TRIP_INFO_2_MONEY_VALUE); + total3.setValue(TRIP_INFO_3_MONEY_VALUE); + total4.setValue(TRIP_INFO_4_MONEY_VALUE); + total5.setValue(TRIP_INFO_5_MONEY_VALUE); + total17.setValue(TRIP_INFO_17_MONEY_VALUE); + + total1.setCurrency(CURRENCY_1); + total2.setCurrency(CURRENCY_2); + total3.setCurrency(CURRENCY_3); + total4.setCurrency(CURRENCY_1); + total5.setCurrency(CURRENCY_2); + total17.setCurrency(CURRENCY_2); + + IMoney fare1 = modelFactory.createMoney(); + IMoney fare2 = modelFactory.createMoney(); + IMoney fare3 = modelFactory.createMoney(); + IMoney fare4 = modelFactory.createMoney(); + IMoney fare5 = modelFactory.createMoney(); + IMoney fare6 = modelFactory.createMoney(); + IMoney fare7 = modelFactory.createMoney(); + IMoney fare17 = modelFactory.createMoney(); + + fare1.setCurrency(CURRENCY_1); + fare2.setCurrency(CURRENCY_2); + fare3.setCurrency(CURRENCY_3); + fare4.setCurrency(CURRENCY_1); + fare5.setCurrency(CURRENCY_2); + fare6.setCurrency(CURRENCY_1); + fare7.setCurrency(CURRENCY_1); + fare17.setCurrency(CURRENCY_2); + + fare1.setValue(MATCH_FARE_1); + fare2.setValue(MATCH_FARE_2); + fare3.setValue(MATCH_FARE_3); + fare4.setValue(MATCH_FARE_4); + fare5.setValue(MATCH_FARE_5); + fare6.setValue(MATCH_FARE_6); + fare7.setValue(MATCH_FARE_7); + fare17.setValue(MATCH_FARE_17); + + + //Preferences + IPreferences preferences1 = modelFactory.createPreferences(); + IPreferences preferences2 = modelFactory.createPreferences(); + IPreferences preferences3 = modelFactory.createPreferences(); + IPreferences preferences4 = modelFactory.createPreferences(); + + preferences1.putData(PREFERENCES_1_KEY_1, PREFERENCES_1_VALUE_1); + preferences1.putData(PREFERENCES_1_KEY_2, PREFERENCES_1_VALUE_2); + preferences2.putData(PREFERENCES_2_KEY_1, PREFERENCES_2_VALUE_1); + + //Riders + IRider rider1 = modelFactory.createRider(); + IRider rider2 = modelFactory.createRider(); + IRider rider3 = modelFactory.createRider(); + IRider rider4 = modelFactory.createRider(); + + rider1.setAccountNo(RIDER_1_ACCOUNT_NO); + rider2.setAccountNo(RIDER_2_ACCOUNT_NO); + rider3.setAccountNo(RIDER_3_ACCOUNT_NO); + rider4.setAccountNo(RIDER_4_ACCOUNT_NO); + + rider1.setBankCode(RIDER_1_BANK_CODE); + rider2.setBankCode(RIDER_2_BANK_CODE); + rider3.setBankCode(RIDER_3_BANK_CODE); + rider4.setBankCode(RIDER_4_BANK_CODE); + + rider1.setEmail(RIDER_1_EMAIL); + rider2.setEmail(RIDER_2_EMAIL); + rider3.setEmail(RIDER_3_EMAIL); + rider4.setEmail(RIDER_4_EMAIL); + + rider1.setPassword(md.digest(RIDER_1_PW.getBytes())); + rider2.setPassword(md.digest(RIDER_2_PW.getBytes())); + rider3.setPassword(md.digest(RIDER_3_PW.getBytes())); + rider4.setPassword(md.digest(RIDER_4_PW.getBytes())); + + rider1.setName(RIDER_1_NAME); + rider2.setName(RIDER_2_NAME); + rider3.setName(RIDER_3_NAME); + rider4.setName(RIDER_4_NAME); + + rider1.setAvgRating(RIDER_1_AVG_RATING); + rider2.setAvgRating(RIDER_2_AVG_RATING); + rider3.setAvgRating(RIDER_3_AVG_RATING); + rider4.setAvgRating(RIDER_4_AVG_RATING); + + rider1.setTel(RIDER_1_TEL); + rider2.setTel(RIDER_2_TEL); + rider3.setTel(RIDER_3_TEL); + rider4.setTel(RIDER_4_TEL); + + rider1.setPreferences(preferences1); + rider2.setPreferences(preferences2); + rider3.setPreferences(preferences3); + rider4.setPreferences(preferences4); + + + //Organizations + IOrganization organization1 = modelFactory.createOrganization(); + IOrganization organization2 = modelFactory.createOrganization(); + IOrganization organization3 = modelFactory.createOrganization(); + IOrganization organization4 = modelFactory.createOrganization(); + IOrganization organization5 = modelFactory.createOrganization(); + + organization1.setName(ORGANIZATION_1_NAME); + organization2.setName(ORGANIZATION_2_NAME); + organization3.setName(ORGANIZATION_3_NAME); + organization4.setName(ORGANIZATION_4_NAME); + organization5.setName(ORGANIZATION_5_NAME); + + organization1.addPart(organization4); + organization1.addPart(organization5); + + organization4.addPartOf(organization1); + organization5.addPartOf(organization1); + + organization4.addPart(organization2); + organization2.addPartOf(organization4); + + organization2.addPart(organization1); + organization1.addPartOf(organization2); + + + //Drivers + IDriver driver1 = modelFactory.createDriver(); + IDriver driver2 = modelFactory.createDriver(); + IDriver driver3 = modelFactory.createDriver(); + IDriver driver4 = modelFactory.createDriver(); + IDriver driver5 = modelFactory.createDriver(); + + driver1.setName(DRIVER_1_NAME); + driver2.setName(DRIVER_2_NAME); + driver3.setName(DRIVER_3_NAME); + driver4.setName(DRIVER_4_NAME); + driver5.setName(DRIVER_5_NAME); + + driver1.setTel(DRIVER_1_TEL); + driver2.setTel(DRIVER_2_TEL); + driver3.setTel(DRIVER_3_TEL); + driver4.setTel(DRIVER_4_TEL); + driver5.setTel(DRIVER_5_TEL); + + driver1.setAvgRating(DRIVER_1_AVG_RATING); + driver2.setAvgRating(DRIVER_2_AVG_RATING); + driver3.setAvgRating(DRIVER_3_AVG_RATING); + driver4.setAvgRating(DRIVER_4_AVG_RATING); + driver5.setAvgRating(DRIVER_5_AVG_RATING); + + //EmploymentKeys + IEmploymentKey employmentKey1 = modelFactory.createEmploymentKey(); + IEmploymentKey employmentKey2 = modelFactory.createEmploymentKey(); + IEmploymentKey employmentKey3 = modelFactory.createEmploymentKey(); + IEmploymentKey employmentKey4 = modelFactory.createEmploymentKey(); + IEmploymentKey employmentKey5 = modelFactory.createEmploymentKey(); + IEmploymentKey employmentKey6 = modelFactory.createEmploymentKey(); + IEmploymentKey employmentKey7 = modelFactory.createEmploymentKey(); + IEmploymentKey employmentKey8 = modelFactory.createEmploymentKey(); + IEmploymentKey employmentKey9 = modelFactory.createEmploymentKey(); + IEmploymentKey employmentKey10 = modelFactory.createEmploymentKey(); + IEmploymentKey employmentKey11 = modelFactory.createEmploymentKey(); + IEmploymentKey employmentKey12 = modelFactory.createEmploymentKey(); + IEmploymentKey employmentKey13 = modelFactory.createEmploymentKey(); + IEmploymentKey employmentKey14 = modelFactory.createEmploymentKey(); + + // Driver 1 + employmentKey1.setDriver(driver1); + employmentKey1.setOrganization(organization1); + + employmentKey5.setDriver(driver1); + employmentKey5.setOrganization(organization2); + + employmentKey6.setDriver(driver1); + employmentKey6.setOrganization(organization3); + + employmentKey7.setDriver(driver1); + employmentKey7.setOrganization(organization4); + + employmentKey8.setDriver(driver1); + employmentKey8.setOrganization(organization5); + + // Driver 2 + employmentKey2.setDriver(driver2); + employmentKey2.setOrganization(organization1); + + employmentKey9.setDriver(driver2); + employmentKey9.setOrganization(organization2); + + // Driver 3 + employmentKey3.setDriver(driver3); + employmentKey3.setOrganization(organization3); + + // Driver 4 + employmentKey4.setDriver(driver4); + employmentKey4.setOrganization(organization4); + + // Driver 5 + employmentKey10.setDriver(driver5); + employmentKey10.setOrganization(organization1); + + employmentKey11.setDriver(driver5); + employmentKey11.setOrganization(organization2); + + employmentKey12.setDriver(driver5); + employmentKey12.setOrganization(organization3); + + employmentKey13.setDriver(driver5); + employmentKey13.setOrganization(organization4); + + employmentKey14.setDriver(driver5); + employmentKey14.setOrganization(organization5); + + + //Employments + IEmployment employment1 = modelFactory.createEmployment(); + IEmployment employment2 = modelFactory.createEmployment(); + IEmployment employment3 = modelFactory.createEmployment(); + IEmployment employment4 = modelFactory.createEmployment(); + IEmployment employment5 = modelFactory.createEmployment(); + IEmployment employment6 = modelFactory.createEmployment(); + IEmployment employment7 = modelFactory.createEmployment(); + IEmployment employment8 = modelFactory.createEmployment(); + IEmployment employment9 = modelFactory.createEmployment(); + IEmployment employment10 = modelFactory.createEmployment(); + IEmployment employment11 = modelFactory.createEmployment(); + IEmployment employment12 = modelFactory.createEmployment(); + IEmployment employment13 = modelFactory.createEmployment(); + IEmployment employment14 = modelFactory.createEmployment(); + + employment1.setActive(true); + employment1.setSince(new Date()); + employment1.setId(employmentKey1); + + + employment2.setActive(true); + employment2.setSince(createDate(2017, 4, 3, 2, 2)); + employment2.setId(employmentKey2); + + employment3.setActive(false); + employment3.setSince(createDate(2018, 8, 23, 4, 45)); + employment3.setId(employmentKey3); + + employment4.setActive(true); + employment4.setSince(createDate(2014, 7, 19, 1, 1)); + employment4.setId(employmentKey4); + + employment5.setActive(false); + employment5.setSince(localDateToDate(LocalDate.now().minusDays(2))); + employment5.setId(employmentKey5); + + employment6.setActive(true); + employment6.setSince(createDate(2018, 2, 2, 2, 2)); + employment6.setId(employmentKey6); + + employment7.setActive(true); + employment7.setSince(createDate(2018, 1, 1, 1, 1)); + employment7.setId(employmentKey7); + + employment8.setActive(true); + Date oneMonthAndDayAgo = localDateToDate(LocalDate.now().minusDays(32)); + employment8.setSince(oneMonthAndDayAgo); + employment8.setId(employmentKey8); + + employment9.setActive(true); + employment9.setSince(oneMonthAndDayAgo); + employment9.setId(employmentKey9); + + employment10.setActive(true); + employment10.setSince(localDateToDate(LocalDate.now().minusDays(2))); + employment10.setId(employmentKey10); + + employment11.setActive(true); + employment11.setSince(localDateToDate(LocalDate.now().minusDays(2))); + employment11.setId(employmentKey11); + + employment12.setActive(true); + employment12.setSince(localDateToDate(LocalDate.now().minusDays(2))); + employment12.setId(employmentKey12); + + employment13.setActive(true); + employment13.setSince(localDateToDate(LocalDate.now().minusDays(2))); + employment13.setId(employmentKey13); + + employment14.setActive(true); + employment14.setSince(localDateToDate(LocalDate.now().minusDays(2))); + employment14.setId(employmentKey14); + + driver1.addEmployment(employment1); + driver1.addEmployment(employment5); + driver1.addEmployment(employment6); + driver1.addEmployment(employment7); + driver1.addEmployment(employment8); + + driver2.addEmployment(employment2); + driver2.addEmployment(employment9); + + driver3.addEmployment(employment3); + + driver4.addEmployment(employment4); + + driver5.addEmployment(employment10); + driver5.addEmployment(employment11); + driver5.addEmployment(employment12); + driver5.addEmployment(employment13); + driver5.addEmployment(employment14); + + + organization1.addEmployment(employment1); + organization1.addEmployment(employment2); + organization1.addEmployment(employment10); + + organization2.addEmployment(employment5); + organization2.addEmployment(employment9); + organization2.addEmployment(employment11); + + organization3.addEmployment(employment3); + organization3.addEmployment(employment6); + organization3.addEmployment(employment12); + + organization4.addEmployment(employment4); + organization4.addEmployment(employment7); + organization4.addEmployment(employment13); + + organization5.addEmployment(employment8); + organization5.addEmployment(employment14); + + //Vehicles + IVehicle vehicle1 = modelFactory.createVehicle(); + IVehicle vehicle2 = modelFactory.createVehicle(); + IVehicle vehicle3 = modelFactory.createVehicle(); + IVehicle vehicle4 = modelFactory.createVehicle(); + + vehicle1.setLicense(VEHICLE_1_LICENSE); + vehicle2.setLicense(VEHICLE_2_LICENSE); + vehicle3.setLicense(VEHICLE_3_LICENSE); + vehicle4.setLicense(VEHICLE_4_LICENSE); + + vehicle1.setColor(COLOR_1); + vehicle2.setColor(COLOR_2); + vehicle3.setColor(COLOR_3); + vehicle4.setColor(COLOR_1); + + vehicle1.setType(TYPE_1); + vehicle2.setType(TYPE_1); + vehicle3.setType(TYPE_2); + vehicle4.setType(TYPE_1); + + driver1.setVehicle(vehicle1); + driver2.setVehicle(vehicle2); + driver3.setVehicle(vehicle3); + driver4.setVehicle(vehicle4); + driver5.setVehicle(vehicle1); + + List vehiclesOrganization1 = new LinkedList<>(); + List vehiclesOrganization2 = new LinkedList<>(); + + vehiclesOrganization1.add(vehicle1); + vehiclesOrganization1.add(vehicle2); + vehiclesOrganization1.add(vehicle3); + + vehiclesOrganization2.add(vehicle4); + + organization1.setVehicles(vehiclesOrganization1); + organization2.setVehicles(vehiclesOrganization2); + + //Locations + ILocation location1 = modelFactory.createLocation(); + ILocation location2 = modelFactory.createLocation(); + ILocation location3 = modelFactory.createLocation(); + ILocation location4 = modelFactory.createLocation(); + ILocation location5 = modelFactory.createLocation(); + + location1.setName(LOCATION_1_NAME); + location2.setName(LOCATION_2_NAME); + location3.setName(LOCATION_3_NAME); + location4.setName(LOCATION_4_NAME); + location5.setName(LOCATION_5_NAME); + + location1.setLocationId(LOCATION_1_ID); + location2.setLocationId(LOCATION_2_ID); + location3.setLocationId(LOCATION_3_ID); + location4.setLocationId(LOCATION_4_ID); + location5.setLocationId(LOCATION_5_ID); + + //Matches + IMatch match1 = modelFactory.createMatch(); + IMatch match2 = modelFactory.createMatch(); + IMatch match3 = modelFactory.createMatch(); + IMatch match4 = modelFactory.createMatch(); + IMatch match5 = modelFactory.createMatch(); + IMatch match7 = modelFactory.createMatch(); + IMatch match9 = modelFactory.createMatch(); + IMatch match17 = modelFactory.createMatch(); + + match1.setDate(new Date()); + match2.setDate(new Date()); + match3.setDate(new Date()); + match4.setDate(new Date()); + match5.setDate(new Date()); + match7.setDate(new Date()); + match9.setDate(new Date()); + match17.setDate(new Date()); + + match1.setFare(fare1); + match2.setFare(fare2); + match3.setFare(fare3); + match4.setFare(fare4); + match5.setFare(fare5); + match7.setFare(fare6); + match9.setFare(fare7); + match17.setFare(fare17); + + match1.setDriver(driver1); + match2.setDriver(driver1); + match3.setDriver(driver1); + match4.setDriver(driver2); + match5.setDriver(driver3); + match7.setDriver(driver4); + match9.setDriver(driver1); + match17.setDriver(driver1); + + match1.setVehicle(vehicle1); + match2.setVehicle(vehicle1); + match3.setVehicle(vehicle1); + match4.setVehicle(vehicle2); + match5.setVehicle(vehicle3); + match7.setVehicle(vehicle4); + match9.setVehicle(vehicle1); + match17.setVehicle(vehicle1); + + + //Trips + ITrip trip1 = modelFactory.createTrip(); + ITrip trip2 = modelFactory.createTrip(); + ITrip trip3 = modelFactory.createTrip(); + ITrip trip4 = modelFactory.createTrip(); + ITrip trip5 = modelFactory.createTrip(); + ITrip trip6 = modelFactory.createTrip(); + ITrip trip7 = modelFactory.createTrip(); + ITrip trip8 = modelFactory.createTrip(); + ITrip trip9 = modelFactory.createTrip(); + ITrip trip10 = modelFactory.createTrip(); + ITrip trip11 = modelFactory.createTrip(); + ITrip trip12 = modelFactory.createTrip(); + ITrip trip13 = modelFactory.createTrip(); + ITrip trip14 = modelFactory.createTrip(); + ITrip trip15 = modelFactory.createTrip(); + ITrip trip16 = modelFactory.createTrip(); + ITrip trip17 = modelFactory.createTrip(); + + trip1.setCreated(new Date()); + trip1.setUpdated(new Date()); + trip2.setCreated(new Date()); + trip2.setUpdated(new Date()); + trip3.setCreated(new Date()); + trip3.setUpdated(new Date()); + trip4.setCreated(new Date()); + trip4.setUpdated(new Date()); + trip5.setCreated(new Date()); + trip5.setUpdated(new Date()); + trip6.setCreated(TRIP_6_CREATED); + trip6.setUpdated(new Date()); + trip7.setCreated(new Date()); + trip7.setUpdated(new Date()); + trip8.setCreated(new Date()); + trip8.setUpdated(new Date()); + trip9.setCreated(new Date()); + trip9.setUpdated(new Date()); + trip10.setCreated(new Date()); + trip10.setUpdated(new Date()); + trip11.setCreated(TRIP_11_CREATED); + trip11.setUpdated(new Date()); + trip12.setCreated(TRIP_12_CREATED); + trip12.setUpdated(new Date()); + trip13.setCreated(TRIP_13_CREATED); + trip13.setUpdated(new Date()); + trip14.setCreated(TRIP_14_CREATED); + trip14.setUpdated(new Date()); + trip15.setCreated(TRIP_15_CREATED); + trip15.setUpdated(new Date()); + trip16.setCreated(TRIP_16_CREATED); + trip16.setUpdated(new Date()); + trip17.setCreated(new Date()); + trip17.setUpdated(new Date()); + + + trip1.setState(TripState.COMPLETED); + trip2.setState(TripState.COMPLETED); + trip3.setState(TripState.COMPLETED); + trip4.setState(TripState.COMPLETED); + trip5.setState(TripState.COMPLETED); + trip6.setState(TripState.CREATED); + trip7.setState(TripState.APPROACHING); + trip8.setState(TripState.CANCELLED); + trip9.setState(TripState.IN_PROGRESS); + trip10.setState(TripState.QUEUED); + trip11.setState(TripState.CANCELLED); + trip12.setState(TripState.CANCELLED); + trip13.setState(TripState.CANCELLED); + trip14.setState(TripState.CANCELLED); + trip15.setState(TripState.CANCELLED); + trip16.setState(TripState.CANCELLED); + trip17.setState(TripState.COMPLETED); + + trip1.setPickup(location1); + trip2.setPickup(location1); + trip3.setPickup(location1); + trip4.setPickup(location3); + trip5.setPickup(location4); + trip6.setPickup(location5); + trip7.setPickup(location1); + trip8.setPickup(location1); + trip9.setPickup(location2); + trip10.setPickup(location3); + trip11.setPickup(location3); + trip12.setPickup(location3); + trip13.setPickup(location3); + trip14.setPickup(location3); + trip15.setPickup(location3); + trip16.setPickup(location3); + trip17.setPickup(location3); + + + trip1.setDestination(location2); + trip2.setDestination(location2); + trip3.setDestination(location2); + trip4.setDestination(location1); + trip5.setDestination(location4); + trip6.setDestination(location1); + trip7.setDestination(location3); + trip8.setDestination(location4); + trip9.setDestination(location5); + trip10.setDestination(location1); + trip11.setDestination(location1); + trip12.setDestination(location1); + trip13.setDestination(location1); + trip14.setDestination(location1); + trip15.setDestination(location1); + trip16.setDestination(location1); + trip17.setDestination(location1); + + List stopsTrip1 = new LinkedList<>(); + stopsTrip1.add(location3); + stopsTrip1.add(location4); + stopsTrip1.add(location5); + trip1.setStops(stopsTrip1); + + List stopsTrip2 = new LinkedList<>(); + stopsTrip2.add(location3); + trip2.setStops(stopsTrip2); + + List stopsTrip6 = new LinkedList<>(); + stopsTrip6.add(location2); + stopsTrip6.add(location3); + stopsTrip6.add(location4); + trip6.setStops(stopsTrip6); + + List stopsTrip10 = new LinkedList<>(); + stopsTrip10.add(location4); + trip10.setStops(stopsTrip10); + + trip1.setRider(rider1); + trip2.setRider(rider2); + trip3.setRider(rider3); + trip4.setRider(rider2); + trip5.setRider(rider1); + trip6.setRider(rider4); + trip7.setRider(rider3); + trip8.setRider(rider2); + trip9.setRider(rider1); + trip10.setRider(rider2); + trip17.setRider(rider3); + + + List tripsRider1 = new LinkedList<>(); + tripsRider1.add(trip1); + tripsRider1.add(trip5); + tripsRider1.add(trip9); + rider1.setTrips(tripsRider1); + + List tripsRider2 = new LinkedList<>(); + tripsRider2.add(trip2); + tripsRider2.add(trip4); + tripsRider2.add(trip8); + tripsRider2.add(trip10); + rider2.setTrips(tripsRider2); + + List tripsRider3 = new LinkedList<>(); + tripsRider3.add(trip3); + tripsRider3.add(trip7); + tripsRider3.add(trip17); + rider3.setTrips(tripsRider3); + + List tripsRider4 = new LinkedList<>(); + tripsRider4.add(trip6); + rider4.setTrips(tripsRider4); + + trip1.setMatch(match1); + trip2.setMatch(match2); + trip3.setMatch(match3); + trip4.setMatch(match4); + trip5.setMatch(match5); + trip7.setMatch(match7); + trip9.setMatch(match9); + trip17.setMatch(match17); + + match1.setTrip(trip1); + match2.setTrip(trip2); + match3.setTrip(trip3); + match4.setTrip(trip4); + match5.setTrip(trip5); + match7.setTrip(trip7); + match9.setTrip(trip9); + match17.setTrip(trip17); + + //TripInfos + ITripInfo tripInfo1 = modelFactory.createTripInfo(); + ITripInfo tripInfo2 = modelFactory.createTripInfo(); + ITripInfo tripInfo3 = modelFactory.createTripInfo(); + ITripInfo tripInfo4 = modelFactory.createTripInfo(); + ITripInfo tripInfo5 = modelFactory.createTripInfo(); + ITripInfo tripInfo17 = modelFactory.createTripInfo(); + + LocalDate now = LocalDate.now(); + tripInfo1.setCompleted(localDateToDate(now.minusDays(10))); + tripInfo2.setCompleted(localDateToDate(now.minusDays(1))); + tripInfo3.setCompleted(localDateToDate(now.minusDays(20))); + tripInfo4.setCompleted(localDateToDate(now.minusDays(29))); + tripInfo5.setCompleted(localDateToDate(now.minusDays(30))); + tripInfo17.setCompleted(localDateToDate(now.minusDays(31))); + + tripInfo1.setDistance(TRIP_1_DISTANCE); + tripInfo2.setDistance(TRIP_2_DISTANCE); + tripInfo3.setDistance(TRIP_3_DISTANCE); + tripInfo4.setDistance(TRIP_4_DISTANCE); + tripInfo5.setDistance(TRIP_5_DISTANCE); + tripInfo17.setDistance(TRIP_17_DISTANCE); + + tripInfo1.setTotal(total1); + tripInfo2.setTotal(total2); + tripInfo3.setTotal(total3); + tripInfo4.setTotal(total4); + tripInfo5.setTotal(total5); + tripInfo17.setTotal(total17); + + tripInfo1.setDriverRating(4); + tripInfo2.setDriverRating(3); + tripInfo3.setDriverRating(2); + tripInfo4.setDriverRating(1); + tripInfo5.setDriverRating(6); + tripInfo17.setDriverRating(6); + + tripInfo1.setRiderRating(2); + tripInfo2.setRiderRating(5); + tripInfo3.setRiderRating(3); + tripInfo4.setRiderRating(6); + tripInfo5.setRiderRating(1); + tripInfo17.setRiderRating(1); + + tripInfo1.setTrip(trip1); + tripInfo2.setTrip(trip2); + tripInfo3.setTrip(trip3); + tripInfo4.setTrip(trip4); + tripInfo5.setTrip(trip5); + tripInfo17.setTrip(trip17); + + trip1.setTripInfo(tripInfo1); + trip2.setTripInfo(tripInfo2); + trip3.setTripInfo(tripInfo3); + trip4.setTripInfo(tripInfo4); + trip5.setTripInfo(tripInfo5); + trip17.setTripInfo(tripInfo17); + + em.persist(location1); + em.persist(location2); + em.persist(location3); + em.persist(location4); + em.persist(location5); + em.persist(preferences1); + em.persist(preferences2); + em.persist(preferences3); + em.persist(preferences4); + em.persist(rider1); + em.persist(rider2); + em.persist(rider3); + em.persist(rider4); + em.persist(vehicle1); + em.persist(vehicle2); + em.persist(vehicle3); + em.persist(vehicle4); + em.persist(organization1); + em.persist(organization2); + em.persist(organization3); + em.persist(organization4); + em.persist(organization5); + em.persist(driver1); + em.persist(driver2); + em.persist(driver3); + em.persist(driver4); + em.persist(driver5); + em.persist(employment1); + em.persist(employment2); + em.persist(employment3); + em.persist(employment4); + em.persist(employment5); + em.persist(employment6); + em.persist(employment7); + em.persist(employment8); + em.persist(employment9); + em.persist(employment10); + em.persist(employment11); + em.persist(employment12); + em.persist(employment13); + em.persist(employment14); + em.persist(trip1); + em.persist(trip2); + em.persist(trip3); + em.persist(trip4); + em.persist(trip5); + em.persist(trip6); + em.persist(trip7); + em.persist(trip8); + em.persist(trip9); + em.persist(trip10); + em.persist(trip11); + em.persist(trip12); + em.persist(trip13); + em.persist(trip14); + em.persist(trip15); + em.persist(trip16); + em.persist(trip17); + em.persist(match1); + em.persist(match2); + em.persist(match3); + em.persist(match4); + em.persist(match5); + em.persist(match7); + em.persist(match9); + em.persist(match17); + em.persist(tripInfo1); + em.persist(tripInfo2); + em.persist(tripInfo3); + em.persist(tripInfo4); + em.persist(tripInfo5); + em.persist(tripInfo17); + + trip6.setCreated(TRIP_6_CREATED); + trip11.setCreated(TRIP_11_CREATED); + trip12.setCreated(TRIP_12_CREATED); + trip13.setCreated(TRIP_13_CREATED); + trip14.setCreated(TRIP_14_CREATED); + trip15.setCreated(TRIP_15_CREATED); + trip16.setCreated(TRIP_16_CREATED); + + preferences1Id = preferences1.getId(); + preferences2Id = preferences2.getId(); + preferences3Id = preferences3.getId(); + preferences4Id = preferences4.getId(); + rider1Id = rider1.getId(); + rider2Id = rider2.getId(); + rider3Id = rider3.getId(); + rider4Id = rider4.getId(); + vehicle1Id = vehicle1.getId(); + vehicle2Id = vehicle2.getId(); + vehicle3Id = vehicle3.getId(); + vehicle4Id = vehicle4.getId(); + organization1Id = organization1.getId(); + organization2Id = organization2.getId(); + organization3Id = organization3.getId(); + organization4Id = organization4.getId(); + organization5Id = organization5.getId(); + driver1Id = driver1.getId(); + driver2Id = driver2.getId(); + driver3Id = driver3.getId(); + driver4Id = driver4.getId(); + employmentId1 = employment1.getId(); + employmentId2 = employment2.getId(); + employmentId3 = employment3.getId(); + employmentId4 = employment4.getId(); + employmentId5 = employment5.getId(); + match1Id = match1.getId(); + match2Id = match2.getId(); + match3Id = match3.getId(); + match4Id = match4.getId(); + match5Id = match5.getId(); + match7Id = match7.getId(); + match9Id = match9.getId(); + match17Id = match9.getId(); + location1Id = location1.getId(); + location2Id = location2.getId(); + location3Id = location3.getId(); + location4Id = location4.getId(); + location5Id = location5.getId(); + trip1Id = trip1.getId(); + trip2Id = trip2.getId(); + trip3Id = trip3.getId(); + trip4Id = trip4.getId(); + trip5Id = trip5.getId(); + trip6Id = trip6.getId(); + trip7Id = trip7.getId(); + trip8Id = trip8.getId(); + trip9Id = trip9.getId(); + trip10Id = trip10.getId(); + trip11Id = trip11.getId(); + trip12Id = trip12.getId(); + trip13Id = trip13.getId(); + trip14Id = trip14.getId(); + trip15Id = trip15.getId(); + trip16Id = trip16.getId(); + trip17Id = trip17.getId(); + tripInfo1Id = tripInfo1.getId(); + tripInfo2Id = tripInfo2.getId(); + tripInfo3Id = tripInfo3.getId(); + tripInfo4Id = tripInfo4.getId(); + tripInfo5Id = tripInfo5.getId(); + tripInfo17Id = tripInfo5.getId(); + + em.flush(); + } + + private MessageDigest getMessageDigest() { + try { + return MessageDigest.getInstance("SHA1"); + } catch (NoSuchAlgorithmException e) { + throw new IllegalStateException(e); + } + } +} diff --git a/ass1-jpa/src/test/java/dst/ass1/jpa/tests/UniqueConstraintTester.java b/ass1-jpa/src/test/java/dst/ass1/jpa/tests/UniqueConstraintTester.java new file mode 100644 index 0000000..99e70f0 --- /dev/null +++ b/ass1-jpa/src/test/java/dst/ass1/jpa/tests/UniqueConstraintTester.java @@ -0,0 +1,57 @@ +package dst.ass1.jpa.tests; + +import org.hibernate.exception.ConstraintViolationException; + +import javax.persistence.EntityManager; +import javax.persistence.EntityTransaction; +import javax.persistence.PersistenceException; +import java.util.function.Consumer; +import java.util.function.Supplier; + +import static org.junit.Assert.fail; + +/** + * Tests a unique constraint by creating two instances of an entity, calling the same value setter on each entity, + * and finally trying to persist them. + * + * @param the entity type + */ +public class UniqueConstraintTester { + + private Consumer valueSetter; + private E e1; + private E e2; + + public UniqueConstraintTester(E e1, E e2, Consumer valueSetter) { + this.e1 = e1; + this.e2 = e2; + this.valueSetter = valueSetter; + } + + public UniqueConstraintTester(Supplier entityFactory, Consumer valueSetter) { + this(entityFactory.get(), entityFactory.get(), valueSetter); + } + + public void run(EntityManager em) { + EntityTransaction tx = em.getTransaction(); + if (!tx.isActive()) { + tx.begin(); + } + + valueSetter.accept(e1); + em.persist(e1); + em.flush(); + + try { + valueSetter.accept(e2); + em.persist(e2); + em.flush(); + fail("Missing unique constraint in " + e2.getClass()); + } catch (PersistenceException e) { + Throwable cause = e.getCause(); + if (!(cause instanceof ConstraintViolationException)) { + fail("Missing unique constraint in " + e2.getClass()); + } + } + } +} diff --git a/ass1-jpa/src/test/resources/logback.xml b/ass1-jpa/src/test/resources/logback.xml new file mode 100644 index 0000000..0e0ca75 --- /dev/null +++ b/ass1-jpa/src/test/resources/logback.xml @@ -0,0 +1,16 @@ + + + + + + %d{yyyy-MM-dd HH:mm:ss.SSS} - %highlight(%5p) [%12.12thread] %cyan(%-40.40logger{39}): %m%n + + + + + + + + + + diff --git a/ass1-kv/pom.xml b/ass1-kv/pom.xml new file mode 100644 index 0000000..4f5dcd3 --- /dev/null +++ b/ass1-kv/pom.xml @@ -0,0 +1,27 @@ + + + + 4.0.0 + + + at.ac.tuwien.infosys.dst + dst + 2021.1 + .. + + + ass1-kv + + jar + + DST :: Assignment 1 :: Key-Value Store + + + + redis.clients + jedis + + + + diff --git a/ass1-kv/src/main/java/dst/ass1/kv/ISessionManager.java b/ass1-kv/src/main/java/dst/ass1/kv/ISessionManager.java new file mode 100644 index 0000000..c911073 --- /dev/null +++ b/ass1-kv/src/main/java/dst/ass1/kv/ISessionManager.java @@ -0,0 +1,69 @@ +package dst.ass1.kv; + +public interface ISessionManager { + + /** + * Creates a new session id and stores the userId and session timeout under the given id in the session store. + * + * @param userId the user to create the session for + * @param timeToLive the session timeout after which the session expires in seconds + * @return the session id. + * @throws SessionCreationFailedException if the session couldn't be created, e.g., due to a failed transaction + */ + String createSession(Long userId, int timeToLive) throws SessionCreationFailedException; + + /** + * Sets a key--value pair in the given session. + * + * @param sessionId the session to store the variable in + * @param key the name of the variable + * @param value the value + * @throws SessionNotFoundException if the session wasn't found + */ + void setSessionVariable(String sessionId, String key, String value) throws SessionNotFoundException; + + /** + * Returns the value of the given session variable. + * + * @param sessionId the session id + * @param key the name of the variable + * @return the variable value, or null if it doesn't exist + * @throws SessionNotFoundException if the given session id has expired or doesn't exist + */ + String getSessionVariable(String sessionId, String key) throws SessionNotFoundException; + + /** + * Returns the user to whom the given session belongs. + * + * @param sessionId the session id + * @return the user id + * @throws SessionNotFoundException if the given session id has expired or doesn't exist + */ + Long getUserId(String sessionId) throws SessionNotFoundException; + + /** + * Returns the current time-to-live for the given session. + * + * @param sessionId the session id + * @return the session ttl in seconds + * @throws SessionNotFoundException if the given session id has expired or doesn't exist + */ + int getTimeToLive(String sessionId) throws SessionNotFoundException; + + /** + * Checks whether the given user has an open session, if so, the session id is returned (and the timeout + * parameter ignored), otherwise a new session is created with the given timeout and the newly generated id is + * returned. + * + * @param userId the user to require the session for + * @param timeToLive the session timeout after which the session expires in seconds + * @return the session id. + * @throws SessionCreationFailedException if the session couldn't be created, e.g., due to a failed transaction + */ + String requireSession(Long userId, int timeToLive) throws SessionCreationFailedException; + + /** + * Closes whatever underlying connection is required to maintain the session manager. + */ + void close(); +} diff --git a/ass1-kv/src/main/java/dst/ass1/kv/ISessionManagerFactory.java b/ass1-kv/src/main/java/dst/ass1/kv/ISessionManagerFactory.java new file mode 100644 index 0000000..e4cc967 --- /dev/null +++ b/ass1-kv/src/main/java/dst/ass1/kv/ISessionManagerFactory.java @@ -0,0 +1,13 @@ +package dst.ass1.kv; + +import java.util.Properties; + +public interface ISessionManagerFactory { + /** + * Creates an implementation of an {@link ISessionManager}. + * + * @param properties the properties to use for instantiation + * @return a session manager object + */ + ISessionManager createSessionManager(Properties properties); +} diff --git a/ass1-kv/src/main/java/dst/ass1/kv/SessionCreationFailedException.java b/ass1-kv/src/main/java/dst/ass1/kv/SessionCreationFailedException.java new file mode 100644 index 0000000..b571a94 --- /dev/null +++ b/ass1-kv/src/main/java/dst/ass1/kv/SessionCreationFailedException.java @@ -0,0 +1,25 @@ +package dst.ass1.kv; + +/** + * Exception indicating that a request to create a new session could not be fulfilled. + */ +public class SessionCreationFailedException extends Exception { + + private static final long serialVersionUID = 1L; + + public SessionCreationFailedException() { + } + + public SessionCreationFailedException(String message) { + super(message); + } + + public SessionCreationFailedException(String message, Throwable cause) { + super(message, cause); + } + + public SessionCreationFailedException(Throwable cause) { + super(cause); + } + +} diff --git a/ass1-kv/src/main/java/dst/ass1/kv/SessionNotFoundException.java b/ass1-kv/src/main/java/dst/ass1/kv/SessionNotFoundException.java new file mode 100644 index 0000000..a548198 --- /dev/null +++ b/ass1-kv/src/main/java/dst/ass1/kv/SessionNotFoundException.java @@ -0,0 +1,24 @@ +package dst.ass1.kv; + +/** + * Exception to indicate that this is not the session you are looking for. + */ +public class SessionNotFoundException extends Exception { + + private static final long serialVersionUID = 1L; + + public SessionNotFoundException() { + } + + public SessionNotFoundException(String message) { + super(message); + } + + public SessionNotFoundException(String message, Throwable cause) { + super(message, cause); + } + + public SessionNotFoundException(Throwable cause) { + super(cause); + } +} diff --git a/ass1-kv/src/main/java/dst/ass1/kv/impl/SessionManagerFactory.java b/ass1-kv/src/main/java/dst/ass1/kv/impl/SessionManagerFactory.java new file mode 100644 index 0000000..06b84d7 --- /dev/null +++ b/ass1-kv/src/main/java/dst/ass1/kv/impl/SessionManagerFactory.java @@ -0,0 +1,17 @@ +package dst.ass1.kv.impl; + +import dst.ass1.kv.ISessionManager; +import dst.ass1.kv.ISessionManagerFactory; + +import java.util.Properties; + +public class SessionManagerFactory implements ISessionManagerFactory { + + @Override + public ISessionManager createSessionManager(Properties properties) { + // TODO + // read "redis.host" and "redis.port" from the properties + + return null; + } +} diff --git a/ass1-kv/src/test/java/dst/ass1/kv/RedisCleaner.java b/ass1-kv/src/test/java/dst/ass1/kv/RedisCleaner.java new file mode 100644 index 0000000..6f778d8 --- /dev/null +++ b/ass1-kv/src/test/java/dst/ass1/kv/RedisCleaner.java @@ -0,0 +1,60 @@ +package dst.ass1.kv; + +import org.junit.rules.ExternalResource; +import redis.clients.jedis.Jedis; + +import java.io.IOException; +import java.io.InputStream; +import java.util.Properties; + +/** + * Drops the entire key space of a redis instance before and after a test run. + */ +public class RedisCleaner extends ExternalResource { + + private Properties properties; + private Jedis jedis; + + @Override + protected void before() throws IOException { + properties = loadProperties(); + + String host = properties.getProperty("redis.host"); + int port = Integer.parseInt(properties.getProperty("redis.port")); + jedis = new Jedis(host, port); + + // completely clear the redis instance before each test + jedis.flushAll(); + } + + @Override + protected void after() { + // completely clear the redis instance after each test + try { + jedis.flushAll(); + } finally { + // close the connection pool + jedis.close(); + } + } + + /** + * @return loaded redis properties + */ + public Properties getProperties() { + return properties; + } + + public Jedis getJedis() { + return jedis; + } + + private Properties loadProperties() throws IOException { + Properties properties = new Properties(); + try (InputStream in = getClass().getClassLoader().getResourceAsStream("redis.properties")) { + properties.load(in); + } + return properties; + } + +} diff --git a/ass1-kv/src/test/java/dst/ass1/kv/tests/Ass1_5_1Test.java b/ass1-kv/src/test/java/dst/ass1/kv/tests/Ass1_5_1Test.java new file mode 100644 index 0000000..0dccd79 --- /dev/null +++ b/ass1-kv/src/test/java/dst/ass1/kv/tests/Ass1_5_1Test.java @@ -0,0 +1,102 @@ +package dst.ass1.kv.tests; + +import dst.ass1.kv.ISessionManager; +import dst.ass1.kv.ISessionManagerFactory; +import dst.ass1.kv.RedisCleaner; +import dst.ass1.kv.SessionNotFoundException; +import dst.ass1.kv.impl.SessionManagerFactory; +import org.junit.After; +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; + +import static org.hamcrest.Matchers.*; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.junit.Assert.*; + +public class Ass1_5_1Test { + + @Rule + public RedisCleaner redisRule = new RedisCleaner(); + + private ISessionManager sessionManager; + + @Before + public void setUp() { + ISessionManagerFactory sessionManagerFactory = new SessionManagerFactory(); + + sessionManager = sessionManagerFactory.createSessionManager(redisRule.getProperties()); + } + + @After + public void tearDown() { + sessionManager.close(); + } + + @Test + public void createSession_createsSessionId() throws Exception { + String sessionId = sessionManager.createSession(1337L, 15000); + assertNotNull(sessionId); + } + + @Test + public void getAndSetSessionVariable_behavesCorrectly() throws Exception { + String sessionId = sessionManager.createSession(1337L, 15000); + sessionManager.setSessionVariable(sessionId, "f00", "bar"); + assertEquals("bar", sessionManager.getSessionVariable(sessionId, "f00")); + } + + @Test(expected = SessionNotFoundException.class) + public void setSessionVariable_forNonExistingSession_throwsSessionNotFoundException() throws Exception { + sessionManager.setSessionVariable("nonExistingSessionId", "f00", "bar"); + } + + @Test(expected = SessionNotFoundException.class) + public void getSessionVariable_forNonExistingSession_throwsSessionNotFoundException() throws Exception { + sessionManager.getSessionVariable("nonExistingSessionId", "f00"); + } + + @Test + public void getSessionVariable_onNonExistingVariable_returnsNull() throws Exception { + String sessionId = sessionManager.createSession(1337L, 15000); + String value = sessionManager.getSessionVariable(sessionId, "f00"); + assertNull(value); + } + + @Test + public void getUserId_returnsCorrectUserID() throws Exception { + Long userId = 1337L; + String sessionId = sessionManager.createSession(userId, 15000); + assertEquals(userId, sessionManager.getUserId(sessionId)); + } + + @Test(expected = SessionNotFoundException.class) + public void getUserId_forNonExistingSession_throwsException() throws Exception { + sessionManager.getUserId("nonExistingSessionId"); + } + + @Test + public void getTimeToLive_returnsCorrectValue() throws Exception { + String sessionId = sessionManager.createSession(1337L, 60); + int ttl = sessionManager.getTimeToLive(sessionId); + assertThat(ttl, allOf(greaterThan(57), lessThan(61))); + } + + @Test + public void getTimeToLive_afterExpiry_throwsSessionNotFoundException() throws Exception { + String sessionId = sessionManager.createSession(1337L, 2); + int ttl = sessionManager.getTimeToLive(sessionId); + assertThat(ttl, greaterThan(0)); + Thread.sleep(3000); + + assertThrows(SessionNotFoundException.class, () -> { + sessionManager.getTimeToLive(sessionId); + }); + } + + @Test(expected = SessionNotFoundException.class) + public void getTimeToLive_forNonExistingSession_throwsSessionNotFoundException() throws Exception { + sessionManager.getTimeToLive("nonExistingSessionId"); + } + +} diff --git a/ass1-kv/src/test/java/dst/ass1/kv/tests/Ass1_5_2Test.java b/ass1-kv/src/test/java/dst/ass1/kv/tests/Ass1_5_2Test.java new file mode 100644 index 0000000..6d90ee6 --- /dev/null +++ b/ass1-kv/src/test/java/dst/ass1/kv/tests/Ass1_5_2Test.java @@ -0,0 +1,50 @@ +package dst.ass1.kv.tests; + +import dst.ass1.kv.ISessionManager; +import dst.ass1.kv.ISessionManagerFactory; +import dst.ass1.kv.RedisCleaner; +import dst.ass1.kv.impl.SessionManagerFactory; +import org.junit.After; +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; + +public class Ass1_5_2Test { + + @Rule + public RedisCleaner redisRule = new RedisCleaner(); + + private ISessionManager sessionManager; + + @Before + public void setUp() { + ISessionManagerFactory sessionManagerFactory = new SessionManagerFactory(); + + sessionManager = sessionManagerFactory.createSessionManager(redisRule.getProperties()); + } + + @After + public void tearDown() { + sessionManager.close(); + } + + @Test + public void testRequireSessionForExistingSession_existingIdReturned() throws Exception { + String newId = sessionManager.createSession(1337L, 30000); + assertNotNull(newId); + + String requiredId = sessionManager.requireSession(1337L, 15000); + assertEquals(newId, requiredId); + } + + @Test + public void testRequireSessionForNonExistingSession_newSessionCreated() throws Exception { + String sessionId = sessionManager.requireSession(1337L, 15000); + + assertEquals(Long.valueOf(1337L), sessionManager.getUserId(sessionId)); + } + +} diff --git a/ass1-kv/src/test/java/dst/ass1/kv/tests/Ass1_5_Suite.java b/ass1-kv/src/test/java/dst/ass1/kv/tests/Ass1_5_Suite.java new file mode 100644 index 0000000..0afbcdf --- /dev/null +++ b/ass1-kv/src/test/java/dst/ass1/kv/tests/Ass1_5_Suite.java @@ -0,0 +1,13 @@ +package dst.ass1.kv.tests; + +import org.junit.runner.RunWith; +import org.junit.runners.Suite; +import org.junit.runners.Suite.SuiteClasses; + +@RunWith(Suite.class) +@SuiteClasses( { + Ass1_5_1Test.class, + Ass1_5_2Test.class +}) +public class Ass1_5_Suite { +} diff --git a/ass1-kv/src/test/resources/logback.xml b/ass1-kv/src/test/resources/logback.xml new file mode 100644 index 0000000..e16fad1 --- /dev/null +++ b/ass1-kv/src/test/resources/logback.xml @@ -0,0 +1,14 @@ + + + + + + %d{yyyy-MM-dd HH:mm:ss.SSS} - %highlight(%5p) [%12.12thread] %cyan(%-40.40logger{39}): %m%n + + + + + + + + diff --git a/ass1-kv/src/test/resources/redis.properties b/ass1-kv/src/test/resources/redis.properties new file mode 100644 index 0000000..c1bbd02 --- /dev/null +++ b/ass1-kv/src/test/resources/redis.properties @@ -0,0 +1,4 @@ +# you can change this to, e.g., 127.0.0.1 if you have a local redis instance +redis.host=192.168.99.99 +#redis.host=127.0.0.1 +redis.port=6379 diff --git a/pom.xml b/pom.xml new file mode 100644 index 0000000..f742244 --- /dev/null +++ b/pom.xml @@ -0,0 +1,327 @@ + + + 4.0.0 + + at.ac.tuwien.infosys.dst + dst + 2021.1 + + DST :: Parent + + pom + + + + + + org.apache.maven.plugins + maven-compiler-plugin + + + org.apache.maven.plugins + maven-jar-plugin + + + org.apache.maven.plugins + maven-surefire-plugin + + + + + + + org.apache.maven.plugins + maven-compiler-plugin + ${maven-compiler-plugin.version} + + 11 + 11 + + + + org.apache.maven.plugins + maven-surefire-plugin + ${maven-surefire-plugin.version} + + false + alphabetical + + + + org.apache.maven.plugins + maven-jar-plugin + ${maven-jar-plugin.version} + + + + + test-jar + + + + + false + + + + com.spotify + dockerfile-maven-plugin + ${maven-dockerfile-plugin.version} + + + build-and-tag-latest + package + + build + + + + tag-version + package + + tag + + + ${project.version} + + + + + tuw-dst/${project.artifactId} + + + + org.apache.maven.plugins + maven-dependency-plugin + ${maven-dependency-plugin.version} + + + prepare-package + + copy-dependencies + + + + + false + false + true + runtime + ${project.build.directory}/lib + + + + kr.motd.maven + os-maven-plugin + ${os-maven-plugin.version} + + + org.xolstice.maven.plugins + protobuf-maven-plugin + ${protobuf-maven-plugin.version} + + com.google.protobuf:protoc:3.5.1-1:exe:${os.detected.classifier} + + grpc-java + io.grpc:protoc-gen-grpc-java:${grpc.version}:exe:${os.detected.classifier} + + + + + + compile + compile-custom + + + + + + + + + + + javax + javaee-api + 8.0.1 + + + javax.xml.bind + jaxb-api + + + org.slf4j + slf4j-api + + + ch.qos.logback + logback-classic + + + junit + junit + + + org.hamcrest + hamcrest-all + + + + + + + + org.slf4j + slf4j-api + ${slf4j.version} + + + ch.qos.logback + logback-classic + ${logback.version} + + + javax.xml.bind + jaxb-api + ${jaxb.version} + + + junit + junit + ${junit.version} + test + + + org.hamcrest + hamcrest-all + ${hamcrest.version} + test + + + org.mockito + mockito-core + ${mockito.version} + test + + + + + org.hibernate + hibernate-core + ${hibernate.version} + + + + org.hibernate.javax.persistence + hibernate-jpa-2.1-api + + + + + org.hibernate + hibernate-validator + ${hibernate-validator.version} + + + javax.validation + validation-api + + + + + com.h2database + h2 + ${h2.version} + + + org.mongodb + mongodb-driver + ${mongodb.version} + + + de.flapdoodle.embed + de.flapdoodle.embed.mongo + ${flapdoodle.version} + + + redis.clients + jedis + ${jedis.version} + + + + org.javassist + javassist + ${javassist.version} + + + + + + + + all + + ass1-jpa + ass1-doc + ass1-kv + + + + + ass1-jpa + + ass1-jpa + + + + + ass1-kv + + ass1-kv + + + + + ass1-doc + + ass1-doc + + + + + + + + + UTF-8 + + 3.8.0 + 2.22.1 + 1.4.10 + 3.1.1 + 3.1.1 + 2.22.1 + + + 1.7.30 + 1.2.3 + 3.11 + 2.3.1 + 4.13.2 + 1.3 + 3.7.7 + + 5.4.28.Final + 6.2.0.Final + 2.12.1 + 3.27.0-GA + 3.5.1 + 1.4.200 + 3.12.8 + 3.0.0 + + + + diff --git a/vm/Vagrantfile b/vm/Vagrantfile new file mode 100644 index 0000000..2653358 --- /dev/null +++ b/vm/Vagrantfile @@ -0,0 +1,15 @@ +Vagrant.configure("2") do |config| + # ... other config up here + config.vm.box = "dst/21" + + config.vm.hostname = "dst-vm" + config.vm.network :private_network, ip: "192.168.99.99" + + # Prefer VirtualBox before VMware Fusion + config.vm.provider "virtualbox" + config.vm.provider "vmware_fusion" + + # shared folders + config.vm.synced_folder "../", "/dst" + +end