#
# Author:: Seth Falcon (<seth@chef.io>)
# Copyright:: Copyright (c) Chef Software Inc.
# License:: Apache License, Version 2.0
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#

require "spec_helper"
require "chef/dsl/platform_introspection"

class LanguageTester
  attr_reader :node
  def initialize(node)
    @node = node
  end
  include Chef::DSL::PlatformIntrospection
end

describe "PlatformIntrospection implementors" do

  let(:node) { Chef::Node.new }
  let(:platform_introspector) { LanguageTester.new(node) }

  it_behaves_like "a platform introspector"

end

describe Chef::DSL::PlatformIntrospection::PlatformDependentValue do
  before do
    platform_hash = {
      :openbsd => { default: "free, functional, secure" },
      %i{redhat centos fedora scientific} => { default: '"stable"' },
      :ubuntu => { "10.04" => "using upstart more", :default => "using init more" },
      :default => "bork da bork",
    }
    @platform_specific_value = Chef::DSL::PlatformIntrospection::PlatformDependentValue.new(platform_hash)
  end

  it "returns the default value when the platform doesn't match" do
    expect(@platform_specific_value.value_for_node(platform: :dos)).to eq("bork da bork")
  end

  it "returns a value for a platform set as a group" do
    expect(@platform_specific_value.value_for_node(platform: :centos)).to eq('"stable"')
  end

  it "returns a value for the platform when it was set as a symbol but fetched as a string" do
    expect(@platform_specific_value.value_for_node(platform: "centos")).to eq('"stable"')
  end

  it "returns a value for a specific platform version" do
    node = { platform: "ubuntu", platform_version: "10.04" }
    expect(@platform_specific_value.value_for_node(node)).to eq("using upstart more")
  end

  it "returns a platform-default value if the platform version doesn't match an explicit one" do
    node = { platform: "ubuntu", platform_version: "9.10" }
    expect(@platform_specific_value.value_for_node(node)).to eq("using init more")
  end

  it "returns nil if there is no default and no platforms match" do
    # this matches the behavior in the original implementation.
    # whether or not it's correct is another matter.
    platform_specific_value = Chef::DSL::PlatformIntrospection::PlatformDependentValue.new({})
    expect(platform_specific_value.value_for_node(platform: "foo")).to be_nil
  end

  it "raises an argument error if the platform hash is not correctly structured" do
    bad_hash = { ubuntu: :foo } # should be :ubuntu => {:default => 'foo'}
    expect { Chef::DSL::PlatformIntrospection::PlatformDependentValue.new(bad_hash) }.to raise_error(ArgumentError)
  end

end
describe Chef::DSL::PlatformIntrospection::PlatformFamilyDependentValue do
  before do
    @array_values = %i{stop start reload}

    @platform_family_hash = {
      "debian" => "debian value",
      [:rhel, "fedora"] => "redhatty value",
      "suse" => @array_values,
      :gentoo => "gentoo value",
      :default => "default value",
    }

    @platform_family_value = Chef::DSL::PlatformIntrospection::PlatformFamilyDependentValue.new(@platform_family_hash)
  end

  it "returns the default value when the platform family doesn't match" do
    expect(@platform_family_value.value_for_node(platform_family: :os2)).to eq("default value")
  end

  it "returns a value for the platform family when it was set as a string but fetched as a symbol" do
    expect(@platform_family_value.value_for_node(platform_family: :debian)).to eq("debian value")
  end

  it "returns a value for the platform family when it was set as a symbol but fetched as a string" do
    expect(@platform_family_value.value_for_node(platform_family: "gentoo")).to eq("gentoo value")
  end

  it "returns an array value stored for a platform family" do
    expect(@platform_family_value.value_for_node(platform_family: "suse")).to eq(@array_values)
  end

  it "returns a value for the platform family when it was set within an array hash key as a symbol" do
    expect(@platform_family_value.value_for_node(platform_family: :rhel)).to eq("redhatty value")
  end

  it "returns a value for the platform family when it was set within an array hash key as a string" do
    expect(@platform_family_value.value_for_node(platform_family: "fedora")).to eq("redhatty value")
  end

  it "returns nil if there is no default and no platforms match" do
    platform_specific_value = Chef::DSL::PlatformIntrospection::PlatformFamilyDependentValue.new({})
    expect(platform_specific_value.value_for_node(platform_family: "foo")).to be_nil
  end

end

describe "ChefHelper functions mixed into classes" do
  METHODS = %i{windows? fedora_derived? bsd_based? rhel? aix? gentoo?}.freeze

  METHODS.each do |method|
    it "mixes #{method} into Chef::Resource instances" do
      expect(Chef::Resource.instance_methods.include?(method)).to be true
    end

    it "mixes #{method} into Chef::Resource classes (provides lines, etc)" do
      expect(Chef::Resource.respond_to?(method)).to be true
    end

    it "mixes #{method} into Chef::Provider instances (actions)" do
      expect(Chef::Provider.instance_methods.include?(method)).to be true
    end

    it "mixes #{method} into Chef::Provider classes (provides lines, etc)" do
      expect(Chef::Provider.respond_to?(method)).to be true
    end

    it "mixes #{method} into Chef::Recipe instances (recipe files)" do
      expect(Chef::Recipe.instance_methods.include?(method)).to be true
    end

    it "mixes #{method} into Chef::Node instances (attribute files)" do
      expect(Chef::Recipe.instance_methods.include?(method)).to be true
    end
  end
end