ramaze.ch.oddb.org 1.0.0

data/test/drugs/test_atc.rb

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+# Drugs::TestAtc -- de.oddb.org -- 20.02.2007 -- hwyss@ywesee.com
+
+$: << File.expand_path('../../lib', File.dirname(__FILE__))
+
+require 'test/unit'
+require 'oddb/drugs/atc'
+require 'test/stub/model'
+
+module ODDB
+  module Drugs
+    class TestAtc < Test::Unit::TestCase
+      def setup
+        @atc = Atc.new('A01AA01')
+      end
+      def test_level
+        l1 = Atc.new('A')
+        assert_equal(1, l1.level)
+        l2 = Atc.new('A01')
+        assert_equal(2, l2.level)
+        l3 = Atc.new('A01A')
+        assert_equal(3, l3.level)
+        l4 = Atc.new('A01AA')
+        assert_equal(4, l4.level)
+        assert_equal(5, @atc.level)
+      end
+      def test_parent
+        @atc.save
+        parent = Atc.new('A01AA')
+        parent.save
+        grandparent = Atc.new('A01A')
+        grandparent.save
+        assert_equal(parent, @atc.parent)
+        assert_equal(grandparent, parent.parent)
+        assert_nil(grandparent.parent)
+      end
+      def test_parent_code
+        assert_equal('A01AA', @atc.parent_code)
+        l4 = Atc.new('A01AA')
+        assert_equal('A01A', l4.parent_code)
+        l3 = Atc.new('A01A')
+        assert_equal('A01', l3.parent_code)
+        l2 = Atc.new('A01')
+        assert_equal('A', l2.parent_code)
+        l1 = Atc.new('A')
+        assert_equal(nil, l1.parent_code)
+      end
+      def test_sort
+        other = Atc.new('B01BC02')
+        assert_equal([@atc, other], [other, @atc].sort)
+      end
+    end
+  end
+end

data/test/drugs/test_composition.rb

@@ -0,0 +1,88 @@
+#!/usr/bin/env ruby
+# Drugs::TestComposition -- de.oddb.org -- 10.11.2006 -- hwyss@ywesee.com
+
+$: << File.expand_path('../../lib', File.dirname(__FILE__))
+
+require 'flexmock'
+require 'test/unit'
+require 'oddb/drugs/composition'
+
+module ODDB
+  module Drugs
+    class TestComposition < Test::Unit::TestCase
+      include FlexMock::TestCase
+      def setup
+        @composition = Composition.new
+      end
+      def test_active_agent
+        agt1 = flexmock('agent')
+        agt2 = flexmock('agent')
+        agt1.should_receive(:substance).and_return("substance1")
+        agt2.should_receive(:substance).and_return("substance2")
+        @composition.add_active_agent(agt1)
+        @composition.add_active_agent(agt2)
+        assert_equal(agt1, @composition.active_agent("substance1"))
+        assert_equal(agt2, @composition.active_agent("substance2"))
+      end
+      def test_equality
+        other = Composition.new
+        third = Composition.new
+        assert_equal(true, other == @composition)
+        assert_equal(true, @composition == other)
+        assert_equal(true, third == @composition)
+        assert_equal(true, @composition == third)
+
+        gform1 = flexmock('galenic form')
+        @composition.galenic_form = gform1
+        assert_equal(false, other == @composition)
+        assert_equal(false, @composition == other)
+
+        other.galenic_form = gform1
+        assert_equal(true, other == @composition)
+        assert_equal(true, @composition == other)
+
+        gform2 = flexmock('other galenic form')
+        third.galenic_form = gform2
+        assert_equal(false, third == @composition)
+        assert_equal(false, @composition == third)
+
+        agt1 = flexmock('active agent')
+        agt1.should_receive(:<=>).and_return(-1)
+        @composition.add_active_agent(agt1)
+        assert_equal(false, other == @composition)
+        assert_equal(false, @composition == other)
+
+        other.add_active_agent(agt1)
+        assert_equal(true, other == @composition)
+        assert_equal(true, @composition == other)
+
+        agt2 = flexmock('other active agent')
+        agt2.should_receive(:<=>).and_return(1)
+        third.galenic_form = gform1
+        third.add_active_agent(agt2)
+        assert_equal(false, third == @composition)
+        assert_equal(false, @composition == third)
+
+        @composition.add_active_agent(agt2)
+        other.add_active_agent(agt2)
+        third.add_active_agent(agt1)
+        assert_equal(true, other == @composition)
+        assert_equal(true, @composition == other)
+        assert_equal(true, third == @composition)
+        assert_equal(true, @composition == third)
+      end
+      def test_include
+        sub1 = flexmock('substance')
+        sub2 = flexmock('substance')
+        assert_equal(false, @composition.include?(sub1, 10, 'mg'))
+        assert_equal(false, @composition.include?(sub2, 10, 'mg'))
+        act = flexmock('active_agent')
+        @composition.add_active_agent(act)
+        act.should_receive(:substance).and_return(sub1)
+        act.should_receive(:dose).and_return(Dose.new(10, 'mg'))
+        assert_equal(true, @composition.include?(sub1, 10, 'mg'))
+        assert_equal(false, @composition.include?(sub2, 10, 'mg'))
+      end
+    end
+  end
+end

