caruby-tissue 1.3.1 → 1.3.2

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

@@ -0,0 +1,61 @@
+require File.join(File.dirname(__FILE__), '..', 'test_case')
+require 'test/fixtures/lib/catissue/defaults_test_fixture'
+
+class SpecimenRequirementTest < Test::Unit::TestCase
+  include CaTissue::TestCase
+
+  def setup
+    super
+    @rqmt = defaults.specimen_requirement
+  end
+
+  def test_event
+    assert(@rqmt.collection_event.requirements.include?(@rqmt), "Event requirements not updated")
+  end
+
+  def test_defaults
+    @rqmt.specimen_characteristics = nil
+    verify_defaults(@rqmt)
+  end
+
+  # Tests whether the child_specimens domain type is overridden in the configuration from the
+  # inferred Java parameterized generic type property.
+  def test_child_specimens_type
+    assert_equal(CaTissue::SpecimenRequirement, @rqmt.class.domain_type(:child_specimens), "child_specimens domain type not overridden in configuration to non-abstract SpecimenRequirement")
+  end
+
+   def test_derivative_validation
+     @rqmt.derive(:count => 2, :specimen_type => (@rqmt.specimen_type + ' Block'))
+     assert_equal(2, @rqmt.children.size, "Derived requirement count incorrect")
+     @rqmt.add_defaults
+     assert_raise(ValidationError, "Multiple derivatives incorrectly succeeds validation") { @rqmt.validate }
+   end
+
+  def test_save
+    verify_save(@rqmt)
+
+    # query the CPE
+    cpe = @rqmt.collection_protocol_event
+    tmpl = CaTissue::SpecimenRequirement.new(:collection_protocol_event => cpe)
+    logger.debug { "Verifying the Requirement CPE query #{tmpl.qp}..." }
+    verify_query(tmpl) do |result|
+      assert_equal(1, result.size, "Requirement event query result size incorrect")
+      assert_equal(@rqmt.identifier, result.first.identifier, "Requirement event query result identifier incorrect")
+    end
+  end
+
+  def test_derived_store
+    child = @rqmt.derive
+    verify_save(@rqmt)
+    assert_equal(1, @rqmt.children.size, "Requirment children size incorrect")
+    assert_same(child, @rqmt.children.first, "Requirment child incorrect")
+
+    # query the derived Requirement
+    tmpl = child.class.new(:parent => @rqmt.copy(:identifier))
+    logger.debug { "Verifying the derived Requirement query #{tmpl}..." }
+    verify_query(tmpl) do |result|
+      assert_equal(1, result.size, "Derived requirement query result size incorrect")
+      assert_equal(child.identifier, result.first.identifier, "Derived requirement query result identifier incorrect")
+    end
+  end
+end

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

