chef 18.8.11 → 18.8.54

data/spec/unit/chef_fs/file_system/repository/base_file_spec.rb

@@ -1,126 +0,0 @@
-#
-# 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/chef_fs/file_system/repository/base_file"
-require "chef/chef_fs/file_system/repository/directory"
-require "chef/chef_fs/file_system/base_fs_object"
-require "chef/chef_fs/file_system/exceptions"
-require "chef/chef_fs/file_system/nonexistent_fs_object"
-
-describe Chef::ChefFS::FileSystem::Repository::BaseFile do
-  let(:root) do
-    Chef::ChefFS::FileSystem::BaseFSDir.new("", nil)
-  end
-
-  let(:tmp_dir) { Dir.mktmpdir }
-
-  let(:parent) do
-    Chef::ChefFS::FileSystem::Repository::Directory.new("test", root, tmp_dir)
-  end
-
-  let(:file) do
-    file = described_class.new("test_file.json", parent)
-    file.write_pretty_json = false
-    file
-  end
-
-  let(:content) { '"name": "canteloup"' }
-  let(:file_path) { File.join(tmp_dir, "test_file.json") }
-
-  after do
-    FileUtils.rm_f(file_path)
-  end
-
-  context "#is_json_file?" do
-    it "returns false when the file is not json", pending: "We assume that everything is ruby or JSON" do
-      file = described_class.new("test_file.dpkg", parent)
-      expect(file.is_json_file?).to be_falsey
-    end
-
-    it "returns true when the file is json" do
-      expect(file.is_json_file?).to be_truthy
-    end
-  end
-
-  context "#name_valid?" do
-    it "rejects dotfiles" do
-      file = described_class.new(".test_file.json", parent)
-      expect(file.name_valid?).to be_falsey
-    end
-
-    it "rejects non json files", pending: "We assume that everything is ruby or JSON" do
-      file = described_class.new("test_file.dpkg", parent)
-      expect(file.name_valid?).to be_falsey
-    end
-
-    it "allows ruby files" do
-      file = described_class.new("test_file.rb", parent)
-      expect(file.name_valid?).to be_truthy
-    end
-
-    it "allows correctly named files" do
-      expect(file.name_valid?).to be_truthy
-    end
-  end
-
-  context "#fs_entry_valid?" do
-    it "rejects invalid names" do
-      file = described_class.new("test_file.dpkg", parent)
-      expect(file.fs_entry_valid?).to be_falsey
-    end
-
-    it "rejects missing files" do
-      FileUtils.rm_f(file_path)
-      expect(file.fs_entry_valid?).to be_falsey
-    end
-
-    it "allows present and properly named files" do
-      FileUtils.touch(file_path)
-      expect(file.fs_entry_valid?).to be_truthy
-    end
-  end
-
-  context "#create" do
-    it "doesn't create an existing file" do
-      FileUtils.touch(file_path)
-      expect { file.create('"name": "canteloup"') }.to raise_error(Chef::ChefFS::FileSystem::AlreadyExistsError)
-    end
-
-    it "creates a new file" do
-      expect(file).to receive(:write).with(content)
-      expect { file.create(content) }.to_not raise_error
-    end
-
-  end
-
-  context "#write" do
-    context "minimises a json object" do
-      it "unless pretty json is off" do
-        expect(file).to_not receive(:minimize)
-        file.write(content)
-      end
-
-      it "correctly" do
-        file = described_class.new("test_file.json", parent)
-        file.write_pretty_json = true
-        expect(file).to receive(:minimize).with(content, file).and_return(content)
-        file.write(content)
-      end
-    end
-  end
-end

data/spec/unit/chef_fs/file_system/repository/directory_spec.rb

