caruby-tissue 1.5.6 → 2.1.1

data/test/fixtures/lib/catissue/defaults_test_fixture.rb

@@ -1,206 +0,0 @@
-require 'singleton'
-require 'caruby/util/validation'
-require 'caruby/util/uniquifier'
-require 'catissue'
-
-module CaTissueTest
-  # Error setting up the test fixture.
-  class TestError < RuntimeError; end
-
-  def self.defaults
-    Defaults.instance
-  end
-
-  # caTissue test default admin fixture.
-  class Defaults
-    include Singleton, Enumerable
-
-    attr_reader :tissue_bank, :protocol, :registration, :specimen,
-      :specimen_requirement, :specimen_collection_group, :box
-    
-    def initialize
-      super
-      populate
-    end
-    
-    # Retusns this fixture's domain objects.
-    def domain_objects
-      instance_variables.map { |iv| instance_eval iv }.select { |value| CaRuby::Resource === value }
-    end
-
-    # Adds default values to this fixture's domain objects.
-    def add_defaults
-      domain_objects.each { |obj| obj.add_defaults unless obj.equal?(specimen) }
-      # Add specimen default values last, since SCG add_specimens propagates the collection event
-      # necessary to set the default specimen label.
-      specimen.add_defaults
-      self
-    end
-
-    # Fetches the default instances from the database. Creates new objects if necesssary.
-    #
-    # @raise [ValidationError] if a domain object fails validation
-    def validate
-      # identifiers are required for validation; these are removed following validation
-      objs_without_ids = domain_objects.select { |obj| obj.identifier.nil? }
-      objs_without_ids.each_with_index { |obj, index| obj.identifier = index + 1 }
-      domain_objects.each { |obj| obj.validate }
-      # restore null identifiers
-      objs_without_ids.each { |obj| obj.identifier = nil }
-      self
-    end
-
-    # Creates this fixture's {#domain_objects} in the database, if necessary.
-    def ensure_exists
-      domain_objects.each { |obj| obj.find(:create) unless obj.identifier or obj.class.dependent? }
-    end
-
-    # Repopulates the defaults and makes the following attributes unique:
-    # * collection_protocol short title
-    # * participant MRN
-    # * specimen label
-    #
-    # @return this fixture
-    def uniquify
-      populate
-      # make the CP and MRN unique; these values will ripple through the SCG, CPR, et al.
-      # to make them unique as well
-      @protocol.title = @protocol.title.uniquify
-      @registration.participant.medical_identifiers.each { |mid| mid.medical_record_number = Uniquifier.qualifier }
-      # unset the SCG name and specimen label so the default is set to a new unique value
-      @specimen_collection_group.name = @specimen.label = nil
-      self
-    end
-    
-    private
-
-    # Adds data to this fixture.
-    #
-    # @return this fixture
-    def populate
-      logger.debug { "Populating the test fixture..." }
- 
-      # the test institution
-      inst = CaTissue::Institution.new(:name => 'Test Institution')
-
-      # the standard test address
-      addr = CaTissue::Address.new
-      addr.city = 'Test City'
-      addr.state = 'Other'
-      addr.country = 'Niue'
-      addr.zipCode = '55555'
-      addr.street = '555 Test St'
-      addr.phoneNumber = '555-555-5555'
-
-      # the test department
-      dept = CaTissue::Department.new(:name => 'Test Department')
-
-      # the test cancer center
-      cc = CaTissue::CancerResearchGroup.new(:name => 'Test Cancer Center')
-
-      # the test tissue bank coordinator
-      coord = CaTissue::User.new
-      coord.loginName = coord.emailAddress = 'test_coordinator@example.edu'
-      coord.lastName = 'Coordinator'
-      coord.firstName = 'Test'
-      coord.address = addr.copy
-      coord.institution = inst
-      coord.department = dept
-      coord.cancer_research_group = cc
-      coord.add_defaults
-
-      # the test surgeon
-      surgeon = CaTissue::User.new
-      surgeon.loginName = surgeon.emailAddress = 'test_surgeon@example.edu'
-      surgeon.lastName = 'Scientist'
-      surgeon.firstName = 'Test'
-      surgeon.address = addr.copy
-      surgeon.institution = inst
-      surgeon.department = dept
-      surgeon.cancer_research_group = cc
-
-      # the test PI
-      pi = CaTissue::User.new
-      pi.loginName = pi.emailAddress = 'test_scientist@example.edu'
-      pi.lastName = 'Scientist'
-      pi.firstName = 'Test'
-      pi.address = addr.copy
-      pi.institution = inst
-      pi.department = dept
-      pi.cancer_research_group = cc
-
-      # the test hospital
-      hospital = CaTissue::Site.new(
-        :site_type => CaTissue::Site::SiteType::COLLECTION,
-        :name => 'Test Collection Site',
-        :address => addr.copy,
-        :coordinator => coord
-      )
-
-      # the test tissue bank
-      @tissue_bank = CaTissue::Site.new(
-        :site_type => CaTissue::Site::SiteType::REPOSITORY,
-        :name => 'Test Tissue Bank',
-        :address => addr.copy,
-        :coordinator => coord
-      )
-      
-      # the test participant
-      pnt = CaTissue::Participant.new(:name => 'Test Participant')
-
-      # add the participant mrn
-      mrn = 555555
-      pnt.add_mrn(hospital, mrn)
-
-      # the test collection protocol
-      @protocol = CaTissue::CollectionProtocol.new(
-        :title => 'Test CP',
-        :principal_investigator => pi
-      )
-
-      # the test consent tier
-      ctier = CaTissue::ConsentTier.new(:statement => 'Test Consent Statement')
-      @protocol.consent_tiers << ctier
-
-      # the collection event template
-      cpe = CaTissue::CollectionProtocolEvent.new(:protocol => @protocol)
-
-      # the participant collection registration
-      @registration = @protocol.register(pnt)
-      # add a consent tier response
-      rsp = CaTissue::ConsentTierResponse.new(:consent_tier => ctier)
-      @registration.consent_tier_responses << rsp
-
-      # the specimen requirement template
-      @specimen_requirement = CaTissue::TissueSpecimenRequirement.new(
-        :collection_event => cpe,
-        :specimen_type => 'Frozen Tissue',
-        :specimen_characteristics => CaTissue::SpecimenCharacteristics.new,
-        :pathological_status => 'Malignant')
-
-      # the sole tissue specimen
-      @specimen = CaTissue::Specimen.create_specimen(:requirement => @specimen_requirement, :initial_quantity => 4.0)
-
-      # the SCG
-      @specimen_collection_group = @protocol.add_specimens(
-        @specimen,
-        :participant => pnt,
-        :collection_event => cpe,
-        :collection_site => hospital,
-        :receiver => coord)
-
-      # a storage container
-      frz_type = CaTissue::StorageType.new(:name => 'Test Freezer', :columns => 10, :rows => 1, :row_label => 'Rack')
-      rack_type = CaTissue::StorageType.new(:name => 'Test Rack', :columns => 10, :rows => 10)
-      box_type = CaTissue::StorageType.new(:name => 'Test Box', :columns => 10, :rows => 10)
-      frz_type << rack_type
-      rack_type << box_type
-      box_type << 'Tissue'
-      # a sample freezer box
-      @box = CaTissue::StorageContainer.new(:storage_type => box_type, :site => @tissue_bank)
-
-      logger.debug { "Test fixture populated." }
-      self
-    end
-  end
-end

