← 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/dataset/CompleteDataSetRegistrationServiceTest.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/dataset/CompleteDataSetRegistrationServiceTest.java
 
1
package org.hisp.dhis.dataset;
 
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.Collection;
 
32
import java.util.Date;
 
33
 
 
34
import org.hisp.dhis.DhisConvenienceTest;
 
35
import org.hisp.dhis.period.MonthlyPeriodType;
 
36
import org.hisp.dhis.period.Period;
 
37
import org.hisp.dhis.period.PeriodService;
 
38
import org.hisp.dhis.source.DummySource;
 
39
import org.hisp.dhis.source.Source;
 
40
import org.hisp.dhis.source.SourceStore;
 
41
 
 
42
/**
 
43
 * @author Lars Helge Overland
 
44
 * @version $Id$
 
45
 */
 
46
public class CompleteDataSetRegistrationServiceTest
 
47
    extends DhisConvenienceTest
 
48
{
 
49
    private CompleteDataSetRegistration registrationA;
 
50
    private CompleteDataSetRegistration registrationB;
 
51
    private CompleteDataSetRegistration registrationC;
 
52
    private CompleteDataSetRegistration registrationD;
 
53
    private CompleteDataSetRegistration registrationE;
 
54
    private CompleteDataSetRegistration registrationF;
 
55
    private CompleteDataSetRegistration registrationG;
 
56
    private CompleteDataSetRegistration registrationH;
 
57
    private CompleteDataSetRegistration registrationI;
 
58
    private CompleteDataSetRegistration registrationJ;
 
59
    private CompleteDataSetRegistration registrationK;
 
60
    private CompleteDataSetRegistration registrationL;
 
61
    
 
62
    private DataSet dataSetA;
 
63
    private DataSet dataSetB;
 
64
    private DataSet dataSetC;
 
65
    
 
66
    private Period periodA;
 
67
    private Period periodB;
 
68
    
 
69
    private Source sourceA;
 
70
    private Source sourceB;
 
71
    private Source sourceC;
 
72
 
 
73
    private Date onTimeA;
 
74
    private Date onTimeB;
 
75
    private Date deadlineA;
 
76
    private Date deadlineB;
 
77
    private Date tooLateA;
 
78
    private Date tooLateB;
 
79
 
 
80
    // -------------------------------------------------------------------------
 
81
    // Fixture
 
82
    // -------------------------------------------------------------------------
 
83
    
 
84
    public void setUpTest()
 
85
    {
 
86
        completeDataSetRegistrationService = (CompleteDataSetRegistrationService) getBean( CompleteDataSetRegistrationService.ID );
 
87
        
 
88
        dataSetService = (DataSetService) getBean( DataSetService.ID );
 
89
        
 
90
        periodService = (PeriodService) getBean( PeriodService.ID );
 
91
 
 
92
        sourceStore = (SourceStore) getBean( SourceStore.ID );
 
93
 
 
94
        sourceA = new DummySource( "SourceA" );
 
95
        sourceB = new DummySource( "SourceB" );
 
96
        sourceC = new DummySource( "SourceC" );
 
97
        
 
98
        sourceStore.addSource( sourceA );
 
99
        sourceStore.addSource( sourceB ); 
 
100
        sourceStore.addSource( sourceC );    
 
101
        
 
102
        periodA = createPeriod( new MonthlyPeriodType(), getDate( 2000, 1, 1 ), getDate( 2000, 1, 31 ) );
 
103
        periodB = createPeriod( new MonthlyPeriodType(), getDate( 2000, 2, 1 ), getDate( 2000, 2, 28 ) );
 
104
        
 
105
        periodService.addPeriod( periodA );
 
106
        periodService.addPeriod( periodB );  
 
107
 
 
108
        dataSetA = createDataSet( 'A', new MonthlyPeriodType() );
 
109
        dataSetB = createDataSet( 'B', new MonthlyPeriodType() );
 
110
        dataSetC = createDataSet( 'C', new MonthlyPeriodType() );
 
111
        
 
112
        dataSetA.getSources().add( sourceA );
 
113
        dataSetA.getSources().add( sourceB );
 
114
        dataSetB.getSources().add( sourceA );
 
115
        dataSetB.getSources().add( sourceB );
 
116
        dataSetC.getSources().add( sourceA );
 
117
        dataSetC.getSources().add( sourceB );        
 
118
        
 
119
        dataSetService.addDataSet( dataSetA );
 
120
        dataSetService.addDataSet( dataSetB );
 
121
        dataSetService.addDataSet( dataSetC );
 
122
 
 
123
        onTimeA = getDate( 2000, 1, 10 );
 
124
        onTimeB = getDate( 2000, 2, 10 );
 
125
        deadlineA = getDate( 2000, 1, 15 );
 
126
        deadlineB = getDate( 2000, 2, 15 );
 
127
        tooLateA = getDate( 2000, 1, 25 );
 
128
        tooLateB = getDate( 2000, 2, 25 );
 
129
    }
 
130
 
 
131
    // -------------------------------------------------------------------------
 
132
    // Tests
 
133
    // -------------------------------------------------------------------------
 
134
    
 
135
    public void testSaveGet()
 
136
    {
 
137
        registrationA = new CompleteDataSetRegistration( dataSetA, periodA, sourceA, new Date() );
 
138
        registrationB = new CompleteDataSetRegistration( dataSetB, periodB, sourceA, new Date() );
 
139
        
 
140
        completeDataSetRegistrationService.saveCompleteDataSetRegistration( registrationA );
 
141
        completeDataSetRegistrationService.saveCompleteDataSetRegistration( registrationB );
 
142
        
 
143
        assertEquals( registrationA, completeDataSetRegistrationService.getCompleteDataSetRegistration( dataSetA, periodA, sourceA ) );
 
144
        assertEquals( registrationB, completeDataSetRegistrationService.getCompleteDataSetRegistration( dataSetB, periodB, sourceA ) );
 
145
        
 
146
        registrationC = new CompleteDataSetRegistration( dataSetA, periodA, sourceA, new Date() );
 
147
        
 
148
        try
 
149
        {
 
150
            completeDataSetRegistrationService.saveCompleteDataSetRegistration( registrationC );
 
151
            
 
152
            fail();
 
153
        }
 
154
        catch ( Exception ex )
 
155
        {
 
156
            // Expected unique constraint exception
 
157
        }
 
158
    }
 
159
    
 
160
    public void testDelete()
 
161
    {
 
162
        registrationA = new CompleteDataSetRegistration( dataSetA, periodA, sourceA, new Date() );
 
163
        registrationB = new CompleteDataSetRegistration( dataSetB, periodB, sourceA, new Date() );
 
164
        
 
165
        completeDataSetRegistrationService.saveCompleteDataSetRegistration( registrationA );
 
166
        completeDataSetRegistrationService.saveCompleteDataSetRegistration( registrationB );
 
167
        
 
168
        assertNotNull( completeDataSetRegistrationService.getCompleteDataSetRegistration( dataSetA, periodA, sourceA ) );
 
169
        assertNotNull( completeDataSetRegistrationService.getCompleteDataSetRegistration( dataSetB, periodB, sourceA ) );
 
170
 
 
171
        completeDataSetRegistrationService.deleteCompleteDataSetRegistration( registrationA );
 
172
        
 
173
        assertNull( completeDataSetRegistrationService.getCompleteDataSetRegistration( dataSetA, periodA, sourceA ) );
 
174
        assertNotNull( completeDataSetRegistrationService.getCompleteDataSetRegistration( dataSetB, periodB, sourceA ) );
 
175
 
 
176
        completeDataSetRegistrationService.deleteCompleteDataSetRegistration( registrationB );
 
177
        
 
178
        assertNull( completeDataSetRegistrationService.getCompleteDataSetRegistration( dataSetA, periodA, sourceA ) );
 
179
        assertNull( completeDataSetRegistrationService.getCompleteDataSetRegistration( dataSetB, periodB, sourceA ) );        
 
180
    }
 
181
 
 
182
    public void testGetAll()
 
183
    {
 
184
        registrationA = new CompleteDataSetRegistration( dataSetA, periodA, sourceA, new Date() );
 
185
        registrationB = new CompleteDataSetRegistration( dataSetB, periodB, sourceA, new Date() );
 
186
        
 
187
        completeDataSetRegistrationService.saveCompleteDataSetRegistration( registrationA );
 
188
        completeDataSetRegistrationService.saveCompleteDataSetRegistration( registrationB );
 
189
        
 
190
        Collection<CompleteDataSetRegistration> registrations = completeDataSetRegistrationService.getAllCompleteDataSetRegistrations();
 
191
        
 
192
        assertEquals( 2, registrations.size() );
 
193
        assertTrue( registrations.contains( registrationA ) );
 
194
        assertTrue( registrations.contains( registrationB ) );
 
195
    }
 
196
 
 
197
    public void testGetDataSetsSourcesPeriods()
 
198
    {
 
199
        registrationA = new CompleteDataSetRegistration( dataSetA, periodA, sourceA, new Date() );
 
200
        registrationB = new CompleteDataSetRegistration( dataSetB, periodA, sourceA, new Date() );
 
201
        registrationC = new CompleteDataSetRegistration( dataSetA, periodB, sourceA, new Date() );
 
202
        registrationD = new CompleteDataSetRegistration( dataSetB, periodB, sourceA, new Date() );
 
203
        registrationE = new CompleteDataSetRegistration( dataSetA, periodA, sourceB, new Date() );
 
204
        registrationF = new CompleteDataSetRegistration( dataSetB, periodA, sourceB, new Date() );
 
205
        registrationG = new CompleteDataSetRegistration( dataSetA, periodB, sourceB, new Date() );
 
206
        registrationH = new CompleteDataSetRegistration( dataSetB, periodB, sourceB, new Date() );
 
207
        
 
208
        completeDataSetRegistrationService.saveCompleteDataSetRegistration( registrationA );
 
209
        completeDataSetRegistrationService.saveCompleteDataSetRegistration( registrationB );
 
210
        completeDataSetRegistrationService.saveCompleteDataSetRegistration( registrationC );
 
211
        completeDataSetRegistrationService.saveCompleteDataSetRegistration( registrationD );
 
212
        completeDataSetRegistrationService.saveCompleteDataSetRegistration( registrationE );
 
213
        completeDataSetRegistrationService.saveCompleteDataSetRegistration( registrationF );
 
214
        completeDataSetRegistrationService.saveCompleteDataSetRegistration( registrationG );
 
215
        completeDataSetRegistrationService.saveCompleteDataSetRegistration( registrationH );
 
216
        
 
217
        Collection<DataSet> dataSets = new ArrayList<DataSet>();
 
218
        
 
219
        dataSets.add( dataSetB );
 
220
        
 
221
        Collection<Source> sources = new ArrayList<Source>();
 
222
 
 
223
        sources.add( sourceA );
 
224
        sources.add( sourceB );
 
225
        
 
226
        Collection<Period> periods = new ArrayList<Period>();
 
227
        
 
228
        periods.add( periodA );
 
229
        
 
230
        Collection<CompleteDataSetRegistration> registrations = completeDataSetRegistrationService.
 
231
            getCompleteDataSetRegistrations( dataSets, sources, periods );
 
232
        
 
233
        assertNotNull( registrations );
 
234
        assertEquals( 2, registrations.size() );
 
235
        assertTrue( registrations.contains( registrationB ) );
 
236
        assertTrue( registrations.contains( registrationF ) );        
 
237
    }
 
238
    
 
239
    public void testGetDataSetSourcesPeriod()
 
240
    {
 
241
        registrationA = new CompleteDataSetRegistration( dataSetA, periodA, sourceA, new Date() );
 
242
        registrationB = new CompleteDataSetRegistration( dataSetB, periodA, sourceA, new Date() );
 
243
        registrationC = new CompleteDataSetRegistration( dataSetA, periodB, sourceA, new Date() );
 
244
        registrationD = new CompleteDataSetRegistration( dataSetB, periodB, sourceA, new Date() );        
 
245
        registrationE = new CompleteDataSetRegistration( dataSetA, periodA, sourceB, new Date() );
 
246
        registrationF = new CompleteDataSetRegistration( dataSetB, periodA, sourceB, new Date() );
 
247
        registrationG = new CompleteDataSetRegistration( dataSetA, periodB, sourceB, new Date() );
 
248
        registrationH = new CompleteDataSetRegistration( dataSetB, periodB, sourceB, new Date() );
 
249
        
 
250
        registrationI = new CompleteDataSetRegistration( dataSetA, periodA, sourceC, new Date() );
 
251
        registrationJ = new CompleteDataSetRegistration( dataSetB, periodA, sourceC, new Date() );
 
252
        registrationK = new CompleteDataSetRegistration( dataSetA, periodB, sourceC, new Date() );
 
253
        registrationL = new CompleteDataSetRegistration( dataSetB, periodB, sourceC, new Date() );
 
254
        
 
255
        completeDataSetRegistrationService.saveCompleteDataSetRegistration( registrationA );
 
256
        completeDataSetRegistrationService.saveCompleteDataSetRegistration( registrationB );
 
257
        completeDataSetRegistrationService.saveCompleteDataSetRegistration( registrationC );
 
258
        completeDataSetRegistrationService.saveCompleteDataSetRegistration( registrationD );
 
259
        completeDataSetRegistrationService.saveCompleteDataSetRegistration( registrationE );
 
260
        completeDataSetRegistrationService.saveCompleteDataSetRegistration( registrationF );
 
261
        completeDataSetRegistrationService.saveCompleteDataSetRegistration( registrationG );
 
262
        completeDataSetRegistrationService.saveCompleteDataSetRegistration( registrationH );        
 
263
        completeDataSetRegistrationService.saveCompleteDataSetRegistration( registrationI );
 
264
        completeDataSetRegistrationService.saveCompleteDataSetRegistration( registrationJ );
 
265
        completeDataSetRegistrationService.saveCompleteDataSetRegistration( registrationK );
 
266
        completeDataSetRegistrationService.saveCompleteDataSetRegistration( registrationL );
 
267
        
 
268
        Collection<Source> sources = new ArrayList<Source>();
 
269
        
 
270
        sources.add( sourceA );
 
271
        sources.add( sourceB );
 
272
        sources.add( sourceC );
 
273
                
 
274
        assertEquals( 2, completeDataSetRegistrationService.getCompleteDataSetRegistrationsForDataSet( dataSetA, sources, periodA ) );
 
275
        assertEquals( 2, completeDataSetRegistrationService.getCompleteDataSetRegistrationsForDataSet( dataSetB, sources, periodA ) );
 
276
        assertEquals( 2, completeDataSetRegistrationService.getCompleteDataSetRegistrationsForDataSet( dataSetA, sources, periodB ) );
 
277
        assertEquals( 2, completeDataSetRegistrationService.getCompleteDataSetRegistrationsForDataSet( dataSetB, sources, periodB ) );
 
278
        assertEquals( 0, completeDataSetRegistrationService.getCompleteDataSetRegistrationsForDataSet( dataSetC, sources, periodA ) );
 
279
        assertEquals( 0, completeDataSetRegistrationService.getCompleteDataSetRegistrationsForDataSet( dataSetC, sources, periodB ) );        
 
280
    }
 
281
 
 
282
    public void testGetDataSetSourcesPeriodDate()
 
283
    {
 
284
        registrationA = new CompleteDataSetRegistration( dataSetA, periodA, sourceA, onTimeA );
 
285
        registrationB = new CompleteDataSetRegistration( dataSetB, periodA, sourceA, onTimeA );
 
286
        registrationC = new CompleteDataSetRegistration( dataSetA, periodB, sourceA, onTimeB );
 
287
        registrationD = new CompleteDataSetRegistration( dataSetB, periodB, sourceA, onTimeB );        
 
288
        registrationE = new CompleteDataSetRegistration( dataSetA, periodA, sourceB, tooLateA );
 
289
        registrationF = new CompleteDataSetRegistration( dataSetB, periodA, sourceB, tooLateA );
 
290
        registrationG = new CompleteDataSetRegistration( dataSetA, periodB, sourceB, tooLateB );
 
291
        registrationH = new CompleteDataSetRegistration( dataSetB, periodB, sourceB, tooLateB );
 
292
        
 
293
        registrationI = new CompleteDataSetRegistration( dataSetA, periodA, sourceC, onTimeA );
 
294
        registrationJ = new CompleteDataSetRegistration( dataSetB, periodA, sourceC, onTimeA );
 
295
        registrationK = new CompleteDataSetRegistration( dataSetA, periodB, sourceC, onTimeB );
 
296
        registrationL = new CompleteDataSetRegistration( dataSetB, periodB, sourceC, onTimeB );
 
297
        
 
298
        completeDataSetRegistrationService.saveCompleteDataSetRegistration( registrationA );
 
299
        completeDataSetRegistrationService.saveCompleteDataSetRegistration( registrationB );
 
300
        completeDataSetRegistrationService.saveCompleteDataSetRegistration( registrationC );
 
301
        completeDataSetRegistrationService.saveCompleteDataSetRegistration( registrationD );
 
302
        completeDataSetRegistrationService.saveCompleteDataSetRegistration( registrationE );
 
303
        completeDataSetRegistrationService.saveCompleteDataSetRegistration( registrationF );
 
304
        completeDataSetRegistrationService.saveCompleteDataSetRegistration( registrationG );
 
305
        completeDataSetRegistrationService.saveCompleteDataSetRegistration( registrationH );        
 
306
        completeDataSetRegistrationService.saveCompleteDataSetRegistration( registrationI );
 
307
        completeDataSetRegistrationService.saveCompleteDataSetRegistration( registrationJ );
 
308
        completeDataSetRegistrationService.saveCompleteDataSetRegistration( registrationK );
 
309
        completeDataSetRegistrationService.saveCompleteDataSetRegistration( registrationL );
 
310
        
 
311
        Collection<Source> sources = new ArrayList<Source>();
 
312
        
 
313
        sources.add( sourceA );
 
314
        sources.add( sourceB );
 
315
        sources.add( sourceC );
 
316
                
 
317
        assertEquals( 1, completeDataSetRegistrationService.getCompleteDataSetRegistrationsForDataSet( dataSetA, sources, periodA, deadlineA ) );
 
318
        assertEquals( 1, completeDataSetRegistrationService.getCompleteDataSetRegistrationsForDataSet( dataSetB, sources, periodA, deadlineA ) );
 
319
        assertEquals( 1, completeDataSetRegistrationService.getCompleteDataSetRegistrationsForDataSet( dataSetA, sources, periodB, deadlineB ) );
 
320
        assertEquals( 1, completeDataSetRegistrationService.getCompleteDataSetRegistrationsForDataSet( dataSetB, sources, periodB, deadlineB ) );
 
321
        assertEquals( 0, completeDataSetRegistrationService.getCompleteDataSetRegistrationsForDataSet( dataSetC, sources, periodA, deadlineA ) );
 
322
        assertEquals( 0, completeDataSetRegistrationService.getCompleteDataSetRegistrationsForDataSet( dataSetC, sources, periodB, deadlineB ) );        
 
323
    }
 
324
 
 
325
    public void testDeleteByDataSet()
 
326
    {
 
327
        registrationA = new CompleteDataSetRegistration( dataSetA, periodA, sourceA, onTimeA );
 
328
        registrationB = new CompleteDataSetRegistration( dataSetA, periodB, sourceA, onTimeA );
 
329
        registrationC = new CompleteDataSetRegistration( dataSetB, periodA, sourceA, onTimeA );
 
330
        registrationD = new CompleteDataSetRegistration( dataSetB, periodB, sourceA, onTimeA );
 
331
        
 
332
        completeDataSetRegistrationService.saveCompleteDataSetRegistration( registrationA );
 
333
        completeDataSetRegistrationService.saveCompleteDataSetRegistration( registrationB );
 
334
        completeDataSetRegistrationService.saveCompleteDataSetRegistration( registrationC );
 
335
        completeDataSetRegistrationService.saveCompleteDataSetRegistration( registrationD );
 
336
        
 
337
        assertNotNull( completeDataSetRegistrationService.getCompleteDataSetRegistration( dataSetA, periodA, sourceA ) );
 
338
        assertNotNull( completeDataSetRegistrationService.getCompleteDataSetRegistration( dataSetA, periodB, sourceA ) );
 
339
        assertNotNull( completeDataSetRegistrationService.getCompleteDataSetRegistration( dataSetB, periodA, sourceA ) );
 
340
        assertNotNull( completeDataSetRegistrationService.getCompleteDataSetRegistration( dataSetB, periodB, sourceA ) );
 
341
        
 
342
        completeDataSetRegistrationService.deleteCompleteDataSetRegistrations( dataSetA );
 
343
 
 
344
        assertNull( completeDataSetRegistrationService.getCompleteDataSetRegistration( dataSetA, periodA, sourceA ) );
 
345
        assertNull( completeDataSetRegistrationService.getCompleteDataSetRegistration( dataSetA, periodB, sourceA ) );
 
346
        assertNotNull( completeDataSetRegistrationService.getCompleteDataSetRegistration( dataSetB, periodA, sourceA ) );
 
347
        assertNotNull( completeDataSetRegistrationService.getCompleteDataSetRegistration( dataSetB, periodB, sourceA ) );   
 
348
    }
 
349
}