da_funk 3.33.1 → 3.34.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8eeac1f3c7449183cfd65b190bd2ca9515f586eb55af7e70fa6ac38762a8ae80
-  data.tar.gz: be5906723b2ef951f592bf8434626f7cac9b20a01f699432132692e0a2df8428
+  metadata.gz: b3a687d541cc683675f05e5ebcf8d28504a929c97a57606e9af3d5f238f04def
+  data.tar.gz: f3a1c52920ca5d00f3b43a3d9e513dad9ae883b7167c4b8c37509089bc489af6
 SHA512:
-  metadata.gz: 9667b789d09b2d1ccc41734b1112a243eec58e91504c85618f9177c4e007ab9ec59e857c99f867295794b5bba3d2c33c25e66e2061fa09b47ee2c3c7b2f929b5
-  data.tar.gz: 693e92596f8be1c74e338e2d3b6bebe20d9b4c9f190f4bee820e76046350039cd8317379a3e9b59101183a9525881110a6e8a94c4527d5601de36bb7c00fde77
+  metadata.gz: 7c7d8b462ac97d930628a593a27bc5a7388d3543683f9950db9449d34d22159c68250dc6a8cd2aa24abbed62c5b0ddd09711d0ca0b040924e9337d4f85e1b1e0
+  data.tar.gz: 40d72d5925bfaf49d65bc54ccbfb2c231d8d2f548fd13f784a8bc1bf1b4c863418251e4a1b773ef44836a01dc3fe53321f5f736e33ae9666fd7783546676eac2

data/Gemfile

@@ -4,4 +4,13 @@ gem 'cloudwalk'
 gem 'rubocop', require: false
 gem 'funky-mock'
 
-gemspec
+group :test do
+  gem 'minitest', group: :test
+  gem 'simplecov', group: :test
+end
+
+group :development, :test do
+  gem 'byebug'
+end
+
+gemspec

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    da_funk (3.33.1)
+    da_funk (3.34.0)
       archive-zip (~> 0.5)
       bundler
       cloudwalk_handshake
@@ -15,17 +15,20 @@ GEM
     archive-zip (0.12.0)
       io-like (~> 0.3.0)
     ast (2.4.1)
+    byebug (11.1.3)
     cloudwalk (1.15.0)
       bundler
       rake
     cloudwalk_handshake (1.21.3)
       funky-simplehttp (~> 0.6)
+    docile (1.3.5)
     funky-emv (1.4.1)
       funky-tlv (~> 0.2)
     funky-mock (0.1.0)
     funky-simplehttp (0.6.0)
     funky-tlv (0.2.3)
     io-like (0.3.1)
+    minitest (5.14.4)
     parallel (1.19.2)
     parser (2.7.2.0)
       ast (~> 2.4.1)
@@ -47,6 +50,10 @@ GEM
     rubocop-ast (1.1.0)
       parser (>= 2.7.1.5)
     ruby-progressbar (1.10.1)
+    simplecov (0.18.5)
+      docile (~> 1.1)
+      simplecov-html (~> 0.11)
+    simplecov-html (0.12.3)
     unicode-display_width (1.7.0)
     yard (0.9.25)
 
@@ -56,12 +63,15 @@ PLATFORMS
   x86-mingw32
 
 DEPENDENCIES
+  byebug
   cloudwalk
   da_funk!
   funky-mock
   funky-simplehttp
+  minitest
   rubocop
+  simplecov
   yard
 
 BUNDLED WITH
-   2.1.4
+   2.2.7

data/Rakefile

@@ -90,3 +90,17 @@ end
 task "test:all"         => :build
 task "test:unit"        => :build
 task "test:integration" => :build
+
+Rake::TestTask.new('test:iso8583') do |t|
+  Bundler.require(:default, :test)
+  t.libs << File.join("lib", "da_funk", "helper")
+  t.libs << File.join("lib","iso8583")
+  t.libs << File.join("test", "iso8583")
+  t.test_files = FileList['test/iso8583/**/*_test.rb']
+end
+
+task "test:iso8583:cov" do
+  ENV.store('COV', '1')
+  Bundler.require(:default, :test)
+  Rake::Task["test:iso8583"].execute
+end

data/lib/da_funk/version.rb

@@ -1,4 +1,4 @@
 module DaFunk
-  VERSION="3.33.1"
+  VERSION="3.34.0"
 end
 

data/lib/iso8583/bitmap.rb

@@ -14,16 +14,51 @@ module ISO8583
   # transparently by the Message class.
   class Bitmap
     include DaFunk::Helper
