berkshelf 5.5.0 → 5.6.0

data/spec/unit/berkshelf/cached_cookbook_spec.rb

@@ -1,48 +1,48 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe Berkshelf::CachedCookbook do
   describe "ClassMethods" do
-    describe '::from_store_path' do
-      let(:path) { fixtures_path.join('cookbooks', 'example_cookbook-0.5.0') }
+    describe "::from_store_path" do
+      let(:path) { fixtures_path.join("cookbooks", "example_cookbook-0.5.0") }
       let(:cached) { described_class.from_path(path) }
 
-      it 'returns a CachedCookbook' do
+      it "returns a CachedCookbook" do
         expect(cached).to be_a(described_class)
       end
 
-      it 'sets a version number' do
-        expect(cached.version).to eq('0.5.0')
+      it "sets a version number" do
+        expect(cached.version).to eq("0.5.0")
       end
 
-      it 'sets the metadata.name value to the cookbook_name' do
-        expect(cached.metadata.name).to eq('example_cookbook')
+      it "sets the metadata.name value to the cookbook_name" do
+        expect(cached.metadata.name).to eq("example_cookbook")
       end
 
-      context 'given a path that does not contain a cookbook' do
-        it 'returns nil' do
+      context "given a path that does not contain a cookbook" do
+        it "returns nil" do
           expect(described_class.from_store_path(tmp_path)).to be_nil
         end
       end
 
-      context 'given a path that does not match the CachedCookbook dirname format' do
-        it 'returns nil' do
-          path = fixtures_path.join('cookbooks', 'example_cookbook')
+      context "given a path that does not match the CachedCookbook dirname format" do
+        it "returns nil" do
+          path = fixtures_path.join("cookbooks", "example_cookbook")
           expect(described_class.from_store_path(path)).to be_nil
         end
       end
 
-      context 'given an already cached cookbook' do
+      context "given an already cached cookbook" do
         let!(:cached) { described_class.from_store_path(path) }
 
-        it 'returns the cached cookbook instance' do
+        it "returns the cached cookbook instance" do
           expect(described_class.from_store_path(path)).to eq(cached)
         end
       end
     end
 
-    describe '::checksum' do
-      it 'returns a checksum of the given filepath' do
-        path = fixtures_path.join('cookbooks', 'example_cookbook-0.5.0', 'README.md')
+    describe "::checksum" do
+      it "returns a checksum of the given filepath" do
+        path = fixtures_path.join("cookbooks", "example_cookbook-0.5.0", "README.md")
         expected_md5 = if IO.binread(path).include?("\r\n")
                          # On windows, with git configured for auto crlf
                          "2414583f86c9eb68bdbb0be391939341"
@@ -52,48 +52,48 @@ describe Berkshelf::CachedCookbook do
         expect(described_class.checksum(path)).to eq(expected_md5)
       end
 
-      context 'given path does not exist' do
-        it 'raises an Errno::ENOENT error' do
-          expect {
-            described_class.checksum(fixtures_path.join('notexisting.file'))
-          }.to raise_error(Errno::ENOENT)
+      context "given path does not exist" do
+        it "raises an Errno::ENOENT error" do
+          expect do
+            described_class.checksum(fixtures_path.join("notexisting.file"))
+          end.to raise_error(Errno::ENOENT)
         end
       end
     end
   end
 
-  let(:dependencies) { { 'mysql' => '= 1.2.0', 'ntp' => '>= 0.0.0' } }
-  let(:recommendations) { { 'database' => '>= 0.0.0' } }
+  let(:dependencies) { { "mysql" => "= 1.2.0", "ntp" => ">= 0.0.0" } }
+  let(:recommendations) { { "database" => ">= 0.0.0" } }
   let(:path) do
     generate_cookbook(Berkshelf.cookbook_store.storage_path,
-      'sparkle', '0.1.0', dependencies: dependencies, recommendations: recommendations)
+      "sparkle", "0.1.0", dependencies: dependencies, recommendations: recommendations)
   end
 
   subject { Berkshelf::CachedCookbook.from_store_path(path) }
 
