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

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