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

Last change on this file since 1456 was 1456, checked in by business@…, 10 years ago

moved gdt package to org.dbnp, moved tests for RelTime?, TemplateEntity?, Template etc. to gdt plugin

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