-  describe '#dependencies' do
-    it 'contains depends from the cookbook metadata' do
+  describe "#dependencies" do
+    it "contains depends from the cookbook metadata" do
       expect(subject.dependencies).to include(dependencies)
     end
 
-    it 'contains recommendations from the cookbook metadata' do
+    it "contains recommendations from the cookbook metadata" do
       expect(subject.dependencies).to include(recommendations)
     end
 
-    it 'returns a hash' do
+    it "returns a hash" do
       expect(subject.dependencies).to be_a(Hash)
     end
   end
 
-  describe '#pretty_hash' do
-    shared_examples 'a pretty_hash cookbook attribute' do |attribute, key|
+  describe "#pretty_hash" do
+    shared_examples "a pretty_hash cookbook attribute" do |attribute, key|
       it "is not present when the `#{attribute}` attribute is nil" do
         allow(subject).to receive(attribute.to_sym).and_return(nil)
         expect(subject.pretty_hash).to_not have_key((key || attribute).to_sym)
       end
 
       it "is not present when the `#{attribute}` attribute is an empty string" do
-        allow(subject).to receive(attribute.to_sym).and_return('')
+        allow(subject).to receive(attribute.to_sym).and_return("")
         expect(subject.pretty_hash).to_not have_key((key || attribute).to_sym)
       end
 
@@ -108,18 +108,18 @@ describe Berkshelf::CachedCookbook do
       end
 
       it "is present when the `#{attribute}` attribute has a Hash value" do
-        allow(subject).to receive(attribute.to_sym).and_return(foo: 'bar')
+        allow(subject).to receive(attribute.to_sym).and_return(foo: "bar")
         expect(subject.pretty_hash).to have_key((key || attribute).to_sym)
       end
     end
 
-    it_behaves_like 'a pretty_hash cookbook attribute', 'cookbook_name', 'name'
-    it_behaves_like 'a pretty_hash cookbook attribute', 'version'
-    it_behaves_like 'a pretty_hash cookbook attribute', 'description'
-    it_behaves_like 'a pretty_hash cookbook attribute', 'maintainer', 'author'
-    it_behaves_like 'a pretty_hash cookbook attribute', 'maintainer_email', 'email'
-    it_behaves_like 'a pretty_hash cookbook attribute', 'license'
-    it_behaves_like 'a pretty_hash cookbook attribute', 'platforms'
-    it_behaves_like 'a pretty_hash cookbook attribute', 'dependencies'
+    it_behaves_like "a pretty_hash cookbook attribute", "cookbook_name", "name"
+    it_behaves_like "a pretty_hash cookbook attribute", "version"
+    it_behaves_like "a pretty_hash cookbook attribute", "description"
+    it_behaves_like "a pretty_hash cookbook attribute", "maintainer", "author"
+    it_behaves_like "a pretty_hash cookbook attribute", "maintainer_email", "email"
+    it_behaves_like "a pretty_hash cookbook attribute", "license"
+    it_behaves_like "a pretty_hash cookbook attribute", "platforms"
+    it_behaves_like "a pretty_hash cookbook attribute", "dependencies"
   end
 end

data/spec/unit/berkshelf/cli_spec.rb

@@ -1,24 +1,24 @@
-require 'spec_helper'
+require "spec_helper"
 
 module Berkshelf
   describe Cli do
     let(:subject) { described_class.new }
-    let(:berksfile) { double('Berksfile') }
-    let(:cookbooks) { ['mysql'] }
+    let(:berksfile) { double("Berksfile") }
+    let(:cookbooks) { ["mysql"] }
 
     before do
       allow(Berksfile).to receive(:from_options).and_return(berksfile)
     end
 
-    describe '#upload' do
-      it 'calls to upload with params if passed in cli' do
+    describe "#upload" do
+      it "calls to upload with params if passed in cli" do
         expect(berksfile).to receive(:upload).with(cookbooks,
           include(skip_syntax_check: true, freeze: false)
         )
 
         subject.options[:skip_syntax_check] = true
         subject.options[:no_freeze]         = true
-        subject.upload('mysql')
+        subject.upload("mysql")
       end
     end
   end