data/test/fixtures/lib/examples/galena/migration/alt_key_shims.rb

@@ -1,7 +0,0 @@
-module CaTissue
-  shims Participant
-  
-  class Participant
-    set_secondary_key_attributes(:first_name, :last_name)
-  end
-end

data/test/lib/catissue/domain/base_haemotology_pathology_test.rb

@@ -1,24 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', 'test_case')
-
-class BaseHaematologyPathologyTest < Test::Unit::TestCase
-  include CaTissue::TestCase
-
-  def setup
-    super
-    @scg = defaults.specimen_collection_group
-    @ann = CaTissue::SpecimenCollectionGroup::Pathology::BaseHaematologyPathologyAnnotation.new(:specimen_collection_group => @scg)
-    @hist = CaTissue::SpecimenCollectionGroup::Pathology::HistologicType.new(:base_pathology_annotation => @ann, :histologic_type => 'Adenocarcinoma - NOS')
-    @fnd = CaTissue::SpecimenCollectionGroup::Pathology::AdditionalFinding.new(:base_pathology_annotation => @ann, :pathologic_finding => 'Test finding')
-    @dtl = CaTissue::SpecimenCollectionGroup::Pathology::Details.new(:additional_finding => @fnd, :detail => 'Test detail')
-  end
-
-  def test_dependents
-    assert_equal([@hist], @ann.histologic_types.to_a, "Annotation histologic types incorrect")
-    assert_equal([@fnd], @ann.additional_findings.to_a, "Annotation additional findings incorrect")
-    assert_equal([@dtl], @fnd.details.to_a, "Finding details incorrect")
-  end
-
-  def test_save
-    verify_save(@ann)
-  end
-end