@@ -0,0 +1,272 @@
+require File.join(File.dirname(__FILE__), '..', 'test_case')
+require 'test/fixtures/lib/catissue/defaults_test_fixture'
+require 'caruby/util/transitive_closure'
+
+class SpecimenTest < Test::Unit::TestCase
+  include CaTissue::TestCase
+
+  def setup
+    super
+    @spc = defaults.specimen
+  end
+
+#  def test_requirement_copy
+#    rqmt = @spc.requirement
+#    rqmt.value_hash(rqmt.class.nondomain_attributes).each do |attr, value|
+#      assert_equal(value, @spc.send(attr), "Specimen requirement #{attr} not copied")
+#    end
+#  end
+#
+#  def test_characteristics
+#    chrs = @spc.specimen_characteristics
+#    assert_not_nil(chrs, "Specimen characterstics not found")
+#  end
+#
+#  def test_defaults
+#    @spc.lineage = @spc.specimen_class = @spc.specimen_characteristics = nil
+#    verify_defaults(@spc)
+#    # specimen class is set as a default value
+#    assert_equal("Tissue", @spc.specimen_class, "Specimen class incorrect")
+#    # the characteristics default is set as a default value
+#    assert_not_nil(@spc.specimen_characteristics, "Specimen characteristics not set to default")
+#  end
+#
+#  # Tests whether the child_specimens domain type is overridden in the configuration from the
+#  # inferred Java parameterized generic type property.
+#  def test_child_specimens_type
+#    assert_equal(CaTissue::Specimen, @spc.class.domain_type(:child_specimens), "child_specimen domain type not overridden in configuration to non-abstract Specimen")
+#  end
+#
+#  def test_parent
+#    @spc.parent = CaTissue::TissueSpecimen.new
+#    assert_equal(1, @spc.parent.children.size, "Specimen children size incorrect")
+#    assert_equal(@spc, @spc.parent.children.first, "Specimen parent incorrect")
+#  end
+#
+#  def test_transitive_closure
+#    @spc.parent = CaTissue::TissueSpecimen.new
+#    # take the transitive closure of specimens in the hierarchy
+#    closure = [@spc.parent].transitive_closure(:children)
+#    assert(closure.include?(@spc.parent), "Specimen transitive closure does not contain parent")
+#    assert(closure.include?(@spc), "Specimen transitive closure does not contain child")
+#  end
+#
+#  def test_move
+#    # add to the default box
+#    box = defaults.box << @spc
+#    pos = @spc.position
+#    assert_not_nil(pos, "Specimen position not set")
+#    assert_same(@spc, pos.specimen, "Specimen position specimen incorrect")
+#    # test move from box to another box
+#    dest = box.copy
+#    @spc >> dest
+#    assert_same(dest, @spc.position.container, "Specimen position container incorrect")
+#    assert(dest.include?(@spc), "Destination #{box.qp} doesn't hold specimen #{@spc.qp}")
+#    assert(!box.include?(@spc), "Old box #{box.qp} still holds specimen #{@spc.qp}")
+#  end
+#
+#  def test_derive
+#    start_quantity = @spc.available_quantity
+#    child_quantity = start_quantity / 2
+#    child = @spc.derive(:specimen_class => :molecular, :specimen_type => 'DNA', :initial_quantity => child_quantity)
+#    assert_equal(CaTissue::MolecularSpecimen, child.class, "Derived specimen class incorrect")
+#    assert_same(@spc, child.parent, "Derived specimen parent incorrect")
+#    assert(@spc.children.include?(child), "Child specimens does not include the derived specimen")
+#    assert_equal(child_quantity, child.initial_quantity, "Child specimen quantity incorrect")
+#    # parent quantity not automatically decremented, since parent and child types differ
+#    assert_equal(start_quantity, @spc.available_quantity, "Parent specimen quantity not decremented correctly")
+#  end
+#
+#  def test_derive_defaults
+#    child = @spc.derive
+#    assert_same(@spc.class, child.class, "Derived specimen class incorrect")
+#    assert_equal(@spc.specimen_type, child.specimen_type, "Derived specimen type incorrect")
+#    assert_equal(@spc.pathological_status, child.pathological_status, "Derived specimen pathological status incorrect")
+#  end
+#
+#  def test_aliquot
+#    start_qty = @spc.available_quantity
+#    # the number of aliquots
+#    count = 2
+#    # the aliqout quantity
+#    alq_qty = start_qty / 4
+#    # the expected parent quantity
+#    par_qty = start_qty - (alq_qty * count)
+#    # make the aliquots
+#    alqs = @spc.derive(:count => count, :initial_quantity => alq_qty)
+#    assert_equal(count, alqs.size, "Aliquot count incorrect")
+#    assert_equal(par_qty, @spc.available_quantity, "Parent specimen quantity not decremented correctly")
+#    alqs.each do |alq|
+#      assert_same(@spc.class, alq.class, "Aliquot class incorrect")
+#      assert_equal(alq_qty, alq.initial_quantity, "Aliquot quantity incorrect")
+#      assert_same(@spc.specimen_characteristics, alq.specimen_characteristics, "Aliquot does not share parent characteristics")
+#    end
+#    # make a non-aliquot derived specimen
+#    @spc.derive(:specimen_class => :molecular, :specimen_type => 'DNA')
+#    # test that only the aliquots are included in the aliquots accessor
+#    assert_equal(alqs.to_set, @spc.aliquots.to_set, "Aliquots accessor incorrect")
+#  end
+#
+#  def test_aliquot_default_quantity
+#    start_qty = @spc.available_quantity
+#    count = 2
+#    expected_qty = start_qty / count
+#    aliquots = @spc.derive(:count => count)
+#    assert_equal(0, @spc.available_quantity, "Parent specimen quantity not decremented correctly")
+#    aliquots.each do |aliquot|
+#      assert_equal(expected_qty, aliquot.initial_quantity, "Aliquot quantity incorrect")
+#    end
+#  end
+#
+#  # Tests whether a Specimen with a position save template does not include the position.
+#  # The position is saved as a caTissue side-effect by creating a proxy transfer event.
+#  def test_position_save_template
+#    defaults.box << @spc
+#    assert_not_nil(@spc.position, "#{@spc.qp} not added to box")
+#    # the save template
+#    tmpl = mock_create_template(@spc)
+#    assert_nil(tmpl.position, "#{@spc.qp} save template incorrectly includes the position")
+#  end
+#
+#  def test_pathology_annotation
+#    pths = @spc.prostate_specimen_pathology_annotations
+#    assert(pths.empty?, "Pathology annotations not empty at start")
+#    pth = CaTissue::Specimen::Pathology::ProstateSpecimenPathologyAnnotation.new
+#    pth.merge_attributes(:specimen => @spc)
+#    grade = CaTissue::Specimen::Pathology::HistologicGrade.new
+#    grade.merge_attributes(:grade => 3, :specimen_base_solid_tissue_pathology_annotation => pth)
+#    htype = CaTissue::Specimen::Pathology::HistologicType.new
+#    htype.merge_attributes(:type => 3, :specimen_base_solid_tissue_pathology_annotation => pth)
+#    gleason = CaTissue::Specimen::Pathology::GleasonScore.new
+#    gleason.merge_attributes(:primary_pattern_score => 3, :secondary_pattern_score => 4, :prostate_specimen_pathology_annotation => pth)
+#    assert_not_nil(pths.first, "Pathology annotation not added to participant pths")
+#    assert_same(pth, pths.first, "Pathology annotation incorrect")
+#    assert_same(gleason, pth.gleason_score, "Pathology annotation gleason score incorrect")
+#    assert_same(grade, pth.histologic_grades.first, "Pathology annotation histologic grades incorrect")
+#    assert_same(htype, pth.histologic_types.first, "Pathology annotation histologic types incorrect")
+#  end
+#
+#  
+#  ## DATABASE TEST CASES ##
+#
+#  def test_simple_save
+#    # save the auto-generated specimen
+#    verify_save(@spc)
+#
+#    # verify SCG specimens query
+#    logger.debug { "Verifying SCG specimens query..." }
+#    scg = @spc.specimen_collection_group
+#    tmpl = scg.copy(:identifier)
+#    spcs = database.query(tmpl, :specimens)
+#    assert_equal(1, spcs.size, "SCG specimen query result count incorrect")
+#    spc = spcs.first
+#    spc.class.nondomain_attributes.each do |attr|
+#      assert_equal(@spc.send(attr), spc.send(attr), "SCG specimen query result #{attr} incorrect")
+#    end
+#    
+#    # make a new specimen in the same SCG
+#    spc2 = @spc.copy
+#    spc2.identifier = nil
+#    spc2.specimen_collection_group = scg
+#    verify_save(spc2)
+#  end
+#  
+#  # Tests the work-around for caTissue Bug #159: Update pending Specimen ignores availableQuantity.
+#  def test_quantity_save
+#    # reset the available quantity
+#    @spc.available_quantity = @spc.initial_quantity / 2
+#    verify_save(@spc)
+#  end
+#
+#  # Exercises the CaTissue::Specimen external_identifiers logical dependency work-around.
+#  def test_eid_save
+#    # add an EID
+#    eid = CaTissue::ExternalIdentifier.new(:name => 'Test Name'.uniquify, :specimen => @spc, :value => 'Test Value'.uniquify)
+#    verify_save(@spc)
+#    # query on the EID
+#    logger.debug { "Verifying Specimen EID query..." }
+#    tmpl = @spc.copy(:external_identifiers)
+#    assert_not_nil(database.find(tmpl), "Specimen not found by external identifier")
+#    assert_equal(@spc.identifier, tmpl.identifier, "Incorrect specimen found by external identifier")
+#    # update the specimen to exercise Bug #164
+#    verify_save(@spc)
+#  end
+#   
+#  def test_events_save
+#    # add an event
+#    CaTissue::FrozenEventParameters.new(:specimen => @spc, :freeze_method => 'Cryostat')
+#    verify_save(@spc)
+#  end
+#
+#  def test_position_save
+#    defaults.box << @spc
+#    verify_save(@spc)
+#    # move the specimen
+#    @spc.position.location = @spc.position.location.succ
+#    logger.debug { "#{name} verifing move of #{@spc} to #{@spc.position.location}..." }
+#    verify_save(@spc)
+#  end
+#  
+#  # Exercise creation of a child specimen.
+#  def test_derived_create
+#    # verify creating a derived specimen
+#    logger.debug { "Verifying creating a derived specimen..." }
+#    # derive a specimen
+#    drv = @spc.derive(:specimen_class => :molecular, :initial_quantity => 20, :specimen_type => 'DNA')
+#    # add an event
+#    CaTissue::SpunEventParameters.new(:specimen => drv, :duration_in_minutes => 2, :gravity_force => 5)
+#    # store the derived specimen
+#    verify_save(drv)
+#    # verify the derived specimen parent
+#    assert_same(@spc, drv.parent, "Derived specimen parent incorrect after store")
+#    # query the derived specimen
+#    tmpl = CaTissue::Specimen.new(:parent => @spc.class.new(:label => @spc.label))
+#    verify_query(tmpl) do |children|
+#      assert_equal(1, children.size, "Parent specimen children count incorrect")
+#      assert(drv.match_in_owner_scope(children), "Derived specimen not found in parent query result")
+#    end
+#  end
+#  
+#  # Exercise update of an auto-generated child specimen.
+#  #
+#  # This test case differs from {#test_derived_create} in that there are critical caTissue code path
+#  # differences which dictate how the derived object save template is built. See the caTissue
+#  # alert comment in CaRuby::StoreTemplateBuilder initialize code for details.
+#  def test_autogenerated_derived_save
+#    # verify updating an auto-generated derived specimen
+#    logger.debug { "Verifying updating an auto-generated derived specimen..." }
+#    # derive a specimen requirement
+#    rqmt = @spc.requirement.derive(:specimen_class => :molecular, :initial_quantity => 20, :specimen_type => 'DNA')
+#    # derive the specimen
+#    drv = @spc.derive(:requirement => rqmt)
+#    # store the derived specimen
+#    verify_save(drv)
+#  end
+#  
+  def test_save_prostate_annotation
+    pa = CaTissue::Specimen::Pathology::ProstateSpecimenPathologyAnnotation.new
+    pa.specimen = @spc
+    grade = CaTissue::Specimen::Pathology::HistologicGrade.new
+    grade.merge_attributes(:grade => 3, :specimen_base_solid_tissue_pathology_annotation => pa)
+    htype = CaTissue::Specimen::Pathology::HistologicType.new
+    htype.merge_attributes(:type => 3, :specimen_base_solid_tissue_pathology_annotation => pa)
+    invn = CaTissue::Specimen::Pathology::Invasion.new
+    invn.merge_attributes(:lymphatic_invasion => 'Present', :specimen_base_solid_tissue_pathology_annotation => pa)
+    gleason = CaTissue::Specimen::Pathology::GleasonScore.new
+    gleason.merge_attributes(:primary_pattern_score => 3, :secondary_pattern_score => 4, :prostate_specimen_pathology_annotation => pa)
+    verify_save(pa)
+    assert_not_nil(pa.identifier, "#{@spc} annotation #{pa} not saved")
+    assert_not_nil(grade.identifier, "#{@spc} annotation #{grade} not saved")
+    assert_not_nil(htype.identifier, "#{@spc} annotation #{htype} not saved")
+    assert_not_nil(invn.identifier, "#{@spc} annotation #{invn} not saved")
+    assert_not_nil(gleason.identifier, "#{gleason} not saved")
+  end
+#
+#  def test_save_melanoma_annotation
+#    ma = CaTissue::Specimen::Pathology::MelanomaSpecimenPathologyAnnotation.new
+#    ma.merge_attributes(:specimen => @spc, :comments => "Test Comment", :depth_of_invasion => 2.0, :mitotic_index => "MitoticIndex",
+#      :ulceration => "Ulceration", :tumor_regression => "TumorRegression", :tumor_infiltrating_lymphocytes => "TumorInfiltratingLymphocytes")
+#    verify_save(ma)
+#    assert_not_nil(ma.identifier, "#{ma} not saved")
+#  end
+end

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

