code_error 0.9.3 → 1.0.0

data/test/test_gen.rb

@@ -0,0 +1,76 @@
+require "minitest/autorun"
+
+$LOAD_PATH.unshift("#{File.dirname(__FILE__)}")
+require "test_helper"
+require "code_error"
+
+class TestGen < Minitest::Test
+  GEN_ERROR_CODE_1 = :gen_code1
+  GEN_ERROR_MSG_1 = 'The error message for gen code 1.'
+  GEN_ERROR_STATUS_1 = :gen_failed1
+
+  GEN_ERROR_CODE_2 = :gen_code2
+  GEN_ERROR_MSG_2 = 'The error message for gen code 2.'
+  GEN_ERROR_STATUS_2 = :gen_failed2
+
+  GEN_ERROR_CODES = {
+    GEN_ERROR_CODE_1 => {
+      :status => GEN_ERROR_STATUS_1,
+      :msg => GEN_ERROR_MSG_1,
+    },
+    GEN_ERROR_CODE_2 => {
+      :status => GEN_ERROR_STATUS_2,
+      :msg => GEN_ERROR_MSG_2,
+    }
+  }
+
+  GEN_ERROR_CODE_UNDEFINED = :undefined_gen_code
+
+  class GenError < CodeError::Base
+    error_codes(GEN_ERROR_CODES)
+  end
+
+  def test_gen_should_return_the_correspond_data_if_given_code_is_defined
+    e = GenError.gen(GEN_ERROR_CODE_1)
+    assert(e.code == GEN_ERROR_CODE_1)
+    assert(e.status == GEN_ERROR_STATUS_1)
+    assert(e.msg == GEN_ERROR_MSG_1)
+    assert(e.data == { :code => GEN_ERROR_CODE_1,
+                       :status => GEN_ERROR_STATUS_1,
+                       :msg => GEN_ERROR_MSG_1,
+                       :info => nil })
+    assert(e.message == e.data.inspect)
+    assert(!e.internal?)
+  end
+
+  def test_gen_should_return_an_internal_error_with_given_code_if_given_code_is_undefined
+    e = GenError.gen(GEN_ERROR_CODE_UNDEFINED)
+    assert(e.code == GEN_ERROR_CODE_UNDEFINED)
+    assert(e.status == CodeError::INTERNAL_STATUS)
+    assert(e.msg == CodeError::INTERNAL_MSG)
+    assert(e.internal?)
+  end
+
+  def test_gen_should_return_an_internal_error_with_given_msg_if_given_code_is_a_string
+    msg = 'An error message.'
+    e = GenError.gen(msg)
+    assert(e.code == CodeError::INTERNAL_CODE)
+    assert(e.status == CodeError::INTERNAL_STATUS)
+    assert(e.msg == msg)
+    assert(e.internal?)
+  end
+
+  def test_gen_should_return_an_success_error_if_given_code_is_a_success_code
+    e = GenError.gen(CodeError::SUCCESS_CODE)
+    assert(e.code == CodeError::SUCCESS_CODE)
+    assert(e.status == CodeError::SUCCESS_STATUS)
+    assert(e.msg == CodeError::SUCCESS_MSG)
+    assert(!e.internal?)
+  end
+
+  def test_gen_should_contain_the_info_if_an_info_is_given
+    info = 'some information'
+    e = GenError.gen(GEN_ERROR_CODE_1, { :info => info })
+    assert(e.info == info)
+  end
+end

data/test/test_masked.rb

@@ -1,89 +1,195 @@
-require "test/unit"
+require "minitest/autorun"
 
 $LOAD_PATH.unshift("#{File.dirname(__FILE__)}")
 require "test_helper"
 require "code_error"
 
-class TestMasked < Test::Unit::TestCase
+class TestMasked < Minitest::Test
 
-  ERROR_CODE_1 = 1
-  ERROR_MSG_1 = 'The error message for code 1.'
-  ERROR_STATUS_1 = :failed
+  MASK_VALUES = [true, false]
 
-  ERROR_CODE_2 = 2
-  ERROR_MSG_2 = 'The error message for code 2.'
-  ERROR_STATUS_2 = :failed
+  MASK_ERROR_CODE_1 = :mask_error_code1
+  MASK_ERROR_MSG_1 = 'The mask error message for code 1.'
+  MASK_ERROR_STATUS_1 = :mask_failed1
 