data/test/lib/catissue/extract/delta_test.rb

@@ -1,25 +0,0 @@
-require 'date'
-require File.join(File.dirname(__FILE__), '..', 'test_case')
-require 'catissue/extract/delta'
-
-class DeltaTest < Test::Unit::TestCase
-  include CaTissue::TestCase
-
-  def test_specimen
-    since = DateTime.now
-    spc = defaults.specimen.create
-    ids = CaTissue::Delta.new(spc.class, since).to_a
-    assert(!ids.empty?, "Delta is empty")
-    assert_equal(1, ids.size, "Delta count incorrect")
-    assert_equal(spc.identifier, ids.first, "Delta value incorrect")
-  end
-
-  def test_scg
-    since = DateTime.now
-    scg = defaults.specimen_collection_group.create
-    ids = CaTissue::Delta.new(scg.class, since).to_a
-    assert(!ids.empty?, "Delta is empty")
-    assert_equal(1, ids.size, "Delta count incorrect")
-    assert_equal(scg.identifier, ids.first, "Delta value incorrect")
-  end
-end

data/test/lib/catissue/extract/extractor_test.rb

@@ -1,43 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', 'test_case')
-require 'catissue/extract/extractor'
-
-class ExtractorTest < Test::Unit::TestCase
-  include CaTissue::TestCase
-
-  CONFIG_DIR = File.join('test', 'fixtures', 'catissue', 'extract', 'conf')
-
-  def test_specimen_write
-    config = File.join(CONFIG_DIR, 'spc_extract.yaml')
-    spc = defaults.specimen.create
-    extractor = CaTissue::Extractor.new(:file => config, :ids => [spc.identifier])
-    extractor.run
-    mapping = File.join(CONFIG_DIR, 'spc_fields.yaml')
-    mapper = CaRuby::CsvMapper.new(mapping, spc.class, extractor.output)
-    rec = mapper.csvio.to_a.first
-    assert_not_nil(rec, "Specimen record not written")
-    mrn = spc.path_value("specimen_collection_group.registration.participant_identifier")
-    assert_equal(mrn.to_s, rec[:mrn].to_s, "Specimen MRN incorrect")
-    spn = spc.path_value("specimen_collection_group.surgical_pathology_number")
-    assert_equal(spn.to_s, rec[:spn].to_s, "Specimen SPN incorrect")
-    date = spc.path_value("specimen_collection_group.collection_event_parameters.timestamp")
-    assert_equal(date.to_s, rec[:collection_date].to_s, "Specimen collection date incorrect")
-    assert_equal(spc.initial_quantity.to_s, rec[:quantity].to_s, "Quantity incorrect")
-  end
-
-  def test_scg_write
-    config = File.join(CONFIG_DIR, 'scg_extract.yaml')
-    scg = defaults.specimen_collection_group.create
-    extractor = CaTissue::Extractor.new(:file => config, :ids => [scg.identifier])
-    extractor.run
-    mapping = File.join(CONFIG_DIR, 'scg_fields.yaml')
-    mapper = CaRuby::CsvMapper.new(mapping, scg.class, extractor.output)
-    rec = mapper.csvio.to_a.first
-    assert_not_nil(rec, "SCG record not written")
-    mrn = scg.path_value("registration.participant_identifier")
-    assert_equal(mrn.to_s, rec[:mrn].to_s, "SCG MRN incorrect")
-    spn = scg.path_value("surgical_pathology_number")
-    assert_equal(spn.to_s, rec[:spn].to_s, "SCG SPN incorrect")
-    date = scg.path_value("collection_event_parameters.timestamp")
-    assert_equal(date.to_s, rec[:collection_date].to_s, "SCG collection date incorrect")
-  end
-end

