← 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/DataSetStoreTest.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/DataSetStoreTest.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.Collection;
 
31
 
 
32
import org.hisp.dhis.DhisConvenienceTest;
 
33
import org.hisp.dhis.period.MonthlyPeriodType;
 
34
import org.hisp.dhis.period.PeriodStore;
 
35
import org.hisp.dhis.period.PeriodType;
 
36
import org.hisp.dhis.period.WeeklyPeriodType;
 
37
import org.hisp.dhis.period.YearlyPeriodType;
 
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 Kristian Nordal
 
44
 * @version $Id: DataSetStoreTest.java 3451 2007-07-09 12:28:19Z torgeilo $
 
45
 */
 
46
public class DataSetStoreTest
 
47
    extends DhisConvenienceTest
 
48
{
 
49
    private PeriodStore periodStore;
 
50
 
 
51
    private DataSetStore dataSetStore;
 
52
 
 
53
    private SourceStore sourceStore;
 
54
    
 
55
    private PeriodType periodType;
 
56
 
 
57
    public void setUpTest()
 
58
        throws Exception
 
59
    {
 
60
        dataSetStore = (DataSetStore) getBean( DataSetStore.ID );
 
61
 
 
62
        periodStore = (PeriodStore) getBean( PeriodStore.ID );
 
63
 
 
64
        sourceStore = (SourceStore) getBean( SourceStore.ID );
 
65
        
 
66
        periodType = PeriodType.getAvailablePeriodTypes().iterator().next();
 
67
    }
 
68
 
 
69
    // -------------------------------------------------------------------------
 
70
    // Supportive methods
 
71
    // -------------------------------------------------------------------------
 
72
 
 
73
    private void assertEquals( char uniqueCharacter, DataSet dataSet )
 
74
    {
 
75
        assertEquals( "DataSet" + uniqueCharacter, dataSet.getName() );
 
76
        assertEquals( "ShortName" + uniqueCharacter, dataSet.getShortName() );
 
77
        assertEquals( periodType, dataSet.getPeriodType() );
 
78
    }
 
79
    
 
80
    // -------------------------------------------------------------------------
 
81
    // DataSet
 
82
    // -------------------------------------------------------------------------
 
83
 
 
84
    public void testAddDataSet()
 
85
    {
 
86
        DataSet dataSetA = createDataSet( 'A', periodType );
 
87
        DataSet dataSetB = createDataSet( 'B', periodType );
 
88
 
 
89
        int idA = dataSetStore.addDataSet( dataSetA );
 
90
        int idB = dataSetStore.addDataSet( dataSetB );
 
91
 
 
92
        dataSetA = dataSetStore.getDataSet( idA );
 
93
        dataSetB = dataSetStore.getDataSet( idB );
 
94
 
 
95
        assertEquals( idA, dataSetA.getId() );
 
96
        assertEquals( 'A', dataSetA );
 
97
 
 
98
        assertEquals( idB, dataSetB.getId() );
 
99
        assertEquals( 'B', dataSetB );
 
100
    }
 
101
 
 
102
    public void testUpdateDataSet()
 
103
    {
 
104
        DataSet dataSet = createDataSet( 'A', periodType );
 
105
 
 
106
        int id = dataSetStore.addDataSet( dataSet );
 
107
 
 
108
        dataSet = dataSetStore.getDataSet( id );
 
109
 
 
110
        assertEquals( 'A', dataSet );
 
111
 
 
112
        dataSet.setName( "DataSetB" );
 
113
 
 
114
        dataSetStore.updateDataSet( dataSet );
 
115
 
 
116
        dataSet = dataSetStore.getDataSet( id );
 
117
 
 
118
        assertEquals( dataSet.getName(), "DataSetB" );
 
119
    }
 
120
 
 
121
    public void testDeleteAndGetDataSet()
 
122
    {
 
123
        DataSet dataSetA = createDataSet( 'A', periodType );
 
124
        DataSet dataSetB = createDataSet( 'B', periodType );
 
125
 
 
126
        int idA = dataSetStore.addDataSet( dataSetA );
 
127
        int idB = dataSetStore.addDataSet( dataSetB );
 
128
 
 
129
        assertNotNull( dataSetStore.getDataSet( idA ) );
 
130
        assertNotNull( dataSetStore.getDataSet( idB ) );
 
131
 
 
132
        dataSetStore.deleteDataSet( dataSetStore.getDataSet( idA ) );
 
133
 
 
134
        assertNull( dataSetStore.getDataSet( idA ) );
 
135
        assertNotNull( dataSetStore.getDataSet( idB ) );
 
136
 
 
137
        dataSetStore.deleteDataSet( dataSetStore.getDataSet( idB ) );
 
138
 
 
139
        assertNull( dataSetStore.getDataSet( idA ) );
 
140
        assertNull( dataSetStore.getDataSet( idB ) );
 
141
    }
 
142
 
 
143
    public void testGetDataSetByName()
 
144
        throws Exception
 
145
    {
 
146
        DataSet dataSetA = createDataSet( 'A', periodType );
 
147
        DataSet dataSetB = createDataSet( 'B', periodType );
 
148
 
 
149
        int idA = dataSetStore.addDataSet( dataSetA );
 
150
        int idB = dataSetStore.addDataSet( dataSetB );
 
151
 
 
152
        assertEquals( dataSetStore.getDataSetByName( "DataSetA" ).getId(), idA );
 
153
        assertEquals( dataSetStore.getDataSetByName( "DataSetB" ).getId(), idB );
 
154
        assertNull( dataSetStore.getDataSetByName( "DataSetC" ) );
 
155
    }
 
156
 
 
157
    public void testGetDataSetByShortName()
 
158
        throws Exception
 
159
    {
 
160
        DataSet dataSetA = createDataSet( 'A', periodType );
 
161
        DataSet dataSetB = createDataSet( 'B', periodType );
 
162
 
 
163
        int idA = dataSetStore.addDataSet( dataSetA );
 
164
        int idB = dataSetStore.addDataSet( dataSetB );
 
165
 
 
166
        assertEquals( dataSetStore.getDataSetByShortName( "ShortNameA" ).getId(), idA );
 
167
        assertEquals( dataSetStore.getDataSetByShortName( "ShortNameB" ).getId(), idB );
 
168
        assertNull( dataSetStore.getDataSetByShortName( "ShortNameC" ) );
 
169
    }
 
170
 
 
171
    public void testGetDataSets()
 
172
    {
 
173
        Source sourceA = new DummySource( "A" );
 
174
        sourceStore.addSource( sourceA );
 
175
        Source sourceB = new DummySource( "B" );
 
176
        sourceStore.addSource( sourceB );
 
177
        Source sourceC = new DummySource( "C" );
 
178
        sourceStore.addSource( sourceC );
 
179
        Source sourceD = new DummySource( "D" );
 
180
        sourceStore.addSource( sourceD );
 
181
 
 
182
        DataSet dataSetA = new DataSet( "A", new WeeklyPeriodType() );
 
183
        dataSetA.getSources().add( sourceA );
 
184
        dataSetStore.addDataSet( dataSetA );
 
185
 
 
186
        DataSet dataSetB = new DataSet( "B", new WeeklyPeriodType() );
 
187
        dataSetB.getSources().add( sourceB );
 
188
        dataSetB.getSources().add( sourceC );
 
189
        dataSetStore.addDataSet( dataSetB );
 
190
 
 
191
        DataSet dataSetC = new DataSet( "C", new WeeklyPeriodType() );
 
192
        dataSetC.getSources().add( sourceA );
 
193
        dataSetC.getSources().add( sourceB );
 
194
        dataSetStore.addDataSet( dataSetC );
 
195
 
 
196
        Collection<DataSet> result;
 
197
 
 
198
        result = dataSetStore.getDataSetsBySource( sourceA );
 
199
        assertEquals( 2, result.size() );
 
200
        assertTrue( result.contains( dataSetA ) );
 
201
        assertTrue( result.contains( dataSetC ) );
 
202
 
 
203
        result = dataSetStore.getDataSetsBySource( sourceB );
 
204
        assertEquals( 2, result.size() );
 
205
        assertTrue( result.contains( dataSetB ) );
 
206
        assertTrue( result.contains( dataSetC ) );
 
207
 
 
208
        result = dataSetStore.getDataSetsBySource( sourceC );
 
209
        assertEquals( 1, result.size() );
 
210
        assertTrue( result.contains( dataSetB ) );
 
211
 
 
212
        result = dataSetStore.getDataSetsBySource( sourceD );
 
213
        assertEquals( 0, result.size() );
 
214
    }
 
215
 
 
216
    public void testGetAllDataSets()
 
217
    {
 
218
        DataSet dataSetA = createDataSet( 'A', periodType );
 
219
        DataSet dataSetB = createDataSet( 'B', periodType );
 
220
 
 
221
        dataSetStore.addDataSet( dataSetA );
 
222
        dataSetStore.addDataSet( dataSetB );
 
223
 
 
224
        Collection<DataSet> dataSets = dataSetStore.getAllDataSets();
 
225
 
 
226
        assertEquals( dataSets.size(), 2 );
 
227
        assertTrue( dataSets.contains( dataSetA ) );
 
228
        assertTrue( dataSets.contains( dataSetB ) );
 
229
    }
 
230
 
 
231
    // -------------------------------------------------------------------------
 
232
    // FrequencyOverrideAssociation
 
233
    // -------------------------------------------------------------------------
 
234
 
 
235
    public void testFrequencyOverrideAssociation()
 
236
        throws Exception
 
237
    {
 
238
        PeriodType periodType1 = periodStore.getPeriodType( YearlyPeriodType.class );
 
239
        PeriodType periodType2 = periodStore.getPeriodType( MonthlyPeriodType.class );
 
240
        PeriodType periodType3 = periodStore.getPeriodType( WeeklyPeriodType.class );
 
241
 
 
242
        DataSet dataSet1 = new DataSet( "name1", periodType1 );
 
243
        DataSet dataSet2 = new DataSet( "name2", periodType2 );
 
244
 
 
245
        dataSetStore.addDataSet( dataSet1 );
 
246
        dataSetStore.addDataSet( dataSet2 );
 
247
 
 
248
        Source source1 = new DummySource( "Source1" );
 
249
        Source source2 = new DummySource( "Source2" );
 
250
        sourceStore.addSource( source1 );
 
251
        sourceStore.addSource( source2 );
 
252
 
 
253
        FrequencyOverrideAssociation association = new FrequencyOverrideAssociation( dataSet1, source1, periodType3 );
 
254
 
 
255
        dataSetStore.addFrequencyOverrideAssociation( association );
 
256
        assertEquals( dataSetStore.getFrequencyOverrideAssociationsByDataSet( dataSet1 ).size(), 1 );
 
257
        assertEquals( dataSetStore.getFrequencyOverrideAssociationsBySource( source1 ).size(), 1 );
 
258
        assertEquals( dataSetStore.getFrequencyOverrideAssociationsByDataSet( dataSet2 ).size(), 0 );
 
259
        assertEquals( dataSetStore.getFrequencyOverrideAssociationsBySource( source2 ).size(), 0 );
 
260
 
 
261
        dataSetStore
 
262
            .addFrequencyOverrideAssociation( new FrequencyOverrideAssociation( dataSet1, source2, periodType3 ) );
 
263
        assertEquals( dataSetStore.getFrequencyOverrideAssociationsByDataSet( dataSet1 ).size(), 2 );
 
264
        assertEquals( dataSetStore.getFrequencyOverrideAssociationsBySource( source1 ).size(), 1 );
 
265
        assertEquals( dataSetStore.getFrequencyOverrideAssociationsByDataSet( dataSet2 ).size(), 0 );
 
266
        assertEquals( dataSetStore.getFrequencyOverrideAssociationsBySource( source2 ).size(), 1 );
 
267
 
 
268
        dataSetStore
 
269
            .addFrequencyOverrideAssociation( new FrequencyOverrideAssociation( dataSet2, source1, periodType3 ) );
 
270
        assertEquals( dataSetStore.getFrequencyOverrideAssociationsByDataSet( dataSet1 ).size(), 2 );
 
271
        assertEquals( dataSetStore.getFrequencyOverrideAssociationsBySource( source1 ).size(), 2 );
 
272
        assertEquals( dataSetStore.getFrequencyOverrideAssociationsByDataSet( dataSet2 ).size(), 1 );
 
273
        assertEquals( dataSetStore.getFrequencyOverrideAssociationsBySource( source2 ).size(), 1 );
 
274
 
 
275
        dataSetStore.removeFrequencyOverrideAssociation( association );
 
276
        assertEquals( dataSetStore.getFrequencyOverrideAssociationsByDataSet( dataSet1 ).size(), 1 );
 
277
        assertEquals( dataSetStore.getFrequencyOverrideAssociationsBySource( source1 ).size(), 1 );
 
278
        assertEquals( dataSetStore.getFrequencyOverrideAssociationsByDataSet( dataSet2 ).size(), 1 );
 
279
        assertEquals( dataSetStore.getFrequencyOverrideAssociationsBySource( source2 ).size(), 1 );
 
280
    }
 
281
}