+
+    class << self
+      # Parse the bytes in string and return the Bitmap and bytes remaining in `str`
+      # after the bitmap is taken away.
+      def parse(str, hex_bitmap = false, bitmap_size = 64)
+        bmp  = Bitmap.new(str, hex_bitmap, bitmap_size)
+
+        rest = if bmp.hex_bitmap?
+                 str[bmp.size_in_bytes_hex, str.length]
+               else
+                 str[bmp.size_in_bytes, str.length]
+               end
+
+        [ bmp, rest ]
+      end
+    end
+
+    # bitmap_size defines the size in bits of bitmap. It has to be multiple of 8 (a byte of 8 bits)
+    attr_reader :bitmap_size
+
+    # additional_bitmap defines if the bit 1 (left to right) indicates the presence of another
+    # bitmap just after the current one
+    attr_reader :additional_bitmap
+
+    attr_reader :bitmaps
+
     # create a new Bitmap object. In case an iso message
     # is passed in, that messages bitmap will be parsed. If
     # not, this initializes and empty bitmap.
-    def initialize(message = nil, hex_bitmap=false)
-      @bmp        = Array.new(128, false)
-      @hex_bitmap = hex_bitmap
+    def initialize(message = nil, hex_bitmap=false, bitmap_size = 64, additional_bitmap = true)
+      raise ISO8583Exception.new "wrong bitmap_size: #{bitmap_size}" if bitmap_size % 8 != 0
+
+      @bitmap_size           = bitmap_size
+      @bmp                   = Array.new(bitmap_size, false)
+      @hex_bitmap            = hex_bitmap
+      @additional_bitmap = additional_bitmap
+      @bitmaps               = 1
 
       message ? initialize_from_message(message) : nil
     end
 
+    def additional_bitmap?
+      !!@additional_bitmap
+    end
+
     def hex_bitmap?
       !!@hex_bitmap
     end
@@ -38,22 +73,40 @@ module ISO8583
       @bmp[i-1]
     end
 
-    # Set the bit to the indicated value. Only `true` sets the
-    # bit, any other value unsets it.
-    def []=(i, value)
-      if i > 128
-        raise ISO8583Exception.new("Bits > 128 are not permitted.")
-      elsif i < 2
-        raise ISO8583Exception.new("Bits < 2 are not permitted (continutation bit is set automatically)")
-      end
-      @bmp[i-1] = (value == true)
-    end
-
     # Sets bit #i
     def set(i)
+      if additional_bitmap?
+        raise ISO8583Exception, "field #{i} shouldn't be set (continuation bit is set automatically)" if i % bitmap_size == 1
+      end
+
+      if i > bitmap_size
+        raise ISO8583Exception, "can't set field #{i}, bitmap_size == #{bitmap_size}" unless additional_bitmap?
+
+        quo = i / bitmap_size
+        rem = i % bitmap_size
+        @bitmaps = rem > 0 ? quo + 1 : quo
+        new_bmp = Array.new(@bitmaps * bitmap_size, false)
+        @bmp.each_with_index { |v, idx| new_bmp[idx] = v }
+        0.upto(@bitmaps - 2) do |pos|
+          new_bmp[pos * bitmap_size] = true
+        end
+        @bmp = new_bmp
+      end
       self[i] = true
     end
 
+    def size_in_bits
+      bitmaps * bitmap_size
+    end
+
+    def size_in_bytes
+      size_in_bits / 8
+    end
+
+    def size_in_bytes_hex
+      size_in_bytes * 2
+    end
+
     # Unsets bit #i
     def unset(i)
       self[i] = false
@@ -64,13 +117,13 @@ module ISO8583
       if RUBY_ENGINE == 'mruby'
         # Convert binary to hex, by slicing the binary in 4 bytes chuncks
         bitmap_hex = ""
-        str = ""
+        str = String.new("", encoding: 'ASCII-8BIT')
         self.to_s.chars.reverse.each_with_index do |ch, i|
           str << ch
           next if i == 0
           if (i+1) % 4 == 0
             bitmap_hex << str.reverse.to_i(2).to_s(16)
-            str = ""
+            str = String.new("", encoding: 'ASCII-8BIT')
           end
         end
         unless str.empty?
@@ -78,29 +131,20 @@ module ISO8583
         end
         bitmap_hex.reverse.upcase
       else
-        [to_s].pack("B*").force_encoding('UTF-8')
+        [to_s].pack("B*")
       end
     end
     alias_method :to_b, :to_bytes
 
     def to_hex