data/test/drugs/test_ddd.rb

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+# Drugs::TestDdd -- de.oddb.org -- 12.12.2006 -- hwyss@ywesee.com
+
+$: << File.expand_path('../../lib', File.dirname(__FILE__))
+
+require 'test/unit'
+require 'oddb/drugs/ddd'
+require 'oddb/drugs/dose'
+
+module ODDB
+  module Drugs
+    class TestDdd < Test::Unit::TestCase
+      def test_to_s
+        ddd = Ddd.new('o')
+        ddd.dose = Dose.new(12, 'mg')
+        assert_equal('o: 12 mg', ddd.to_s)
+        ddd.comment = 'a comment'
+        assert_equal('o: 12 mg (a comment)', ddd.to_s)
+      end
+    end
+  end
+end

data/test/drugs/test_dose.rb

@@ -0,0 +1,190 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+# Drugs::TestDose -- de.oddb.org -- 07.11.2006 -- hwyss@ywesee.com 
+
+$: << File.expand_path('../../lib', File.dirname(__FILE__))
+
+require 'test/unit'
+require 'oddb/drugs/dose'
+
+module ODDB
+  module Drugs
+class TestDose < Test::Unit::TestCase
+  def setup
+    @dose = Dose.new('1,7', 'mL')
+  end
+  def test_initialize1
+    vals = ['Aspirin, Tabletten', '12', '500', 'mg', 'D']
+    dose = Dose.new(*vals[2,2])
+    assert_equal(500, dose.qty)
+    assert_equal('mg', dose.unit.to_s)
+    assert_equal('500 mg', dose.to_s)
+  end
+  def test_initialize2
+    vals = ['Hametum, Salbe', '62.5', 'mg/g', 'D']
+    dose = Dose.new(*vals[1,2])
+    assert_equal(62.5, dose.qty)
+    assert_equal('mg/g', dose.unit.to_s)
+    assert_equal('62.5 mg/g', dose.to_s)
+  end
+  def test_initialize3
+    dose = Dose.new('1,7', 'mL')
+    assert_equal(1.7, dose.qty)
+    assert_equal('ml', dose.unit.to_s)
+    assert_equal('1.7 ml', dose.to_s)
+  end
+  def test_initialize4
+    compare = Dose.new(6.25, 'mg/g')
+    vals = ['62.5', 'mg/10g']
+    dose = Dose.new(*vals)
+    assert_equal(6.25, dose.qty)
+    assert_equal('mg/g', dose.unit.to_s)
+    assert_equal('62.5mg / 10g', dose.to_s)
+    assert_equal(0, compare<=>dose)
+    assert_equal(compare, dose)
+  end
+  def test_initialize5
+    compare = Dose.new(0.5, 'mg/ml')
+    vals = [1, 'mg/2ml']
+    dose = Dose.new(*vals)
+    assert_equal(0.5, dose.qty)
+    assert_equal('mg/ml', dose.unit.to_s)
+    assert_equal('1mg / 2ml', dose.to_s)
+    assert_equal(0, compare<=>dose)
+    assert_equal(compare, dose)
+  end
+  def test_initialize6
+    vals = ['62.5', ' mg / 10g']
+    dose = Dose.new(*vals)
+    assert_equal(6.25, dose.qty)
+    assert_equal('mg/g', dose.unit.to_s)
+    assert_equal('62.5mg / 10g', dose.to_s)
+  end
+  def test_initialize7
+    dose = Dose.new('0.025', '%')
+    assert_equal(0.025, dose.qty)
+    assert_equal('%', dose.unit.to_s)
+    assert_equal('0.025 %', dose.to_s)
+  end
+  def test_initialize8
+    dose = Dose.new('40-60', 'mg')
+    assert_equal(50, dose.qty)
+    assert_equal('mg', dose.unit.to_s)
+    assert_equal('40-60 mg', dose.to_s)
+  end
+  def test_comparable1
+    dose1 = Dose.new(10, 'mg')
+    dose2 = Dose.new(10, 'mg')
+    assert_equal(dose1, dose2)
+  end
+  def test_comparable2
+    dose1 = Dose.new(10, 'mg')
+    dose2 = Dose.new(10, 'g')
+    assert(dose2 > dose1, "dose2 was not > dose1")
+  end
+  def test_comparable3
+    dose1 = Dose.new(1000, 'I.E.')
+    dose2 = Dose.new(500, 'I.E.')
+    assert(dose2 < dose1, "dose2 was not < dose1")
+  end
+  def test_comparable4
+    dose1 = Dose.new(1000, 'mg')
+    dose2 = Dose.new(500, 'I.E.')
+    assert_equal(-1, dose2 <=> dose1, "dose2 was not < dose1")
+  end
+  def test_comparable5
+    dose1 = Dose.new(1000, 'mg')
+    dose2 = Dose.new(500, 'l')
+    assert_equal(-1, dose2 <=> dose1, "dose2 was not < dose1")
+  end
+  def test_comparable6
+    dose1 = Dose.new(1000, 'mg')
+    dose2 = Dose.new(1, 'g')
+    assert(dose2 == dose1, "dose2 was not == dose1")
+  end
+  def test_comparable7
+    dose1 = Dose.new('400-600', 'mg')
+    dose2 = Dose.new('0.4-0.6', 'g')
+    assert(dose2 == dose1, "dose2 was not == dose1")
+  end
+  def test_comparable8
+    dose1 = Dose.new('1000', 'µg')
+    dose2 = Dose.new('1', 'mg')
+    assert(dose2 == dose1, "dose2 was not == dose1")
+  end
+  def test_comparable9
+    dose1 = Dose.new(1000)
+    assert(dose1 == 1000, "Dose was not equal to equivalent Fixnum")
+    assert(1000 == dose1, "Fixnum was not equal to equivalent Dose")
+  end
+  def test_comparable10
+    dose1 = Dose.new(1000)
+    dose2 = Dose.new(1000, 'mg')
+    dose3 = Dose.new(500)
+    dose4 = Dose.new(1000)
+    assert_equal(-1, dose1 <=> dose2)
+    assert_equal(1, dose2 <=> dose1)
+    assert_equal(-1, dose3 <=> dose1)
+    assert_equal(1, dose1 <=> dose3)
+    assert_equal(0, dose1 <=> dose4)
+  end
+  def test_complex_unit
+    dose = nil
+    assert_nothing_raised {
+      dose = Dose.new(20.0, 'mg/5ml')
+    }
+  end
+  def test_from_quanty  
+    quanty = Quanty.new(1,'mg')
+    result = Dose.from_quanty(quanty)
+    assert_instance_of(Dose, result)
+    assert_equal(Dose.new(1, 'mg'), result)
+  end  
+  def test_addition
+    dose1 = Dose.new(7,'ml')
+    dose2 = Dose.new(1,'cl')
+    assert_equal(Dose.new(1.7, 'cl'), dose1 + dose2)
+  end
+  def test_subtraction
+    dose1 = Dose.new(1,'cl')
+    dose2 = Dose.new(7,'ml')
+    assert_equal(Dose.new(0.3, 'cl'), dose1 - dose2)
+  end
+  def test_multiplication
+    dose1 = Dose.new(1,'ml')
+    dose2 = Dose.new(1.7,'kg')
+    assert_equal(Dose.new(1.7, 'ml kg'), dose1 * dose2)
+  end
+  def test_division
+    dose1 = Dose.new(0.2,'g')
+    dose2 = Dose.new(100,'ml')
+    assert_equal(Dose.new(2, 'mg/ml'), dose1 / dose2)
+  end
+  def test_robust_initalizer
+    assert_nothing_raised {
+      Dose.new(12)
+    }
+  end
+  def test_range
+    dose = nil
+    assert_nothing_raised {
+      dose = Dose.new(1..5, 'mg')
+    }
+    assert_equal('1-5 mg', dose.to_s)
+  end
+  def test_robust_to_f
+    dose = Dose.new(12, 'mg')
+    assert_nothing_raised {
+      dose.to_f
+    }
+  end
+  def test_robust_to_i
+    dose = Dose.new(12, 'mg')
+    assert_nothing_raised {
+      dose.to_i
+    }
+    assert_equal(12, dose.to_i)
+  end
+end
+  end
+end

