← 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/datavalue/DataValueStoreTest.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/datavalue/DataValueStoreTest.java
 
1
package org.hisp.dhis.datavalue;
 
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.Calendar;
 
31
import java.util.Collection;
 
32
import java.util.Date;
 
33
import java.util.HashSet;
 
34
 
 
35
import org.hisp.dhis.DhisConvenienceTest;
 
36
import org.hisp.dhis.dataelement.DataElement;
 
37
import org.hisp.dhis.dataelement.DataElementCategoryOptionCombo;
 
38
import org.hisp.dhis.dataelement.DataElementCategoryOptionComboService;
 
39
import org.hisp.dhis.dataelement.DataElementStore;
 
40
import org.hisp.dhis.period.Period;
 
41
import org.hisp.dhis.period.PeriodStore;
 
42
import org.hisp.dhis.period.PeriodType;
 
43
import org.hisp.dhis.source.DummySource;
 
44
import org.hisp.dhis.source.Source;
 
45
import org.hisp.dhis.source.SourceStore;
 
46
import org.hisp.dhis.transaction.TransactionManager;
 
47
 
 
48
/**
 
49
 * @author Torgeir Lorange Ostby
 
50
 * @version $Id: DataValueStoreTest.java 5715 2008-09-17 14:05:28Z larshelg $
 
51
 */
 
52
public class DataValueStoreTest
 
53
    extends DhisConvenienceTest
 