-  ERROR_CODE_UNDEFINED = 55688
+  MASK_ERROR_CODE_2 = :mask_error_code2
+  MASK_ERROR_MSG_2 = 'The mask error message for code 2.'
+  MASK_ERROR_STATUS_2 = :mask_failed2
+
+  MASK_ERROR_CODE_3 = :mask_error_code3
+  MASK_ERROR_MSG_3 = 'The mask error message for code 3.'
+  MASK_ERROR_STATUS_3 = :mask_failed3
+
+  MASK_ERROR_CODE_UNDEFINED = :mask_undefined_code
+
+  MASK_ERROR_CODES = {
+    MASK_ERROR_CODE_1 => {
+      :status => MASK_ERROR_STATUS_1,
+      :msg => MASK_ERROR_MSG_1,
+    },
+    MASK_ERROR_CODE_2 => {
+      :status => MASK_ERROR_STATUS_2,
+      :msg => MASK_ERROR_MSG_2,
+      :masked => false
+    },
+    MASK_ERROR_CODE_3 => {
+      :status => MASK_ERROR_STATUS_3,
+      :msg => MASK_ERROR_MSG_3,
+      :masked => true
+    }
+  }
 
   class MaskedError < CodeError::Base
-    def error_codes
-      {
-        ERROR_CODE_1 => {
-          :status => ERROR_STATUS_1,
-          :msg => ERROR_MSG_1,
-        },
-        ERROR_CODE_2 => {
-          :status => ERROR_STATUS_2,
-          :msg => ERROR_MSG_2,
-          :masked => true
-        }
-      }
-    end
+    error_codes (MASK_ERROR_CODES)
   end
 
   def test_masked_should_mask_the_message_if_the_true_masked_arg_is_given_in_msg_and_data
-    e = MaskedError.new(ERROR_CODE_1)
-    assert(e.msg(true) == "#{CodeError::MASKED_MSG}(#{ERROR_CODE_1})")
-    assert(e.data(true) == { :code => ERROR_CODE_1,
-                             :status => ERROR_STATUS_1,
-                             :msg => "#{CodeError::MASKED_MSG}(#{ERROR_CODE_1})",
-                             :info => {} })
+    e = MaskedError.gen(MASK_ERROR_CODE_1)
+    MASK_VALUES.each do |target_mv|
+      msg = target_mv ? CodeError::DEFAULT_MASKED_MSG : MASK_ERROR_MSG_1
+      assert(e.msg(:masked => target_mv) == msg)
+      assert(e.data(:masked => target_mv) == { :code => MASK_ERROR_CODE_1,
+                                               :status => MASK_ERROR_STATUS_1,
+                                               :msg => msg,
+                                               :info => nil })
+    end
+  end
+
+  def test_masked_should_mask_the_message_if_the_true_masked_arg_is_given_in_msg_and_data_even_the_gen_has_masked_false_option
+    MASK_VALUES.each do |mv|
+      e = MaskedError.gen(MASK_ERROR_CODE_1, { :masked => mv })
+      MASK_VALUES.each do |target_mv|
+        msg = target_mv ? CodeError::DEFAULT_MASKED_MSG : MASK_ERROR_MSG_1
+        assert(e.msg(:masked => target_mv) == msg)
+        assert(e.data(:masked => target_mv) == { :code => MASK_ERROR_CODE_1,
+                                                 :status => MASK_ERROR_STATUS_1,
+                                                 :msg => msg,
+                                                 :info => nil })
+      end
+    end
+  end
+
+  def test_masked_should_mask_the_message_if_the_true_masked_arg_is_given_in_msg_and_data_even_the_code_error_has_masked_false_option
+    MASK_ERROR_CODES.each do |code, value|
+      error_code = code
+      error_msg = value[:msg]
+      error_status= value[:status]
+      e = MaskedError.gen(error_code)
+      MASK_VALUES.each do |target_mv|
+        msg = target_mv ? CodeError::DEFAULT_MASKED_MSG : error_msg
+        e = MaskedError.gen(error_code)
+        assert(e.msg(:masked => target_mv) == msg)
+        assert(e.data(:masked => target_mv) == { :code => error_code,
+                                                 :status => error_status,
+                                                 :msg => msg,
+                                                 :info => nil })
+      end
+    end
   end
 
