de.oddb 2.0.0

data/test/import/data/xml/ATC_2006_ddd.xml

@@ -0,0 +1,35 @@
+<xml xmlns:s='uuid:BDC6E3F0-6DA3-11d1-A2A3-00AA00C14882'
+	xmlns:dt='uuid:C2F41010-65B3-11d1-A29F-00AA00C14882'
+	xmlns:rs='urn:schemas-microsoft-com:rowset'
+	xmlns:z='#RowsetSchema'>
+<s:Schema id='RowsetSchema'>
+	<s:ElementType name='row' content='eltOnly' rs:updatable='true'>
+		<s:AttributeType name='ATCCode' rs:number='1' rs:nullable='true' rs:writeunknown='true' rs:basecatalog='ATC'
+			 rs:basetable='#t1' rs:basecolumn='ATCCode'>
+			<s:datatype dt:type='string' rs:dbtype='str' dt:maxLength='10'/>
+		</s:AttributeType>
+		<s:AttributeType name='DDD' rs:number='2' rs:nullable='true' rs:writeunknown='true' rs:basecatalog='ATC' rs:basetable='#t1'
+			 rs:basecolumn='DDD'>
+			<s:datatype dt:type='string' rs:dbtype='str' dt:maxLength='20'/>
+		</s:AttributeType>
+		<s:AttributeType name='UnitType' rs:number='3' rs:nullable='true' rs:writeunknown='true' rs:basecatalog='ATC'
+			 rs:basetable='#t1' rs:basecolumn='UnitType'>
+			<s:datatype dt:type='string' rs:dbtype='str' dt:maxLength='255'/>
+		</s:AttributeType>
+		<s:AttributeType name='AdmCode' rs:number='4' rs:nullable='true' rs:writeunknown='true' rs:basecatalog='ATC'
+			 rs:basetable='#t1' rs:basecolumn='AdmCode'>
+			<s:datatype dt:type='string' rs:dbtype='str' dt:maxLength='255'/>
+		</s:AttributeType>
+		<s:AttributeType name='DDDComment' rs:number='5' rs:nullable='true' rs:writeunknown='true' rs:basecatalog='ATC'
+			 rs:basetable='#t1' rs:basecolumn='DDDComment'>
+			<s:datatype dt:type='string' rs:dbtype='str' dt:maxLength='255'/>
+		</s:AttributeType>
+		<s:extends type='rs:rowbase'/>
+	</s:ElementType>
+</s:Schema>
+<rs:data>
+	<z:row ATCCode='A01AB02' DDD='60' UnitType='mg' AdmCode='O'/>
+	<z:row ATCCode='A10BB01' DDD='7' UnitType='mg' AdmCode='O' DDDComment='mikrokristall. Substanz'/>
+	<z:row ATCCode='A10BB01' DDD='10' UnitType='mg' AdmCode='O'/>
+</rs:data>
+</xml>

data/test/import/test_dimdi.rb