data/spec/unit/berkshelf/community_rest_spec.rb

@@ -1,21 +1,21 @@
-require 'spec_helper'
+require "spec_helper"
 
 describe Berkshelf::CommunityREST do
   describe "ClassMethods" do
     describe "::unpack" do
-      let(:target) { '/foo/bar' }
-      let(:destination) { '/destination/bar' }
-      let(:file) { double('file') }
-      let(:gzip_reader) { double('gzip_reader') }
-      let(:archive) { double('mixlib_archive') }
+      let(:target) { "/foo/bar" }
+      let(:destination) { "/destination/bar" }
+      let(:file) { double("file") }
+      let(:gzip_reader) { double("gzip_reader") }
+      let(:archive) { double("mixlib_archive") }
 
       before do
-        allow(File).to receive(:open).with(target, 'rb').and_return(file)
+        allow(File).to receive(:open).with(target, "rb").and_return(file)
         allow(archive).to receive(:extract).with(destination)
         allow(Mixlib::Archive).to receive(:new).with(target).and_return(archive)
       end
 
-      it 'unpacks the tar' do
+      it "unpacks the tar" do
         expect(::IO).to receive(:binread).with(target, 2).and_return([0x1F, 0x8B].pack("C*"))
         expect(Mixlib::Archive).to receive(:new).with(target).and_return(archive)
         expect(archive).to receive(:extract).with(destination)
@@ -25,38 +25,38 @@ describe Berkshelf::CommunityREST do
     end
 
     describe "::uri_escape_version" do
-      it 'returns a string' do
+      it "returns a string" do
         expect(Berkshelf::CommunityREST.uri_escape_version(nil)).to be_a(String)
       end
 
       it 'converts a version to it\'s underscored version' do
-        expect(Berkshelf::CommunityREST.uri_escape_version('1.1.2')).to eq('1_1_2')
+        expect(Berkshelf::CommunityREST.uri_escape_version("1.1.2")).to eq("1_1_2")
       end
 
-      it 'works when the version has more than three points' do
-        expect(Berkshelf::CommunityREST.uri_escape_version('1.1.1.2')).to eq('1_1_1_2')
+      it "works when the version has more than three points" do
+        expect(Berkshelf::CommunityREST.uri_escape_version("1.1.1.2")).to eq("1_1_1_2")
       end
 
-      it 'works when the version has less than three points' do
-        expect(Berkshelf::CommunityREST.uri_escape_version('1.2')).to eq('1_2')
+      it "works when the version has less than three points" do
+        expect(Berkshelf::CommunityREST.uri_escape_version("1.2")).to eq("1_2")
       end
     end
 
     describe "::version_from_uri" do
-      it 'returns a string' do
+      it "returns a string" do
         expect(Berkshelf::CommunityREST.version_from_uri(nil)).to be_a(String)
       end
 
-      it 'extracts the version from the URL' do
-        expect(Berkshelf::CommunityREST.version_from_uri('/api/v1/cookbooks/nginx/versions/1_1_2')).to eq('1.1.2')
+      it "extracts the version from the URL" do
+        expect(Berkshelf::CommunityREST.version_from_uri("/api/v1/cookbooks/nginx/versions/1_1_2")).to eq("1.1.2")
       end
 
-      it 'works when the version has more than three points' do
-        expect(Berkshelf::CommunityREST.version_from_uri('/api/v1/cookbooks/nginx/versions/1_1_1_2')).to eq('1.1.1.2')
+      it "works when the version has more than three points" do
+        expect(Berkshelf::CommunityREST.version_from_uri("/api/v1/cookbooks/nginx/versions/1_1_1_2")).to eq("1.1.1.2")
       end
 
-      it 'works when the version has less than three points' do
-        expect(Berkshelf::CommunityREST.version_from_uri('/api/v1/cookbooks/nginx/versions/1_2')).to eq('1.2')
+      it "works when the version has less than three points" do
+        expect(Berkshelf::CommunityREST.version_from_uri("/api/v1/cookbooks/nginx/versions/1_2")).to eq("1.2")
       end
     end
   end