data/test/drugs/test_galenic_form.rb

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+# Drugs::TestGalenicForm -- de.oddb.org -- 21.02.2007 -- hwyss@ywesee.com
+
+$: << File.expand_path('../../lib', File.dirname(__FILE__))
+
+require 'test/unit'
+require 'oddb/drugs/galenic_form'
+
+module ODDB
+  module Drugs
+    class TestGalenicForm < Test::Unit::TestCase
+      def setup
+        @galenic_form = GalenicForm.new
+      end
+      def test_equal
+        other = GalenicForm.new
+        assert_equal(true, @galenic_form == @galenic_form)
+        assert_equal(false, @galenic_form == other)
+        assert_equal(false, other == @galenic_form)
+        assert_equal(false, @galenic_form == nil)
+
+        group = GalenicGroup.new('Tabletten')
+        @galenic_form.group = group
+        assert_equal(true, @galenic_form == @galenic_form)
+        assert_equal(false, @galenic_form == other)
+        assert_equal(false, other == @galenic_form)
+        assert_equal(false, @galenic_form == nil)
+
+        other.group = GalenicGroup.new('Salben')
+        assert_equal(true, @galenic_form == @galenic_form)
+        assert_equal(false, @galenic_form == other)
+        assert_equal(false, other == @galenic_form)
+
+        other.group = group
+        assert_equal(true, @galenic_form == @galenic_form)
+        assert_equal(true, @galenic_form == other)
+        assert_equal(true, other == @galenic_form)
+      end
+    end
+  end
+end

