From 499a85ff2069b30997be10aa651af16583d39ee4 Mon Sep 17 00:00:00 2001 From: "Brian S. O'Neill" Date: Sat, 14 Oct 2006 18:07:30 +0000 Subject: Added wrapped storable tests. --- .../com/amazon/carbonado/TestStorableBase.java | 89 +++++++++++ .../carbonado/spi/TestWrappedStorableFactory.java | 164 +++++++++++++++++++++ .../com/amazon/carbonado/stored/STBContainer.java | 79 ++++++++++ 3 files changed, 332 insertions(+) create mode 100644 src/test/java/com/amazon/carbonado/TestStorableBase.java create mode 100644 src/test/java/com/amazon/carbonado/spi/TestWrappedStorableFactory.java create mode 100644 src/test/java/com/amazon/carbonado/stored/STBContainer.java (limited to 'src/test/java') diff --git a/src/test/java/com/amazon/carbonado/TestStorableBase.java b/src/test/java/com/amazon/carbonado/TestStorableBase.java new file mode 100644 index 0000000..6c49dbb --- /dev/null +++ b/src/test/java/com/amazon/carbonado/TestStorableBase.java @@ -0,0 +1,89 @@ +/* + * 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; + +import junit.framework.TestCase; + +import com.amazon.carbonado.stored.StorableTestBasic; + +/** + * @author Don Schneider + */ +public abstract class TestStorableBase extends TestCase { + private Repository mRepository; + + public TestStorableBase() { + } + + public TestStorableBase(String name) { + super(name); + } + + protected void setUp() throws Exception { + } + + protected void tearDown() throws Exception { + if (mRepository != null) { + mRepository.close(); + mRepository = null; + } + } + + protected Repository getRepository() { + if (mRepository == null) { + mRepository = TestUtilities.buildTempRepository(); + } + return mRepository; + } + + protected void setPrimaryKeyProperties(StorableTestBasic proxy) { + proxy.setId(10); + } + + protected void setBasicProperties(StorableTestBasic proxy) { + proxy.setStringProp("foo"); + proxy.setIntProp(10); + proxy.setLongProp(120); + proxy.setDoubleProp(1.2); + } + + protected void assertStorableEquivalenceById(int id, + Storage s1, + Storage s2) + throws FetchException + { + StorableTestBasic reader = s1.prepare(); + reader.setId(id); + reader.load(); + + StorableTestBasic writer = s2.prepare(); + writer.setId(id); + writer.load(); + + assertTrue(reader.equalProperties(writer)); + } + + protected StorableTestBasic load(Storage readage, int id) + throws FetchException + { + StorableTestBasic item = readage.prepare(); + item.setId(id); + item.load(); + return item; + } +} diff --git a/src/test/java/com/amazon/carbonado/spi/TestWrappedStorableFactory.java b/src/test/java/com/amazon/carbonado/spi/TestWrappedStorableFactory.java new file mode 100644 index 0000000..fd0cd35 --- /dev/null +++ b/src/test/java/com/amazon/carbonado/spi/TestWrappedStorableFactory.java @@ -0,0 +1,164 @@ +/* + * 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.spi; + +import java.lang.reflect.Method; + +import junit.framework.TestSuite; + +import com.amazon.carbonado.Cursor; +import com.amazon.carbonado.Repository; +import com.amazon.carbonado.Storable; +import com.amazon.carbonado.Storage; +import com.amazon.carbonado.TestStorableBase; +import com.amazon.carbonado.TestStorables; + +import com.amazon.carbonado.stored.StorableTestBasic; +import com.amazon.carbonado.stored.STBContainer; + +/** + * + * + * @author Brian S O'Neill + * @author Don Schneider + */ +public class TestWrappedStorableFactory extends TestStorableBase { + public static void main(String[] args) { + junit.textui.TestRunner.run(suite()); + } + + public static TestSuite suite() { + return new TestSuite(TestWrappedStorableFactory.class); + } + + public TestWrappedStorableFactory() { + super(); + } + + /** + * Test setAndGet + */ + public void test_proxiedSetAndGet() throws Exception { + Class wrapperClass = StorableGenerator + .getWrappedClass(StorableTestBasic.class); + + TestStorables.InvocationTracker props = new TestStorables.InvocationTracker("props"); + TestStorables.InvocationTracker handler = new TestStorables.InvocationTracker("handler"); + + StorableTestBasic wrapper = wrapperClass + .getConstructor(WrappedSupport.class, Storable.class) + .newInstance(handler, props); + + setPrimaryKeyProperties(wrapper); + setBasicProperties(wrapper); + + wrapper.getStringProp(); + wrapper.getIntProp(); + wrapper.getLongProp(); + wrapper.getDoubleProp(); + wrapper.getId(); + + for (Method method : Storable.class.getMethods()) { + if (method.getParameterTypes().length > 0) { + if (method.getParameterTypes()[0] != String.class) { + method.invoke(wrapper, wrapper); + } + } else { + method.invoke(wrapper, (Object[]) null); + } + } + + props.assertTrack(TestStorables.ALL_GET_METHODS + | TestStorables.ALL_SET_METHODS + // Copy is called on wrapped storable because wrapped storage is null + | TestStorables.sCopy + | TestStorables.sToStringKeyOnly + | TestStorables.sHasDirtyProperties + | TestStorables.sEqualKeys + | TestStorables.sEqualProperties + | TestStorables.sMarkPropertiesClean + | TestStorables.sMarkAllPropertiesClean + | TestStorables.sMarkPropertiesDirty + | TestStorables.sMarkAllPropertiesDirty + | TestStorables.ALL_COPY_PROP_METHODS); + + handler.assertTrack(TestStorables.sTryLoad + | TestStorables.sLoad + | TestStorables.sInsert + | TestStorables.sTryInsert + | TestStorables.sUpdate + | TestStorables.sTryUpdate + | TestStorables.sDelete + | TestStorables.sTryDelete); + } + + /** + * Verify that storables from joined property are also wrapped. + */ + public void test_wrappedJoin() throws Exception { + Storage stbStorage = + getRepository().storageFor(StorableTestBasic.class); + StorableTestBasic stb = stbStorage.prepare(); + //assertEquals(stbStorage, stb.storage()); + //assertTrue(stb.storage().getClass().getName().indexOf("IndexedStorage") > 0); + + stb.setId(1); + stb.initBasicProperties(); + stb.setStringProp("Hello"); + stb.insert(); + + stb = stbStorage.prepare(); + stb.setId(2); + stb.initBasicProperties(); + stb.setStringProp("Hello"); + stb.insert(); + + stb = stbStorage.prepare(); + stb.setId(3); + stb.initBasicProperties(); + stb.setStringProp("World"); + stb.insert(); + + Storage containerStorage = getRepository().storageFor(STBContainer.class); + + STBContainer container = containerStorage.prepare(); + container.setName("A"); + container.setCategory("Hello"); + container.setCount(2); + container.insert(); + + container = containerStorage.prepare(); + container.setName("B"); + container.setCategory("World"); + container.setCount(1); + container.insert(); + + // Test wrapping of query results + /* + container = containerStorage.prepare(); + container.setName("A"); + container.load(); + Cursor cursor = container.getContained().fetch(); + while (cursor.hasNext()) { + stb = cursor.next(); + assertTrue(stb.storage().getClass().getName().indexOf("IndexedStorage") > 0); + } + */ + } +} diff --git a/src/test/java/com/amazon/carbonado/stored/STBContainer.java b/src/test/java/com/amazon/carbonado/stored/STBContainer.java new file mode 100644 index 0000000..07ec722 --- /dev/null +++ b/src/test/java/com/amazon/carbonado/stored/STBContainer.java @@ -0,0 +1,79 @@ +/* + * 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.stored; + +import java.util.Random; + +import com.amazon.carbonado.Storable; +import com.amazon.carbonado.PrimaryKey; +import com.amazon.carbonado.Join; +import com.amazon.carbonado.Query; +import com.amazon.carbonado.Repository; +import com.amazon.carbonado.RepositoryException; +import com.amazon.carbonado.Storage; +import com.amazon.carbonado.FetchException; + +/** + * STBContainer + * + * @author Don Schneider + */ +@PrimaryKey("name") +public abstract class STBContainer implements Storable { + public abstract String getName(); + public abstract void setName(String name); + + public abstract String getCategory(); + public abstract void setCategory(String cat); + + public abstract int getCount(); + public abstract void setCount(int count); + + @Join(internal="category", external="stringProp") + public abstract Query getContained() throws FetchException; + + // Interesting join to same instance + @Join + public abstract STBContainer getSelf() throws FetchException; + + // This might fail sometimes + public abstract void setSelf(STBContainer newSelf); + + public void initProperties(int count) { + setName("STBContainer_" + count); + setCount(count); + setCategory("imaString_" + count % 10); + } + + public static void insertBunches(Repository repository, int count) + throws RepositoryException + { + Storage storage = + repository.storageFor(STBContainer.class); + STBContainer s; + + // TODO: come up with an XML based mechanism to inject a boatload of data into an empty repo + for (int i = 0; i < count; i ++) { + s = storage.prepare(); + s.initProperties(i); + s.insert(); + } + } + +} -- cgit v1.2.3