@@ -64,161 +64,161 @@ describe Berkshelf::CommunityREST do
   let(:api_uri) { Berkshelf::CommunityREST::V1_API }
   subject { Berkshelf::CommunityREST.new(api_uri) }
 
-  describe '#initialize' do
-    context 'Faraday handlers' do
-      it 'includes follow_redirects to prevent 301 from community, stopping some cookbooks installing' do
+  describe "#initialize" do
+    context "Faraday handlers" do
+      it "includes follow_redirects to prevent 301 from community, stopping some cookbooks installing" do
         expect(subject.builder.handlers).to include(Ridley::Middleware::FollowRedirects)
       end
     end
   end
 
-  describe '#download' do
-    let(:archive) { double('archive', path: '/foo/bar', unlink: true) }
+  describe "#download" do
+    let(:archive) { double("archive", path: "/foo/bar", unlink: true) }
 
     before do
       allow(subject).to receive(:stream).with(any_args()).and_return(archive)
       allow(Berkshelf::CommunityREST).to receive(:unpack)
-        .and_return('/some/path')
+        .and_return("/some/path")
     end
 
-    it 'unpacks the archive' do
+    it "unpacks the archive" do
       stub_request(:get, "#{api_uri}/cookbooks/bacon/versions/1_0_0").to_return(
         status: 200,
         body: '{ "cookbook": "/path/to/cookbook", "version": "1.0.0" }',
-        headers: { 'Content-Type' => 'application/json' },
+        headers: { "Content-Type" => "application/json" }
       )
 
       expect(Berkshelf::CommunityREST).to receive(:unpack)
-        .with('/foo/bar', String)
-        .and_return('/foo/nginx')
+        .with("/foo/bar", String)
+        .and_return("/foo/nginx")
         .once
       expect(archive).to receive(:unlink).once
 
-      subject.download('bacon', '1.0.0')
+      subject.download("bacon", "1.0.0")
     end
   end
 
-  describe '#find' do
-    it 'returns the cookbook and version information' do
+  describe "#find" do
+    it "returns the cookbook and version information" do
       stub_request(:get, "#{api_uri}/cookbooks/bacon/versions/1_0_0").to_return(
         status: 200,
         body: '{ "cookbook": "/path/to/cookbook", "version": "1.0.0" }',
-        headers: { 'Content-Type' => 'application/json' },
+        headers: { "Content-Type" => "application/json" }
       )
 
-      result = subject.find('bacon', '1.0.0')
+      result = subject.find("bacon", "1.0.0")
 
-      expect(result.cookbook).to eq('/path/to/cookbook')
-      expect(result.version).to eq('1.0.0')
+      expect(result.cookbook).to eq("/path/to/cookbook")
+      expect(result.version).to eq("1.0.0")
     end
 
-    it 'raises a CookbookNotFound error on a 404 response for a non-existent cookbook' do
+    it "raises a CookbookNotFound error on a 404 response for a non-existent cookbook" do
       stub_request(:get, "#{api_uri}/cookbooks/not_real/versions/1_0_0").to_return(
         status: 404,
-        body: nil,
+        body: nil
       )
 
-      expect {
-        subject.find('not_real', '1.0.0')
-      }.to raise_error(Berkshelf::CookbookNotFound)
+      expect do
+        subject.find("not_real", "1.0.0")
+      end.to raise_error(Berkshelf::CookbookNotFound)
     end
 
-    it 'raises a CommunitySiteError error on any non 200 or 404 response' do
+    it "raises a CommunitySiteError error on any non 200 or 404 response" do
       stub_request(:get, "#{api_uri}/cookbooks/not_real/versions/1_0_0").to_return(
         status: 500,
-        body: nil,
+        body: nil
       )
 
-      expect {
-        subject.find('not_real', '1.0.0')
-      }.to raise_error(Berkshelf::CommunitySiteError)
+      expect do
+        subject.find("not_real", "1.0.0")
+      end.to raise_error(Berkshelf::CommunitySiteError)
     end
   end
 
