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