chef 11.18.12-x86-mingw32 → 12.0.0.alpha.0-x86-mingw32

data/spec/support/lib/chef/resource/zen_follower.rb

@@ -1,46 +0,0 @@
-#
-# Copyright:: Copyright (c) 2014 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 'chef/knife'
-require 'chef/json_compat'
-
-class Chef
-  class Resource
-    class ZenFollower < Chef::Resource
-      attr_accessor :created_as_type
-
-      provides :follower, :on_platforms => ["zen"]
-
-      def initialize(name, run_context=nil)
-        @resource_name = :zen_follower
-        @created_as_type = "zen_follower"
-        super
-      end
-
-      def to_s
-        "#{created_as_type}[#{name}]"
-      end
-
-      def master(arg=nil)
-        if !arg.nil?
-          @master = arg
-        end
-        @master
-      end
-    end
-  end
-end

data/spec/support/shared/shared_examples.rb

@@ -1,10 +0,0 @@
-# For storing any examples shared between multiple tests
-
-# Any object which defines a .to_json should import this test
-shared_examples "to_json equalivent to Chef::JSONCompat.to_json" do
-
-  it "should allow consumers to call #to_json or Chef::JSONCompat.to_json" do
-    expect(subject.to_json).to eq(Chef::JSONCompat.to_json(subject))
-  end
-
-end

data/spec/unit/chef_fs/data_handler/group_handler_spec.rb

@@ -1,63 +0,0 @@
-#
-# Author:: Ryan Cragun (<ryan@getchef.com>)
-# Copyright:: Copyright (c) 2014 Opscode, 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 'lib/chef/chef_fs/data_handler/group_data_handler'
-
-class TestEntry < Mash
-  attr_accessor :name, :org
-
-  def initialize(name, org)
-    @name = name
-    @org = org
-  end
-end
-
-describe Chef::ChefFS::DataHandler::GroupDataHandler do
-  describe '#normalize_for_post' do
-    let(:entry) do
-      TestEntry.new('workers.json', 'hive')
-    end
-
-    let(:group) do
-      { 'name' => 'worker_bees',
-        'clients' => %w(honey sting),
-        'users' => %w(fizz buzz),
-        'actors' => %w(honey)
-      }
-    end
-
-    let(:normalized) do
-      { 'actors' =>
-          { 'users' => %w(fizz buzz),
-            'clients'=> %w(honey sting),
-            'groups'=> []
-          },
-        'groupname' => 'workers',
-        'name' => 'worker_bees',
-        'orgname' => 'hive'
-      }
-    end
-
-    let(:handler) { described_class.new }
-
-    it 'normalizes the users, clients and groups into actors' do
-      expect(handler.normalize_for_post(group, entry)).to eq(normalized)
-    end
-  end
-end

data/spec/unit/formatters/base_spec.rb

@@ -1,48 +0,0 @@
-#
-# Author:: Lamont Granquist (<lamont@getchef.com>)
-#
-# Copyright:: Copyright (c) 2012 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'
-
-describe Chef::Formatters::Base do
-  let(:out) { double("out") }
-  let(:err) { double("err") }
-  let(:formatter) { Chef::Formatters::Base.new(out, err) }
-
-  it "starts with an indentation of zero" do
-    expect(formatter.output.indent).to eql(0)
-  end
-
-  it "increments it to two correctly" do
-    formatter.indent_by(2)
-    expect(formatter.output.indent).to eql(2)
-  end
-
-  it "increments it and then decrements it corectly" do
-    formatter.indent_by(2)
-    formatter.indent_by(-2)
-    expect(formatter.output.indent).to eql(0)
-  end
-
-  it "does not allow negative indentation" do
-    formatter.indent_by(-2)
-    expect(formatter.output.indent).to eql(0)
-  end
-end
-
-

data/spec/unit/provider/dsc_script_spec.rb

