edi4r 0.9.4.1 → 0.9.6.2

data/test/test_loopback.rb

@@ -1,7 +1,12 @@
-#!/usr/bin/env ruby
+# #!/usr/bin/env ruby
+# -*- encoding: iso-8859-1 -*-
 # :include: ../AuthorCopyright
 
 require 'test/unit'
+require 'rbconfig'
+$ruby_cmd = File.join(RbConfig::CONFIG["bindir"],
+			RbConfig::CONFIG["RUBY_INSTALL_NAME"] + RbConfig::CONFIG["EXEEXT"])
+$ruby_cmd << " -E iso-8859-1" if RUBY_VERSION >= '1.9'
 
 #######################################################################
 # Test the accompanying standalone mapping tools
@@ -13,7 +18,7 @@ class EDIFACT_Tests < Test::Unit::TestCase
   def test_loopback
     s1 = nil
     File.open('in1.inh') {|hnd| hnd.binmode; s1 = hnd.read}
-    s2 = `ruby ./webedi2eancom.rb -a in1.inh | ruby ./eancom2webedi.rb`
+    s2 = `#$ruby_cmd ./webedi2eancom.rb -a in1.inh | #$ruby_cmd ./eancom2webedi.rb`
     assert_equal( 0, $? )
     assert_match( s1, s2 )
   end

data/test/test_rexml.rb

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# *-* encoding: iso-8859-1 -*-
 # :include: ../AuthorCopyright
 
 #######################################################################
@@ -10,9 +11,13 @@
 # Include statement during test setup:
 
 $:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+$:.unshift File.join(File.dirname(__FILE__), '..', '..', 'tdid', 'lib')
+
 require 'edi4r'
 require 'edi4r/edifact'
 require 'edi4r/rexml'
+require 'edi4r-tdid'
+require 'edi4r/edifact-rexml'
 
 # Regular include statements:
 
@@ -62,14 +67,41 @@ class EDIFACT_REXML_Tests < Test::Unit::TestCase
   end
 
 
+  def test_joko
+    icx = nil
+    assert_nothing_raised do
+      icx = EDI::Interchange.parse(File.open("joko2.xml"))
+      assert_equal( 0, icx.validate )
+    end
+
+    ice = EDI::Interchange.parse(File.open("joko_in.edi"))
+    assert_equal( ice.to_s, icx.to_s )  # EDIFACT representations equal?
+    
+    se = StringIO.new
+    xdoc_e = REXML::Document.new
+    ice.to_xml(xdoc_e)
+    xdoc_e.write( se, 0 )
+    xdoc_e.write( File.open('joko2a.xml','w'), 0 )
+
+    sx = StringIO.new
+    xdoc_x = REXML::Document.new
+    icx.to_xml(xdoc_x)
+    xdoc_x.write( sx, 0 )
+
+    ie = EDI::E::Interchange.parse_xml( xdoc_e )
+    ix = EDI::E::Interchange.parse_xml( xdoc_x )
+    assert_equal( ie.to_s, ix.to_s )
+  end
+
+
   def test_groups
 
     xdoc = REXML::Document.new
     assert_nothing_raised{ @icg.to_xml( xdoc ) }
 
     sg = StringIO.new
-    xdoc.write( sg, 0 )
-#    xdoc.write( File.open("groups2.xml",'w'), 0 )
+    xdoc.write( sg )
+#    xdoc.write( File.open("groups2.xml",'w') )
 
     ic = nil
     assert_nothing_raised do

data/test/test_service_messages.rb

