← 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/dataelement/DataElementServiceTest.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/dataelement/DataElementServiceTest.java
 
1
package org.hisp.dhis.dataelement;
 
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.Collection;
 
31
import java.util.HashSet;
 
32
import java.util.Iterator;
 
33
import java.util.Map;
 
34
import java.util.Set;
 
35
 
 
36
import org.hisp.dhis.DhisSpringTest;
 
37
import org.hisp.dhis.expression.Expression;
 
38
import org.hisp.dhis.hierarchy.HierarchyViolationException;
 
39
import org.hisp.dhis.system.util.UUIdUtils;
 
40
import org.hisp.dhis.transaction.TransactionManager;
 
41
 
 
42
/**
 
43
 * @author Kristian Nordal
 
44
 * @version $Id: DataElementServiceTest.java 5742 2008-09-26 11:37:35Z larshelg $
 
45
 */
 
46
public class DataElementServiceTest
 
47
    extends DhisSpringTest
 
48
{
 
49
    private DataElementService dataElementService;
 
50
    
 
51
    private TransactionManager transactionManager;
 
52
 
 
53
    // -------------------------------------------------------------------------
 
54
    // Fixture
 
55
    // -------------------------------------------------------------------------
 
56
 
 
57
    public void setUpTest()
 
58
        throws Exception
 
59
    {
 
60
        dataElementService = (DataElementService) getBean( DataElementService.ID );
 
61
 
 
62
        transactionManager = (TransactionManager) getBean( TransactionManager.ID );
 
63
    }
 
64
 
 
65
    // -------------------------------------------------------------------------
 
66
    // Support methods
 
67
    // -------------------------------------------------------------------------
 
68
 
 
69
    private DataElement createDataElement( char uniqueCharacter )
 
70
    {
 
71
        DataElement dataElement = new DataElement();
 
72
 
 
73
        setDataElementFields(dataElement, uniqueCharacter);
 
74
 
 
75
        return dataElement;
 
76
    }
 
77
 
 
78
    private DataElement setDataElementFields( DataElement dataElement, char uniqueCharacter )
 
79
    {
 
80
        dataElement.setUuid( UUIdUtils.getUUId() );
 
81
        dataElement.setName( "DataElement" + uniqueCharacter );
 
82
        dataElement.setAlternativeName( "AlternativeName" + uniqueCharacter );
 
83
        dataElement.setShortName( "DE" + uniqueCharacter );
 
84
        dataElement.setCode( "Code" + uniqueCharacter );
 
85
        dataElement.setDescription( "DataElementDescription" + uniqueCharacter );
 
86
        dataElement.setAggregationOperator( DataElement.AGGREGATION_OPERATOR_SUM );
 
87
        dataElement.setType( DataElement.TYPE_INT );
 
88
        return dataElement;
 
89
    }
 
90
    
 
91
    private void assertEquals( char uniqueCharacter, DataElement dataElement )
 
92
    {
 
93
        assertEquals( "DataElement" + uniqueCharacter, dataElement.getName() );
 
94
        assertEquals( "AlternativeName" + uniqueCharacter, dataElement.getAlternativeName() );
 
95
        assertEquals( "DE" + uniqueCharacter, dataElement.getShortName() );
 
96
        assertEquals( "Code" + uniqueCharacter, dataElement.getCode() );
 
97
        assertEquals( "DataElementDescription" + uniqueCharacter, dataElement.getDescription() );
 
98
        assertEquals( DataElement.TYPE_INT, dataElement.getType() );
 
99
    }
 
100
 
 
101
    // -------------------------------------------------------------------------
 
102
    // Tests
 
103
    // -------------------------------------------------------------------------
 
104
 
 
105
    public void testAddDataElement()
 
106
        throws Exception
 
107
    {
 
108
        transactionManager.enter();
 
109
 
 
110
        DataElement dataElementA = createDataElement( 'A' );
 
111
        DataElement dataElementB = createDataElement( 'B' );
 
112
        DataElement dataElementC = createDataElement( 'C' );
 
113
        DataElement dataElementD = createDataElement( 'A' );
 
114
 
 
115
        int idA = dataElementService.addDataElement( dataElementA );
 
116
        int idB = dataElementService.addDataElement( dataElementB );
 
117
        int idC = dataElementService.addDataElement( dataElementC );
 
118
 
 
119
        transactionManager.leave();
 
120
 
 
121
        try
 
122
        {
 
123
            // Should give unique constraint violation
 
124
            dataElementService.addDataElement( dataElementD );
 
125
            fail();
 
126
        }
 
127
        catch ( Exception e )
 
128
        {
 
129
            // Expected
 
130
        }
 
131
 
 
132
        transactionManager.enter();
 
133
 
 
134
        dataElementA = dataElementService.getDataElement( idA );
 
135
        assertNotNull( dataElementA );
 
136
        assertEquals( idA, dataElementA.getId() );
 
137
        assertEquals( 'A', dataElementA );
 
138
 
 
139
        dataElementB = dataElementService.getDataElement( idB );
 
140
        assertNotNull( dataElementB );
 
141
        assertEquals( idB, dataElementB.getId() );
 
142
        assertEquals( 'B', dataElementB );
 
143
 
 
144
        dataElementC = dataElementService.getDataElement( idC );
 
145
        assertNotNull( dataElementC );
 
146
        assertEquals( idC, dataElementC.getId() );
 
147
        assertEquals( 'C', dataElementC );
 
148
 
 
149
        transactionManager.leave();
 
150
    }
 
151
 
 
152
    public void testUpdateDataElement()
 
153
        throws Exception
 
154
    {
 
155
        DataElement dataElementA = createDataElement( 'A' );
 
156
        int idA = dataElementService.addDataElement( dataElementA );
 
157
        dataElementA = dataElementService.getDataElement( idA );
 
158
        assertEquals( DataElement.TYPE_INT, dataElementA.getType() );
 
159
 
 
160
        dataElementA.setType( DataElement.TYPE_BOOL );
 
161
        dataElementService.updateDataElement( dataElementA );
 
162
        dataElementA = dataElementService.getDataElement( idA );
 
163
        assertNotNull( dataElementA.getType() );
 
164
        assertEquals( DataElement.TYPE_BOOL, dataElementA.getType() );
 
165
    }
 
166
 
 
167
    public void testDeleteAndGetDataElement()
 
168
        throws Exception
 
169
    {
 
170
        DataElement dataElementA = createDataElement( 'A' );
 
171
        DataElement dataElementB = createDataElement( 'B' );
 
172
        DataElement dataElementC = createDataElement( 'C' );
 
173
        DataElement dataElementD = createDataElement( 'D' );
 
174
 
 
175
        int idA = dataElementService.addDataElement( dataElementA );
 
176
        int idB = dataElementService.addDataElement( dataElementB );
 
177
        int idC = dataElementService.addDataElement( dataElementC );
 
178
        int idD = dataElementService.addDataElement( dataElementD );
 
179
 
 
180
        assertNotNull( dataElementService.getDataElement( idA ) );
 
181
        assertNotNull( dataElementService.getDataElement( idB ) );
 
182
        assertNotNull( dataElementService.getDataElement( idC ) );
 
183
        assertNotNull( dataElementService.getDataElement( idD ) );
 
184
 
 
185
        transactionManager.enter();
 
186
 
 
187
        dataElementA.setParent( dataElementB );
 
188
        dataElementB.getChildren().add( dataElementA );
 
189
        dataElementService.updateDataElement( dataElementA );
 
190
 
 
191
        transactionManager.leave();
 
192
        transactionManager.enter();
 
193
 
 
194
        dataElementA = dataElementService.getDataElement( idA );
 
195
        dataElementB = dataElementService.getDataElement( idB );
 
196
 
 
197
        try
 
198
        {
 
199
            dataElementService.deleteDataElement( dataElementB );
 
200
            fail();
 
201
        }
 
202
        catch ( HierarchyViolationException e )
 
203
        {
 
204
            // Expected
 
205
        }
 
206
 
 
207
        transactionManager.leave();
 
208
        transactionManager.enter();
 
209
 
 
210
        dataElementA.setParent( null );
 
211
        dataElementService.updateDataElement( dataElementA );
 
212
 
 
213
        transactionManager.leave();
 
214
        transactionManager.enter();
 
215
 
 
216
        dataElementA = dataElementService.getDataElement( idA );
 
217
        dataElementB = dataElementService.getDataElement( idB );
 
218
        dataElementC = dataElementService.getDataElement( idC );
 
219
        dataElementD = dataElementService.getDataElement( idD );
 
220
 
 
221
        dataElementService.deleteDataElement( dataElementA );
 
222
        assertNull( dataElementService.getDataElement( idA ) );
 
223
        assertNotNull( dataElementService.getDataElement( idB ) );
 
224
        assertNotNull( dataElementService.getDataElement( idC ) );
 
225
        assertNotNull( dataElementService.getDataElement( idD ) );
 
226
 
 
227
        dataElementService.deleteDataElement( dataElementB );
 
228
        assertNull( dataElementService.getDataElement( idA ) );
 
229
        assertNull( dataElementService.getDataElement( idB ) );
 
230
        assertNotNull( dataElementService.getDataElement( idC ) );
 
231
        assertNotNull( dataElementService.getDataElement( idD ) );
 
232
 
 
233
        dataElementService.deleteDataElement( dataElementC );
 
234
        assertNull( dataElementService.getDataElement( idA ) );
 
235
        assertNull( dataElementService.getDataElement( idB ) );
 
236
        assertNull( dataElementService.getDataElement( idC ) );
 
237
        assertNotNull( dataElementService.getDataElement( idD ) );
 
238
 
 
239
        dataElementService.deleteDataElement( dataElementD );
 
240
        assertNull( dataElementService.getDataElement( idA ) );
 
241
        assertNull( dataElementService.getDataElement( idB ) );
 
242
        assertNull( dataElementService.getDataElement( idC ) );
 
243
        assertNull( dataElementService.getDataElement( idD ) );
 
244
 
 
245
        transactionManager.leave();
 
246
    }
 
247
 
 
248
    public void testGetDataElementByUUID()
 
249
        throws Exception
 
250
    {
 
251
        DataElement dataElementA = createDataElement( 'A' );
 
252
        int idA = dataElementService.addDataElement( dataElementA );
 
253
        
 
254
        dataElementA = dataElementService.getDataElement( idA );
 
255
        String uuid = dataElementA.getUuid();
 
256
        
 
257
        DataElement dataElementB = dataElementService.getDataElement( uuid );
 
258
        
 
259
        assertEquals( dataElementA, dataElementB );
 
260
    }
 
261
 
 
262
    public void testGetDataElementByName()
 
263
        throws Exception
 
264
    {
 
265
        DataElement dataElementA = createDataElement( 'A' );
 
266
        DataElement dataElementB = createDataElement( 'B' );
 
267
        int idA = dataElementService.addDataElement( dataElementA );
 
268
        int idB = dataElementService.addDataElement( dataElementB );
 
269
 
 
270
        dataElementA = dataElementService.getDataElementByName( "DataElementA" );
 
271
        assertNotNull( dataElementA );
 
272
        assertEquals( idA, dataElementA.getId() );
 
273
        assertEquals( 'A', dataElementA );
 
274
 
 
275
        dataElementB = dataElementService.getDataElementByName( "DataElementB" );
 
276
        assertNotNull( dataElementB );
 
277
        assertEquals( idB, dataElementB.getId() );
 
278
        assertEquals( 'B', dataElementB );
 
279
 
 
280
        DataElement dataElementC = dataElementService.getDataElementByName( "DataElementC" );
 
281
        assertNull( dataElementC );
 
282
    }
 
283
 
 
284
    public void testGetDataElementByAlternativeName()
 
285
        throws Exception
 
286
    {
 
287
        DataElement dataElementA = createDataElement( 'A' );
 
288
        DataElement dataElementB = createDataElement( 'B' );
 
289
        int idA = dataElementService.addDataElement( dataElementA );
 
290
        int idB = dataElementService.addDataElement( dataElementB );
 
291
 
 
292
        dataElementA = dataElementService.getDataElementByAlternativeName( "AlternativeNameA" );
 
293
        assertNotNull( dataElementA );
 
294
        assertEquals( idA, dataElementA.getId() );
 
295
        assertEquals( 'A', dataElementA );
 
296
 
 
297
        dataElementB = dataElementService.getDataElementByAlternativeName( "AlternativeNameB" );
 
298
        assertNotNull( dataElementB );
 
299
        assertEquals( idB, dataElementB.getId() );
 
300
        assertEquals( 'B', dataElementB );
 
301
 
 
302
        DataElement dataElementC = dataElementService.getDataElementByAlternativeName( "AlternativeNameC" );
 
303
        assertNull( dataElementC );
 
304
    }
 
305
 
 
306
    public void testGetDataElementByShortName()
 
307
        throws Exception
 
308
    {
 
309
        DataElement dataElementA = createDataElement( 'A' );
 
310
        DataElement dataElementB = createDataElement( 'B' );
 
311
        int idA = dataElementService.addDataElement( dataElementA );
 
312
        int idB = dataElementService.addDataElement( dataElementB );
 
313
 
 
314
        dataElementA = dataElementService.getDataElementByShortName( "DEA" );
 
315
        assertNotNull( dataElementA );
 
316
        assertEquals( idA, dataElementA.getId() );
 
317
        assertEquals( 'A', dataElementA );
 
318
 
 
319
        dataElementB = dataElementService.getDataElementByShortName( "DEB" );
 
320
        assertNotNull( dataElementB );
 
321
        assertEquals( idB, dataElementB.getId() );
 
322
        assertEquals( 'B', dataElementB );
 
323
 
 
324
        DataElement dataElementC = dataElementService.getDataElementByShortName( "DEC" );
 
325
        assertNull( dataElementC );
 
326
    }
 
327
 
 
328
    public void testGetDataElementByCode()
 
329
        throws Exception
 
330
    {
 
331
        DataElement dataElementA = createDataElement( 'A' );
 
332
        DataElement dataElementB = createDataElement( 'B' );
 
333
        int idA = dataElementService.addDataElement( dataElementA );
 
334
        int idB = dataElementService.addDataElement( dataElementB );
 
335
 
 
336
        dataElementA = dataElementService.getDataElementByCode( "CodeA" );
 
337
        assertNotNull( dataElementA );
 
338
        assertEquals( idA, dataElementA.getId() );
 
339
        assertEquals( 'A', dataElementA );
 
340
 
 
341
        dataElementB = dataElementService.getDataElementByCode( "CodeB" );
 
342
        assertNotNull( dataElementB );
 
343
        assertEquals( idB, dataElementB.getId() );
 
344
        assertEquals( 'B', dataElementB );
 
345
 
 
346
        DataElement dataElementC = dataElementService.getDataElementByCode( "CodeC" );
 
347
        assertNull( dataElementC );
 
348
    }
 
349
 
 
350
    public void testGetAllDataElements()
 
351
        throws Exception
 
352
    {
 
353
        assertEquals( 0, dataElementService.getAllDataElements().size() );
 
354
 
 
355
        DataElement dataElementA = createDataElement( 'A' );
 
356
        DataElement dataElementB = createDataElement( 'B' );
 
357
        DataElement dataElementC = createDataElement( 'C' );
 
358
        DataElement dataElementD = createDataElement( 'D' );
 
359
 
 
360
        dataElementService.addDataElement( dataElementA );
 
361
        dataElementService.addDataElement( dataElementB );
 
362
        dataElementService.addDataElement( dataElementC );
 
363
        dataElementService.addDataElement( dataElementD );
 
364
 
 
365
        Collection<DataElement> dataElementsRef = new HashSet<DataElement>();
 
366
        dataElementsRef.add( dataElementA );
 
367
        dataElementsRef.add( dataElementB );
 
368
        dataElementsRef.add( dataElementC );
 
369
        dataElementsRef.add( dataElementD );
 
370
 
 
371
        transactionManager.enter();
 
372
 
 
373
        Collection<DataElement> dataElements = dataElementService.getAllDataElements();
 
374
        assertNotNull( dataElements );
 
375
        assertEquals( dataElementsRef.size(), dataElements.size() );
 
376
        assertTrue( dataElements.containsAll( dataElementsRef ) );
 
377
 
 
378
        transactionManager.leave();
 
379
    }
 
380
 
 
381
    public void testGetAggregateableDataElements()
 
382
    {
 
383
        assertEquals( 0, dataElementService.getAggregateableDataElements().size() );
 
384
 
 
385
        DataElement dataElementA = createDataElement( 'A' );
 
386
        DataElement dataElementB = createDataElement( 'B' );
 
387
        DataElement dataElementC = createDataElement( 'C' );
 
388
        DataElement dataElementD = createDataElement( 'D' );
 
389
        
 
390
        dataElementA.setType( DataElement.TYPE_INT );
 
391
        dataElementB.setType( DataElement.TYPE_BOOL );
 
392
        dataElementC.setType( DataElement.TYPE_STRING );
 
393
        dataElementD.setType( DataElement.TYPE_INT );
 
394
 
 
395
        dataElementService.addDataElement( dataElementA );
 
396
        dataElementService.addDataElement( dataElementB );
 
397
        dataElementService.addDataElement( dataElementC );
 
398
        dataElementService.addDataElement( dataElementD );
 
399
 
 
400
        Collection<DataElement> dataElementsRef = new HashSet<DataElement>();
 
401
        dataElementsRef.add( dataElementA );
 
402
        dataElementsRef.add( dataElementB );
 
403
        dataElementsRef.add( dataElementD );
 
404
 
 
405
        transactionManager.enter();
 
406
 
 
407
        Collection<DataElement> dataElements = dataElementService.getAggregateableDataElements();
 
408
        assertNotNull( dataElements );
 
409
        assertEquals( dataElementsRef.size(), dataElements.size() );
 
410
        assertTrue( dataElements.containsAll( dataElementsRef ) );
 
411
 
 
412
        transactionManager.leave();
 
413
    }
 
414
    
 
415
    public void testGetAllActiveDataElements()
 
416
        throws Exception
 
417
    {
 
418
        assertEquals( 0, dataElementService.getAllActiveDataElements().size() );
 
419
 
 
420
        DataElement dataElementA = createDataElement( 'A' );
 
421
        dataElementA.setActive( true );
 
422
        DataElement dataElementB = createDataElement( 'B' );
 
423
        dataElementB.setActive( true );
 
424
        DataElement dataElementC = createDataElement( 'C' );
 
425
        dataElementC.setActive( true );
 
426
        DataElement dataElementD = createDataElement( 'D' );
 
427
 
 
428
        dataElementService.addDataElement( dataElementA );
 
429
        dataElementService.addDataElement( dataElementB );
 
430
        dataElementService.addDataElement( dataElementC );
 
431
        dataElementService.addDataElement( dataElementD );
 
432
 
 
433
        Collection<DataElement> dataElementsRef = new HashSet<DataElement>();
 
434
        dataElementsRef.add( dataElementA );
 
435
        dataElementsRef.add( dataElementB );
 
436
        dataElementsRef.add( dataElementC );
 
437
 
 
438
        transactionManager.enter();
 
439
 
 
440
        assertEquals( dataElementsRef.size() + 1, dataElementService.getAllDataElements().size() );
 
441
 
 
442
        Collection<DataElement> dataElements = dataElementService.getAllActiveDataElements();
 
443
        assertNotNull( dataElements );
 
444
        assertEquals( dataElementsRef.size(), dataElements.size() );
 
445
        assertTrue( dataElements.containsAll( dataElementsRef ) );
 
446
 
 
447
        transactionManager.leave();
 
448
    }
 
449
 
 
450
    public void testGetDataElementsByAggregationOperator()
 
451
        throws Exception
 
452
    {
 
453
        assertEquals( 0, dataElementService.getDataElementsByAggregationOperator(
 
454
            DataElement.AGGREGATION_OPERATOR_AVERAGE ).size() );
 
455
        assertEquals( 0, dataElementService.getDataElementsByAggregationOperator( DataElement.AGGREGATION_OPERATOR_SUM )
 
456
            .size() );
 
457
 
 
458
        DataElement dataElementA = createDataElement( 'A' );
 
459
        dataElementA.setAggregationOperator( DataElement.AGGREGATION_OPERATOR_AVERAGE );
 
460
        DataElement dataElementB = createDataElement( 'B' );
 
461
        dataElementB.setAggregationOperator( DataElement.AGGREGATION_OPERATOR_SUM );
 
462
        DataElement dataElementC = createDataElement( 'C' );
 
463
        dataElementC.setAggregationOperator( DataElement.AGGREGATION_OPERATOR_SUM );
 
464
        DataElement dataElementD = createDataElement( 'D' );
 
465
        dataElementD.setAggregationOperator( DataElement.AGGREGATION_OPERATOR_SUM );
 
466
 
 
467
        dataElementService.addDataElement( dataElementA );
 
468
        dataElementService.addDataElement( dataElementB );
 
469
        dataElementService.addDataElement( dataElementC );
 
470
        dataElementService.addDataElement( dataElementD );
 
471
 
 
472
        assertEquals( 1, dataElementService.getDataElementsByAggregationOperator(
 
473
            DataElement.AGGREGATION_OPERATOR_AVERAGE ).size() );
 
474
        assertEquals( 3, dataElementService.getDataElementsByAggregationOperator( DataElement.AGGREGATION_OPERATOR_SUM )
 
475
            .size() );
 
476
    }
 
477
 
 
478
    public void testGetDataElementsByType()
 
479
    {
 
480
        assertEquals( 0, dataElementService.getDataElementsByType( DataElement.TYPE_INT ).size() );
 
481
        assertEquals( 0, dataElementService.getDataElementsByType( DataElement.TYPE_BOOL ).size() );
 
482
 
 
483
        DataElement dataElementA = createDataElement( 'A' );
 
484
        dataElementA.setType( DataElement.TYPE_INT );
 
485
        DataElement dataElementB = createDataElement( 'B' );
 
486
        dataElementB.setType( DataElement.TYPE_BOOL );
 
487
        DataElement dataElementC = createDataElement( 'C' );
 
488
        dataElementC.setType( DataElement.TYPE_BOOL );
 
489
        DataElement dataElementD = createDataElement( 'D' );
 
490
        dataElementD.setType( DataElement.TYPE_BOOL );
 
491
 
 
492
        dataElementService.addDataElement( dataElementA );
 
493
        dataElementService.addDataElement( dataElementB );
 
494
        dataElementService.addDataElement( dataElementC );
 
495
        dataElementService.addDataElement( dataElementD );
 
496
 
 
497
        assertEquals( 1, dataElementService.getDataElementsByType( DataElement.TYPE_INT ).size() );
 
498
        assertEquals( 3, dataElementService.getDataElementsByType( DataElement.TYPE_BOOL ).size() );
 
499
    }
 
500
 
 
501
    // -------------------------------------------------------------------------
 
502
    // CalculatedDataElements
 
503
    // -------------------------------------------------------------------------
 
504
 
 
505
    public void testCalculatedDataElements()
 
506
        throws Exception
 
507
    {
 
508
        DataElement deA = createDataElement('A');
 
509
        DataElement deB = createDataElement('B');
 
510
        DataElement deC = createDataElement('C');
 
511
        DataElement deD = createDataElement('D');
 
512
        DataElement deE = createDataElement('E');
 
513
 
 
514
        int deIdA = dataElementService.addDataElement(deA);
 
515
        int deIdB = dataElementService.addDataElement(deB);
 
516
        int deIdC = dataElementService.addDataElement(deC);
 
517
        int deIdD = dataElementService.addDataElement(deD);
 
518
        dataElementService.addDataElement(deE);
 
519
        
 
520
        CalculatedDataElement cdeX = (CalculatedDataElement) setDataElementFields( new CalculatedDataElement (), 'X' );
 
521
        CalculatedDataElement cdeY = (CalculatedDataElement) setDataElementFields( new CalculatedDataElement (), 'Y' );
 
522
 
 
523
        Set<DataElement> dataElementsX = new HashSet<DataElement> ();
 
524
        dataElementsX.add(deA);
 
525
        dataElementsX.add(deB);
 
526
        Expression expressionX = new Expression ( "["+deIdA+"] * 2 + ["+deIdB+"] * 3", "foo", dataElementsX );
 
527
        cdeX.setExpression(expressionX);
 
528
        cdeX.setSaved(true);
 
529
        dataElementService.addDataElement(cdeX);
 
530
        
 
531
        Set<DataElement> dataElementsY = new HashSet<DataElement> ();
 
532
        dataElementsY.add(deC);
 
533
        dataElementsY.add(deD);
 
534
        Expression expressionY = new Expression ( "["+deIdC+"] * 2 + ["+deIdD+"] * 3", "foo", dataElementsY );
 
535
        cdeY.setExpression(expressionY);
 
536
        cdeY.setSaved(true);
 
537
        dataElementService.addDataElement(cdeY);
 
538
        
 
539
        Collection<CalculatedDataElement> cdes = dataElementService.getAllCalculatedDataElements();
 
540
        assertEquals( 2, cdes.size() );
 
541
        
 
542
        //CalculatedDataElement cde;
 
543
        CalculatedDataElement cde = dataElementService.getCalculatedDataElementByDataElement( deA );
 
544
        assertNotNull(cde);
 
545
        assertEquals("DataElementX", cde.getName() );
 
546
        
 
547
        cde = dataElementService.getCalculatedDataElementByDataElement( deE );
 
548
        assertNull(cde);
 
549
        
 
550
        Set<DataElement> dataElements = new HashSet<DataElement> ();
 
551
        dataElements.add(deA);
 
552
        cdes = dataElementService.getCalculatedDataElementsByDataElements( dataElements );
 
553
        assertEquals( 1, cdes.size() );
 
554
        assertEquals("DataElementX", cdes.iterator().next().getName());
 
555
        
 
556
        dataElements.add(deC);
 
557
        cdes = dataElementService.getCalculatedDataElementsByDataElements( dataElements );
 
558
        assertEquals( 2, cdes.size() );
 
559
 
 
560
        Iterator<CalculatedDataElement> iterator = cdes.iterator();
 
561
        assertEquals( iterator.next().getName(), "DataElementX" );
 
562
        assertEquals( iterator.next().getName(), "DataElementY" );
 
563
        
 
564
        //Make sure the results are unique
 
565
        dataElements.add(deB);
 
566
        cdes = dataElementService.getCalculatedDataElementsByDataElements( dataElements );
 
567
        assertEquals( 2, cdes.size() );
 
568
 
 
569
        iterator = cdes.iterator();
 
570
        assertEquals( iterator.next().getName(), "DataElementX" );
 
571
        assertEquals( iterator.next().getName(), "DataElementY" );
 
572
 
 
573
        //Check that no other data elements are returned
 
574
        dataElements.add(deE);
 
575
        cdes = dataElementService.getCalculatedDataElementsByDataElements( dataElements );
 
576
        assertEquals( 2, cdes.size() );
 
577
        
 
578
        Map<DataElement,Integer> factorMap = dataElementService.getDataElementFactors(cdeX);
 
579
        assertEquals( 2, factorMap.size() );
 
580
        assertTrue(factorMap.keySet().contains(deA));
 
581
        assertEquals( new Integer(2), factorMap.get(deA));
 
582
        assertTrue(factorMap.keySet().contains(deB));
 
583
        assertEquals( new Integer(3), factorMap.get(deB));
 
584
 
 
585
    }
 
586
    
 
587
    // -------------------------------------------------------------------------
 
588
    // DataElementGroup
 
589
    // -------------------------------------------------------------------------
 
590
 
 
591
    public void testAddDataElementGroup()
 
592
        throws Exception
 
593
    {
 
594
        DataElementGroup dataElementGroupA = new DataElementGroup( "DataElementGroupA" );
 
595
        DataElementGroup dataElementGroupB = new DataElementGroup( "DataElementGroupB" );
 
596
        DataElementGroup dataElementGroupC = new DataElementGroup( "DataElementGroupC" );
 
597
        DataElementGroup dataElementGroupD = new DataElementGroup( "DataElementGroupA" );
 
598
 
 
599
        int idA = dataElementService.addDataElementGroup( dataElementGroupA );
 
600
        int idB = dataElementService.addDataElementGroup( dataElementGroupB );
 
601
        int idC = dataElementService.addDataElementGroup( dataElementGroupC );
 
602
 
 
603
        try
 
604
        {
 
605
            // Should give unique constraint violation
 
606
            dataElementService.addDataElementGroup( dataElementGroupD );
 
607
            fail();
 
608
        }
 
609
        catch ( Exception e )
 
610
        {
 
611
            // Expected
 
612
        }
 
613
 
 
614
        dataElementGroupA = dataElementService.getDataElementGroup( idA );
 
615
        assertNotNull( dataElementGroupA );
 
616
        assertEquals( idA, dataElementGroupA.getId() );
 
617
        assertEquals( "DataElementGroupA", dataElementGroupA.getName() );
 
618
 
 
619
        dataElementGroupB = dataElementService.getDataElementGroup( idB );
 
620
        assertNotNull( dataElementGroupB );
 
621
        assertEquals( idB, dataElementGroupB.getId() );
 
622
        assertEquals( "DataElementGroupB", dataElementGroupB.getName() );
 
623
 
 
624
        dataElementGroupC = dataElementService.getDataElementGroup( idC );
 
625
        assertNotNull( dataElementGroupC );
 
626
        assertEquals( idC, dataElementGroupC.getId() );
 
627
        assertEquals( "DataElementGroupC", dataElementGroupC.getName() );
 
628
    }
 
629
 
 
630
    public void testUpdateDataElementGroup()
 
631
        throws Exception
 
632
    {
 
633
        DataElementGroup dataElementGroupA = new DataElementGroup( "DataElementGroupA" );
 
634
        DataElementGroup dataElementGroupB = new DataElementGroup( "DataElementGroupB" );
 
635
        DataElementGroup dataElementGroupC = new DataElementGroup( "DataElementGroupC" );
 
636
 
 
637
        int idA = dataElementService.addDataElementGroup( dataElementGroupA );
 
638
        int idB = dataElementService.addDataElementGroup( dataElementGroupB );
 
639
        int idC = dataElementService.addDataElementGroup( dataElementGroupC );
 
640
 
 
641
        dataElementGroupA = dataElementService.getDataElementGroup( idA );
 
642
        assertNotNull( dataElementGroupA );
 
643
        assertEquals( idA, dataElementGroupA.getId() );
 
644
        assertEquals( "DataElementGroupA", dataElementGroupA.getName() );
 
645
 
 
646
        dataElementGroupA.setName( "DataElementGroupAA" );
 
647
        dataElementService.updateDataElementGroup( dataElementGroupA );
 
648
 
 
649
        dataElementGroupA = dataElementService.getDataElementGroup( idA );
 
650
        assertNotNull( dataElementGroupA );
 
651
        assertEquals( idA, dataElementGroupA.getId() );
 
652
        assertEquals( "DataElementGroupAA", dataElementGroupA.getName() );
 
653
 
 
654
        dataElementGroupB = dataElementService.getDataElementGroup( idB );
 
655
        assertNotNull( dataElementGroupB );
 
656
        assertEquals( idB, dataElementGroupB.getId() );
 
657
        assertEquals( "DataElementGroupB", dataElementGroupB.getName() );
 
658
 
 
659
        dataElementGroupC = dataElementService.getDataElementGroup( idC );
 
660
        assertNotNull( dataElementGroupC );
 
661
        assertEquals( idC, dataElementGroupC.getId() );
 
662
        assertEquals( "DataElementGroupC", dataElementGroupC.getName() );
 
663
    }
 
664
 
 
665
    public void testDeleteAndGetDataElementGroup()
 
666
        throws Exception
 
667
    {
 
668
        DataElementGroup dataElementGroupA = new DataElementGroup( "DataElementGroupA" );
 
669
        DataElementGroup dataElementGroupB = new DataElementGroup( "DataElementGroupB" );
 
670
        DataElementGroup dataElementGroupC = new DataElementGroup( "DataElementGroupC" );
 
671
        DataElementGroup dataElementGroupD = new DataElementGroup( "DataElementGroupD" );
 
672
 
 
673
        int idA = dataElementService.addDataElementGroup( dataElementGroupA );
 
674
        int idB = dataElementService.addDataElementGroup( dataElementGroupB );
 
675
        int idC = dataElementService.addDataElementGroup( dataElementGroupC );
 
676
        int idD = dataElementService.addDataElementGroup( dataElementGroupD );
 
677
 
 
678
        assertNotNull( dataElementService.getDataElementGroup( idA ) );
 
679
        assertNotNull( dataElementService.getDataElementGroup( idB ) );
 
680
        assertNotNull( dataElementService.getDataElementGroup( idC ) );
 
681
        assertNotNull( dataElementService.getDataElementGroup( idD ) );
 
682
 
 
683
        dataElementService.deleteDataElementGroup( dataElementGroupA );
 
684
        assertNull( dataElementService.getDataElementGroup( idA ) );
 
685
        assertNotNull( dataElementService.getDataElementGroup( idB ) );
 
686
        assertNotNull( dataElementService.getDataElementGroup( idC ) );
 
687
        assertNotNull( dataElementService.getDataElementGroup( idD ) );
 
688
 
 
689
        dataElementService.deleteDataElementGroup( dataElementGroupB );
 
690
        assertNull( dataElementService.getDataElementGroup( idA ) );
 
691
        assertNull( dataElementService.getDataElementGroup( idB ) );
 
692
        assertNotNull( dataElementService.getDataElementGroup( idC ) );
 
693
        assertNotNull( dataElementService.getDataElementGroup( idD ) );
 
694
 
 
695
        dataElementService.deleteDataElementGroup( dataElementGroupC );
 
696
        assertNull( dataElementService.getDataElementGroup( idA ) );
 
697
        assertNull( dataElementService.getDataElementGroup( idB ) );
 
698
        assertNull( dataElementService.getDataElementGroup( idC ) );
 
699
        assertNotNull( dataElementService.getDataElementGroup( idD ) );
 
700
 
 
701
        dataElementService.deleteDataElementGroup( dataElementGroupD );
 
702
        assertNull( dataElementService.getDataElementGroup( idA ) );
 
703
        assertNull( dataElementService.getDataElementGroup( idB ) );
 
704
        assertNull( dataElementService.getDataElementGroup( idC ) );
 
705
        assertNull( dataElementService.getDataElementGroup( idD ) );
 
706
    }
 
707
 
 
708
    public void testGetDataElementGroupByUUID()
 
709
        throws Exception
 
710
    {
 
711
        DataElementGroup groupA = new DataElementGroup( "groupA" );
 
712
        int idA = dataElementService.addDataElementGroup( groupA );
 
713
        
 
714
        groupA = dataElementService.getDataElementGroup( idA );
 
715
        String uuid = groupA.getUuid();
 
716
        
 
717
        DataElementGroup groupB = dataElementService.getDataElementGroup( uuid );
 
718
        
 
719
        assertEquals( groupA, groupB );
 
720
    }
 
721
 
 
722
    public void testGetDataElementGroupByName()
 
723
        throws Exception
 
724
    {
 
725
        DataElementGroup dataElementGroupA = new DataElementGroup( "DataElementGroupA" );
 
726
        DataElementGroup dataElementGroupB = new DataElementGroup( "DataElementGroupB" );
 
727
        int idA = dataElementService.addDataElementGroup( dataElementGroupA );
 
728
        int idB = dataElementService.addDataElementGroup( dataElementGroupB );
 
729
 
 
730
        assertNotNull( dataElementService.getDataElementGroup( idA ) );
 
731
        assertNotNull( dataElementService.getDataElementGroup( idB ) );
 
732
 
 
733
        dataElementGroupA = dataElementService.getDataElementGroupByName( "DataElementGroupA" );
 
734
        assertNotNull( dataElementGroupA );
 
735
        assertEquals( idA, dataElementGroupA.getId() );
 
736
        assertEquals( "DataElementGroupA", dataElementGroupA.getName() );
 
737
 
 
738
        dataElementGroupB = dataElementService.getDataElementGroupByName( "DataElementGroupB" );
 
739
        assertNotNull( dataElementGroupB );
 
740
        assertEquals( idB, dataElementGroupB.getId() );
 
741
        assertEquals( "DataElementGroupB", dataElementGroupB.getName() );
 
742
 
 
743
        DataElementGroup dataElementGroupC = dataElementService.getDataElementGroupByName( "DataElementGroupC" );
 
744
        assertNull( dataElementGroupC );
 
745
    }
 
746
 
 
747
    public void testGetAllDataElementGroups()
 
748
        throws Exception
 
749
    {
 
750
    }
 
751
    
 
752
    public void testGetGroupsContainingDataElement() throws Exception
 
753
    {
 
754
        transactionManager.enter();
 
755
        
 
756
        DataElement dataElementA = createDataElement( 'A' );
 
757
        DataElement dataElementB = createDataElement( 'B' );
 
758
        DataElement dataElementC = createDataElement( 'C' );
 
759
        DataElement dataElementD = createDataElement( 'D' );
 
760
        dataElementService.addDataElement( dataElementA );
 
761
        dataElementService.addDataElement( dataElementB );
 
762
        dataElementService.addDataElement( dataElementC );
 
763
        dataElementService.addDataElement( dataElementD );
 
764
        
 
765
        transactionManager.leave();
 
766
        transactionManager.enter();
 
767
        
 
768
        DataElementGroup dataElementGroupA = new DataElementGroup( "DataElementGroupA" );
 
769
        DataElementGroup dataElementGroupB = new DataElementGroup( "DataElementGroupB" );
 
770
        DataElementGroup dataElementGroupC = new DataElementGroup( "DataElementGroupC" );
 
771
        DataElementGroup dataElementGroupD = new DataElementGroup( "DataElementGroupD" );
 
772
        
 
773
        Set<DataElement> membersA = new HashSet<DataElement>();
 
774
        membersA.add( dataElementA );
 
775
        membersA.add( dataElementB );
 
776
        membersA.add( dataElementC );
 
777
        
 
778
        Set<DataElement> membersB = new HashSet<DataElement>();
 
779
        membersB.add( dataElementC );
 
780
        membersB.add( dataElementD );
 
781
 
 
782
        dataElementGroupA.setMembers( membersA );
 
783
        dataElementGroupB.setMembers( membersB );
 
784
        dataElementGroupC.setMembers( membersA );
 
785
        dataElementGroupD.setMembers( membersB );
 
786
        
 
787
        dataElementService.addDataElementGroup( dataElementGroupA );
 
788
        dataElementService.addDataElementGroup( dataElementGroupB );
 
789
        dataElementService.addDataElementGroup( dataElementGroupC );
 
790
        dataElementService.addDataElementGroup( dataElementGroupD );
 
791
        
 
792
        transactionManager.leave();
 
793
        
 
794
        Collection<DataElementGroup> groupsA = dataElementService.getGroupsContainingDataElement( dataElementA );
 
795
        
 
796
        assertTrue( groupsA.size() == 2 );
 
797
        assertTrue( groupsA.contains( dataElementGroupA ) );
 
798
        assertTrue( groupsA.contains( dataElementGroupC ) );        
 
799
 
 
800
        Collection<DataElementGroup> groupsB = dataElementService.getGroupsContainingDataElement( dataElementC );
 
801
        
 
802
        assertTrue( groupsB.size() == 4 );
 
803
    }
 
804
}