-  def test_masked_should_mask_the_message_if_given_code_is_undefined_but_the_true_masked_arg_is_given_in_msg_and_data
-    e = MaskedError.new(ERROR_CODE_UNDEFINED)
-    assert(e.msg(true) == "#{CodeError::MASKED_MSG}(#{ERROR_CODE_UNDEFINED})")
-    assert(e.data(true) == { :code => ERROR_CODE_UNDEFINED,
-                             :status => CodeError::INTERNAL_STATUS,
-                             :msg => "#{CodeError::MASKED_MSG}(#{ERROR_CODE_UNDEFINED})",
-                             :info => {} })
+  def test_masked_should_mask_the_message_if_the_true_masked_arg_is_given_in_msg_and_data_even_the_class_has_masked_false_option
+    MASK_VALUES.each do |mv|
+      MaskedError.masked mv
+      MASK_VALUES.each do |target_mv|
+        msg = target_mv ? CodeError::DEFAULT_MASKED_MSG : MASK_ERROR_MSG_1
+        e = MaskedError.gen(MASK_ERROR_CODE_1)
+        assert(e.msg(:masked => target_mv) == msg)
+        assert(e.data(:masked => target_mv) == { :code => MASK_ERROR_CODE_1,
+                                                 :status => MASK_ERROR_STATUS_1,
+                                                 :msg => msg,
+                                                 :info => nil })
+      end
+    end
   end
 
-  def test_masked_should_mask_the_message_if_given_code_is_a_string_but_the_true_masked_arg_is_given_in_msg_and_data
-    msg = 'An error message.'
-    e = MaskedError.new(msg)
-    assert(e.msg(true) == "#{CodeError::MASKED_MSG}(#{CodeError::INTERNAL_CODE})")
-    assert(e.data(true) == { :code => CodeError::INTERNAL_CODE,
-                             :status => CodeError::INTERNAL_STATUS,
-                             :msg => "#{CodeError::MASKED_MSG}(#{CodeError::INTERNAL_CODE})",
-                             :info => {} })
+  def test_masked_should_mask_the_message_if_the_gen_has_masked_true_option
+    MASK_VALUES.each do |target_mv|
+      msg = target_mv ? CodeError::DEFAULT_MASKED_MSG : MASK_ERROR_MSG_1
+      e = MaskedError.gen(MASK_ERROR_CODE_1, { :masked => target_mv })
+      assert(e.msg == msg)
+      assert(e.data == { :code => MASK_ERROR_CODE_1,
+                         :status => MASK_ERROR_STATUS_1,
+                         :msg => msg,
+                         :info => nil })
+    end
   end
 
-  def test_masked_should_mask_the_message_if_given_code_is_a_success_code_but_the_true_masked_arg_is_given_in_msg_and_data
-    e = MaskedError.new(CodeError::SUCCESS_CODE)
-    assert(e.msg(true) == "#{CodeError::MASKED_MSG}")
-    assert(e.data(true) == { :code => CodeError::SUCCESS_CODE,
-                             :status => CodeError::SUCCESS_STATUS,
-                             :msg => "#{CodeError::MASKED_MSG}",
-                             :info => {} })
+  def test_masked_should_mask_the_message_if_the_gen_has_masked_true_option_even_the_code_errors_has_masked_false_option
+    MASK_ERROR_CODES.each do |code, value|
+      error_code = code
+      error_msg = value[:msg]
+      error_status= value[:status]
+      MASK_VALUES.each do |target_mv|
+        msg = target_mv ? CodeError::DEFAULT_MASKED_MSG : error_msg
+        e = MaskedError.gen(error_code, { :masked => target_mv })
+        assert(e.msg == msg)
+        assert(e.data == { :code => error_code,
+                           :status => error_status,
+                           :msg => msg,
+                           :info => nil })
+      end
+    end
   end
 
