# encoding: utf-8
require 'spec_helper'
require 'dslable_dsl'

describe Dslable::Dsl do
  context :gem_name do
    cases = [
      {
        case_no: 1,
        case_title: 'valid gem name',
        input: 'abcdefghijklmnopqrstuvwxyz01234567891_',
        expected: 'abcdefghijklmnopqrstuvwxyz01234567891_'
      },
      {
        case_no: 2,
        case_title: 'empty gem name',
        input: '',
        expect_error: true
      },
      {
        case_no: 3,
        case_title: 'nil gem name',
        input: nil,
        expect_error: true
      },
      {
        case_no: 4,
        case_title: 'invalid gem name contain space',
        input: 'gem 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_dsl = Dslable::Dsl.new

          # -- when --
          if c[:expect_error]
            lambda { dslable_dsl.gem_name c[:input] }.should raise_error(Dslable::InvalidDslError)
            next
          end
          dslable_dsl.gem_name c[:input]
          actual = dslable_dsl._gem_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 :gem_desc do
    cases = [
      {
        case_no: 1,
        case_title: 'valid gem desc',
        input: 'abcdefghijklmnopqrstuvwxyz01234567891_',
        expected: 'abcdefghijklmnopqrstuvwxyz01234567891_'
      },
      {
        case_no: 2,
        case_title: 'empty gem desc',
        input: '',
        expect_error: true
      },
      {
        case_no: 3,
        case_title: 'nil gem desc',
        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_dsl = Dslable::Dsl.new

          # -- when --
          if c[:expect_error]
            lambda { dslable_dsl.gem_desc c[:input] }.should raise_error(Dslable::InvalidDslError)
            next
          end
          dslable_dsl.gem_desc c[:input]
          actual = dslable_dsl._gem_desc

          # -- 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 :field do
    cases = [
      {
        case_no: 1,
        case_title: 'case_title',
        input_field_name: :field_name,
        input_field_desc: 'field_desc',
        input_args_name: :args_name,
        input_args_desc: 'args_desc',
        expected_field_name: :field_name,
        expected_field_desc: 'field_desc',
        expected_args_name: :args_name,
        expected_args_desc: 'args_desc',
      },
    ]

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

          # -- given --
          dslable_dsl = Dslable::Dsl.new

          # -- when --
          dslable_dsl.field c[:input_field_name] do |f|
            f.desc c[:input_field_desc]
            f.args c[:input_args_name] do |a|
              a.desc c[:input_args_desc]
            end
          end

          # -- then --
          actual = dslable_dsl.fields.first
          expect(actual._field_name).to eq(c[:expected_field_name])
          expect(actual._desc).to eq(c[:expected_field_desc])
          expect(actual._args._args_name).to eq(c[:expected_args_name])
          expect(actual._args._desc).to eq(c[:expected_args_desc])
        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 :bin_name do
    cases = [
      {
        case_no: 1,
        case_title: 'valid bin name',
        input: 'abcdefghijklmnopqrstuvwxyz01234567891_',
        expected: 'abcdefghijklmnopqrstuvwxyz01234567891_'
      },
      {
        case_no: 2,
        case_title: 'empty bin name',
        input: '',
        expect_error: true
      },
      {
        case_no: 3,
        case_title: 'nil bin name',
        input: nil,
        expect_error: true
      },
      {
        case_no: 4,
        case_title: 'invalid bin name contain space',
        input: 'bin 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_dsl = Dslable::Dsl.new

          # -- when --
          if c[:expect_error]
            lambda { dslable_dsl.bin_name c[:input] }.should raise_error(Dslable::InvalidDslError)
            next
          end
          dslable_dsl.bin_name c[:input]
          actual = dslable_dsl._bin_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
end