chef-cli 1.0.3

data/spec/unit/policyfile/cookbook_location_specification_spec.rb

@@ -0,0 +1,347 @@
+#
+# Copyright:: Copyright (c) 2014-2018 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-cli/policyfile/cookbook_location_specification"
+
+describe ChefCLI::Policyfile::CookbookLocationSpecification do
+
+  let(:policyfile_filename) { File.join(fixtures_path, "example_app/Policyfile.rb") }
+
+  let(:version_constraint) { ">= 0.0.0" }
+
+  let(:cookbook_name) { "my_cookbook" }
+
+  let(:source_options) { {} }
+
+  let(:cached_cookbook) { double("ChefCLI::CookbookMetadata") }
+
+  let(:install_path) { Pathname.new("~/.chefcli/cache/cookbooks/my_cookbook-1.0.0") }
+
+  let(:installer) { double("CookbookOmnifetch location", cached_cookbook: cached_cookbook, install_path: install_path) }
+
+  let(:storage_config) do
+    ChefCLI::Policyfile::StorageConfig.new.use_policyfile(policyfile_filename)
+  end
+
+  let(:cookbook_location_spec) { described_class.new(cookbook_name, version_constraint, source_options, storage_config) }
+
+  it "has a name" do
+    expect(cookbook_location_spec.name).to eq(cookbook_name)
+  end
+
+  it "has a version constraint" do
+    expect(cookbook_location_spec.version_constraint).to eq(Semverse::Constraint.new(version_constraint))
+  end
+
+  it "has source options it was created with" do
+    expect(cookbook_location_spec.source_options).to eq(source_options)
+  end
+
+  it "is equal to another cookbook spec with the same name, constraint, and options" do
+    equal_spec = described_class.new(cookbook_name, version_constraint, source_options, storage_config)
+    expect(cookbook_location_spec).to eq(equal_spec)
+  end
+
+  it "is not equal to another cookbook spec if the name, constraint or option differ" do
+    different_name = described_class.new("wut", version_constraint, source_options, storage_config)
+    expect(cookbook_location_spec).to_not eq(different_name)
+
+    different_constraint = described_class.new(cookbook_name, ">= 1.0.0", source_options, storage_config)
+    expect(cookbook_location_spec).to_not eq(different_constraint)
+
+    different_opts = described_class.new(cookbook_name, version_constraint, { git: "git://example.com/wat.git" }, storage_config)
+    expect(cookbook_location_spec).to_not eq(different_opts)
+  end
+
+  it "gives the base directory from which relative paths will be expanded" do
+    expect(cookbook_location_spec.relative_paths_root).to eq(File.join(fixtures_path, "example_app"))
+  end
+
+  it "gives source options for locking via the installer" do
+    lock_data = double("Installer lock data")
+    expect(installer).to receive(:lock_data).and_return(lock_data)
+    expect(cookbook_location_spec).to receive(:installer).and_return(installer)
+    expect(cookbook_location_spec.source_options_for_lock).to eq(lock_data)
+  end
+
+  it "converts to a readable string with all relevant info" do
+    expected_s = "Cookbook 'my_cookbook' >= 0.0.0"
+    expect(cookbook_location_spec.to_s).to eq(expected_s)
+  end
+
+  describe "fetching and querying a cookbook" do
+
+    before do
+      expect(CookbookOmnifetch).to receive(:init).with(cookbook_location_spec, source_options).and_return(installer)
+    end
+
+    it "initializes a CookbookOmnifetch location class to handle installation" do
+      expect(cookbook_location_spec.installer).to eq(installer)
+    end
+
+    it "delegates #installed? to the installer" do
+      expect(installer).to receive(:installed?).and_return(false)
+      expect(cookbook_location_spec).to_not be_installed
+      expect(installer).to receive(:installed?).and_return(true)
+      expect(cookbook_location_spec).to be_installed
+    end
+
+    it "delegates installation to the installer" do
+      expect(installer).to receive(:installed?).and_return(false)
+      expect(installer).to receive(:install)
+      cookbook_location_spec.ensure_cached
+    end
+
+    it "does not install the cookbook if it's already cached" do
+      expect(installer).to receive(:installed?).and_return(true)
+      expect(installer).to_not receive(:install)
+      cookbook_location_spec.ensure_cached
+    end
+
+    it "delegates cache_key to the installer" do
+      expect(installer).to receive(:cache_key).and_return("my_cookbook-1.2.3-supermarket.chef.io")
+      expect(cookbook_location_spec.cache_key).to eq("my_cookbook-1.2.3-supermarket.chef.io")
+    end
+
+    it "delegates relative_path to the installer" do
+      expect(installer).to receive(:relative_path).and_return(Pathname.new("../my_stuff/my_cookbook"))
+      expect(cookbook_location_spec.relative_path).to eq("../my_stuff/my_cookbook")
+    end
+
+    it "loads the cookbook metadata via the installer" do
+      expect(cookbook_location_spec.cached_cookbook).to eq(cached_cookbook)
+    end
+
+    it "gives the cookbook's version via the metadata" do
+      expect(cached_cookbook).to receive(:version).and_return("1.2.3")
+      expect(cookbook_location_spec.version).to eq("1.2.3")
+    end
+
+    it "gives the cookbook's dependencies via the metadata" do
+      expect(cached_cookbook).to receive(:dependencies).and_return("apt" => "~> 1.2.3")
+      expect(cookbook_location_spec.dependencies).to eq("apt" => "~> 1.2.3")
+    end
+
+    it "determines whether a cookbook has a given recipe" do
+      cookbook_path = cookbook_location_spec.cookbook_path
+      # "cache" cookbook_path so we stub the correct object
+      allow(cookbook_location_spec).to receive(:cookbook_path).and_return(cookbook_path)
+
+      default_recipe_path = install_path.join("recipes/default.rb")
+      nope_recipe_path = install_path.join("recipes/nope.rb")
+
+      expect(cookbook_path).to receive(:join).with("recipes/default.rb").and_return(default_recipe_path)
+      expect(cookbook_path).to receive(:join).with("recipes/nope.rb").and_return(nope_recipe_path)
+
+      expect(default_recipe_path).to receive(:exist?).and_return(true)
+      expect(nope_recipe_path).to receive(:exist?).and_return(false)
+
+      expect(cookbook_location_spec.cookbook_has_recipe?("default")).to be(true)
+      expect(cookbook_location_spec.cookbook_has_recipe?("nope")).to be(false)
+    end
+
+  end
+
+  describe "when created with no source" do
+
+    it "has a nil installer" do
+      expect(cookbook_location_spec.installer).to be_nil
+    end
+
+    it "is not at a fixed version" do
+      expect(cookbook_location_spec.version_fixed?).to be false
+    end
+
+  end
+
+  describe "when created with invalid source options" do
+
+    let(:source_options) { { herp: "derp" } }
+
+    it "is invalid" do
+      expect(cookbook_location_spec).to_not be_valid
+      expect(cookbook_location_spec.errors.size).to eq(1)
+      error = cookbook_location_spec.errors.first
+      expect(error).to eq("Cookbook `my_cookbook' has invalid source options `{:herp=>\"derp\"}'")
+    end
+
+  end
+
+  describe "when created with a git source" do
+
+    let(:source_options) { { git: "git@github.com:example/my_cookbook.git" } }
+
+    it "has a git installer" do
+      expect(cookbook_location_spec.installer).to be_a_kind_of(CookbookOmnifetch::GitLocation)
+    end
+
+    it "has a fixed version" do
+      expect(cookbook_location_spec.version_fixed?).to be true
+    end
+
+    it "mirrors a canonical upstream" do
+      expect(cookbook_location_spec.mirrors_canonical_upstream?).to be true
+    end
+
+    it "is valid" do
+      expect(cookbook_location_spec.errors.size).to eq(0)
+      expect(cookbook_location_spec).to be_valid
+    end
+
+  end
+
+  describe "when created with a github source" do
+
+    let(:source_options) { { github: "my_org/my_cookbook" } }
+
+    it "has a github installer" do
+      expect(cookbook_location_spec.installer).to be_a_kind_of(CookbookOmnifetch::GithubLocation)
+    end
+
+    it "has a fixed version" do
+      expect(cookbook_location_spec.version_fixed?).to be true
+    end
+
+    it "mirrors a canonical upstream" do
+      expect(cookbook_location_spec.mirrors_canonical_upstream?).to be true
+    end
+
+    it "is valid" do
+      expect(cookbook_location_spec.errors.size).to eq(0)
+      expect(cookbook_location_spec).to be_valid
+    end
+
+  end
+
+  describe "when created with a path source" do
+
+    let(:source_options) { { path: "../example_cookbook" } }
+
+    it "has a path installer" do
+      expect(cookbook_location_spec.installer).to be_a_kind_of(CookbookOmnifetch::PathLocation)
+    end
+
+    it "has a fixed version" do
+      expect(cookbook_location_spec.version_fixed?).to be true
+    end
+
+    it "isnt a mirror of a canonical upstream" do
+      expect(cookbook_location_spec.mirrors_canonical_upstream?).to be false
+    end
+
+    it "is valid" do
+      expect(cookbook_location_spec.errors.size).to eq(0)
+      expect(cookbook_location_spec).to be_valid
+    end
+
+  end
+
+  describe "when created with an artifactserver source" do
+
+    let(:source_options) { { artifactserver: "https://supermarket.chef.io:/api/v1/cookbooks/my_cookbook/versions/2.0.0/download" } }
+
+    it "has a artifactserver installer" do
+      expect(cookbook_location_spec.installer).to be_a_kind_of(CookbookOmnifetch::ArtifactserverLocation)
+    end
+
+    it "does not have a fixed version" do
+      expect(cookbook_location_spec.version_fixed?).to be false
+    end
+
+    it "is a mirror of a canonical upstream" do
+      expect(cookbook_location_spec.mirrors_canonical_upstream?).to be true
+    end
+
+    it "is valid" do
+      expect(cookbook_location_spec.errors.size).to eq(0)
+      expect(cookbook_location_spec).to be_valid
+    end
+
+  end
+
+  describe "when created with a chef_server source" do
+
+    let(:source_options) { { chef_server: "https://api.opscode.com/organizations/chef-oss-dev/cookbooks/my_cookbook/versions/2.0.0/download" } }
+
+    let(:http_client) { instance_double("ChefCLI::ChefServerAPIMulti") }
+
+    before do
+      CookbookOmnifetch.integration.default_chef_server_http_client = http_client
+    end
+
+    after do
+      CookbookOmnifetch.integration.default_chef_server_http_client = nil
+    end
+
+    it "has a chef_server installer" do
+      expect(cookbook_location_spec.installer).to be_a_kind_of(CookbookOmnifetch::ChefServerLocation)
+    end
+
+    it "does not have a fixed version" do
+      expect(cookbook_location_spec.version_fixed?).to be false
+    end
+
+    it "is a mirror of a canonical upstream" do
+      expect(cookbook_location_spec.mirrors_canonical_upstream?).to be true
+    end
+
+    it "is valid" do
+      expect(cookbook_location_spec.errors.size).to eq(0)
+      expect(cookbook_location_spec).to be_valid
+    end
+
+  end
+
+  describe "when created with a chef_server_artifact source" do
+
+    let(:source_options) do
+      {
+        chef_server_artifact: "https://api.opscode.com/organizations/chef-oss-dev/",
+        identifier: "09d43fad354b3efcc5b5836fef5137131f60f974",
+      }
+    end
+
+    let(:http_client) { instance_double("ChefCLI::ChefServerAPIMulti") }
+
+    before do
+      CookbookOmnifetch.integration.default_chef_server_http_client = http_client
+    end
+
+    after do
+      CookbookOmnifetch.integration.default_chef_server_http_client = nil
+    end
+
+    it "has a chef_server_artifact installer" do
+      expect(cookbook_location_spec.installer).to be_a_kind_of(CookbookOmnifetch::ChefServerArtifactLocation)
+    end
+
+    it "does has a fixed version" do
+      expect(cookbook_location_spec.version_fixed?).to be(true)
+    end
+
+    it "is a mirror of a canonical upstream" do
+      expect(cookbook_location_spec.mirrors_canonical_upstream?).to be(true)
+    end
+
+    it "is valid" do
+      expect(cookbook_location_spec.errors.size).to eq(0)
+      expect(cookbook_location_spec).to be_valid
+    end
+
+  end
+end

