berkshelf-api 1.4.0 → 2.0.0

data/spec/unit/berkshelf/api/cache_builder/worker_spec.rb

@@ -4,7 +4,7 @@ describe Berkshelf::API::CacheBuilder::Worker do
   describe "ClassMethods" do
     describe "::[]" do
       it "returns the class of the registered worker" do
-        expect(described_class["opscode"]).to eql(Berkshelf::API::CacheBuilder::Worker::Opscode)
+        expect(described_class["supermarket"]).to eql(Berkshelf::API::CacheBuilder::Worker::Supermarket)
       end
     end
 

data/spec/unit/berkshelf/api/cache_builder_spec.rb

@@ -11,12 +11,16 @@ describe Berkshelf::API::CacheBuilder do
     let(:future) { double('future', value: nil) }
     let(:cache_manager) { double('cache_manager') }
 
-    before { instance.stub(workers: workers) }
+    before do
+      # https://github.com/celluloid/celluloid/wiki/Testing
+      allow(instance.wrapped_object).to receive(:workers).and_return(workers)
+      allow(instance.wrapped_object).to receive(:cache_manager).and_return(cache_manager)
+      allow(cache_manager).to receive(:process_workers)
+    end
 
     it "asks the cache_manager to process all of its actors" do
-      instance.stub(:cache_manager).and_return(cache_manager)
-      cache_manager.should_receive(:process_workers).with(instance.workers).and_return(future)
-      build
+      expect(cache_manager).to receive(:process_workers).with(workers)
+      instance.build
     end
   end
 
@@ -32,11 +36,11 @@ describe Berkshelf::API::CacheBuilder do
 
     context "when no workers are explicitly configured" do
       it "has one worker started by default" do
-        expect(workers).to have(1).item
+        expect(workers.size).to eq(1)
       end
 
-      it "has an opscode worker started by default" do
-        expect(workers.first).to be_a(described_class::Worker::Opscode)
+      it "has an Supermarket worker started by default" do
+        expect(workers.first).to be_a(described_class::Worker::Supermarket)
       end
     end
 
@@ -68,7 +72,7 @@ describe Berkshelf::API::CacheBuilder do
       end
 
       it "has two workers" do
-        expect(workers).to have(2).items
+        expect(workers.size).to eq(2)
       end
 
       it "keeps the ordering" do

data/spec/unit/berkshelf/api/cache_manager_spec.rb

@@ -1,10 +1,13 @@
 require 'spec_helper'
 
 describe Berkshelf::API::CacheManager do
+  subject { described_class.new }
+
   describe "ClassMethods" do
-    describe "::new" do
-      subject { described_class.new }
-      its(:cache) { should be_empty }
+    describe ".new" do
+      it 'has an empty cache' do
+        expect(subject.cache).to be_empty
+      end
 
       context "when a save file exists" do
         before do
@@ -39,20 +42,18 @@ describe Berkshelf::API::CacheManager do
     end
   end
 
-  subject { described_class.new }
-
   it_behaves_like "a human-readable string"
 
   describe "#add" do
-    pending
+    skip
   end
 
   describe "#load_save" do
-    pending
+    skip
   end
 
   describe "#remove" do
-    pending
+    skip
   end
 
   describe "#clear" do
@@ -69,8 +70,8 @@ describe Berkshelf::API::CacheManager do
   end
 
   describe "#diff" do
-    let(:cookbook_one) { Berkshelf::API::RemoteCookbook.new("ruby", "1.2.3", "opscode", nil, 1) }
-    let(:cookbook_two) { Berkshelf::API::RemoteCookbook.new("elixir", "2.0.0", "opscode", nil, 1) }
+    let(:cookbook_one) { Berkshelf::API::RemoteCookbook.new("ruby", "1.2.3", "supermarket", nil, 1) }
+    let(:cookbook_two) { Berkshelf::API::RemoteCookbook.new("elixir", "2.0.0", "supermarket", nil, 1) }
     let(:comparison) { Array.new }
 
     before do
@@ -81,11 +82,11 @@ describe Berkshelf::API::CacheManager do
     end
 
     it "returns two items" do
-      expect(@diff).to have(2).items
+      expect(@diff.size).to eq(2)
     end
 
     context "when there are more than one worker endpoints" do
