← Back to branch summary

~mortenoh/+junk/dhis2-detailed-import-export

« back to all changes in this revision

Viewing changes to dhis-2/dhis-services/dhis-service-core/src/test/java/org/hisp/dhis/period/PeriodStoreTest.java

  • Committer: larshelge at gmail
  • Date: 2009-03-03 16:46:36 UTC
  • Revision ID: larshelge@gmail.com-20090303164636-2sjlrquo7ib1gf7r
Initial check-in

Show diffs side-by-side

added added

removed removed

Lines of Context:
dhis-2/dhis-services/dhis-service-core/src/test/java/org/hisp/dhis/period/PeriodStoreTest.java
 
1
package org.hisp.dhis.period;
 
2
 
 
3
/*
 
4
 * Copyright (c) 2004-2007, University of Oslo
 
5
 * All rights reserved.
 
6
 *
 
7
 * Redistribution and use in source and binary forms, with or without
 
8
 * modification, are permitted provided that the following conditions are met:
 
9
 * * Redistributions of source code must retain the above copyright notice, this
 
10
 *   list of conditions and the following disclaimer.
 
11
 * * Redistributions in binary form must reproduce the above copyright notice,
 
12
 *   this list of conditions and the following disclaimer in the documentation
 
13
 *   and/or other materials provided with the distribution.
 
14
 * * Neither the name of the HISP project nor the names of its contributors may
 
15
 *   be used to endorse or promote products derived from this software without
 
16
 *   specific prior written permission.
 
17
 *
 
18
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 
19
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 
20
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 
21
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
 
22
 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 
23
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 
24
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
 
25
 * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 
26
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 
27
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
28
 */
 
29
 
 
30
import java.util.ArrayList;
 
31
import java.util.Calendar;
 
32
import java.util.Collection;
 
33
import java.util.Date;
 
34
import java.util.HashSet;
 
35
import java.util.Iterator;
 
36
 
 
37
import org.hisp.dhis.DhisSpringTest;
 
38
import org.hisp.dhis.dataelement.DataElement;
 
39
import org.hisp.dhis.dataelement.DataElementCategoryOptionCombo;
 
40
import org.hisp.dhis.dataelement.DataElementCategoryOptionComboService;
 
41
import org.hisp.dhis.dataelement.DataElementStore;
 
42
import org.hisp.dhis.datavalue.DataValue;
 
43
import org.hisp.dhis.datavalue.DataValueStore;
 
44
import org.hisp.dhis.source.DummySource;
 
45
import org.hisp.dhis.source.Source;
 
46
import org.hisp.dhis.source.SourceStore;
 
47
import org.hisp.dhis.system.util.UUIdUtils;
 
48
import org.hisp.dhis.transaction.TransactionManager;
 
49
 
 
50
/**
 
51
 * @author Torgeir Lorange Ostby
 
52
 * @version $Id: PeriodStoreTest.java 5983 2008-10-17 17:42:44Z larshelg $
 
53
 */
 
54
public class PeriodStoreTest
 
55
    extends DhisSpringTest
 