@@ -1,174 +0,0 @@
-#
-# Author:: Jay Mundrawala (<jdm@getchef.com>)
-#
-# Copyright:: Copyright (c) 2014 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 'chef'
-require 'chef/util/dsc/resource_info'
-require 'spec_helper'
-
-describe Chef::Provider::DscScript do
-  context 'when DSC is available' do
-    let (:node) {
-      node = Chef::Node.new
-      node.automatic[:languages][:powershell][:version] = '4.0'
-      node
-    }
-    let (:events) { Chef::EventDispatch::Dispatcher.new }
-    let (:run_context) { Chef::RunContext.new(node, {}, events) }
-    let (:resource) { Chef::Resource::DscScript.new("script", run_context) }
-    let (:provider) do
-      Chef::Provider::DscScript.new(resource, run_context)
-    end
-
-    describe '#load_current_resource' do
-      it "describes the resource as converged if there were 0 DSC resources" do
-        allow(provider).to receive(:run_configuration).with(:test).and_return([])
-        provider.load_current_resource
-        provider.instance_variable_get('@resource_converged').should be_true
-      end
-
-      it "describes the resource as not converged if there is 1 DSC resources that is converged" do
-        dsc_resource_info = Chef::Util::DSC::ResourceInfo.new('resource', false, ['nothing will change something'])
-        allow(provider).to receive(:run_configuration).with(:test).and_return([dsc_resource_info])
-        provider.load_current_resource
-        provider.instance_variable_get('@resource_converged').should be_true
-      end
-
-      it "describes the resource as not converged if there is 1 DSC resources that is not converged" do
-        dsc_resource_info = Chef::Util::DSC::ResourceInfo.new('resource', true, ['will change something'])
-        allow(provider).to receive(:run_configuration).with(:test).and_return([dsc_resource_info])
-        provider.load_current_resource
-        provider.instance_variable_get('@resource_converged').should be_false
-      end
-
-      it "describes the resource as not converged if there are any DSC resources that are not converged" do
-        dsc_resource_info1 = Chef::Util::DSC::ResourceInfo.new('resource', true, ['will change something'])
-        dsc_resource_info2 = Chef::Util::DSC::ResourceInfo.new('resource', false, ['nothing will change something'])
-
-        allow(provider).to receive(:run_configuration).with(:test).and_return([dsc_resource_info1, dsc_resource_info2])
-        provider.load_current_resource
-        provider.instance_variable_get('@resource_converged').should be_false
-      end
-
-      it "describes the resource as converged if all DSC resources that are converged" do
-        dsc_resource_info1 = Chef::Util::DSC::ResourceInfo.new('resource', false, ['nothing will change something'])
-        dsc_resource_info2 = Chef::Util::DSC::ResourceInfo.new('resource', false, ['nothing will change something'])
-
-        allow(provider).to receive(:run_configuration).with(:test).and_return([dsc_resource_info1, dsc_resource_info2])
-        provider.load_current_resource
-        provider.instance_variable_get('@resource_converged').should be_true
-      end
-    end
-
-    describe '#generate_configuration_document' do
-      # I think integration tests should cover these cases
-
-      it 'uses configuration_document_from_script_path when a dsc script file is given' do
-        allow(provider).to receive(:load_current_resource)
-        resource.command("path_to_script")
-        generator = double('Chef::Util::DSC::ConfigurationGenerator')
-        generator.should_receive(:configuration_document_from_script_path)
-        allow(Chef::Util::DSC::ConfigurationGenerator).to receive(:new).and_return(generator)
-        provider.send(:generate_configuration_document, 'tmp', nil)
-      end
-
-      it 'uses configuration_document_from_script_code when a the dsc resource is given' do
-        allow(provider).to receive(:load_current_resource)
-        resource.code("ImADSCResource{}")
-        generator = double('Chef::Util::DSC::ConfigurationGenerator')
-        generator.should_receive(:configuration_document_from_script_code)
-        allow(Chef::Util::DSC::ConfigurationGenerator).to receive(:new).and_return(generator)
-        provider.send(:generate_configuration_document, 'tmp', nil)
-      end
-
-      it 'should noop if neither code or command are provided' do
-        allow(provider).to receive(:load_current_resource)
-        generator = double('Chef::Util::DSC::ConfigurationGenerator')
-        generator.should_receive(:configuration_document_from_script_code).with('', anything(), anything())
-        allow(Chef::Util::DSC::ConfigurationGenerator).to receive(:new).and_return(generator)
-        provider.send(:generate_configuration_document, 'tmp', nil)
-      end
-    end
-
-    describe 'action_run' do
-      it 'should converge the script if it is not converged' do
-        dsc_resource_info = Chef::Util::DSC::ResourceInfo.new('resource', true, ['will change something'])
-        allow(provider).to receive(:run_configuration).with(:test).and_return([dsc_resource_info])
-        allow(provider).to receive(:run_configuration).with(:set)
-
-        provider.run_action(:run)
-        resource.should be_updated
-      end
-
-      it 'should not converge if the script is already converged' do
-        allow(provider).to receive(:run_configuration).with(:test).and_return([])
-        
-        provider.run_action(:run)
-        resource.should_not be_updated
-      end
-    end
-
-    describe '#generate_description' do
-      it 'removes the resource name from the beginning of any log line from the LCM' do
-        dsc_resource_info = Chef::Util::DSC::ResourceInfo.new('resourcename', true, ['resourcename doing something', 'lastline'])
-        provider.instance_variable_set('@dsc_resources_info', [dsc_resource_info])
-        provider.send(:generate_description)[1].should match(/converge DSC resource resourcename by doing something/)
-      end
-
-      it 'ignores the last line' do
-        dsc_resource_info = Chef::Util::DSC::ResourceInfo.new('resourcename', true, ['resourcename doing something', 'lastline'])
-        provider.instance_variable_set('@dsc_resources_info', [dsc_resource_info])
-        provider.send(:generate_description)[1].should_not match(/lastline/)
-      end
-
-      it 'reports a dsc resource has not been changed if the LCM reported no change was required' do
-        dsc_resource_info = Chef::Util::DSC::ResourceInfo.new('resourcename', false, ['resourcename does nothing', 'lastline'])
-        provider.instance_variable_set('@dsc_resources_info', [dsc_resource_info])
-        provider.send(:generate_description)[1].should match(/converge DSC resource resourcename by doing nothing/)
-      end
-    end
-  end
-
-  context 'when Dsc is not available' do
-    let (:node) { Chef::Node.new }
-    let (:events) { Chef::EventDispatch::Dispatcher.new }
-    let (:run_context) { Chef::RunContext.new(node, {}, events) }
-    let (:resource) { Chef::Resource::DscScript.new('script', run_context) }
-    let (:provider) { Chef::Provider::DscScript.new(resource, run_context) }
-
-    describe 'action_run' do
-      ['1.0', '2.0', '3.0'].each do |version|
-        it "raises an exception for powershell version '#{version}'" do
-          node.automatic[:languages][:powershell][:version] = version
-
-          expect {
-            provider.run_action(:run)
-          }.to raise_error(Chef::Exceptions::NoProviderAvailable)
-        end
-      end
-
-      it 'raises an exception if Powershell is not present' do
-        expect {
-          provider.run_action(:run)
-        }.to raise_error(Chef::Exceptions::NoProviderAvailable)
-      end
-
-    end
-  end
-end
-