-      let(:new_cookbook) { Berkshelf::API::RemoteCookbook.new("ruby", "3.0.0", "opscode", nil, 2) }
+      let(:new_cookbook) { Berkshelf::API::RemoteCookbook.new("ruby", "3.0.0", "supermarket", nil, 2) }
       let(:comparison) { [ cookbook_one, cookbook_two, new_cookbook ] }
 
       before do
@@ -100,7 +101,7 @@ describe Berkshelf::API::CacheManager do
         let(:comparison) { [cookbook_one] }
 
         before do
-         @created, @deleted = @diff = subject.send(:diff, comparison, 1) 
+         @created, @deleted = @diff = subject.send(:diff, comparison, 1)
         end
 
         it "only deletes cookbooks at the same priority" do
@@ -110,7 +111,7 @@ describe Berkshelf::API::CacheManager do
     end
 
     context "when there are created and deleted cookbooks" do
-      let(:new_cookbook) { Berkshelf::API::RemoteCookbook.new("ruby", "3.0.0", "opscode", nil, 1) }
+      let(:new_cookbook) { Berkshelf::API::RemoteCookbook.new("ruby", "3.0.0", "supermarket", nil, 1) }
       let(:comparison) { [ cookbook_one, new_cookbook ] }
 
       it "should return created and deleted cookbooks" do
@@ -120,7 +121,7 @@ describe Berkshelf::API::CacheManager do
     end
 
     context "when there are only created cookbooks" do
-      let(:new_cookbook) { Berkshelf::API::RemoteCookbook.new("ruby", "3.0.0", "opscode", nil, 1) }
+      let(:new_cookbook) { Berkshelf::API::RemoteCookbook.new("ruby", "3.0.0", "supermarket", nil, 1) }
       let(:comparison) { [ cookbook_one, cookbook_two, new_cookbook ] }
 
       it "should return only created cookbooks" do

data/spec/unit/berkshelf/api/config_spec.rb

@@ -13,12 +13,11 @@ describe Berkshelf::API::Config do
     subject { described_class.new }
 
     it "has a endpoint configured" do
-      expect(subject.endpoints).to have(1).item
+      expect(subject.endpoints.size).to eq(1)
     end
 
-    it "has the Opscode community site as an endpoint" do
-      expect(subject.endpoints.first.type).to eql("opscode")
-      expect(subject.endpoints.first.options[:url]).to eql("http://cookbooks.opscode.com/api/v1")
+    it "has the Supermarket community site as an endpoint" do
+      expect(subject.endpoints.first.type).to eql("supermarket")
     end
   end
 end

data/spec/unit/berkshelf/api/dependency_cache_spec.rb

@@ -1,5 +1,9 @@
 require 'spec_helper'
 
+def remote_cookbook(name, version, location_type = 'supermarket', location_path = 'https://supermarket.getchef.com', priority = 1, info = {})
+  Berkshelf::API::RemoteCookbook.new(name, version, location_type, location_path, priority, info)
+end
+
 describe Berkshelf::API::DependencyCache do
   describe "ClassMethods" do
     describe "::from_file" do
@@ -77,8 +81,8 @@ describe Berkshelf::API::DependencyCache do
   describe "#cookbooks" do
     it "should return a list of RemoteCookbooks" do
       expected_value = [
-        Berkshelf::API::RemoteCookbook.new("chicken", "1.0"),
-        Berkshelf::API::RemoteCookbook.new("tuna", "3.0.0")
+        remote_cookbook("chicken", "1.0"),
+        remote_cookbook("tuna", "3.0.0")
       ]
 
       expect(subject.cookbooks).to eql(expected_value)
@@ -86,12 +90,12 @@ describe Berkshelf::API::DependencyCache do
   end
 
   describe "#add" do
-    let(:cookbook) { Berkshelf::API::RemoteCookbook.new("ruby", "1.2.3", "opscode") }
+    let(:cookbook) { remote_cookbook("ruby", "1.2.3", "supermarket") }
     before { subject.clear }
 
     it "adds items to the cache" do
       subject.add(cookbook, double(platforms: nil, dependencies: nil))
-      expect(subject.to_hash).to have(1).item
+      expect(subject.to_hash.size).to eq(1)
     end
   end
 
