oddb.org 1.0.0 → 1.0.1

data/doc/robots.txt

@@ -0,0 +1,29 @@
+User-agent: Mediapartners-Google*
+Disallow: /
+User-agent:
+Disallow: /
+User-agent: *
+Disallow: /de/atupri/
+Disallow: /fr/atupri/
+Disallow: /en/atupri/
+Disallow: /de/just-medical/
+Disallow: /fr/just-medical/
+Disallow: /en/just-medical/
+Disallow: /de/hirslanden/
+Disallow: /fr/hirslanden/
+Disallow: /en/hirslanden/
+Disallow: /de/generika/
+Disallow: /fr/generika/
+Disallow: /en/generika/
+Disallow: /de/innova/
+Disallow: /fr/innova/
+Disallow: /en/innova/
+Disallow: /de/provita/
+Disallow: /fr/provita/
+Disallow: /en/provita/
+Disallow: /de/santesuisse/
+Disallow: /fr/santesuisse/
+Disallow: /en/santesuisse/
+Disallow: /de/schoenenberger/
+Disallow: /fr/schoenenberger/
+Disallow: /en/schoenenberger/

data/ext/export/src/generics_xls.rb

@@ -9,6 +9,7 @@ require 'spreadsheet/excel'
 module ODDB
 	module OdbaExporter
 		class GenericXls
