← Back to branch summary

~ubuntu-branches/ubuntu/wily/libhibernate3-java/wily-proposed

« back to all changes in this revision

Viewing changes to test/org/hibernate/test/idgen/enhanced/SequenceStyleConfigUnitTest.java

  • Committer: Bazaar Package Importer
  • Author(s): Torsten Werner
  • Date: 2007-10-14 14:43:34 UTC
  • Revision ID: james.westby@ubuntu.com-20071014144334-eamc8i0q10gs1aro
Tags: upstream-3.2.5
Import upstream version 3.2.5

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/org/hibernate/test/idgen/enhanced/SequenceStyleConfigUnitTest.java
 
1
package org.hibernate.test.idgen.enhanced;
 
2
 
 
3
import java.util.Properties;
 
4
 
 
5
import junit.framework.Test;
 
6
import junit.framework.TestSuite;
 
7
 
 
8
import org.hibernate.junit.UnitTestCase;
 
9
import org.hibernate.dialect.Dialect;
 
10
import org.hibernate.id.enhanced.SequenceStyleGenerator;
 
11
import org.hibernate.id.enhanced.SequenceStructure;
 
12
import org.hibernate.id.enhanced.OptimizerFactory;
 
13
import org.hibernate.id.enhanced.TableStructure;
 
14
import org.hibernate.Hibernate;
 
15
import org.hibernate.MappingException;
 
16
 
 
17
/**
 
18
 * Tests that SequenceStyleGenerator configures itself as expected
 
19
 * in various scenarios
 
20
 *
 
21
 * @author Steve Ebersole
 
22
 */
 
