wamblee.org Git - utils/blob - support/general/src/test/java/org/wamblee/persistence/PersistentFactoryTest.java

   1 /*
   2  * Copyright 2005-2010 the original author or authors.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package org.wamblee.persistence;
  17
  18 import static junit.framework.Assert.*;
  19
  20 import javax.persistence.Id;
  21 import javax.persistence.Version;
  22
  23 import org.junit.Test;
  24 import org.wamblee.persistence.PersistentFactory.EntityAccessor;
  25 import org.wamblee.persistence.PersistentFactory.EntityObjectAccessor;
  26
  27 public class PersistentFactoryTest {
  28
  29     public static class X1 {
  30         @Id
  31         private int pk;
  32
  33         public int getPk() {
  34             return pk;
  35         }
  36
  37         public void setPk(int aPk) {
  38             pk = aPk;
  39         }
  40
  41         private void privateSetter(int aPk) {
  42             pk = aPk;
  43         }
  44
  45         private int privateGetter() {
  46             return pk;
  47         }
  48     }
  49
  50     public static class X2 {
  51         private int pk;
  52
  53         @Id
  54         public int getPk() {
  55             return pk;
  56         }
  57
  58         public void setPk(int aPk) {
  59             pk = aPk;
  60         }
  61     }
  62
  63     public static class X3 {
  64         private int pk;
  65
  66         @Id
  67         private int getPk() {
  68             return pk;
  69         }
  70
  71         private void setPk(int aPk) {
  72             pk = aPk;
  73         }
  74     }
  75
  76     public static class X4 {
  77         @Version
  78         private int version;
  79
  80         public int getVersion() {
  81             return version;
  82         }
  83
  84         public void setVersion(int aVersion) {
  85             version = aVersion;
  86         }
  87
  88         private void privateSetter(int aVersion) {
  89             version = aVersion;
  90         }
  91
  92         private int privateGetter() {
  93             return version;
  94         }
  95     }
  96
  97     public static class X5 {
  98         private int version;
  99
 100         @Version
 101         public int getVersion() {
 102             return version;
 103         }
 104
 105         public void setVersion(int aVersion) {
 106             version = aVersion;
 107         }
 108     }
 109
 110     public static class X6 {
 111         private int version;
 112
 113         @Version
 114         private int getVersion() {
 115             return version;
 116         }
 117
 118         private void setVersion(int aVersion) {
 119             version = aVersion;
 120         }
 121     }
 122
 123     public static class X7 {
 124         @Id
 125         public int id;
 126
 127         @Version
 128         public int version;
 129     }
 130
 131     // FieldAccessor test
 132
 133     @Test
 134     public void testFieldAccessorSet() throws Exception {
 135         Accessor<Integer> accessor = new FieldAccessor<Integer>(X1.class
 136             .getDeclaredField("pk"));
 137         X1 x1 = new X1();
 138         assertEquals(0, x1.getPk());
 139         accessor.set(x1, 10);
 140         assertEquals(10, x1.getPk());
 141     }
 142
 143     // PropertyAccessor test
 144     @Test
 145     public void testPropertyAccessorSet() throws Exception {
 146         Accessor<Integer> accessor = new PropertyAccessor<Integer>(X1.class
 147             .getDeclaredMethod("getPk"), X1.class.getDeclaredMethod("setPk",
 148             int.class));
 149         X1 x1 = new X1();
 150         assertEquals(0, x1.getPk());
 151         accessor.set(x1, 10);
 152         assertEquals(10, x1.getPk());
 153     }
 154
 155     @Test
 156     public void testPropertyAccessorPrivate() throws Exception {
 157         Accessor<Integer> accessor = new PropertyAccessor<Integer>(X1.class
 158             .getDeclaredMethod("privateGetter"), X1.class.getDeclaredMethod("privateSetter",
 159             int.class));
 160         X1 x1 = new X1();
 161         assertEquals(0, x1.getPk());
 162         accessor.set(x1, 10);
 163         assertEquals((Integer)10, accessor.get(x1));
 164
 165     }
 166
 167     // EntityAccessor test
 168
 169     @Test
 170     public void testEntityAccessorPkField() {
 171         EntityAccessor accessor = PersistentFactory.createEntityAccessor(X1.class);
 172         assertNotNull(accessor);
 173         assertTrue(accessor.getPk() instanceof FieldAccessor);
 174         assertNull(accessor.getVersion());
 175         assertEquals("pk", ((FieldAccessor) accessor.getPk()).getField()
 176             .getName());
 177     }
 178
 179     @Test
 180     public void testEntityAccessorPkProperty() {
 181         EntityAccessor accessor = PersistentFactory.createEntityAccessor(X2.class);
 182         assertNotNull(accessor);
 183         assertNotNull(accessor.getPk());
 184         assertTrue(accessor.getPk() instanceof PropertyAccessor);
 185         assertNull(accessor.getVersion());
 186         PropertyAccessor property = (PropertyAccessor) accessor.getPk();
 187         assertEquals("getPk", property.getGetter().getName());
 188         assertEquals("setPk", property.getSetter().getName());
 189     }
 190
 191     @Test
 192     public void testEntityAccessorPkPropertyPrivate() {
 193         EntityAccessor accessor = PersistentFactory.createEntityAccessor(X3.class);
 194         assertNotNull(accessor);
 195         assertNotNull(accessor.getPk());
 196         assertTrue(accessor.getPk() instanceof PropertyAccessor);
 197         assertNull(accessor.getVersion());
 198         PropertyAccessor property = (PropertyAccessor) accessor.getPk();
 199         assertEquals("getPk", property.getGetter().getName());
 200         assertEquals("setPk", property.getSetter().getName());
 201     }
 202
 203     @Test
 204     public void testEntityAccessorVersionField() {
 205         EntityAccessor accessor = PersistentFactory.createEntityAccessor(X4.class);
 206         assertNotNull(accessor);
 207         assertTrue(accessor.getVersion() instanceof FieldAccessor);
 208         assertNull(accessor.getPk());
 209         assertEquals("version", ((FieldAccessor) accessor.getVersion()).getField()
 210             .getName());
 211     }
 212
 213     @Test
 214     public void testEntityAccessorVersionProperty() {
 215         EntityAccessor accessor = PersistentFactory.createEntityAccessor(X5.class);
 216         assertNotNull(accessor);
 217         assertNotNull(accessor.getVersion());
 218         assertTrue(accessor.getVersion() instanceof PropertyAccessor);
 219         assertNull(accessor.getPk());
 220         PropertyAccessor property = (PropertyAccessor) accessor.getVersion();
 221         assertEquals("getVersion", property.getGetter().getName());
 222         assertEquals("setVersion", property.getSetter().getName());
 223     }
 224
 225     @Test
 226     public void testEntityAccessorVersionPropertyPrivate() {
 227         EntityAccessor accessor = PersistentFactory.createEntityAccessor(X6.class);
 228         assertNotNull(accessor);
 229         assertNotNull(accessor.getVersion());
 230         assertTrue(accessor.getVersion() instanceof PropertyAccessor);
 231         assertNull(accessor.getPk());
 232         PropertyAccessor property = (PropertyAccessor) accessor.getVersion();
 233         assertEquals("getVersion", property.getGetter().getName());
 234         assertEquals("setVersion", property.getSetter().getName());
 235     }
 236
 237     @Test
 238     public void testNoVersionAndNoPk() {
 239         EntityAccessor accessor = PersistentFactory.createEntityAccessor(String.class);
 240         assertNull(accessor);
 241     }
 242
 243     @Test
 244     public void testPkAndVersion() {
 245         EntityAccessor accessor = PersistentFactory.createEntityAccessor(X7.class);
 246         assertNotNull(accessor.getPk());
 247         assertNotNull(accessor.getVersion());
 248
 249         X7 x = new X7();
 250         assertEquals(0, x.id);
 251         assertEquals(0, x.version);
 252
 253         accessor.getPk().set(x, 10);
 254         accessor.getVersion().set(x, 20);
 255
 256         assertEquals(10, x.id);
 257         assertEquals(20, x.version);
 258     }
 259
 260     @Test
 261     public void testEntityAccessorCache() {
 262         EntityAccessor accessor = PersistentFactory.createEntityAccessor(X1.class);
 263         EntityAccessor accessor2 = PersistentFactory.createEntityAccessor(X1.class);
 264
 265         assertSame(accessor, accessor2);
 266     }
 267
 268     // EntityObjectAccessor test for undefined pk and/or version.
 269     @Test
 270     public void testEntityObjectAccessorRobustness() {
 271         EntityObjectAccessor accessor =  new EntityObjectAccessor("hello world",
 272             new EntityAccessor(null, null));
 273         assertNull(accessor.getPrimaryKey());
 274         assertNull(accessor.getPersistedVersion());
 275         accessor.setPrimaryKey("bla");
 276         accessor.setPersistedVersion(100);
 277
 278     }
 279 }