Changeset 400

Show
Ignore:
Timestamp:
11-05-10 09:26:40 (4 years ago)
Author:
keesvb
Message:

split out subject tests better to distinguish between different problems

Files:
1 modified

Legend:

Unmodified
Added
Removed
  • trunk/test/integration/gscf/SubjectTests.groovy

    r398 r400  
    2222 
    2323        final String testSubjectName = "Test subject" 
     24        final String testSubjectTemplateName = "Human" 
     25        final String testSubjectSpeciesTerm = "Homo sapiens" 
    2426        final String testSubjectBMITemplateFieldName = "BMI" 
    2527        final double testSubjectBMI = 25.32 
    2628 
     29        /** 
     30         * Set up test: create test subject to use in the tests, thereby test creation 
     31         */ 
    2732        protected void setUp() { 
    2833                super.setUp() 
    29         } 
    30  
    31         protected void tearDown() { 
    32                 super.tearDown() 
    33         } 
    34  
    35         /** 
    36          * Test creation and saving of a new human subject, 
    37          * by finding the appropriate template as should be defined in the Bootstrap, 
    38          * and finding the appropriate species as should be defined in the Bootstrap and giveDomainFields 
    39          * 
    40          */ 
    41         void testCreation() { 
    4234 
    4335                // Look up human template 
    44                 def humanTemplate = Template.findByName('Human') 
     36                def humanTemplate = Template.findByName(testSubjectTemplateName) 
    4537                assert humanTemplate 
     38 
     39                def humanTerm = Term.findByName(testSubjectSpeciesTerm) 
     40                assert humanTerm 
    4641 
    4742                def subject = new Subject( 
    4843                        name: testSubjectName, 
    49                         template: humanTemplate 
     44                        template: humanTemplate, 
     45                        species: humanTerm 
    5046                ) 
    5147 
    52                 // This subject should not validate as required fields species is missing 
    53                 assert !subject.validate() 
     48                assert subject.save(flush:true) 
     49        } 
     50 
     51        void testSave() { 
     52                // Try to retrieve the subject and make sure it's the same 
     53                def subjectDB = Subject.findByName(testSubjectName) 
     54                assert subjectDB 
     55                assert subjectDB.name.equals(testSubjectName) 
     56                assert subjectDB.template.name.equals(testSubjectTemplateName) 
     57                assert subjectDB.species.name.equals(testSubjectSpeciesTerm) 
     58        } 
     59 
     60        void testValidators() { 
     61 
     62                def subject = new Subject( 
     63                        name: testSubjectName + "-test" 
     64                ); 
     65                // Should not validate as template and species are missing 
     66                assert !subject.validate() 
     67 
     68                subject.template = Template.findByName(testSubjectTemplateName) 
     69                // Still, species is missing 
     70                assert !subject.validate() 
     71 
     72                subject.species = Term.findByName(testSubjectSpeciesTerm) 
     73                assert subject.validate() 
     74 
     75                // Change name to already existing name, should fail 
     76                subject.name = testSubjectName 
     77                assert !subject.validate() 
     78        } 
     79 
     80        /** 
     81         * Test domain field setter of a subject, 
     82         * by finding the appropriate species as should be defined in the Bootstrap and giveDomainFields 
     83         * Test that species ontology is correctly defined in giveDomainFields 
     84         * Test setFieldValue() for domain field species 
     85         * 
     86         */ 
     87        void testDomainFieldSetters() { 
     88 
     89                def subject = Subject.findByName(testSubjectName) 
     90                assert subject 
     91 
     92                // Remove species from subject, should not validate anymore 
     93                subject.species = null 
     94                assert !subject.validate() 
     95 
    5496 
    5597                // Get domain fields and make sure they are name and species 
     
    70112 
    71113                def speciesTerms = speciesOntology.giveTerms() 
    72                 def humanTerm = speciesTerms.find { it.name == 'Homo sapiens'}// or speciesOntology.giveTermByName('Homo sapiens') 
     114                def humanTerm = speciesTerms.find { it.name == testSubjectSpeciesTerm} 
    73115                assert humanTerm 
    74116 
    75                 // Assign species, subject should now validate 
    76                 subject.species = humanTerm 
     117                // Make sure giveTermByName returns the same term 
     118                assert humanTerm == speciesOntology.giveTermByName('Homo sapiens') 
     119 
     120                // Make sure the (in this test used!) Term.findByName returns the same 
     121                // If this doesn't hold, we probably should rewrite these tests 
     122                assert humanTerm == Term.findByName(testSubjectSpeciesTerm) 
     123 
     124                // Assign species, subject should now validate and save 
     125                subject.setFieldValue('species',humanTerm) 
    77126                assert subject.validate() 
     127                assert subject.save(flush:true) 
     128 
     129                assert subjectDB.getFieldValue('species') == humanTerm 
     130                assert subjectDB.getFieldValue('name').equals(testSubjectName) 
     131                assert subjectDB.getFieldValue('species') == humanTerm 
     132 
     133        } 
     134 
     135        /** 
     136         * Test getFieldValue() for domain fields 
     137         */ 
     138        void testDomainFieldGetters() { 
     139 
     140                def subjectDB = Subject.findByName(testSubjectName) 
     141                assert subjectDB 
     142 
     143                assert subjectDB.getFieldValue('name').equals(testSubjectName) 
     144                assert subjectDB.getFieldValue('species') == Term.findByName(testSubjectSpeciesTerm) 
     145        } 
     146 
     147        /** 
     148         * Test setFieldValue() for template fields 
     149         */ 
     150        void testTemplateFieldSetters() { 
     151 
     152                def subject = Subject.findByName(testSubjectName) 
     153                assert subject 
    78154 
    79155                // Assign a template field using setFieldValue: BMI 
     
    86162                assert subject.save(flush: true) 
    87163 
    88                 // Try to retrieve the subject and make sure it's the same 
     164 
     165        } 
     166 
     167        /** 
     168        * Test getFieldValue() for template fields 
     169        */ 
     170        void testTemplateFieldGetters() { 
     171 
     172                // Try to retrieve the subject and make sure the BMI was stored 
    89173                def subjectDB = Subject.findByName(testSubjectName) 
    90174                assert subjectDB 
    91                 assert subjectDB.name.equals(testSubjectName) 
    92                 assert subjectDB.template.name.equals(humanTemplate.name) 
    93                 assert subjectDB.species.name.equals(humanTerm.name) 
     175                assert subjectDB.getFieldValue(testSubjectBMITemplateFieldName) == testSubjectBMI 
     176        } 
     177 
     178        /** 
     179         * Test giveFields(): should return name, species and template fields 
     180         */ 
     181        void testGiveFields() { 
     182 
     183                def subject = Subject.findByName(testSubjectName) 
     184                assert subject 
    94185 
    95186                // Test giveFields 
    96                 def fields = subjectDB.giveFields() 
     187                def fields = subject.giveFields() 
    97188                def i = 0 
    98189                assert fields[i++].name == 'name' 
    99190                assert fields[i++].name == 'species' 
     191 
     192                // Look up human template 
     193                def humanTemplate = Template.findByName(testSubjectTemplateName) 
     194                assert humanTemplate 
     195 
    100196                humanTemplate.fields.each { 
    101197                        assert fields[i++].name.equals(it.name) 
    102198                } 
    103199 
    104                 // Test getFieldValue 
    105                 assert subjectDB.getFieldValue('name').equals(testSubjectName) 
    106                 assert subjectDB.getFieldValue('species') == humanTerm 
    107                 assert subjectDB.getFieldValue(testSubjectBMITemplateFieldName) == testSubjectBMI 
    108  
     200        } 
     201 
     202        protected void tearDown() { 
     203                super.tearDown() 
    109204        } 
    110205