23
public class SequenceStyleConfigUnitTest extends UnitTestCase {
 
24
        public SequenceStyleConfigUnitTest(String string) {
 
25
                super( string );
 
26
        }
 
27
 
 
28
        public static Test suite() {
 
29
                return new TestSuite( SequenceStyleConfigUnitTest.class );
 
30
        }
 
31
 
 
32
        /**
 
33
         * Test all params defaulted with a dialect supporting sequences
 
34
         */
 
35
        public void testDefaultedSequenceBackedConfiguration() {
 
36
                Dialect dialect = new SequenceDialect();
 
37
                Properties props = new Properties();
 
38
                SequenceStyleGenerator generator = new SequenceStyleGenerator();
 
39
                generator.configure( Hibernate.LONG, props, dialect );
 
40
 
 
41
                assertClassAssignability( SequenceStructure.class, generator.getDatabaseStructure().getClass() );
 
42
                assertClassAssignability( OptimizerFactory.NoopOptimizer.class, generator.getOptimizer().getClass() );
 
43
                assertEquals( SequenceStyleGenerator.DEF_SEQUENCE_NAME, generator.getDatabaseStructure().getName() );
 
44
        }
 
45
 
 
46
        /**
 
47
         * Test all params defaulted with a dialect which does not support sequences
 
48
         */
 
49
        public void testDefaultedTableBackedConfiguration() {
 
50
                Dialect dialect = new TableDialect();
 
51
                Properties props = new Properties();
 
52
                SequenceStyleGenerator generator = new SequenceStyleGenerator();
 
53
                generator.configure( Hibernate.LONG, props, dialect );
 
54
 
 
55
                assertClassAssignability( TableStructure.class, generator.getDatabaseStructure().getClass() );
 
56
                assertClassAssignability( OptimizerFactory.NoopOptimizer.class, generator.getOptimizer().getClass() );
 
57
                assertEquals( SequenceStyleGenerator.DEF_SEQUENCE_NAME, generator.getDatabaseStructure().getName() );
 
58
        }
 
59
 
 
60
        /**
 
61
         * Test default optimizer selection for sequence backed generators
 
62
         * based on the configured increment size; both in the case of the
 
63
         * dialect supporting pooled sequences (pooled) and not (hilo)
 
64
         */
 
65
        public void testDefaultOptimizerBasedOnIncrementBackedBySequence() {
 
66
                Properties props = new Properties();
 
67
                props.setProperty( SequenceStyleGenerator.INCREMENT_PARAM, "10" );
 
68
 
 
69
                // for dialects which do not support pooled sequences, we default to hilo
 
70
                Dialect dialect = new SequenceDialect();
 
71
                SequenceStyleGenerator generator = new SequenceStyleGenerator();
 
72
                generator.configure( Hibernate.LONG, props, dialect );
 
73
                assertClassAssignability( SequenceStructure.class, generator.getDatabaseStructure().getClass() );
 
74
                assertClassAssignability( OptimizerFactory.HiLoOptimizer.class, generator.getOptimizer().getClass() );
 
75
                assertEquals( SequenceStyleGenerator.DEF_SEQUENCE_NAME, generator.getDatabaseStructure().getName() );
 
76
 
 
77
                // for dialects which do support pooled sequences, we default to pooled
 
78
                dialect = new PooledSequenceDialect();
 
79
                generator = new SequenceStyleGenerator();
 
80
                generator.configure( Hibernate.LONG, props, dialect );
 
81
                assertClassAssignability( SequenceStructure.class, generator.getDatabaseStructure().getClass() );
 
82
                assertClassAssignability( OptimizerFactory.PooledOptimizer.class, generator.getOptimizer().getClass() );
 
83
                assertEquals( SequenceStyleGenerator.DEF_SEQUENCE_NAME, generator.getDatabaseStructure().getName() );
 
84
        }
 
85
 
 
86
        /**
 
87
         * Test default optimizer selection for table backed generators
 
88
         * based on the configured increment size.  Here we always prefer
 
89
         * pooled.
 
90
         */
 
91
        public void testDefaultOptimizerBasedOnIncrementBackedByTable() {
 
92
                Properties props = new Properties();
 
93
                props.setProperty( SequenceStyleGenerator.INCREMENT_PARAM, "10" );
 
94
                Dialect dialect = new TableDialect();
 
95
                SequenceStyleGenerator generator = new SequenceStyleGenerator();
 
96
                generator.configure( Hibernate.LONG, props, dialect );
 
97
                assertClassAssignability( TableStructure.class, generator.getDatabaseStructure().getClass() );
 
98
                assertClassAssignability( OptimizerFactory.PooledOptimizer.class, generator.getOptimizer().getClass() );
 
99
                assertEquals( SequenceStyleGenerator.DEF_SEQUENCE_NAME, generator.getDatabaseStructure().getName() );
 
100
        }
 
101
 
 
102
        /**
 
103
         * Test forcing of table as backing strucuture with dialect supporting sequences
 
104
         */
 
105
        public void testForceTableUse() {
 
106
                Dialect dialect = new SequenceDialect();
 
107
                Properties props = new Properties();
 
108
                props.setProperty( SequenceStyleGenerator.FORCE_TBL_PARAM, "true" );
 
109
                SequenceStyleGenerator generator = new SequenceStyleGenerator();
 
110
                generator.configure( Hibernate.LONG, props, dialect );
 
111
                assertClassAssignability( TableStructure.class, generator.getDatabaseStructure().getClass() );
 
112
                assertClassAssignability( OptimizerFactory.NoopOptimizer.class, generator.getOptimizer().getClass() );
 
113
                assertEquals( SequenceStyleGenerator.DEF_SEQUENCE_NAME, generator.getDatabaseStructure().getName() );
 
114
        }
 
115
 
 
116
        /**
 
117
         * Test explicitly specifying both optimizer and increment
 
118
         */
 
119
        public void testExplicitOptimizerWithExplicitIncrementSize() {
 
120
                // with sequence ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
121
                Dialect dialect = new SequenceDialect();
 
122
 
 
123
                // optimizer=none w/ increment > 1 => should honor optimizer
 
124
                Properties props = new Properties();
 
125
                props.setProperty( SequenceStyleGenerator.OPT_PARAM, OptimizerFactory.NONE );
 
126
                props.setProperty( SequenceStyleGenerator.INCREMENT_PARAM, "20" );
 
127
                SequenceStyleGenerator generator = new SequenceStyleGenerator();
 
128
                generator.configure( Hibernate.LONG, props, dialect );
 
129
                assertClassAssignability( SequenceStructure.class, generator.getDatabaseStructure().getClass() );
 
130
                assertClassAssignability( OptimizerFactory.NoopOptimizer.class, generator.getOptimizer().getClass() );
 
131
                assertEquals( 1, generator.getOptimizer().getIncrementSize() );
 
132
                assertEquals( 1, generator.getDatabaseStructure().getIncrementSize() );
 
133
 
 
134
                // optimizer=hilo w/ increment > 1 => hilo
 
135
                props = new Properties();
 
136
                props.setProperty( SequenceStyleGenerator.OPT_PARAM, OptimizerFactory.HILO );
 
137
                props.setProperty( SequenceStyleGenerator.INCREMENT_PARAM, "20" );generator = new SequenceStyleGenerator();
 
138
                generator.configure( Hibernate.LONG, props, dialect );
 
139
                assertClassAssignability( SequenceStructure.class, generator.getDatabaseStructure().getClass() );
 
140
                assertClassAssignability( OptimizerFactory.HiLoOptimizer.class, generator.getOptimizer().getClass() );
 
141
                assertEquals( 20, generator.getOptimizer().getIncrementSize() );
 
142
                assertEquals( 20, generator.getDatabaseStructure().getIncrementSize() );
 
143
 
 
144
                // optimizer=pooled w/ increment > 1 => hilo
 
145
                props = new Properties();
 
146
                props.setProperty( SequenceStyleGenerator.OPT_PARAM, OptimizerFactory.POOL );
 
147
                props.setProperty( SequenceStyleGenerator.INCREMENT_PARAM, "20" );
 
148
                generator = new SequenceStyleGenerator();
 
149
                generator.configure( Hibernate.LONG, props, dialect );
 
150
                assertClassAssignability( SequenceStructure.class, generator.getDatabaseStructure().getClass() );
 
151
                assertClassAssignability( OptimizerFactory.HiLoOptimizer.class, generator.getOptimizer().getClass() );
 
152
                assertEquals( 20, generator.getOptimizer().getIncrementSize() );
 
153
                assertEquals( 20, generator.getDatabaseStructure().getIncrementSize() );
 
154
        }
 
155
 
 
156
        private static class TableDialect extends Dialect {
 
157
                public boolean supportsSequences() {
 
158
                        return false;
 
159
                }
 
160
        }
 
161
 
 
162
        private static class SequenceDialect extends Dialect {
 
163
                public boolean supportsSequences() {
 
164
                        return true;
 
165
                }
 
166
                public boolean supportsPooledSequences() {
 
167
                        return false;
 
168
                }
 
169
                public String getSequenceNextValString(String sequenceName) throws MappingException {
 
170
                        return "";
 
171
                }
 
172
        }
 
173
 
 
174
        private static class PooledSequenceDialect extends SequenceDialect {
 
175
                public boolean supportsPooledSequences() {
 
176
                        return true;
 
177
                }
 
178
        }
 
179
}