-      value = self.to_s.to_i(2).to_s(16).upcase
-      if value.respond_to? :force_encoding
-        value.force_encoding('UTF-8')
-      else
-        value
-      end
+      self.to_s.to_i(2).to_s(16).upcase.ljust(size_in_bytes_hex, '0')
     end
 
     # Generate a String representation of this bitmap in the form:
     #	01001100110000011010110110010100100110011000001101011011001010
     def to_s
-      #check whether any `high` bits are set
-      ret           = (65..128).find {|bit| !!self[bit]}
-      high, @bmp[0] = ret ? [128, true] : [64, false]
-
-      str = ""
-      1.upto(high) do|i|
+      str = String.new("", encoding: "ASCII-8BIT")
+      1.upto(size_in_bits) do |i|
         str << (self[i] ? '1' : '0')
       end
 
@@ -110,6 +154,12 @@ module ISO8583
 
     private
 
+    # Set the bit to the indicated value. Only `true` sets the
+    # bit, any other value unsets it.
+    def []=(i, value)
+      @bmp[i-1] = (value == true)
+    end
+
     def convert_hex_to_binary(str)
       str.chars.reverse.inject("") do |string, ch|
         string + ch.to_i(16).to_s(2).rjust(4, "0").reverse
@@ -118,40 +168,30 @@ module ISO8583
 
     def initialize_from_message(message)
       bmp = if hex_bitmap?
-              rjust(convert_hex_to_binary(message[0..15]), 64, '0')
+              slice_range = (bitmap_size * 2) / 8 - 1
+              rjust(convert_hex_to_binary(message[0..slice_range]), bitmap_size, '0')
             else
-              message.unpack("B64")[0]
+              message.unpack("B#{bitmap_size}")[0]
             end
 
-      if bmp[0,1] == "1"
-        bmp = if hex_bitmap?
-                rjust(convert_hex_to_binary(message[0..31]), 128, '0')
-              else
-                message.unpack("B128")[0]
-              end
+      if additional_bitmap?
+        has_next_bitmap = bmp[0] == "1"
+        while has_next_bitmap
+          @bitmaps += 1
+          bmp = if hex_bitmap?
+                  slice_range = (bitmap_size * bitmaps * 2) / 8 - 1
+                  rjust(convert_hex_to_binary(message[0..slice_range]), bitmap_size * bitmaps, '0')
+                else
+                  message.unpack("B#{bitmap_size * bitmaps}")[0]
+                end
+          has_next_bitmap = bmp[bitmap_size * (bitmaps - 1)] == "1"
+        end
       end
 
       0.upto(bmp.length-1) do |i|
         @bmp[i] = (bmp[i,1] == "1")
       end
     end
-
-    class << self
-      # Parse the bytes in string and return the Bitmap and bytes remaining in `str`
-      # after the bitmap is taken away.
-      def parse(str, hex_bitmap = false)
-        bmp  = Bitmap.new(str, hex_bitmap)
-
-        rest = if bmp.hex_bitmap?
-                 bmp[1] ? str[32, str.length] : str[16, str.length]
-               else
-                 bmp[1] ? str[16, str.length] : str[8, str.length]
-               end
-
-        [ bmp, rest ]
-      end
-    end
-
   end
 end
 

data/lib/iso8583/codec.rb

@@ -106,11 +106,11 @@ module ISO8583
   Packed_Number.encoder = lambda { |val|
     val = val.to_s
     val = val.length % 2 == 0 ? val : "0"+val
-    raise ISO8583Exception.new("Invalid value: #{val} must be numeric!") unless val =~ /^[0-9]*$/
-    [val].pack("H*")
+    raise ISO8583Exception.new("Invalid value: #{val} must be numeric!") unless val =~ /^[0-9A-Fa-f]*$/
+    String.new([val].pack("H*"), encoding: "ASCII-8BIT")
   }
   Packed_Number.decoder = lambda{|encoded|
-    d = encoded.unpack("H*")[0].to_i
+    encoded.unpack("H*")[0].to_i
   }
 
   A_Codec = Codec.new

data/lib/iso8583/field.rb

@@ -72,7 +72,7 @@ module ISO8583
                 when Integer
                   raise ISO8583Exception.new("Too long: #{value} (#{name})! length=#{length}")  if encoded_value.length > length
                   raise ISO8583Exception.new("Too short: #{value} (#{name})! length=#{length}") if encoded_value.length < length
-                  "" 
+                  String.new("", encoding: 'ASCII-8BIT')
                 when Field
                   raise ISO8583Exception.new("Max lenth exceeded: #{value}, max: #{max}") if max && encoded_value.length > max
                   length.encode(encoded_value.length)