@@ -0,0 +1,150 @@
+require File.join(File.dirname(__FILE__), '..', 'test_case')
+require 'caruby/util/uniquifier'
+require 'test/fixtures/lib/catissue/defaults_test_fixture'
+
+class StorageContainerTest < Test::Unit::TestCase
+  include CaTissue::TestCase
+
+  def setup
+    super
+    @spc = defaults.specimen
+    site = defaults.tissue_bank
+    frz_type = CaTissue::StorageType.new(:name => 'Test Freezer'.uniquify, :columns => 1, :rows => 2)
+    rack_type = CaTissue::StorageType.new(:name => 'Test Rack'.uniquify, :columns => 2, :rows => 1)
+    box_type = CaTissue::StorageType.new(:name => 'Test Box'.uniquify, :columns => 1, :rows => 2)
+    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 << array_type
+    box_type << @spc.specimen_class
+    @frz = CaTissue::StorageContainer.new(:site => site, :container_type => frz_type)
+    @array = CaTissue::SpecimenArray.new(:container_type => array_type)
+  end
+
+  def test_defaults
+    verify_defaults(@frz)
+  end
+
+  def test_add
+    @frz << @spc
+
+    rack = @frz[0, 0]
+    assert_not_nil(rack, "Rack not created")
+    assert(@frz.holds?(rack), "Rack not added to freezer")
+    assert_same(@frz, rack.parent, "Rack parent is not the freezer")
+    assert_equal(rack, @frz[0, 0], "Rack index accessor incorrect")
+
+    box = rack[0, 0]
+    assert_not_nil(box, "Box not created")
+    assert(rack.holds?(box), "Rack doesn't hold box")
+    assert_same(rack, box.parent, "Box parent is not the rack")
+
+    assert(box.holds?(@spc), "Box doesn't hold specimen")
+    assert_same(@spc, box[0, 0], "Specimen index accessor incorrect")
+    assert_nil(@frz[0, 1], "Empty slot index accessor not nil")
+    assert_nil(@frz[0, 2], "Column out of bounds index accessor not nil")
+    assert_nil(@frz[1, 0], "Row out of bounds index accessor not nil")
+    assert(!rack.full?, "Rack is incorrectly full")
+    assert(!box.full?, "Box is incorrectly full")
+
+    # add a new specimen
+    @frz << spc2 =  @spc.copy
+    assert_same(box, spc2.position.container, "New specimen box incorrect")
+    assert(!rack.full?, "Rack is incorrectly full")
+    assert(box.full?, "Box is incorrectly not full")
+
+    # create a new box for another specimen
+    @frz << spc3 = @spc.copy
+    assert_not_same(box, spc3.position.container, "New box not allocated")
+    assert(rack.full?, "Rack is not full")
+
+    # create a new box for another specimen
+    @frz << spc4 = @spc.copy
+    assert_same(spc3.position.container, spc4.position.container, "New box incorrectly allocated")
+    
+    # fill the freezer
+    4.times { @frz << @spc.copy }
+    assert(@frz.full?, "Freezer incorrectly not full")
+    assert(@frz.completely_full?, "Freezer incorrectly not completely full")
+    
+    # create a new box with no place to put it
+    assert_raises(IndexError, "Add to full box succeeded") { box << @spc.copy }
+  end
+  
+  def test_fill_gap
+     @frz << @spc
+
+    rack = @frz[0, 0]
+    assert_not_nil(rack, "Rack not created")
+    box = rack[0, 0]
+    assert_not_nil(box, "Box not created")
+    
+    # make another box
+    @frz << box2 = box.copy(:container_type)
+    assert_equal(box2, rack[1, 0], "Rack index accessor incorrect")
+
+    # add a specimen to the second box
+    box2 << spc2 = @spc.copy
+    assert_equal(spc2, box2[0, 0], "Specimen is placed in #{@spc.position.location} rather than the second box #{box.qp}")
+   
+    # add a specimen to the first available slot in the first box
+    spc3 = @spc.copy
+    @frz << spc3
+    assert_equal(spc3, box[0, 1], "Specimen is placed in #{@spc.position.location} rather than the first box #{box.qp}")
+    
+    # add a specimen to the second box
+    @frz << spc4 = @spc.copy
+    assert_equal(spc4, box2[0, 1], "Specimen is not placed in second box")
+    
+    # fill the freezer
+    4.times { @frz << @spc.copy }
+    assert(@frz.full?, "Freezer incorrectly not full")
+    assert(@frz.completely_full?, "Freezer incorrectly not completely full")
+  end
+
+  def test_comparison
+    @frz << @spc
+    assert_equal(@frz, @frz, "Same not equal")
+    rack = @frz.subcontainers.first
+    assert_not_nil(rack, "Rack missing")
+    box = rack.subcontainers.first
+    assert_not_nil(box, "Box missing")
+    assert(rack < @frz, "Rack not < freezer")
+    assert(@frz > rack, "Freezer not > rack")
+    assert(box < rack, "Box not < rack")
+    assert(box < @frz, "Box not < rack")
+  end
+
+#  def test_save
+#    @frz << @spc
+#    rack = @frz.subcontainers.first
+#    assert_not_nil(rack, "Rack missing")
+#    box = rack.subcontainers.first
+#    assert_not_nil(box, "Box missing")
+#
+#    # verify that the box name can be set
+#    box.name = 'Test Box'.uniquify
+#    verify_save(box)
+#    assert_not_nil(@frz.identifier, "#{@frz.qp} not saved")
+#
+#    assert_not_nil(rack.identifier, "#{rack.qp} not saved")
+#    assert_not_nil(rack.position, "#{rack.qp} position missing")
+#    assert_not_nil(rack.position.identifier, "#{rack.qp} position not saved")
+#    assert_not_nil(@frz.subcontainers.first, "#{@frz.qp} subcontainer not found")
+#    assert_same(rack, @frz.subcontainers.first, "#{@frz.qp} subcontainer is not the rack")
+#    assert_same(@frz, rack.position.parent_container, "#{rack.qp} position container missing")
+#
+#    assert_not_nil(box.identifier, "#{box} not saved")
+#    assert_not_nil(box.position, "#{box} position missing")
+#    assert_not_nil(box.position.identifier, "#{box} position not saved")
+#    assert_same(rack, box.position.parent_container, "#{box} position container missing")
+#    assert_not_nil(rack.subcontainers.first, "#{rack.qp} subcontainer not found")
+#    assert_same(box, rack.subcontainers.first, "#{rack.qp} subcontainer is not the box")
+#
+#    assert(!box.specimens.empty?, "#{box} doesn't hold a specimen")
+#    assert_same(@spc, box.specimens.first, "#{box} specimen incorrect")
+#    assert_not_nil(@spc.identifier, "#{@spc} not saved")
+#    assert_not_nil(@spc.position, "#{@spc} missing position")
+#  end
+end