@@ -0,0 +1,323 @@
+#!/usr/bin/env ruby
+# Import::TestDimdi -- de.oddb.org -- 04.09.2006 -- hwyss@ywesee.com
+
+$: << File.expand_path('..', File.dirname(__FILE__))
+$: << File.expand_path('../../lib', File.dirname(__FILE__))
+
+require 'test/unit'
+require 'oddb/import/dimdi'
+require 'stub/model'
+require 'flexmock'
+
+module ODDB
+  module Import
+    class TestDimdi < Test::Unit::TestCase
+      include FlexMock::TestCase
+      def setup
+        @config = flexstub(ODDB.config)
+        @var = File.expand_path('var', File.dirname(__FILE__))
+        @data_dir = File.expand_path('data', File.dirname(__FILE__))
+        @xls_dir = File.join(@var, 'xls')
+        FileUtils.rm_r(@xls_dir) if(File.exist?(@xls_dir))
+        @config.should_receive(:var).and_return(@var)
+      end
+      def set_time_temporarily(year, month)
+        flexstub(Time) do |timeclass|
+          timeclass.should_receive(:now).and_return do
+            flexmock do |nowobj|
+              nowobj.should_receive(:month).and_return(month)
+              nowobj.should_receive(:year).and_return(year)
+            end
+          end
+        end
+      end
+      def test_download_path
+        set_time_temporarily(2010, 4)
+        download_path = "http://www.dimdi.de/dynamic/de/amg/fbag/downloadcenter/2010/2-quartal/"
+        assert_equal(download_path, Dimdi.download_path)
+      end
+      def test_download_path2
+        set_time_temporarily(2009, 3)
+        download_path = "http://www.dimdi.de/dynamic/de/amg/fbag/downloadcenter/2009/1-quartal/"
+        assert_equal(download_path, Dimdi.download_path)
+      end
+      def test_current_date
+        path = File.join(@data_dir, 'html', 'dimdi_index.html')
+        assert_equal(Date.new(2010,4), Dimdi.current_date(path))
+      end
+      def test_download_latest__only_once
+        today = Date.new(2006,10)
+        file = "liste_zuzahlungsbefreite_arzneimittel_suchfunktion.xls"
+        path = File.join(@xls_dir, file)
+        arch = File.join(@xls_dir, sprintf("2006.10.01-%s", file))
+        zuzahlung = "http://www.die-gesundheitsreform.de/presse/pressethemen/avwg/pdf/liste_zuzahlungsbefreite_arzneimittel_suchfunktion.xls"
+        zuzahlung_uri = flexmock('Zuzahlungsbefreiung-URI')
+        zuzahlung_uri.should_receive(:open)\
+          .times(2).and_return { 
+          StringIO.new("download_latest-io-read")
+        }
+        uriparse = flexstub(URI)
+        uriparse.should_receive(:parse).with(zuzahlung)\
+          .times(2).and_return(zuzahlung_uri)
+        Dimdi.download_latest(zuzahlung, today) { |fh|
+          assert_equal('download_latest-io-read', fh.read)
+        }
+        assert(File.exist?(path))
+        assert(File.exist?(arch))
+        Dimdi.download_latest(zuzahlung, today) { |fh|
+          flunk("should not be called again")
+        }
+      end
+    end
+    module Dimdi
+class TestGalenicForm < Test::Unit::TestCase
+  def setup
+    Drugs::GalenicForm.instances.clear
+    Drugs::GalenicGroup.instances.clear
+    @data_dir = File.expand_path('data', File.dirname(__FILE__))
+    @path = File.expand_path('xls/darform_010706.xls', @data_dir) 
+    @import = GalenicForm.new
+  end
+  def setup_form(name)
+    form = Drugs::GalenicForm.new
+    form.description.de = name
+    form.save
+    form
+  end
+  def test_import
+    input = open(@path)
+    assert_equal([], Drugs::GalenicForm.instances)
+    @import.import(input)
+    assert_equal(3, Drugs::GalenicForm.instances.size)
+    expected = [u("Aerolizer"), u("Ampullen"), u("Depotampullen")]
+    names = Drugs::GalenicForm.instances.collect { |inst|
+      inst.description.de
+    }
+    assert_equal(expected, names)
+
+    # do it again, nothing should change
+    input = open(@path)
+    @import.import(input)
+    assert_equal(3, Drugs::GalenicForm.instances.size)
+    names = Drugs::GalenicForm.instances.collect { |inst|
+      inst.description.de
+    }
+    assert_equal(expected, names)
+    galenic_form = Drugs::GalenicForm.instances.last
+    assert_instance_of(Drugs::GalenicForm, galenic_form)
+    assert_equal(2, galenic_form.codes.size)
+    code = galenic_form.codes.first
+    assert_instance_of(Util::Code, code)
+    assert_equal('DE', code.country)
+    assert_equal("galenic_form", code.type)
+    assert_equal('AMPD', code.value)
+    code = galenic_form.codes.last
+    assert_instance_of(Util::Code, code)
+    assert_equal('DE', code.country)
+    assert_equal("galenic_form", code.type)
+    assert_equal('AMPD1', code.value)
+  end
+  def test_postprocess
+    form1 = setup_form('Tabletten')
+    form2 = setup_form('Filmtabletten')
+    form3 = setup_form('Retardtabletten')
+    form4 = setup_form('Retardkapseln')
+    @import.postprocess
+    group1 = Drugs::GalenicGroup.find_by_name('Tabletten')
+    assert_equal(group1, form1.group)
+    assert_equal(group1, form2.group)
+    group2 = Drugs::GalenicGroup.find_by_name('Retard-Tabletten')
+    assert_equal(group2, form3.group)
+    assert_equal(group2, form4.group)
+  end
+end
+class TestProduct < Test::Unit::TestCase
+  def setup
+    Drugs::Product.instances.clear
+    @data_dir = File.expand_path('data', File.dirname(__FILE__))
+    @path = File.expand_path('xls/fb010708.xls', @data_dir) 
+    @import = Product.new
+  end
+  def test_import_base_data
+    tabl = Drugs::GalenicForm.new
+    tabl.description.de = 'Kapseln'
+    tabl.add_code(Util::Code.new(:galenic_form, 'KAPS', 'DE'))
+    tabl.save
+    atc = Drugs::Atc.new('M04AA51')
+    atc.name.de = 'Amoxicillin, Fuzzy match'
+    atc.save
+    assert_equal([], Drugs::Product.instances)
+    sub1 = Drugs::Substance.new
+    sub1.add_code(Util::Code.new("substance", u("POXM"), 'DE'))
+    sub1.save
+    tab = Drugs::GalenicForm.new
+    code = Util::Code.new("galenic_form", "TABS", "DE")
+    tab.add_code(code)
+    tab.description.de = "Tabletten"
+    tab.save
+    input = open(@path)
+    report = @import.import(input)
+    assert_instance_of(Array, report)
+    names = Drugs::Product.instances.collect { |inst|
+      inst.name.de
+    }
+    assert_equal(14, Drugs::Product.instances.size, names.inspect)
+    expected = [ "Piroxicam Ratioph Tabs", "Amoxicillin Rat Mg Fta",
+      "Buscopan", "Aquaphoril Aca", "To Be Deleted", "Aspirin", "Sibelium",
+      "Move The Package", "Capto Dura M", "Move The Sequence", "Aknefug Mino",
+      "Ribofluor Mgml", "Dexa Ct Mg Tabletten", "Madopar" ]
+    assert_equal(expected, names)
+    pr = Drugs::Product.instances.first
+    assert_equal(1, pr.sequences.size)
+    seq = pr.sequences.first
+    assert_equal(1, seq.compositions.size)
+    comp = seq.compositions.first
+    assert_equal(1.1, comp.equivalence_factor)
+    assert_equal(1, comp.active_agents.size)
+    agent = comp.active_agents.first
+    assert_equal(sub1, agent.substance)
+    assert_equal(2, seq.packages.size)
+    pack = seq.packages.first
+    assert_equal(34.25, pack.price(:public, 'DE'))
+    assert_equal(34.28, pack.price(:festbetrag, 'DE'))
+    code = pack.code(:festbetragsstufe, 'DE')
+    assert_instance_of(Util::Code, code)
+    assert_equal(2, code.value)
+    code = pack.code(:festbetragsgruppe, 'DE')
+    assert_instance_of(Util::Code, code)
+    assert_equal(u('9'), code.value)
+    assert_equal(1, pack.parts.size)
+    assert_equal(100, pack.size)
+    part = pack.parts.first
+    assert_instance_of(Drugs::Unit, part.unit)
+    assert_equal(u('Tabletten'), part.unit.name.de)
+    code = pack.code(:cid, 'DE')
+    assert_instance_of(Util::Code, code)
+    assert_equal("649", code.value)
+
+    pack = seq.packages.last
+    code = pack.code(:cid, 'DE')
+    assert_instance_of(Util::Code, code)
+    assert_equal("114568", code.value)
+
+    pr = Drugs::Product.instances.at(1)
+    seq = pr.sequences.first
+    assert_equal(atc, seq.atc)
+
+    pr = Drugs::Product.instances.at(2)
+    seq = pr.sequences.first
+    pack = seq.packages.first
+    assert_equal('2A', pack.code(:festbetragsgruppe).value)
+
+    pr = Drugs::Product.instances.last
+    seq = pr.sequences.first
+    comp = seq.compositions.first
+    assert_equal(2, comp.active_agents.size)
+    assert_equal(["Levodopa", "Benserazid"], 
+                 comp.substances.collect { |sub| sub.name.de })
+    assert_equal([Drugs::Dose.new(0,'mg'), Drugs::Dose.new(0,'mg')],
+                 comp.doses)
+
+    # do it again, nothing should change
+    input = open(@path)
+    report = @import.import(input)
+    assert_instance_of(Array, report)
+    assert_equal(14, Drugs::Product.instances.size)
+    names = Drugs::Product.instances.collect { |inst|
+      inst.name.de
+    }
+    assert_equal(expected, names)
+    pr = Drugs::Product.instances.first
+    assert_equal(1, pr.sequences.size)
+    seq = pr.sequences.first
+    assert_equal(1, seq.compositions.size)
+    comp = seq.compositions.first
+    assert_equal(1.1, comp.equivalence_factor)
+    assert_equal(1, comp.active_agents.size)
+    agent = comp.active_agents.first
+    assert_equal(sub1, agent.substance)
+    assert_equal(2, seq.packages.size)
+    pack = seq.packages.first
+    assert_equal(34.25, pack.price(:public, 'DE'))
+    assert_equal(34.28, pack.price(:festbetrag, 'DE'))
+    code = pack.code(:festbetragsstufe, 'DE')
+    assert_instance_of(Util::Code, code)
+    assert_equal(2, code.value)
+    code = pack.code(:festbetragsgruppe, 'DE')
+    assert_instance_of(Util::Code, code)
+    assert_equal(u('9'), code.value)
+    assert_equal(1, pack.parts.size)
+    assert_equal(100, pack.size)
+    part = pack.parts.first
+    assert_instance_of(Drugs::Unit, part.unit)
+    assert_equal(u('Tabletten'), part.unit.name.de)
+    code = pack.code(:cid, 'DE')
+    assert_instance_of(Util::Code, code)
+    assert_equal("649", code.value)
+
+    pack = seq.packages.last
+    code = pack.code(:cid, 'DE')
+    assert_instance_of(Util::Code, code)
+    assert_equal("114568", code.value)
+
+    pr = Drugs::Product.instances.at(1)
+    seq = pr.sequences.first
+    assert_equal(atc, seq.atc)
+
+    pr = Drugs::Product.instances.at(2)
+    seq = pr.sequences.first
+    pack = seq.packages.first
+    assert_equal('2A', pack.code(:festbetragsgruppe).value)
+
+    pr = Drugs::Product.instances.last
+    seq = pr.sequences.first
+    comp = seq.compositions.first
+    assert_equal(2, comp.active_agents.size)
+    assert_equal(["Levodopa", "Benserazid"], 
+                 comp.substances.collect { |sub| sub.name.de })
+    assert_equal([Drugs::Dose.new(0,'mg'), Drugs::Dose.new(0,'mg')],
+                 comp.doses)
+  end
+end
+class TestSubstance < Test::Unit::TestCase
+  def setup
+    Drugs::Substance.instances.clear
+    @data_dir = File.expand_path('data', File.dirname(__FILE__))
+    @path = File.expand_path('xls/wirkkurz_010406.xls', @data_dir) 
+    @import = Substance.new
+  end
+  def test_import
+    assert_equal([], Drugs::Substance.instances)
+    input = open(@path)
+    report = @import.import(input)
+    assert_instance_of(Array, report)
+    assert_equal(7, Drugs::Substance.instances.size)
+    expected = [u("Acebutolol"), u("Aceclofenac"), u("Atenolol"),
+      u("Chlort"), u("Hydralazin"), u("Acemetacin"),
+      u("Almotriptan")]
+    names = Drugs::Substance.instances.collect { |inst|
+      inst.name.de
+    }
+    assert_equal(expected, names)
+    # do it again, nothing should change
+    input = open(@path)
+    report = @import.import(input)
+    assert_instance_of(Array, report)
+    assert_equal(7, Drugs::Substance.instances.size)
+    names = Drugs::Substance.instances.collect { |inst|
+      inst.name.de
+    }
+    assert_equal(expected, names)
+    substance = Drugs::Substance.instances.first
+    assert_instance_of(Drugs::Substance, substance)
+    assert_equal(1, substance.codes.size)
+    code = substance.codes.first
+    assert_instance_of(Util::Code, code)
+    assert_equal('DE', code.country)
+    assert_equal("substance", code.type)
+    assert_equal('ABTL', code.value)
+  end
+end
+    end
+  end
+end