@@ -85,11 +85,46 @@ module ISO8583
   end
 
   class BCDField < Field
+    attr_accessor :data_length
+    attr_accessor :byte_length
     # This corrects the length for BCD fields, as their encoded length is half (+ parity) of the
     # content length. E.g. 123 (length = 3) encodes to "\x01\x23" (length 2)
     def length
-      _length = super
-      (_length % 2) != 0 ? (_length / 2) + 1 : _length / 2
+      @byte_length
+    end
+
+    def encode(value)
+      begin
+        encoded_value = codec.encode(value)
+        @data_length = value.size
+        @byte_length = encoded_value.bytes.size
+      rescue ISO8583Exception => e
+        ContextLog.exception(e, e.backtrace, "#{e.message} (#{name})") if Object.const_defined?(:ContextLog)
+        raise ISO8583Exception.new(e.message+" (#{name})")
+      end
+
+      if padding
+        if padding.arity == 1
+          encoded_value = padding.call(encoded_value)
+        elsif padding.arity == 2
+          encoded_value = padding.call(encoded_value, length)
+        end
+      end
+
+      len_str = case length
+                when Integer
+                  raise ISO8583Exception.new("Too long: #{value} (#{name})! length=#{length}")  if encoded_value.length > length
+                  raise ISO8583Exception.new("Too short: #{value} (#{name})! length=#{length}") if encoded_value.length < length
+                  String.new("", encoding: 'ASCII-8BIT')
+                when Field
+                  raise ISO8583Exception.new("Max length exceeded: #{value}, max: #{max}") if max && @byte_length > max
+                  length.encode(@data_length)
+                else
+                  raise ISO8583Exception.new("Invalid length (#{length}) for '#{name}' field")
+                end
+
+      len_str + encoded_value
+
     end
   end
 

data/lib/iso8583/fields.rb

@@ -4,6 +4,8 @@
 # this distribution
 #++
 
+require_relative '../da_funk/helper'
+
 module ISO8583
   include DaFunk::Helper
 
@@ -16,7 +18,7 @@ module ISO8583
   # The following fields are available:
   #
   # [+LL+]           special form to de/encode variable length indicators, two bytes ASCII numerals
-  # [+LLL+]          special form to de/encode variable length indicators, two bytes ASCII numerals
+  # [+LLL+]          special form to de/encode variable length indicators, three bytes ASCII numerals
   # [+LL_BCD+]       special form to de/encode variable length indicators, two BCD digits
   # [+LLVAR_N+]      two byte variable length ASCII numeral, payload ASCII numerals
   # [+LLLVAR_N+]     three byte variable length ASCII numeral, payload ASCII numerals

data/lib/iso8583/message.rb

@@ -117,9 +117,16 @@ module ISO8583
     # ISO8583 allows hex or binary bitmap, so it should be configurable
     attr_reader :use_hex_bitmap
 
+    # ignore_mti allow use of Message without mti. Useful for fields with variable subfields
+    attr_reader :ignore_mti
+
+    # bitmap_size define the size of bitmap to be used, in number of bits.
+    # It should be a multiple of 8 (a byte of 8 bits)
+    attr_reader :bitmap_size
+
     # Instantiate a new instance of this type of Message
     # optionally specifying an mti.
-    def initialize(mti = nil, use_hex_bitmap = false)
+    def initialize(mti = nil, use_hex_bitmap = false, ignore_mti = false, bitmap_size = 64)
       # values is an internal field used to collect all the
       # bmp number | bmp name | field en/decoders | values
       # which are set in this message.
@@ -127,7 +134,8 @@ module ISO8583
 
       self.mti = mti if mti
       @use_hex_bitmap = use_hex_bitmap
-
+      @ignore_mti = ignore_mti
+      @bitmap_size = bitmap_size
     end
 
     # Set the mti of the Message using either the actual value
@@ -143,7 +151,9 @@ module ISO8583
     #    mes = MyMessage.new
     #    mes.mti = 1100 # or mes.mti = "Authorization Request Acquirer Gateway"
     def mti=(value)
-      num, name = _get_mti_definition(value)
+      raise ISO8583Exception.new "can't set MTI when `ignore_mti` is set" if ignore_mti
+
+      num, _ = _get_mti_definition(value)
       @mti = num
     end
 
@@ -180,9 +190,12 @@ module ISO8583
 
     # Retrieve the byte representation of the bitmap.
     def to_b