-  def test_masked_should_unmask_the_message_if_given_msg_is_masked_in_new_but_the_false_masked_arg_is_given_in_msg_and_data
-    e = MaskedError.new(ERROR_CODE_1, :masked)
-    assert(e.msg(false) == "#{ERROR_MSG_1}(#{ERROR_CODE_1})")
-    assert(e.data(false) == { :code => ERROR_CODE_1,
-                              :status => ERROR_STATUS_1,
-                              :msg => "#{ERROR_MSG_1}(#{ERROR_CODE_1})",
-                              :info => {} })
+  def test_masked_should_mask_the_message_if_the_gen_has_masked_true_option_even_the_class_has_masked_false_option
+    MASK_VALUES.each do |mv|
+      MaskedError.masked mv
+      MASK_VALUES.each do |target_mv|
+        msg = target_mv ? CodeError::DEFAULT_MASKED_MSG : MASK_ERROR_MSG_1
+        e = MaskedError.gen(MASK_ERROR_CODE_1, { :masked => target_mv })
+        assert(e.msg == msg)
+        assert(e.data == { :code => MASK_ERROR_CODE_1,
+                           :status => MASK_ERROR_STATUS_1,
+                           :msg => msg,
+                           :info => nil })
+      end
+    end
   end
 
-  def test_masked_should_unmask_the_message_if_true_masked_config_is_given_but_the_false_masked_arg_is_given_in_msg_and_data
-    e = MaskedError.new(ERROR_CODE_2)
-    assert(e.msg(false) == "#{ERROR_MSG_2}(#{ERROR_CODE_2})")
-    assert(e.data(false) == { :code => ERROR_CODE_2,
-                              :status => ERROR_STATUS_2,
-                              :msg => "#{ERROR_MSG_2}(#{ERROR_CODE_2})",
-                              :info => {} })
+  def test_masked_should_mask_the_message_if_the_code_errors_has_masked_true_option
+    MASK_ERROR_CODES.each do |code, value|
+      error_code = code
+      error_msg = value[:msg]
+      error_status= value[:status]
+      msg = value[:masked] ? CodeError::DEFAULT_MASKED_MSG : error_msg
+      e = MaskedError.gen(error_code)
+      assert(e.msg == msg)
+      assert(e.data == { :code => error_code,
+                         :status => error_status,
+                         :msg => msg,
+                         :info => nil })
+    end
+  end
+
+  def test_masked_should_mask_the_message_if_the_code_errors_has_masked_true_option_even_the_class_has_masked_false_option
+    MASK_VALUES.each do |mv|
+      MaskedError.masked mv
+      MASK_ERROR_CODES.each do |code, value|
+        next if value[:masked].nil?
+        error_code = code
+        error_msg = value[:msg]
+        error_status= value[:status]
+        msg = value[:masked] ? CodeError::DEFAULT_MASKED_MSG : error_msg
+        e = MaskedError.gen(error_code)
+        assert(e.msg == msg)
+        assert(e.data == { :code => error_code,
+                           :status => error_status,
+                           :msg => msg,
+                           :info => nil })
+      end
+    end
+  end
+
+  def test_masked_should_mask_the_message_if_the_class_has_masked_true_option
+    MASK_VALUES.each do |mv|
+      MaskedError.masked mv
+      msg = mv ? CodeError::DEFAULT_MASKED_MSG : MASK_ERROR_MSG_1
+      e = MaskedError.gen(MASK_ERROR_CODE_1)
+      assert(e.msg == msg)
+      assert(e.data == { :code => MASK_ERROR_CODE_1,
+                         :status => MASK_ERROR_STATUS_1,
+                         :msg => msg,
+                         :info => nil })
+    end
   end
 end

data/test/test_pos.rb