@@ -100,12 +104,12 @@ describe Berkshelf::API::DependencyCache do
 
     it "saves the contents of the cache as json to the given path" do
       subject.save(path)
-      expect(File.exist?(path)).to be_true
+      expect(File.exist?(path)).to be_truthy
     end
   end
 
   describe "#clear" do
-    let(:cookbook) { Berkshelf::API::RemoteCookbook.new("ruby", "1.2.3", "opscode") }
+    let(:cookbook) { remote_cookbook("ruby", "1.2.3", "supermarket") }
     before { subject.add(cookbook, double(platforms: nil, dependencies: nil)) }
 
     it "empties items added to the cache" do

data/spec/unit/berkshelf/api/endpoint/v1_spec.rb

@@ -25,30 +25,50 @@ describe Berkshelf::API::Endpoint::V1 do
         subject { last_response }
         let(:app_cache) { cache_manager.cache }
 
-        its(:status) { should be(200) }
-        its(:body) { should eq(app_cache.to_json) }
+        it 'has the right status' do
+          expect(subject.status).to eq(200)
+        end
+
+        it 'has the right body' do
+          expect(subject.body).to eq(app_cache.to_json)
+        end
       end
       context "the user requests json" do
         subject { last_response }
         let(:app_cache) { cache_manager.cache }
         let(:rack_env) { { 'HTTP_ACCEPT' => 'application/json' } }
 
-        its(:status) { should be(200) }
-        its(:body) { should eq(app_cache.to_json) }
+        it 'has the right status' do
+          expect(subject.status).to eq(200)
+        end
+
+        it 'has the right body' do
+          expect(subject.body).to eq(app_cache.to_json)
+        end
       end
       context "the user requests msgpack" do
         subject { last_response }
         let(:app_cache) { cache_manager.cache }
         let(:rack_env) { { 'HTTP_ACCEPT' => 'application/x-msgpack' } }
 
-        its(:status) { should be(200) }
-        its(:body) { should eq(app_cache.to_msgpack) }
+        it 'has the right status' do
+          expect(subject.status).to eq(200)
+        end
+
+        it 'has the right body' do
+          expect(subject.body).to eq(app_cache.to_msgpack)
+        end
       end
     end
 
     context "the cache is still warming" do
-      its(:status) { should be(503) }
-      its(:headers) { should have_key("Retry-After") }
+      it 'has the right status' do
+        expect(subject.status).to eq(503)
+      end
+
+      it 'has the right headers' do
+        expect(subject.headers).to have_key('Retry-After')
+      end
     end
   end
 
@@ -62,13 +82,39 @@ describe Berkshelf::API::Endpoint::V1 do
     context "the cache has been warmed" do
       let(:cache_warm) { true }
 
-      its(:status) { should be(200) }
-      its(:body) { should eq({status: 'ok', version: Berkshelf::API::VERSION, cache_status: 'ok', uptime: 100.0}.to_json) }
+      it 'has the right status' do
+        expect(subject.status).to eq(200)
+      end
+
+      it 'has the right body' do
+        status = {
+          status:  'ok',
+          version: Berkshelf::API::VERSION,
+          cache_status: 'ok',
+          uptime: 100.0,
+        }.to_json
+
+        expect(subject.body).to eq(status)
+      end
     end
 
     context "the cache is still warming" do
-      its(:status) { should be(200) }
-      its(:body) { should eq({status: 'ok', version: Berkshelf::API::VERSION, cache_status: 'warming', uptime: 100.0}.to_json) }
+      let(:cache_warm) { false }
+
+      it 'has the right status' do
+        expect(subject.status).to eq(200)
+      end
+
+      it 'has the right body' do
+        status = {
+          status:  'ok',
+          version: Berkshelf::API::VERSION,
+          cache_status: 'warming',
+          uptime: 100.0,
+        }.to_json
+
+        expect(subject.body).to eq(status)
+      end
     end
   end
 end

data/spec/unit/berkshelf/api/rack_app_spec.rb

@@ -1,6 +1,9 @@
 require 'spec_helper'
 
 describe Berkshelf::API::RackApp do
-  subject { described_class }
-  its(:endpoints) { should have(1).item.at_least }
+  describe '.endpoints' do
+    it 'has at least one item' do
+      expect(described_class.endpoints.size).to be > 0
+    end
+  end
 end