@@ -1,175 +0,0 @@
-#
-# Author:: Thom May (<thom@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/chef_fs/file_system/repository/directory"
-require "chef/chef_fs/file_system/base_fs_object"
-require "chef/chef_fs/file_system/exceptions"
-require "chef/chef_fs/file_system/nonexistent_fs_object"
-
-CHILD_FILES = %w{ test1.json test2.json skip test3.json skip2 test4 }.freeze
-
-class TestDirectory < Chef::ChefFS::FileSystem::Repository::Directory
-  def make_child_entry(name)
-    TestFile.new(name, self)
-  end
-
-  def can_have_child?(name, is_dir)
-    !is_dir && File.extname(name) == ".json"
-  end
-
-  def dir_ls
-    CHILD_FILES
-  end
-end
-
-class TestFile < Chef::ChefFS::FileSystem::BaseFSObject
-  def fs_entry_valid?
-    name.start_with? "test"
-  end
-
-  def name_valid?
-    true
-  end
-end
-
-describe Chef::ChefFS::FileSystem::Repository::Directory do
-  let(:root) do
-    Chef::ChefFS::FileSystem::BaseFSDir.new("", nil)
-  end
-
-  let(:tmp_dir) { Dir.mktmpdir }
-
-  let(:directory) do
-    described_class.new("test", root, tmp_dir)
-  end
-
-  let(:test_directory) do
-    TestDirectory.new("test", root, tmp_dir)
-  end
-
-  let(:file_double) do
-    double(TestFile, create: true, exist?: false, exists?: false)
-  end
-
-  context "#make_child_entry" do
-    it "raises if not implemented" do
-      expect { directory.send(:make_child_entry, "test") }.to raise_error("Not Implemented")
-    end
-  end
-
-  context "#create_child" do
-    it "creates a new TestFile" do
-      expect(TestFile).to receive(:new).with("test_child", test_directory).and_return(file_double)
-      allow(file_double).to receive(:file_path).and_return("#{test_directory}/test_child")
-      expect(file_double).to receive(:write).with("test")
-      test_directory.create_child("test_child", "test")
-    end
-  end
-
-  context "#child" do
-    it "returns a child if it's valid" do
-      expect(test_directory.child("test")).to be_an_instance_of(TestFile)
-    end
-
-    it "returns a non existent object otherwise" do
-      file_double = instance_double(TestFile, name_valid?: false)
-      expect(TestFile).to receive(:new).with("test_child", test_directory).and_return(file_double)
-      expect(test_directory.child("test_child")).to be_an_instance_of(Chef::ChefFS::FileSystem::NonexistentFSObject)
-    end
-  end
-
-  context "#children" do
-    before do
-      CHILD_FILES.sort.each do |child|
-        expect(TestFile).to receive(:new).with(child, test_directory).and_call_original
-      end
-    end
-
-    it "creates a child for each name" do
-      test_directory.children
-    end
-
-    it "filters invalid names" do
-      expect(test_directory.children.map(&:name)).to eql %w{ test1.json test2.json test3.json }
-    end
-  end
-
-  context "#empty?" do
-    it "is true if there are no children" do
-      expect(test_directory).to receive(:children).and_return([])
-      expect(test_directory.empty?).to be_truthy
-    end
-
-    it "is false if there are children" do
-      expect(test_directory.empty?).to be_falsey
-    end
-  end
-
-  describe "checks entry validity" do
-    it "rejects dotfiles" do
-      dir = described_class.new(".test", root, tmp_dir)
-      expect(dir.name_valid?).to be_falsey
-    end
-
-    it "rejects files" do
-      Tempfile.open("test") do |file|
-        dir = described_class.new("test", root, file.path)
-        expect(dir.name_valid?).to be_truthy
-        expect(dir.fs_entry_valid?).to be_falsey
-      end
-    end
-
-    it "accepts directories" do
-      expect(directory.name_valid?).to be_truthy
-    end
-  end
-
-  describe "creates directories" do
-    it "doesn't create an existing directory" do
-      expect { directory.create }.to raise_error(Chef::ChefFS::FileSystem::AlreadyExistsError)
-    end
-
-    it "creates a new directory" do
-      FileUtils.rmdir(tmp_dir)
-      expect(Dir).to receive(:mkdir).with(tmp_dir)
-      expect { directory.create }.to_not raise_error
-    end
-
-    after do
-      FileUtils.rm_rf(tmp_dir)
-    end
-  end
-
-  describe "deletes directories" do
-    it "won't delete a non-existant directory" do
-      FileUtils.rmdir(tmp_dir)
-      expect { directory.delete(true) }.to raise_error(Chef::ChefFS::FileSystem::NotFoundError)
-    end
-
-    it "must delete recursively" do
-      expect { directory.delete(false) }.to raise_error(Chef::ChefFS::FileSystem::MustDeleteRecursivelyError)
-    end
-
-    it "deletes a directory" do
-      expect(FileUtils).to receive(:rm_r).with(tmp_dir)
-      expect { directory.delete(true) }.to_not raise_error
-    end
-  end
-
-end

data/spec/unit/chef_fs/file_system_spec.rb

