caruby-tissue 1.3.1 → 1.3.2

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

@@ -0,0 +1,70 @@
+require File.join(File.dirname(__FILE__), '..', 'test_case')
+require 'caruby/util/uniquifier'
+require 'test/fixtures/lib/catissue/defaults_test_fixture'
+
+class StorageTypeTest < Test::Unit::TestCase
+  include CaTissue::TestCase
+
+  def setup
+    super
+    @spc = defaults.specimen
+    @frz_type = CaTissue::StorageType.new(:name => 'Freezer'.uniquify, :columns => 5, :rows => 5)
+    @rack_type = CaTissue::StorageType.new(:name => 'Rack'.uniquify, :columns => 1, :rows => 1)
+    @box_type = CaTissue::StorageType.new(:name => 'Box'.uniquify, :columns => 1, :rows => 1)
+    @array_type = CaTissue::SpecimenArrayType.new(:name => 'SpecimenArray'.uniquify,
+      :specimen_class => @spc.specimen_class, :specimen_types => [@spc.specimen_type],
+      :columns => 5, :rows => 5)
+    @frz_type << @rack_type
+    @rack_type << @box_type
+    @box_type << @array_type << @spc.specimen_class
+  end
+
+  def test_defaults
+    verify_defaults(@frz_type)
+  end
+
+  def test_create_container
+    frz = @frz_type.create_container
+    assert_same(CaTissue::StorageContainer, frz.class, "Created instance class incorrect")
+    assert_same(@frz_type, frz.container_type, "Created container type incorrect")
+  end
+
+  def test_can_hold
+    assert(@frz_type.can_hold_child?(@rack_type.create_container), "Freezer can't hold a rack")
+    assert(@rack_type.can_hold_child?(@box_type.create_container), "Rack can't hold a box")
+    assert(@box_type.can_hold_child?(@array_type.create_container), "Box can't hold an array")
+    assert(@array_type.can_hold_child?(@spc), "Array can't hold the specimen")
+    assert(@box_type.can_hold_child?(@spc), "Box can't hold the specimen")
+  end
+
+  def test_comparison
+    assert_equal(@frz_type, @frz_type, "Same not equal")
+    assert_equal(@frz_type, @frz_type.copy(:name), "Name not used in equality")
+    assert(@rack_type < @frz_type, "Rack type not < freezer type")
+    assert(@frz_type > @rack_type, "Freezer type not > rack type")
+    assert(@box_type < @rack_type, "Box type not < rack type")
+  end
+  
+  def test_closure
+    assert_equal([@frz_type, @rack_type, @box_type], @frz_type.closure,  "Freezer type closure incorrect")
+  end
+
+  def test_path_to
+    assert_equal([@frz_type, @rack_type, @box_type], @frz_type.path_to(@spc), "Freezer path to specimen incorrect")
+  end
+  
+  ## DATABASE TESTS ##
+
+  def test_save
+    verify_save(@box_type)
+    assert(@box_type.find_containers.empty?, "Box incorrectly found")
+    site = defaults.tissue_bank
+    box = @box_type.find_available(site)
+    assert_nil(box, "Available box incorrectly created")
+    box = @box_type.find_available(site, :create)
+    assert_not_nil(box, "Available box not created")
+    assert_not_nil(box.identifier, "Available box missing identifier")
+    stored = @box_type.find_containers.map { |ctr| ctr.identifier}
+    assert_equal([box.identifier], stored, "Box with identifier #{box.identifier} not found")
+  end
+end

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