54
{
 
55
    private DataValueStore dataValueStore;
 
56
 
 
57
    private DataElementStore dataElementStore;
 
58
    
 
59
    private PeriodStore periodStore;
 
60
 
 
61
    private SourceStore sourceStore;
 
62
 
 
63
    private TransactionManager transactionManager;
 
64
    
 
65
    private Calendar calendar = Calendar.getInstance();
 
66
 
 
67
    // -------------------------------------------------------------------------
 
68
    // Supporting data
 
69
    // -------------------------------------------------------------------------
 
70
 
 
71
    private DataElement dataElementA;
 
72
 
 
73
    private DataElement dataElementB;
 
74
 
 
75
    private DataElement dataElementC;
 
76
 
 
77
    private DataElement dataElementD;
 
78
 
 
79
    private DataElementCategoryOptionCombo optionCombo;
 
80
    
 
81
    private Period periodA;
 
82
 
 
83
    private Period periodB;
 
84
 
 
85
    private Period periodC;
 
86
 
 
87
    private Period periodD;
 
88
 
 
89
    private Source sourceA;
 
90
 
 
91
    private Source sourceB;
 
92
 
 
93
    private Source sourceC;
 
94
 
 
95
    private Source sourceD;
 
96
 
 
97
    // -------------------------------------------------------------------------
 
98
    // Set up/tear down
 
99
    // -------------------------------------------------------------------------
 
100
 
 
101
    public void setUpTest()
 
102
        throws Exception
 
103
    {
 
104
        dataValueStore = (DataValueStore) getBean( DataValueStore.ID );
 
105
        
 
106
        dataElementStore = (DataElementStore) getBean( DataElementStore.ID );
 
107
 
 
108
        categoryOptionComboService = (DataElementCategoryOptionComboService) getBean( DataElementCategoryOptionComboService.ID );
 
109
        
 
110
        periodStore = (PeriodStore) getBean( PeriodStore.ID );
 
111
        
 
112
        sourceStore = (SourceStore) getBean( SourceStore.ID );
 
113
        
 
114
        transactionManager = (TransactionManager) getBean( TransactionManager.ID );
 
115
        
 
116
        // ---------------------------------------------------------------------
 
117
        // Add supporting data
 
118
        // ---------------------------------------------------------------------
 
119
 
 
120
        dataElementA = createDataElement( 'A' );
 
121
        dataElementB = createDataElement( 'B' );
 
122
        dataElementC = createDataElement( 'C' );
 
123
        dataElementD = createDataElement( 'D' );
 
124
        
 
125
        dataElementStore.addDataElement( dataElementA );
 
126
        dataElementStore.addDataElement( dataElementB );
 
127
        dataElementStore.addDataElement( dataElementC );
 
128
        dataElementStore.addDataElement( dataElementD );
 
129
 
 
130
        PeriodType periodType = periodStore.getAllPeriodTypes().iterator().next();
 
131
        periodA = new Period( periodType, getDay( 5 ), getDay( 6 ) );
 
132
        periodB = new Period( periodType, getDay( 6 ), getDay( 7 ) );
 
133
        periodC = new Period( periodType, getDay( 7 ), getDay( 8 ) );
 
134
        periodD = new Period( periodType, getDay( 8 ), getDay( 9 ) );
 
135
 
 
136
        periodStore.addPeriod( periodA );
 
137
        periodStore.addPeriod( periodB );
 
138
        periodStore.addPeriod( periodC );
 
139
        periodStore.addPeriod( periodD );
 
140
 
 
141
        sourceA = new DummySource( "SourceA" );
 
142
        sourceB = new DummySource( "SourceB" );
 
143
        sourceC = new DummySource( "SourceC" );
 
144
        sourceD = new DummySource( "SourceD" );
 
145
 
 
146
        sourceStore.addSource( sourceA );
 
147
        sourceStore.addSource( sourceB );
 
148
        sourceStore.addSource( sourceC );
 
149
        sourceStore.addSource( sourceD );        
 
150
 
 
151
        optionCombo = new DataElementCategoryOptionCombo();
 
152
        
 
153
        categoryOptionComboService.addDataElementCategoryOptionCombo( optionCombo );
 
154
    }
 
155
 
 
156
    // -------------------------------------------------------------------------
 
157
    // Support methods
 
158
    // -------------------------------------------------------------------------
 
159
 
 
160
    private Date getDay( int day )
 
161
    {
 
162
        calendar.clear();
 
163
        calendar.set( Calendar.DAY_OF_YEAR, day );
 
164
 
 
165
        return calendar.getTime();
 
166
    }
 
167
 
 
168
    // -------------------------------------------------------------------------
 
169
    // Basic DataValue
 
170
    // -------------------------------------------------------------------------
 
171
 
 
172
    public void testAddDataValue()
 
173
        throws Exception
 
174
    {
 
175
        DataValue dataValueA = new DataValue( dataElementA, periodA, sourceA, optionCombo );
 
176
        dataValueA.setValue( "1" );
 
177
        DataValue dataValueB = new DataValue( dataElementB, periodA, sourceA, optionCombo );
 
178
        dataValueB.setValue( "2" );
 
179
        DataValue dataValueC = new DataValue( dataElementC, periodC, sourceA, optionCombo );
 
180
        dataValueC.setValue( "3" );
 
181
        DataValue dataValueD = new DataValue( dataElementA, periodA, sourceA, optionCombo );
 
182
        dataValueD.setValue( "4" );
 
183
 
 
184
        dataValueStore.addDataValue( dataValueA );
 
185
        dataValueStore.addDataValue( dataValueB );
 
186
        dataValueStore.addDataValue( dataValueC );
 
187
 
 
188
        try
 
189
        {
 
190
            // Should give unique constraint violation
 
191
            dataValueStore.addDataValue( dataValueD );
 
192
            fail();
 
193
        }
 
194
        catch ( Exception e )
 
195
        {
 
196
            // Expected
 
197
        }
 
198
 
 
199
        transactionManager.enter();
 
200
 
 
201
        dataValueA = dataValueStore.getDataValue( sourceA, dataElementA, periodA );
 
202
        assertNotNull( dataValueA );
 
203
        assertEquals( sourceA.getId(), dataValueA.getSource().getId() );
 
204
        assertEquals( dataElementA, dataValueA.getDataElement() );
 
205
        assertEquals( periodA, dataValueA.getPeriod() );
 
206
        assertEquals( "1", dataValueA.getValue() );
 
207
 
 
208
        transactionManager.leave();
 
209
        transactionManager.enter();
 
210
 
 
211
        dataValueB = dataValueStore.getDataValue( sourceA, dataElementB, periodA );
 
212
        assertNotNull( dataValueB );
 
213
        assertEquals( sourceA.getId(), dataValueB.getSource().getId() );
 
214
        assertEquals( dataElementB, dataValueB.getDataElement() );
 
215
        assertEquals( periodA, dataValueB.getPeriod() );
 
216
        assertEquals( "2", dataValueB.getValue() );
 
217
 
 
218
        transactionManager.leave();
 
219
        transactionManager.enter();
 
220
 
 
221
        dataValueC = dataValueStore.getDataValue( sourceA, dataElementC, periodC );
 
222
        assertNotNull( dataValueC );
 
223
        assertEquals( sourceA.getId(), dataValueC.getSource().getId() );
 
224
        assertEquals( dataElementC, dataValueC.getDataElement() );
 
225
        assertEquals( periodC, dataValueC.getPeriod() );
 
226
        assertEquals( "3", dataValueC.getValue() );
 
227
 
 
228
        transactionManager.leave();
 
229
    }
 
230
 
 
231
    public void testUpdataDataValue()
 
232
        throws Exception
 
233
    {
 
234
        DataValue dataValueA = new DataValue( dataElementA, periodA, sourceA, optionCombo );
 
235
        dataValueA.setValue( "1" );
 
236
        DataValue dataValueB = new DataValue( dataElementB, periodA, sourceB, optionCombo );
 
237
        dataValueB.setValue( "2" );
 
238
 
 
239
        dataValueStore.addDataValue( dataValueA );
 
240
        dataValueStore.addDataValue( dataValueB );
 
241
 
 
242
        assertNotNull( dataValueStore.getDataValue( sourceA, dataElementA, periodA ) );
 
243
        assertNotNull( dataValueStore.getDataValue( sourceB, dataElementB, periodA ) );
 
244
 
 
245
        dataValueA.setValue( "5" );
 
246
        dataValueStore.updateDataValue( dataValueA );
 
247
 
 
248
        dataValueA = dataValueStore.getDataValue( sourceA, dataElementA, periodA );
 
249
        assertNotNull( dataValueA );
 
250
        assertEquals( "5", dataValueA.getValue() );
 
251
 
 
252
        dataValueB = dataValueStore.getDataValue( sourceB, dataElementB, periodA );
 
253
        assertNotNull( dataValueB );
 
254
        assertEquals( "2", dataValueB.getValue() );
 
255
    }
 
256
 
 
257
    public void testDeleteAndGetDataValue()
 
258
        throws Exception
 
259
    {
 
260
        DataValue dataValueA = new DataValue( dataElementA, periodA, sourceA, optionCombo );
 
261
        dataValueA.setValue( "1" );
 
262
        DataValue dataValueB = new DataValue( dataElementB, periodA, sourceA, optionCombo );
 
263
        dataValueB.setValue( "2" );
 
264
        DataValue dataValueC = new DataValue( dataElementC, periodC, sourceD, optionCombo );
 
265
        dataValueC.setValue( "3" );
 
266
        DataValue dataValueD = new DataValue( dataElementD, periodC, sourceB, optionCombo );
 
267
        dataValueD.setValue( "4" );
 
268
 
 
269
        dataValueStore.addDataValue( dataValueA );
 
270
        dataValueStore.addDataValue( dataValueB );
 
271
        dataValueStore.addDataValue( dataValueC );
 
272
        dataValueStore.addDataValue( dataValueD );
 
273
 
 
274
        assertNotNull( dataValueStore.getDataValue( sourceA, dataElementA, periodA ) );
 
275
        assertNotNull( dataValueStore.getDataValue( sourceA, dataElementB, periodA ) );
 
276
        assertNotNull( dataValueStore.getDataValue( sourceD, dataElementC, periodC ) );
 
277
        assertNotNull( dataValueStore.getDataValue( sourceB, dataElementD, periodC ) );
 
278
 
 
279
        dataValueStore.deleteDataValue( dataValueA );
 
280
        assertNull( dataValueStore.getDataValue( sourceA, dataElementA, periodA ) );
 
281
        assertNotNull( dataValueStore.getDataValue( sourceA, dataElementB, periodA ) );
 
282
        assertNotNull( dataValueStore.getDataValue( sourceD, dataElementC, periodC ) );
 
283
        assertNotNull( dataValueStore.getDataValue( sourceB, dataElementD, periodC ) );
 
284
 
 
285
        dataValueStore.deleteDataValue( dataValueB );
 
286
        assertNull( dataValueStore.getDataValue( sourceA, dataElementA, periodA ) );
 
287
        assertNull( dataValueStore.getDataValue( sourceA, dataElementB, periodA ) );
 
288
        assertNotNull( dataValueStore.getDataValue( sourceD, dataElementC, periodC ) );
 
289
        assertNotNull( dataValueStore.getDataValue( sourceB, dataElementD, periodC ) );
 
290
 
 
291
        dataValueStore.deleteDataValue( dataValueC );
 
292
        assertNull( dataValueStore.getDataValue( sourceA, dataElementA, periodA ) );
 
293
        assertNull( dataValueStore.getDataValue( sourceA, dataElementB, periodA ) );
 
294
        assertNull( dataValueStore.getDataValue( sourceD, dataElementC, periodC ) );
 
295
        assertNotNull( dataValueStore.getDataValue( sourceB, dataElementD, periodC ) );
 
296
 
 
297
        dataValueStore.deleteDataValue( dataValueD );
 
298
        assertNull( dataValueStore.getDataValue( sourceA, dataElementA, periodA ) );
 
299
        assertNull( dataValueStore.getDataValue( sourceA, dataElementB, periodA ) );
 
300
        assertNull( dataValueStore.getDataValue( sourceD, dataElementC, periodC ) );
 
301
        assertNull( dataValueStore.getDataValue( sourceB, dataElementD, periodC ) );
 
302
    }
 
303
 
 
304
    public void testDeleteDataValuesBySource()
 
305
        throws Exception
 
306
    {
 
307
        DataValue dataValueA = new DataValue( dataElementA, periodA, sourceA, optionCombo );
 
308
        dataValueA.setValue( "1" );
 
309
        DataValue dataValueB = new DataValue( dataElementB, periodA, sourceA, optionCombo );
 
310
        dataValueB.setValue( "2" );
 
311
        DataValue dataValueC = new DataValue( dataElementC, periodC, sourceD, optionCombo );
 
312
        dataValueC.setValue( "3" );
 
313
        DataValue dataValueD = new DataValue( dataElementD, periodC, sourceB, optionCombo );
 
314
        dataValueD.setValue( "4" );
 
315
 
 
316
        dataValueStore.addDataValue( dataValueA );
 
317
        dataValueStore.addDataValue( dataValueB );
 
318
        dataValueStore.addDataValue( dataValueC );
 
319
        dataValueStore.addDataValue( dataValueD );
 
320
 
 
321
        assertNotNull( dataValueStore.getDataValue( sourceA, dataElementA, periodA ) );
 
322
        assertNotNull( dataValueStore.getDataValue( sourceA, dataElementB, periodA ) );
 
323
        assertNotNull( dataValueStore.getDataValue( sourceD, dataElementC, periodC ) );
 
324
        assertNotNull( dataValueStore.getDataValue( sourceB, dataElementD, periodC ) );
 
325
 
 
326
        dataValueStore.deleteDataValuesBySource( sourceA );
 
327
        assertNull( dataValueStore.getDataValue( sourceA, dataElementA, periodA ) );
 
328
        assertNull( dataValueStore.getDataValue( sourceA, dataElementB, periodA ) );
 
329
        assertNotNull( dataValueStore.getDataValue( sourceD, dataElementC, periodC ) );
 
330
        assertNotNull( dataValueStore.getDataValue( sourceB, dataElementD, periodC ) );
 
331
 
 
332
        dataValueStore.deleteDataValuesBySource( sourceB );
 
333
        assertNull( dataValueStore.getDataValue( sourceA, dataElementA, periodA ) );
 
334
        assertNull( dataValueStore.getDataValue( sourceA, dataElementB, periodA ) );
 
335
        assertNotNull( dataValueStore.getDataValue( sourceD, dataElementC, periodC ) );
 
336
        assertNull( dataValueStore.getDataValue( sourceB, dataElementD, periodC ) );
 
337
 
 
338
        dataValueStore.deleteDataValuesBySource( sourceC );
 
339
        assertNull( dataValueStore.getDataValue( sourceA, dataElementA, periodA ) );
 
340
        assertNull( dataValueStore.getDataValue( sourceA, dataElementB, periodA ) );
 
341
        assertNotNull( dataValueStore.getDataValue( sourceD, dataElementC, periodC ) );
 
342
        assertNull( dataValueStore.getDataValue( sourceB, dataElementD, periodC ) );
 
343
 
 
344
        dataValueStore.deleteDataValuesBySource( sourceD );
 
345
        assertNull( dataValueStore.getDataValue( sourceA, dataElementA, periodA ) );
 
346
        assertNull( dataValueStore.getDataValue( sourceA, dataElementB, periodA ) );
 
347
        assertNull( dataValueStore.getDataValue( sourceD, dataElementC, periodC ) );
 
348
        assertNull( dataValueStore.getDataValue( sourceB, dataElementD, periodC ) );
 
349
    }
 
350
 
 
351
    public void testDeleteDataValuesByDataElement()
 
352
        throws Exception
 
353
    {
 
354
        DataValue dataValueA = new DataValue( dataElementA, periodA, sourceA, optionCombo );
 
355
        dataValueA.setValue( "1" );
 
356
        DataValue dataValueB = new DataValue( dataElementB, periodA, sourceA, optionCombo );
 
357
        dataValueB.setValue( "2" );
 
358
        DataValue dataValueC = new DataValue( dataElementC, periodC, sourceD, optionCombo );
 
359
        dataValueC.setValue( "3" );
 
360
        DataValue dataValueD = new DataValue( dataElementD, periodC, sourceB, optionCombo );
 
361
        dataValueD.setValue( "4" );
 
362
 
 
363
        dataValueStore.addDataValue( dataValueA );
 
364
        dataValueStore.addDataValue( dataValueB );
 
365
        dataValueStore.addDataValue( dataValueC );
 
366
        dataValueStore.addDataValue( dataValueD );
 
367
 
 
368
        assertNotNull( dataValueStore.getDataValue( sourceA, dataElementA, periodA ) );
 
369
        assertNotNull( dataValueStore.getDataValue( sourceA, dataElementB, periodA ) );
 
370
        assertNotNull( dataValueStore.getDataValue( sourceD, dataElementC, periodC ) );
 
371
        assertNotNull( dataValueStore.getDataValue( sourceB, dataElementD, periodC ) );
 
372
 
 
373
        dataValueStore.deleteDataValuesByDataElement( dataElementA );
 
374
        assertNull( dataValueStore.getDataValue( sourceA, dataElementA, periodA ) );
 
375
        assertNotNull( dataValueStore.getDataValue( sourceA, dataElementB, periodA ) );
 
376
        assertNotNull( dataValueStore.getDataValue( sourceD, dataElementC, periodC ) );
 
377
        assertNotNull( dataValueStore.getDataValue( sourceB, dataElementD, periodC ) );
 
378
 
 
379
        dataValueStore.deleteDataValuesByDataElement( dataElementB );
 
380
        assertNull( dataValueStore.getDataValue( sourceA, dataElementA, periodA ) );
 
381
        assertNull( dataValueStore.getDataValue( sourceA, dataElementB, periodA ) );
 
382
        assertNotNull( dataValueStore.getDataValue( sourceD, dataElementC, periodC ) );
 
383
        assertNotNull( dataValueStore.getDataValue( sourceB, dataElementD, periodC ) );
 
384
 
 
385
        dataValueStore.deleteDataValuesByDataElement( dataElementC );
 
386
        assertNull( dataValueStore.getDataValue( sourceA, dataElementA, periodA ) );
 
387
        assertNull( dataValueStore.getDataValue( sourceA, dataElementB, periodA ) );
 
388
        assertNull( dataValueStore.getDataValue( sourceD, dataElementC, periodC ) );
 
389
        assertNotNull( dataValueStore.getDataValue( sourceB, dataElementD, periodC ) );
 
390
 
 
391
        dataValueStore.deleteDataValuesByDataElement( dataElementD );
 
392
        assertNull( dataValueStore.getDataValue( sourceA, dataElementA, periodA ) );
 
393
        assertNull( dataValueStore.getDataValue( sourceA, dataElementB, periodA ) );
 
394
        assertNull( dataValueStore.getDataValue( sourceD, dataElementC, periodC ) );
 
395
        assertNull( dataValueStore.getDataValue( sourceB, dataElementD, periodC ) );
 
396
    }
 
397
 
 
398
    // -------------------------------------------------------------------------
 
399
    // Collections of DataValues
 
400
    // -------------------------------------------------------------------------
 
401
 
 
402
    public void testGetAllDataValues()
 
403
        throws Exception
 
404
    {
 
405
        DataValue dataValueA = new DataValue( dataElementA, periodA, sourceA, optionCombo );
 
406
        dataValueA.setValue( "1" );
 
407
        DataValue dataValueB = new DataValue( dataElementB, periodA, sourceA, optionCombo );
 
408
        dataValueB.setValue( "2" );
 
409
        DataValue dataValueC = new DataValue( dataElementC, periodC, sourceD, optionCombo );
 
410
        dataValueC.setValue( "3" );
 
411
        DataValue dataValueD = new DataValue( dataElementD, periodC, sourceB, optionCombo );
 
412
        dataValueD.setValue( "4" );
 
413
    
 
414
        dataValueStore.addDataValue( dataValueA );
 
415
        dataValueStore.addDataValue( dataValueB );
 
416
        dataValueStore.addDataValue( dataValueC );
 
417
        dataValueStore.addDataValue( dataValueD );
 
418
        
 
419
        Collection<DataValue> dataValues = dataValueStore.getAllDataValues();
 
420
        assertNotNull( dataValues );
 
421
        assertEquals( 4, dataValues.size() );
 
422
    }   
 
423
        
 
424
    public void testGetDataValuesSourcePeriod()
 
425
        throws Exception
 
426
    {
 
427
        DataValue dataValueA = new DataValue( dataElementA, periodA, sourceA, optionCombo );
 
428
        dataValueA.setValue( "1" );
 
429
        DataValue dataValueB = new DataValue( dataElementB, periodA, sourceA, optionCombo );
 
430
        dataValueB.setValue( "2" );
 
431
        DataValue dataValueC = new DataValue( dataElementC, periodC, sourceD, optionCombo );
 
432
        dataValueC.setValue( "3" );
 
433
        DataValue dataValueD = new DataValue( dataElementD, periodC, sourceB, optionCombo );
 
434
        dataValueD.setValue( "4" );
 
435
 
 
436
        dataValueStore.addDataValue( dataValueA );
 
437
        dataValueStore.addDataValue( dataValueB );
 
438
        dataValueStore.addDataValue( dataValueC );
 
439
        dataValueStore.addDataValue( dataValueD );
 
440
 
 
441
        Collection<DataValue> dataValues = dataValueStore.getDataValues( sourceA, periodA );
 
442
        assertNotNull( dataValues );
 
443
        assertEquals( 2, dataValues.size() );
 
444
 
 
445
        dataValues = dataValueStore.getDataValues( sourceB, periodC );
 
446
        assertNotNull( dataValues );
 
447
        assertEquals( 1, dataValues.size() );
 
448
 
 
449
        dataValues = dataValueStore.getDataValues( sourceB, periodD );
 
450
        assertNotNull( dataValues );
 
451
        assertEquals( 0, dataValues.size() );
 
452
    }
 
453
 
 
454
    public void testGetDataValuesSourceDataElement()
 
455
        throws Exception
 
456
    {
 
457
        DataValue dataValueA = new DataValue( dataElementA, periodA, sourceA, optionCombo );
 
458
        dataValueA.setValue( "1" );
 
459
        DataValue dataValueB = new DataValue( dataElementB, periodA, sourceA, optionCombo );
 
460
        dataValueB.setValue( "2" );
 
461
        DataValue dataValueC = new DataValue( dataElementC, periodC, sourceD, optionCombo );
 
462
        dataValueC.setValue( "3" );
 
463
        DataValue dataValueD = new DataValue( dataElementD, periodC, sourceB, optionCombo );
 
464
        dataValueD.setValue( "4" );
 
465
 
 
466
        dataValueStore.addDataValue( dataValueA );
 
467
        dataValueStore.addDataValue( dataValueB );
 
468
        dataValueStore.addDataValue( dataValueC );
 
469
        dataValueStore.addDataValue( dataValueD );
 
470
 
 
471
        Collection<DataValue> dataValues = dataValueStore.getDataValues( sourceA, dataElementA );
 
472
        assertNotNull( dataValues );
 
473
        assertEquals( 1, dataValues.size() );
 
474
 
 
475
        dataValues = dataValueStore.getDataValues( sourceA, dataElementB );
 
476
        assertNotNull( dataValues );
 
477
        assertEquals( 1, dataValues.size() );
 
478
 
 
479
        dataValues = dataValueStore.getDataValues( sourceA, dataElementC );
 
480
        assertNotNull( dataValues );
 
481
        assertEquals( 0, dataValues.size() );
 
482
    }
 
483
 
 
484
    public void testGetDataValuesSourcesDataElement()
 
485
        throws Exception
 
486
    {
 
487
        DataValue dataValueA = new DataValue( dataElementA, periodA, sourceA, optionCombo );
 
488
        dataValueA.setValue( "1" );
 
489
        DataValue dataValueB = new DataValue( dataElementB, periodA, sourceA, optionCombo );
 
490
        dataValueB.setValue( "2" );
 
491
        DataValue dataValueC = new DataValue( dataElementC, periodC, sourceD, optionCombo );
 
492
        dataValueC.setValue( "3" );
 
493
        DataValue dataValueD = new DataValue( dataElementA, periodC, sourceB, optionCombo );
 
494
        dataValueD.setValue( "4" );
 
495
 
 
496
        dataValueStore.addDataValue( dataValueA );
 
497
        dataValueStore.addDataValue( dataValueB );
 
498
        dataValueStore.addDataValue( dataValueC );
 
499
        dataValueStore.addDataValue( dataValueD );
 
500
 
 
501
        Collection<Source> sources = new HashSet<Source>();
 
502
        sources.add( sourceA );
 
503
        sources.add( sourceB );
 
504
 
 
505
        Collection<DataValue> dataValues = dataValueStore.getDataValues( sources, dataElementA );
 
506
        assertNotNull( dataValues );
 
507
        assertEquals( 2, dataValues.size() );
 
508
 
 
509
        dataValues = dataValueStore.getDataValues( sources, dataElementB );
 
510
        assertNotNull( dataValues );
 
511
        assertEquals( 1, dataValues.size() );
 
512
 
 
513
        dataValues = dataValueStore.getDataValues( sources, dataElementC );
 
514
        assertNotNull( dataValues );
 
515
        assertEquals( 0, dataValues.size() );
 
516
    }
 
517
 
 
518
    public void testGetDataValuesSourcePeriodDataElements()
 
519
        throws Exception
 
520
    {
 
521
        DataValue dataValueA = new DataValue( dataElementA, periodA, sourceA, optionCombo );
 
522
        dataValueA.setValue( "1" );
 
523
        DataValue dataValueB = new DataValue( dataElementB, periodA, sourceA, optionCombo );
 
524
        dataValueB.setValue( "2" );
 
525
        DataValue dataValueC = new DataValue( dataElementC, periodC, sourceD, optionCombo );
 
526
        dataValueC.setValue( "3" );
 
527
        DataValue dataValueD = new DataValue( dataElementA, periodC, sourceB, optionCombo );
 
528
        dataValueD.setValue( "4" );
 
529
 
 
530
        dataValueStore.addDataValue( dataValueA );
 
531
        dataValueStore.addDataValue( dataValueB );
 
532
        dataValueStore.addDataValue( dataValueC );
 
533
        dataValueStore.addDataValue( dataValueD );
 
534
 
 
535
        Collection<DataElement> dataElements = new HashSet<DataElement>();
 
536
        dataElements.add( dataElementA );
 
537
        dataElements.add( dataElementB );
 
538
 
 
539
        Collection<DataValue> dataValues = dataValueStore.getDataValues( sourceA, periodA, dataElements );
 
540
        assertNotNull( dataValues );
 
541
        assertEquals( 2, dataValues.size() );
 
542
 
 
543
        dataValues = dataValueStore.getDataValues( sourceB, periodC, dataElements );
 
544
        assertNotNull( dataValues );
 
545
        assertEquals( 1, dataValues.size() );
 
546
 
 
547
        dataValues = dataValueStore.getDataValues( sourceD, periodC, dataElements );
 
548
        assertNotNull( dataValues );
 
549
        assertEquals( 0, dataValues.size() );
 
550
    }
 
551
    
 
552
    public void testGetDataValuesDataElementPeriodsSources()
 
553
        throws Exception
 
554
    {
 
555
        DataValue dataValueA = new DataValue( dataElementA, periodA, sourceB, optionCombo );
 
556
        dataValueA.setValue( "1" );
 
557
        DataValue dataValueB = new DataValue( dataElementA, periodB, sourceA, optionCombo );
 
558
        dataValueB.setValue( "2" );
 
559
        DataValue dataValueC = new DataValue( dataElementA, periodA, sourceC, optionCombo );
 
560
        dataValueC.setValue( "3" );
 
561
        DataValue dataValueD = new DataValue( dataElementB, periodB, sourceD, optionCombo );
 
562
        dataValueD.setValue( "4" );
 
563
        
 
564
        dataValueStore.addDataValue( dataValueA );
 
565
        dataValueStore.addDataValue( dataValueB );
 
566
        dataValueStore.addDataValue( dataValueC );
 
567
        dataValueStore.addDataValue( dataValueD );
 
568
        
 
569
        Collection<Period> periods = new HashSet<Period>();
 
570
        periods.add( periodA );
 
571
        periods.add( periodB );
 
572
 
 
573
        Collection<Source> sources = new HashSet<Source>();
 
574
        sources.add( sourceA );
 
575
        sources.add( sourceB );
 
576
        
 
577
        Collection<DataValue> dataValues = dataValueStore.getDataValues( dataElementA, periods, sources );
 
578
        
 
579
        assertEquals( dataValues.size(), 2 );
 
580
        assertTrue( dataValues.contains( dataValueA ) );
 
581
        assertTrue( dataValues.contains( dataValueB ) );
 
582
    }
 
583
 
 
584
    public void testGetDataValuesOptionComboDataElementPeriodsSources()
 
585
        throws Exception
 
586
    {
 
587
        DataValue dataValueA = new DataValue( dataElementA, periodA, sourceB, optionCombo );
 
588
        dataValueA.setValue( "1" );
 
589
        DataValue dataValueB = new DataValue( dataElementA, periodB, sourceA, optionCombo );
 
590
        dataValueB.setValue( "2" );
 
591
        DataValue dataValueC = new DataValue( dataElementA, periodA, sourceC, optionCombo );
 
592
        dataValueC.setValue( "3" );
 
593
        DataValue dataValueD = new DataValue( dataElementB, periodB, sourceD, optionCombo );
 
594
        dataValueD.setValue( "4" );
 
595
        
 
596
        dataValueStore.addDataValue( dataValueA );
 
597
        dataValueStore.addDataValue( dataValueB );
 
598
        dataValueStore.addDataValue( dataValueC );
 
599
        dataValueStore.addDataValue( dataValueD );
 
600
        
 
601
        Collection<Period> periods = new HashSet<Period>();
 
602
        periods.add( periodA );
 
603
        periods.add( periodB );
 
604
 
 
605
        Collection<Source> sources = new HashSet<Source>();
 
606
        sources.add( sourceA );
 
607
        sources.add( sourceB );
 
608
        
 
609
        Collection<DataValue> dataValues = dataValueStore.getDataValues( dataElementA, optionCombo, periods, sources );
 
610
        
 
611
        assertEquals( dataValues.size(), 2 );
 
612
        assertTrue( dataValues.contains( dataValueA ) );
 
613
        assertTrue( dataValues.contains( dataValueB ) );
 
614
    }
 
615
    
 
616
    public void testGetDataValuesDataElementsPeriodsSourcesFirstResultMaxResults()
 
617
        throws Exception
 
618
    {
 
619
        DataValue dataValueA = new DataValue( dataElementA, periodA, sourceA, optionCombo );
 
620
        dataValueA.setValue( "1" );
 
621
        DataValue dataValueB = new DataValue( dataElementA, periodB, sourceB, optionCombo );
 
622
        dataValueB.setValue( "2" );
 
623
        DataValue dataValueC = new DataValue( dataElementB, periodC, sourceC, optionCombo );
 
624
        dataValueC.setValue( "3" );
 
625
        DataValue dataValueD = new DataValue( dataElementB, periodD, sourceD, optionCombo );
 
626
        dataValueD.setValue( "4" );
 
627
        DataValue dataValueE = new DataValue( dataElementC, periodA, sourceA, optionCombo );
 
628
        dataValueC.setValue( "5" );
 
629
        DataValue dataValueF = new DataValue( dataElementC, periodB, sourceB, optionCombo );
 
630
        dataValueD.setValue( "6" );
 
631
        DataValue dataValueG = new DataValue( dataElementD, periodC, sourceC, optionCombo );
 
632
        dataValueC.setValue( "7" );
 
633
        DataValue dataValueH = new DataValue( dataElementD, periodD, sourceD, optionCombo );
 
634
        dataValueD.setValue( "8" );
 
635
        
 
636
        dataValueStore.addDataValue( dataValueA );
 
637
        dataValueStore.addDataValue( dataValueB );
 
638
        dataValueStore.addDataValue( dataValueC );
 
639
        dataValueStore.addDataValue( dataValueD );
 
640
        dataValueStore.addDataValue( dataValueE );
 
641
        dataValueStore.addDataValue( dataValueF );
 
642
        dataValueStore.addDataValue( dataValueG );
 
643
        dataValueStore.addDataValue( dataValueH );
 
644
        
 
645
        Collection<DataElement> dataElements = new HashSet<DataElement>();
 
646
        dataElements.add( dataElementA );
 
647
        dataElements.add( dataElementB );
 
648
        dataElements.add( dataElementC );
 
649
        
 
650
        Collection<Period> periods = new HashSet<Period>();
 
651
        periods.add( periodA );
 
652
        periods.add( periodB );
 
653
        periods.add( periodC );
 
654
 
 
655
        Collection<Source> sources = new HashSet<Source>();
 
656
        sources.add( sourceA );
 
657
        sources.add( sourceB );
 
658
        sources.add( sourceC );
 
659
        
 
660
        Collection<DataValue> dataValues = dataValueStore.getDataValues( dataElements, periods, sources, 0, 10 );
 
661
        
 
662
        assertEquals( dataValues.size(), 5 );
 
663
        assertTrue( dataValues.contains( dataValueA ) );
 
664
        assertTrue( dataValues.contains( dataValueB ) );
 
665
        assertTrue( dataValues.contains( dataValueC ) );
 
666
        assertTrue( dataValues.contains( dataValueE ) );
 
667
        assertTrue( dataValues.contains( dataValueF ) );        
 
668
 
 
669
        dataValues = dataValueStore.getDataValues( dataElements, periods, sources, 1, 3 );
 
670
        
 
671
        assertEquals( dataValues.size(), 3 );        
 
672
        assertTrue( dataValues.contains( dataValueB ) );
 
673
        assertTrue( dataValues.contains( dataValueC ) );
 
674
        assertTrue( dataValues.contains( dataValueE ) );        
 
675
    }
 
676
}