@@ -1,150 +0,0 @@
-#
-# Author:: John Keiser (<jkeiser@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/chef_fs/file_system"
-require "chef/chef_fs/file_pattern"
-
-describe Chef::ChefFS::FileSystem, ruby: ">= 3.0" do
-  include FileSystemSupport
-
-  context "with empty filesystem" do
-    let(:fs) { memory_fs("", {}) }
-
-    context "list" do
-      it "/" do
-        list_should_yield_paths(fs, "/", "/")
-      end
-      it "/a" do
-        list_should_yield_paths(fs, "/a", "/a")
-      end
-      it "/a/b" do
-        list_should_yield_paths(fs, "/a/b", "/a/b")
-      end
-      it "/*" do
-        list_should_yield_paths(fs, "/*", "/")
-      end
-    end
-
-    context "resolve_path" do
-      it "/" do
-        expect(Chef::ChefFS::FileSystem.resolve_path(fs, "/").path).to eq("/")
-      end
-      it "nonexistent /a" do
-        expect(Chef::ChefFS::FileSystem.resolve_path(fs, "/a").path).to eq("/a")
-      end
-      it "nonexistent /a/b" do
-        expect(Chef::ChefFS::FileSystem.resolve_path(fs, "/a/b").path).to eq("/a/b")
-      end
-    end
-  end
-
-  context "with a populated filesystem" do
-    let(:fs) do
-      memory_fs("", {
-        a: {
-          aa: {
-            c: "",
-            zz: "",
-          },
-          ab: {
-            c: "",
-          },
-        },
-        x: "",
-        y: {},
-      })
-    end
-    context "list" do
-      it "/**" do
-        list_should_yield_paths(fs, "/**", "/", "/a", "/x", "/y", "/a/aa", "/a/aa/c", "/a/aa/zz", "/a/ab", "/a/ab/c")
-      end
-      it "/" do
-        list_should_yield_paths(fs, "/", "/")
-      end
-      it "/*" do
-        list_should_yield_paths(fs, "/*", "/", "/a", "/x", "/y")
-      end
-      it "/*/*" do
-        list_should_yield_paths(fs, "/*/*", "/a/aa", "/a/ab")
-      end
-      it "/*/*/*" do
-        list_should_yield_paths(fs, "/*/*/*", "/a/aa/c", "/a/aa/zz", "/a/ab/c")
-      end
-      it "/*/*/?" do
-        list_should_yield_paths(fs, "/*/*/?", "/a/aa/c", "/a/ab/c")
-      end
-      it "/a/*/c" do
-        list_should_yield_paths(fs, "/a/*/c", "/a/aa/c", "/a/ab/c")
-      end
-      it "/**b/c" do
-        list_should_yield_paths(fs, "/**b/c", "/a/ab/c")
-      end
-      it "/a/ab/c" do
-        no_blocking_calls_allowed
-        list_should_yield_paths(fs, "/a/ab/c", "/a/ab/c")
-      end
-      it "nonexistent /a/ab/blah" do
-        no_blocking_calls_allowed
-        list_should_yield_paths(fs, "/a/ab/blah", "/a/ab/blah")
-      end
-      it "nonexistent /a/ab/blah/bjork" do
-        no_blocking_calls_allowed
-        list_should_yield_paths(fs, "/a/ab/blah/bjork", "/a/ab/blah/bjork")
-      end
-    end
-
-    context "resolve_path" do
-      before(:each) do
-        no_blocking_calls_allowed
-      end
-      it "resolves /" do
-        expect(Chef::ChefFS::FileSystem.resolve_path(fs, "/").path).to eq("/")
-      end
-      it "resolves /x" do
-        expect(Chef::ChefFS::FileSystem.resolve_path(fs, "/x").path).to eq("/x")
-      end
-      it "resolves /a" do
-        expect(Chef::ChefFS::FileSystem.resolve_path(fs, "/a").path).to eq("/a")
-      end
-      it "resolves /a/aa" do
-        expect(Chef::ChefFS::FileSystem.resolve_path(fs, "/a/aa").path).to eq("/a/aa")
-      end
-      it "resolves /a/aa/zz" do
-        expect(Chef::ChefFS::FileSystem.resolve_path(fs, "/a/aa/zz").path).to eq("/a/aa/zz")
-      end
-      it "resolves nonexistent /q/x/w" do
-        expect(Chef::ChefFS::FileSystem.resolve_path(fs, "/q/x/w").path).to eq("/q/x/w")
-      end
-    end
-
-    context "empty?" do
-      it "is not empty /" do
-        expect(Chef::ChefFS::FileSystem.resolve_path(fs, "/").empty?).to be false
-      end
-      it "is empty /y" do
-        expect(Chef::ChefFS::FileSystem.resolve_path(fs, "/y").empty?).to be true
-      end
-      it "is not a directory and can't be tested /x" do
-        expect { Chef::ChefFS::FileSystem.resolve_path(fs, "/x").empty? }.to raise_error(NoMethodError)
-      end
-    end
-  end
-
-  # Need to add the test case for copy_to method - not able to do the implimentation with Dir.mktmpdir
-end