data/spec/unit/resource/dsc_script_spec.rb

@@ -1,98 +0,0 @@
-#
-# Author:: Adam Edwards (<adamed@getchef.com>)
-# Copyright:: Copyright (c) 2014 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'
-
-describe Chef::Resource::DscScript do
-  let(:dsc_test_resource_name) { 'DSCTest' }
-
-  context 'when Powershell supports Dsc' do
-    let(:dsc_test_run_context) {
-      node = Chef::Node.new
-      node.automatic[:languages][:powershell][:version] = '4.0'
-      empty_events = Chef::EventDispatch::Dispatcher.new
-      Chef::RunContext.new(node, {}, empty_events)
-    }
-    let(:dsc_test_resource) {
-      Chef::Resource::DscScript.new(dsc_test_resource_name, dsc_test_run_context) 
-    }
-    let(:configuration_code) {'echo "This is supposed to create a configuration document."'}
-    let(:configuration_path) {'c:/myconfigs/formatc.ps1'}
-    let(:configuration_name) { 'formatme' }
-    let(:configuration_data) { '@{AllNodes = @( @{ NodeName = "localhost"; PSDscAllowPlainTextPassword = $true })}' }
-    let(:configuration_data_script) { 'c:/myconfigs/data/safedata.psd1' }
-
-    it "has a default action of `:run`" do
-      expect(dsc_test_resource.action).to eq(:run)
-    end
-
-    it "has an allowed_actions attribute with only the `:run` and `:nothing` attributes" do
-      expect(dsc_test_resource.allowed_actions.to_set).to eq([:run,:nothing].to_set)
-    end
-
-    it "allows the code attribute to be set" do
-      dsc_test_resource.code(configuration_code)
-      expect(dsc_test_resource.code).to eq(configuration_code)
-    end
-
-    it "allows the command attribute to be set" do
-      dsc_test_resource.command(configuration_path)
-      expect(dsc_test_resource.command).to eq(configuration_path)
-    end
-
-    it "allows the configuration_name attribute to be set" do
-      dsc_test_resource.configuration_name(configuration_name)
-      expect(dsc_test_resource.configuration_name).to eq(configuration_name)
-    end
-
-    it "allows the configuration_data attribute to be set" do
-      dsc_test_resource.configuration_data(configuration_data)
-      expect(dsc_test_resource.configuration_data).to eq(configuration_data)
-    end
-
-    it "allows the configuration_data_script attribute to be set" do
-      dsc_test_resource.configuration_data_script(configuration_data_script)
-      expect(dsc_test_resource.configuration_data_script).to eq(configuration_data_script)
-    end
-
-    it "raises an ArgumentError exception if an attempt is made to set the code attribute when the command attribute is already set" do
-      dsc_test_resource.command(configuration_path)
-      expect { dsc_test_resource.code(configuration_code) }.to raise_error(ArgumentError)
-    end
-
-    it "raises an ArgumentError exception if an attempt is made to set the command attribute when the code attribute is already set" do
-      dsc_test_resource.code(configuration_code)
-      expect { dsc_test_resource.command(configuration_path) }.to raise_error(ArgumentError)
-    end
-
-    it "raises an ArgumentError exception if an attempt is made to set the configuration_name attribute when the code attribute is already set" do
-      dsc_test_resource.code(configuration_code)
-      expect { dsc_test_resource.configuration_name(configuration_name) }.to raise_error(ArgumentError)
-    end
-
-    it "raises an ArgumentError exception if an attempt is made to set the configuration_data attribute when the configuration_data_script attribute is already set" do
-      dsc_test_resource.configuration_data_script(configuration_data_script)
-      expect { dsc_test_resource.configuration_data(configuration_data) }.to raise_error(ArgumentError)
-    end
-
-    it "raises an ArgumentError exception if an attempt is made to set the configuration_data_script attribute when the configuration_data attribute is already set" do
-      dsc_test_resource.configuration_data(configuration_data)
-      expect { dsc_test_resource.configuration_data_script(configuration_data_script) }.to raise_error(ArgumentError)
-    end
-  end
-end