data/spec/unit/berkshelf/api/rest_gateway_spec.rb

@@ -1,19 +1,40 @@
 require 'spec_helper'
 require 'berkshelf/api/rest_gateway'
 
-describe Berkshelf::API::RESTGateway do
-  describe "ClassMethods" do
-    describe "::new" do
-      let(:options) { Hash.new }
+module Berkshelf
+  module API
+    describe RESTGateway do
+      let(:options) { {} }
       subject { described_class.new(options) }
 
-      its(:host) { should eql(described_class::DEFAULT_OPTIONS[:host]) }
-      its(:port) { should eql(described_class::DEFAULT_OPTIONS[:port]) }
-      its(:app)  { should be_a(Berkshelf::API::RackApp) }
+      describe '.new' do
+        context 'when given a different port' do
+          before do
+            options[:port] = 26210
+          end
 
-      context "given a different port" do
-        before { options[:port] = 26210 }
-        its(:port) { should eql(26210) }
+          it 'uses the correct port' do
+            expect(subject.port).to eq(26210)
+          end
+        end
+      end
+
+      describe '#host' do
+        it 'has the default value' do
+          expect(subject.host).to eq(described_class::DEFAULT_OPTIONS[:host])
+        end
+      end
+
+      describe '#port' do
+        it 'has the default value' do
+          expect(subject.port).to eq(described_class::DEFAULT_OPTIONS[:port])
+        end
+      end
+
+      describe '#app' do
+        it 'has the default value' do
+          expect(subject.app).to be_a(RackApp)
+        end
       end
     end
   end

data/spec/unit/berkshelf/api/site_connector/supermarket_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+describe Berkshelf::API::SiteConnector::Supermarket do
+  let(:url) { 'https://example.com' }
+  let(:json) do
+    <<-EOH.gsub(/^ {6}/, '')
+      {
+        "berkshelf": {
+          "0.1.0": {
+            "location_type": "supermarket",
+            "location_path": "#{url}",
+            "download_url": "#{url}/cookbooks/berkshelf/versions/0.1.0/download",
+            "dependencies": {
+              "ruby": ">= 0.0.0"
+            }
+          },
+          "0.2.0": {
+            "location_type": "supermarket",
+            "location_path": "#{url}",
+            "download_url": "#{url}/cookbooks/berkshelf/versions/0.2.0/download",
+            "dependencies": {
+              "ruby": ">= 0.0.0"
+            }
+          }
+        }
+      }
+    EOH
+  end
+
+  subject { described_class.new(url: url) }
+
+  before do
+    allow(subject).to receive(:open)
+      .and_return(double(File, read: json))
+  end
+
+  describe "#universe" do
+    it "uses OpenURI to get the universe" do
+      expect(subject).to receive(:open)
+        .with("#{url}/universe.json", kind_of(Hash))
+
+      subject.universe
+    end
+
+    it 'parses the response as JSON' do
+      expect(subject.universe).to be_a(Hash)
+      expect(subject.universe).to have_key('berkshelf')
+    end
+
+    context 'when the server does not respond' do
+      before do
+        allow(subject).to receive(:open)
+          .and_raise(Timeout::Error)
+      end
+
+      it 'catches and logs the error' do
+        expect(subject.log).to receive(:error).with(/in 15 seconds/)
+        expect { subject.universe }.to_not raise_error
+      end
+    end
+
+    context 'when the response is not valid JSON' do
+      let(:json) { 'bad json' }
+
+      it 'catches a JSON::ParserError' do
+        expect(subject.log).to receive(:error).with(/^Failed to parse JSON/)
+        expect { subject.universe }.to_not raise_error
+      end
+    end
+
+    [
+      SocketError,
+      Errno::ECONNREFUSED,
+      Errno::ECONNRESET,
+      Errno::ENETUNREACH,
+    ].each do |error|
+      context "when `#{error}' is raised" do
+        before do
+          allow(subject).to receive(:open)
+            .and_raise(error)
+        end
+
+        it "catches and logs the error" do
+          expect(subject.log).to receive(:error).with(/^Failed to get/)
+          expect { subject.universe }.to_not raise_error
+        end
+      end
+    end
+  end
+end