data/spec/unit/policyfile/cookbook_locks_spec.rb

@@ -0,0 +1,527 @@
+#
+# Copyright:: Copyright (c) 2014-2018 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-cli/policyfile/cookbook_locks"
+
+shared_examples_for "Cookbook Lock" do
+
+  let(:cookbook_lock_data) { cookbook_lock.to_lock }
+
+  it "has a cookbook name" do
+    expect(cookbook_lock.name).to eq(cookbook_name)
+  end
+
+  it "has a source_options attribute" do
+    cookbook_lock.source_options = { artifactserver: "https://artifacts.example.com/nginx/1.0.0/download" }
+    expect(cookbook_lock.source_options).to eq({ artifactserver: "https://artifacts.example.com/nginx/1.0.0/download" })
+  end
+
+  it "has an identifier attribute" do
+    cookbook_lock.identifier = "my-opaque-id"
+    expect(cookbook_lock.identifier).to eq("my-opaque-id")
+  end
+
+  it "has a dotted_decimal_identifier attribute" do
+    cookbook_lock.dotted_decimal_identifier = "123.456.789"
+    expect(cookbook_lock.dotted_decimal_identifier).to eq("123.456.789")
+  end
+
+  it "has a version attribute" do
+    cookbook_lock.version = "1.2.3"
+    expect(cookbook_lock.version).to eq("1.2.3")
+  end
+
+  it "has a storage config" do
+    expect(cookbook_lock.storage_config).to eq(storage_config)
+  end
+
+  context "when the underlying cookbook has not been mutated, or #refresh! has not been called" do
+
+    it "is not updated" do
+      expect(cookbook_lock).to_not be_updated
+    end
+
+    it "does not have an updated identifier" do
+      expect(cookbook_lock.identifier_updated?).to be false
+    end
+
+    it "does not have an updated version" do
+      expect(cookbook_lock.version_updated?).to be false
+    end
+
+  end
+
+  context "when version and identifier attributes are populated" do
+
+    before do
+      allow(cookbook_lock).to receive(:validate!)
+
+      cookbook_lock.identifier = "my-opaque-id"
+      cookbook_lock.dotted_decimal_identifier = "123.456.789"
+      cookbook_lock.version = "1.2.3"
+      cookbook_lock.source_options = { sourcekey: "location info" }
+    end
+
+    it "includes the identifier in the lock data" do
+      expect(cookbook_lock_data["identifier"]).to eq("my-opaque-id")
+    end
+
+    it "includes the dotted decimal identifier in the lock data" do
+      expect(cookbook_lock_data["dotted_decimal_identifier"]).to eq("123.456.789")
+    end
+
+    it "includes the version in lock data" do
+      expect(cookbook_lock_data["version"]).to eq("1.2.3")
+    end
+
+    it "includes the source_options in lock data" do
+      expect(cookbook_lock_data["source_options"]).to eq({ sourcekey: "location info" })
+    end
+
+    it "creates a CookbookLocationSpecification with the source and version data" do
+      location_spec = cookbook_lock.cookbook_location_spec
+      expect(location_spec.name).to eq(cookbook_name)
+      expect(location_spec.version_constraint).to eq(Semverse::Constraint.new("= 1.2.3"))
+      expect(location_spec.source_options).to eq({ sourcekey: "location info" })
+    end
+
+    it "delegates #dependencies to cookbook_location_spec" do
+      deps = [ [ "foo", ">= 0.0.0"], [ "bar", "~> 2.1" ] ]
+      expect(cookbook_lock.cookbook_location_spec).to receive(:dependencies).and_return(deps)
+      expect(cookbook_lock.dependencies).to eq(deps)
+    end
+
+    it "delegates #installed? to the CookbookLocationSpecification" do
+      location_spec = cookbook_lock.cookbook_location_spec
+      expect(location_spec).to receive(:installed?).and_return(true)
+      expect(cookbook_lock).to be_installed
+      expect(location_spec).to receive(:installed?).and_return(false)
+      expect(cookbook_lock).to_not be_installed
+    end
+
+  end
+
+  context "when created from lock data" do
+
+    let(:lock_data) do
+      {
+        "identifier" => "my-opaque-id",
+        "dotted_decimal_identifier" => "123.456.789",
+        "version" => "1.2.3",
+        "source_options" => { "sourcekey" => "location info" },
+        "cache_key" => nil,
+        "source" => "cookbooks_local_path",
+      }
+    end
+
+    before do
+      cookbook_lock.build_from_lock_data(lock_data)
+    end
+
+    it "sets the identifier attribute" do
+      expect(cookbook_lock.identifier).to eq("my-opaque-id")
+    end
+
+    it "sets the dotted_decimal_identifier attribute" do
+      expect(cookbook_lock.dotted_decimal_identifier).to eq("123.456.789")
+    end
+
+    it "sets the version attribute" do
+      expect(cookbook_lock.version).to eq("1.2.3")
+    end
+
+    it "sets the source options" do
+      expect(cookbook_lock.source_options).to eq({ sourcekey: "location info" })
+    end
+  end
+
+end
+
+describe ChefCLI::Policyfile::CachedCookbook do
+
+  let(:cookbook_name) { "nginx" }
+
+  let(:storage_config) { ChefCLI::Policyfile::StorageConfig.new }
+
+  let(:cookbook_lock) do
+    described_class.new(cookbook_name, storage_config)
+  end
+
+  include_examples "Cookbook Lock"
+
+  it "has a cache_key attribute" do
+    cookbook_lock.cache_key = "nginx-1.0.0-example.com"
+    expect(cookbook_lock.cache_key).to eq("nginx-1.0.0-example.com")
+  end
+
+  it "has an origin attribute" do
+    cookbook_lock.origin = "https://artifacts.example.com/nginx/1.0.0/download"
+    expect(cookbook_lock.origin).to eq("https://artifacts.example.com/nginx/1.0.0/download")
+  end
+
+  it "errors locating the cookbook when the cache key is not set" do
+    expect { cookbook_lock.cookbook_path }.to raise_error(ChefCLI::MissingCookbookLockData)
+  end
+
+  it "ignores calls to #refresh!" do
+    expect { cookbook_lock.refresh! }.to_not raise_error
+  end
+
+  context "when populated with valid data" do
+
+    let(:cookbook_name) { "foo" }
+
+    let(:cache_path) { File.join(fixtures_path, "cached_cookbooks") }
+
+    before do
+      cookbook_lock.cache_key = "foo-1.0.0"
+
+      storage_config.cache_path = cache_path
+    end
+
+    it "gives the path to the cookbook in the cache" do
+      expect(cookbook_lock.cookbook_path).to eq(File.join(cache_path, "foo-1.0.0"))
+    end
+
+  end
+
+end
+
+describe ChefCLI::Policyfile::LocalCookbook do
+
+  let(:cookbook_name) { "nginx" }
+
+  let(:storage_config) { ChefCLI::Policyfile::StorageConfig.new }
+
+  let(:scm_profiler) { instance_double("ChefCLI::CookbookProfiler::Git", profile_data: {}) }
+
+  let(:cookbook_lock) do
+    lock = described_class.new(cookbook_name, storage_config)
+    allow(lock).to receive(:scm_profiler).and_return(scm_profiler)
+    lock
+  end
+
+  include_examples "Cookbook Lock"
+
+  describe "gathering identifier info" do
+    let(:identifiers) do
+      instance_double("ChefCLI::CookbookProfiler::Identifiers",
+                     content_identifier: "abc123",
+                     dotted_decimal_identifier: "111.222.333",
+                     semver_version: "1.2.3")
+    end
+
+    before do
+      allow(cookbook_lock).to receive(:identifiers).and_return(identifiers)
+      cookbook_lock.gather_profile_data
+    end
+
+    it "sets the content identifier" do
+      expect(cookbook_lock.identifier).to eq("abc123")
+    end
+
+    it "sets the backwards compatible dotted decimal identifer equivalent" do
+      expect(cookbook_lock.dotted_decimal_identifier).to eq("111.222.333")
+    end
+
+    it "collects the 'real' SemVer version of the cookbook" do
+      expect(cookbook_lock.version).to eq("1.2.3")
+    end
+
+  end
+
+  describe "selecting an SCM profiler" do
+
+    let(:cookbook_source_relpath) { "nginx" }
+
+    let(:cookbook_source_path) do
+      path = File.join(tempdir, cookbook_source_relpath)
+      FileUtils.mkdir_p(path)
+      path
+    end
+
+    # everywhere else, #scm_profiler is stubbed, we need the unstubbed version
+    let(:cookbook_lock) do
+      described_class.new(cookbook_name, storage_config)
+    end
+
+    before do
+      cookbook_lock.source = cookbook_source_path
+    end
+
+    after do
+      clear_tempdir
+    end
+
+    context "when the cookbook is in a git-repo" do
+
+      before do
+        FileUtils.mkdir_p(git_dir_path)
+      end
+
+      context "when the cookbook is a self-contained git repo" do
+
+        let(:git_dir_path) { File.join(cookbook_source_path, ".git") }
+
+        it "selects the git profiler" do
+          expect(cookbook_lock.scm_profiler).to be_an_instance_of(ChefCLI::CookbookProfiler::Git)
+        end
+
+      end
+
+      context "when the cookbook is a subdirectory of a git repo" do
+
+        let(:cookbook_source_relpath) { "cookbook_repo/nginx" }
+
+        let(:git_dir_path) { File.join(tempdir, "cookbook_repo/.git") }
+
+        it "selects the git profiler" do
+          expect(cookbook_lock.scm_profiler).to be_an_instance_of(ChefCLI::CookbookProfiler::Git)
+        end
+
+      end
+
+    end
+
+    context "when the cookbook is not in a git repo" do
+
+      it "selects the null profiler" do
+        expect(cookbook_lock.scm_profiler).to be_an_instance_of(ChefCLI::CookbookProfiler::NullSCM)
+      end
+
+    end
+
+  end
+
+  context "when loading data from a serialized form" do
+
+    let(:previous_lock_data) do
+      {
+        "identifier" => "abc123",
+        "dotted_decimal_identifier" => "111.222.333",
+        "version" => "1.2.3",
+        "source" => "../my_repo/nginx",
+        "source_options" => {
+          "path" => "../my_repo/nginx",
+        },
+        "cache_key" => nil,
+      }
+    end
+
+    before do
+      cookbook_lock.build_from_lock_data(previous_lock_data)
+    end
+
+    it "sets the identifier" do
+      expect(cookbook_lock.identifier).to eq("abc123")
+    end
+
+    it "sets the dotted_decimal_identifier" do
+      expect(cookbook_lock.dotted_decimal_identifier).to eq("111.222.333")
+    end
+
+    it "sets the version" do
+      expect(cookbook_lock.version).to eq("1.2.3")
+    end
+
+    it "sets the source attribute" do
+      expect(cookbook_lock.source).to eq("../my_repo/nginx")
+    end
+
+    it "sets the source options, symbolizing keys so the data is compatible with CookbookLocationSpecification" do
+      expected = { path: "../my_repo/nginx" }
+      expect(cookbook_lock.source_options).to eq(expected)
+    end
+
+    it "doesn't refresh scm_data when #lock_data is called" do
+      allow(scm_profiler).to receive(:profile_data).and_raise("This shouldn't get called")
+      cookbook_lock.lock_data
+    end
+
+    context "after the data has been refreshed" do
+
+      before do
+        allow(cookbook_lock).to receive(:identifiers).and_return(identifiers)
+        cookbook_lock.refresh!
+      end
+
+      context "and the underlying hasn't been mutated" do
+
+        let(:identifiers) do
+          instance_double("ChefCLI::CookbookProfiler::Identifiers",
+                         content_identifier: "abc123",
+                         dotted_decimal_identifier: "111.222.333",
+                         semver_version: "1.2.3")
+        end
+
+        it "has the correct identifier" do
+          expect(cookbook_lock.identifier).to eq("abc123")
+        end
+
+        it "has the correct dotted_decimal_identifier" do
+          expect(cookbook_lock.dotted_decimal_identifier).to eq("111.222.333")
+        end
+
+        it "has the correct version" do
+          expect(cookbook_lock.version).to eq("1.2.3")
+        end
+
+        it "sets the updated flag to false" do
+          expect(cookbook_lock).to_not be_updated
+        end
+
+        it "sets the version_updated flag to false" do
+          expect(cookbook_lock.version_updated?).to be(false)
+        end
+
+        it "sets the identifier_updated flag to false" do
+          expect(cookbook_lock.identifier_updated?).to be(false)
+        end
+
+      end
+
+      context "and the underlying data has been mutated" do
+        # represents the updated state of the cookbook
+        let(:identifiers) do
+          instance_double("ChefCLI::CookbookProfiler::Identifiers",
+                         content_identifier: "def456",
+                         dotted_decimal_identifier: "777.888.999",
+                         semver_version: "7.8.9")
+        end
+
+        it "sets the content identifier to the new identifier" do
+          expect(cookbook_lock.identifier).to eq("def456")
+        end
+
+        it "sets the dotted_decimal_identifier to the new identifier" do
+          expect(cookbook_lock.dotted_decimal_identifier).to eq("777.888.999")
+        end
+
+        it "sets the SemVer version to the new version" do
+          expect(cookbook_lock.version).to eq("7.8.9")
+        end
+
+        it "sets the updated flag to true" do
+          expect(cookbook_lock).to be_updated
+        end
+
+        it "sets the version_updated flag to true" do
+          expect(cookbook_lock.version_updated?).to be(true)
+        end
+
+        it "sets the identifier_updated flag to true" do
+          expect(cookbook_lock.identifier_updated?).to be(true)
+        end
+      end
+    end
+  end
+
+end
+
+describe ChefCLI::Policyfile::ArchivedCookbook do
+
+  let(:cookbook_name) { "nginx" }
+
+  let(:storage_config) { ChefCLI::Policyfile::StorageConfig.new }
+
+  let(:wrapped_cookbook_lock_data) do
+    {
+      "identifier" => "abc123",
+      "dotted_decimal_identifier" => "111.222.333",
+      "version" => "1.2.3",
+      "source" => "../my_repo/nginx",
+      "source_options" => {
+        # when getting the cookbook location spec, source options needs to have
+        # symbolic keys, so a round trip via LocalCookbook#build_from_lock_data
+        # will result in this being a symbol
+        path: "../my_repo/nginx",
+      },
+      "cache_key" => nil,
+      "scm_info" => {},
+    }
+  end
+
+  let(:wrapped_cookbook_lock) do
+    lock = ChefCLI::Policyfile::LocalCookbook.new(cookbook_name, storage_config)
+    allow(lock).to receive(:scm_info).and_return({})
+    lock.build_from_lock_data(wrapped_cookbook_lock_data)
+    lock
+  end
+
+  let(:cookbook_lock) do
+    described_class.new(wrapped_cookbook_lock, storage_config)
+  end
+
+  let(:archived_cookbook_path) { File.join(storage_config.relative_paths_root, "cookbook_artifacts", "nginx-abc123") }
+
+  it "sets cookbook_path to the path within the archive" do
+    expect(cookbook_lock.cookbook_path).to eq(archived_cookbook_path)
+  end
+
+  it "implements build_from_lock_data" do
+    msg = "ArchivedCookbook cannot be built from lock data, it can only wrap an existing lock object"
+    expect { cookbook_lock.build_from_lock_data({}) }.to raise_error(NotImplementedError, msg)
+  end
+
+  it "implements validate!" do
+    expect(cookbook_lock.validate!).to be(true)
+  end
+
+  it "implements refresh!" do
+    expect(cookbook_lock.refresh!).to be(true)
+  end
+
+  it "implements installed?" do
+    allow(File).to receive(:exist?).with(archived_cookbook_path).and_return(false)
+    allow(File).to receive(:directory?).with(archived_cookbook_path).and_return(false)
+    expect(cookbook_lock.installed?).to be(false)
+    allow(File).to receive(:exist?).with(archived_cookbook_path).and_return(true)
+    allow(File).to receive(:directory?).with(archived_cookbook_path).and_return(true)
+    expect(cookbook_lock.installed?).to be(true)
+  end
+
+  describe "delegated behavior" do
+
+    it "sets the identifier" do
+      expect(cookbook_lock.identifier).to eq("abc123")
+    end
+
+    it "sets the dotted_decimal_identifier" do
+      expect(cookbook_lock.dotted_decimal_identifier).to eq("111.222.333")
+    end
+
+    it "sets the version" do
+      expect(cookbook_lock.version).to eq("1.2.3")
+    end
+
+    it "sets the source attribute" do
+      expect(cookbook_lock.source).to eq("../my_repo/nginx")
+    end
+
+    it "sets the source options, symbolizing keys so the data is compatible with CookbookLocationSpecification" do
+      expected = { path: "../my_repo/nginx" }
+      expect(cookbook_lock.source_options).to eq(expected)
+    end
+
+    it "returns unchanged data when calling to_lock" do
+      expect(cookbook_lock.to_lock).to eq(wrapped_cookbook_lock_data)
+    end
+
+  end
+
+end