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

Last change on this file since 817 was 817, checked in by keesvb, 10 years ago

fixed deleting of event groups, they now also cascade to samples in the event group

  • Property svn:keywords set to Date Author Rev
File size: 8.7 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: 817 $
21 * $Author: keesvb $
22 * $Date: 2010-08-17 12:42:54 +0000 (di, 17 aug 2010) $
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 sampling event template
47                def samplingEventTemplate = Template.findByName(testSamplingEventTemplateName)
48                assert samplingEventTemplate
49
50                // Look up sample template
51                def sampleTemplate = Template.findByName(testSampleTemplateName)
52                assert sampleTemplate
53
54                // Create parent sampling event
55                def samplingEvent = new SamplingEvent(
56                        startTime: testSamplingEventTime,
57                        duration: testSamplingEventDuration,
58                        template: samplingEventTemplate,
59                        sampleTemplate: sampleTemplate
60                )
61
62                // The SamplingEvent should not validate at this point because it doesn't have a parent study
63                assert !samplingEvent.validate()
64
65                study.addToSamplingEvents(samplingEvent)
66                // It should do fine now
67                assert samplingEvent.validate()
68                assert samplingEvent.save(flush:true)
69
70                // Create sample with the retrieved study as parent
71                def sample = new Sample(
72                    name: testSampleName,
73                    template: sampleTemplate,
74                    parentEvent: samplingEvent
75                )
76
77                // At this point, the sample should not validate, because it doesn't have a parent study assigned
78                assert !sample.validate()
79
80                // Add the sample to the retrieved parent study
81                study.addToSamples(sample)
82                assert study.samples.find { it.name == sample.name}
83
84                // Now, the sample should validate
85                if (!sample.validate()) {
86                        sample.errors.each { println it}
87                }
88                assert sample.validate()
89
90                // Make sure the sample is saved to the database
91                assert sample.save(flush: true)
92
93        }
94
95        void testSave() {
96
97                // Try to retrieve the sample and make sure it's the same
98                def sampleDB = Sample.findByName(testSampleName)
99                assert sampleDB
100                assert sampleDB.name.equals(testSampleName)
101                assert sampleDB.template.name.equals(testSampleTemplateName)
102                assert sampleDB.parentEvent
103                assert sampleDB.parentEvent.startTime.equals(testSamplingEventTime)
104
105                println "The sample has parentEvent ${sampleDB.parentEvent.encodeAsHTML()}"
106                // A sample without a name should not be saveable
107                sampleDB.name = null
108                assert !sampleDB.validate()
109
110                // A sample without a parent SamplingEvent should not be saveable
111                sampleDB.name = testSampleName
112                sampleDB.parentEvent = null
113                assert !sampleDB.validate()
114        }
115
116        void testDelete() {
117                def sampleDB = Sample.findByName(testSampleName)
118                sampleDB.delete()
119                try {
120                        sampleDB.save()
121                        assert false // The save should not succeed since the sample is referenced by a study
122                }
123                catch(org.springframework.dao.InvalidDataAccessApiUsageException e) {
124                        sampleDB.discard()
125                        assert true // OK, correct exception (at least for the in-mem db, for PostgreSQL it's probably a different one...)
126                }
127
128                // Now, delete the sample from the study samples collection, and then the delete action should be cascaded to the sample itself
129                def study = Study.findByTitle(testStudyName)
130                assert study
131                study.removeFromSamples sampleDB
132
133                // Make sure the sample doesn't exist anymore at this point
134                assert !Sample.findByName(testSampleName)
135                assert Sample.count() == 0
136                assert study.samples.size() == 0
137        }
138
139        void testDeleteViaParentSubject() {
140
141                def sampleDB = Sample.findByName(testSampleName)
142                assert sampleDB
143
144                // Retrieve the parent study
145                def study = Study.findByTitle(testStudyName)
146                assert study
147
148                def subject = SubjectTests.createSubject(study)
149                assert subject
150
151                sampleDB.parentSubject = subject
152                assert sampleDB.validate()
153                assert sampleDB.save()
154
155                // Use the deleteSubject method
156                def msg = study.deleteSubject(subject)
157                println msg
158                assert study.save()
159
160                assert !study.subjects.contains(subject)
161
162                assert !Subject.findByName(subject.name)
163                assert !Sample.findByName(testSampleName)
164
165                assert Subject.count() == 0
166                assert Sample.count() == 0
167
168        }
169
170        void testDeleteViaParentSamplingEvent() {
171
172                def sampleDB = Sample.findByName(testSampleName)
173                assert sampleDB
174
175                // Retrieve the parent study
176                def study = Study.findByTitle(testStudyName)
177                assert study
178
179                def event = sampleDB.parentEvent
180                assert event
181
182                // Use the deleteSamplingEvent method
183                def msg = study.deleteSamplingEvent(event)
184                println msg
185                assert study.save()
186
187                assert !study.samplingEvents.contains(event)
188
189                assert !SamplingEvent.findByStartTime(testSamplingEventTime)
190                assert !Sample.findByName(testSampleName)
191
192                assert SamplingEvent.count() == 0
193                assert Sample.count() == 0
194
195        }
196
197        void testDeleteViaParentEventGroup() {
198
199                def sampleDB = Sample.findByName(testSampleName)
200                assert sampleDB
201
202                // Retrieve the parent study
203                def study = Study.findByTitle(testStudyName)
204                assert study
205
206                // Retrieve the sample's sampling event
207                def event = sampleDB.parentEvent
208                assert event
209
210                // Create a subject and add it at the sample's parent
211                def subject = SubjectTests.createSubject(study)
212                assert subject
213                sampleDB.parentSubject = subject
214                assert sampleDB.validate()
215                assert sampleDB.save()
216
217                // Create an event group in this study with the sample's sampling event
218                def group = new EventGroup(
219                    name: testEventGroupName
220                )
221                study.addToEventGroups(group)
222                assert group.validate()
223
224
225                group.addToSubjects(subject)
226                group.addToSamplingEvents(event)
227                assert study.eventGroups.find { it.name == group.name}
228                assert group.validate()
229                assert study.save()
230
231                // Use the deleteSamplingEvent method
232                def msg = study.deleteEventGroup(group)
233                println msg
234                assert study.save()
235
236                assert !study.eventGroups.contains(group)
237                assert !EventGroup.findByName(testEventGroupName)
238                assert !Sample.findByName(testSampleName)
239
240                assert EventGroup.count() == 0
241                assert Sample.count() == 0
242
243        }
244
245        void testStudyRelation() {
246                // Retrieve the parent study
247                def study = Study.findByTitle(testStudyName)
248                assert study
249
250                // Test giveSampleTemplates
251                def templates = study.giveSampleTemplates()
252                assert templates
253                assert templates.size() == 1
254                assert templates.asList().first().name == testSampleTemplateName
255
256                // Test if the sample is in the samples collection
257                assert study.samples
258                assert study.samples.size() == 1
259                assert study.samples.first().name == testSampleName
260        }
261
262
263        void testParentStudy() {
264                def sample = Sample.findByName(testSampleName)
265                assert sample
266
267                assert sample.parent
268                assert sample.parent.code == testStudyCode
269        }
270
271        void testSampleUniqueNameConstraint() {
272                def sample = Sample.findByName(testSampleName)
273                assert sample
274
275                def study = sample.parent
276                assert study
277
278                def sample2 = new Sample(
279                    name: testSampleName,
280                    template: sample.template,
281                    parentEvent: sample.parentEvent
282                )
283
284                // Add the sample to the retrieved parent study
285                study.addToSamples(sample2)
286
287                // At this point, the sample should not validate or save, because there is already a sample with that name in the study
288                assert !sample2.validate()
289                assert !sample2.save(flush:true)
290
291        }
292
293        void testFindViaSamplingEvent() {
294                // Try to retrieve the sampling event by using the time...
295                // (should be also the parent study but that's not yet implemented)
296                def samplingEventDB = SamplingEvent.findByStartTime(testSamplingEventTime)
297                assert samplingEventDB
298
299                def samples = samplingEventDB.getSamples()
300                assert samples
301                assert samples.size() == 1
302                assert samples.first().name == testSampleName
303        }
304
305        void testDomainFields() {
306                def sample = Sample.findByName(testSampleName)
307                assert sample
308
309                // Make sure the domain fields exist
310                assert sample.fieldExists('name')
311                assert sample.fieldExists('material')
312
313                // Make sure they are domain fields
314                assert sample.isDomainField('name')
315                assert sample.isDomainField('material')
316
317                // Make sure that they have the right type
318                assert sample.giveFieldType('name') == TemplateFieldType.STRING
319                assert sample.giveFieldType('material') == TemplateFieldType.ONTOLOGYTERM
320
321        }
322
323        protected void tearDown() {
324                super.tearDown()
325        }
326
327}
Note: See TracBrowser for help on using the repository browser.