@@ -0,0 +1,190 @@
+#!/usr/bin/env ruby
+# -*- encoding: iso-8859-1 -*-
+# :include: ../AuthorCopyright
+
+# Load path magic...
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'test/unit'
+
+require 'edi4r'
+# require 'edi4r-tdid'
+require 'edi4r/edifact'
+
+class EDIFACT_Tests < Test::Unit::TestCase
+
+  # edi@energy sample:
+  # UCI+10001+4078901000029:14+4012345000023:14+4'
+  # Dieses Beispiel identifiziert die Übertragung 10001 vom Absender
+  # 4078901000029 (ILN) an den Empfänger 4012345000023 (ILN). 
+  # In der empfangenen Datei wurde ein Syntaxfehler festgestellt.
+
+  def fill_CONTRL( msg )
+    seg = msg.new_segment('UCI')
+    msg.add seg
+    seg.d0020 = '10001'
+    seg.cS002.d0004 = '4078901000029'
+    seg.cS002.d0007 = '14'
+    seg.cS003.d0010 = '4012345000023'
+    seg.cS003.d0007 = '14'
+    seg.d0083 = '4'
+  end
+
+  # Sample data from EANCOM 2002 example 2:
+  #
+  # UNH+AUT0001+AUTACK:4:1:UN:EAN001'
+  # USH+7+1+3+1+2+1++++1:20020102:100522:0100'
+  # USA+1:16:1:6:1:7:1'
+  # USC+AXZ4711+4::541234500006:2+3'
+  # USA+6:16:1:10:1:7:1'
+  # USB+1++5412345678908:14+8798765432106:14'
+  # USX+INT12435+5412345678908:14+8798765432106:14'
+  # USY+1+1:139B7CB..........7C72B03CE5F'
+  # UST+1+5'
+  # UNT+10+AUT0001
+  #
+  def fill_AUTACK( msg )
+    msg.header.d0062 = 'AUT0001'
+
+    seg = msg.new_segment('USH')
+    msg.add seg
+    seg.d0501 = 7
+    seg.d0534 = 1
+    seg.d0541 = 3
+    seg.d0503 = 1
+    seg.d0505 = 2
+    seg.d0507 = 1
+    seg.cS501.d0517 = 1
+    seg.cS501.d0338 = '20020102'
+    seg.cS501.d0314 = '100522'
+    seg.cS501.d0336 = '0100'
+
+    seg = msg.new_segment('USA')
+    msg.add seg
+    seg.cS502.d0523 = 1
+    seg.cS502.d0525 = 16
+    seg.cS502.d0533 = 6
+    seg.cS502.d0527 = 1
+    seg.cS502.d0529 = 6
+    seg.cS502.d0591 = 7
+    seg.cS502.d0601 = 1
+
+    seg = msg.new_segment('USC')
+    msg.add seg
+    seg.d0536 = 'AXZ4711'
+    seg.cS500.d0577 = 4
+    seg.cS500.d0511 = '541234500006'
+    seg.cS500.d0513 = 2
+    seg.d0545 = 3
+
+    seg = msg.new_segment('USA')
+    msg.add seg
+    seg.cS502.d0523 = 6
+    seg.cS502.d0525 = 16
+    seg.cS502.d0533 = 1
+    seg.cS502.d0527 = 10
+    seg.cS502.d0529 = 1
+    seg.cS502.d0591 = 7
+    seg.cS502.d0601 = 1
+
+    seg = msg.new_segment('USB')
+    msg.add seg
+    seg.d0503 = 1
+    seg.cS002.d0004 = '5412345678908'
+    seg.cS002.d0007 = 14
+    seg.cS003.d0010 = '8798765432106'
+    seg.cS003.d0007 = 14
+
+    seg = msg.new_segment('USX')
+    msg.add seg
+    seg.d0020 = 'INT12435'
+    seg.cS002.d0004 = '5412345678908'
+    seg.cS002.d0007 = 14
+    seg.cS003.d0010 = '8798765432106'
+    seg.cS003.d0007 = 14
+
+    seg = msg.new_segment('USY')
+    msg.add seg
+    seg.d0534 = 1
+    seg.cS508.d0563 = 1
+    seg.cS508.d0560 = '139B7CB..........7C72B03CE5F'
+
+    seg = msg.new_segment('UST')
+    msg.add seg
+    seg.d0534 = 1
+    seg.d0588 = 5
+  end
+
+
+
+  def test_CONTRL_creation
+
+    test_set = [
+	    {:sv => 2, :version => '2', :release => '2'}, # Can't work - segments missing?
+	    {:sv => 3, :version => 'D', :release => '3'},
+	    {:sv => 3, :version => 'D', :release => '3', :assigned_code => '1.3c'},
+#	    {:sv => 3, :version => 'D', :release => '96A', :assigned_code => 'EAN002'},
+    ]
+    test_set.each do |testcase|
+      ic = nil
+      assert_nothing_raised { ic = EDI::E::Interchange.new(
+	      :version => testcase[:sv],
+	      :charset => testcase[:sv] == 2 ? 'UNOB' : 'UNOC') }
+      ic.header.d0035 = 1  # Test indicator
+      msg = ic.new_message(:msg_type => 'CONTRL',
+			   :version => testcase[:version],
+			   :release => testcase[:release],
+     			   :assigned_code => testcase[:assigned_code])
+      fill_CONTRL(msg)
+      ic.add msg
+      assert_equal( 1, msg.header.first.value ) # value of DE 0062
+      s009 = ['CONTRL', testcase[:version], testcase[:release], 'UN'].join ic.una.ce_sep
+      s009 << ":#{testcase[:assigned_code]}" unless testcase[:assigned_code].nil?
+      assert_equal( s009, msg.header[1].to_s ) # S009
+      assert_equal( ['UNH', 1, s009].join(ic.una.de_sep), msg.header.to_s ) # UNH
+#     puts ic
+    end
+  end
+
+  def test_AUTACK_creation
+
+    test_set = [
+	    {:sv => 4, :version => '4', :release => '1'},
+	    {:sv => 4, :version => '4', :release => '1', :assigned_code => 'EAN008'},
+	    {:sv => 3, :version => '4', :release => '1', :should_fail => true}
+    ]
+    test_set.each do |testcase|
+      ic = nil
+      assert_nothing_raised { ic = EDI::E::Interchange.new(
+	      :version => testcase[:sv], :charset => 'UNOA') }
+      unb = ic.header 
+      unb.d0020 = 'INT12435'
+      unb.cS002.d0004 = '5412345678908'
+      unb.cS002.d0007 = 14
+      unb.cS003.d0010 = '8798765432106'
+      unb.cS003.d0007 = 14
+      msg = ic.new_message(:msg_type => 'AUTACK',
+			   :version => testcase[:version],
+			   :release => testcase[:release],
+     			   :assigned_code => testcase[:assigned_code])
+      if testcase[:should_fail]
+        assert_raise(RuntimeError, EDI::EDILookupError) do
+	  fill_AUTACK(msg) # Lookup error?
+	  ic.add msg       # Validation error?
+	end
+      else
+        assert_nothing_raised do
+	  fill_AUTACK(msg)
+	  ic.add msg
+	end
+      end
+
+      assert_equal( 'AUT0001', msg.header.first.value ) # value of DE 0062
+      s009 = "AUTACK:#{testcase[:version]}:#{testcase[:release]}:UN"
+      s009 << ":#{testcase[:assigned_code]}" unless testcase[:assigned_code].nil?
+      assert_equal( s009, msg.header[1].to_s ) # S009
+      assert_equal( "UNH+AUT0001+"+s009, msg.header.to_s ) # UNH
+    end
+  end
+
+end