56
{
 
57
    private PeriodStore periodStore;
 
58
    
 
59
    private DataElementStore dataElementStore;
 
60
 
 
61
    private DataElementCategoryOptionComboService categoryOptionComboService;
 
62
    
 
63
    private SourceStore sourceStore;
 
64
    
 
65
    private DataValueStore dataValueStore;
 
66
 
 
67
    private TransactionManager transactionManager;
 
68
 
 
69
    private Calendar calendar;
 
70
 
 
71
    private DataElementCategoryOptionCombo optionCombo;
 
72
    
 
73
    // -------------------------------------------------------------------------
 
74
    // Set up/tear down
 
75
    // -------------------------------------------------------------------------
 
76
 
 
77
    public void setUpTest()
 
78
        throws Exception
 
79
    {
 
80
        periodStore = (PeriodStore) getBean( PeriodStore.ID );
 
81
        
 
82
        dataElementStore = (DataElementStore) getBean( DataElementStore.ID );
 
83
 
 
84
        categoryOptionComboService = (DataElementCategoryOptionComboService) getBean( DataElementCategoryOptionComboService.ID );
 
85
        
 
86
        sourceStore = (SourceStore) getBean( SourceStore.ID );
 
87
        
 
88
        dataValueStore = (DataValueStore) getBean( DataValueStore.ID );
 
89
 
 
90
        transactionManager = (TransactionManager) getBean( TransactionManager.ID );
 
91
        
 
92
        calendar = Calendar.getInstance();
 
93
 
 
94
        optionCombo = new DataElementCategoryOptionCombo();
 
95
        
 
96
        categoryOptionComboService.addDataElementCategoryOptionCombo( optionCombo );
 
97
    }
 
98
 
 
99
    // -------------------------------------------------------------------------
 
100
    // Support methods
 
101
    // -------------------------------------------------------------------------
 
102
 
 
103
    private Date getDay( int day )
 
104
    {
 
105
        calendar.clear();
 
106
        calendar.set( Calendar.DAY_OF_YEAR, day );
 
107
 
 
108
        return calendar.getTime();
 
109
    }
 
110
    
 
111
    private Date getDate( int day, int month, int year )
 
112
    {
 
113
        calendar.clear();
 
114
        calendar.set( Calendar.YEAR, year );
 
115
        calendar.set( Calendar.MONTH, month - 1 );
 
116
        calendar.set( Calendar.DAY_OF_MONTH, day );
 
117
                        
 
118
        return calendar.getTime();
 
119
    }
 
120
 
 
121
    private DataElement createDataElement( char uniqueCharacter )
 
122
    {
 
123
        DataElement dataElement = new DataElement();
 
124
 
 
125
        dataElement.setUuid( UUIdUtils.getUUId() );
 
126
        dataElement.setName( "DataElement" + uniqueCharacter );
 
127
        dataElement.setAlternativeName( "AlternativeName" + uniqueCharacter );
 
128
        dataElement.setShortName( "DE" + uniqueCharacter );
 
129
        dataElement.setCode( "Code" + uniqueCharacter );
 
130
        dataElement.setDescription( "DataElementDescription" + uniqueCharacter );
 
131
        dataElement.setAggregationOperator( DataElement.AGGREGATION_OPERATOR_SUM );
 
132
        dataElement.setType( DataElement.TYPE_INT );
 
133
 
 
134
        return dataElement;
 
135
    }
 
136
    
 
137
    // -------------------------------------------------------------------------
 
138
    // Period
 
139
    // -------------------------------------------------------------------------
 
140
 
 
141
    public void testAddPeriod()
 
142
        throws Exception
 
143
    {
 
144
        transactionManager.enter();
 
145
 
 
146
        Collection<PeriodType> periodTypes = periodStore.getAllPeriodTypes();
 
147
        Iterator<PeriodType> it = periodTypes.iterator();
 
148
        PeriodType periodTypeA = it.next();
 
149
        PeriodType periodTypeB = it.next();
 
150
 
 
151
        Period periodA = new Period( periodTypeA, getDay( 0 ), getDay( 1 ) );
 
152
        Period periodB = new Period( periodTypeA, getDay( 1 ), getDay( 2 ) );
 
153
        Period periodC = new Period( periodTypeB, getDay( 2 ), getDay( 3 ) );
 
154
        Period periodD = new Period( periodTypeA, getDay( 0 ), getDay( 1 ) );
 
155
        int idA = periodStore.addPeriod( periodA );
 
156
        int idB = periodStore.addPeriod( periodB );
 
157
        int idC = periodStore.addPeriod( periodC );
 
158
 
 
159
        transactionManager.leave();
 
160
 
 
161
        try
 
162
        {
 
163
            // Should give unique constraint violation.
 
164
            periodStore.addPeriod( periodD );
 
165
            fail();
 
166
        }
 
167
        catch ( Exception e )
 
168
        {
 
169
            // Expected.
 
170
        }
 
171
 
 
172
        transactionManager.enter();
 
173
 
 
174
        periodA = periodStore.getPeriod( idA );
 
175
        assertNotNull( periodA );
 
176
        assertEquals( idA, periodA.getId() );
 
177
        assertEquals( periodTypeA, periodA.getPeriodType() );
 
178
        assertEquals( getDay( 0 ), periodA.getStartDate() );
 
179
        assertEquals( getDay( 1 ), periodA.getEndDate() );
 
180
 
 
181
        periodB = periodStore.getPeriod( idB );
 
182
        assertNotNull( periodB );
 
183
        assertEquals( idB, periodB.getId() );
 
184
        assertEquals( periodTypeA, periodB.getPeriodType() );
 
185
        assertEquals( getDay( 1 ), periodB.getStartDate() );
 
186
        assertEquals( getDay( 2 ), periodB.getEndDate() );
 
187
 
 
188
        periodC = periodStore.getPeriod( idC );
 
189
        assertNotNull( periodC );
 
190
        assertEquals( idC, periodC.getId() );
 
191
        assertEquals( periodTypeB, periodC.getPeriodType() );
 
192
        assertEquals( getDay( 2 ), periodC.getStartDate() );
 
193
        assertEquals( getDay( 3 ), periodC.getEndDate() );
 
194
 
 
195
        transactionManager.leave();
 
196
    }
 
197
 
 
198
    public void testDeleteAndGetPeriod()
 
199
        throws Exception
 
200
    {
 
201
        transactionManager.enter();
 
202
 
 
203
        Collection<PeriodType> periodTypes = periodStore.getAllPeriodTypes();
 
204
        Iterator<PeriodType> it = periodTypes.iterator();
 
205
        PeriodType periodTypeA = it.next();
 
206
        PeriodType periodTypeB = it.next();
 
207
 
 
208
        Period periodA = new Period( periodTypeA, getDay( 0 ), getDay( 1 ) );
 
209
        Period periodB = new Period( periodTypeA, getDay( 1 ), getDay( 2 ) );
 
210
        Period periodC = new Period( periodTypeB, getDay( 2 ), getDay( 3 ) );
 
211
        Period periodD = new Period( periodTypeB, getDay( 3 ), getDay( 4 ) );
 
212
        int idA = periodStore.addPeriod( periodA );
 
213
        int idB = periodStore.addPeriod( periodB );
 
214
        int idC = periodStore.addPeriod( periodC );
 
215
        int idD = periodStore.addPeriod( periodD );
 
216
 
 
217
        assertNotNull( periodStore.getPeriod( idA ) );
 
218
        assertNotNull( periodStore.getPeriod( idB ) );
 
219
        assertNotNull( periodStore.getPeriod( idC ) );
 
220
        assertNotNull( periodStore.getPeriod( idD ) );
 
221
 
 
222
        periodStore.deletePeriod( periodA );
 
223
        assertNull( periodStore.getPeriod( idA ) );
 
224
        assertNotNull( periodStore.getPeriod( idB ) );
 
225
        assertNotNull( periodStore.getPeriod( idC ) );
 
226
        assertNotNull( periodStore.getPeriod( idD ) );
 
227
 
 
228
        periodStore.deletePeriod( periodB );
 
229
        assertNull( periodStore.getPeriod( idA ) );
 
230
        assertNull( periodStore.getPeriod( idB ) );
 
231
        assertNotNull( periodStore.getPeriod( idC ) );
 
232
        assertNotNull( periodStore.getPeriod( idD ) );
 
233
 
 
234
        periodStore.deletePeriod( periodC );
 
235
        assertNull( periodStore.getPeriod( idA ) );
 
236
        assertNull( periodStore.getPeriod( idB ) );
 
237
        assertNull( periodStore.getPeriod( idC ) );
 
238
        assertNotNull( periodStore.getPeriod( idD ) );
 
239
 
 
240
        periodStore.deletePeriod( periodD );
 
241
        assertNull( periodStore.getPeriod( idA ) );
 
242
        assertNull( periodStore.getPeriod( idB ) );
 
243
        assertNull( periodStore.getPeriod( idC ) );
 
244
        assertNull( periodStore.getPeriod( idD ) );
 
245
 
 
246
        transactionManager.leave();
 
247
    }
 
248
 
 
249
    public void testGetPeriod()
 
250
        throws Exception
 
251
    {
 
252
        transactionManager.enter();
 
253
        
 
254
        Collection<PeriodType> periodTypes = periodStore.getAllPeriodTypes();
 
255
        Iterator<PeriodType> it = periodTypes.iterator();
 
256
        PeriodType periodTypeA = it.next();
 
257
        PeriodType periodTypeB = it.next();
 
258
 
 
259
        Period periodA = new Period( periodTypeA, getDay( 0 ), getDay( 1 ) );
 
260
        Period periodB = new Period( periodTypeA, getDay( 1 ), getDay( 2 ) );
 
261
        Period periodC = new Period( periodTypeB, getDay( 2 ), getDay( 3 ) );
 
262
        Period periodD = new Period( periodTypeB, getDay( 3 ), getDay( 4 ) );
 
263
        Period periodE = new Period( periodTypeA, getDay( 3 ), getDay( 4 ) );
 
264
        int idA = periodStore.addPeriod( periodA );
 
265
        int idB = periodStore.addPeriod( periodB );
 
266
        int idC = periodStore.addPeriod( periodC );
 
267
        int idD = periodStore.addPeriod( periodD );
 
268
        int idE = periodStore.addPeriod( periodE );
 
269
 
 
270
        periodA = periodStore.getPeriod( getDay( 0 ), getDay( 1 ), periodTypeA );
 
271
        assertNotNull( periodA );
 
272
        assertEquals( idA, periodA.getId() );
 
273
        assertEquals( periodTypeA, periodA.getPeriodType() );
 
274
        assertEquals( getDay( 0 ), periodA.getStartDate() );
 
275
        assertEquals( getDay( 1 ), periodA.getEndDate() );
 
276
        
 
277
        periodB = periodStore.getPeriod( getDay( 1 ), getDay( 2 ), periodTypeA );
 
278
        assertNotNull( periodB );
 
279
        assertEquals( idB, periodB.getId() );
 
280
        assertEquals( periodTypeA, periodB.getPeriodType() );
 
281
        assertEquals( getDay( 1 ), periodB.getStartDate() );
 
282
        assertEquals( getDay( 2 ), periodB.getEndDate() );
 
283
 
 
284
        periodC = periodStore.getPeriod( getDay( 2 ), getDay( 3 ), periodTypeB );
 
285
        assertNotNull( periodC );
 
286
        assertEquals( idC, periodC.getId() );
 
287
        assertEquals( periodTypeB, periodC.getPeriodType() );
 
288
        assertEquals( getDay( 2 ), periodC.getStartDate() );
 
289
        assertEquals( getDay( 3 ), periodC.getEndDate() );
 
290
 
 
291
        periodD = periodStore.getPeriod( getDay( 3 ), getDay( 4 ), periodTypeB );
 
292
        assertNotNull( periodD );
 
293
        assertEquals( idD, periodD.getId() );
 
294
        assertEquals( periodTypeB, periodD.getPeriodType() );
 
295
        assertEquals( getDay( 3 ), periodD.getStartDate() );
 
296
        assertEquals( getDay( 4 ), periodD.getEndDate() );
 
297
 
 
298
        periodE = periodStore.getPeriod( getDay( 3 ), getDay( 4 ), periodTypeA );
 
299
        assertNotNull( periodE );
 
300
        assertEquals( idE, periodE.getId() );
 
301
        assertEquals( periodTypeA, periodE.getPeriodType() );
 
302
        assertEquals( getDay( 3 ), periodE.getStartDate() );
 
303
        assertEquals( getDay( 4 ), periodE.getEndDate() );
 
304
        
 
305
        assertNull( periodStore.getPeriod( getDay( 1 ), getDay( 2 ), periodTypeB ) );
 
306
        assertNull( periodStore.getPeriod( getDay( 2 ), getDay( 3 ), periodTypeA ) );
 
307
        assertNull( periodStore.getPeriod( getDay( 0 ), getDay( 5 ), periodTypeB ) );
 
308
        assertNull( periodStore.getPeriod( getDay( 4 ), getDay( 3 ), periodTypeB ) );
 
309
        assertNull( periodStore.getPeriod( getDay( 5 ), getDay( 6 ), periodTypeA ) );
 
310
        
 
311
        transactionManager.leave();
 
312
    }
 
313
    
 
314
    public void testGetAllPeriods()
 
315
        throws Exception
 
316
    {
 
317
        PeriodType periodType = periodStore.getAllPeriodTypes().iterator().next();
 
318
 
 
319
        Period periodA = new Period( periodType, getDay( 0 ), getDay( 1 ) );
 
320
        Period periodB = new Period( periodType, getDay( 1 ), getDay( 2 ) );
 
321
        Period periodC = new Period( periodType, getDay( 2 ), getDay( 3 ) );
 
322
        
 
323
        periodStore.addPeriod( periodA );
 
324
        periodStore.addPeriod( periodB );
 
325
        periodStore.addPeriod( periodC );
 
326
        
 
327
        Collection<Period> periods = periodStore.getAllPeriods();
 
328
        
 
329
        assertNotNull( periods );
 
330
        assertEquals( 3, periods.size() );
 
331
        assertTrue( periods.contains( periodA ) );
 
332
        assertTrue( periods.contains( periodB ) );
 
333
        assertTrue( periods.contains( periodC ) );        
 
334
    }
 
335
    
 
336
    public void testGetPeriodsBetweenDates()
 
337
        throws Exception
 
338
    {
 
339
        transactionManager.enter();
 
340
 
 
341
        Collection<PeriodType> periodTypes = periodStore.getAllPeriodTypes();
 
342
        Iterator<PeriodType> it = periodTypes.iterator();
 
343
        PeriodType periodTypeA = it.next();
 
344
        PeriodType periodTypeB = it.next();
 
345
 
 
346
        Period periodA = new Period( periodTypeA, getDay( 0 ), getDay( 1 ) );
 
347
        Period periodB = new Period( periodTypeA, getDay( 1 ), getDay( 2 ) );
 
348
        Period periodC = new Period( periodTypeB, getDay( 2 ), getDay( 3 ) );
 
349
        Period periodD = new Period( periodTypeB, getDay( 3 ), getDay( 4 ) );
 
350
        periodStore.addPeriod( periodA );
 
351
        periodStore.addPeriod( periodB );
 
352
        periodStore.addPeriod( periodC );
 
353
        periodStore.addPeriod( periodD );
 
354
 
 
355
        Collection<Period> periods = periodStore.getPeriodsBetweenDates( getDay( 0 ), getDay( 0 ) );
 
356
        assertNotNull( periods );
 
357
        assertEquals( 0, periods.size() );
 
358
 
 
359
        periods = periodStore.getPeriodsBetweenDates( getDay( 0 ), getDay( 1 ) );
 
360
        assertNotNull( periods );
 
361
        assertEquals( 1, periods.size() );
 
362
        assertEquals( periodA, periods.iterator().next() );
 
363
 
 
364
        periods = periodStore.getPeriodsBetweenDates( getDay( 1 ), getDay( 4 ) );
 
365
        assertNotNull( periods );
 
366
        assertEquals( 3, periods.size() );
 
367
        assertTrue( periods.contains( periodB ) );
 
368
        assertTrue( periods.contains( periodC ) );
 
369
        assertTrue( periods.contains( periodD ) );
 
370
 
 
371
        periods = periodStore.getPeriodsBetweenDates( getDay( 0 ), getDay( 5 ) );
 
372
        assertNotNull( periods );
 
373
        assertEquals( 4, periods.size() );
 
374
        assertTrue( periods.contains( periodA ) );
 
375
        assertTrue( periods.contains( periodB ) );
 
376
        assertTrue( periods.contains( periodC ) );
 
377
        assertTrue( periods.contains( periodD ) );
 
378
 
 
379
        transactionManager.leave();
 
380
    }
 
381
 
 
382
    public void testGetIntersectingPeriodsByPeriodType()
 
383
        throws Exception
 
384
    {
 
385
        transactionManager.enter();
 
386
        
 
387
        PeriodType ypt = PeriodType.getPeriodTypeByName( "Yearly" );
 
388
        
 
389
        Date jan2006 = getDate(1, 1, 2006);
 
390
        Date dec2006 = getDate(31, 12, 2006);
 
391
        Date jan2007 = getDate(1, 1, 2007);
 
392
        Date dec2007 = getDate(31, 12, 2007);
 
393
        
 
394
        Period periodA = new Period(ypt, jan2006, dec2006);
 
395
        Period periodB = new Period(ypt, jan2007, dec2007);     
 
396
        periodStore.addPeriod(periodA);
 
397
        periodStore.addPeriod(periodB);         
 
398
        
 
399
        PeriodType mpt = PeriodType.getPeriodTypeByName( "Monthly" );
 
400
        
 
401
        Date janstart = getDate(1,1,2006);
 
402
        Date janend = getDate(31,1,2006);
 
403
        Date febstart = getDate(1,2,2006);
 
404
        Date febend = getDate(28,2,2006);
 
405
        Date marstart = getDate(1,3,2006);
 
406
        Date marend = getDate(31,3,2006);
 
407
        Date aprstart = getDate(1,4,2006);
 
408
        Date aprend = getDate(30,4,2006);
 
409
        Date maystart = getDate(1,5,2006);
 
410
        Date mayend = getDate(31,5,2006);
 
411
        Date junstart = getDate(1,6,2006);
 
412
        Date junend = getDate(30,6,2006);
 
413
        Date julstart = getDate(1,7,2006);
 
414
        Date julend = getDate(31,7,2006);
 
415
        Date augstart = getDate(1,8,2006);
 
416
        Date augend = getDate(31,8,2006);
 
417
        Date sepstart = getDate(1,9,2006);
 
418
        Date sepend = getDate(30,9,2006);
 
419
        Date octstart = getDate(1,10,2006);
 
420
        Date octend = getDate(31,10,2006);
 
421
        Date novstart = getDate(1,11,2006);
 
422
        Date novend = getDate(30,11,2006);
 
423
        Date decstart = getDate(1,12,2006);
 
424
        Date decend = getDate(31,12,2006);
 
425
        
 
426
        Period periodC = new Period(mpt,janstart,janend);
 
427
        Period periodD = new Period(mpt,febstart,febend);
 
428
        Period periodE = new Period(mpt,marstart,marend);
 
429
        Period periodF = new Period(mpt,aprstart,aprend);
 
430
        Period periodG = new Period(mpt,maystart,mayend);
 
431
        Period periodH = new Period(mpt,junstart,junend);
 
432
        Period periodI = new Period(mpt,julstart,julend);
 
433
        Period periodJ = new Period(mpt,augstart,augend);
 
434
        Period periodK = new Period(mpt,sepstart,sepend);
 
435
        Period periodL = new Period(mpt,octstart,octend);
 
436
        Period periodM = new Period(mpt,novstart,novend);
 
437
        Period periodN = new Period(mpt,decstart,decend);
 
438
        
 
439
        periodStore.addPeriod(periodC);
 
440
        periodStore.addPeriod(periodD);
 
441
        periodStore.addPeriod(periodE);
 
442
        periodStore.addPeriod(periodF);
 
443
        periodStore.addPeriod(periodG);
 
444
        periodStore.addPeriod(periodH);
 
445
        periodStore.addPeriod(periodI);
 
446
        periodStore.addPeriod(periodJ);
 
447
        periodStore.addPeriod(periodK);
 
448
        periodStore.addPeriod(periodL);
 
449
        periodStore.addPeriod(periodM);
 
450
        periodStore.addPeriod(periodN);
 
451
        
 
452
        Collection<Period> periodsA = periodStore.getIntersectingPeriodsByPeriodType(ypt, getDate(1,6,2006), getDate(30,11,2006)); 
 
453
        assertNotNull( periodsA );
 
454
        assertEquals( 1, periodsA.size() );
 
455
        
 
456
        Collection<Period> periodsB = periodStore.getIntersectingPeriodsByPeriodType(mpt, getDate(1,6,2006), getDate(30,11,2006));      
 
457
        assertNotNull( periodsB );
 
458
        assertEquals( 6, periodsB.size() );
 
459
        
 
460
        transactionManager.leave();
 
461
    }
 
462
    
 
463
    public void testGetIntersectingPeriods()
 
464
        throws Exception
 
465
    {
 
466
        PeriodType type = periodStore.getAllPeriodTypes().iterator().next();
 
467
        
 
468
        Period periodA = new Period( type, getDay( 0 ), getDay( 2 ) );
 
469
        Period periodB = new Period( type, getDay( 2 ), getDay( 4 ) );
 
470
        Period periodC = new Period( type, getDay( 4 ), getDay( 6 ) );
 
471
        Period periodD = new Period( type, getDay( 6 ), getDay( 8 ) );
 
472
        Period periodE = new Period( type, getDay( 8 ), getDay( 10 ) );
 
473
        Period periodF = new Period( type, getDay( 10 ), getDay( 12 ) );
 
474
        Period periodG = new Period( type, getDay( 12 ), getDay( 14 ) );
 
475
        Period periodH = new Period( type, getDay( 2 ), getDay( 6 ) );
 
476
        Period periodI = new Period( type, getDay( 8 ), getDay( 12 ) );
 
477
        Period periodJ = new Period( type, getDay( 2 ), getDay( 12 ) );
 
478
        
 
479
        periodStore.addPeriod( periodA );
 
480
        periodStore.addPeriod( periodB );
 
481
        periodStore.addPeriod( periodC );
 
482
        periodStore.addPeriod( periodD );
 
483
        periodStore.addPeriod( periodE );
 
484
        periodStore.addPeriod( periodF );
 
485
        periodStore.addPeriod( periodG );
 
486
        periodStore.addPeriod( periodH );
 
487
        periodStore.addPeriod( periodI );
 
488
        periodStore.addPeriod( periodJ );
 
489
        
 
490
        Collection<Period> periods = periodStore.getIntersectingPeriods( getDay( 4 ), getDay( 10 ) );
 
491
        
 
492
        assertEquals( periods.size(), 6 );
 
493
        
 
494
        assertTrue( periods.contains( periodC ) );
 
495
        assertTrue( periods.contains( periodD ) );
 
496
        assertTrue( periods.contains( periodE ) );
 
497
        assertTrue( periods.contains( periodH ) );
 
498
        assertTrue( periods.contains( periodI ) );
 
499
        assertTrue( periods.contains( periodJ ) );
 
500
    }
 
501
    
 
502
    public void testGetPeriodsByPeriodType()
 
503
        throws Exception
 
504
    {
 
505
        transactionManager.enter();
 
506
 
 
507
        Collection<PeriodType> periodTypes = periodStore.getAllPeriodTypes();
 
508
        Iterator<PeriodType> it = periodTypes.iterator();
 
509
        PeriodType periodTypeA = it.next();
 
510
        PeriodType periodTypeB = it.next();
 
511
        PeriodType periodTypeC = it.next();
 
512
 
 
513
        Period periodA = new Period( periodTypeA, getDay( 0 ), getDay( 1 ) );
 
514
        Period periodB = new Period( periodTypeA, getDay( 1 ), getDay( 2 ) );
 
515
        Period periodC = new Period( periodTypeA, getDay( 2 ), getDay( 3 ) );
 
516
        Period periodD = new Period( periodTypeB, getDay( 3 ), getDay( 4 ) );
 
517
        periodStore.addPeriod( periodA );
 
518
        periodStore.addPeriod( periodB );
 
519
        periodStore.addPeriod( periodC );
 
520
        periodStore.addPeriod( periodD );
 
521
 
 
522
        Collection<Period> periodsARef = new HashSet<Period>();
 
523
        periodsARef.add( periodA );
 
524
        periodsARef.add( periodB );
 
525
        periodsARef.add( periodC );
 
526
 
 
527
        Collection<Period> periodsA = periodStore.getPeriodsByPeriodType( periodTypeA );
 
528
        assertNotNull( periodsA );
 
529
        assertEquals( periodsARef.size(), periodsA.size() );
 
530
        assertTrue( periodsA.containsAll( periodsARef ) );
 
531
 
 
532
        Collection<Period> periodsB = periodStore.getPeriodsByPeriodType( periodTypeB );
 
533
        assertNotNull( periodsB );
 
534
        assertEquals( 1, periodsB.size() );
 
535
        assertEquals( periodD, periodsB.iterator().next() );
 
536
 
 
537
        Collection<Period> periodsC = periodStore.getPeriodsByPeriodType( periodTypeC );
 
538
        assertNotNull( periodsC );
 
539
        assertEquals( 0, periodsC.size() );
 
540
 
 
541
        transactionManager.leave();
 
542
    }
 
543
 
 
544
    public void testGetPeriodsWithAssociatedDataValues()
 
545
        throws Exception
 
546
    {
 
547
        DataElement dataElementA = createDataElement( 'A' );   
 
548
        DataElement dataElementB = createDataElement( 'B' );
 
549
        DataElement dataElementC = createDataElement( 'C' );
 
550
    
 
551
        PeriodType quarterly = PeriodType.getPeriodTypeByName( QuarterlyPeriodType.NAME );
 
552
        PeriodType monthly = PeriodType.getPeriodTypeByName( MonthlyPeriodType.NAME );
 
553
        PeriodType weekly = PeriodType.getPeriodTypeByName( WeeklyPeriodType.NAME );
 
554
        
 
555
        Period qu1 = new Period( quarterly, getDate( 1, 1, 2008 ), getDate( 31, 3, 2008 ) );
 
556
        
 
557
        Period jan = new Period( monthly, getDate( 1, 1, 2008 ), getDate( 31, 1, 2008 ) );
 
558
        Period feb = new Period( monthly, getDate( 1, 2, 2008 ), getDate( 29, 2, 2008 ) );
 
559
        Period mar = new Period( monthly, getDate( 1, 3, 2008 ), getDate( 31, 3, 2008 ) );
 
560
        Period apr = new Period( monthly, getDate( 1, 4, 2008 ), getDate( 30, 4, 2008 ) );
 
561
        Period may = new Period( monthly, getDate( 1, 5, 2008 ), getDate( 31, 5, 2008 ) );
 
562
        
 
563
        Period w01 = new Period( weekly, getDate( 31, 12, 2007 ), getDate( 6, 1, 2008 ) );
 
564
        Period w02 = new Period( weekly, getDate( 7, 1, 2008 ), getDate( 13, 1, 2008 ) );
 
565
        Period w03 = new Period( weekly, getDate( 14, 1, 2008 ), getDate( 20, 1, 2008 ) );
 
566
        Period w04 = new Period( weekly, getDate( 21, 1, 2008 ), getDate( 27, 1, 2008 ) );
 
567
        Period w05 = new Period( weekly, getDate( 28, 1, 2008 ), getDate( 3, 2, 2008 ) );
 
568
                
 
569
        Source sourceA = new DummySource( "SourceA" );
 
570
        Source sourceB = new DummySource( "SourceB" );
 
571
        Source sourceC = new DummySource( "SourceC" );
 
572
        
 
573
        DataValue dataValueA = new DataValue( dataElementA, jan, sourceA, optionCombo );
 
574
        dataValueA.setValue( "1" );
 
575
        DataValue dataValueB = new DataValue( dataElementA, feb, sourceB, optionCombo );
 
576
        dataValueB.setValue( "2" );
 
577
        DataValue dataValueC = new DataValue( dataElementA, apr, sourceB, optionCombo );
 
578
        dataValueC.setValue( "3" );
 
579
        DataValue dataValueD = new DataValue( dataElementA, qu1, sourceA, optionCombo );
 
580
        dataValueD.setValue( "4" );
 
581
        DataValue dataValueE = new DataValue( dataElementB, w01, sourceA, optionCombo );
 
582
        dataValueE.setValue( "5" );
 
583
        DataValue dataValueF = new DataValue( dataElementB, w02, sourceB, optionCombo );
 
584
        dataValueF.setValue( "6" );
 
585
        DataValue dataValueG = new DataValue( dataElementB, w03, sourceA, optionCombo );
 
586
        dataValueG.setValue( "7" );
 
587
        DataValue dataValueH = new DataValue( dataElementB, w04, sourceB, optionCombo );
 
588
        dataValueH.setValue( "8" );
 
589
        DataValue dataValueI = new DataValue( dataElementB, w05, sourceA, optionCombo );
 
590
        dataValueI.setValue( "9" );
 
591
        
 
592
        transactionManager.enter();
 
593
    
 
594
        dataElementStore.addDataElement( dataElementA );
 
595
        dataElementStore.addDataElement( dataElementB );
 
596
        dataElementStore.addDataElement( dataElementC );
 
597
     
 
598
        sourceStore.addSource( sourceA );
 
599
        sourceStore.addSource( sourceB );
 
600
        sourceStore.addSource( sourceC );
 
601
        
 
602
        dataValueStore.addDataValue( dataValueA );
 
603
        dataValueStore.addDataValue( dataValueB );
 
604
        dataValueStore.addDataValue( dataValueC );
 
605
        dataValueStore.addDataValue( dataValueD );
 
606
        dataValueStore.addDataValue( dataValueE );
 
607
        dataValueStore.addDataValue( dataValueF );
 
608
        dataValueStore.addDataValue( dataValueG );
 
609
        dataValueStore.addDataValue( dataValueH );
 
610
        dataValueStore.addDataValue( dataValueI );
 
611
        
 
612
        transactionManager.leave();
 
613
                
 
614
        Collection<DataElement> dataElements1 = new ArrayList<DataElement>();
 
615
        
 
616
        dataElements1.add( dataElementA );
 
617
        dataElements1.add( dataElementB );
 
618
        
 
619
        Collection<DataElement> dataElements2 = new ArrayList<DataElement>();
 
620
        
 
621
        dataElements2.add( dataElementC );
 
622
        
 
623
        Collection<Source> sources1 = new ArrayList<Source>();
 
624
        
 
625
        sources1.add( sourceA );
 
626
        sources1.add( sourceB );
 
627
        
 
628
        Collection<Source> sources2 = new ArrayList<Source>();
 
629
        
 
630
        sources2.add( sourceC );
 
631
        
 
632
        Collection<Period> periods = periodStore.getPeriods( jan, dataElements1, sources1 );
 
633
        
 
634
        assertEquals( periods.size(), 7 );
 
635
 
 
636
        periods = periodStore.getPeriods( feb, dataElements1, sources1 );
 
637
        
 
638
        assertEquals( periods.size(), 3 );
 
639
        
 
640
        periods = periodStore.getPeriods( mar, dataElements1, sources1 );
 
641
 
 
642
        assertEquals( periods.size(), 1 );
 
643
        
 
644
        periods = periodStore.getPeriods( apr, dataElements1, sources1 );
 
645
 
 
646
        assertEquals( periods.size(), 1 );
 
647
        
 
648
        periods = periodStore.getPeriods( may, dataElements1, sources1 );
 
649
 
 
650
        assertEquals( periods.size(), 0 );
 
651
        
 
652
        periods = periodStore.getPeriods( jan, dataElements1, sources2 );
 
653
        
 
654
        assertEquals( periods.size(), 0 );
 
655
        
 
656
        periods = periodStore.getPeriods( feb, dataElements2, sources1 );
 
657
 
 
658
        assertEquals( periods.size(), 0 );
 
659
        
 
660
        periods = periodStore.getPeriods( mar, dataElements2, sources2 );
 
661
    }
 
662
    
 
663
    // -------------------------------------------------------------------------
 
664
    // PeriodType
 
665
    // -------------------------------------------------------------------------
 
666
 
 
667
    public void testAddPeriodType()
 
668
        throws Exception
 
669
    {
 
670
        Collection<PeriodType> periodTypes = periodStore.getAllPeriodTypes();
 
671
        Iterator<PeriodType> it = periodTypes.iterator();
 
672
        PeriodType refA = it.next();
 
673
        PeriodType refB = it.next();
 
674
        PeriodType refC = it.next();
 
675
 
 
676
        periodStore.deletePeriodType( refA );
 
677
        periodStore.deletePeriodType( refB );
 
678
        periodStore.deletePeriodType( refC );
 
679
 
 
680
        int idA = periodStore.addPeriodType( refA );
 
681
        int idB = periodStore.addPeriodType( refB );
 
682
        int idC = periodStore.addPeriodType( refC );
 
683
 
 
684
        PeriodType periodTypeA = periodStore.getPeriodType( idA );
 
685
        assertNotNull( periodTypeA );
 
686
        assertEquals( idA, periodTypeA.getId() );
 
687
        assertEquals( refA.getName(), periodTypeA.getName() );
 
688
 
 
689
        PeriodType periodTypeB = periodStore.getPeriodType( idB );
 
690
        assertNotNull( periodTypeB );
 
691
        assertEquals( idB, periodTypeB.getId() );
 
692
        assertEquals( refB.getName(), periodTypeB.getName() );
 
693
 
 
694
        PeriodType periodTypeC = periodStore.getPeriodType( idC );
 
695
        assertNotNull( periodTypeC );
 
696
        assertEquals( idC, periodTypeC.getId() );
 
697
        assertEquals( refC.getName(), periodTypeC.getName() );
 
698
    }
 
699
 
 
700
    public void testDeleteAndGetPeriodType()
 
701
        throws Exception
 
702
    {
 
703
        Collection<PeriodType> periodTypes = periodStore.getAllPeriodTypes();
 
704
        Iterator<PeriodType> it = periodTypes.iterator();
 
705
        PeriodType periodTypeA = it.next();
 
706
        PeriodType periodTypeB = it.next();
 
707
        PeriodType periodTypeC = it.next();
 
708
        PeriodType periodTypeD = it.next();
 
709
 
 
710
        int idA = periodTypeA.getId();
 
711
        int idB = periodTypeB.getId();
 
712
        int idC = periodTypeC.getId();
 
713
        int idD = periodTypeD.getId();
 
714
 
 
715
        assertNotNull( periodStore.getPeriodType( idA ) );
 
716
        assertNotNull( periodStore.getPeriodType( idB ) );
 
717
        assertNotNull( periodStore.getPeriodType( idC ) );
 
718
        assertNotNull( periodStore.getPeriodType( idD ) );
 
719
 
 
720
        assertNotNull( periodStore.getPeriodType( periodTypeA.getClass() ) );
 
721
        assertNotNull( periodStore.getPeriodType( periodTypeB.getClass() ) );
 
722
        assertNotNull( periodStore.getPeriodType( periodTypeC.getClass() ) );
 
723
        assertNotNull( periodStore.getPeriodType( periodTypeD.getClass() ) );
 
724
 
 
725
        periodStore.deletePeriodType( periodTypeA );
 
726
        assertNull( periodStore.getPeriodType( idA ) );
 
727
        assertNotNull( periodStore.getPeriodType( idB ) );
 
728
        assertNotNull( periodStore.getPeriodType( idC ) );
 
729
        assertNotNull( periodStore.getPeriodType( idD ) );
 
730
        
 
731
        assertNull( periodStore.getPeriodType( periodTypeA.getClass() ) );
 
732
        assertNotNull( periodStore.getPeriodType( periodTypeB.getClass() ) );
 
733
        assertNotNull( periodStore.getPeriodType( periodTypeC.getClass() ) );
 
734
        assertNotNull( periodStore.getPeriodType( periodTypeD.getClass() ) );
 
735
 
 
736
        periodStore.deletePeriodType( periodTypeB );
 
737
        assertNull( periodStore.getPeriodType( idA ) );
 
738
        assertNull( periodStore.getPeriodType( idB ) );
 
739
        assertNotNull( periodStore.getPeriodType( idC ) );
 
740
        assertNotNull( periodStore.getPeriodType( idD ) );
 
741
        
 
742
        assertNull( periodStore.getPeriodType( periodTypeA.getClass() ) );
 
743
        assertNull( periodStore.getPeriodType( periodTypeB.getClass() ) );
 
744
        assertNotNull( periodStore.getPeriodType( periodTypeC.getClass() ) );
 
745
        assertNotNull( periodStore.getPeriodType( periodTypeD.getClass() ) );
 
746
 
 
747
        periodStore.deletePeriodType( periodTypeC );
 
748
        assertNull( periodStore.getPeriodType( idA ) );
 
749
        assertNull( periodStore.getPeriodType( idB ) );
 
750
        assertNull( periodStore.getPeriodType( idC ) );
 
751
        assertNotNull( periodStore.getPeriodType( idD ) );
 
752
        
 
753
        assertNull( periodStore.getPeriodType( periodTypeA.getClass() ) );
 
754
        assertNull( periodStore.getPeriodType( periodTypeB.getClass() ) );
 
755
        assertNull( periodStore.getPeriodType( periodTypeC.getClass() ) );
 
756
        assertNotNull( periodStore.getPeriodType( periodTypeD.getClass() ) );
 
757
 
 
758
        periodStore.deletePeriodType( periodTypeD );
 
759
        assertNull( periodStore.getPeriodType( idA ) );
 
760
        assertNull( periodStore.getPeriodType( idB ) );
 
761
        assertNull( periodStore.getPeriodType( idC ) );
 
762
        assertNull( periodStore.getPeriodType( idD ) );
 
763
        
 
764
        assertNull( periodStore.getPeriodType( periodTypeA.getClass() ) );
 
765
        assertNull( periodStore.getPeriodType( periodTypeB.getClass() ) );
 
766
        assertNull( periodStore.getPeriodType( periodTypeC.getClass() ) );
 
767
        assertNull( periodStore.getPeriodType( periodTypeD.getClass() ) );
 
768
    }
 
769
}