-  describe '#latest_version' do
-    it 'returns the version number of the latest version of the cookbook' do
+  describe "#latest_version" do
+    it "returns the version number of the latest version of the cookbook" do
       stub_request(:get, "#{api_uri}/cookbooks/bacon").to_return(
         status: 200,
         body: '{ "latest_version": "1.0.0" }',
-        headers: { 'Content-Type' => 'application/json' }
+        headers: { "Content-Type" => "application/json" }
       )
 
-      latest = subject.latest_version('bacon')
-      expect(latest).to eq('1.0.0')
+      latest = subject.latest_version("bacon")
+      expect(latest).to eq("1.0.0")
     end
 
-    it 'raises a CookbookNotFound error on a 404 response' do
+    it "raises a CookbookNotFound error on a 404 response" do
       stub_request(:get, "#{api_uri}/cookbooks/not_real").to_return(
         status: 404,
-        body: nil,
+        body: nil
       )
 
-      expect {
-        subject.latest_version('not_real')
-      }.to raise_error(Berkshelf::CookbookNotFound)
+      expect do
+        subject.latest_version("not_real")
+      end.to raise_error(Berkshelf::CookbookNotFound)
     end
 
-    it 'raises a CommunitySiteError error on any non 200 or 404 response' do
+    it "raises a CommunitySiteError error on any non 200 or 404 response" do
       stub_request(:get, "#{api_uri}/cookbooks/not_real").to_return(
         status: 500,
-        body: nil,
+        body: nil
       )
 
-      expect {
-        subject.latest_version('not_real')
-      }.to raise_error(Berkshelf::CommunitySiteError)
+      expect do
+        subject.latest_version("not_real")
+      end.to raise_error(Berkshelf::CommunitySiteError)
     end
   end
 
-  describe '#versions' do
-    it 'returns an array containing an item for each version' do
+  describe "#versions" do
+    it "returns an array containing an item for each version" do
       stub_request(:get, "#{api_uri}/cookbooks/bacon").to_return(
         status: 200,
         body: '{ "versions": ["/bacon/versions/1_0_0", "/bacon/versions/2_0_0"] }',
-        headers: { 'Content-Type' => 'application/json' }
+        headers: { "Content-Type" => "application/json" }
       )
 
-      versions = subject.versions('bacon')
+      versions = subject.versions("bacon")
       expect(versions.size).to eq(2)
     end
 
-    it 'raises a CookbookNotFound error on a 404 response' do
+    it "raises a CookbookNotFound error on a 404 response" do
       stub_request(:get, "#{api_uri}/cookbooks/not_real").to_return(
         status: 404,
-        body: nil,
+        body: nil
       )
 
-      expect {
-        subject.versions('not_real')
-      }.to raise_error(Berkshelf::CookbookNotFound)
+      expect do
+        subject.versions("not_real")
+      end.to raise_error(Berkshelf::CookbookNotFound)
     end
 
-    it 'raises a CommunitySiteError error on any non 200 or 404 response' do
+    it "raises a CommunitySiteError error on any non 200 or 404 response" do
       stub_request(:get, "#{api_uri}/cookbooks/not_real").to_return(
         status: 500,
-        body: nil,
+        body: nil
       )
 
-      expect {
-        subject.versions('not_real')
-      }.to raise_error(Berkshelf::CommunitySiteError)
+      expect do
+        subject.versions("not_real")
+      end.to raise_error(Berkshelf::CommunitySiteError)
     end
   end
 
-  describe '#satisfy' do
-    it 'returns the version number of the best solution' do
+  describe "#satisfy" do
+    it "returns the version number of the best solution" do
       stub_request(:get, "#{api_uri}/cookbooks/bacon").to_return(
         status: 200,
         body: '{ "versions": ["/bacon/versions/1_0_0", "/bacon/versions/2_0_0"] }',
-        headers: { 'Content-Type' => 'application/json' }
+        headers: { "Content-Type" => "application/json" }
       )
 
-      result = subject.satisfy('bacon', '= 1.0.0')
-      expect(result).to eq('1.0.0')
+      result = subject.satisfy("bacon", "= 1.0.0")
+      expect(result).to eq("1.0.0")
     end
   end
 
-  describe '#stream' do
+  describe "#stream" do
     skip
   end
 end