+ 			RECIPIENTS = [ 'mhatakeyama@ywesee.com', 'zdavatz@ywesee.com' ]
 			FLAGS = {
 				:address					=> 'neue Herstelleradresse',
 				:comment					=> 'neue Bemerkung',
@@ -90,7 +91,7 @@ module ODDB
 				generics = []
 				comparables = []
 				@app.each_package { |pac|
-					if(pac.public? && pac.registration.active? && !pac.basename.nil? && pac.comparables.select{|pack| pack.basename.nil?}.empty?)
+					if(pac.public? && pac.registration.active?)
 						if(pac.registration.original? && (comps = pac.comparables) \
 							 && !comps.empty?)
 							originals.push(pac)
@@ -102,11 +103,28 @@ module ODDB
 				}
                 # Check Packages
                 # Some packages cannot be compared if package basename is nil
-                nilpackages = originals.select{|pac| pac.basename.nil?}.map{|pac| [pac.company_name, pac.barcode]}
+                nilpackages = originals.select{|pac| pac.basename.nil?} + generics.select{|pac| pac.basename.nil?}
                 unless nilpackages.empty? 
-                  error_message = "Package basename is nil. The package is not comparable.\n\n"
-                  error_message << "Package (company, EAN code): " << nilpackages.join(", ") << "\n"
-                  raise StandardError, error_message
+                  message =  "Package name may have a number in it and therefore basename becomes nil.\n"
+                  message << "The following packages are skipped during export_generics, since the packages are not comparable.\n\n"
+                  link = "http://#{SERVER_NAME}/de/gcc/search/zone/drugs/search_query/"
+                  message << "Package (company, EAN code, link):\n" 
+                  message << nilpackages.map{|pac| [pac.company_name, pac.barcode, link + pac.barcode].join(", ")}.join("\n")
+                  message << "\n"
+				  log = Log.new(@@today)
+				  log.report = [
+					"Class: #{self.class}",
+                    "Method: export_generics",
+					"Message: #{message}",
+					"Backtrace:",
+					caller(0).join("\n"),
+				  ].join("\n")
+				  log.recipients = RECIPIENTS.dup
+				  log.notify("Warning: Nil basename packages")
+
+                  # Remove the packages that basename is nil
+                  originals -= nilpackages
+                  generics  -= nilpackages
                 end
 
 				originals.sort.each { |pac| export_comparables(pac) }
@@ -176,3 +194,9 @@ module ODDB
 		end
 	end
 end
+
+begin
+      require 'testenvironment2'
+rescue LoadError
+end
+

data/ext/export/src/oddbdat.rb

@@ -420,7 +420,7 @@ module ODDB
 					11	=>	galform,
 					12	=>	conc,
 					13	=>	unit,
-					16	=>	@package.parts.first.multi,
+					16	=>	@package.parts.first ? @package.parts.first.multi : '',
 					17	=>	comform,
 					18	=>	qty,
 					19	=>	qty_unit,

data/ext/export/test/test_generics_xls.rb

@@ -0,0 +1,216 @@
+#!/usr/bin/env ruby
+# Odba::Exporter::TestGenericsXls -- oddb -- 22.12.2010 -- mhatakeyama@ywesee.com
+
+$: << File.expand_path('../src', File.dirname(__FILE__))
+$: << File.expand_path('../../../src', File.dirname(__FILE__))
+$: << File.expand_path('../../..', File.dirname(__FILE__))
+
+require 'test/unit'
+require 'flexmock'
+require 'spreadsheet'
+require 'generics_xls'
+require 'date'
+
+module ODDB
+  module OdbaExporter
+    class TestGenericXls < Test::Unit::TestCase
+      include FlexMock::TestCase
+      def setup
+        @loggroup_swiss = LogGroup.new(:swissmedic_journal)
+        @loggroup_swiss.create_log(Date.today)
+        @loggroup_swiss.latest.change_flags = {123 => [:new]}
+        @loggroup_bsv = LogGroup.new(:bsv_sl)
+        @loggroup_bsv.create_log(Date.today)
+        @loggroup_bsv.latest.change_flags = {123 => [:price_cut]}
+
+        flexstub(ODBA.cache) do |cacheobj|
+           cacheobj.should_receive(:fetch_named).and_return do
+             flexmock do |appobj|
+               appobj.should_receive(:log_group).with(:swissmedic_journal).and_return(@loggroup_swiss)
+               appobj.should_receive(:log_group).with(:bsv_sl).and_return(@loggroup_bsv)
+             end
+           end
+        end
+
+        @pac = flexmock('Package') do |pack|
+          pack.should_receive(:basename).and_return("basename")
+          pack.should_receive(:dose).and_return("dose")
+          pack.should_receive(:comparable_size).and_return(111)
+          pack.should_receive(:barcode).and_return("222")
+          pack.should_receive(:pharmacode).and_return(333)
+          pack.should_receive(:name).and_return("name")
+          pack.should_receive(:price_exfactory).and_return(444.444)
+          pack.should_receive(:price_public).and_return(555.555)
+          pack.should_receive(:company_name).and_return("company_name")
+          pack.should_receive(:ikscat).and_return(666)
+          pack.should_receive(:sl_entry).and_return(777)
+          pack.should_receive(:registration_date).and_return(Date.new(2010,12,31))
+          pack.should_receive(:"registration.pointer").and_return(123)
+          pack.should_receive(:pointer).and_return(123)
+          pack.should_receive(:comparables).and_return([@pac])
+          pack.should_receive(:"registration.generic?").and_return(true)
+          pack.should_receive(:public?).and_return(true)
+        end
+
+        @generics_xls = GenericXls.new(".")
+      end
+      def test__remarks1
+        pac = flexstub(Package) do |pack|
+          pack.should_receive(:"registration.pointer").and_return(999)
+          pack.should_receive(:pointer).and_return(999)
+        end
+        assert_nil(@generics_xls._remarks(pac, 'Generikum'))
+      end
+      def test__remarks2
+        expect = "Generikum: neue Registration, Preissenkung"
+        assert_equal(expect, @generics_xls._remarks(@pac, 'Generikum'))
+      end
+      def test_remarks
+        expect = "Original: neue Registration, Preissenkung Generikum: neue Registration, Preissenkung"
+        assert_equal(expect, @generics_xls.remarks(@pac, @pac))
+      end
+      def test_format_price
+        price = nil
+        assert_nil(@generics_xls.format_price(price))
+        price = 12.349
+        assert_equal("12.35", @generics_xls.format_price(price))
+      end
+      def test_preprocess_fields
+        fields = [1,2,3,Date.new(2010, 12, 31)]
+        assert_equal(["1","2","3","31.12.2010"], @generics_xls.preprocess_fields(fields))
+      end
+      def test_format_original
+        expect = ["basename", "basename dose/111", "222", "333", "name", "dose", "111", 
+                  "444.44", "555.55", "company_name", "666", "SL", "31.12.2010"]
+        assert_equal(expect,  @generics_xls.format_original(@pac))
+      end
+      def test_format_generic
+        pac = flexstub(@pac) do |pack|
+          pack.should_receive(:sl_entry).and_return(nil)
+        end
+        expect = ["222", "333", "name", "dose", "111", "444.44", "555.55", "company_name",
+                  "666", "", "31.12.2010"]
+        assert_equal(expect,  @generics_xls.format_generic(pac))
+      end
+      def test_format_row
+        expect = ["basename", "basename dose/111", "222", "333", "name", "dose", "111",
+                  "444.44", "555.55", "company_name", "666", "SL", "31.12.2010", "222",
+                  "333", "name", "dose", "111", "444.44", "555.55", "company_name",
+                  "666", "SL", "31.12.2010", 
+                  "Original: neue Registration, Preissenkung Generikum: neue Registration, Preissenkung"]
+        assert_equal(expect,  @generics_xls.format_row(@pac, @pac))
+      end
+      def assert_row(row)
+        flexstub(Spreadsheet::Excel) do |klass|
+          klass.should_receive(:new).and_return(flexmock{|book|
+            book.should_receive(:add_worksheet).and_return(flexmock{|sheet|
+              sheet.should_receive(:format_column)
+              sheet.should_receive(:write).with(0,0,Array, Spreadsheet::Format)
+              sheet.should_receive(:write).with(1,0,row) # This is the check point
+            })
+          })
+        end
+      end
+      def test_export_generic
+        expect_row = ["", "", "", "", "", "", "", "", "", "", "", "", "", 
+                      "222", "333", "name", "dose", "111", "444.44", "555.55", 
+                      "company_name", "666", "SL", "31.12.2010", 
+                      "Generikum: neue Registration, Preissenkung"]
+        assert_row(expect_row)
+        generics_xls = GenericXls.new(".")
+        assert_equal(2, generics_xls.export_generic(@pac))
+      end
+      def test_export_comparable
+        expect_row =  ["basename", "basename dose/111", "222", "333", "name", 
+                       "dose", "111", "444.44", "555.55", "company_name", "666", 
+                       "SL", "31.12.2010", "222", "333", "name", "dose", "111", 
+                       "444.44", "555.55", "company_name", "666", "SL", "31.12.2010", 
+                       "Original: neue Registration, Preissenkung Generikum: neue Registration, Preissenkung"]
+        assert_row(expect_row)
+        generics_xls = GenericXls.new(".")
+        assert_equal(2, generics_xls.export_comparable(@pac, @pac))
+      end
+      def test_export_comparables
+        expect_row =  ["basename", "basename dose/111", "222", "333", "name", 
+                       "dose", "111", "444.44", "555.55", "company_name", "666", 
+                       "SL", "31.12.2010", "222", "333", "name", "dose", "111", 
+                       "444.44", "555.55", "company_name", "666", "SL", "31.12.2010", 
+                       "Original: neue Registration, Preissenkung Generikum: neue Registration, Preissenkung"]
+        assert_row(expect_row)
+        generics_xls = GenericXls.new(".")
+        assert_equal(2, generics_xls.export_comparable(@pac, @pac))
+ 
+      end
+      def redefine_ODBA(package)
+        # This is a trick code, a little bit different from the flexstub in setup method
+        # That is why I can re-define the ODBA stub.
+        flexstub(ODBA) do |odba|
+          odba.should_receive(:cache).and_return(flexmock{|cache|
+           cache.should_receive(:fetch_named).and_return(flexmock{|app|
+             app.should_receive(:log_group).with(:swissmedic_journal).and_return(@loggroup_swiss)
+             app.should_receive(:log_group).with(:bsv_sl).and_return(@loggroup_bsv)
+             app.should_receive(:each_package).and_yield(package)
+           })
+          })
+        end
+      end
+      def test_export_generics__case_no_output
+        # Note:
+        # if the return value of comparables is not empty (point.1), or
+        # if the return value of registration.generics? is not false (ture) (point.2),
+        # then you have to define the other method in the flexstub(Package),
+        # since export_comparables or export_generic will be called.
+        pac = flexstub(@pac) do |pack|
+          pack.should_receive(:"registration.active?").and_return(true)
+          pack.should_receive(:"registration.original?").and_return(true)
+          pack.should_receive(:comparables).and_return([])                # point.1
+          pack.should_receive(:"registration.generic?").and_return(false) # point.2
+        end
+
+        redefine_ODBA(pac)
+
+        generics_xls = GenericXls.new(".")
+        assert_equal(2, generics_xls.export_generics)
+      end
+      def test_export_generics__case_warning
+        pac = flexstub(@pac) do |pack|
+          pack.should_receive(:"registration.active?").and_return(true)
+          pack.should_receive(:"registration.original?").and_return(true)
+          pack.should_receive(:basename).and_return(nil)      # This is the point
+        end
+
+        redefine_ODBA(pac)
+
+        # Note:
+        # if the following flexstub is not defined,
+        # an actual email will be sent.
+        flexstub(Log) do |log|
+          log.should_receive(:new)
+        end
+
+        generics_xls = GenericXls.new(".")
+        assert_raise(NoMethodError) do    # This means the report process runs if this assert passes
+          generics_xls.export_generics
+        end
+      end
+      def test_export_generics__case_export
+        pac = flexstub(@pac) do |pack|
+          pack.should_receive(:"registration.active?").and_return(true)
+          pack.should_receive(:"registration.original?").and_return(true)
+          pack.should_receive(:comparables).and_return([]) 
+          pack.should_receive(:basename).and_return("basename")          # This is the point
+          pack.should_receive(:"registration.generic?").and_return(true) # This is the point
+          pack.should_receive(:"registration.pointer").and_return(123)
+        end
+
+        redefine_ODBA(pac)
+
+        # Note:
+        # The actual row value (data) is not checked here,
+        # since it is tested in test_export_generic.
+        generics_xls = GenericXls.new(".")
+        assert_equal(3, generics_xls.export_generics)
+      end
+   end
+  end
+end

data/ext/export/test/test_oddbdat.rb

@@ -0,0 +1,880 @@
+#!/usr/bin/env ruby
+# ODDB::OdbaExporter::TestTable, TestLine -- oddb -- 03.02.2011 -- mhatakeyama@ywesee.com
+
+$: << File.expand_path('../src', File.dirname(__FILE__))
+$: << File.expand_path('../../../src', File.dirname(__FILE__))
+$: << File.expand_path('../../..', File.dirname(__FILE__))
+$: << File.expand_path('../../../test', File.dirname(__FILE__))
+
+require 'stub/odba'
+require 'test/unit'
+require 'flexmock'
+require 'oddbdat'
+require 'model/package'
+require 'model/text'
+require 'date'
+
+
+# This definition is called in TestMCMTable
+class String
+  def src
+    self + ".src"
+  end
+end
+
+module ODDB
+  module OdbaExporter
+    DATE = Date.today.strftime("%Y%m%d%H%M%S")
+    # Tests for *Line classes
+    class TestLine < Test::Unit::TestCase
+      Line::LENGTH = 3
+      def setup
+        @line = Line.new
+      end
+      def test_content
+        assert_equal([], @line.content(nil))
+        structure = {1=>"1", 2=>"2", 3=>"3"}
+        assert_equal(["1", "2", "3"], @line.content(structure))
+      end
+      def test_empty?
+        assert_equal(true, @line.empty?)
+      end
+      def test_structure
+        assert_equal(nil, @line.structure)
+      end
+      def test_to_s
+        assert_equal('', @line.to_s)
+      end
+    end
+    class TestAcLine < Test::Unit::TestCase
+      include FlexMock::TestCase
+      def setup
+        @package = ODDB::Package.new('12')
+        @registration = flexmock('registration') do |mock|
+          mock.should_receive(:generic_type).and_return(:generic)
+          #mock.should_receive(:registration_date).and_return(Date.today)
+          mock.should_receive(:registration_date).and_return(Date.new(2011,2,3))
+        end
+        @package.sequence = flexmock('sequence') do |seq|
+          seq.should_receive(:registration).and_return @registration
+          seq.should_receive(:iksnr).and_return('12345')
+        end
+        @package.create_sl_entry 
+        @package.sl_entry.limitation = 'limitation'
+        @package.sl_entry.limitation_points = 5
+        flexstub(@package).should_receive(:oid).and_return(123)
+        flexstub(Date).should_receive(:"today.strftime").and_return('20110203000000')
+        @acline = AcLine.new(@package)
+      end
+      def test_generic_code
+        assert_equal('Y', @acline.generic_code(@registration))
+      end
+      def test_iks_date
+        expected = '20110203'
+        assert_equal(expected, @acline.iks_date(@registration))
+      end
+      def test_ikskey
+        assert_equal('12345012', @acline.ikskey)
+      end
+      def test_inscode
+        assert_equal('1', @acline.inscode)
+      end
+      def test_limitation
+        assert_equal('Y', @acline.limitation)
+      end
+      def test_limitation_points
+        assert_equal(5, @acline.limitation_points)
+      end
+      def test_structure
+        expected = {
+          1 =>"01",
+          2 =>"20110203000000",
+          3 =>"1",
+          4 =>123,
+          5 =>"4",
+          7 =>"12345012",
+          14=>nil,
+          20=>"Y",
+          22=>"20110203",
+          29=>"3",
+          32=>nil,
+          39=>"1",
+          40=>"Y",
+          41=>5,
+          47=>nil,
+        }
+
+        # test
+        assert_equal(expected.sort, @acline.structure.sort)
+      end
+    end
+    class TestAccompLine < Test::Unit::TestCase
+      include FlexMock::TestCase
+      def test_structure
+        package = ODDB::Package.new('12')
+        flexstub(package).should_receive(:oid).and_return(123)
+        registration = flexmock('registration') do |mock|
+          mock.should_receive(:company).and_return(flexmock('compay') do |comp|
+            comp.should_receive(:oid).and_return(111)
+          end)
+        end
+        package.sequence = flexmock('sequence') do |seq|
+          seq.should_receive(:registration).and_return registration
+          seq.should_receive(:iksnr).and_return('12345')
+        end
+        flexstub(Date).should_receive(:"today.strftime").and_return('20110203000000')
+        @accompline = AccompLine.new(package)
+        expected = {
+          1=>"19", 
+          2=>"20110203000000", 
+          3=>123, 
+          4=>111,
+          5=>"H", 
+          6=>"4", 
+        }
+        assert_equal(expected.sort, @accompline.structure.sort)
+      end
+    end
+    class TestAcLimLine < Test::Unit::TestCase
+      include FlexMock::TestCase
+      def test_structure
+        flexstub(Date).should_receive(:"today.strftime").and_return('20110203000000')
+        @aclimline = AcLimLine.new(111, 222, 333)
+        expected = {
+          1=>"09", 
+          2=>"20110203000000", 
+          3=>111, 
+          4=>333,
+          5=>222, 
+          6=>"4", 
+        }
+        assert_equal(expected.sort, @aclimline.structure.sort)
+      end
+    end
+    class TestAcnamLine < Test::Unit::TestCase
+      include FlexMock::TestCase
+      def setup
+        @package = ODDB::Package.new('12')
+        @package.sequence = flexmock('sequence') do |seq|
+          seq.should_receive(:galenic_forms).and_return(['galenic_forms'])
+          seq.should_receive(:dose).and_return(flexmock('dose') do |dose|
+            dose.should_receive(:is_a?).and_return(true)
+            dose.should_receive(:qty).and_return('qty')
+            dose.should_receive(:unit).and_return('unit')
+          end)
+          seq.should_receive(:name).and_return('name')
+          seq.should_receive(:name_base).and_return('name_base')
+          seq.should_receive(:name_descr).and_return('name_descr')
+        end
+        flexstub(Date).should_receive(:"today.strftime").and_return('20110203000000')
+      end
+      def test_structure__package_parts_nil_case
+        flexstub(@package) do |pack|
+          pack.should_receive(:oid).and_return(123)
+          pack.should_receive(:commercial_forms).and_return(['commercial_forms'])
+          pack.should_receive(:"comparable_size.qty").and_return('comparable_size.qty')
+          pack.should_receive(:parts).and_return([])
+        end
+
+        @acnamline = AcnamLine.new(@package)
+        expected = {
+          1=>"03",
+          2=>"20110203000000",
+          3=>"1",
+          4=>123,
+          5=>"D",
+          6=>"4",
+          7=>"name",
+          8=>"name_base",
+          9=>"name_descr",
+          11=>"galenic_forms",
+          12=>"qty",
+          13=>"unit",
+          16=>"",
+          17=>"commercial_forms",
+          18=>"comparable_size.qty",
+          19=>"commercial_forms",
+        }
+        assert_equal(expected.sort, @acnamline.structure.sort)
+      end
+      def test_structure__package_parts_not_nil_case
+        count = 0
+        part = flexmock('part') do |mock|
+          mock.should_receive(:measure).and_return(count+=1)
+          mock.should_receive(:multi).and_return('multi')
+        end
+        parts = [part, part, part]
+        flexstub(@package) do |pack|
+          pack.should_receive(:oid).and_return(123)
+          pack.should_receive(:commercial_forms).and_return(['commercial_forms'])
+          pack.should_receive(:"comparable_size.qty").and_return('comparable_size.qty')
+          pack.should_receive(:parts).and_return(parts)
+        end
+
+        @acnamline = AcnamLine.new(@package)
+        expected = {
+          1=>"03",
+          2=>"20110203000000",
+          3=>"1",
+          4=>123,
+          5=>"D",
+          6=>"4",
+          7=>"name",
+          8=>"name_base",
+          9=>"name_descr",
+          11=>"galenic_forms",
+          12=>"qty",
+          13=>"unit",
+          16=>"multi",
+          17=>"commercial_forms",
+          18=>"comparable_size.qty",
+          19=>"commercial_forms",
+        }
+        assert_equal(expected.sort, @acnamline.structure.sort)
+      end
+    end
+    class TestAcmedLine < Test::Unit::TestCase
+      include FlexMock::TestCase
+      def test_structure
+        flexstub(Date).should_receive(:"today.strftime").and_return('20110203000000')
+        package = ODDB::Package.new('12')
+        flexstub(package) do |pack|
+          pack.should_receive(:oid).and_return(123)
+          pack.should_receive(:fachinfo).and_return(flexmock('fachinfo') do |fach|
+            fach.should_receive(:oid).and_return('fachinfo.oid')
+          end)
+        end
+        package.sequence = flexmock('sequence') do |seq|
+          seq.should_receive(:atc_class).and_return(flexmock('atc_class') do |atc|
+            atc.should_receive(:code).and_return('atc.code')
+          end)
+          seq.should_receive(:galenic_forms).and_return(flexmock('galenic_forms') do |gal|
+            gal.should_receive(:first).and_return(flexmock('galform') do |form|
+              form.should_receive(:oid).and_return('galform.oid')
+            end)
+          end)
+        end
+                                      
+        @acmedline = AcmedLine.new(package)
+        expected = {
+          1=>"02",
+          2=>"20110203000000",
+          3=>"1",
+          4=>123,
+          5=>"4",
+          7=>"fachinfo.oid",
+          10=>"atc.code",
+          12=>"galform.oid",
+        }
+        assert_equal(expected.sort, @acmedline.structure.sort)
+      end
+    end
+    class TestAcOddbLine < Test::Unit::TestCase
+      include FlexMock::TestCase
+      def test_structure
+        package = ODDB::Package.new('12')
+        flexstub(package).should_receive(:oid).and_return(123)
+        package.pharmacode = 223
+        @acoddbline = AcOddbLine.new(package)
+        expected = {
+          1 => 123,
+          2 => "223"
+        }
+        assert_equal(expected.sort, @acoddbline.structure.sort)
+      end
+    end
+    class TestAcpricealgPublicLine < Test::Unit::TestCase
+      include FlexMock::TestCase
+      def setup
+        @package = ODDB::Package.new('12')
+        @package.price_public = 123.45
+        flexstub(@package).should_receive(:oid).and_return(123)
+        flexstub(Date).should_receive(:"today.strftime").and_return('20110203000000')
+        @acpriceline = AcpricealgPublicLine.new(@package)
+      end
+      def test_price_public_type
+        assert_equal('PPUB', @acpriceline.price_public_type)
+        @package.create_sl_entry
+        assert_equal('PSL2', @acpriceline.price_public_type)
+      end
+      def test_structure
+        expected = {
+          1=>"07", 
+          2=>"20110203000000", 
+          3=>123, 
+          4=>"PPUB",
+          5=>"4", 
+          6=>"123.45", 
+        }
+        assert_equal(expected.sort, @acpriceline.structure.sort)
+      end
+   end
+    class TestAcpricealgExfactoryLine < Test::Unit::TestCase
+      include FlexMock::TestCase
+      def test_structure
+        package = ODDB::Package.new('12')
+        flexstub(package).should_receive(:oid).and_return(123)
+        package.price_exfactory = 123.45
+        flexstub(Date).should_receive(:"today.strftime").and_return('20110203000000')
+        @acpriceline = AcpricealgExfactoryLine.new(package)
+        expected = {
+          1=>"07", 
+          2=>"20110203000000", 
+          3=>123, 
+          4=>"PSL1",
+          5=>"4", 
+          6=>"123.45", 
+        }
+        assert_equal(expected.sort, @acpriceline.structure.sort)
+      end
+    end
+    class TestAcscLine < Test::Unit::TestCase
+      include FlexMock::TestCase
+      def test_structure
+        # test nil case
+        package = ODDB::Package.new('12')
+        @acscline = AcscLine.new(package, nil, 'count')
+        assert_equal(nil, @acscline.structure)
+
+        # test not nil case
+        flexstub(package).should_receive(:oid).and_return(123)
+        active_agent = flexmock('active_agent') do |act|
+          act.should_receive(:dose).and_return(flexmock('dose') do |dose|
+            dose.should_receive(:is_a?).and_return(true)
+            dose.should_receive(:qty).and_return('qty')
+            dose.should_receive(:unit).and_return('unit')
+          end)
+          act.should_receive(:substance).and_return(flexmock('oid') do |oid|
+            oid.should_receive(:oid).and_return('oid')
+          end)
+        end
+        flexstub(Date).should_receive(:"today.strftime").and_return('20110203000000')
+        @acscline =AcscLine.new(package, active_agent, 223)
+
+        expected = {
+          1=>"41",
+          2=>"20110203000000",
+          3=>123,
+          4=>223,
+          5=>"4",
+          6=>"oid",
+          7=>"qty",
+          8=>"unit",
+          9=>"W",
+        }
+        assert_equal(expected.sort, @acscline.structure.sort)
+      end
+    end
+    class TestAtcLine < Test::Unit::TestCase
+      include FlexMock::TestCase
+      def test_structure
+        # test nil case
+        @atcline = AtcLine.new(nil)
+        assert_equal(nil, @atcline.structure)
+
+        # test not nil case
+        atcclass = flexmock('atcclass') do |atc|
+          atc.should_receive(:code).and_return('code')
+          atc.should_receive(:description).and_return('description')
+        end
+        flexstub(Date).should_receive(:"today.strftime").and_return('20110203000000')
+        @atcline = AtcLine.new(atcclass)
+        expected = {
+          1=>"11",
+          2=>"20110203000000",
+          3=>"8",
+          4=>"code",
+          5=>"D",
+          6=>"4",
+          7=>"description",
+        }
+        assert_equal(expected, @atcline.structure)
+      end
+    end
+    class TestCompLine < Test::Unit::TestCase
+      include FlexMock::TestCase
+      def test_structure
+        company = flexmock('company') do |comp|
+          comp.should_receive(:oid).and_return('oid')
+          comp.should_receive(:ean13).and_return('ean13')
+          comp.should_receive(:name).and_return('name')
+          comp.should_receive(:address_email).and_return('address_email')
+          comp.should_receive(:url).and_return('url')
+          comp.should_receive(:address).and_return(flexmock('addr') do |addr|
+            addr.should_receive(:address).and_return('address')
+            addr.should_receive(:plz).and_return('plz')
+            addr.should_receive(:city).and_return('city')
+            addr.should_receive(:"fon.first").and_return('fon.first')
+            addr.should_receive(:"fax.first").and_return('fax.first')
+          end)
+        end
+        flexstub(Date).should_receive(:"today.strftime").and_return('20110203000000')
+        @compline = CompLine.new(company)
+        expected = {
+          1=>"12",
+          2=>"20110203000000",
+          3=>"oid",
+          4=>"4",
+          5=>"ean13",
+          7=>"name",
+          8=>"address",
+          9=>"CH",
+          10=>"plz",
+          11=>"city",
+          13=>"fon.first",
+          15=>"fax.first",
+          16=>"address_email",
+          17=>"url",
+        }
+        assert_equal(expected.sort, @compline.structure.sort)
+      end
+    end
+    class TestEanLine < Test::Unit::TestCase
+      include FlexMock::TestCase
+      def setup
+        packclass = flexmock('package') do |pack|
+          pack.should_receive(:new).and_return(flexmock do |mock|
+            mock.should_receive(:oid).and_return('oid')
+            mock.should_receive(:barcode).and_return('barcode')
+          end)
+        end
+        @package = packclass.new
+        flexstub(Date).should_receive(:"today.strftime").and_return('20110203000000')
+      end
+      def test_barcode
+        @eanline = EanLine.new(@package)
+        assert_equal('barcode', @eanline.barcode)
+      end
+      def test_structure
+        @eanline = EanLine.new(@package)
+        expected = {
+          1=>"06", 
+          2=>"20110203000000", 
+          3=>"oid", 
+          4=>"E13",
+          5=>"barcode", 
+          6=>"4", 
+        }
+        assert_equal(expected, @eanline.structure)
+      end
+    end
+    class TestGalenicFormLine < Test::Unit::TestCase
+      include FlexMock::TestCase
+      def test_structure
+        galenic_form = flexmock('galenic_form') do |gal|
+          gal.should_receive(:oid).and_return('oid')
+          gal.should_receive(:to_s).and_return('to_s')
+        end
+        @galenicline = GalenicFormLine.new(galenic_form)
+        expected = {
+          1=>"11", 
+          2=>DATE, 
+          3=>"5", 
+          4=>"oid",
+          5=>"D", 
+          6=>"4", 
+          7=>"to_s", 
+        }
+        assert_equal(expected.sort, @galenicline.structure.sort)
+      end
+    end
+    class TestScLine < Test::Unit::TestCase
+      include FlexMock::TestCase
+      def test_structure
+        package = ODDB::Package.new('12')
+        substance = flexmock('substance') do |sub|
+          sub.should_receive(:oid).and_return('oid')
+        end
+        flexstub(Date).should_receive(:"today.strftime").and_return('20110203000000')
+        @scline = ScLine.new(package, substance)
+        expected = {
+          1=>"40",
+          2=>"20110203000000",
+          3=>"oid",
+          4=>"L",
+          5=>"4",
+          6=>substance,
+        }
+        assert_equal(expected.sort, @scline.structure.sort)
+      end
+    end
+    class TestLimitationLine < Test::Unit::TestCase
+      include FlexMock::TestCase
+      def test_structure
+        flexstub(Date).should_receive(:"today.strftime").and_return('20110203000000')
+        @limitationline = LimitationLine.new('lim_oid')
+        expected = {
+          1=>"16", 
+          2=>"20110203000000", 
+          3=>"lim_oid",
+          5=>"4", 
+          6=>"COM", 
+        }
+        assert_equal(expected.sort, @limitationline.structure.sort)
+      end
+    end
+    class TestLimTxtLine < Test::Unit::TestCase
+      include FlexMock::TestCase
+      def test_structure
+        flexstub(Date).should_receive(:"today.strftime").and_return('20110203000000')
+        @limtxtline = LimTxtLine.new('lim_oid', 'language', 'txt')
+        expected = {
+          1=>"10", 
+          2=>"20110203000000", 
+          3=>"lim_oid", 
+          4=>"language",
+          5=>"4", 
+          6=>"txt", 
+        }
+        assert_equal(expected.sort, @limtxtline.structure.sort)
+      end
+    end
+    class TestMCMLine < Test::Unit::TestCase
+      include FlexMock::TestCase
+      def test_structure
+        flexstub(Date).should_receive(:"today.strftime").and_return('20110203000000')
+        @mcmline = MCMLine.new('fi_oid', 'line_nr', 'language', 'text')
+        expected = {
+          1=>"31",
+          7=>"text",
+          2=>"20110203000000",
+          3=>"fi_oid",
+          4=>"L",
+          5=>"line_nr",
+          6=>"4",
+        }
+        assert_equal(expected.sort, @mcmline.structure.sort)
+      end
+    end
+
+    # Tests for *Table classes
+    class TestTable < Test::Unit::TestCase
+      Table::FILENAME = 'table'
+      def test_filename
+        table = Table.new
+        assert_equal('table', table.filename)
+      end
+    end
+    class TestAcTable < Test::Unit::TestCase
+      include FlexMock::TestCase
+      def test_lines
+        flexstub(AcLine).should_receive(:new).and_return('acline')
+        @actable = AcTable.new
+        assert_equal(['acline'], @actable.lines('package'))
+      end
+    end
+    class TestAccompTable < Test::Unit::TestCase
+      include FlexMock::TestCase
+      def test_lines
+        flexstub(AccompLine).should_receive(:new).and_return('accompline')
+        @accomptable = AccompTable.new
+        assert_equal(['accompline'], @accomptable.lines('package'))
+      end
+    end
+    class TestAcLimTable < Test::Unit::TestCase
+      include FlexMock::TestCase
+      def test_lines
+        # test package.sl_entry == nil calse
+        package = ODDB::Package.new('12')
+        @aclimtable = AcLimTable.new
+        assert_equal([], @aclimtable.lines(package))
+
+        # test not nil case
+        ## preparation
+        package.create_sl_entry
+        package.sl_entry.create_limitation_text
+        paragraphs = [1,2]
+        chap = flexmock('chap') do |chap|
+          chap.should_receive(:paragraphs).and_return(flexmock('paragraphs') do |para|
+            para.should_receive(:each_with_index).and_yield(paragraphs)
+          end)
+        end
+        package.sl_entry.limitation_text.descriptions[0] = chap
+        ## test 
+        flexstub(AcLimLine).should_receive(:new).with(1,2,1002).and_return('aclimline')
+        assert_equal(['aclimline'], @aclimtable.lines(package))
+      end
+    end
+    class TestAcmedTable < Test::Unit::TestCase
+      include FlexMock::TestCase
+      def test_lines
+        flexstub(AcmedLine).should_receive(:new).and_return('acmedline')
+        @acmedtable = AcmedTable.new
+        assert_equal(['acmedline'], @acmedtable.lines('package'))
+      end
+    end
+    class TestAcnamTable < Test::Unit::TestCase
+      include FlexMock::TestCase
+      def test_lines
+        flexstub(AcnamLine).should_receive(:new).and_return('acnamline')
+        @acnamtable = AcnamTable.new
+        assert_equal(['acnamline'], @acnamtable.lines('package'))
+      end
+    end
+    class TestAcOddbTable < Test::Unit::TestCase
+      include FlexMock::TestCase
+      def test_lines
+        # test package.pharmacode nil case
+        package = ODDB::Package.new('12')
+        @acoddbtable = AcOddbTable.new
+        assert_equal([], @acoddbtable.lines(package))
+
+        # test not nil case
+        package.pharmacode = 123
+        flexstub(AcOddbLine).should_receive(:new).and_return('acoddbline')
+        assert_equal(['acoddbline'], @acoddbtable.lines(package))
+      end
+    end
+    class TestAcpricealgTable < Test::Unit::TestCase
+      include FlexMock::TestCase
+      def test_lines
+        flexstub(AcpricealgPublicLine).should_receive(:new).and_return('acpricepublic')
+        flexstub(AcpricealgExfactoryLine).should_receive(:new).and_return('acpriceexfactory')
+        @acpricetable = AcpricealgTable.new 
+        assert_equal(["acpricepublic", "acpriceexfactory"], @acpricetable.lines('package'))
+      end
+    end
+    class TestAcscTable < Test::Unit::TestCase
+      include FlexMock::TestCase
+      def test_lines
+        active_agents = ['act']
+        package = flexmock('package') do |pack|
+          pack.should_receive(:active_agents).and_return(active_agents)
+        end
+
+        # test
+        flexstub(AcscLine).should_receive(:new).with(package, 'act',  0).and_return('acscline')
+        @acsctable = AcscTable.new
+        assert_equal(['acscline'], @acsctable.lines(package))
+      end
+    end
+    class TestLimitationTable < Test::Unit::TestCase
+      include FlexMock::TestCase
+      def test_lines
+        # test package.sl_entry nil case
+        package = ODDB::Package.new('12')
+        @limitationtable = LimitationTable.new
+        assert_equal([], @limitationtable.lines(package))
+
+        # test not nil case
+        package.create_sl_entry
+        package.sl_entry.create_limitation_text
+        paragraphs = ['par']
+        chap = flexmock('chap') do |cha|
+          cha.should_receive(:paragraphs).and_return(paragraphs)
+        end
+        package.sl_entry.limitation_text.descriptions[0] = chap
+        flexstub(package).should_receive(:oid).and_return(123)
+
+        # test
+        flexstub(LimitationLine).should_receive(:new).with(123000).and_return('limitationline')
+        assert_equal(['limitationline'], @limitationtable.lines(package))
+      end
+    end
+    class TestLimTxtTable < Test::Unit::TestCase
+      include FlexMock::TestCase
+      def test_lines
+        # test package.sl_entry nil case
+        package = ODDB::Package.new('12')
+        @limtxttable = LimTxtTable.new
+        assert_equal([], @limtxttable.lines(package))
+
+        # test not nil case
+        package.create_sl_entry
+        package.sl_entry.create_limitation_text
+        flexstub(package).should_receive(:oid).and_return(123)
+        paragraph  = flexmock('par') do |par|
+          par.should_receive(:text).and_return('text')
+        end
+        paragraphs = [paragraph]
+        chap = flexmock('chap') do |cha|
+          cha.should_receive(:paragraphs).and_return(paragraphs)
+        end
+        package.sl_entry.limitation_text.descriptions['lang'] = chap
+
+        # test
+        flexstub(LimTxtLine).should_receive(:new).with(123000, 'L', 'text').and_return('limtxtline')
+        assert_equal(['limtxtline'], @limtxttable.lines(package))
+      end
+    end
+    class TestEanTable < Test::Unit::TestCase
+      include FlexMock::TestCase
+      def test_lines
+        flexstub(EanLine).should_receive(:new).and_return('eanline')
+        @eantable = EanTable.new
+        assert_equal(['eanline'], @eantable.lines('package'))
+      end
+    end
+    # The following constants are necessary for TestMCMTable
+    ODDB::Text::ImageLink = 'imagelink'
+    ODDB::Text::Table = 'table'
+    SERVER_NAME = 'server_name/'
+    class TestMCMTable < Test::Unit::TestCase
+      include FlexMock::TestCase
+      def setup
+        @mcmtable = MCMTable.new
+      end
+      def test_lines
+        # test fi.description empty case
+        fi = flexmock('fi') do |f|
+          f.should_receive(:descriptions).and_return([])
+        end
+        assert_equal([], @mcmtable.lines(fi))
+
+        # test not empty case
+        flexstub(MCMLine).should_receive(:new).and_return('mcmline')
+        chapter = flexmock('chapter') do |chap|
+          chap.should_receive(:heading).and_return('')
+          chap.should_receive(:sections).and_return([])
+        end
+        doc = flexmock('doc') do |d|
+          d.should_receive(:each_chapter).and_yield(chapter)
+        end
+        fi = flexmock('fi') do |f|
+          f.should_receive(:descriptions).and_return({'lang', doc})
+          f.should_receive(:oid).and_return('oid')
+        end
+        assert_equal(['mcmline'], @mcmtable.lines(fi))
+      end
+      def test_format_lines__sections_empty
+        chapter = flexmock('chapter') do |chap|
+          chap.should_receive(:heading).and_return('')
+          chap.should_receive(:sections).and_return([])
+        end
+
+        assert_equal('', @mcmtable.format_line(chapter))
+      end
+      def test_format_lines__sections_not_empty
+        format = flexmock('format') do |form|
+          form.should_receive(:italic?).and_return(true)
+          form.should_receive(:range).and_return(0..7)
+        end
+        paragraph = flexmock('paragraph') do |par|
+          par.should_receive(:text).and_return('par.text')
+          par.should_receive(:formats).and_return([format])
+          par.should_receive(:preformatted?).and_return(true)
+        end
+        section = flexmock('section') do |sec|
+          sec.should_receive(:subheading).and_return('subhead')
+          sec.should_receive(:paragraphs).and_return([paragraph])
+        end
+        chapter = flexmock('chapter') do |chap|
+          chap.should_receive(:heading).and_return('head')
+          chap.should_receive(:sections).and_return([section])
+        end
+
+        # test
+        expected = "<BI>head<E><P><I>subhead<E><I>par.text<E><P>"
+        assert_equal(expected, @mcmtable.format_line(chapter))
+      end
+      def test_format_lines__ImageLink
+        section = flexmock('section') do |sec|
+          sec.should_receive(:subheading).and_return('subhead')
+          sec.should_receive(:paragraphs).and_return([ODDB::Text::ImageLink])
+        end
+        chapter = flexmock('chapter') do |chap|
+          chap.should_receive(:heading).and_return('head')
+          chap.should_receive(:sections).and_return([section])
+        end
+
+        # test
+        expected = "<BI>head<E><P><I>subhead<E><IMG src='http://server_name/imagelink.src'/>"
+        assert_equal(expected, @mcmtable.format_line(chapter))
+      end
+      def test_format_lines__Table
+        section = flexmock('section') do |sec|
+          sec.should_receive(:subheading).and_return('subhead')
+          sec.should_receive(:paragraphs).and_return([ODDB::Text::Table])
+        end
+        chapter = flexmock('chapter') do |chap|
+          chap.should_receive(:heading).and_return('head')
+          chap.should_receive(:sections).and_return([section])
+        end
+
+        # test
+        expected = "<BI>head<E><P><I>subhead<E><N>table<E>"
+        assert_equal(expected, @mcmtable.format_line(chapter))
+      end
+    end
+    # the followings are necessary for TestCodesTable
+    AtcClass = 'atcclass'
+    GalenicForm = 'galenicform'
+    class TestCodesTable < Test::Unit::TestCase
+      include FlexMock::TestCase
+      def setup
+        flexstub(AtcLine).should_receive(:new).and_return('atcline')
+        flexstub(GalenicFormLine).should_receive(:new).and_return('galenicformline')
+        @codestable = CodesTable.new
+      end
+      def test_atclines
+        assert_equal(['atcline'], @codestable.atclines('atcclass'))
+      end
+      def test_gallines
+        assert_equal(['galenicformline'], @codestable.gallines('galform'))
+      end
+      def test_lines
+        assert_equal(['atcline'], @codestable.lines(AtcClass))
+        assert_equal(['galenicformline'], @codestable.lines(GalenicForm))
+      end
+    end
+    class TestScTable < Test::Unit::TestCase
+      include FlexMock::TestCase
+      def test_lines
+        flexstub(ScLine).should_receive(:new).and_return('scline')
+        @sctable = ScTable.new
+        assert_equal(['scline'], @sctable.lines('substance'))
+      end
+    end
+    class TestCompTable < Test::Unit::TestCase
+      include FlexMock::TestCase
+      def test_lines
+        flexstub(CompLine).should_receive(:new).and_return('compline')
+        @comptable = CompTable.new
+        assert_equal(['compline'], @comptable.lines('company'))
+      end
+    end
+    class TestReadme < Test::Unit::TestCase
+      def test_lines
+        expected = <<-EOS
+	oddbdat.tar.gz und oddbdat.zip enthalten die täglich aktualisierten Artikelstammdaten der ODDB. Die Daten werden von ywesee in das OddbDat-Format umgewandelt und allen gewünschten Systemlieferanten von Schweizer Spitälern zur Verfügung gestellt.
+
+	Feedback bitte an zdavatz@ywesee.com
+
+	-AC (Tabelle 1) - ODDB-Code
+	-ACMED (Tabelle 2) - Weitere Produktinformationen
+	-ACNAM (Tabelle 3) - Sprachen
+	-ACBARCODE (Tabelle 6) - EAN-Artikelcode
+	-ACPRICEALG (Tabelle 7) - Preise
+	-ACLIM (Tabelle 9) - Limitationen
+	-LIMTXT (Tabelle 10) - Limitationstexte
+	-CODES (Tabelle 11) - Codebeschreibungen (ATC-Beschreibung, Galenische Form)
+	-COMP (Tabelle 12) - Hersteller
+	-LIMITATION (Tabelle 16) - Limitationen der SL
+	-ACCOMP (Tabelle 19) - Verbindungstabelle zwischen AC und COMP
+	-SC (Tabelle 40) - Substanzen
+	-ACSC (Tabelle 41) - Verbindungstabelle zwischen AC und SC
+	-ACODDB (Tabelle 99) - Verbindungstabelle zwischen ODDB-ID und Pharmacode
+
+	Folgende Tabelle mit den Fachinformationen steht wegen ihrer Grösse separat als tar.gz- oder zip-Download zur Verfügung.
+
+	-MCM (Tabelle 31)	- Fachinformationen
+
+	Die Daten werden als oddbdat.tar.gz und oddbdat.zip auf unserem Server bereitgestellt - Vorzugsweise benutzen Sie einen der folgenden direkten Links.
+
+	Ganze Packages (ohne Fachinformationen):
+	http://www.oddb.org/resources/downloads/oddbdat.tar.gz
+	http://www.oddb.org/resources/downloads/oddbdat.zip
+
+	Nur Fachinformationen (sehr grosse Dateien):
+	http://www.oddb.org/resources/downloads/s31x.tar.gz
+	http://www.oddb.org/resources/downloads/s31x.zip
+
+
+        EOS
+        assert_equal(expected, Readme.new.lines)
+      end
+    end
+
+  end
+end
+