de.oddb 2.0.0

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,172 @@
+#!/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 = Util::Money.new(10, :public, 'DE')
+        assert(price.is_for?(:public, 'DE'))
+        @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)
+        expected = Util::Money.new(500, :public)
+        assert_nil(@package.dose_price(nil))
+        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

data/test/drugs/test_part.rb

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+# Drugs::TestPart -- de.oddb.org -- 22.11.2006 -- hwyss@ywesee.com
+
+$: << File.expand_path('../../lib', File.dirname(__FILE__))
+
+require 'test/unit'
+require 'oddb/drugs/part'
+
+module ODDB
+  module Drugs
+    class TestPart < Test::Unit::TestCase
+      def setup
+        @part = Part.new
+      end
+      def test_size_writer
+        @part.size = 1.5
+        assert_instance_of(Float, @part.size)
+        assert_equal(1.5, @part.size)
+        @part.size = 5
+        assert_instance_of(Fixnum, @part.size)
+        assert_equal(5, @part.size)
+      end
+      def test_comparable_size
+        assert_equal(Dose.new(1), @part.comparable_size)
+        @part.size = "4.5"
+        assert_equal(Dose.new(4.5), @part.comparable_size)
+        @part.quantity = Dose.new(20, 'ml')
+        assert_equal(Dose.new(90, 'ml'), @part.comparable_size)
+      end
+    end
+  end
+end

data/test/drugs/test_product.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+# Drugs::TestProduct -- de.oddb.org -- 09.08.2006 -- hwyss@ywesee.com
+
+$: << File.expand_path('../../lib', File.dirname(__FILE__))
+
+require 'flexmock'
+require 'test/unit'
+require 'oddb/drugs/product'
+
+module ODDB
+  module Drugs
+    class TestProduct < Test::Unit::TestCase
+      include FlexMock::TestCase
+      def setup
+        @product = Product.new
+      end
+      def test_name
+        assert_instance_of(Util::Multilingual, @product.name)
+      end
+      def test_packages
+        seq1 = flexmock('sequence')
+        seq2 = flexmock('sequence')
+        seq1.should_receive(:packages).and_return(%w{foo bar})
+        seq2.should_receive(:packages).and_return(%w{baz})
+        @product.add_sequence(seq1)
+        @product.add_sequence(seq2)
+        assert_equal(%w{foo bar baz}, @product.packages)
+      end
+    end
+  end
+end

data/test/drugs/test_sequence.rb