data/test/import/test_excel.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+# Import::TestExcel -- de.oddb.org -- 04.09.2006 -- hwyss@ywesee.com
+
+$: << File.expand_path('../../lib', File.dirname(__FILE__))
+
+require 'test/unit'
+require 'oddb/import/dimdi'
+
+module ODDB
+  module Import
+    class TestExcel < Test::Unit::TestCase
+      def setup
+        @data_dir = File.expand_path('data', File.dirname(__FILE__))
+        @path = File.expand_path('xls/fb010706.xls', @data_dir) 
+        @input = open(@path)
+        @import = Excel.new
+      end
+      def test_parse__and_cell
+        workbook = @import.parse(@input)
+        assert_instance_of(Spreadsheet::Excel::Workbook, workbook)
+        assert_equal(1, workbook.worksheets.size)
+        worksheet = workbook.worksheet(0)
+        assert_instance_of(Spreadsheet::Excel::Worksheet, worksheet)
+        assert_equal(u("PIROXICAM RATIO"), @import.cell(worksheet.row(1), 0))
+        assert_equal(20, @import.cell(worksheet.row(1), 5))
+        assert_equal(Date.new(2006,7), 
+                     @import.cell(worksheet.row(1), 13))
+      end
+    end
+  end
+end

data/test/import/test_gkv.rb

