001: /*
002: * Licensed to the Apache Software Foundation (ASF) under one
003: * or more contributor license agreements. See the NOTICE file
004: * distributed with this work for additional information
005: * regarding copyright ownership. The ASF licenses this file
006: * to you under the Apache License, Version 2.0 (the
007: * "License"); you may not use this file except in compliance
008: * with the License. You may obtain a copy of the License at
009: *
010: * http://www.apache.org/licenses/LICENSE-2.0
011: *
012: * Unless required by applicable law or agreed to in writing,
013: * software distributed under the License is distributed on an
014: * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
015: * KIND, either express or implied. See the License for the
016: * specific language governing permissions and limitations
017: * under the License.
018: */
019: package org.apache.openjpa.persistence.jdbc.annotations;
020:
021: import java.awt.*;
022: import java.util.Map;
023:
024: import org.apache.openjpa.jdbc.conf.JDBCConfiguration;
025: import org.apache.openjpa.jdbc.meta.ClassMapping;
026: import org.apache.openjpa.jdbc.meta.Discriminator;
027: import org.apache.openjpa.jdbc.meta.FieldMapping;
028: import org.apache.openjpa.jdbc.meta.ValueMapping;
029: import org.apache.openjpa.jdbc.meta.strats.ClassNameDiscriminatorStrategy;
030: import org.apache.openjpa.jdbc.schema.ForeignKey;
031: import org.apache.openjpa.jdbc.sql.DBDictionary;
032: import org.apache.openjpa.persistence.JPAFacadeHelper;
033: import org.apache.openjpa.persistence.OpenJPAEntityManager;
034: import org.apache.openjpa.persistence.test.SingleEMFTestCase;
035:
036: /**
037: * <p>Test the parsing of non-standard mapping annotations.</p>
038: *
039: * @author Abe White
040: */
041: public class TestNonstandardMappingAnnotations extends
042: SingleEMFTestCase {
043:
044: private ClassMapping _mapping;
045: private DBDictionary _dict;
046:
047: public void setUp() {
048: setUp(NonstandardMappingEntity.class, ExtensionsEntity.class,
049: NonstandardMappingMappedSuper.class, EmbedValue2.class,
050: EmbedValue.class, CLEAR_TABLES);
051:
052: // trigger complete resolution of metadata etc.
053: emf.createEntityManager().close();
054:
055: JDBCConfiguration conf = (JDBCConfiguration) emf
056: .getConfiguration();
057: _dict = conf.getDBDictionaryInstance();
058: _mapping = (ClassMapping) JPAFacadeHelper.getMetaData(emf,
059: NonstandardMappingEntity.class);
060: }
061:
062: public void testNonpolymorphic() {
063: FieldMapping fm = _mapping.getFieldMapping("superRel");
064: assertEquals(ValueMapping.POLY_FALSE, fm.getPolymorphic());
065:
066: ValueMapping vm = _mapping.getFieldMapping("joinCollection")
067: .getElementMapping();
068: assertEquals(ValueMapping.POLY_JOINABLE, vm.getPolymorphic());
069:
070: vm = _mapping.getFieldMapping("joinMap").getKeyMapping();
071: assertEquals(ValueMapping.POLY_FALSE, vm.getPolymorphic());
072: vm = _mapping.getFieldMapping("joinMap").getElementMapping();
073: assertEquals(ValueMapping.POLY_FALSE, vm.getPolymorphic());
074: }
075:
076: public void testDataStoreIdColumn() {
077: assertEquals("NONSTD_ENTITY", _mapping.getTable().getName());
078: assertEquals(ClassMapping.ID_DATASTORE, _mapping
079: .getIdentityType());
080: assertEquals(1, _mapping.getPrimaryKeyColumns().length);
081: assertEquals("OID", _mapping.getPrimaryKeyColumns()[0]
082: .getName());
083: }
084:
085: public void testDiscriminator() {
086: Discriminator disc = _mapping.getDiscriminator();
087: assertTrue(disc.getStrategy() instanceof ClassNameDiscriminatorStrategy);
088: assertEquals(1, disc.getColumns().length);
089: assertEquals("DISCRIM", disc.getColumns()[0].getName());
090: }
091:
092: public void testSuperclassOverride() {
093: FieldMapping fm = _mapping.getFieldMapping("superCollection");
094: assertEquals("SUP_COLL", fm.getTable().getName());
095: assertEquals(1, fm.getJoinForeignKey().getColumns().length);
096: assertEquals("OWNER", fm.getJoinForeignKey().getColumns()[0]
097: .getName());
098: assertEquals(1, fm.getElementMapping().getColumns().length);
099: assertEquals("SUP_ELEM", fm.getElementMapping().getColumns()[0]
100: .getName());
101: assertNull(fm.getElementMapping().getValueIndex());
102: assertNotNull(fm.getJoinIndex());
103: }
104:
105: public void testCustomField() {
106: FieldMapping fm = _mapping.getFieldMapping("custom");
107: assertTrue(fm.getHandler() instanceof PointHandler);
108: assertEquals(2, fm.getColumns().length);
109: assertEquals("X_COL", fm.getColumns()[0].getName());
110: assertEquals("Y_COL", fm.getColumns()[1].getName());
111: assertNotNull(fm.getValueIndex());
112: }
113:
114: public void testValueCollection() {
115: FieldMapping fm = _mapping.getFieldMapping("stringCollection");
116: assertEquals("STRINGS_COLL", fm.getTable().getName());
117: assertEquals(1, fm.getJoinForeignKey().getColumns().length);
118: assertEquals("OWNER", fm.getJoinForeignKey().getColumns()[0]
119: .getName());
120: assertEquals(1, fm.getElementMapping().getColumns().length);
121: assertEquals("STR_ELEM", fm.getElementMapping().getColumns()[0]
122: .getName());
123: assertEquals(127, fm.getElementMapping().getColumns()[0]
124: .getSize());
125: assertNotNull(fm.getElementMapping().getValueIndex());
126: assertNull(fm.getJoinIndex());
127: }
128:
129: public void testJoinCollection() {
130: FieldMapping fm = _mapping.getFieldMapping("joinCollection");
131: assertEquals("JOIN_COLL", fm.getTable().getName());
132: assertEquals(1, fm.getJoinForeignKey().getColumns().length);
133: assertEquals("OWNER", fm.getJoinForeignKey().getColumns()[0]
134: .getName());
135: assertEquals(1, fm.getElementMapping().getColumns().length);
136: assertEquals("JOIN_ELEM",
137: fm.getElementMapping().getColumns()[0].getName());
138: assertForeignKey(fm.getJoinForeignKey());
139: assertForeignKey(fm.getElementMapping().getForeignKey());
140: }
141:
142: private void assertForeignKey(ForeignKey fk) {
143: if (_dict.supportsForeignKeys)
144: assertEquals(ForeignKey.ACTION_RESTRICT, fk
145: .getDeleteAction());
146: }
147:
148: public void testValueMap() {
149: FieldMapping fm = _mapping.getFieldMapping("stringMap");
150: assertEquals("STRINGS_MAP", fm.getTable().getName());
151: assertEquals(1, fm.getJoinForeignKey().getColumns().length);
152: assertEquals("OWNER", fm.getJoinForeignKey().getColumns()[0]
153: .getName());
154: assertEquals(1, fm.getKeyMapping().getColumns().length);
155: assertEquals("STR_KEY", fm.getKeyMapping().getColumns()[0]
156: .getName());
157: assertEquals(127, fm.getKeyMapping().getColumns()[0].getSize());
158: assertEquals(1, fm.getElementMapping().getColumns().length);
159: assertEquals("STR_VAL", fm.getElementMapping().getColumns()[0]
160: .getName());
161: assertEquals(127, fm.getElementMapping().getColumns()[0]
162: .getSize());
163: assertNull(fm.getJoinIndex());
164: assertNotNull(fm.getKeyMapping().getValueIndex());
165: assertNotNull(fm.getElementMapping().getValueIndex());
166: }
167:
168: public void testJoinMap() {
169: FieldMapping fm = _mapping.getFieldMapping("joinMap");
170: assertEquals("JOIN_MAP", fm.getTable().getName());
171: assertEquals(1, fm.getJoinForeignKey().getColumns().length);
172: assertEquals("OWNER", fm.getJoinForeignKey().getColumns()[0]
173: .getName());
174: assertEquals(1, fm.getKeyMapping().getColumns().length);
175: assertEquals("JOIN_KEY", fm.getKeyMapping().getColumns()[0]
176: .getName());
177: assertEquals(1, fm.getElementMapping().getColumns().length);
178: assertEquals("JOIN_VAL", fm.getElementMapping().getColumns()[0]
179: .getName());
180: assertForeignKey(fm.getJoinForeignKey());
181: assertForeignKey(fm.getKeyMapping().getForeignKey());
182: assertForeignKey(fm.getElementMapping().getForeignKey());
183: }
184:
185: public void testEmbeddedOverride() {
186: FieldMapping fm = _mapping.getFieldMapping("embed");
187: assertTrue(fm.isEmbedded());
188: assertEquals(1, fm.getColumns().length);
189: assertTrue("UUID_HEX".equalsIgnoreCase(fm.getColumns()[0]
190: .getName()));
191:
192: ClassMapping embed = fm.getEmbeddedMapping();
193: fm = embed.getFieldMapping("rel");
194: assertEquals(1, fm.getColumns().length);
195: assertEquals("EM_REL_ID", fm.getColumns()[0].getName());
196: fm = embed.getFieldMapping("eager");
197: assertEquals("EM_EAGER", fm.getTable().getName());
198: assertEquals(1, fm.getElementMapping().getColumns().length);
199: assertEquals("ELEM_EAGER_ID", fm.getElementMapping()
200: .getColumns()[0].getName());
201: }
202:
203: public void testEmbeddedElementOverride() {
204: FieldMapping fm = _mapping.getFieldMapping("embedCollection");
205: assertTrue(fm.getElement().isEmbedded());
206: assertEquals("EMBED_COLL", fm.getTable().getName());
207: assertEquals(0, fm.getElementMapping().getColumns().length);
208:
209: ClassMapping embed = fm.getElementMapping()
210: .getEmbeddedMapping();
211: fm = embed.getFieldMapping("basic");
212: assertEquals(1, fm.getColumns().length);
213: assertEquals("EM_BASIC", fm.getColumns()[0].getName());
214: }
215:
216: public void testInsertAndRetrieve() {
217: NonstandardMappingEntity pc = new NonstandardMappingEntity();
218: pc.getSuperCollection().add("super");
219: pc.setCustom(new Point(1, 2));
220: pc.getStringCollection().add("string");
221: NonstandardMappingEntity pc2 = new NonstandardMappingEntity();
222: pc.getJoinCollection().add(pc2);
223: pc.getStringMap().put("stringKey", "stringValue");
224: NonstandardMappingEntity pc3 = new NonstandardMappingEntity();
225: pc.getJoinMap().put(pc2, pc3);
226: ExtensionsEntity embed = new ExtensionsEntity();
227: embed.setExternalValues('M');
228: embed.setExternalizer(String.class);
229: pc.setEmbed(embed);
230: EmbedValue2 embed2 = new EmbedValue2();
231: embed2.setBasic("basic");
232: pc.getEmbedCollection().add(embed2);
233:
234: OpenJPAEntityManager em = emf.createEntityManager();
235: em.getTransaction().begin();
236: em.persistAll(new Object[] { pc, pc2, pc3 });
237: em.getTransaction().commit();
238: Object pcId = em.getObjectId(pc);
239: Object pc2Id = em.getObjectId(pc2);
240: Object pc3Id = em.getObjectId(pc3);
241: em.close();
242:
243: em = emf.createEntityManager();
244: pc = em.find(NonstandardMappingEntity.class, pcId);
245: assertEquals(1, pc.getSuperCollection().size());
246: assertEquals("super", pc.getSuperCollection().get(0));
247: assertEquals(1, pc.getCustom().x);
248: assertEquals(2, pc.getCustom().y);
249: assertEquals(1, pc.getStringCollection().size());
250: assertEquals("string", pc.getStringCollection().get(0));
251: assertEquals(1, pc.getJoinCollection().size());
252: assertEquals(pc2Id, em.getObjectId(pc.getJoinCollection()
253: .get(0)));
254: assertEquals(1, pc.getStringMap().size());
255: assertEquals("stringValue", pc.getStringMap().get("stringKey"));
256: assertEquals(1, pc.getJoinMap().size());
257: Map.Entry entry = pc.getJoinMap().entrySet().iterator().next();
258: assertEquals(pc2Id, em.getObjectId(entry.getKey()));
259: assertEquals(pc3Id, em.getObjectId(entry.getValue()));
260: assertEquals('M', pc.getEmbed().getExternalValues());
261: assertEquals(String.class, pc.getEmbed().getExternalizer());
262: assertEquals(1, pc.getEmbedCollection().size());
263: assertEquals("basic", pc.getEmbedCollection().get(0).getBasic());
264: em.close();
265: }
266:
267: public void testInsertAndRetrieveEmbeddedCollection() {
268: NonstandardMappingEntity pc = new NonstandardMappingEntity();
269: EmbedValue2 embed2 = new EmbedValue2();
270: embed2.setBasic("basic");
271: pc.getEmbedCollection().add(embed2);
272:
273: OpenJPAEntityManager em = emf.createEntityManager();
274: em.getTransaction().begin();
275: em.persist(pc);
276: em.getTransaction().commit();
277: Object pcId = em.getObjectId(pc);
278: em.close();
279:
280: em = emf.createEntityManager();
281: pc = em.find(NonstandardMappingEntity.class, pcId);
282: assertEquals(1, pc.getEmbedCollection().size());
283: assertEquals("basic", pc.getEmbedCollection().get(0).getBasic());
284: em.close();
285: }
286: }
|