data/test/drugs/test_package.rb

@@ -0,0 +1,173 @@
+#!/usr/bin/env ruby
+# Drugs::TestPackage -- de.oddb.org -- 14.11.2006 -- hwyss@ywesee.com
+
+$: << File.expand_path('../../lib', File.dirname(__FILE__))
+
+require 'flexmock'
+require 'test/unit'
+require 'oddb/drugs/package'
+require 'oddb/drugs/dose'
+require 'oddb/util/money'
+
+module ODDB
+  module Drugs
+    class TestPackage < Test::Unit::TestCase
+      include FlexMock::TestCase
+      def setup
+        @package = Package.new
+      end
+      def test_comparable
+        other = Package.new
+        third = Package.new
+
+        ## empty packages are comparable
+        assert_equal(true, other.comparable?(@package))
+        assert_equal(true, @package.comparable?(other))
+        assert_equal(true, third.comparable?(@package))
+        assert_equal(true, @package.comparable?(third))
+
+        ## if the number of parts is different: not comparable
+        part1 = flexmock("part")
+        part1.should_receive(:comparable_size)\
+          .and_return(Dose.new(10, 'mg'))
+        @package.add_part(part1)
+        assert_equal(false, other.comparable?(@package))
+        assert_equal(false, @package.comparable?(other))
+        assert_equal(false, third.comparable?(@package))
+        assert_equal(false, @package.comparable?(third))
+
+        ## if the comparable_size is the same: comparable
+        part2 = flexmock("part")
+        part2.should_receive(:comparable_size)\
+          .and_return(Dose.new(10, 'mg'))
+        other.add_part(part2)
+        assert_equal(true, other.comparable?(@package))
+        assert_equal(true, @package.comparable?(other))
+
+        ## if the comparable_size is not the same: not comparable
+        part3 = flexmock("part")
+        part3.should_receive(:comparable_size)\
+          .and_return(Dose.new(20, 'mg'))
+        third.add_part(part3)
+        assert_equal(false, third.comparable?(@package))
+        assert_equal(false, @package.comparable?(third))
+
+        ## comparable still works for multiple parts
+        @package.add_part(part3)
+        other.add_part(part3)
+        assert_equal(true, other.comparable?(@package))
+        assert_equal(true, @package.comparable?(other))
+
+        ## ... but not if the order of parts is different
+        third.add_part(part2)
+        assert_equal(false, third.comparable?(@package))
+        assert_equal(false, @package.comparable?(third))
+      end
+      def test_comparables
+        part1 = flexmock("part")
+        part1.should_receive(:comparable_size)\
+          .and_return(Dose.new(10, 'mg'))
+        part1.should_ignore_missing
+        @package.add_part(part1)
+
+        sequence = flexmock('sequence')
+        seq1 = flexmock('sequence')
+        seq2 = flexmock('sequence')
+        sequence.should_receive(:comparables).and_return([seq1, seq2])
+        sequence.should_receive(:compositions).and_return([])
+        sequence.should_ignore_missing
+        @package.sequence = sequence
+
+        package1 = Package.new
+        package1.add_part(part1)
+        seq1.should_receive(:packages).and_return([package1, @package])
+
+        part2 = flexmock("part")
+        part2.should_receive(:comparable_size)\
+          .and_return(Dose.new(20, 'mg'))
+        package2 = Package.new
+        package2.add_part(part2)
+        seq2.should_receive(:packages).and_return([package2])
+
+        assert_equal([package1], @package.comparables)
+      end
+      def test_comparable_size
+        assert_equal([], @package.comparable_size)
+        part1 = flexmock("part")
+        part1.should_receive(:comparable_size)\
+          .and_return(Dose.new(10, 'mg'))
+        @package.add_part(part1)
+        assert_equal([Dose.new(10, 'mg')], @package.comparable_size)
+        part2 = flexmock("part")
+        part2.should_receive(:comparable_size)\
+          .and_return(Dose.new(20, 'mg'))
+        @package.add_part(part2)
+        assert_equal([Dose.new(10, 'mg'), Dose.new(20, 'mg')], 
+                     @package.comparable_size)
+      end
+      def test_dose_price
+        doses = []
+
+        sequence = flexmock('sequence')
+        sequence.should_receive(:add_package).with(@package)
+        sequence.should_receive(:save)
+        sequence.should_receive(:compositions).and_return([])
+        sequence.should_receive(:doses).and_return(doses)
+        @package.sequence = sequence
+
+        dose = Drugs::Dose.new(1, 'g')
+        assert_nil(@package.dose_price(nil))
+        assert_nil(@package.dose_price(dose))
+
+        price = Business::Price.new(:public, 'CH')
+        price.value = Util::Money.new(10)
+        assert(price.is_for?(:public, 'CH'))
+        @package.add_price(price)
+        assert_nil(@package.dose_price(nil))
+        assert_nil(@package.dose_price(dose))
+
+        doses.push(Drugs::Dose.new(10, 'mg'))
+        assert_nil(@package.dose_price(nil))
+        assert_nil(@package.dose_price(dose))
+
+        part1 = flexmock("part")
+        part1.should_receive(:comparable_size)\
+          .and_return(Dose.new(2))
+        part1.should_ignore_missing
+        @package.add_part(part1)
+        assert_nil(@package.dose_price(nil))
+        expected = Util::Money.new(500)
+        assert_equal(expected, @package.dose_price(dose))
+      end
+      def test_sequence_writer
+        part = flexmock('Part')
+        sequence = flexmock('Sequence')
+        comp = flexmock('Composition')
+        @package.add_part(part)
+        sequence.should_receive(:add_package).times(1)
+        sequence.should_receive(:save).times(2)
+        sequence.should_receive(:compositions).and_return([comp])
+        part.should_receive(:composition=).with(comp)\
+          .times(1).and_return { assert(true) }
+        part.should_receive(:save)
+        @package.sequence = sequence
+
+        sequence.should_receive(:remove_package).with(@package).times(1)
+        part.should_receive(:composition=).with(nil)\
+          .times(1).and_return { assert(true) }
+        @package.sequence = nil
+      end
+      def test_size
+        assert_equal(0, @package.size)
+        part1 = flexmock("part")
+        part1.should_receive(:comparable_size).and_return(Dose.new(1))
+        @package.add_part(part1)
+        assert_equal(1, @package.size)
+        part2 = flexmock("part")
+        part2.should_receive(:comparable_size).and_return(Dose.new(2))
+        @package.add_part(part2)
+        assert_equal(3, @package.size)
+      end
+    end
+  end
+end