@@ -0,0 +1,213 @@
+require "minitest/autorun"
+
+$LOAD_PATH.unshift("#{File.dirname(__FILE__)}")
+require "test_helper"
+require "code_error"
+
+class TestPos < Minitest::Test
+
+  POS_OPTIONS = [:append, :prepend, :none]
+
+  def show_code_msg(pos, msg, code)
+    case pos
+      when :append then "#{msg} (#{code})"
+      when :prepend then "(#{code}) #{msg}"
+      else
+        msg
+    end
+  end
+
+  POS_ERROR_CODE_1 = :pos_error_code1
+  POS_ERROR_MSG_1 = 'The pos error message for code 1.'
+  POS_ERROR_STATUS_1 = :pos_failed1
+
+  POS_ERROR_CODE_2 = :pos_error_code2
+  POS_ERROR_MSG_2 = 'The pos error message for code 2.'
+  POS_ERROR_STATUS_2 = :pos_failed2
+
+  POS_ERROR_CODE_3 = :pos_error_code3
+  POS_ERROR_MSG_3 = 'The pos error message for code 3.'
+  POS_ERROR_STATUS_3 = :pos_failed3
+
+  POS_ERROR_CODE_4 = :pos_error_code4
+  POS_ERROR_MSG_4 = 'The pos error message for code 4.'
+  POS_ERROR_STATUS_4 = :pos_failed4
+
+  POS_ERROR_CODE_UNDEFINED = :pos_undefined_code
+
+  POS_ERROR_CODES = {
+    POS_ERROR_CODE_1 => {
+      :status => POS_ERROR_STATUS_1,
+      :msg => POS_ERROR_MSG_1,
+    },
+    POS_ERROR_CODE_2 => {
+      :status => POS_ERROR_STATUS_2,
+      :msg => POS_ERROR_MSG_2,
+      :pos => :none
+    },
+    POS_ERROR_CODE_3 => {
+      :status => POS_ERROR_STATUS_3,
+      :msg => POS_ERROR_MSG_3,
+      :pos => :append
+    },
+    POS_ERROR_CODE_4 => {
+      :status => POS_ERROR_STATUS_4,
+      :msg => POS_ERROR_MSG_4,
+      :pos => :prepend
+    }
+  }
+
+  class PosError < CodeError::Base
+    error_codes (POS_ERROR_CODES)
+  end
+
+  def test_pos_should_put_code_in_msg_if_the_pos_arg_is_given_in_msg_and_data
+    POS_OPTIONS.each do |pos|
+      e = PosError.gen(POS_ERROR_CODE_1)
+      msg = show_code_msg(pos, POS_ERROR_MSG_1, POS_ERROR_CODE_1)
+      assert(e.msg(:pos => pos) == msg)
+      assert(e.data(:pos => pos) == { :code => POS_ERROR_CODE_1,
+                                      :status => POS_ERROR_STATUS_1,
+                                      :msg => msg,
+                                      :info => nil })
+    end
+  end
+
+  def test_pos_should_put_code_in_msg_if_the_pos_arg_is_given_in_msg_and_data_even_the_gen_has_other_pos_option
+    POS_OPTIONS.each do |pos|
+      POS_OPTIONS.each do |pos_target|
+        e = PosError.gen(POS_ERROR_CODE_1, { :pos => pos })
+        msg = show_code_msg(pos_target, POS_ERROR_MSG_1, POS_ERROR_CODE_1)
+        assert(e.msg(:pos => pos_target) == msg)
+        assert(e.data(:pos => pos_target) == { :code => POS_ERROR_CODE_1,
+                                               :status => POS_ERROR_STATUS_1,
+                                               :msg => msg,
+                                               :info => nil })
+      end
+    end
+  end
+
+  def test_pos_should_put_code_in_msg_if_the_pos_arg_is_given_in_msg_and_data_even_the_code_error_has_other_pos_option
+    POS_ERROR_CODES.each do |code, value|
+      error_code = code
+      error_msg = value[:msg]
+      error_status= value[:status]
+      POS_OPTIONS.each do |pos_target|
+        e = PosError.gen(error_code)
+        msg = show_code_msg(pos_target, error_msg, error_code)
+        assert(e.msg(:pos => pos_target) == msg)
+        assert(e.data(:pos => pos_target) == { :code => error_code,
+                                               :status => error_status,
+                                               :msg => msg,
+                                               :info => nil })
+      end
+    end
+  end
+
+  def test_pos_should_put_code_in_msg_if_the_pos_arg_is_given_in_msg_and_data_even_the_class_has_other_pos_option
+    POS_OPTIONS.each do |pos|
+      PosError.pos pos
+      POS_OPTIONS.each do |pos_target|
+        e = PosError.gen(POS_ERROR_CODE_1)
+        msg = show_code_msg(pos_target, POS_ERROR_MSG_1, POS_ERROR_CODE_1)
+        assert(e.msg(:pos => pos_target) == msg)
+        assert(e.data(:pos => pos_target) == { :code => POS_ERROR_CODE_1,
+                                               :status => POS_ERROR_STATUS_1,
+                                               :msg => msg,
+                                               :info => nil })
+      end
+    end
+  end
+
+  def test_pos_should_put_code_in_msg_if_the_gen_has_pos_option
+    POS_OPTIONS.each do |pos|
+      e = PosError.gen(POS_ERROR_CODE_1, { :pos => pos })
+      msg = show_code_msg(pos, POS_ERROR_MSG_1, POS_ERROR_CODE_1)
+      assert(e.msg == msg)
+      assert(e.data == { :code => POS_ERROR_CODE_1,
+                         :status => POS_ERROR_STATUS_1,
+                         :msg => msg,
+                         :info => nil })
+    end
+  end
+
+  def test_pos_should_put_code_in_msg_if_the_gen_has_pos_option_even_the_code_errors_has_other_pos_option
+    POS_ERROR_CODES.each do |code, value|
+      error_code = code
+      error_msg = value[:msg]
+      error_status= value[:status]
+      POS_OPTIONS.each do |pos_target|
+        e = PosError.gen(error_code, { :pos => pos_target })
+        msg = show_code_msg(pos_target, error_msg, error_code)
+        assert(e.msg == msg)
+        assert(e.data == { :code => error_code,
+                           :status => error_status,
+                           :msg => msg,
+                           :info => nil })
+      end
+    end
+  end
+
+  def test_pos_should_put_code_in_msg_if_the_gen_has_pos_option_even_the_class_has_other_pos_option
+    POS_OPTIONS.each do |pos|
+      PosError.pos pos
+      POS_OPTIONS.each do |pos_target|
+        e = PosError.gen(POS_ERROR_CODE_1, { :pos => pos_target })
+        msg = show_code_msg(pos_target, POS_ERROR_MSG_1, POS_ERROR_CODE_1)
+        assert(e.msg == msg)
+        assert(e.data == { :code => POS_ERROR_CODE_1,
+                           :status => POS_ERROR_STATUS_1,
+                           :msg => msg,
+                           :info => nil })
+      end
+    end
+  end
+
+  def test_pos_should_put_code_in_msg_if_the_code_errors_has_pos_option
+    POS_ERROR_CODES.each do |code, value|
+      error_code = code
+      error_msg = value[:msg]
+      error_status= value[:status]
+      e = PosError.gen(error_code)
+      msg = show_code_msg(value[:pos], error_msg, error_code)
+      assert(e.msg == msg)
+      assert(e.data == { :code => error_code,
+                         :status => error_status,
+                         :msg => msg,
+                         :info => nil })
+    end
+  end
+
+  def test_pos_should_put_code_in_msg_if_the_code_errors_has_pos_option_even_the_class_has_other_pos_option
+    POS_OPTIONS.each do |pos|
+      PosError.pos pos
+      POS_ERROR_CODES.each do |code, value|
+        next if value[:pos].nil?
+        error_code = code
+        error_msg = value[:msg]
+        error_status= value[:status]
+        e = PosError.gen(error_code)
+        msg = show_code_msg(value[:pos], error_msg, error_code)
+        assert(e.msg == msg)
+        assert(e.data == { :code => error_code,
+                           :status => error_status,
+                           :msg => msg,
+                           :info => nil })
+      end
+    end
+  end
+
+  def test_pos_should_put_code_in_msg_if_the_class_has_pos_option
+    POS_OPTIONS.each do |pos|
+      PosError.pos pos
+      e = PosError.gen(POS_ERROR_CODE_1)
+      msg = show_code_msg(pos, POS_ERROR_MSG_1, POS_ERROR_CODE_1)
+      assert(e.msg == msg)
+      assert(e.data == { :code => POS_ERROR_CODE_1,
+                         :status => POS_ERROR_STATUS_1,
+                         :msg => msg,
+                         :info => nil })
+    end
+  end
+
+end