data/spec/unit/chef_fs/path_util_spec.rb

@@ -1,108 +0,0 @@
-#
-# Author:: Kartik Null Cating-Subramanian (<ksubramanian@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/chef_fs/path_utils"
-
-describe Chef::ChefFS::PathUtils do
-  context "invoking join" do
-    it "joins well-behaved distinct path elements" do
-      expect(Chef::ChefFS::PathUtils.join("a", "b", "c")).to eq("a/b/c")
-    end
-
-    it "strips extraneous slashes in the middle of paths" do
-      expect(Chef::ChefFS::PathUtils.join("a/", "/b", "/c/")).to eq("a/b/c")
-      expect(Chef::ChefFS::PathUtils.join("a/", "/b", "///c/")).to eq("a/b/c")
-    end
-
-    it "preserves the whether the first element was absolute or not" do
-      expect(Chef::ChefFS::PathUtils.join("/a/", "/b", "c/")).to eq("/a/b/c")
-      expect(Chef::ChefFS::PathUtils.join("///a/", "/b", "c/")).to eq("/a/b/c")
-    end
-  end
-
-  context "invoking is_absolute?" do
-    it "confirms that paths starting with / are absolute" do
-      expect(Chef::ChefFS::PathUtils.is_absolute?("/foo/bar/baz")).to be true
-      expect(Chef::ChefFS::PathUtils.is_absolute?("/foo")).to be true
-    end
-
-    it "confirms that paths starting with // are absolute even though that looks like some windows network path" do
-      expect(Chef::ChefFS::PathUtils.is_absolute?("//foo/bar/baz")).to be true
-    end
-
-    it "confirms that root is indeed absolute" do
-      expect(Chef::ChefFS::PathUtils.is_absolute?("/")).to be true
-    end
-
-    it "confirms that paths starting without / are relative" do
-      expect(Chef::ChefFS::PathUtils.is_absolute?("foo/bar/baz")).to be false
-      expect(Chef::ChefFS::PathUtils.is_absolute?("a")).to be false
-    end
-
-    it "returns false for an empty path." do
-      expect(Chef::ChefFS::PathUtils.is_absolute?("")).to be false
-    end
-  end
-
-  context "invoking realest_path" do
-    let(:good_path) { __dir__ }
-    let(:parent_path) { File.dirname(good_path) }
-
-    it "handles paths with no wildcards or globs" do
-      expect(Chef::ChefFS::PathUtils.realest_path(good_path)).to eq(File.expand_path(good_path))
-    end
-
-    it "handles paths with .. and ." do
-      expect(Chef::ChefFS::PathUtils.realest_path(good_path + "/../.")).to eq(File.expand_path(parent_path))
-    end
-
-    it "handles paths with *" do
-      expect(Chef::ChefFS::PathUtils.realest_path(good_path + "/*/foo")).to eq(File.expand_path(good_path + "/*/foo"))
-    end
-
-    it "handles directories that do not exist" do
-      expect(Chef::ChefFS::PathUtils.realest_path(good_path + "/something/or/other")).to eq(File.expand_path(good_path + "/something/or/other"))
-    end
-
-    it "handles root correctly" do
-      if ChefUtils.windows?
-        expect(Chef::ChefFS::PathUtils.realest_path("C:/")).to eq("C:/")
-      else
-        expect(Chef::ChefFS::PathUtils.realest_path("/")).to eq("/")
-      end
-    end
-  end
-
-  context "invoking descendant_path" do
-    it "handles paths with various casing on windows" do
-      allow(ChefUtils).to receive(:windows?) { true }
-      expect(Chef::ChefFS::PathUtils.descendant_path("C:/ab/b/c", "C:/AB/B")).to eq("c")
-      expect(Chef::ChefFS::PathUtils.descendant_path("C:/ab/b/c", "c:/ab/B")).to eq("c")
-    end
-
-    it "returns nil if the path does not have the given ancestor" do
-      expect(Chef::ChefFS::PathUtils.descendant_path("/D/E/F", "/A/B/C")).to be_nil
-      expect(Chef::ChefFS::PathUtils.descendant_path("/A/B/D", "/A/B/C")).to be_nil
-    end
-
-    it "returns blank if the ancestor equals the path" do
-      expect(Chef::ChefFS::PathUtils.descendant_path("/A/B/D", "/A/B/D")).to eq("")
-    end
-  end
-end

data/spec/unit/chef_spec.rb

@@ -1,25 +0,0 @@
-#
-# Author:: Adam Jacob (<adam@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"
-
-describe Chef do
-  it "should have a version defined" do
-    expect(Chef::VERSION).to match(/(\d+)\.(\d+)\.(\d+)/)
-  end
-end