-      raise ISO8583Exception.new "no MTI set!" unless mti
-      mti_enc = self.class._mti_format.encode(mti).force_encoding('UTF-8')
-      mti_enc << _body.join.force_encoding('UTF-8')
+      raise ISO8583Exception.new "no MTI set!" if !(ignore_mti || mti)
+
+      return _body.join if ignore_mti
+
+      mti_enc = self.class._mti_format.encode(mti)
+      mti_enc << _body.join
     end
 
     # Returns a nicely formatted representation of this
@@ -209,12 +222,12 @@ module ISO8583
     # Returns an array of two byte arrays:
     # [bitmap_bytes, message_bytes]
     def _body
-      bitmap  = Bitmap.new
-      message = ""
+      bitmap  = Bitmap.new(nil, use_hex_bitmap, bitmap_size)
+      message = String.new("", encoding: 'ASCII-8BIT')
       @values.keys.sort.each do |bmp_num|
         bitmap.set(bmp_num)
         enc_value = @values[bmp_num].encode
-        message << enc_value.force_encoding('UTF-8')
+        message << enc_value
       end
 
       if use_hex_bitmap
@@ -356,12 +369,12 @@ module ISO8583
       end
 
       # Parse the bytes `str` returning a message of the defined type.
-      def parse(str, use_hex_bitmap = false)
-        message = self.new(nil, use_hex_bitmap)
+      def parse(str, use_hex_bitmap = false, bitmap_size = 64)
+        message = self.new(nil, use_hex_bitmap, false, bitmap_size)
 
         message.mti, rest = _mti_format.parse(str)
 