@@ -0,0 +1,140 @@
+#!/usr/bin/env ruby
+# Drugs::TestSequence -- de.oddb.org -- 10.11.2006 -- hwyss@ywesee.com
+
+$: << File.expand_path('../../lib', File.dirname(__FILE__))
+
+require 'flexmock'
+require 'test/unit'
+require 'oddb/drugs/ddd'
+require 'oddb/drugs/sequence'
+
+module ODDB
+  module Drugs
+    class TestSequence < Test::Unit::TestCase
+      include FlexMock::TestCase
+      def setup
+        @sequence = Sequence.new
+      end
+      def test_comparable
+        other = Sequence.new
+        third = Sequence.new
+        assert_equal(true, @sequence.comparable?(other))
+        assert_equal(true, other.comparable?(@sequence))
+        assert_equal(true, @sequence.comparable?(third))
+        assert_equal(true, third.comparable?(@sequence))
+
+        comp1 = flexmock('composition')
+        @sequence.add_composition(comp1)
+        assert_equal(false, @sequence.comparable?(other))
+        assert_equal(false, other.comparable?(@sequence))
+
+        other.add_composition(comp1)
+        assert_equal(true, @sequence.comparable?(other))
+        assert_equal(true, other.comparable?(@sequence))
+
+        comp2 = flexmock('other composition')
+        third.add_composition(comp2)
+        assert_equal(false, @sequence.comparable?(third))
+        assert_equal(false, third.comparable?(@sequence))
+
+        @sequence.add_composition(comp2)
+        other.add_composition(comp2)
+        third.add_composition(comp1)
+        assert_equal(true, @sequence.comparable?(other))
+        assert_equal(true, other.comparable?(@sequence))
+        assert_equal(false, @sequence.comparable?(third))
+        assert_equal(false, third.comparable?(@sequence))
+      end
+      def test_comparables
+        seq1 = Sequence.new
+        seq2 = Sequence.new
+        atc = flexmock('atc')
+        atc.should_receive(:sequences)\
+          .and_return([seq1, @sequence, seq2])
+        atc.should_ignore_missing
+        @sequence.atc = atc
+
+        comp1 = flexmock('composition')
+        @sequence.add_composition(comp1)
+        seq1.add_composition(comp1)
+        comp2 = flexmock('composition')
+        seq2.add_composition(comp2)
+
+        assert_equal([seq1, @sequence], @sequence.comparables)
+      end
+      def test_ddds
+        ddd1 = Drugs::Ddd.new('O')
+        ddd2 = Drugs::Ddd.new('P')
+        atc = flexmock('atc')
+        atc.should_ignore_missing
+        atc.should_receive(:ddds).and_return([ddd1, ddd2])
+        @sequence.atc = atc
+
+        comp1 = flexmock('composition')
+        comp1.should_ignore_missing
+        @sequence.add_composition(comp1)
+        assert_equal([], @sequence.ddds)
+
+        form1 = flexmock('galenic_form')
+        form1.should_ignore_missing
+        comp1.should_receive(:galenic_form).and_return(form1)
+        assert_equal([], @sequence.ddds)
+
+        group1 = flexmock('galenic_group')
+        group1.should_ignore_missing
+        form1.should_receive(:group).and_return(group1)
+        assert_equal([], @sequence.ddds)
+
+        group1.should_receive(:administration).and_return('O')
+        assert_equal([ddd1], @sequence.ddds)
+      end
+      def test_include
+        sub1 = flexmock('substance')
+        sub2 = flexmock('substance')
+        assert_equal(false, @sequence.include?(sub1, 10, 'mg'))
+        assert_equal(false, @sequence.include?(sub2, 10, 'mg'))
+        comp = flexmock('composition')
+        @sequence.add_composition(comp)
+        comp.should_receive(:include?).and_return { |sub, dose, unit|
+          assert_equal(10, dose)
+          assert_equal('mg', unit)
+          sub == sub1
+        }
+        assert_equal(true, @sequence.include?(sub1, 10, 'mg'))
+        assert_equal(false, @sequence.include?(sub2, 10, 'mg'))
+      end
+      def test_identical
+        other = Sequence.new
+        third = Sequence.new
+        assert_equal(true, @sequence.identical?(other))
+        assert_equal(true, other.identical?(@sequence))
+        assert_equal(true, @sequence.identical?(third))
+        assert_equal(true, third.identical?(@sequence))
+
+        comp1 = flexmock('composition')
+        comp1.should_ignore_missing
+        @sequence.add_composition(comp1)
+        assert_equal(false, @sequence.identical?(other))
+        assert_equal(false, other.identical?(@sequence))
+
+        other.add_composition(comp1)
+        assert_equal(true, @sequence.identical?(other))
+        assert_equal(true, other.identical?(@sequence))
+
+        comp2 = flexmock('other composition')
+        comp2.should_ignore_missing
+        third.add_composition(comp2)
+        assert_equal(false, @sequence.identical?(third))
+        assert_equal(false, third.identical?(@sequence))
+
+        @sequence.add_composition(comp2)
+        other.add_composition(comp2)
+        third.add_composition(comp1)
+        assert_equal(true, @sequence.identical?(other))
+        assert_equal(true, other.identical?(@sequence))
+        assert_equal(false, @sequence.identical?(third))
+        assert_equal(false, third.identical?(@sequence))
+      end
+    end
+  end
+end

data/test/drugs/test_substance.rb

@@ -0,0 +1,51 @@
+#!/usr/bin/env ruby
+# Drugs::TestSubstance -- de.oddb.org -- 13.11.2006 -- hwyss@ywesee.com
+
+$: << File.expand_path('../../lib', File.dirname(__FILE__))
+
+require 'flexmock'
+require 'test/unit'
+require 'oddb/drugs/substance'
+
+module ODDB
+  module Drugs
+    class TestSubstance < Test::Unit::TestCase
+      include FlexMock::TestCase
+      def setup
+        @substance = Substance.new
+      end
+      def test_group_writer
+        group = flexmock('group')
+        group.should_receive(:add_substance).times(1).with(@substance)
+        group.should_receive(:save).times(2)
+        assert_nil(@substance.group)
+        @substance.group = group
+        assert_equal(group, @substance.group)
+        @substance.group = group
+        assert_equal(group, @substance.group)
+        other = flexmock('other group')
+        group.should_receive(:remove_substance).times(1).with(@substance)
+        other.should_receive(:add_substance).times(1).with(@substance)
+        other.should_receive(:save).times(2)
+        @substance.group = other
+        assert_equal(other, @substance.group)
+        other.should_receive(:remove_substance).times(1).with(@substance)
+        @substance.group = nil
+        assert_nil(@substance.group)
+      end
+      def test_merge
+        @substance.name.de = 'Original'
+        other = Substance.new
+        other.name.de = 'Merged'
+        agent = flexmock('ActiveAgent')
+        other.instance_variable_set('@active_agents', [agent])
+        agent.should_receive(:substance=).with(@substance).times(1)
+        agent.should_receive(:save).times(1)
+        agent.should_ignore_missing
+        @substance.merge(other)
+        assert_equal 'Original', @substance.name.de
+        assert_equal ['Original', 'Merged'], @substance.name.all
+      end
+    end
+  end
+end