/** Returns the key's parent. */ @Override public Key getParent() { List<PathElement> ancestors = getAncestors(); if (ancestors.isEmpty()) { return null; } PathElement parent = ancestors.get(ancestors.size() - 1); Key.Builder keyBuilder; if (parent.hasName()) { keyBuilder = Key.newBuilder(getProjectId(), parent.getKind(), parent.getName()); } else { keyBuilder = Key.newBuilder(getProjectId(), parent.getKind(), parent.getId()); } String namespace = getNamespace(); if (namespace != null) { keyBuilder.setNamespace(namespace); } return keyBuilder.addAncestors(ancestors.subList(0, ancestors.size() - 1)).build(); }
@Test public void testAllocateId() throws Exception { Datastore datastore = createStrictMock(Datastore.class); IncompleteKey pKey1 = IncompleteKey.newBuilder("ds", "k").build(); Key key1 = Key.newBuilder(pKey1, 1).build(); expect(datastore.allocateId(new IncompleteKey[] {pKey1})) .andReturn(Collections.singletonList(key1)); replay(datastore); assertEquals(key1, DatastoreHelper.allocateId(datastore, pKey1)); verify(datastore); }
@Test public void testGetWithDatastore() throws Exception { Datastore datastore = createStrictMock(Datastore.class); IncompleteKey pKey1 = IncompleteKey.newBuilder("ds", "k").build(); Key key1 = Key.newBuilder(pKey1, 1).build(); Entity entity1 = Entity.newBuilder(key1).build(); Key key2 = Key.newBuilder(pKey1, 2).build(); ReadOption eventualConsistency = ReadOption.eventualConsistency(); expect(datastore.get(Collections.singletonList(key1))) .andReturn(Collections.singletonList(entity1).iterator()); expect(datastore.get(Collections.singletonList(key2))) .andReturn(Collections.<Entity>emptyIterator()); expect(datastore.get(Collections.singletonList(key1), eventualConsistency)) .andReturn(Collections.singletonList(entity1).iterator()); replay(datastore); assertEquals(entity1, DatastoreHelper.get(datastore, key1)); assertNull(DatastoreHelper.get(datastore, key2)); assertEquals(entity1, DatastoreHelper.get(datastore, key1, eventualConsistency)); verify(datastore); }
@Test public void testAllocateId() { KeyFactory keyFactory = datastore.newKeyFactory().setKind(KIND1); IncompleteKey pk1 = keyFactory.newKey(); Key key1 = datastore.allocateId(pk1); assertEquals(key1.getProjectId(), pk1.getProjectId()); assertEquals(key1.getNamespace(), pk1.getNamespace()); assertEquals(key1.getAncestors(), pk1.getAncestors()); assertEquals(key1.getKind(), pk1.getKind()); assertTrue(key1.hasId()); assertFalse(key1.hasName()); assertEquals(Key.newBuilder(pk1, key1.getId()).build(), key1); Key key2 = datastore.allocateId(pk1); assertNotEquals(key1, key2); assertEquals(Key.newBuilder(pk1, key2.getId()).build(), key2); try { datastore.allocateId(key1); fail("Expecting a failure"); } catch (IllegalArgumentException expected) { assertEquals(expected.getMessage(), "keys must be IncompleteKey instances"); } }
@Test public void testFetchWithTransaction() throws Exception { Transaction transaction = createStrictMock(Transaction.class); IncompleteKey pKey1 = IncompleteKey.newBuilder("ds", "k").build(); Key key1 = Key.newBuilder(pKey1, 1).build(); Key key2 = Key.newBuilder(pKey1, "a").build(); Entity entity1 = Entity.newBuilder(key1).build(); Entity entity2 = Entity.newBuilder(key2).build(); expect(transaction.get(new Key[] {key1, key2})) .andReturn(Iterators.forArray(entity1, entity2)) .once(); replay(transaction); List<Entity> values = DatastoreHelper.fetch(transaction, new Key[] {key1, key2}); assertEquals(2, values.size()); assertEquals(entity1, values.get(0)); assertEquals(entity2, values.get(1)); verify(transaction); } }
@Test public void testAllocateIdArray() { KeyFactory keyFactory = datastore.newKeyFactory().setKind(KIND1); IncompleteKey incompleteKey1 = keyFactory.newKey(); IncompleteKey incompleteKey2 = keyFactory.setKind(KIND2).addAncestor(PathElement.of(KIND1, 10)).newKey(); Key key3 = keyFactory.newKey("name"); List<Key> result1 = datastore.allocateId(incompleteKey1, incompleteKey2, incompleteKey1); assertEquals(3, result1.size()); assertEquals(Key.newBuilder(incompleteKey1, result1.get(0).getId()).build(), result1.get(0)); assertEquals(Key.newBuilder(incompleteKey1, result1.get(2).getId()).build(), result1.get(2)); assertEquals(Key.newBuilder(incompleteKey2, result1.get(1).getId()).build(), result1.get(1)); try { datastore.allocateId(incompleteKey1, incompleteKey2, key3); fail("expecting a failure"); } catch (IllegalArgumentException expected) { assertEquals(expected.getMessage(), "keys must be IncompleteKey instances"); } }
@Test public void testAllocateId() { KeyFactory keyFactory = DATASTORE.newKeyFactory().setKind(KIND1); IncompleteKey pk1 = keyFactory.newKey(); Key key1 = DATASTORE.allocateId(pk1); assertEquals(key1.getProjectId(), pk1.getProjectId()); assertEquals(key1.getNamespace(), pk1.getNamespace()); assertEquals(key1.getAncestors(), pk1.getAncestors()); assertEquals(key1.getKind(), pk1.getKind()); assertTrue(key1.hasId()); assertFalse(key1.hasName()); assertEquals(Key.newBuilder(pk1, key1.getId()).build(), key1); Key key2 = DATASTORE.allocateId(pk1); assertNotEquals(key1, key2); assertEquals(Key.newBuilder(pk1, key2.getId()).build(), key2); }
@Test public void testGetWithTransaction() throws Exception { Transaction transaction = createStrictMock(Transaction.class); IncompleteKey pKey1 = IncompleteKey.newBuilder("ds", "k").build(); Key key1 = Key.newBuilder(pKey1, 1).build(); Entity entity1 = Entity.newBuilder(key1).build(); Key key2 = Key.newBuilder(pKey1, 2).build(); expect(transaction.get(new Key[] {key1})) .andReturn(Collections.singletonList(entity1).iterator()); expect(transaction.get(new Key[] {key2})).andReturn(Collections.<Entity>emptyIterator()); replay(transaction); assertEquals(entity1, DatastoreHelper.get(transaction, key1)); assertNull(DatastoreHelper.get(transaction, key2)); verify(transaction); }
@Test public void testParent() { assertNull(pk1.getParent()); assertEquals(parent1, pk2.getParent()); Key parent2 = Key.newBuilder("ds", "kind3", "name").setNamespace("ns").build(); IncompleteKey pk3 = IncompleteKey.newBuilder(parent2, "kind3").build(); assertEquals(parent2, pk3.getParent()); } }
@Test public void testKeyFactory() { KeyFactory keyFactory = datastore.newKeyFactory().setKind(KIND1); assertEquals(INCOMPLETE_KEY1, keyFactory.newKey()); assertEquals( IncompleteKey.newBuilder(INCOMPLETE_KEY1).setKind(KIND2).build(), datastore.newKeyFactory().setKind(KIND2).newKey()); assertEquals(KEY1, keyFactory.newKey("name")); assertEquals(Key.newBuilder(KEY1).setId(2).build(), keyFactory.newKey(2)); }
@Before public void setUp() { pk1 = IncompleteKey.newBuilder("ds", "kind1").build(); parent1 = Key.newBuilder("ds", "kind2", 10).setNamespace("ns").build(); pk2 = IncompleteKey.newBuilder(parent1, "kind3").build(); }
@Test public void testGetKey() throws Exception { BaseEntity<Key> entity = builder.build(); assertEquals(KEY, entity.getKey("key")); Key key = Key.newBuilder(KEY).setName("BLA").build(); entity = builder.set("key", key).build(); assertEquals(key, entity.getKey("key")); }
@Test public void testAdd() throws Exception { Datastore datastore = createStrictMock(Datastore.class); IncompleteKey pKey = IncompleteKey.newBuilder("ds", "k").build(); Key key = Key.newBuilder(pKey, 1).build(); Entity entity = Entity.newBuilder(key).build(); expect(datastore.add(new Entity[] {entity})).andReturn(Collections.singletonList(entity)); replay(datastore); assertEquals(entity, DatastoreHelper.add(datastore, entity)); verify(datastore); }
@Test public void testToAndFromUrlSafe() throws Exception { Key key = Key.newBuilder("d", "k", "n").build(); String urlSafe = key.toUrlSafe(); Key copy = Key.fromUrlSafe(urlSafe); assertEquals(key, copy); } }
@Test public void testAllocateIdArray() { KeyFactory keyFactory = DATASTORE.newKeyFactory().setKind(KIND1); IncompleteKey incompleteKey1 = keyFactory.newKey(); IncompleteKey incompleteKey2 = keyFactory.setKind(KIND2).addAncestors(PathElement.of(KIND1, 10)).newKey(); List<Key> result = DATASTORE.allocateId(incompleteKey1, incompleteKey2, incompleteKey1); assertEquals(3, result.size()); assertEquals(Key.newBuilder(incompleteKey1, result.get(0).getId()).build(), result.get(0)); assertEquals(Key.newBuilder(incompleteKey1, result.get(2).getId()).build(), result.get(2)); assertEquals(Key.newBuilder(incompleteKey2, result.get(1).getId()).build(), result.get(1)); }