-        bmp, rest = Bitmap.parse(rest, use_hex_bitmap)
+        bmp, rest = Bitmap.parse(rest, use_hex_bitmap, bitmap_size)
 
         bmp.each {|bit|
           bmp_def      = _definitions[bit]

data/lib/iso8583/util.rb

@@ -30,7 +30,7 @@ module ISO8583
   end
 
   def _conv(str, mapping)
-    _str = ""
+    _str = String.new("", encoding: "ASCII-8BIT")
     str.each_byte{|byte|
       _str << mapping[byte]
     }

data/test/iso8583/bitmap_test.rb

@@ -0,0 +1,277 @@
+require_relative 'minitest_helper'
+
+module ISO8583
+  class TestBitmap < Minitest::Test
+    def test_parse_with_hex_bitmap_without_additional_bitmap
+      message = "7020000000008000165432123456789876000000000000001500986"
+      hex_bitmap = true
+      bitmap_size = 64
+
+      bitmap, _ = Bitmap.parse(message, hex_bitmap, bitmap_size)
+
+      expect = "7020000000008000"
+      assert_equal(expect, bitmap.to_hex)
+    end
+
+    def test_parse_with_bin_bitmap_without_additional_bitmap
+      message = String.new("\x70\x20\x00\x00\x00\x00\x80\x00165432123456789876000000000000001500986", encoding: "ASCII-8BIT")
+      hex_bitmap = false
+      bitmap_size = 64
+
+      bitmap, _ = Bitmap.parse(message, hex_bitmap, bitmap_size)
+
+      expect = String.new("\x70\x20\x00\x00\x00\x00\x80\x00", encoding: "ASCII-8BIT")
+      assert_equal(expect, bitmap.to_bytes)
+    end
+
+    def test_parse_with_hex_bitmap_having_one_additional_bitmap
+      message = "F02000000000800000000000000000021654321234567898760000000000000015009860a53ec23-8f0b-4328-a51f-b9202dad7b8b"
+      hex_bitmap = true
+      bitmap_size = 64
+
+      bitmap, _ = Bitmap.parse(message, hex_bitmap, bitmap_size)
+
+      expect = "F0200000000080000000000000000002"
+      assert_equal(expect, bitmap.to_hex)
+    end
+
+    def test_parse_with_bin_bitmap_having_one_additional_bitmap
+      message = String.new("\xF0\x20\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x021654321234567898760000000000000015009860a53ec23-8f0b-4328-a51f-b9202dad7b8b", encoding: 'ASCII-8BIT')
+      hex_bitmap = false
+      bitmap_size = 64
+
+      bitmap, _ = Bitmap.parse(message, hex_bitmap, bitmap_size)
+
+      expect = String.new("\xF0\x20\x00\x00\x00\x00\x80\x00\x00\x00\x00\x00\x00\x00\x00\x02", encoding: "ASCII-8BIT")
+      assert_equal(expect, bitmap.to_bytes)
+    end
+
+    def test_parse_with_hex_bitmap_having_more_additionals_bitmap
+      message = "808002blablabla"
+      hex_bitmap = true
+      bitmap_size = 8
+
+      bitmap, _ = Bitmap.parse(message, hex_bitmap, bitmap_size)
+
+      expect = "808002"
+      assert_equal(expect, bitmap.to_hex)
+      assert_equal(true, bitmap[23])
+    end
+
+    def test_parse_returning_remainder_of_message_small_bitmap_size
+      message = "40blablabla"
+      hex_bitmap = true
+      bitmap_size = 8
+
+      _, rest = Bitmap.parse(message, hex_bitmap, bitmap_size)
+
+      expect = "blablabla"
+      assert_equal(expect, rest)
+    end
+
+    def test_parse_returning_remainder_of_message_usual_bitmap_size
+      message = "4000000000000000foobarbaz"
+      hex_bitmap = true
+      bitmap_size = 64
+
+      _, rest = Bitmap.parse(message, hex_bitmap, bitmap_size)
+
+      expect = "foobarbaz"
+      assert_equal(expect, rest)
+    end
+
+    def test_parse_returning_remainder_of_message_big_bitmap_size
+      message = "40000000000000000000000000000000bazbarfoo"
+      hex_bitmap = true
+      bitmap_size = 128
+
+      _, rest = Bitmap.parse(message, hex_bitmap, bitmap_size)
+
+      expect = "bazbarfoo"
+      assert_equal(expect, rest)
+    end
+
+    def test_raises_on_wrong_bitmap_size
+      e = assert_raises { Bitmap.new(nil, false, 1) }
+      assert_equal(ISO8583Exception, e.class)
+      assert_equal('wrong bitmap_size: 1', e.message)
+    end
+
+    def test_set_and_get_value
+      bitmap = Bitmap.new(nil, false, 8)
+      bitmap.set(2)
+      assert_equal(true, bitmap[2])
+      assert_equal(false, bitmap[1])
+    end
+
+    def test_avoid_set_bit_greater_than_size
+      bitmap = Bitmap.new(nil, false, 8,  false)
+      e = assert_raises { bitmap.set(9) }
+      assert_equal(ISO8583Exception, e.class)
+      assert_equal("can't set field 9, bitmap_size == 8", e.message)
+    end
+
+    def test_allow_set_bit_1_when_no_has_additional_bitmap
+      bitmap = Bitmap.new(nil, false, 8,  false)
+      bitmap.set(1)
+      assert_equal(true, bitmap[1])
+    end
+
+    def test_avoid_set_bit_1_when_has_additional_bitmap
+      bitmap = Bitmap.new(nil, false, 8,  true)
+      e = assert_raises { bitmap.set(1) }
+      assert_equal(ISO8583Exception, e.class)
+      assert_equal("field 1 shouldn't be set (continuation bit is set automatically)", e.message)
+    end
+
+    def test_set_continuation_bit
+      bitmap = Bitmap.new(nil, false, 8,  true)
+      bitmap.set(20)
+      assert_equal(true, bitmap[1])
+      assert_equal(true, bitmap[9])
+      assert_equal(false, bitmap[17])
+      assert_equal(true, bitmap[20])
+    end
+
+    def test_set_continuation_bit_with_bitmap_size_of_64
+      bitmap = Bitmap.new(nil, false, 64,  true)
+      bitmap.set(180)
+      assert_equal(true, bitmap[1])
+      assert_equal(true, bitmap[65])
+      assert_equal(false, bitmap[129])
+      assert_equal(true, bitmap[180])
+    end
+
+    def test_unset_field
+      bitmap = Bitmap.new(nil, false, 8,  false)
+      assert_equal(false, bitmap[1])
+      bitmap.set(1)
+      assert_equal(true, bitmap[1])
+      bitmap.unset(1)
+      assert_equal(false, bitmap[1])
+    end
+
+    def test_to_s_bitmap_size_8_bits
+      bitmap = Bitmap.new(nil, false, 8,  false)
+      bitmap.set(2)
+      bitmap.set(7)
+
+      assert_equal('01000010', bitmap.to_s)
+    end
+
+    def test_to_s_bitmap_size_8_bits_having_additional_bitmap
+      bitmap = Bitmap.new(nil, false, 8,  true)
+      bitmap.set(2)
+      bitmap.set(10)
+
+      assert_equal('1100000001000000', bitmap.to_s)
+    end
+
+    def test_to_s_bitmap_size_64_bits
+      bitmap = Bitmap.new(nil, false, 64,  true)
+      bitmap.set(2)
+      bitmap.set(3)
+      bitmap.set(7)
+      bitmap.set(11)
+      bitmap.set(39)
+
+      assert_equal('0110001000100000000000000000000000000010000000000000000000000000', bitmap.to_s)
+    end
+
+    def test_to_s_bitmap_size_64_bits_having_additional_bitmap
+      bitmap = Bitmap.new(nil, false, 64,  true)
+      bitmap.set(2)
+      bitmap.set(3)
+      bitmap.set(7)
+      bitmap.set(11)
+      bitmap.set(39)
+      bitmap.set(127)
+
+      assert_equal('11100010001000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000000000000000000000000000010', bitmap.to_s)
+    end
+
+    def test_to_hex_without_fields
+      bitmap = Bitmap.new(nil, true, 8,  true)
+
+      expected = "00"
+      assert_equal(expected, bitmap.to_hex)
+    end
+
+    def test_to_hex_with_many_fields
+      bitmap = Bitmap.new(nil, true, 64,  true)
+      bitmap.set(2)
+      bitmap.set(3)
+      bitmap.set(4)
+      bitmap.set(5)
+      bitmap.set(6)
+      bitmap.set(7)
+      bitmap.set(8)
+      bitmap.set(66)
+
+      expected = "FF000000000000004000000000000000"
+
+      assert_equal(expected, bitmap.to_hex)
+    end
+
+    def test_to_b_bitmap_size_8
+      bitmap = Bitmap.new(nil, false, 8,  false)
+      bitmap.set(2)
+      bitmap.set(3)
+      bitmap.set(4)
+      bitmap.set(5)
+      bitmap.set(6)
+      bitmap.set(7)
+
+      expected = String.new("\x7E", encoding: 'ASCII-8BIT')
+
+      assert_equal(expected, bitmap.to_b)
+    end
+
+    def test_to_b_bitmap_size_8_having_additional_bitmap
+      bitmap = Bitmap.new(nil, false, 8,  true)
+      bitmap.set(2)
+      bitmap.set(3)
+      bitmap.set(4)
+      bitmap.set(5)
+      bitmap.set(6)
+      bitmap.set(7)
+      bitmap.set(11)
+
+      expected = String.new("\xFE\x20", encoding: 'ASCII-8BIT')
+
+      assert_equal(expected, bitmap.to_b)
+    end
+
+    def test_to_b_bitmap_size_64
+      bitmap = Bitmap.new(nil, false, 64,  false)
+      bitmap.set(2)
+      bitmap.set(3)
+      bitmap.set(4)
+      bitmap.set(5)
+      bitmap.set(6)
+      bitmap.set(7)
+      bitmap.set(8)
+      bitmap.set(64)
+
+      expected = String.new("\x7F\x00\x00\x00\x00\x00\x00\x01", encoding: 'ASCII-8BIT')
+
+      assert_equal(expected, bitmap.to_b)
+    end
+
+    def test_to_b_bitmap_size_64_having_additional_bitmap
+      bitmap = Bitmap.new(nil, false, 64,  true)
+      bitmap.set(2)
+      bitmap.set(3)
+      bitmap.set(4)
+      bitmap.set(5)
+      bitmap.set(6)
+      bitmap.set(7)
+      bitmap.set(8)
+      bitmap.set(66)
+
+      expected = String.new("\xFF\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\x00\x00\x00", encoding: 'ASCII-8BIT')
+
+      assert_equal(expected, bitmap.to_b)
+    end
+  end
+end

data/test/iso8583/message_test.rb

@@ -0,0 +1,111 @@
+require_relative 'minitest_helper'
+
+module ISO8583
+  class TestMTIMessage < Message
+    mti_format N, length: 4
+    mti 100, "Test Authorization"
+
+    bmp 2, "foo", ANS, length: 3
+  end
+
+  class TestMTIMessageBCDPacked < Message
+    mti_format N_BCD, length: 4
+    mti 100, "Test Authorization"
+
+    bmp 2, "foo", ANS, length: 3
+  end
+
+  class TestNoMTIMessage < Message
+    bmp 2, "foo", ANS, length: 3
+  end
+
+  class TestMessageInitialization < Minitest::Test
+    def test_ignore_mti_field_set
+      msg = TestNoMTIMessage.new(nil, true, true)
+      assert_equal true, msg.ignore_mti
+    end
+
+    def test_cant_set_mit_if_ignore_mti
+      msg = TestNoMTIMessage.new(nil, true, true)
+      assert_raises { msg.mti = 100 }
+    end
+
+    def test_can_set_mti_unless_ignore_mti
+      msg = TestMTIMessage.new(100, true)
+
+      assert_equal 100, msg.mti
+    end
+
+    def test_set_mti_bcd_packed_bin_bitmap
+      msg = TestMTIMessageBCDPacked.new(100, false)
+
+      expected = String.new("\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", encoding: 'ASCII-8BIT')
+      assert_equal expected, msg.to_b
+    end
+  end
+
+  class Test_to_b_Method < Minitest::Test
+    def test_raises_when_no_mti_and_no_ignore_mti
+      msg = TestMTIMessage.new(nil, true)
+      assert_raises {msg.to_b}
+    end
+
+    def test_return_bitmap_without_mti_set_and_hex_bitmap
+      msg = TestNoMTIMessage.new(nil, true, true, 24)
+      msg[2] = "bar"
+      assert_equal("400000bar", msg.to_b)
+    end
+
+    def test_return_bitmap_without_mti_set_and_bin_bitmap
+      msg = TestNoMTIMessage.new(nil, false, true, 24)
+      msg[2] = "bar"
+
+      expected = String.new("\x40\x00\x00bar", encoding: 'ASCII-8BIT')
+      assert_equal(expected, msg.to_b)
+    end
+  end
+
+  class Test_parse_Method < Minitest::Test
+
+    def test_parse_with_hex_bitmap
+      msg = "010040bar"
+
+      isomsg = TestMTIMessage.parse(msg, true, 8)
+
+      expected = 100
+      assert_equal(expected, isomsg.mti)
+      expected = "bar"
+      assert_equal(expected, isomsg[2])
+    end
+
+    def test_parse_with_bin_bitmap
+      msg = "0100\x40bar"
+
+      isomsg = TestMTIMessage.parse(msg, false, 8)
+
+      expected = 100
+      assert_equal(expected, isomsg.mti)
+      expected = "bar"
+      assert_equal(expected, isomsg[2])
+    end
+
+    def test_parse_raises_when_undefined_field
+      msg = "0100\x20bar"
+
+      e = assert_raises { TestMTIMessage.parse(msg, false, 8) }
+      assert_equal(ISO8583ParseException, e.class)
+      assert_equal("The message contains fields not defined", e.message)
+    end
+
+    def test_parse_raises_when_undefined_field
+      msg = "0100\x40\x00\x00\x00\x00\x00\x00\x00bar"
+
+      isomsg = TestMTIMessage.parse(msg, false)
+
+      expected = 100
+      assert_equal(expected, isomsg.mti)
+      expected = "bar"
+      assert_equal(expected, isomsg[2])
+    end
+  end
+end

data/test/iso8583/minitest_helper.rb

@@ -0,0 +1,11 @@
+if ENV['COV']
+  require 'simplecov'
+  SimpleCov.start
+end
+
+require 'byebug'
+require 'minitest/autorun'
+PROJECT_ROOT = File.join(File.dirname(File.expand_path(__FILE__)), '..', '..')
+Dir.glob(File.join(PROJECT_ROOT, 'lib', 'iso8583', '**', '*.rb')).each do |file|
+  require file
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: da_funk
 version: !ruby/object:Gem::Version
-  version: 3.33.1
+  version: 3.34.0
 platform: ruby
 authors:
 - Thiago Scalone
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-02-19 00:00:00.000000000 Z
+date: 2021-05-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -218,6 +218,9 @@ files:
 - test/integration/mrb_eval_test.rb
 - test/integration/notification_test.rb
 - test/integration/params_dat_test.rb
+- test/iso8583/bitmap_test.rb
+- test/iso8583/message_test.rb
+- test/iso8583/minitest_helper.rb
 - test/resources/shared/bitmap.dat
 - test/resources/shared/bitmap_gp.dat
 - test/test_helper.rb
@@ -244,7 +247,7 @@ homepage: http://github.com/cloudwalkio/da_funk
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -259,8 +262,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
-signing_key: 
+rubygems_version: 3.0.0
+signing_key:
 specification_version: 4
 summary: MRuby Embedded System Framework
 test_files:
@@ -268,6 +271,9 @@ test_files:
 - test/integration/mrb_eval_test.rb
 - test/integration/notification_test.rb
 - test/integration/params_dat_test.rb
+- test/iso8583/bitmap_test.rb
+- test/iso8583/message_test.rb
+- test/iso8583/minitest_helper.rb
 - test/resources/shared/bitmap.dat
 - test/resources/shared/bitmap_gp.dat
 - test/test_helper.rb