# encoding: utf-8
require "spec_helper"
require "dslable_args"

describe Dslable::Args do
  context :desc do
    cases = [
      {
        case_no: 1,
        case_title: "valid description",
        input: "this is descripotion",
        expected: "this is descripotion"
      },
      {
        case_no: 2,
        case_title: "empty description",
        input: "",
        expected: ""
      },
      {
        case_no: 3,
        case_title: "nil description",
        input: nil,
        expected: ""
      },
    ]

    cases.each do |c|
      it "|case_no=#{c[:case_no]}|case_title=#{c[:case_title]}" do
        begin
          case_before c

          # -- given --
          dslable_args = Dslable::Args.new

          # -- when --
          dslable_args.desc c[:input]

          # -- then --
          actual = dslable_args._desc
          expect(actual).to eq(c[:expected])
        ensure
          case_after c
        end
      end

      def case_before(c)
        # implement each case before
      end

      def case_after(c)
        # implement each case after
      end
    end
  end

  context :args_name do
    cases = [
      {
        case_no: 1,
        case_title: "valid dsl_args name",
        input: "abcdefghijklmnopqrstuvwxyz01234567891_",
        expected: "abcdefghijklmnopqrstuvwxyz01234567891_"
      },
      {
        case_no: 2,
        case_title: "empty dsl_args name",
        input: "",
        expect_error: true
      },
      {
        case_no: 3,
        case_title: "nil dsl_args name",
        input: nil,
        expect_error: true
      },
      {
        case_no: 4,
        case_title: "invalid dsl_args name contain space",
        input: "method name",
        expect_error: true
      },
    ]

    cases.each do |c|
      it "|case_no=#{c[:case_no]}|case_title=#{c[:case_title]}" do
        begin
          case_before c

          # -- given --
          dslable_args = Dslable::Args.new

          # -- when --
          if c[:expect_error]
            lambda {dslable_args.args_name c[:input]}.should raise_error(Dslable::InvalidArgsError)
            next
          end
          dslable_args.args_name c[:input]
          actual = dslable_args._args_name

          # -- then --
          expect(actual).to eq(c[:expected])
        ensure
          case_after c
        end
      end

      def case_before(c)
        # implement each case before
      end

      def case_after(c)
        # implement each case after
      end
    end
  end

  context :klass do
    cases = [
      {
        case_no: 1,
        case_title: "valid klass String",
        input: String,
        expected: String
      },
      {
        case_no: 2,
        case_title: "valid klass Array",
        input: Array,
        expected: Array
      },
      {
        case_no: 3,
        case_title: "valid klass Hash",
        input: Hash,
        expected: Hash
      },
      {
        case_no: 4,
        case_title: "invalid klass Hash",
        input: Fixnum,
        expect_error: true
      },
      {
        case_no: 5,
        case_title: "nil klass",
        input: nil,
        expect_error: true
      },
    ]

    cases.each do |c|
      it "|case_no=#{c[:case_no]}|case_title=#{c[:case_title]}" do
        begin
          case_before c

          # -- given --
          dslable_args = Dslable::Args.new

          # -- when --
          if c[:expect_error]
            lambda {dslable_args.klass c[:input]}.should raise_error(Dslable::InvalidArgsError)
            next
          end
          dslable_args.klass c[:input]
          actual = dslable_args._klass

          # -- then --
          expect(actual).to eq(c[:expected])
        ensure
          case_after c
        end
      end

      def case_before(c)
        # implement each case before
      end

      def case_after(c)
        # implement each case after
      end
    end
  end

  context :required do
    cases = [
      {
        case_no: 1,
        case_title: "valid required",
        expected: true
      },
    ]

    cases.each do |c|
      it "|case_no=#{c[:case_no]}|case_title=#{c[:case_title]}" do
        begin
          case_before c

          # -- given --
          dslable_args = Dslable::Args.new

          # -- when --
          dslable_args.required
          actual = dslable_args._required

          # -- then --
          expect(actual).to eq(c[:expected])
        ensure
          case_after c
        end
      end

      def case_before(c)
        # implement each case before
      end

      def case_after(c)
        # implement each case after
      end
    end
  end

  context :default_value do
    cases = [
      {
        case_no: 1,
        case_title: "valid default",
        input: "valid default",
        expected: "valid default"
      },
    ]

    cases.each do |c|
      it "|case_no=#{c[:case_no]}|case_title=#{c[:case_title]}" do
        begin
          case_before c

          # -- given --
          dslable_args = Dslable::Args.new

          # -- when --
          dslable_args.default_value c[:input]
          actual = dslable_args._default_value

          # -- then --
          expect(actual).to eq(c[:expected])
        ensure
          case_after c
        end
      end

      def case_before(c)
        # implement each case before
      end

      def case_after(c)
        # implement each case after
      end
    end
  end

end