data/test/lib/catissue/import/importable_module_test.rb

@@ -1,14 +0,0 @@
-$:.unshift 'lib'
-$:.unshift '../caruby/lib'
-
-require "test/unit"
-
-require 'catissue'
-
-class ImportableTest < Test::Unit::TestCase
-  LOG_FILE = 'test/results/catissue/import/log/catissue.log'
-
-  def test_import
-    assert_nothing_raised(Exception, 'Java class not imported') { CaTissue::CollectionProtocol }
-  end
-end

data/test/lib/catissue/test_case.rb

@@ -1,247 +0,0 @@
-# load the core gem
-require 'rubygems'
-begin
-  gem 'caruby-core'
-rescue LoadError
-  # if the gem is not available, then try a local development source
-  $:.unshift  '../caruby/lib'
-end
-
-# open the logger
-LOG_FILE = 'test/results/log/catissue.log' unless defined?(LOG_FILE)
-require 'caruby/util/log' and
-  CaRuby::Log.instance.open(LOG_FILE, :shift_age => 10, :shift_size => 1048576, :debug => true)
-  
-# Add the caruby-tissue source
-$:.unshift '../catissue/lib'
-
-require 'catissue'
-require '../catissue/test/fixtures/lib/catissue/defaults_test_fixture'
-
-module CaTissue
-  module TestCase
-    attr_reader :database
-
-    def setup
-      super()
-      logger.info("Testing #{name}...")
-      @database = CaTissue::Database.instance
-    end
-
-    def teardown
-      super
-      @database.close if @database
-      logger.info("Test #{name} completed.")
-    end
-    
-    def defaults
-      @defaults ||= CaTissueTest.defaults.uniquify
-    end
-    
-    # Tests the domain object +add_defaults_local+ method.
-    # Subclasses are responsible for setting every attribute that is a pre-condition for default value initialization.
-    def verify_defaults(subject)
-      subject.add_defaults
-      msg = "#{subject.qp} with default attributes fails validation"
-      assert_nothing_raised(ValidationError, msg) { subject.validate }
-    end
-
-    # Tests saving the subject. Calls {Database#save} on the subject and verifies that subject and its
-    # references were persisted.
-    #
-    # @param [Resource] subject the object to save
-    def verify_save(subject)
-      logger.debug{ "Verifying #{subject.qp} save with content:\n#{dump(subject)}" }
-      # capture the save operation time
-      @database.clear
-      st = Stopwatch.measure { @database.open { |db| db.save(subject) } }.elapsed
-      # the database execution time
-      dt = @database.execution_time
-      logger.debug { "#{subject.qp} save took #{'%.2f' % st} seconds, of which #{'%.2f' % dt} were database operations." }
-      verify_saved(subject)
-    end
-
-    # Verifies that the given subject and its references were persisted.
-    #
-    # @param [Resource] subject the saved object to verify
-    def verify_saved(subject)
-      logger.debug { "Verifying saved content of #{subject}..." }
-      subject.dependent? ? verify_saved_dependent(subject) : verify_saved_independent(subject)
-      logger.debug { "Verified saved content of #{subject}." }
-    end
-    
-    # Tests a query on the given template.
-    # The block given to this method is called on the query result.
-    def verify_query(template, *path) # :yields: result
-      yield database.query(template, *path)
-    end
-
-    # Returns the Ruby date as determined by setting a Java Date property.
-    def date(year, month, day)
-      jdate = java.util.Calendar.instance
-      jdate.clear
-      jdate.set(year, month - 1, day)
-      jdate.time.to_ruby_date
-    end
-
-    private
-    
-    def dump(obj)
-      @database.lazy_loader.suspend { obj.dump }
-    end
-  
-    # @param (see #mock_storable_template)
-    # @return (see #mock_storable_template)
-    def mock_create_template(obj)
-      mock_storable_template(obj) { |ref| ref.class.creatable_domain_attributes }
-    end
-  
-    # @param (see #mock_storable_template)
-    # @return (see #mock_storable_template)
-    def mock_update_template(obj)
-      mock_storable_template(obj) { |ref| ref.class.updatable_domain_attributes }
-    end
-    
-    # @param [Resource] obj the domain object to "save"
-    # @return [Resource] the template to use in the save operation
-    # @yield [ref] the storable attributes
-    # @yieldparam [Resource] ref the domain object to "save"
-    def mock_storable_template(obj, &selector)
-      # add fake identifiers to prerequisite references
-      obj.class.storable_prerequisite_attributes.each do |attr|
-        obj.send(attr).enumerate { |ref| ref.identifier = 1 }
-      end
-      # the template builder
-      bldr = CaRuby::StoreTemplateBuilder.new(@database, &selector)
-      # the save template
-      bldr.build_template(obj)
-    end
-
-    def verify_saved_dependent(dependent)
-      verify_dependency(dependent)
-      verify_saved_content(dependent)
-    end
-    
-    def verify_dependency(dependent)
-      return if dependent.class.owner_attribute.nil?
-      # kludge for annotation proxy nonsense (cf. Annotation#owner)
-      ownr = Annotation === dependent ? (dependent.proxy or dependent.owner) : dependent.owner
-      assert_not_nil(ownr, "Owner missing for dependent: #{dependent}")
-      attribute = ownr.class.dependent_attribute(dependent.class)
-      assert_not_nil(attribute, "#{ownr.class.qp} => #{dependent.class.qp} reference attribute not found")
-      # a dependent collection reference must be refetched
-      if ownr.class.collection_attribute?(attribute) then
-        verify_saved_dependent_collection_member(dependent, ownr, attribute)
-      else
-        assert_not_nil(dependent.identifier, "Stored dependent #{dependent} identifier is not set")
-      end
-    end
-
-    # Verifies that the given dependent has an identifier and that the given owner dependent attribute value
-    # contains the dependent.
-    #
-    # @quirk JRuby Set include? incorrectly returns false in the OHSU PSR samples_test test_save_grade
-    #   call to this method. Work around by using Set detect rather than include?.
-    def verify_saved_dependent_collection_member(dependent, owner, attribute)
-      deps = owner.send(attribute)
-      assert(deps.detect { |dep| dep == dependent }, "Owner #{owner.qp} #{attribute} value #{deps.pp_s} does not contain #{dependent}")
-      assert_not_nil(dependent.identifier, "Identifier not set for stored owner #{owner.qp} #{attribute} dependent collection member #{dependent}")
-    end
-
-    # Verifies the subject stored content.
-    def verify_saved_independent(subject)
-      subject_id = subject.identifier
-      assert_not_nil(subject_id, "#{subject.class.qp} identifier not set")
-      verify_saved_content(subject)
-    end
-
-    # Verifies that the given subject matches the database content. Does not verify subject unless it has
-    # a secondary key.
-    def verify_saved_content(subject)
-      attrs = subject.class.secondary_key_attributes
-      return if attrs.empty?
-      rqd = attrs & subject.class.mandatory_attributes
-      missing = rqd.reject { |attr| subject.send(attr) }
-      assert(missing.empty?, "#{subject} is missing values for required secondary key attributes #{missing.to_series}")
-      # make a secondary key search template
-      vh = attrs.to_compact_hash do |attr|
-         v = subject.send(attr)
-         Resource === v ? v.copy : v
-      end
-      # return if there is a missing optional secondary key attribute
-      return unless vh.size == attrs.size
-      tmpl = subject.class.new(vh)
-      # find the template in the database
-      logger.debug  { "Verifying #{subject.qp} by finding and comparing template #{tmpl.pp_s}..." }
-      assert_not_nil(tmpl.find, "#{subject} not found in database")
-      # compare the subject to the fetched template
-      verify_that_saved_matches_fetched(subject, tmpl)
-    end
-
-    # Verifies that the given expected domain object has the same content as actual,
-    # and that the dependents match.
-    #
-    # @quirk caTissue caTissue mutilates an unspecified specimen type available quantity, e.g.
-    #   changing a Specimen with specimen type 'Not Specified' from available quantity 1, initial
-    #   quantity 1 to available quantity 0, initial quantity 3 results in available quantity 2
-    #   in database. The update is necessary when creating the Specimen with available quantity 0,
-    #   initial quantity 3 to work around a different caTissue bug. Thus, the bug work-around
-    #   is broken by a different caTissue bug.
-    #
-    # @param [Resource] expected the saved value
-    # @param [Resource] actual the fetched value
-    def verify_that_saved_matches_fetched(expected, actual)
-      expected.class.saved_nondomain_attributes.each do |attr|
-        # available_quantity broken for spc type Not Specified; see quirk above.
-        # TODO - Compare attributes that are fetched and set on create.
-        attr_md = expected.class.attribute_metadata(attr)
-        if verify_saved_attribute?(attr_md) then
-          eval = expected.database.lazy_loader.suspend { expected.send(attr) }
-          next if eval.nil_or_empty?
-          aval = actual.send(attr)
-          if eval.nil? then
-            assert_nil(aval, "#{expected.qp} was saved without a #{attr} value, but was stored in the database with value #{actual.qp}")
-          else
-            assert_not_nil(aval, "#{expected.qp} was saved with #{attr} value #{eval.qp}, but this value was not found in the database.")
-            if attr == :available_quantity and expected.specimen_type == 'Not Specified' and eval != aval then
-              logger.warn("Skipped broken caTissue unspecified specimen type available comparison.")
-            else
-              assert(CaRuby::Resource.value_equal?(eval, aval), "#{expected.qp} was saved with #{attr} value #{eval.qp} that does not match the database value #{aval.qp}")
-            end
-          end
-        end
-      end
-      verify_dependents_match(expected, actual)
-    end
-    
-    # @param [Attribute] attr_md the saved attribute to check
-    # @return whether the attribute is fetched, creatable and not volatile
-    def verify_saved_attribute?(attr_md)
-      attr_md.fetched? and attr_md.creatable? and not attr_md.volatile?
-    end
-
-    # Verifies that each expected dependent matches an actual dependent and has the same content.
-    def verify_dependents_match(expected, actual)
-      expected.class.dependent_attributes.each_pair do |attr, attr_md|
-        # annotation query not supported
-        # TODO - enable when supported
-        next if attr_md.type < Annotation
-        edeps = expected.database.lazy_loader.suspend { expected.send(attr) }
-        next if edeps.nil_or_empty?
-        adeps = actual.send(attr)
-        logger.debug { "Verifying #{expected.qp} dependent #{attr} #{edeps.qp} against #{actual.qp} #{adeps.qp}..." } unless edeps.nil_or_empty?
-        if attr_md.collection? then
-          edeps.each do |edep|
-            adep = edep.match_in_owner_scope(adeps)
-            assert_not_nil(adep, "#{expected} #{attr} dependent #{edep} not found in fetched #{adeps.pp_s}")
-            verify_that_saved_matches_fetched(edep, adep)
-          end
-        else
-          edep = edeps; adep = adeps;
-          assert_not_nil(adep, "#{expected} #{attr} dependent #{edep} not found in database")
-          verify_that_saved_matches_fetched(edep, adep)
-        end
-      end
-    end
-  end
-end