Changeset 400

Timestamp:

11-05-10 09:26:40 (6 years ago)

Author:

keesvb

Message:

split out subject tests better to distinguish between different problems

File:

• trunk/test/integration/gscf/SubjectTests.groovy (modified) (3 diffs)

trunk/test/integration/gscf/SubjectTests.groovy

@@ -22 +22 @@
 
         final String testSubjectName = "Test subject"
+        final String testSubjectTemplateName = "Human"
+        final String testSubjectSpeciesTerm = "Homo sapiens"
         final String testSubjectBMITemplateFieldName = "BMI"
         final double testSubjectBMI = 25.32
 
+        /**
+         * Set up test: create test subject to use in the tests, thereby test creation
+         */
         protected void setUp() {
                 super.setUp()
-        }
-
-        protected void tearDown() {
-                super.tearDown()
-        }
-
-        /**
-         * Test creation and saving of a new human subject,
-         * by finding the appropriate template as should be defined in the Bootstrap,
-         * and finding the appropriate species as should be defined in the Bootstrap and giveDomainFields
-         *
-         */
-        void testCreation() {
 
                 // Look up human template
-                def humanTemplate = Template.findByName('Human')
+                def humanTemplate = Template.findByName(testSubjectTemplateName)
                 assert humanTemplate
+
+                def humanTerm = Term.findByName(testSubjectSpeciesTerm)
+                assert humanTerm
 
                 def subject = new Subject(
                         name: testSubjectName,
-                        template: humanTemplate
+                        template: humanTemplate,
+                        species: humanTerm
                 )
 
-                // This subject should not validate as required fields species is missing
-                assert !subject.validate()
+                assert subject.save(flush:true)
+        }
+
+        void testSave() {
+                // Try to retrieve the subject and make sure it's the same
+                def subjectDB = Subject.findByName(testSubjectName)
+                assert subjectDB
+                assert subjectDB.name.equals(testSubjectName)
+                assert subjectDB.template.name.equals(testSubjectTemplateName)
+                assert subjectDB.species.name.equals(testSubjectSpeciesTerm)
+        }
+
+        void testValidators() {
+
+                def subject = new Subject(
+                        name: testSubjectName + "-test"
+                );
+                // Should not validate as template and species are missing
+                assert !subject.validate()
+
+                subject.template = Template.findByName(testSubjectTemplateName)
+                // Still, species is missing
+                assert !subject.validate()
+
+                subject.species = Term.findByName(testSubjectSpeciesTerm)
+                assert subject.validate()
+
+                // Change name to already existing name, should fail
+                subject.name = testSubjectName
+                assert !subject.validate()
+        }
+
+        /**
+         * Test domain field setter of a subject,
+         * by finding the appropriate species as should be defined in the Bootstrap and giveDomainFields
+         * Test that species ontology is correctly defined in giveDomainFields
+         * Test setFieldValue() for domain field species
+         *
+         */
+        void testDomainFieldSetters() {
+
+                def subject = Subject.findByName(testSubjectName)
+                assert subject
+
+                // Remove species from subject, should not validate anymore
+                subject.species = null
+                assert !subject.validate()
+
 
                 // Get domain fields and make sure they are name and species
@@ -70 +112 @@
 
                 def speciesTerms = speciesOntology.giveTerms()
-                def humanTerm = speciesTerms.find { it.name == 'Homo sapiens'}// or speciesOntology.giveTermByName('Homo sapiens')
+                def humanTerm = speciesTerms.find { it.name == testSubjectSpeciesTerm}
                 assert humanTerm
 
-                // Assign species, subject should now validate
-                subject.species = humanTerm
+                // Make sure giveTermByName returns the same term
+                assert humanTerm == speciesOntology.giveTermByName('Homo sapiens')
+
+                // Make sure the (in this test used!) Term.findByName returns the same
+                // If this doesn't hold, we probably should rewrite these tests
+                assert humanTerm == Term.findByName(testSubjectSpeciesTerm)
+
+                // Assign species, subject should now validate and save
+                subject.setFieldValue('species',humanTerm)
                 assert subject.validate()
+                assert subject.save(flush:true)
+
+                assert subjectDB.getFieldValue('species') == humanTerm
+                assert subjectDB.getFieldValue('name').equals(testSubjectName)
+                assert subjectDB.getFieldValue('species') == humanTerm
+
+        }
+
+        /**
+         * Test getFieldValue() for domain fields
+         */
+        void testDomainFieldGetters() {
+
+                def subjectDB = Subject.findByName(testSubjectName)
+                assert subjectDB
+
+                assert subjectDB.getFieldValue('name').equals(testSubjectName)
+                assert subjectDB.getFieldValue('species') == Term.findByName(testSubjectSpeciesTerm)
+        }
+
+        /**
+         * Test setFieldValue() for template fields
+         */
+        void testTemplateFieldSetters() {
+
+                def subject = Subject.findByName(testSubjectName)
+                assert subject
 
                 // Assign a template field using setFieldValue: BMI
@@ -86 +162 @@
                 assert subject.save(flush: true)
 
-                // Try to retrieve the subject and make sure it's the same
+
+        }
+
+        /**
+        * Test getFieldValue() for template fields
+        */
+        void testTemplateFieldGetters() {
+
+                // Try to retrieve the subject and make sure the BMI was stored
                 def subjectDB = Subject.findByName(testSubjectName)
                 assert subjectDB
-                assert subjectDB.name.equals(testSubjectName)
-                assert subjectDB.template.name.equals(humanTemplate.name)
-                assert subjectDB.species.name.equals(humanTerm.name)
+                assert subjectDB.getFieldValue(testSubjectBMITemplateFieldName) == testSubjectBMI
+        }
+
+        /**
+         * Test giveFields(): should return name, species and template fields
+         */
+        void testGiveFields() {
+
+                def subject = Subject.findByName(testSubjectName)
+                assert subject
 
                 // Test giveFields
-                def fields = subjectDB.giveFields()
+                def fields = subject.giveFields()
                 def i = 0
                 assert fields[i++].name == 'name'
                 assert fields[i++].name == 'species'
+
+                // Look up human template
+                def humanTemplate = Template.findByName(testSubjectTemplateName)
+                assert humanTemplate
+
                 humanTemplate.fields.each {
                         assert fields[i++].name.equals(it.name)
                 }
 
-                // Test getFieldValue
-                assert subjectDB.getFieldValue('name').equals(testSubjectName)
-                assert subjectDB.getFieldValue('species') == humanTerm
-                assert subjectDB.getFieldValue(testSubjectBMITemplateFieldName) == testSubjectBMI
-
+        }
+
+        protected void tearDown() {
+                super.tearDown()
         }