diff options
Diffstat (limited to 'src/test/java/com/amazon/carbonado/repo')
3 files changed, 717 insertions, 0 deletions
diff --git a/src/test/java/com/amazon/carbonado/repo/replicated/TestCursors.java b/src/test/java/com/amazon/carbonado/repo/replicated/TestCursors.java new file mode 100644 index 0000000..d9a6b38 --- /dev/null +++ b/src/test/java/com/amazon/carbonado/repo/replicated/TestCursors.java @@ -0,0 +1,204 @@ +/*
+ * Copyright 2006 Amazon Technologies, Inc. or its affiliates.
+ * Amazon, Amazon.com and Carbonado are trademarks or registered trademarks
+ * of Amazon Technologies, Inc. or its affiliates. All rights reserved.
+ *
+ * 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 com.amazon.carbonado.repo.replicated;
+
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.Iterator;
+import java.util.Map;
+
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+import com.amazon.carbonado.Repository;
+import com.amazon.carbonado.RepositoryBuilder;
+import com.amazon.carbonado.Storage;
+import com.amazon.carbonado.Cursor;
+import com.amazon.carbonado.Query;
+import com.amazon.carbonado.FetchException;
+import com.amazon.carbonado.RepositoryException;
+import com.amazon.carbonado.ConfigurationException;
+
+import com.amazon.carbonado.TestUtilities;
+import com.amazon.carbonado.stored.StorableTestBasic;
+import com.amazon.carbonado.stored.STBContainer;
+
+/**
+ *
+ * @author Don Schneider
+ */
+public class TestCursors extends TestCase {
+
+ public static void main(String[] args) {
+ junit.textui.TestRunner.run(suite());
+ }
+
+ public static TestSuite suite() {
+ return new TestSuite(TestCursors.class);
+ }
+
+ public TestCursors(String s) {
+ super(s);
+ }
+
+ public TestCursors() {
+ this("default");
+ }
+
+ /**
+ * Test joins
+ */
+ public void test_joins() throws Exception {
+ Repository repository = TestUtilities.buildTempRepository("test_joins");
+ setup(repository);
+ do_test_joins(repository);
+ repository.close();
+ repository = null;
+ }
+
+ public void do_test_joins(Repository repository) throws Exception {
+ Storage<STBContainer> storage = repository.storageFor(STBContainer.class);
+ STBContainer s = storage.prepare();
+ s.setName("first");
+ s.setCategory("imaString_1");
+ s.setCount(1000001);
+
+ Collection<Integer> ids = checkContents(s, 1);
+
+ assertEquals(10, ids.size());
+
+ LinkedHashMap<String, Collection<Integer>> allIdCollections =
+ new LinkedHashMap<String, Collection<Integer>>();
+ Cursor<STBContainer> cSTBC = storage.query().fetch();
+ while (cSTBC.hasNext()) {
+ STBContainer stbc = cSTBC.next();
+ ids = checkContents(stbc, stbc.getCount());
+ for (Map.Entry entry : allIdCollections.entrySet()) {
+ if (entry.getKey().equals(stbc.getCategory())) {
+ assertTrue(ids.equals(entry.getValue()));
+ } else {
+ assertFalse(ids.equals(entry.getValue()));
+ }
+ }
+ allIdCollections.put(stbc.getCategory(), ids);
+ }
+ }
+
+ /**
+ * Test queries
+ */
+ public void test_queries() throws Exception {
+ Repository repository = TestUtilities.buildTempRepository("test_queries");
+ setup(repository);
+ do_test_queries(repository);
+ repository.close();
+ }
+
+ public void do_test_queries(Repository repository) throws Exception {
+ Storage<StorableTestBasic> storage =
+ repository.storageFor(StorableTestBasic.class);
+ filterTest(storage, "id > ? & id < ?", 10, 20, 11, 20);
+ filterTest(storage, "id >= ? & id < ?", 10, 20, 10, 20);
+ filterTest(storage, "id > ? & id <= ?", 10, 20, 11, 21);
+ filterTest(storage, "id >= ? & id <= ?", 10, 20, 10, 21);
+ }
+
+ /**
+ * Test RRQueries
+ * Includes an implicit test of the repository configuration
+ */
+ public void test_RRQueries() throws Exception {
+ RepositoryBuilder replicaRepository = TestUtilities.newTempRepositoryBuilder();
+ RepositoryBuilder masterRepository = TestUtilities.newTempRepositoryBuilder("alt");
+
+ ReplicatedRepositoryBuilder builder = new ReplicatedRepositoryBuilder();
+ try {
+ builder.assertReady();
+ fail("unready builder passed assertReady()");
+ }
+ catch (ConfigurationException e) {
+ // expected
+ }
+ builder.setName("test");
+ try {
+ builder.assertReady();
+ fail("unready builder passed assertReady()");
+ }
+ catch (ConfigurationException e) {
+ // expected
+ }
+ builder.setReplicaRepositoryBuilder(replicaRepository);
+ try {
+ builder.assertReady();
+ fail("builder config passed assertReady()");
+ }
+ catch (ConfigurationException e) {
+ // expected
+ }
+ builder.setMasterRepositoryBuilder(masterRepository);
+ builder.assertReady();
+
+ Repository RR = builder.build();
+
+ setup(RR);
+
+ do_test_joins(RR);
+ do_test_queries(RR);
+
+ RR.close();
+ }
+
+ private Collection<Integer> checkContents(STBContainer s, int count) throws FetchException {
+ Query<StorableTestBasic> q = s.getContained();
+ Cursor<StorableTestBasic> cSTB = q.fetch();
+ Collection<Integer> ids = new HashSet<Integer>(15);
+ while (cSTB.hasNext()) {
+ StorableTestBasic stb = cSTB.next();
+ assertEquals("imaString_" + count % 10, stb.getStringProp());
+ Integer id = new Integer(stb.getId());
+ assertFalse(ids.contains(id));
+ ids.add(id);
+ }
+ return ids;
+ }
+
+ private void filterTest(Storage<StorableTestBasic> storage,
+ String queryString,
+ int min,
+ int max,
+ int first,
+ int last)
+ throws Exception
+ {
+ Query<StorableTestBasic> q = storage.query(queryString).with(min).with(max);
+ Cursor<StorableTestBasic> c = q.fetch();
+ int i = first;
+ while (c.hasNext()) {
+ StorableTestBasic item = c.next();
+ assertEquals(queryString, i, item.getId());
+ i++;
+ }
+ assertEquals(queryString, last, i);
+ }
+
+ private void setup(Repository repository) throws RepositoryException {
+ StorableTestBasic.insertBunches(repository, 100);
+ STBContainer.insertBunches(repository, 30);
+ }
+}
diff --git a/src/test/java/com/amazon/carbonado/repo/replicated/TestProxiedStorable.java b/src/test/java/com/amazon/carbonado/repo/replicated/TestProxiedStorable.java new file mode 100644 index 0000000..6de2faf --- /dev/null +++ b/src/test/java/com/amazon/carbonado/repo/replicated/TestProxiedStorable.java @@ -0,0 +1,219 @@ +/*
+ * Copyright 2006 Amazon Technologies, Inc. or its affiliates.
+ * Amazon, Amazon.com and Carbonado are trademarks or registered trademarks
+ * of Amazon Technologies, Inc. or its affiliates. All rights reserved.
+ *
+ * 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 com.amazon.carbonado.repo.replicated;
+
+import java.lang.reflect.Method;
+
+import junit.framework.TestSuite;
+import com.amazon.carbonado.TestUtilities;
+import com.amazon.carbonado.spi.StorableInterceptorFactory;
+import com.amazon.carbonado.stored.StorableTestBasic;
+import com.amazon.carbonado.stored.StorableTestBasicIdMunger;
+import com.amazon.carbonado.TestStorables;
+
+import com.amazon.carbonado.Repository;
+import com.amazon.carbonado.Storable;
+import com.amazon.carbonado.Storage;
+import com.amazon.carbonado.SupportException;
+import com.amazon.carbonado.FetchException;
+import com.amazon.carbonado.TestStorableBase;
+
+import com.amazon.carbonado.spi.WrappedStorage;
+
+/*
+ * TestProxiedStorable
+ *
+ * @author Don Schneider
+ */
+public class TestProxiedStorable extends TestStorableBase {
+ public static void main(String[] args) {
+ junit.textui.TestRunner.run(suite());
+ }
+
+ public static TestSuite suite() {
+ return new TestSuite(TestProxiedStorable.class);
+ }
+
+ public TestProxiedStorable() {
+ super();
+ }
+
+ /**
+ * Test copy storable properties interface
+ */
+ public void test_copyStorableProperties() throws Exception {
+ Storage<StorableTestBasic> storage = getRepository().storageFor(StorableTestBasic.class);
+ StorableTestBasic storable = storage.prepare();
+
+ TestStorables.InvocationTracker tracker = new TestStorables.InvocationTracker("tracker");
+ storable.copyAllProperties(tracker);
+ // unloaded, not dirty; nothing happens
+ tracker.assertTrack(0);
+
+ storable.setId(1);
+ storable.setIntProp(1);
+ storable.copyAllProperties(tracker);
+ // setId, setIntProp
+ tracker.assertTrack(0x1 + 0x10);
+ tracker.clearTracks();
+
+ setBasicProperties(storable);
+ storable.copyAllProperties(tracker);
+ // setXxx
+ tracker.assertTrack(TestStorables.ALL_SET_METHODS);
+ tracker.clearTracks();
+
+ storable = storage.prepare();
+ storable.copyPrimaryKeyProperties(tracker);
+ tracker.assertTrack(0);
+ setPrimaryKeyProperties(storable);
+ storable.copyPrimaryKeyProperties(tracker);
+ // setXxx
+ tracker.assertTrack(TestStorables.ALL_PRIMARY_KEYS);
+ tracker.clearTracks();
+
+ storable = storage.prepare();
+ storable.copyUnequalProperties(tracker);
+ // Better not do anything since unloaded
+ tracker.assertTrack(0);
+ storable.setIntProp(0); // this will now be dirty, and equal
+ storable.copyUnequalProperties(tracker);
+ // Should only examine one dirty property since still unloaded
+ tracker.assertTrack(0x8);
+ storable.setIntProp(1); // this will now be dirty and not equal
+ storable.copyUnequalProperties(tracker);
+ tracker.assertTrack(0x8 + 0x10);
+
+ // get a fresh one
+ storable = storage.prepare();
+ storable.setStringProp("hi");
+ storable.setId(22);
+ storable.copyPrimaryKeyProperties(tracker);
+ storable.copyDirtyProperties(tracker);
+ // setId, setStringProp
+ tracker.assertTrack(0x1 + 0x4);
+ }
+
+ /**
+ * Test Interceptor
+ */
+ public void test_Interceptor() throws Exception {
+ Storage<StorableTestBasic> storage = getRepository().storageFor(StorableTestBasic.class);
+ StorableTestBasic storable = storage.prepare();
+
+ StorableInterceptorFactory<StorableTestBasic> proxyFactory
+ = StorableInterceptorFactory.getInstance(StorableTestBasicIdMunger.class,
+ StorableTestBasic.class,
+ false);
+ StorableTestBasic proxy = proxyFactory.create(storable);
+
+ proxy.setId(1);
+ assertEquals(storable.getId(), 2<<8);
+
+ storable.setId(5<<8);
+ assertEquals(proxy.getId(), 4);
+
+ proxy.setStringProp("passthrough");
+ assertEquals("passthrough", storable.getStringProp());
+ }
+
+ /**
+ * Test replicatingStorable
+ */
+ public void test_replicatingStorable() throws Exception {
+ Repository altRepo = TestUtilities.buildTempRepository("alt");
+
+ final Storage<StorableTestBasic> readage =
+ getRepository().storageFor(StorableTestBasic.class);
+ final Storage<StorableTestBasic> writage = altRepo.storageFor(StorableTestBasic.class);
+
+ Storage<StorableTestBasic> wrappage =
+ new ReplicatedStorage<StorableTestBasic>(getRepository(), readage, writage);
+
+ StorableTestBasic replicator = wrappage.prepare();
+
+ replicator.setId(1);
+ setBasicProperties(replicator);
+ replicator.insert();
+
+ StorableTestBasic reader = load(readage, 1);
+ StorableTestBasic writer = load(writage, 1);
+
+ assertTrue(reader.equalProperties(writer));
+
+ assertStorableEquivalenceById(1, readage, writage);
+
+ replicator = wrappage.prepare();
+
+ replicator.setId(1);
+ replicator.setStringProp("updated");
+ replicator.setLongProp(2342332);
+ replicator.update();
+ writer = load(writage, 1);
+ reader = load(readage, 1);
+ assertTrue(reader.equalProperties(writer));
+
+ replicator.delete();
+
+
+ try {
+ reader.load();
+ fail("successfully loaded deleted 'read' storable");
+ }
+ catch (FetchException e) {
+ // expected
+ }
+ try {
+ writer.load();
+ fail("successfully loaded deleted 'write' storable");
+ }
+ catch (FetchException e) {
+ // expected
+ }
+
+ StorableTestBasic replicator2 = wrappage.prepare();
+
+ replicator2.setId(2);
+ setBasicProperties(replicator2);
+ replicator2.insert();
+
+ // Now use the old replicator (which should be in "unloaded" state, since we've
+ // just finished deleting something, to delete it.
+ replicator.setId(2);
+ replicator.delete();
+
+ try {
+ load(readage, 2);
+ fail("successfully loaded deleted 'read' storable 2");
+ }
+ catch (FetchException e) {
+ // expected
+ }
+ try {
+ load(writage, 2);
+ fail("successfully loaded deleted 'write' storable 2");
+ }
+ catch (FetchException e) {
+ // expected
+ }
+
+ altRepo.close();
+ altRepo = null;
+ }
+
+}
diff --git a/src/test/java/com/amazon/carbonado/repo/replicated/TestRepair.java b/src/test/java/com/amazon/carbonado/repo/replicated/TestRepair.java new file mode 100644 index 0000000..d21fceb --- /dev/null +++ b/src/test/java/com/amazon/carbonado/repo/replicated/TestRepair.java @@ -0,0 +1,294 @@ +/*
+ * Copyright 2006 Amazon Technologies, Inc. or its affiliates.
+ * Amazon, Amazon.com and Carbonado are trademarks or registered trademarks
+ * of Amazon Technologies, Inc. or its affiliates. All rights reserved.
+ *
+ * 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 com.amazon.carbonado.repo.replicated;
+
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+import com.amazon.carbonado.OptimisticLockException;
+import com.amazon.carbonado.Repository;
+import com.amazon.carbonado.RepositoryBuilder;
+import com.amazon.carbonado.Storage;
+import com.amazon.carbonado.UniqueConstraintException;
+
+import com.amazon.carbonado.repo.replicated.ReplicatedRepository;
+import com.amazon.carbonado.repo.replicated.ReplicatedRepositoryBuilder;
+
+import com.amazon.carbonado.TestUtilities;
+import com.amazon.carbonado.stored.StorableTestBasic;
+import com.amazon.carbonado.stored.StorableVersioned;
+
+/**
+ *
+ *
+ * @author Brian S O'Neill
+ */
+public class TestRepair extends TestCase {
+ public static void main(String[] args) {
+ junit.textui.TestRunner.run(suite());
+ }
+
+ public static TestSuite suite() {
+ return new TestSuite(TestRepair.class);
+ }
+
+ private Repository mReplica;
+ private Repository mMaster;
+ private Repository mReplicated;
+
+ public TestRepair(String name) {
+ super(name);
+ }
+
+ protected void setUp() throws Exception {
+ RepositoryBuilder replica = TestUtilities.newTempRepositoryBuilder("rr-replica");
+ RepositoryBuilder master = TestUtilities.newTempRepositoryBuilder("rr-master");
+
+ ReplicatedRepositoryBuilder builder = new ReplicatedRepositoryBuilder();
+ builder.setName("rr");
+ builder.setReplicaRepositoryBuilder(replica);
+ builder.setMasterRepositoryBuilder(master);
+
+ ReplicatedRepository rr = (ReplicatedRepository) builder.build();
+
+ mReplica = rr.getReplicaRepository();
+ mMaster = rr.getMasterRepository();
+ mReplicated = rr;
+ }
+
+ protected void tearDown() throws Exception {
+ mReplicated.close();
+ mReplica = null;
+ mMaster = null;
+ mReplicated = null;
+ }
+
+ public void testMissingEntry() throws Exception {
+ // Insert an entry into master.
+ {
+ Storage<StorableTestBasic> storage = mMaster.storageFor(StorableTestBasic.class);
+ StorableTestBasic stb = storage.prepare();
+ stb.setId(5);
+ stb.setStringProp("hello");
+ stb.setIntProp(1);
+ stb.setLongProp(1L);
+ stb.setDoubleProp(1.0);
+ stb.insert();
+ }
+
+ // Verify not available from rr.
+ {
+ Storage<StorableTestBasic> storage = mReplicated.storageFor(StorableTestBasic.class);
+ StorableTestBasic stb = storage.prepare();
+ stb.setId(5);
+ assertFalse(stb.tryLoad());
+ }
+
+ // Insert into rr.
+ {
+ Storage<StorableTestBasic> storage = mReplicated.storageFor(StorableTestBasic.class);
+ StorableTestBasic stb = storage.prepare();
+ stb.setId(5);
+ stb.setStringProp("world");
+ stb.setIntProp(1);
+ stb.setLongProp(1L);
+ stb.setDoubleProp(1.0);
+ try {
+ stb.insert();
+ fail();
+ } catch (UniqueConstraintException e) {
+ }
+ }
+
+ // Wait a moment for repair thread to finish.
+ Thread.sleep(1000);
+
+ // Verify available from rr.
+ {
+ Storage<StorableTestBasic> storage = mReplicated.storageFor(StorableTestBasic.class);
+ StorableTestBasic stb = storage.prepare();
+ stb.setId(5);
+ assertTrue(stb.tryLoad());
+ assertEquals("hello", stb.getStringProp());
+ }
+ }
+
+ public void testMissingVersionedEntry() throws Exception {
+ // Insert an entry into master.
+ {
+ Storage<StorableVersioned> storage = mMaster.storageFor(StorableVersioned.class);
+ StorableVersioned sv = storage.prepare();
+ sv.setID(5);
+ sv.setValue("hello");
+ sv.insert();
+ }
+
+ // Verify not available from rr.
+ {
+ Storage<StorableVersioned> storage = mReplicated.storageFor(StorableVersioned.class);
+ StorableVersioned sv = storage.prepare();
+ sv.setID(5);
+ assertFalse(sv.tryLoad());
+ }
+
+ // Insert into rr.
+ {
+ Storage<StorableVersioned> storage = mReplicated.storageFor(StorableVersioned.class);
+ StorableVersioned sv = storage.prepare();
+ sv.setID(5);
+ sv.setValue("world");
+ try {
+ sv.insert();
+ fail();
+ } catch (UniqueConstraintException e) {
+ }
+ }
+
+ // Wait a moment for repair thread to finish.
+ Thread.sleep(1000);
+
+ // Verify available from rr.
+ {
+ Storage<StorableVersioned> storage = mReplicated.storageFor(StorableVersioned.class);
+ StorableVersioned sv = storage.prepare();
+ sv.setID(5);
+ assertTrue(sv.tryLoad());
+ assertEquals("hello", sv.getValue());
+ assertEquals(1, sv.getVersion());
+ }
+ }
+
+ public void testStaleEntry() throws Exception {
+ // Insert an entry into rr.
+ {
+ Storage<StorableVersioned> storage = mReplicated.storageFor(StorableVersioned.class);
+ StorableVersioned sv = storage.prepare();
+ sv.setID(5);
+ sv.setValue("hello");
+ sv.insert();
+ }
+
+ // Update master entry.
+ {
+ Storage<StorableVersioned> storage = mMaster.storageFor(StorableVersioned.class);
+ StorableVersioned sv = storage.prepare();
+ sv.setID(5);
+ sv.load();
+ sv.setValue("world");
+ sv.update();
+ }
+
+ // Verify old version in replica.
+ {
+ Storage<StorableVersioned> storage = mReplica.storageFor(StorableVersioned.class);
+ StorableVersioned sv = storage.prepare();
+ sv.setID(5);
+ sv.load();
+ assertEquals(1, sv.getVersion());
+ assertEquals("hello", sv.getValue());
+ }
+
+ // Attempt to update rr entry.
+ {
+ Storage<StorableVersioned> storage = mReplicated.storageFor(StorableVersioned.class);
+ StorableVersioned sv = storage.prepare();
+ sv.setID(5);
+ sv.load();
+ assertEquals(1, sv.getVersion());
+ assertEquals("hello", sv.getValue());
+
+ sv.setValue("ciao");
+ try {
+ sv.update();
+ fail();
+ } catch (OptimisticLockException e) {
+ }
+ }
+
+ // Wait a moment for repair thread to finish.
+ Thread.sleep(1000);
+
+ // Verify new version in rr and update it.
+ {
+ Storage<StorableVersioned> storage = mReplicated.storageFor(StorableVersioned.class);
+ StorableVersioned sv = storage.prepare();
+ sv.setID(5);
+ sv.load();
+ assertEquals(2, sv.getVersion());
+ assertEquals("world", sv.getValue());
+
+ sv.setValue("ciao");
+ sv.update();
+ }
+ }
+
+ public void testStaleEntryAndBackoff() throws Exception {
+ // Insert an entry into rr.
+ {
+ Storage<StorableVersioned> storage = mReplicated.storageFor(StorableVersioned.class);
+ StorableVersioned sv = storage.prepare();
+ sv.setID(5);
+ sv.setValue("hello");
+ sv.insert();
+ }
+
+ // Update master entry.
+ {
+ Storage<StorableVersioned> storage = mMaster.storageFor(StorableVersioned.class);
+ StorableVersioned sv = storage.prepare();
+ sv.setID(5);
+ sv.load();
+ sv.setValue("world");
+ sv.update();
+ }
+
+ // Attempt to update rr entry.
+ {
+ Storage<StorableVersioned> storage = mReplicated.storageFor(StorableVersioned.class);
+ StorableVersioned sv = storage.prepare();
+ sv.setID(5);
+
+ int failCount = 0;
+
+ for (int retryCount = 3;;) {
+ try {
+ sv.load();
+ sv.setValue("ciao");
+ sv.update();
+ break;
+ } catch (OptimisticLockException e) {
+ failCount++;
+ retryCount = e.backoff(e, retryCount, 1000);
+ }
+ }
+
+ assertTrue(failCount > 0);
+ }
+
+ // Verify new version in rr.
+ {
+ Storage<StorableVersioned> storage = mReplicated.storageFor(StorableVersioned.class);
+ StorableVersioned sv = storage.prepare();
+ sv.setID(5);
+ sv.load();
+ assertEquals(3, sv.getVersion());
+ assertEquals("ciao", sv.getValue());
+ }
+ }
+}
|