@@ -0,0 +1,38 @@
+require File.join(File.dirname(__FILE__), '..', 'test_case')
+require 'test/fixtures/lib/catissue/defaults_test_fixture'
+require 'caruby/database/store_template_builder'
+
+class TransferEventParametersTest < Test::Unit::TestCase
+  include CaTissue::TestCase
+
+  def setup
+    super
+    spc = defaults.specimen
+    defaults.box << spc
+    @xfr = CaTissue::TransferEventParameters.new(:specimen => spc, :to => spc.location)
+  end
+
+#  def test_inverse_setter
+#    assert(@xfr.specimen.event_parameters.include?(@xfr), "EventParameters not found in specimen")
+#  end
+#
+#  def test_defaults
+#    verify_defaults(@xfr)
+#  end
+
+#  def test_save
+#    verify_save(@xfr)
+#    shift(@xfr)
+#    verify_save(@xfr)
+#  end
+
+  private
+
+  # Resets the given CaTissue::TransferEventParameters xfr so that +from+ is the
+  # old +to+, +to+ is the next location, and the identifier is cleared.
+  def shift(xfr)
+    xfr.from = xfr.to
+    xfr.to = xfr.from.succ
+    xfr.identifier = nil
+  end
+end

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

@@ -0,0 +1,50 @@
+require File.join(File.dirname(__FILE__), '..', 'test_case')
+require 'catissue/defaults_test_fixture'
+
+class UserTest < Test::Unit::TestCase
+  include CaTissue::TestCase
+
+  def setup
+    super
+    @user = defaults.tissue_bank.coordinator
+  end
+
+#  # Verifies the secondary key.
+#  def test_secondary_key
+#    assert_equal(@user.login_name, @user.key, 'Key incorrect')
+#  end
+#
+#  def test_defaults
+#    verify_defaults
+#  end
+#
+#  # Exercises setting the login name from the email address.
+#  def test_default_login_value
+#    @user.login_name = nil
+#    verify_defaults
+#  end
+#
+#  # Exercises setting the email address from the login name.
+#  def test_default_email_value
+#    @user.email_address = nil
+#    verify_defaults
+#  end
+#
+#  def verify_defaults
+#    @user.address.identifier = 1
+#    @user.cancer_research_group.identifier = 2
+#    @user.department.identifier = 3
+#    @user.institution.identifier = 4
+#    super(@user)
+#  end
+
+  # Tests creating a user.
+  def test_save
+    addr = @user.email_address
+    at_ndx = addr.index('@')
+    modifier = "_#{Uniquifier.qualifier.to_s}"
+    @user.email_address = addr.insert(at_ndx, modifier)
+    @user.login_name = nil
+    verify_save(@user)
+  end
+end

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

@@ -0,0 +1,25 @@
+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

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,14 @@
+$:.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/migration/test_case.rb