@@ -0,0 +1,260 @@
+#!/usr/bin/env ruby
+# Import::TestGkv -- ch.oddb.org -- 17.08.2009 -- hwyss@ywesee.com
+
+$: << File.expand_path('..', File.dirname(__FILE__))
+$: << File.expand_path('../../lib', File.dirname(__FILE__))
+
+require 'test/unit'
+require 'flexmock'
+require 'stub/model'
+require 'oddb/import/gkv'
+require 'oddb/config'
+require 'oddb'
+
+module ODDB
+  module Import
+class TestGkv < Test::Unit::TestCase
+  include FlexMock::TestCase
+  def setup
+    Drugs::Atc.instances.clear
+    Drugs::Package.instances.clear
+    Drugs::Product.instances.clear
+    Drugs::Sequence.instances.clear
+    Drugs::Substance.instances.clear
+    Business::Company.instances.clear
+    svc = DRb.start_service 'druby://localhost:0'
+    ODDB.config.server_url = svc.uri
+    @import = Gkv.new
+    dir = File.expand_path('var', File.dirname(__FILE__))
+    ODDB.config.var = dir
+    @pdf_dir = File.join dir, 'pdf/gkv'
+    dir = File.expand_path('data', File.dirname(__FILE__))
+    @html_dir = File.join dir, 'html/gkv'
+    dir = File.expand_path 'data/txt/gkv', File.dirname(__FILE__)
+    @path = File.join dir, 'gkv_p1.txt'
+    ODDB.logger = flexmock(:logger)
+    ODDB.logger.should_receive(:error).and_return do |gkv, block|
+      assert_equal 'Gkv', gkv
+      flunk block.call
+    end
+    super
+  end
+  def teardown
+    FileUtils.rm_r @pdf_dir if File.exist?(@pdf_dir)
+    super
+  end
+  def setup_page(url, html, mech=nil)
+    response = {'content-type' => 'text/html'}
+    Mechanize::Page.new(URI.parse(url), response, html, 200, mech)
+  end
+  def simulate_import
+    handler = GkvHandler.new @import.method(:process_page)
+    File.read(@path).each do |line|
+      handler.send_flowing_data line
+      handler.send_line_break
+    end
+    handler.send_page
+    @import.postprocess
+    @import.report
+  end
+  def test_latest_url
+    agent = flexmock(Mechanize.new)
+    url = 'https://www.gkv-spitzenverband.de/Befreiungsliste_Arzneimittel_Versicherte.gkvnet'
+    path = File.join @html_dir, 'Befreiungsliste_Arzneimittel_Versicherte.gkvnet'
+    page = setup_page url, File.read(path), agent
+    agent.should_receive(:get).with(url).and_return(page)
+    expected = 'https://www.gkv-spitzenverband.de/upload/Zuzahlungsbefreit_sort_Name_100901_14383.pdf'
+    assert_equal expected, @import.latest_url(agent)
+  end
+  def test_latest_url_missing_link
+    agent = flexmock(Mechanize.new)
+    url = 'https://www.gkv-spitzenverband.de/Befreiungsliste_Arzneimittel_Versicherte.gkvnet'
+    html = "<html><body>hogehoge</body></html>"
+    page = setup_page url, html, agent
+    agent.should_receive(:get).with(url).and_return(page)
+    expected = nil
+    assert_equal nil, @import.latest_url(agent)
+  end
+  def test_download_latest
+    called = false
+    @import.download_latest @path do |fh|
+      assert_instance_of(File, fh)
+      called = true
+    end
+    assert called, "download_latest did not call block"
+    @import.download_latest @path do |fh|
+      flunk "download_latest should not call block, if files are identical"
+    end
+    assert true
+  end
+  def test_import
+    existing = Drugs::Package.new
+    existing.add_code(Util::Code.new(:cid, '4000741', 'DE'))
+    existing.add_part(Drugs::Part.new)
+    existing.save
+    sequence = Drugs::Sequence.new
+    product = Drugs::Product.new
+    product.name.de = 'A product'
+    existing.sequence = sequence
+    sequence.product = product
+    assert_nil(existing.code(:zuzahlungsbefreit))
+
+    ## simulate a call to @import.import
+    report = simulate_import
+
+    assert_instance_of(Array, report)
+    assert_equal(3, Drugs::Product.instances.size)
+    assert_equal(true, Drugs::Product.instances.include?(product))
+    assert_equal(1, product.sequences.size)
+    sequence = product.sequences.first
+    #assert_equal(1, sequence.compositions.size)
+    #composition = sequence.compositions.first
+    #assert_equal(2, composition.active_agents.size)
+    #agent1 = composition.active_agents.at(0)
+    #agent2 = composition.active_agents.at(1)
+    #assert_equal('Allopurinol', agent1.substance.name.de)
+    #assert_equal(Drugs::Dose.new(100, 'mg'), agent1.dose)
+    #assert_equal('Benzbromaron', agent2.substance.name.de)
+    #assert_equal(Drugs::Dose.new(20, 'mg'), agent2.dose)
+    code = existing.code(:zuzahlungsbefreit)
+    assert_instance_of(Util::Code, code)
+    assert_equal(true, code.value)
+    confirmed = @import.instance_variable_get('@confirmed_pzns')
+    assert_equal(11, confirmed.size)
+    #assert_equal(2, Business::Company.instances.size)
+    #comp = Business::Company.instances.first
+    #assert_equal('Ratiopharm GmbH', comp.name.de)
+
+    # do it again, nothing should change
+    existing.code(:zuzahlungsbefreit).value = false
+
+    ## simulate a call to @import.import
+    report = simulate_import
+
+    assert_instance_of(Array, report)
+    assert_equal(3, Drugs::Product.instances.size)
+    assert_equal(true, Drugs::Product.instances.include?(product))
+    assert_equal(1, product.sequences.size)
+    sequence = product.sequences.first
+    #assert_equal(1, sequence.compositions.size)
+    #composition = sequence.compositions.first
+    #assert_equal(2, composition.active_agents.size)
+    #agent1 = composition.active_agents.at(0)
+    #agent2 = composition.active_agents.at(1)
+    #assert_equal('Allopurinol', agent1.substance.name.de)
+    #assert_equal(Drugs::Dose.new(100, 'mg'), agent1.dose)
+    #assert_equal('Benzbromaron', agent2.substance.name.de)
+    #assert_equal(Drugs::Dose.new(20, 'mg'), agent2.dose)
+    code = existing.code(:zuzahlungsbefreit)
+    assert_instance_of(Util::Code, code)
+    assert_equal(true, code.value)
+    confirmed = @import.instance_variable_get('@confirmed_pzns')
+    assert_equal(11, confirmed.size)
+    #assert_equal(2, Business::Company.instances.size)
+    #comp = Business::Company.instances.first
+    #assert_equal('Ratiopharm GmbH', comp.name.de)
+  end
+  def test_import__ml
+    existing = Drugs::Package.new
+    existing.add_code(Util::Code.new(:cid, '4000646', 'DE'))
+    existing.add_part(Drugs::Part.new)
+    existing.save
+    sequence = Drugs::Sequence.new
+    product = Drugs::Product.new
+    product.name.de = 'A product'
+    existing.sequence = sequence
+    sequence.product = product
+    assert_nil(existing.code(:zuzahlungsbefreit))
+    report = simulate_import
+    assert_instance_of(Array, report)
+    assert_equal(3, Drugs::Product.instances.size)
+    assert_equal(true, Drugs::Product.instances.include?(product))
+    assert_equal(1, product.sequences.size)
+    sequence = product.sequences.first
+    #assert_equal(1, sequence.compositions.size)
+    #composition = sequence.compositions.first
+    #assert_equal(1, composition.active_agents.size)
+    #agent1 = composition.active_agents.at(0)
+    #assert_equal('Amoxicillin-3-Wasser', agent1.substance.name.de)
+    #assert_equal(Drugs::Dose.new(287, 'mg'), agent1.dose)
+    code = existing.code(:zuzahlungsbefreit)
+    assert_instance_of(Util::Code, code)
+    assert_equal(true, code.value)
+    assert_equal(1, existing.parts.size)
+    part = existing.parts.first
+    assert_equal(6, part.size)
+    assert_equal('0.5 ml', part.quantity.to_s)
+
+    # do it again, nothing should change
+    report = simulate_import
+    assert_instance_of(Array, report)
+    assert_equal(3, Drugs::Product.instances.size)
+    assert_equal(true, Drugs::Product.instances.include?(product))
+    assert_equal(1, product.sequences.size)
+    sequence = product.sequences.first
+    #assert_equal(1, sequence.compositions.size)
+    #composition = sequence.compositions.first
+    #assert_equal(1, composition.active_agents.size)
+    #agent1 = composition.active_agents.at(0)
+    #assert_equal('Amoxicillin-3-Wasser', agent1.substance.name.de)
+    #assert_equal(Drugs::Dose.new(287, 'mg'), agent1.dose)
+    code = existing.code(:zuzahlungsbefreit)
+    assert_instance_of(Util::Code, code)
+    assert_equal(true, code.value)
+    assert_equal(1, existing.parts.size)
+    part = existing.parts.first
+    assert_equal(6, part.size)
+    assert_equal('0.5 ml', part.quantity.to_s)
+  end
+  def test_postprocess
+    product = Drugs::Product.new
+    product.name.de = 'Product 100% Company'
+    product.save
+    company = Business::Company.new
+    company.name.de = 'Company AG'
+    company.save
+    @import.postprocess
+    assert_equal(company, product.company)
+  end
+  def test_postprocess__comp
+    product = Drugs::Product.new
+    product.name.de = 'Product 100% Producer Comp'
+    product.save
+    company = Business::Company.new
+    company.name.de = 'Producer AG'
+    company.save
+    @import.postprocess
+    assert_equal(company, product.company)
+  end
+  def test_postprocess__search
+    product = Drugs::Product.new
+    product.name.de = 'Product 100% Manu'
+    product.save
+    company = Business::Company.new
+    company.name.de = 'Manufacturer AG'
+    company.save
+    @import.postprocess
+    assert_equal(company, product.company)
+  end
+  def test_postprocess__prune_packages
+    pzn1 = Util::Code.new(:cid, '12345', 'DE')
+    zzb1 = Util::Code.new(:zuzahlungsbefreit, 'true', 'DE')
+    pac1 = Drugs::Package.new
+    pac1.add_code(pzn1)
+    pac1.add_code(zzb1)
+    pac1.save
+    pzn2 = Util::Code.new(:cid, '54321', 'DE')
+    zzb2 = Util::Code.new(:zuzahlungsbefreit, 'true', 'DE')
+    pac2 = Drugs::Package.new
+    pac2.add_code(pzn2)
+    pac2.add_code(zzb2)
+    pac2.save
+    @import.instance_variable_set('@confirmed_pzns',
+                                 pac1.code(:cid).value => true)
+    @import.postprocess
+    assert_equal('true', zzb1.value)
+    assert_equal(false, zzb2.value)
+  end
+end
+  end
+end