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

package gscf

import dbnp.studycapturing.Study
import dbnp.studycapturing.Template
import grails.test.GrailsUnitTestCase
import dbnp.studycapturing.SamplingEvent
import dbnp.studycapturing.Sample
import dbnp.studycapturing.TemplateFieldType
import dbnp.studycapturing.Subject
import dbnp.studycapturing.EventGroup

/**
 * Test the creation of a Sample and its TemplateEntity functionality on data model level
 *
 * @author keesvb
 * @since 20100511
 * @package dbnp.studycapturing
 *
 * Revision information:
 * $Rev: 817 $
 * $Author: keesvb $
 * $Date: 2010-08-17 12:42:54 +0000 (di, 17 aug 2010) $
 */

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 @XYZ!"
        final String testSampleTemplateName = "Human blood sample"

        final String testSamplingEventName = "Test sampling event"
        final String testSamplingEventTemplateName = "Blood extraction"
        final long testSamplingEventTime = 34534534L
        final long testSamplingEventDuration = 1000L
        final String testEventGroupName = "Test Group"


        protected void setUp() {
                super.setUp()

                // Retrieve the study that should have been created in StudyTests
                def study = Study.findByTitle(testStudyName)
                assert study

                // Look up sampling event template
                def samplingEventTemplate = Template.findByName(testSamplingEventTemplateName)
                assert samplingEventTemplate

                // Look up sample template
                def sampleTemplate = Template.findByName(testSampleTemplateName)
                assert sampleTemplate

                // Create parent sampling event
                def samplingEvent = new SamplingEvent(
                        startTime: testSamplingEventTime,
                        duration: testSamplingEventDuration,
                        template: samplingEventTemplate,
                        sampleTemplate: sampleTemplate
                )

                // The SamplingEvent should not validate at this point because it doesn't have a parent study
                assert !samplingEvent.validate()

                study.addToSamplingEvents(samplingEvent)
                // It should do fine now
                assert samplingEvent.validate()
                assert samplingEvent.save(flush:true)

                // 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 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)

                println "The sample has parentEvent ${sampleDB.parentEvent.encodeAsHTML()}"
                // 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 testDelete() {
                def sampleDB = Sample.findByName(testSampleName)
                sampleDB.delete()
                try {
                        sampleDB.save()
                        assert false // The save should not succeed since the sample is referenced by a study
                }
                catch(org.springframework.dao.InvalidDataAccessApiUsageException e) {
                        sampleDB.discard()
                        assert true // OK, correct exception (at least for the in-mem db, for PostgreSQL it's probably a different one...)
                }

                // Now, delete the sample from the study samples collection, and then the delete action should be cascaded to the sample itself
                def study = Study.findByTitle(testStudyName)
                assert study
                study.removeFromSamples sampleDB

                // Make sure the sample doesn't exist anymore at this point
                assert !Sample.findByName(testSampleName)
                assert Sample.count() == 0
                assert study.samples.size() == 0
        }

        void testDeleteViaParentSubject() {

                def sampleDB = Sample.findByName(testSampleName)
                assert sampleDB

                // Retrieve the parent study
                def study = Study.findByTitle(testStudyName)
                assert study

                def subject = SubjectTests.createSubject(study)
                assert subject

                sampleDB.parentSubject = subject
                assert sampleDB.validate()
                assert sampleDB.save()

                // Use the deleteSubject method
                def msg = study.deleteSubject(subject)
                println msg
                assert study.save()

                assert !study.subjects.contains(subject)

                assert !Subject.findByName(subject.name)
                assert !Sample.findByName(testSampleName)

                assert Subject.count() == 0
                assert Sample.count() == 0

        }

        void testDeleteViaParentSamplingEvent() {

                def sampleDB = Sample.findByName(testSampleName)
                assert sampleDB

                // Retrieve the parent study
                def study = Study.findByTitle(testStudyName)
                assert study

                def event = sampleDB.parentEvent
                assert event

                // Use the deleteSamplingEvent method
                def msg = study.deleteSamplingEvent(event)
                println msg
                assert study.save()

                assert !study.samplingEvents.contains(event)

                assert !SamplingEvent.findByStartTime(testSamplingEventTime)
                assert !Sample.findByName(testSampleName)

                assert SamplingEvent.count() == 0
                assert Sample.count() == 0

        }

        void testDeleteViaParentEventGroup() {

                def sampleDB = Sample.findByName(testSampleName)
                assert sampleDB

                // Retrieve the parent study
                def study = Study.findByTitle(testStudyName)
                assert study

                // Retrieve the sample's sampling event
                def event = sampleDB.parentEvent
                assert event

                // Create a subject and add it at the sample's parent
                def subject = SubjectTests.createSubject(study)
                assert subject
                sampleDB.parentSubject = subject
                assert sampleDB.validate()
                assert sampleDB.save()

                // Create an event group in this study with the sample's sampling event
                def group = new EventGroup(
                    name: testEventGroupName
                )
                study.addToEventGroups(group)
                assert group.validate()


                group.addToSubjects(subject)
                group.addToSamplingEvents(event)
                assert study.eventGroups.find { it.name == group.name}
                assert group.validate()
                assert study.save()

                // Use the deleteSamplingEvent method
                def msg = study.deleteEventGroup(group)
                println msg
                assert study.save()

                assert !study.eventGroups.contains(group)
                assert !EventGroup.findByName(testEventGroupName)
                assert !Sample.findByName(testSampleName)

                assert EventGroup.count() == 0
                assert Sample.count() == 0

        }

        void testStudyRelation() {
                // Retrieve the parent study
                def study = Study.findByTitle(testStudyName)
                assert study

                // Test giveSampleTemplates
                def templates = study.giveSampleTemplates()
                assert templates
                assert templates.size() == 1
                assert templates.asList().first().name == testSampleTemplateName

                // Test if the sample is in the samples collection
                assert study.samples
                assert study.samples.size() == 1
                assert study.samples.first().name == testSampleName
        }


        void testParentStudy() {
                def sample = Sample.findByName(testSampleName)
                assert sample

                assert sample.parent
                assert sample.parent.code == testStudyCode
        }

        void testSampleUniqueNameConstraint() {
                def sample = Sample.findByName(testSampleName)
                assert sample

                def study = sample.parent
                assert study

                def sample2 = new Sample(
                    name: testSampleName,
                    template: sample.template,
                    parentEvent: sample.parentEvent
                )

                // Add the sample to the retrieved parent study
                study.addToSamples(sample2)

                // At this point, the sample should not validate or save, because there is already a sample with that name in the study
                assert !sample2.validate()
                assert !sample2.save(flush:true)

        }

        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 sample = Sample.findByName(testSampleName)
                assert sample

                // Make sure the domain fields exist
                assert sample.fieldExists('name')
                assert sample.fieldExists('material')

                // Make sure they are domain fields
                assert sample.isDomainField('name')
                assert sample.isDomainField('material')

                // Make sure that they have the right type
                assert sample.giveFieldType('name') == TemplateFieldType.STRING
                assert sample.giveFieldType('material') == TemplateFieldType.ONTOLOGYTERM

        }

        protected void tearDown() {
                super.tearDown()
        }

}