@@ -0,0 +1,103 @@
+LOG_FILE = 'test/results/log/migration.log'
+
+require File.join(File.dirname(__FILE__), '..', 'test_case')
+require 'caruby/domain/uniquify'
+require 'catissue/migration/migrator'
+
+module CaTissue
+  module MigrationTestCase
+    include CaTissue::TestCase
+
+    #@param [String] fixtures the fixtures directory
+    def setup(fixtures)
+      @fixtures = fixtures
+      # Clear the uniquifier for this migration.
+      CaRuby::ResourceUniquifier.instance.clear
+    end
+
+    ## MIGRATION TEST UTILITY METHODS ##
+
+    private
+
+    # Runs a migrator on the given input fixture and options.
+    #
+    # @param (see #create_migrator)
+    # @option (see #create_migrator)
+    def migrate_to_database(fixture, opts={}, &verifier)
+      mgtr = create_migrator(fixture, opts)
+      logger.debug { "Migration test migrating #{fixture} fixture..." }
+      mgtr.migrate_to_database(&verifier)
+      logger.debug { "Migration test migrated #{fixture} fixture." }
+    end
+
+    # Creates a new Migrator for the given fixture with the given options.
+    # If a factory block is provided, then that factory is called to make a new
+    # Migrator instance. Otherwise, {CaTissue::Migrator#initialize} makes the instance.
+    #
+    # If there is no :input option, then the migration input is set to the
+    # _fixture_.+csv+ file in the {#initialize} fixtures directory.
+    #
+    # @param [Symbol] fixture the migration test fixture
+    # @param [{Symbol => Object}] opts (see CaTissue::Migrator#initialize)
+    # @option (see CaTissue::Migrator#initialize)
+    # @return [CaTissue::Migrator]
+    # @yield [opts] the optional Migrator factory
+    def create_migrator(fixture, opts={}, &factory)
+      opts[:quiet] = true
+      opts[:input] ||= File.join(@fixtures, fixture.to_s + '.csv')
+      block_given? ? yield(opts) : CaTissue::Migrator.new(opts)
+    end
+
+    # Verifies that the given test fixture is successfully migrated.
+    # Each migrated target object is validated using {CaTissue::TestCase#verify_saved}.
+    # In addition, if a verifier block is given to this method, then that block is
+    # called on the target migration object, or nil if no target was migrated.
+    # Supported options are described in {CaTissue::Migrator#migrate}.
+    #
+    # @param (see #verify_target)
+    # @option (see #verify_target)
+    # @yield (see #verify_target)
+    # @yieldparam (see #verify_target)
+    def verify_save(fixture, opts={})
+      logger.debug { "Migrating the #{fixture} test fixture..." }
+      opts[:unique] = true unless opts.has_key?(:unique)
+      opts[:controlled_values] = true unless opts.has_key?(:controlled_values)
+      migrate_to_database(fixture, opts) do |tgt|
+        verify_saved(tgt)
+        yield tgt if block_given?
+      end
+    end
+
+    # Verifies the given fixture migration.
+    # Each migrated target object is validated using {#validate_target}.
+    # The target is migrated but not stored.
+    #
+    # @param [Symbol] fixture the test fixture to verify
+    # @param [<Symbol>] opts the migration options
+    # @option (see CaTissue::Migrator#migrate)
+    # @yield [target] verifies the given target
+    # @yieldparam [Resource] target the domain object to verify
+    def verify_target(fixture, opts={}, &verifier)
+      opts[:unique] ||= false
+      create_migrator(fixture, opts).migrate { |tgt| validate_target(tgt, &verifier) }
+    end
+
+    # Validates that the given target was successfully migrated.
+    # If a target was migrated, then this method calls {CaTissue::TestCase#verify_defaults}
+    # to confirm that the target can be stored.
+    # In addition, if a block is given to this method then the block is called on the
+    # (possibly nil) migration target.
+    #
+    # @param [Resource] target the domain object to verify
+    # @yield (see #verify_target)
+    # @yieldparam (see #verify_target)
+    def validate_target(target)
+      assert_not_nil(target, "Missing target")
+      logger.debug { "Validating migration target #{target}..." }
+      verify_defaults(target) if target
+      yield target if block_given?
+      logger.debug { "Validated migration target #{target}." }
+      target
+    end
+  end
+end

data/test/lib/catissue/test_case.rb

@@ -0,0 +1,225 @@
+# 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?
+      owner = dependent.owner
+      assert_not_nil(owner, "Owner missing for dependent: #{dependent}")
+      attribute = owner.class.dependent_attribute(dependent.class)
+      assert_not_nil(attribute, "Dependent attribute missing for #{dependent} owner #{owner}")
+      # a dependent collection reference must be refetched
+      if owner.class.collection_attribute?(attribute) then
+        verify_saved_dependent_collection_member(dependent, owner, 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.
+    def verify_saved_dependent_collection_member(dependent, owner, attribute)
+      deps = owner.send(attribute)
+      assert(deps.include?(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 & subject.class.mandatory_attributes
+      return if attrs.empty?
+      missing = attrs.reject { |attr| subject.send(attr) }
+      assert(missing.empty?, "#{subject} is missing values for 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
+      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.
+    #
+    # @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|
+        # 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.")
+            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
+      verify_dependents_match(expected, actual)
+    end
+    
+    # @param [AttributeMetadata] 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 do |attr|
+        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 edeps.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