| /* |
| * Copyright 2013 The Apache Software Foundation. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| package org.apache.olingo.odata2.annotation.processor.core.datasource; |
| |
| import java.nio.charset.Charset; |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| import java.util.UUID; |
| import java.util.concurrent.CountDownLatch; |
| import java.util.concurrent.TimeUnit; |
| |
| import org.apache.olingo.odata2.annotation.processor.core.datasource.DataSource.BinaryData; |
| import org.apache.olingo.odata2.annotation.processor.core.edm.AnnotationEdmProvider; |
| import org.apache.olingo.odata2.annotation.processor.core.model.Building; |
| import org.apache.olingo.odata2.annotation.processor.core.model.City; |
| import org.apache.olingo.odata2.annotation.processor.core.model.Employee; |
| import org.apache.olingo.odata2.annotation.processor.core.model.GuidKeyEntity; |
| import org.apache.olingo.odata2.annotation.processor.core.model.Location; |
| import org.apache.olingo.odata2.annotation.processor.core.model.Manager; |
| import org.apache.olingo.odata2.annotation.processor.core.model.ModelSharedConstants; |
| import org.apache.olingo.odata2.annotation.processor.core.model.Photo; |
| import org.apache.olingo.odata2.annotation.processor.core.model.RefBase; |
| import org.apache.olingo.odata2.annotation.processor.core.model.Room; |
| import org.apache.olingo.odata2.annotation.processor.core.model.Team; |
| import org.apache.olingo.odata2.annotation.processor.core.util.AnnotationHelper; |
| import org.apache.olingo.odata2.annotation.processor.core.util.AnnotationRuntimeException; |
| import org.apache.olingo.odata2.api.annotation.edm.EdmKey; |
| import org.apache.olingo.odata2.api.annotation.edm.EdmProperty; |
| import org.apache.olingo.odata2.api.edm.EdmEntitySet; |
| import org.apache.olingo.odata2.api.edm.EdmEntityType; |
| import org.apache.olingo.odata2.api.edm.FullQualifiedName; |
| import org.apache.olingo.odata2.api.edm.provider.EntitySet; |
| import org.apache.olingo.odata2.api.exception.ODataException; |
| import org.apache.olingo.odata2.api.exception.ODataNotFoundException; |
| import org.junit.Assert; |
| import org.junit.Ignore; |
| import org.junit.Test; |
| import org.mockito.Mockito; |
| |
| /** |
| * |
| */ |
| public class AnnotationsInMemoryDsTest { |
| |
| final static Set<Class<?>> ANNOTATED_MODEL_CLASSES = new HashSet<Class<?>>(); |
| final static Set<Class<?>> ANNOTATED_ENTITY_SET_CLASSES = new HashSet<Class<?>>(); |
| |
| static { |
| ANNOTATED_ENTITY_SET_CLASSES.add(Building.class); |
| ANNOTATED_ENTITY_SET_CLASSES.add(Employee.class); |
| ANNOTATED_ENTITY_SET_CLASSES.add(Manager.class); |
| ANNOTATED_ENTITY_SET_CLASSES.add(Photo.class); |
| ANNOTATED_ENTITY_SET_CLASSES.add(Room.class); |
| ANNOTATED_ENTITY_SET_CLASSES.add(Team.class); |
| |
| ANNOTATED_MODEL_CLASSES.addAll(ANNOTATED_ENTITY_SET_CLASSES); |
| ANNOTATED_MODEL_CLASSES.add(Location.class); |
| ANNOTATED_MODEL_CLASSES.add(City.class); |
| ANNOTATED_MODEL_CLASSES.add(RefBase.class); |
| } |
| |
| private final AnnotationInMemoryDs datasource; |
| private final AnnotationEdmProvider edmProvider; |
| private static final String DEFAULT_CONTAINER = ModelSharedConstants.CONTAINER_1; |
| |
| public AnnotationsInMemoryDsTest() throws ODataException { |
| datasource = new AnnotationInMemoryDs(Building.class.getPackage().getName(), false); |
| edmProvider = new AnnotationEdmProvider(Building.class.getPackage().getName()); |
| } |
| |
| @Test |
| public void initFromPackage() throws Exception { |
| AnnotationInMemoryDs ds = new AnnotationInMemoryDs(Building.class.getPackage().getName(), false); |
| Assert.assertNotNull(ds); |
| } |
| |
| @Test(expected = IllegalArgumentException.class) |
| public void initFromNotExistingPackage() throws Exception { |
| AnnotationInMemoryDs ds = new AnnotationInMemoryDs("does.not.exist", false); |
| Assert.assertNotNull(ds); |
| } |
| |
| @Test |
| public void initFromPackageWithoutAnnotatedClasses() throws Exception { |
| AnnotationInMemoryDs ds = new AnnotationInMemoryDs(this.getClass().getPackage().getName(), false); |
| Assert.assertNotNull(ds); |
| } |
| |
| @Test |
| public void initFromClassCollectionEntitySets() throws Exception { |
| AnnotationInMemoryDs ds = new AnnotationInMemoryDs(ANNOTATED_ENTITY_SET_CLASSES, false); |
| Assert.assertNotNull(ds); |
| } |
| |
| @Test |
| public void initFromClassCollectionModel() throws Exception { |
| AnnotationInMemoryDs ds = new AnnotationInMemoryDs(ANNOTATED_MODEL_CLASSES, false); |
| Assert.assertNotNull(ds); |
| } |
| |
| @Test(expected = ODataException.class) |
| public void initFromClassCollectionNotAnnotated() throws Exception { |
| Set<Class<?>> annotatedClassesAndMore = new HashSet<Class<?>>(ANNOTATED_ENTITY_SET_CLASSES); |
| annotatedClassesAndMore.add(String.class); |
| annotatedClassesAndMore.add(Object.class); |
| AnnotationInMemoryDs ds = new AnnotationInMemoryDs(annotatedClassesAndMore, false); |
| Assert.assertNotNull(ds); |
| } |
| |
| @Test |
| @Ignore |
| public void multiThreadedSyncOnBuildingsTest() throws Exception { |
| final EdmEntitySet edmEntitySet = createMockedEdmEntitySet("Buildings"); |
| CountDownLatch latch; |
| |
| List<Thread> threads = new ArrayList<Thread>(); |
| int max = 500; |
| |
| latch = new CountDownLatch(max); |
| for (int i = 0; i < max; i++) { |
| threads.add(createBuildingThread(latch, datasource, edmEntitySet, String.valueOf("10"))); |
| } |
| |
| for (Thread thread : threads) { |
| thread.start(); |
| } |
| |
| latch.await(60, TimeUnit.SECONDS); |
| |
| DataStore<Building> ds = datasource.getDataStore(Building.class); |
| Collection<Building> buildings = ds.read(); |
| Assert.assertEquals(max, buildings.size()); |
| } |
| |
| @org.apache.olingo.odata2.api.annotation.edm.EdmEntitySet |
| @org.apache.olingo.odata2.api.annotation.edm.EdmEntityType |
| private static class SimpleEntity { |
| |
| @EdmKey |
| @EdmProperty |
| public Integer id; |
| @EdmProperty |
| public String name; |
| } |
| |
| @Test |
| @Ignore |
| public void multiThreadedSyncCreateReadTest() throws Exception { |
| Collection<Class<?>> ac = new ArrayList<Class<?>>(); |
| ac.add(SimpleEntity.class); |
| final AnnotationInMemoryDs localDs = new AnnotationInMemoryDs(SimpleEntity.class.getPackage().getName(), true); |
| final AnnotationEdmProvider localProvider = new AnnotationEdmProvider(ac); |
| final EdmEntitySet edmEntitySet = createMockedEdmEntitySet(localProvider, "SimpleEntitySet"); |
| final CountDownLatch latch; |
| |
| List<Thread> threads = new ArrayList<Thread>(); |
| int max = 500; |
| latch = new CountDownLatch(max); |
| for (int i = 0; i < max; i++) { |
| Runnable run = new Runnable() { |
| @Override |
| public void run() { |
| SimpleEntity se = new SimpleEntity(); |
| se.id = Integer.valueOf(String.valueOf(System.currentTimeMillis()).substring(8)); |
| se.name = "Name: " + System.currentTimeMillis(); |
| try { |
| localDs.createData(edmEntitySet, se); |
| } catch (Exception ex) { |
| throw new RuntimeException(ex); |
| } finally { |
| latch.countDown(); |
| } |
| } |
| }; |
| |
| threads.add(new Thread(run)); |
| } |
| |
| for (Thread thread : threads) { |
| thread.start(); |
| } |
| |
| latch.await(60, TimeUnit.SECONDS); |
| |
| DataStore<SimpleEntity> ds = localDs.getDataStore(SimpleEntity.class); |
| Collection<SimpleEntity> buildings = ds.read(); |
| Assert.assertEquals(max, buildings.size()); |
| } |
| |
| private Thread createBuildingThread(final CountDownLatch latch, final DataSource datasource, |
| final EdmEntitySet edmEntitySet, final String id) { |
| Runnable run = new Runnable() { |
| @Override |
| public void run() { |
| Building building = new Building(); |
| building.setName("Common Building - " + System.currentTimeMillis()); |
| building.setId(id); |
| try { |
| datasource.createData(edmEntitySet, building); |
| } catch (Exception ex) { |
| ex.printStackTrace(); |
| throw new RuntimeException(ex); |
| } finally { |
| latch.countDown(); |
| } |
| } |
| }; |
| |
| return new Thread(run); |
| } |
| |
| @Test |
| public void readBinaryData() throws Exception { |
| EdmEntitySet entitySet = createMockedEdmEntitySet("Photos"); |
| |
| DataStore<Photo> photoDataStore = datasource.getDataStore(Photo.class); |
| Photo photo = new Photo(); |
| photo.setName("SomePic"); |
| photo.setType("PNG"); |
| byte[] image = "binary".getBytes(Charset.defaultCharset()); |
| photo.setImage(image); |
| photo.setImageType("image/png"); |
| photoDataStore.create(photo); |
| |
| Map<String, Object> keys = new HashMap<String, Object>(); |
| keys.put("Name", "SomePic"); |
| keys.put("ImageFormat", "PNG"); |
| Photo toReadPhoto = (Photo) datasource.readData(entitySet, keys); |
| |
| // execute |
| BinaryData readBinaryData = datasource.readBinaryData(entitySet, toReadPhoto); |
| |
| // validate |
| Assert.assertEquals("binary", new String(readBinaryData.getData(), Charset.defaultCharset())); |
| Assert.assertArrayEquals(image, readBinaryData.getData()); |
| Assert.assertEquals("image/png", readBinaryData.getMimeType()); |
| } |
| |
| @Test |
| public void readBinaryDataDirect() throws Exception { |
| EdmEntitySet entitySet = createMockedEdmEntitySet("Photos"); |
| |
| DataStore<Photo> photoDataStore = datasource.getDataStore(Photo.class); |
| Photo photo = new Photo(); |
| photo.setName("SomePic"); |
| photo.setType("PNG"); |
| byte[] image = "binary".getBytes(Charset.defaultCharset()); |
| photo.setImage(image); |
| photo.setImageType("image/png"); |
| photoDataStore.create(photo); |
| |
| Photo toReadPhoto = new Photo(); |
| toReadPhoto.setName("SomePic"); |
| toReadPhoto.setType("PNG"); |
| toReadPhoto.setImage(null); |
| toReadPhoto.setImageType(null); |
| |
| BinaryData readBinaryData = datasource.readBinaryData(entitySet, toReadPhoto); |
| |
| Assert.assertEquals("binary", new String(readBinaryData.getData(), Charset.defaultCharset())); |
| Assert.assertArrayEquals(image, readBinaryData.getData()); |
| Assert.assertEquals("image/png", readBinaryData.getMimeType()); |
| } |
| |
| @Test |
| public void writeBinaryData() throws Exception { |
| EdmEntitySet entitySet = createMockedEdmEntitySet("Photos"); |
| |
| DataStore<Photo> photoDataStore = datasource.getDataStore(Photo.class); |
| |
| Photo toWritePhoto = new Photo(); |
| toWritePhoto.setName("SomePic"); |
| toWritePhoto.setType("PNG"); |
| photoDataStore.create(toWritePhoto); |
| byte[] image = "binary".getBytes(Charset.defaultCharset()); |
| String mimeType = "image/png"; |
| BinaryData writeBinaryData = new BinaryData(image, mimeType); |
| // execute |
| datasource.writeBinaryData(entitySet, toWritePhoto, writeBinaryData); |
| |
| // validate |
| Photo photoKey = new Photo(); |
| photoKey.setName("SomePic"); |
| photoKey.setType("PNG"); |
| Photo storedPhoto = photoDataStore.read(photoKey); |
| Assert.assertEquals("binary", new String(storedPhoto.getImage(), Charset.defaultCharset())); |
| Assert.assertArrayEquals(image, storedPhoto.getImage()); |
| Assert.assertEquals("image/png", storedPhoto.getImageType()); |
| } |
| |
| @Test(expected = ODataNotFoundException.class) |
| public void writeBinaryDataNotFound() throws Exception { |
| EdmEntitySet entitySet = createMockedEdmEntitySet("Photos"); |
| |
| Photo toWritePhoto = new Photo(); |
| toWritePhoto.setName("SomePic"); |
| toWritePhoto.setType("PNG"); |
| byte[] image = "binary".getBytes(Charset.defaultCharset()); |
| String mimeType = "image/png"; |
| BinaryData writeBinaryData = new BinaryData(image, mimeType); |
| // execute |
| datasource.writeBinaryData(entitySet, toWritePhoto, writeBinaryData); |
| } |
| |
| @Test |
| public void newDataObject() throws Exception { |
| EdmEntitySet roomsEntitySet = createMockedEdmEntitySet("Rooms"); |
| Room room = (Room) datasource.newDataObject(roomsEntitySet); |
| |
| Assert.assertNotNull(room); |
| } |
| |
| @Test |
| public void readEntity() throws Exception { |
| EdmEntitySet buildingsEntitySet = createMockedEdmEntitySet("Buildings"); |
| EdmEntitySet roomsEntitySet = createMockedEdmEntitySet("Rooms"); |
| |
| Building building = new Building(); |
| building.setName("Common Building"); |
| |
| final int roomsCount = 3; |
| List<Room> rooms = new ArrayList<Room>(); |
| for (int i = 0; i < roomsCount; i++) { |
| Room room = new Room(i, "Room " + i); |
| room.setBuilding(building); |
| datasource.createData(roomsEntitySet, room); |
| rooms.add(room); |
| } |
| |
| building.getRooms().addAll(rooms); |
| datasource.createData(buildingsEntitySet, building); |
| |
| Map<String, Object> keys = new HashMap<String, Object>(); |
| keys.put("Id", "1"); |
| |
| // execute |
| Object relatedData = datasource.readData(buildingsEntitySet, keys); |
| |
| // validate |
| Building readBuilding = (Building) relatedData; |
| Assert.assertEquals("Common Building", readBuilding.getName()); |
| Assert.assertEquals("1", readBuilding.getId()); |
| |
| Collection<Room> relatedRooms = readBuilding.getRooms(); |
| Assert.assertEquals(roomsCount, relatedRooms.size()); |
| for (Room room : relatedRooms) { |
| Assert.assertNotNull(room.getId()); |
| Assert.assertTrue(room.getName().matches("Room \\d*")); |
| Assert.assertEquals("Common Building", room.getBuilding().getName()); |
| } |
| } |
| |
| @Test(expected = AnnotationRuntimeException.class) |
| public void readUnknownEntity() throws Exception { |
| EdmEntitySet unknownEntitySet = Mockito.mock(EdmEntitySet.class); |
| Mockito.when(unknownEntitySet.getName()).thenReturn("UnknownEntity"); |
| Map<String, Object> keys = new HashMap<String, Object>(); |
| keys.put("Id", "1"); |
| |
| // execute |
| datasource.readData(unknownEntitySet, keys); |
| } |
| |
| @Test(expected = AnnotationRuntimeException.class) |
| public void readUnknownEntities() throws Exception { |
| EdmEntitySet unknownEntitySet = Mockito.mock(EdmEntitySet.class); |
| Mockito.when(unknownEntitySet.getName()).thenReturn("UnknownEntity"); |
| |
| // execute |
| datasource.readData(unknownEntitySet); |
| } |
| |
| @Test |
| public void readEntities() throws Exception { |
| EdmEntitySet roomsEntitySet = createMockedEdmEntitySet("Rooms"); |
| |
| Building building = new Building(); |
| building.setName("Common Building"); |
| |
| final int roomsCount = 11; |
| List<Room> rooms = new ArrayList<Room>(); |
| for (int i = 0; i < roomsCount; i++) { |
| Room room = new Room(i, "Room " + i); |
| room.setBuilding(building); |
| datasource.createData(roomsEntitySet, room); |
| rooms.add(room); |
| } |
| |
| // execute |
| Object relatedData = datasource.readData(roomsEntitySet); |
| |
| // validate |
| @SuppressWarnings("unchecked") |
| Collection<Room> relatedRooms = (Collection<Room>) relatedData; |
| Assert.assertEquals(roomsCount, relatedRooms.size()); |
| for (Room room : relatedRooms) { |
| Assert.assertNotNull(room.getId()); |
| Assert.assertTrue(room.getName().matches("Room \\d*")); |
| Assert.assertEquals("Common Building", room.getBuilding().getName()); |
| } |
| } |
| |
| @Test |
| @SuppressWarnings("unchecked") |
| public void readRelatedEntities() throws Exception { |
| EdmEntitySet buildingsEntitySet = createMockedEdmEntitySet("Buildings"); |
| EdmEntitySet roomsEntitySet = createMockedEdmEntitySet("Rooms"); |
| |
| Building building = new Building(); |
| building.setName("Common Building"); |
| |
| final int roomsCount = 10; |
| List<Room> rooms = new ArrayList<Room>(); |
| for (int i = 0; i < roomsCount; i++) { |
| Room room = new Room(i, "Room " + i); |
| room.setBuilding(building); |
| datasource.createData(roomsEntitySet, room); |
| rooms.add(room); |
| } |
| |
| building.getRooms().addAll(rooms); |
| datasource.createData(buildingsEntitySet, building); |
| |
| Map<String, Object> keys = new HashMap<String, Object>(); |
| keys.put("Id", "1"); |
| |
| Building read = (Building) datasource.readData(buildingsEntitySet, keys); |
| Assert.assertEquals("Common Building", read.getName()); |
| Assert.assertEquals("1", read.getId()); |
| |
| // execute |
| Object relatedData = datasource.readRelatedData( |
| buildingsEntitySet, building, roomsEntitySet, Collections.EMPTY_MAP); |
| |
| // validate |
| Assert.assertTrue("Result is no collection.", relatedData instanceof Collection); |
| Collection<Room> relatedRooms = (Collection<Room>) relatedData; |
| Assert.assertEquals(roomsCount, relatedRooms.size()); |
| for (Room room : relatedRooms) { |
| Assert.assertNotNull(room.getId()); |
| Assert.assertTrue(room.getName().matches("Room \\d*")); |
| Assert.assertEquals("Common Building", room.getBuilding().getName()); |
| } |
| } |
| |
| @Test |
| @SuppressWarnings("unchecked") |
| public void readRelatedEntity() throws Exception { |
| EdmEntitySet buildingsEntitySet = createMockedEdmEntitySet("Buildings"); |
| EdmEntitySet roomsEntitySet = createMockedEdmEntitySet("Rooms"); |
| |
| Building building = new Building(); |
| building.setName("Common Building"); |
| |
| Room room = new Room(12, "Room 12"); |
| room.setBuilding(building); |
| datasource.createData(roomsEntitySet, room); |
| datasource.createData(buildingsEntitySet, building); |
| |
| Map<String, Object> keys = new HashMap<String, Object>(); |
| keys.put("Id", Integer.valueOf(12)); |
| Room read = (Room) datasource.readData(roomsEntitySet, keys); |
| Assert.assertEquals("Room 12", read.getName()); |
| Assert.assertEquals("12", read.getId()); |
| |
| // execute |
| Object relatedData = datasource.readRelatedData( |
| roomsEntitySet, room, buildingsEntitySet, Collections.EMPTY_MAP); |
| |
| // validate |
| Assert.assertTrue("Result is no room.", relatedData instanceof Building); |
| Building b = (Building) relatedData; |
| Assert.assertEquals("Common Building", b.getName()); |
| } |
| |
| @Test |
| @SuppressWarnings("unchecked") |
| public void readRelatedEntityWithNull() throws Exception { |
| EdmEntitySet buildingsEntitySet = createMockedEdmEntitySet("Buildings"); |
| EdmEntitySet roomsEntitySet = createMockedEdmEntitySet("Rooms"); |
| |
| Building building = new Building(); |
| building.setName("Common Building"); |
| datasource.createData(buildingsEntitySet, building); |
| |
| Room room = new Room(12, "Room 12"); |
| room.setBuilding(null); |
| datasource.createData(roomsEntitySet, room); |
| // |
| Map<String, Object> keys = new HashMap<String, Object>(); |
| keys.put("Id", Integer.valueOf(12)); |
| Room read = (Room) datasource.readData(roomsEntitySet, keys); |
| Assert.assertEquals("Room 12", read.getName()); |
| Assert.assertEquals("12", read.getId()); |
| |
| // execute |
| Object relatedData = datasource.readRelatedData( |
| roomsEntitySet, room, buildingsEntitySet, Collections.EMPTY_MAP); |
| |
| // validate |
| Assert.assertNull("Related data must be null.", relatedData); |
| } |
| |
| @Test |
| public void readRelatedTargetEntity() throws Exception { |
| EdmEntitySet buildingsEntitySet = createMockedEdmEntitySet("Buildings"); |
| EdmEntitySet roomsEntitySet = createMockedEdmEntitySet("Rooms"); |
| |
| Building building = new Building(); |
| building.setName("Common Building"); |
| |
| final int roomsCount = 10; |
| List<Room> rooms = new ArrayList<Room>(); |
| for (int i = 0; i < roomsCount; i++) { |
| Room room = new Room(i, "Room " + i); |
| room.setBuilding(building); |
| datasource.createData(roomsEntitySet, room); |
| rooms.add(room); |
| } |
| |
| building.getRooms().addAll(rooms); |
| datasource.createData(buildingsEntitySet, building); |
| |
| Map<String, Object> keys = new HashMap<String, Object>(); |
| keys.put("Id", "1"); |
| |
| Building read = (Building) datasource.readData(buildingsEntitySet, keys); |
| Assert.assertEquals("Common Building", read.getName()); |
| Assert.assertEquals("1", read.getId()); |
| |
| // execute |
| Map<String, Object> targetKeys = new HashMap<String, Object>(); |
| targetKeys.put("Id", 3); |
| Object relatedData = datasource.readRelatedData( |
| buildingsEntitySet, building, roomsEntitySet, targetKeys); |
| |
| // validate |
| Assert.assertTrue("Result is no Room.", relatedData instanceof Room); |
| Room relatedRoom = (Room) relatedData; |
| Assert.assertEquals("3", relatedRoom.getId()); |
| Assert.assertEquals("Room 3", relatedRoom.getName()); |
| Assert.assertEquals("Common Building", relatedRoom.getBuilding().getName()); |
| } |
| |
| @Test |
| public void createSimpleEntity() throws Exception { |
| EdmEntitySet edmEntitySet = createMockedEdmEntitySet("Buildings"); |
| |
| Building building = new Building(); |
| building.setName("Common Building"); |
| datasource.createData(edmEntitySet, building); |
| |
| Map<String, Object> keys = new HashMap<String, Object>(); |
| keys.put("Id", "1"); |
| |
| Building read = (Building) datasource.readData(edmEntitySet, keys); |
| Assert.assertEquals("Common Building", read.getName()); |
| Assert.assertEquals("1", read.getId()); |
| } |
| |
| @Test |
| public void createSimpleEntityWithOwnKey() throws Exception { |
| EdmEntitySet edmEntitySet = createMockedEdmEntitySet("Buildings"); |
| |
| Building building = new Building(); |
| building.setName("Common Building"); |
| AnnotationHelper ah = new AnnotationHelper(); |
| ah.setValueForProperty(building, "Id", "42"); |
| datasource.createData(edmEntitySet, building); |
| |
| Map<String, Object> keys = new HashMap<String, Object>(); |
| keys.put("Id", "42"); |
| |
| Building read = (Building) datasource.readData(edmEntitySet, keys); |
| Assert.assertEquals("Common Building", read.getName()); |
| Assert.assertEquals("42", read.getId()); |
| } |
| |
| @Test |
| public void createSimpleEntityWithDuplicateKey() throws Exception { |
| EdmEntitySet edmEntitySet = createMockedEdmEntitySet("Buildings"); |
| AnnotationHelper ah = new AnnotationHelper(); |
| |
| Building building = new Building(); |
| building.setName("Common Building"); |
| ah.setValueForProperty(building, "Id", "42"); |
| datasource.createData(edmEntitySet, building); |
| // |
| Building buildingDuplicate = new Building(); |
| buildingDuplicate.setName("Duplicate Building"); |
| ah.setValueForProperty(buildingDuplicate, "Id", "42"); |
| datasource.createData(edmEntitySet, buildingDuplicate); |
| |
| Map<String, Object> keys42 = new HashMap<String, Object>(); |
| keys42.put("Id", "42"); |
| Building read42 = (Building) datasource.readData(edmEntitySet, keys42); |
| Assert.assertEquals("Common Building", read42.getName()); |
| Assert.assertEquals("42", read42.getId()); |
| |
| Map<String, Object> keys = new HashMap<String, Object>(); |
| keys.put("Id", "1"); |
| Building read = (Building) datasource.readData(edmEntitySet, keys); |
| Assert.assertEquals("Duplicate Building", read.getName()); |
| Assert.assertEquals("1", read.getId()); |
| } |
| |
| @Test |
| public void createEntityTwoKeys() throws Exception { |
| EdmEntitySet edmEntitySet = createMockedEdmEntitySet("Photos"); |
| |
| Photo photo = new Photo(); |
| photo.setName("BigPicture"); |
| photo.setType("PNG"); |
| photo.setImageUri("https://localhost/image.png"); |
| photo.setImageType("image/png"); |
| datasource.createData(edmEntitySet, photo); |
| |
| Map<String, Object> keys = new HashMap<String, Object>(); |
| keys.put("ImageFormat", "PNG"); |
| keys.put("Name", "BigPicture"); |
| |
| Photo read = (Photo) datasource.readData(edmEntitySet, keys); |
| Assert.assertEquals("BigPicture", read.getName()); |
| Assert.assertEquals("PNG", read.getType()); |
| Assert.assertEquals("image/png", read.getImageType()); |
| Assert.assertEquals("https://localhost/image.png", read.getImageUri()); |
| } |
| |
| @Test |
| public void createAndUpdateEntityTwoKeys() throws Exception { |
| EdmEntitySet edmEntitySet = createMockedEdmEntitySet("Photos"); |
| |
| Photo photo = new Photo(); |
| final String nameKeyValue = "BigPicture"; |
| final String typeKeyValue = "PNG"; |
| photo.setName(nameKeyValue); |
| photo.setType(typeKeyValue); |
| photo.setImageUri("https://localhost/image.png"); |
| photo.setImageType("image/png"); |
| datasource.createData(edmEntitySet, photo); |
| |
| Map<String, Object> keys = new HashMap<String, Object>(); |
| keys.put("Name", "BigPicture"); |
| keys.put("ImageFormat", "PNG"); |
| |
| Photo read = (Photo) datasource.readData(edmEntitySet, keys); |
| Assert.assertEquals("BigPicture", read.getName()); |
| Assert.assertEquals("PNG", read.getType()); |
| Assert.assertEquals("image/png", read.getImageType()); |
| Assert.assertEquals("https://localhost/image.png", read.getImageUri()); |
| |
| // update |
| Photo updatedPhoto = new Photo(); |
| updatedPhoto.setName(nameKeyValue); |
| updatedPhoto.setType(typeKeyValue); |
| updatedPhoto.setImageUri("https://localhost/image.jpg"); |
| updatedPhoto.setImageType("image/jpg"); |
| datasource.updateData(edmEntitySet, updatedPhoto); |
| |
| Map<String, Object> updatedKeys = new HashMap<String, Object>(); |
| updatedKeys.put("Name", nameKeyValue); |
| updatedKeys.put("ImageFormat", typeKeyValue); |
| |
| Photo readUpdated = (Photo) datasource.readData(edmEntitySet, updatedKeys); |
| Assert.assertEquals("BigPicture", readUpdated.getName()); |
| Assert.assertEquals("PNG", readUpdated.getType()); |
| Assert.assertEquals("image/jpg", readUpdated.getImageType()); |
| Assert.assertEquals("https://localhost/image.jpg", readUpdated.getImageUri()); |
| } |
| |
| @Test |
| public void createTwoKeyEntityWithOneKeyAlreadySet() throws Exception { |
| EdmEntitySet edmEntitySet = createMockedEdmEntitySet("Photos"); |
| |
| final String typeKeyValue = "PNG"; |
| final String automaticNameKeyValue = "1"; |
| |
| Photo photo = new Photo(); |
| photo.setType(typeKeyValue); |
| photo.setImageUri("https://localhost/big_picture.png"); |
| photo.setImageType("image/png"); |
| datasource.createData(edmEntitySet, photo); |
| |
| List<?> photos = datasource.readData(edmEntitySet); |
| Photo readPhoto = (Photo) photos.get(0); |
| Assert.assertEquals(automaticNameKeyValue + ":" + typeKeyValue, |
| readPhoto.getName() + ":" + readPhoto.getType()); |
| } |
| |
| @Test |
| public void ensureTwoKeyEntityKeysAreUnique() throws Exception { |
| EdmEntitySet edmEntitySet = createMockedEdmEntitySet("Photos"); |
| |
| final String nameKeyName = "Name"; |
| final String typeKeyName = "ImageFormat"; |
| final String nameKeyValue = "Big Picture"; |
| final String typeKeyValue = "PNG"; |
| |
| final String generatedValue1 = "1"; |
| final String generatedValue2 = "2"; |
| |
| final String imageUri1 = "https://localhost/big_picture.png"; |
| final String imageUri2 = "https://localhost/bigger_picture.png"; |
| |
| // Add photo 1 |
| Photo photo1 = new Photo(); |
| photo1.setName(nameKeyValue); |
| photo1.setType(typeKeyValue); |
| photo1.setImageUri(imageUri1); |
| photo1.setImageType("image/png"); |
| datasource.createData(edmEntitySet, photo1); |
| |
| // Add photo 2 (same key values) |
| Photo photo2 = new Photo(); |
| photo2.setName(nameKeyValue); |
| photo2.setType(typeKeyValue); |
| photo2.setImageUri("https://localhost/bigger_picture.png"); |
| photo2.setImageType("image/png"); |
| datasource.createData(edmEntitySet, photo2); |
| |
| List<?> photos = datasource.readData(edmEntitySet); |
| Assert.assertEquals(2, photos.size()); |
| |
| // Check photo 1 has specified key values. |
| Map<String, Object> keys1 = new HashMap<String, Object>(); |
| keys1.put(nameKeyName, nameKeyValue); |
| keys1.put(typeKeyName, typeKeyValue); |
| Photo readPhoto = (Photo) datasource.readData(edmEntitySet, keys1); |
| Assert.assertEquals(imageUri1, readPhoto.getImageUri()); |
| |
| // Check photo 2 has generated key values. |
| Map<String, Object> keys2 = new HashMap<String, Object>(); |
| keys2.put(nameKeyName, generatedValue1); |
| keys2.put(typeKeyName, generatedValue2); |
| Photo readPhoto2 = (Photo) datasource.readData(edmEntitySet, keys2); |
| Assert.assertEquals(imageUri2, readPhoto2.getImageUri()); |
| } |
| |
| @Test |
| public void createGuidKeyEntity() throws Exception { |
| EdmEntitySet edmEntitySet = createMockedEdmEntitySet(GuidKeyEntity.GUID_KEY_ENTITIES); |
| |
| final String entityName = "Entity name"; |
| GuidKeyEntity testEntity = new GuidKeyEntity(); |
| testEntity.setName(entityName); |
| datasource.createData(edmEntitySet, testEntity); |
| |
| List<?> entities = datasource.readData(edmEntitySet); |
| GuidKeyEntity readEntity = (GuidKeyEntity) entities.get(0); |
| Assert.assertEquals(entityName, readEntity.getName()); |
| } |
| |
| @Test |
| public void createGuidKeyEntityWithOwnKey() throws Exception { |
| EdmEntitySet edmEntitySet = createMockedEdmEntitySet(GuidKeyEntity.GUID_KEY_ENTITIES); |
| |
| final UUID entityId = UUID.randomUUID(); |
| final String entityName = "Entity name"; |
| GuidKeyEntity testEntity = new GuidKeyEntity(); |
| testEntity.setId(entityId); |
| testEntity.setName(entityName); |
| datasource.createData(edmEntitySet, testEntity); |
| |
| Map<String, Object> keys = new HashMap<String, Object>(); |
| keys.put("Id", entityId); |
| |
| GuidKeyEntity readEntity = (GuidKeyEntity) datasource.readData(edmEntitySet, keys); |
| Assert.assertEquals(entityId, readEntity.getId()); |
| Assert.assertEquals(entityName, readEntity.getName()); |
| } |
| |
| @Test |
| public void deleteSimpleEntity() throws Exception { |
| EdmEntitySet edmEntitySet = createMockedEdmEntitySet("Buildings"); |
| DataStore<Building> datastore = datasource.getDataStore(Building.class); |
| |
| Building building = new Building(); |
| building.setName("Common Building"); |
| datastore.create(building); |
| |
| Map<String, Object> keys = new HashMap<String, Object>(); |
| keys.put("Id", "1"); |
| |
| Building read = (Building) datasource.readData(edmEntitySet, keys); |
| Assert.assertEquals("Common Building", read.getName()); |
| Assert.assertEquals("1", read.getId()); |
| |
| // |
| datasource.deleteData(edmEntitySet, keys); |
| |
| // validate |
| try { |
| Building readAfterDelete = (Building) datasource.readData(edmEntitySet, keys); |
| Assert.fail("Expected " + ODataNotFoundException.class + "was not thrown for '" + readAfterDelete + "'."); |
| } catch (ODataNotFoundException e) {} |
| } |
| |
| @Test(expected = AnnotationRuntimeException.class) |
| public void unknownEntitySetForEntity() throws Exception { |
| String entitySetName = "Unknown"; |
| FullQualifiedName entityType = new FullQualifiedName(DEFAULT_CONTAINER, entitySetName); |
| |
| EdmEntitySet edmEntitySet = Mockito.mock(EdmEntitySet.class); |
| Mockito.when(edmEntitySet.getName()).thenReturn(entitySetName); |
| EdmEntityType edmEntityType = Mockito.mock(EdmEntityType.class); |
| Mockito.when(edmEntitySet.getEntityType()).thenReturn(edmEntityType); |
| Mockito.when(edmEntityType.getName()).thenReturn(entityType.getName()); |
| |
| Map<String, Object> keys = new HashMap<String, Object>(); |
| keys.put("Id", "1"); |
| // |
| datasource.readData(edmEntitySet, keys); |
| } |
| |
| @Test(expected = AnnotationRuntimeException.class) |
| public void unknownEntitySetForEntities() throws Exception { |
| String entitySetName = "Unknown"; |
| FullQualifiedName entityType = new FullQualifiedName(DEFAULT_CONTAINER, entitySetName); |
| |
| EdmEntitySet edmEntitySet = Mockito.mock(EdmEntitySet.class); |
| Mockito.when(edmEntitySet.getName()).thenReturn(entitySetName); |
| EdmEntityType edmEntityType = Mockito.mock(EdmEntityType.class); |
| Mockito.when(edmEntitySet.getEntityType()).thenReturn(edmEntityType); |
| Mockito.when(edmEntityType.getName()).thenReturn(entityType.getName()); |
| |
| // |
| datasource.readData(edmEntitySet); |
| } |
| |
| @Test |
| public void writeRelations() throws Exception { |
| DataStore<Building> buildingStore = DataStore.createInMemory(Building.class, true); |
| DataStore<Room> roomStore = DataStore.createInMemory(Room.class, true); |
| |
| EdmEntitySet buildingsEntitySet = createMockedEdmEntitySet("Buildings"); |
| EdmEntitySet roomsEntitySet = createMockedEdmEntitySet("Rooms"); |
| |
| Building building = new Building(); |
| building.setName("Common Building"); |
| Building created = buildingStore.create(building); |
| |
| Room room = new Room(42, "Room with Number"); |
| room.setSeats(123); |
| ; |
| room.setVersion(4711); |
| roomStore.create(room); |
| |
| Map<String, Object> targetEntityKeyValues = new HashMap<String, Object>(); |
| targetEntityKeyValues.put("Id", 42); |
| |
| // execute |
| datasource.writeRelation(buildingsEntitySet, building, roomsEntitySet, targetEntityKeyValues); |
| |
| // validate |
| Building readBuilding = buildingStore.read(created); |
| Room readRoom = roomStore.read(new Room(42, "")); |
| |
| List<Room> readRooms = readBuilding.getRooms(); |
| Assert.assertEquals(1, readRooms.size()); |
| Assert.assertEquals(readRoom, readRooms.get(0)); |
| |
| Assert.assertEquals("42", readRoom.getId()); |
| Assert.assertEquals(123, readRoom.getSeats()); |
| Assert.assertEquals(4711, readRoom.getVersion()); |
| Assert.assertEquals(readBuilding, readRoom.getBuilding()); |
| } |
| |
| private EdmEntitySet createMockedEdmEntitySet(final String entitySetName) throws ODataException { |
| return createMockedEdmEntitySet(edmProvider, entitySetName); |
| } |
| |
| private EdmEntitySet createMockedEdmEntitySet(final AnnotationEdmProvider edmProvider, final String entitySetName) |
| throws ODataException { |
| EntitySet entitySet = edmProvider.getEntitySet(DEFAULT_CONTAINER, entitySetName); |
| FullQualifiedName entityType = entitySet.getEntityType(); |
| |
| EdmEntitySet edmEntitySet = Mockito.mock(EdmEntitySet.class); |
| Mockito.when(edmEntitySet.getName()).thenReturn(entitySetName); |
| EdmEntityType edmEntityType = Mockito.mock(EdmEntityType.class); |
| Mockito.when(edmEntitySet.getEntityType()).thenReturn(edmEntityType); |
| Mockito.when(edmEntityType.getName()).thenReturn(entityType.getName()); |
| |
| return edmEntitySet; |
| } |
| } |
