1 /*-
2  * See the file LICENSE for redistribution information.
3  *
4  * Copyright (c) 2000, 2010 Oracle and/or its affiliates.  All rights reserved.
5  *
6  */
7 package com.sleepycat.persist.test;
8 
9 import java.util.Iterator;
10 import java.util.List;
11 
12 import junit.framework.TestCase;
13 
14 import com.sleepycat.je.DatabaseException;
15 import com.sleepycat.je.Environment;
16 import com.sleepycat.persist.EntityStore;
17 import com.sleepycat.persist.StoreConfig;
18 import com.sleepycat.persist.evolve.Mutations;
19 import com.sleepycat.persist.model.ClassMetadata;
20 import com.sleepycat.persist.model.EntityModel;
21 import com.sleepycat.persist.model.Persistent;
22 import com.sleepycat.persist.raw.RawStore;
23 import com.sleepycat.persist.raw.RawType;
24 
25 @Persistent
26 abstract class EvolveCase {
27 
28     static final String STORE_NAME = "foo";
29 
30     transient boolean updated;
31     transient boolean newMetadataWritten;
32 
getMutations()33     Mutations getMutations() {
34         return null;
35     }
36 
configure(EntityModel model, StoreConfig config)37     void configure(EntityModel model, StoreConfig config) {
38     }
39 
getStoreOpenException()40     String getStoreOpenException() {
41         return null;
42     }
43 
getNRecordsExpected()44     int getNRecordsExpected() {
45         return 1;
46     }
47 
checkUnevolvedModel(EntityModel model, Environment env)48     void checkUnevolvedModel(EntityModel model, Environment env) {
49     }
50 
checkEvolvedModel(EntityModel model, Environment env, boolean oldTypesExist)51     void checkEvolvedModel(EntityModel model,
52                            Environment env,
53                            boolean oldTypesExist) {
54     }
55 
56     /**
57      * @throws DatabaseException from subclasses.
58      */
writeObjects(EntityStore store)59     void writeObjects(EntityStore store)
60         throws DatabaseException {
61     }
62 
63     /**
64      * @throws DatabaseException from subclasses.
65      */
readObjects(EntityStore store, boolean doUpdate)66     void readObjects(EntityStore store, boolean doUpdate)
67         throws DatabaseException {
68     }
69 
70     /**
71      * @throws DatabaseException from subclasses.
72      */
readRawObjects(RawStore store, boolean expectEvolved, boolean expectUpdated)73     void readRawObjects(RawStore store,
74                         boolean expectEvolved,
75                         boolean expectUpdated)
76         throws DatabaseException {
77     }
78 
79     /**
80      * @throws DatabaseException from subclasses.
81      */
copyRawObjects(RawStore rawStore, EntityStore newStore)82     void copyRawObjects(RawStore rawStore, EntityStore newStore)
83         throws DatabaseException {
84     }
85 
86     /**
87      * Checks for equality and prints the entire values rather than
88      * abbreviated values like TestCase.assertEquals does.
89      */
checkEquals(Object expected, Object got)90     static void checkEquals(Object expected, Object got) {
91         if ((expected != null) ? (!expected.equals(got)) : (got != null)) {
92             TestCase.fail("Expected:\n" + expected + "\nBut got:\n" + got);
93         }
94     }
95 
96     /**
97      * Asserts than an entity database exists or does not exist.
98      */
assertDbExists(boolean expectExists, Environment env, String entityClassName)99     void assertDbExists(boolean expectExists,
100                         Environment env,
101                         String entityClassName) {
102         assertDbExists(expectExists, env, entityClassName, null);
103     }
104 
105     /**
106      * Checks that an entity class exists or does not exist.
107      */
checkEntity(boolean exists, EntityModel model, Environment env, String className, int version, String secKeyName)108     void checkEntity(boolean exists,
109                      EntityModel model,
110                      Environment env,
111                      String className,
112                      int version,
113                      String secKeyName) {
114         if (exists) {
115             TestCase.assertNotNull(model.getEntityMetadata(className));
116             ClassMetadata meta = model.getClassMetadata(className);
117             TestCase.assertNotNull(meta);
118             TestCase.assertEquals(version, meta.getVersion());
119             TestCase.assertTrue(meta.isEntityClass());
120 
121             RawType raw = model.getRawType(className);
122             TestCase.assertNotNull(raw);
123             TestCase.assertEquals(version, raw.getVersion());
124 
125             RawType rawVersion = model.getRawTypeVersion(className, version);
126             TestCase.assertNotNull(rawVersion);
127             TestCase.assertTrue(!rawVersion.isDeleted());
128         } else {
129             TestCase.assertNull(model.getEntityMetadata(className));
130             TestCase.assertNull(model.getClassMetadata(className));
131             TestCase.assertNull(model.getRawType(className));
132 
133             RawType rawVersion = model.getRawTypeVersion(className, version);
134             TestCase.assertTrue(rawVersion == null || rawVersion.isDeleted());
135         }
136 
137         assertDbExists(exists, env, className);
138         if (secKeyName != null) {
139             assertDbExists(exists, env, className, secKeyName);
140         }
141     }
142 
143     /**
144      * Checks that a non-entity class exists or does not exist.
145      */
checkNonEntity(boolean exists, EntityModel model, Environment env, String className, int version)146     void checkNonEntity(boolean exists,
147                         EntityModel model,
148                         Environment env,
149                         String className,
150                         int version) {
151         if (exists) {
152             ClassMetadata meta = model.getClassMetadata(className);
153             TestCase.assertNotNull(meta);
154             TestCase.assertEquals(version, meta.getVersion());
155             TestCase.assertTrue(!meta.isEntityClass());
156 
157             RawType raw = model.getRawType(className);
158             TestCase.assertNotNull(raw);
159             TestCase.assertEquals(version, raw.getVersion());
160 
161             RawType rawVersion = model.getRawTypeVersion(className, version);
162             TestCase.assertNotNull(rawVersion);
163             TestCase.assertTrue(!rawVersion.isDeleted());
164         } else {
165             TestCase.assertNull(model.getClassMetadata(className));
166             TestCase.assertNull(model.getRawType(className));
167 
168             RawType rawVersion = model.getRawTypeVersion(className, version);
169             TestCase.assertTrue(rawVersion == null || rawVersion.isDeleted());
170         }
171 
172         TestCase.assertNull(model.getEntityMetadata(className));
173         assertDbExists(false, env, className);
174     }
175 
176     /**
177      * Asserts than a database expectExists or does not exist. If keyName is
178      * null, checks an entity database.  If keyName is non-null, checks a
179      * secondary database.
180      */
assertDbExists(boolean expectExists, Environment env, String entityClassName, String keyName)181     void assertDbExists(boolean expectExists,
182                         Environment env,
183                         String entityClassName,
184                         String keyName) {
185 
186         /*
187          * If the evolved metadata has not been written (e.g., we're in
188          * read-only mode), then class evolution will not yet have created,
189          * removed or renamed databases, and we cannot check their existence.
190          */
191         if (newMetadataWritten) {
192             PersistTestUtils.assertDbExists
193                 (expectExists, env, STORE_NAME, entityClassName, keyName);
194         }
195     }
196 
checkVersions(EntityModel model, String name, int version)197     static void checkVersions(EntityModel model, String name, int version) {
198         checkVersions(model, new String[] {name}, new int[] {version});
199     }
200 
checkVersions(EntityModel model, String name1, int version1, String name2, int version2)201     static void checkVersions(EntityModel model,
202                               String name1,
203                               int version1,
204                               String name2,
205                               int version2) {
206         checkVersions
207             (model, new String[] {name1, name2},
208              new int[] {version1, version2});
209     }
210 
checkVersions(EntityModel model, String[] names, int[] versions)211     private static void checkVersions(EntityModel model,
212                                       String[] names,
213                                       int[] versions) {
214         List<RawType> all = model.getAllRawTypeVersions(names[0]);
215         TestCase.assertNotNull(all);
216 
217         assert names.length == versions.length;
218         TestCase.assertEquals(all.toString(), names.length, all.size());
219 
220         Iterator<RawType> iter = all.iterator();
221         for (int i = 0; i < names.length; i += 1) {
222             RawType type = iter.next();
223             TestCase.assertEquals(versions[i], type.getVersion());
224             TestCase.assertEquals(names[i], type.getClassName());
225         }
226     }
227 }
228