source: trunk/test/integration/gscf/SampleTests.groovy @ 1504

Last change on this file since 1504 was 1504, checked in by s.h.sikkema@…, 10 years ago

Partially fixed the integration tests

  • Property svn:keywords set to Rev Author Date
File size: 11.0 KB
Line 
1package gscf
2
3import dbnp.studycapturing.*
4import org.dbnp.gdt.Template
5import org.dbnp.gdt.TemplateFieldType
6
7/**
8 * Test the creation of a Sample and its TemplateEntity functionality on data model level
9 *
10 * @author keesvb
11 * @since 20100511
12 * @package dbnp.studycapturing
13 *
14 * Revision information:
15 * $Rev: 1504 $
16 * $Author: s.h.sikkema@gmail.com $
17 * $Date: 2011-02-08 09:48:41 +0000 (di, 08 feb 2011) $
18 */
19
20class SampleTests extends StudyTests {
21
22        // This test extends StudyTests, so that we have a test study to assign as a parent study
23
24        final String testSampleName = "Test sample @XYZ!"
25        final String testSampleTemplateName = "Human blood sample"
26
27        final String testSamplingEventName = "Test sampling event"
28        final String testSamplingEventTemplateName = "Blood extraction"
29        final long testSamplingEventTime = 34534534L
30        final long testSamplingEventDuration = 1000L
31        final String testEventGroupName = "Test Group"
32
33
34        protected void setUp() {
35                super.setUp()
36
37                // Retrieve the study that should have been created in StudyTests
38                def study = Study.findByTitle(testStudyName)
39                assert study
40
41                // Look up sample template
42                def sampleTemplate = Template.findByName(testSampleTemplateName)
43                assert sampleTemplate
44
45                // Create sample with the retrieved study as parent
46                def sample = new Sample(
47                    name: testSampleName,
48                    template: sampleTemplate
49                )
50
51                // At this point, the sample should not validate, because it doesn't have a parent study assigned
52                assert !sample.validate()
53
54                // Add the sample to the retrieved parent study
55                study.addToSamples(sample)
56                assert study.samples.find { it.name == sample.name}
57
58                // Now, the sample should validate
59                if (!sample.validate()) {
60                        sample.errors.each { println it}
61                }
62                assert sample.validate()
63
64                // Make sure the sample is saved to the database
65                assert sample.save(flush: true)
66
67        }
68
69        private void addParentSamplingEvent() {
70
71                // Retrieve the sample
72                def sampleDB = Sample.findByName(testSampleName)
73                assert sampleDB
74
75                // Retrieve the study that should have been created in StudyTests
76                def study = Study.findByTitle(testStudyName)
77                assert study
78
79                // Look up sampling event template
80                def samplingEventTemplate = Template.findByName(testSamplingEventTemplateName)
81                assert samplingEventTemplate
82
83                // Create parent sampling event
84                def samplingEvent = new SamplingEvent(
85                        startTime: testSamplingEventTime,
86                        duration: testSamplingEventDuration,
87                        template: samplingEventTemplate,
88                        sampleTemplate: Template.findByName(testSampleTemplateName)
89                )
90
91                // The SamplingEvent should not validate at this point because it doesn't have a parent study
92                assert !samplingEvent.validate()
93
94                study.addToSamplingEvents(samplingEvent)
95                // It should do fine now
96                assert samplingEvent.validate()
97                assert samplingEvent.save(flush:true)
98
99                // Add sample to the sampling event
100                samplingEvent.addToSamples(sampleDB)
101
102                // Make sure the sampling event is really the parent event of the sample
103                assert sampleDB.parentEvent
104                assert sampleDB.parentEvent == samplingEvent
105                assert sampleDB.parentEvent.startTime.equals(testSamplingEventTime)
106
107        }
108
109        private void addParentSubject() {
110
111                def sampleDB = Sample.findByName(testSampleName)
112                assert sampleDB
113
114                // Retrieve the parent study
115                def study = Study.findByTitle(testStudyName)
116                assert study
117
118                def subject = SubjectTests.createSubject(study)
119                assert subject
120
121                sampleDB.parentSubject = subject
122                assert sampleDB.validate()
123                assert sampleDB.save()
124
125        }
126
127        /**
128         * Test whether a study which has orphan (without parent subject/event) samples cannot be published
129         */
130        void testStudyPublish() {
131                def sampleDB = Sample.findByName(testSampleName)
132                assert sampleDB
133
134                // Retrieve the parent study
135                def study = Study.findByTitle(testStudyName)
136                assert study
137
138                // Make sure the study validates at this point
139                assert study.validate()
140
141                // Try to publish the study, should fail as it has a sample without a parent sampling event
142                study.published = true
143                assert !study.validate()
144
145                // Add parent sampling event
146                addParentSamplingEvent()
147
148                // Add parent subject
149                addParentSubject()
150
151                // Now the study should validate
152                assert study.validate()
153        }
154
155        void testSave() {
156
157                // Try to retrieve the sample and make sure it's the same
158                def sampleDB = Sample.findByName(testSampleName)
159                assert sampleDB
160                assert sampleDB.name.equals(testSampleName)
161                assert sampleDB.template.name.equals(testSampleTemplateName)
162
163                println "The sample has parentEvent ${sampleDB.parentEvent.encodeAsHTML()}"
164                // A sample without a name should not be saveable
165                sampleDB.name = null
166                assert !sampleDB.validate()
167
168        }
169
170        void testDelete() {
171                def sampleDB = Sample.findByName(testSampleName)
172                assert sampleDB
173                sampleDB.delete()
174                try {
175                        sampleDB.save()
176                        assert false // The save should not succeed since the sample is referenced by a study
177                }
178                catch(org.springframework.dao.InvalidDataAccessApiUsageException e) {
179                        sampleDB.discard()
180                        assert true // OK, correct exception (at least for the in-mem db, for PostgreSQL it's probably a different one...)
181                }
182
183                // Now, delete the sample from the study samples collection, and then the delete action should be cascaded to the sample itself
184                def study = Study.findByTitle(testStudyName)
185                assert study
186                study.removeFromSamples sampleDB
187
188                // Make sure the sample doesn't exist anymore at this point
189                assert !Sample.findByName(testSampleName)
190                assert Sample.count() == 0
191                assert study.samples.size() == 0
192        }
193
194        void testDeleteViaParentSubject() {
195
196                def sampleDB = Sample.findByName(testSampleName)
197                assert sampleDB
198
199                // Retrieve the parent study
200                def study = Study.findByTitle(testStudyName)
201                assert study
202
203                // Add parent subject
204                addParentSubject()
205                Subject subject = sampleDB.parentSubject
206
207                // Use the deleteSubject method
208                def msg = study.deleteSubject(subject)
209                println msg
210                assert study.save()
211
212                assert !study.subjects.contains(subject)
213
214                assert !Subject.findByName(subject.name)
215                assert !Sample.findByName(testSampleName)
216
217                assert Subject.count() == 0
218                assert Sample.count() == 0
219
220        }
221
222        void testDeleteViaParentSamplingEvent() {
223
224                def sampleDB = Sample.findByName(testSampleName)
225                assert sampleDB
226
227                // Retrieve the parent study
228                def study = Study.findByTitle(testStudyName)
229                assert study
230
231                // Add parent sampling event
232                addParentSamplingEvent()
233
234                def event = sampleDB.parentEvent
235                assert event
236
237                // Use the deleteSamplingEvent method
238                def msg = study.deleteSamplingEvent(event)
239                println msg
240                assert study.save()
241
242                assert !study.samplingEvents.contains(event)
243
244                assert !SamplingEvent.findByStartTime(testSamplingEventTime)
245                assert !Sample.findByName(testSampleName)
246
247                assert SamplingEvent.count() == 0
248                assert Sample.count() == 0
249
250        }
251
252        void testDeleteViaParentEventGroup() {
253
254                def sampleDB = Sample.findByName(testSampleName)
255                assert sampleDB
256
257                // Retrieve the parent study
258                def study = Study.findByTitle(testStudyName)
259                assert study
260
261                // Retrieve the sample's sampling event
262                addParentSamplingEvent()
263                def event = sampleDB.parentEvent
264                assert event
265
266                // Add parent subject
267                addParentSubject()
268                Subject subject = sampleDB.parentSubject
269
270                // Create an event group in this study with the sample's sampling event and subject
271                def group = new EventGroup(
272                    name: testEventGroupName
273                )
274                study.addToEventGroups(group)
275                assert group.validate()
276
277                group.addToSubjects(subject)
278                group.addToSamplingEvents(event)
279
280                assert study.eventGroups.find { it.name == group.name}
281                assert group.validate()
282                assert study.save()
283
284                // Use the deleteEventGroup method
285                def msg = study.deleteEventGroup(group)
286                println msg
287                assert Sample.count() == 0 // trigger (if any) e.ObjectDeletedException: deleted object would be re-saved by cascade (remove deleted object from associations)
288                if (!study.validate()) {
289                        study.errors.each { println it}
290                }
291                assert study.validate()
292
293                assert study.save()
294
295                assert !study.eventGroups.contains(group)
296                assert !EventGroup.findByName(testEventGroupName)
297                assert !Sample.findByName(testSampleName)
298
299                assert EventGroup.count() == 0
300                assert Sample.count() == 0
301
302        }
303
304        void testStudyRelation() {
305                // Retrieve the parent study
306                def study = Study.findByTitle(testStudyName)
307                assert study
308
309                // Test giveSampleTemplates
310                def templates = study.giveSampleTemplates()
311                assert templates
312                assert templates.size() == 1
313                assert templates.asList().first().name == testSampleTemplateName
314
315                // Test if the sample is in the samples collection
316                assert study.samples
317                assert study.samples.size() == 1
318                assert study.samples.first().name == testSampleName
319        }
320
321
322        void testParentStudy() {
323                def sample = Sample.findByName(testSampleName)
324                assert sample
325
326                assert sample.parent
327                assert sample.parent.code == testStudyCode
328        }
329
330        void testSampleUniqueNameConstraint() {
331                def sample = Sample.findByName(testSampleName)
332                assert sample
333
334                def study = sample.parent
335                assert study
336
337                def sample2 = new Sample(
338                    name: testSampleName,
339                    template: sample.template,
340                    parentEvent: sample.parentEvent
341                )
342
343                // Add the sample to the retrieved parent study
344                study.addToSamples(sample2)
345
346                // At this point, the sample should not validate or save, because there is already a sample with that name in the study
347                assert !sample2.validate()
348                assert !sample2.save(flush:true)
349
350        }
351
352        /**
353         * Test whether it's indeed not possible to add two yet-to-be-saved samples with the same name to a yet-to-be-saved study
354         */
355        void testSampleUniqueNameConstraintAtValidate() {
356                def sample = Sample.findByName(testSampleName)
357                assert sample
358
359                def study = sample.parent
360                assert study
361
362                def sample1 = new Sample(
363                    name: testSampleName + "-double",
364                    template: sample.template,
365                    parentEvent: sample.parentEvent
366                )
367
368                def sample2 = new Sample(
369                        name: testSampleName + "-double",
370                    template: sample.template,
371                    parentEvent: sample.parentEvent
372                )
373
374                // Add the sample to the retrieved parent study
375                study.addToSamples(sample1)
376                study.addToSamples(sample2)
377
378                // At this point, the sample should not validate or save, because there is already a sample with that name in the study
379                assert !sample1.validate()
380                assert !sample1.save(flush:true)
381
382                assert !sample2.validate()
383                assert !sample2.save(flush:true)
384        }
385
386        void testFindViaSamplingEvent() {
387
388                // Add parent sampling event
389                addParentSamplingEvent()
390               
391                // Try to retrieve the sampling event by using the time...
392                // (should be also the parent study but that's not yet implemented)
393                def samplingEventDB = SamplingEvent.findByStartTime(testSamplingEventTime)
394                assert samplingEventDB
395
396                def samples = samplingEventDB.getSamples()
397                assert samples
398                assert samples.size() == 1
399                assert samples.every {it.name == testSampleName}
400        }
401
402        void testDomainFields() {
403                def sample = Sample.findByName(testSampleName)
404                assert sample
405
406                // Make sure the domain fields exist
407                assert sample.fieldExists('name')
408                assert sample.fieldExists('material')
409
410                // Make sure they are domain fields
411                assert sample.isDomainField('name')
412                assert sample.isDomainField('material')
413
414                // Make sure that they have the right type
415                assert sample.giveFieldType('name') == TemplateFieldType.STRING
416                assert sample.giveFieldType('material') == TemplateFieldType.ONTOLOGYTERM
417
418        }
419
420        protected void tearDown() {
421                super.tearDown()
422        }
423
424}
Note: See TracBrowser for help on using the repository browser.