Changeset 653 for trunk/test

Timestamp:

Jul 15, 2010, 1:01:53 PM (13 years ago)

Author:

keesvb

Message:

updated study tests with code, added samplingevent and sample tests

Location:

trunk/test/integration/gscf

Files:

• SampleTests.groovy (copied) (copied from trunk/test/integration/gscf/StudyTests.groovy) (2 diffs)
• StudyTests.groovy (modified) (6 diffs)

trunk/test/integration/gscf/SampleTests.groovy

@@ -1 +1 @@
 package gscf
 
-import grails.test.*
-import dbnp.studycapturing.*
-import dbnp.data.*
+import dbnp.studycapturing.Study
+import dbnp.studycapturing.Template
+import grails.test.GrailsUnitTestCase
+import dbnp.studycapturing.SamplingEvent
+import dbnp.studycapturing.Sample
 
 /**
- * Test the creation of a Subject and its TemplateEntity functionality on data model level
+ * Test the creation of a Sample and its TemplateEntity functionality on data model level
  *
  * @author keesvb
@@ -17 +19 @@
  * $Date$
  */
-class StudyTests extends GrailsUnitTestCase {
 
-        final String testStudyName = "Test study"
-        final String testStudyTemplateName = "Academic study"
-        final Date testStudyStartDate = Date.parse('yyyy-MM-dd','2007-12-11')
-        final Date testStudyStartDate2 = Date.parse('yyyy-MM-dd','2008-05-11')
-        final String testStudyStartDateString2 = "11-5-2008"
-        // The following dates do net yet work:
-        //final String testStudyStartDateString2 = "11-05-2010"
-        //final String testStudyStartDateString2 = "Tue Dec 13 00:00:00 EST 2008"
+class SampleTests extends StudyTests {
+
+        // This test extends StudyTests, so that we have a test study to assign as a parent study
+
+        final String testSampleName = "Test sample"
+        final String testSampleTemplateName = "Human blood sample"
+
+        final String testSamplingEventName = "Test sampling event"
+        final String testSamplingEventTemplateName = "Blood extraction"
+        final long testSamplingEventTime = 34534534L
+
 
         protected void setUp() {
                 super.setUp()
 
-                // Look up academic template
-                def studyTemplate = Template.findByName(testStudyTemplateName)
-                assert studyTemplate
+                // Retrieve the study that should have been created in StudyTests
+                def study = Study.findByTitle(testStudyName)
+                assert study
 
-                def study = new Study(
-                    title: testStudyName,
-                    template: studyTemplate,
-                    startDate: testStudyStartDate
+                // Look up sampling event template
+                def samplingEventTemplate = Template.findByName(testSamplingEventTemplateName)
+                assert samplingEventTemplate
+
+                // Create parent sampling event
+                def samplingEvent = new SamplingEvent(
+                        startTime: testSamplingEventTime,
+                        endTime: testSamplingEventTime,
+                        template: samplingEventTemplate
                 )
 
-                if (!study.validate()) {
-                        study.errors.each { println it}
+                if (!samplingEvent.validate()) {
+                        samplingEvent.errors.each { println it}
                 }
-                assert study.validate()
+                assert samplingEvent.validate()
 
 
-                assert study.save(flush: true)
+                // Look up sample template
+                def sampleTemplate = Template.findByName(testSampleTemplateName)
+                assert sampleTemplate
+
+                // Create sample with the retrieved study as parent
+                def sample = new Sample(
+                    name: testSampleName,
+                    template: sampleTemplate,
+                    parentEvent: samplingEvent
+                )
+
+                // At this point, the sample should not validate, because it doesn't have a parent study assigned
+                assert !sample.validate()
+
+                // Add the sample to the retrieved parent study
+                study.addToSamples(sample)
+                assert study.samples.find { it.name == sample.name}
+
+                // Now, the sample should validate
+                if (!sample.validate()) {
+                        sample.errors.each { println it}
+                }
+                assert sample.validate()
+
+                // Make sure the sample is saved to the database
+                assert sample.save(flush: true)
 
         }
 
         void testSave() {
-                // Try to retrieve the study and make sure it's the same
-                def studyDB = Study.findByTitle(testStudyName)
-                assert studyDB
-                assert studyDB.title.equals(testStudyName)
-                assert studyDB.template.name.equals(testStudyTemplateName)
-                assert studyDB.startDate.equals(testStudyStartDate)
+                // Try to retrieve the sample and make sure it's the same
+                def sampleDB = Sample.findByName(testSampleName)
+                assert sampleDB
+                assert sampleDB.name.equals(testSampleName)
+                assert sampleDB.template.name.equals(testSampleTemplateName)
+                assert sampleDB.parentEvent
+                assert sampleDB.parentEvent.startTime.equals(testSamplingEventTime)
 
-                // A study without a title should not be saveable
-                studyDB.title = null
-                assert !studyDB.validate()
+                // A sample without a name should not be saveable
+                sampleDB.name = null
+                assert !sampleDB.validate()
+
+                // A sample without a parent SamplingEvent should not be saveable
+                sampleDB.name = testSampleName
+                sampleDB.parentEvent = null
+                assert !sampleDB.validate()
+        }
+
+        void testStudyRelation() {
+                // Retrieve the parent study
+                def study = Study.findByTitle(testStudyName)
+                assert study
+
+                // Test giveSamplingEventTemplates
+                def templates = study.giveSamplingEventTemplates()
+                assert templates
+                assert templates.size() == 1
+                assert templates
+
+                // Test if the sample is in the samples collection
+                assert study.samples
+                assert study.samples.size() == 1
+                assert study.samples.first().name == testSampleName
+        }
+
+        void testFindViaSamplingEvent() {
+                // Try to retrieve the sampling event by using the time...
+                // (should be also the parent study but that's not yet implemented)
+                def samplingEventDB = SamplingEvent.findByStartTime(testSamplingEventTime)
+                assert samplingEventDB
+
+                def samples = samplingEventDB.getSamples()
+                assert samples
+                assert samples.size() == 1
+                assert samples.first().name == testSampleName
         }
 
         void testDomainFields() {
-                def study = Study.findByTitle(testStudyName)
-                assert study
+                def sample = Sample.findByName(testStudyName)
+                assert sample
 
                 // Make sure the domain fields exist
-                assert study.fieldExists('title')
-                assert study.fieldExists('startDate')
+                assert sample.fieldExists('name')
+                assert sample.fieldExists('material')
 
                 // Make sure they are domain fields
-                assert study.isDomainField('title')
-                assert study.isDomainField('startDate')
-                
-        }
-
-        void testSetDate() {
-                def study = Study.findByTitle(testStudyName)
-                assert study
-
-                // Set a new date, using a string, and check whether that is stored correctly
-                study.setFieldValue("startDate",testStudyStartDateString2)
-                assert study.validate()
-                assert study.save(flush:true)
-                assert study.getFieldValue("startDate").equals(testStudyStartDate2) 
+                assert sample.isDomainField('name')
+                assert sample.isDomainField('material')
 
         }

trunk/test/integration/gscf/StudyTests.groovy

@@ -21 +21 @@
         final String testStudyName = "Test study"
         final String testStudyTemplateName = "Academic study"
+        final String testStudyCode = "AAA-Test"
         final Date testStudyStartDate = Date.parse('yyyy-MM-dd','2007-12-11')
         final Date testStudyStartDate2 = Date.parse('yyyy-MM-dd','2008-05-11')
@@ -36 +37 @@
 
                 def study = new Study(
-                    title: testStudyName,
-                    template: studyTemplate,
-                    startDate: testStudyStartDate
+                        title: testStudyName,
+                        template: studyTemplate,
+                        startDate: testStudyStartDate,
+                        code: testStudyCode
                 )
 
@@ -53 +55 @@
         void testSave() {
                 // Try to retrieve the study and make sure it's the same
-                def studyDB = Study.findByTitle(testStudyName)
+                def studyDB = Study.findByCode(testStudyCode)
                 assert studyDB
                 assert studyDB.title.equals(testStudyName)
+                assert studyDB.code.equals(testStudyCode)
                 assert studyDB.template.name.equals(testStudyTemplateName)
                 assert studyDB.startDate.equals(testStudyStartDate)
@@ -65 +68 @@
 
         void testDomainFields() {
-                def study = Study.findByTitle(testStudyName)
+                def study = Study.findByCode(testStudyCode)
                 assert study
 
@@ -71 +74 @@
                 assert study.fieldExists('title')
                 assert study.fieldExists('startDate')
+                assert study.fieldExists('code')
+
 
                 // Make sure they are domain fields
                 assert study.isDomainField('title')
                 assert study.isDomainField('startDate')
+                assert study.isDomainField('code')
                 
         }
 
         void testSetDate() {
-                def study = Study.findByTitle(testStudyName)
+                def study = Study.findByCode(testStudyCode)
                 assert study
 
@@ -91 +97 @@
 
         protected void tearDown() {
+
+                // Delete the created study
+                def study = Study.findByCode(testStudyCode)
+                assert study
+
+                study.delete()
+                assert Study.findByCode(testStudyCode) == null
+
                 super.tearDown()
         }