data/spec/unit/util/dsc/configuration_generator_spec.rb

@@ -1,171 +0,0 @@
-#
-# Author:: Jay Mundrawala <jmundrawala@getchef.com>
-# Copyright:: Copyright (c) 2014 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 'chef'
-require 'chef/util/dsc/configuration_generator'
-
-describe Chef::Util::DSC::ConfigurationGenerator do
-  let(:conf_man) do
-    node = Chef::Node.new
-    Chef::Util::DSC::ConfigurationGenerator.new(node, 'tmp')
-  end
-
-  describe '#validate_configuration_name!' do
-    it 'should not raise an error if a name contains all upper case letters' do
-      conf_man.send(:validate_configuration_name!, "HELLO")
-    end
-
-    it 'should not raise an error if the name contains all lower case letters' do
-      conf_man.send(:validate_configuration_name!, "hello")
-    end
-
-    it 'should not raise an error if no special characters are used except _' do
-      conf_man.send(:validate_configuration_name!, "hello_world")
-    end
-
-    %w{! @ # $ % ^ & * & * ( ) - = + \{ \} . ? < > \\ /}.each do |sym|
-      it "raises an Argument error if it configuration name contains #{sym}" do
-        expect {
-          conf_man.send(:validate_configuration_name!, "Hello#{sym}")
-        }.to raise_error(ArgumentError)
-      end
-    end
-  end
-
-  describe "#get_merged_configuration_flags" do
-    context 'when strings are used as switches' do
-      it 'should merge the hash if there are no restricted switches' do
-        merged = conf_man.send(:get_merged_configuration_flags!, {'flag' => 'a'}, 'hello')
-        merged.should include(:flag)
-        merged[:flag].should eql('a')
-        merged.should include(:outputpath)
-      end
-
-      it 'should raise an ArgumentError if you try to override outputpath' do
-        expect {
-          conf_man.send(:get_merged_configuration_flags!, {'outputpath' => 'a'}, 'hello')
-        }.to raise_error(ArgumentError)
-      end
-
-      it 'should be case insensitive for switches that are not allowed' do
-        expect {
-          conf_man.send(:get_merged_configuration_flags!, {'OutputPath' => 'a'}, 'hello')
-        }.to raise_error(ArgumentError)
-      end
-
-      it 'should be case insensitive to switches that are allowed' do
-        merged = conf_man.send(:get_merged_configuration_flags!, {'FLAG' => 'a'}, 'hello')
-        merged.should include(:flag)
-      end
-    end
-
-    context 'when symbols are used as switches' do
-      it 'should merge the hash if there are no restricted switches' do
-        merged = conf_man.send(:get_merged_configuration_flags!, {:flag => 'a'}, 'hello')
-        merged.should include(:flag)
-        merged[:flag].should eql('a')
-        merged.should include(:outputpath)
-      end
-
-      it 'should raise an ArgumentError if you try to override outputpath' do
-        expect {
-          conf_man.send(:get_merged_configuration_flags!, {:outputpath => 'a'}, 'hello')
-        }.to raise_error(ArgumentError)
-      end
-
-      it 'should be case insensitive for switches that are not allowed' do
-        expect {
-          conf_man.send(:get_merged_configuration_flags!, {:OutputPath => 'a'}, 'hello')
-        }.to raise_error(ArgumentError)
-      end
-
-      it 'should be case insensitive to switches that are allowed' do
-        merged = conf_man.send(:get_merged_configuration_flags!, {:FLAG => 'a'}, 'hello')
-        merged.should include(:flag)
-      end
-    end
-
-    context 'when there are no flags' do
-      it 'should supply an output path if configuration_flags is an empty hash' do
-        merged = conf_man.send(:get_merged_configuration_flags!, {}, 'hello')
-        merged.should include(:outputpath)
-        merged.length.should eql(1)
-      end
-
-      it 'should supply an output path if configuration_flags is an empty hash' do
-        merged = conf_man.send(:get_merged_configuration_flags!, nil, 'hello')
-        merged.should include(:outputpath)
-        merged.length.should eql(1)
-      end
-    end
-
-    # What should happen if configuration flags contains duplicates?
-    # flagA => 'a', flaga => 'a'
-    # or
-    # flagA => 'a', flaga => 'b'
-    #
-  end
-
-  describe '#write_document_generation_script' do
-    let(:file_like_object) { double("file like object") }
-
-    it "should write the input to a file" do
-      allow(File).to receive(:open).and_yield(file_like_object)
-      allow(File).to receive(:join) do |a, b|
-        [a,b].join("++")
-      end
-      allow(file_like_object).to receive(:write)
-      conf_man.send(:write_document_generation_script, 'file', 'hello')
-      expect(file_like_object).to have_received(:write)
-    end
-  end
-
-  describe "#find_configuration_document" do
-    it "should find the mof file" do
-      # These tests seem way too implementation specific. Unfortunatly, File and Dir
-      # need to be mocked because they are OS specific
-      allow(File).to receive(:join) do |a, b|
-        [a,b].join("++")
-      end
-
-      allow(Dir).to receive(:entries).with("tmp++hello") {['f1', 'f2', 'hello.mof', 'f3']}
-      expect(conf_man.send(:find_configuration_document, 'hello')).to eql('tmp++hello++hello.mof')
-    end
-
-    it "should return nil if the mof file is not found" do
-      allow(File).to receive(:join) do |a, b|
-        [a,b].join("++")
-      end
-      allow(Dir).to receive(:entries).with("tmp++hello") {['f1', 'f2', 'f3']}
-      expect(conf_man.send(:find_configuration_document, 'hello')).to be_nil
-    end
-  end
-
-  describe "#configuration_code" do
-    it "should build dsc" do
-      dsc = conf_man.send(:configuration_code, 'archive{}', 'hello')
-      found_configuration = false
-      dsc.split(';').each do |command|
-        if command.downcase =~ /\s*configuration\s+'hello'\s*\{\s*node\s+'localhost'\s*\{\s*archive\s*\{\s*\}\s*\}\s*\}\s*/
-          found_configuration = true
-        end
-      end
-      expect(found_configuration).to be_true
-    end
-  end
-end