data/test/test_streaming.rb

@@ -0,0 +1,167 @@
+#!/usr/bin/env ruby
+# :include: ../AuthorCopyright
+
+# Load path magic...
+$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'test/unit'
+
+require 'edi4r'
+require 'edi4r/edifact'
+
+#######################################################################
+# Test the streaming parser with a large interchange
+#
+# Instead of mapping, we derive some statistics:
+#   Count number of line items, report no. of messages
+
+module MyParserAddons
+
+  attr_accessor :lin, :all
+
+  def on_other( s )
+    $stderr.puts "other: #{s}"
+  end
+
+  def on_segment( s, tag )
+    case tag
+    when 'LIN'
+      self.lin += 1
+      self.all += 1
+    else
+      self.all += 1
+    end
+    super
+  end
+
+  def to_s
+    "Found %d LIN segments, %d total segments" % [self.lin, self.all]
+  end
+end
+
+
+class MyParser < EDI::E::StreamingParser
+  include MyParserAddons
+
+  def initialize
+    @lin = @all = 0
+    super
+  end
+end
+
+
+class MyLWBuilder < EDI::E::StreamingBuilder
+  include MyParserAddons
+
+  def initialize( validate )
+    @lin = @all = 0
+    super
+  end
+
+  def on_segment( s, tag )
+    case tag
+    when 'LIN'
+      self.lin += 1
+      self.all += 1
+    else
+      self.all += 1
+    end
+    # super
+  end
+
+  def on_interchange_end
+#    @ic.validate
+#    super
+  end
+end
+
+
+class MyBuilder < EDI::E::StreamingBuilder
+  include MyParserAddons
+
+  def initialize( validate )
+    @lin = @all = 0
+    super
+  end
+end
+
+
+class MyDemoParser < EDI::E::StreamingParser
+  attr_reader :counters
+  
+  def initialize
+    @counters = Hash.new(0)
+    super
+  end
+  
+  def on_segment( s, tag )
+    @counters[tag] += 1
+  end
+end
+  
+
+class StreamParser_Tests < Test::Unit::TestCase
+
+  def test_streaming_parser
+    parser = MyParser.new
+    assert_nothing_raised{ parser.go File.open('in1.edi') }
+    assert_equal( 2, parser.lin )
+    assert_equal( 35, parser.all )
+
+    # Syntax check
+    #
+    parser = EDI::E::StreamingParser.new
+    assert_raise(EDI::E::EDISyntaxError){ parser.go( File.open('damaged_file.edi') ) }
+  end
+
+  def test_sample_code
+    assert_nothing_raised {
+      parser = MyDemoParser.new
+      parser.go( File.open( 'remadv101.edi' ) )
+      # parser.go( File.open( 'I0002352726' ) ) # Huge interchange, 5MB
+      puts "Segment tag statistics:"
+      parser.counters.keys.sort.each do |tag|
+        print "%03s: %4d\n" % [ tag, parser.counters[tag] ]
+      end
+    }
+    parser = EDI::E::StreamingParser.new
+    def parser.on_segment( s, tag ) # singleton
+      if tag == 'AJT'
+        puts "Interchange in '#{self.path}' contains at least one segment AJT."
+        puts "Here is its contents: #{s}"
+        throw :done   # Skip further parsing
+      end
+    end
+    def parser.on_unz_uiz( s, tag )
+      puts "Interchange in '#{self.path}' does NOT contain a segment AJT!"
+    end
+    assert_nothing_raised do
+      parser.go( File.open( 'in1.edi' ) )
+      parser.go( File.open( 'remadv101.edi' ) )
+    end
+
+  end
+
+  def test_streaming_lightweight_builder
+    builder = MyLWBuilder.new( false )
+    assert_nothing_raised{ builder.go File.open('I0002352726') }
+    ic = builder.interchange
+    assert_equal( 35679, builder.lin )
+    assert_equal( 290947, builder.all )
+    assert_equal( 28, ic.size )
+  end
+
+  def test_streaming_builder
+    builder = MyBuilder.new( false )
+    assert_nothing_raised{ builder.go File.open('in1.edi') }
+    ic = builder.interchange
+    assert_equal( 2, builder.lin )
+    assert_equal( 35, builder.all )
+    assert_equal( 1, ic.size )
+    assert_nothing_raised{ assert(ic.validate) }
+
+    builder = MyBuilder.new( true )
+    assert_nothing_raised{ builder.go File.open('groups.edi') }
+  end
+
+end

data/test/test_tut_examples.rb

@@ -3,11 +3,13 @@
 
 # Load path magic...
 $:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+$:.unshift File.join(File.dirname(__FILE__), '..', '..', 'tdid', 'lib')
 
 require 'test/unit'
 
 require 'edi4r'
 require 'edi4r/edifact'
+require 'edi4r-tdid'
 
 # require "rubygems"
 # require_gem "edi4r"
@@ -119,7 +121,7 @@ class Tutorial_Tests < Test::Unit::TestCase
     last_msg = ic.last
     d = last_msg['DTM']  # Array of all DTM segments, any segment group
     assert( d. is_a?( Array ) )
-    d = msg.find_all {|seg| seg.name == 'DTM' && seg.sg_name == 'SG4'}
+    d = last_msg.find_all {|seg| seg.name == 'DTM' && seg.sg_name == 'SG4'}
     assert_equal( 11, d.size )
 
     doc1 = last_msg['DOC'].first