require 'support/shared/integration/integration_helper'
require 'chef/mixin/properties'

module ChefMixinPropertiesSpec
  describe "Chef::Resource.property" do
    include IntegrationSupport

    context "with a base class A with properties a, ab, and ac" do
      class A
        include Chef::Mixin::Properties
        property :a, 'a', default: 'a'
        property :ab, ['a', 'b'], default: 'a'
        property :ac, ['a', 'c'], default: 'a'
      end

      context "and a module B with properties b, ab and bc" do
        module B
          include Chef::Mixin::Properties
          property :b, 'b', default: 'b'
          property :ab, default: 'b'
          property :bc, ['b', 'c'], default: 'c'
        end

        context "and a derived class C < A with properties c, ac and bc" do
          class C < A
            include B
            property :c, 'c', default: 'c'
            property :ac, default: 'c'
            property :bc, default: 'c'
          end

          it "A.properties has a, ab, and ac with types 'a', ['a', 'b'], and ['b', 'c']" do
            expect(A.properties.keys).to eq [ :a, :ab, :ac ]
            expect(A.properties[:a].validation_options[:is]).to eq 'a'
            expect(A.properties[:ab].validation_options[:is]).to eq [ 'a', 'b' ]
            expect(A.properties[:ac].validation_options[:is]).to eq [ 'a', 'c' ]
          end
          it "B.properties has b, ab, and bc with types 'b', nil and ['b', 'c']" do
            expect(B.properties.keys).to eq [ :b, :ab, :bc ]
            expect(B.properties[:b].validation_options[:is]).to eq 'b'
            expect(B.properties[:ab].validation_options[:is]).to be_nil
            expect(B.properties[:bc].validation_options[:is]).to eq [ 'b', 'c' ]
          end
          it "C.properties has a, b, c, ac and bc with merged types" do
            expect(C.properties.keys).to eq [ :a, :ab, :ac, :b, :bc, :c ]
            expect(C.properties[:a].validation_options[:is]).to eq 'a'
            expect(C.properties[:b].validation_options[:is]).to eq 'b'
            expect(C.properties[:c].validation_options[:is]).to eq 'c'
            expect(C.properties[:ac].validation_options[:is]).to eq [ 'a', 'c' ]
            expect(C.properties[:bc].validation_options[:is]).to eq [ 'b', 'c' ]
          end
          it "C.properties has ab with a non-merged type (from B)" do
            expect(C.properties[:ab].validation_options[:is]).to be_nil
          end

          context "and an instance of C" do
            let(:c) { C.new }

            it "all properties can be retrieved and merged properties default to ab->b, ac->c, bc->c" do
              expect(c.a).to  eq('a')
              expect(c.b).to  eq('b')
              expect(c.c).to  eq('c')
              expect(c.ab).to eq('b')
              expect(c.ac).to eq('c')
              expect(c.bc).to eq('c')
            end
          end
        end
      end
    end
  end

  context "with an Inner module" do
    module Inner
      include Chef::Mixin::Properties
      property :inner
    end

    context "and an Outer module including it" do
      module Outer
        include Inner
        property :outer
      end

      context "and an Outerest class including that" do
        class Outerest
          include Outer
          property :outerest
        end

        it "Outerest.properties.validation_options[:is] inner, outer, outerest" do
          expect(Outerest.properties.keys).to eq [:inner, :outer, :outerest]
        end
      end
    end
  end
end