berkshelf-api 0.1.0

data/spec/unit/berkshelf/api/cache_builder/worker/chef_server_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe Berkshelf::API::CacheBuilder::Worker::ChefServer do
+  describe "ClassMethods" do
+    subject { described_class }
+    its(:worker_type) { should eql("chef_server") }
+  end
+
+  subject do
+    described_class.new(url: "http://localhost:8889", client_name: "reset",
+      client_key: fixtures_path.join("reset.pem"))
+  end
+
+  describe "#cookbooks" do
+    before do
+      chef_cookbook("ruby", "1.0.0")
+      chef_cookbook("ruby", "2.0.0")
+      chef_cookbook("elixir", "3.0.0")
+      chef_cookbook("elixir", "3.0.1")
+    end
+
+    it "returns an array containing an item for each cookbook on the server" do
+      expect(subject.cookbooks).to have(4).items
+    end
+
+    it "returns an array of RemoteCookbooks" do
+      subject.cookbooks.each do |cookbook|
+        expect(cookbook).to be_a(Berkshelf::API::RemoteCookbook)
+      end
+    end
+
+    it "each RemoteCookbook is tagged with a location_type matching the worker_type of the builder" do
+      subject.cookbooks.each do |cookbook|
+        expect(cookbook.location_type).to eql(described_class.worker_type)
+      end
+    end
+  end
+
+  describe "#build" do
+    before do
+      Berkshelf::API::CacheManager.start
+      chef_cookbook("ruby", "1.0.0")
+      chef_cookbook("ruby", "2.0.0")
+      chef_cookbook("elixir", "3.0.0")
+      chef_cookbook("elixir", "3.0.1")
+    end
+
+    let(:cache) { Berkshelf::API::CacheManager.instance.cache }
+
+    it "adds each item to the cache" do
+      subject.build
+      expect(cache).to have_cookbook("ruby", "1.0.0")
+      expect(cache).to have_cookbook("ruby", "2.0.0")
+      expect(cache).to have_cookbook("elixir", "3.0.0")
+      expect(cache).to have_cookbook("elixir", "3.0.1")
+      expect(cache.cookbooks).to have(4).items
+    end
+  end
+end

data/spec/unit/berkshelf/api/cache_builder/worker/opscode_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Berkshelf::API::CacheBuilder::Worker::Opscode do
+  describe "ClassMethods" do
+    subject { described_class }
+    its(:worker_type) { should eql("opscode") }
+  end
+
+  let(:cookbooks) { ["chicken", "tuna"] }
+  let(:chicken_versions) { ["1.0", "2.0"] }
+  let(:tuna_versions) { ["3.0.0", "3.0.1"] }
+  let(:connection) do
+    connection = double('connection')
+    connection.stub(:cookbooks).and_return(cookbooks)
+    connection
+  end
+
+  subject do
+    Berkshelf::API::CacheManager.start
+    described_class.new
+  end
+
+  describe "#cookbooks" do
+    let(:location_type) { described_class.worker_type }
+    let(:location_path) { Berkshelf::API::SiteConnector::Opscode::V1_API}
+
+    it "returns an array of RemoteCookbooks described by the server" do
+      expected_value = [
+        Berkshelf::API::RemoteCookbook.new("chicken", "1.0", location_type, location_path),
+        Berkshelf::API::RemoteCookbook.new("chicken", "2.0", location_type, location_path),
+        Berkshelf::API::RemoteCookbook.new("tuna", "3.0.0", location_type, location_path),
+        Berkshelf::API::RemoteCookbook.new("tuna", "3.0.1", location_type, location_path)
+      ]
+
+      connection.should_receive(:future).with(:versions, "chicken").and_return(double(value: chicken_versions))
+      connection.should_receive(:future).with(:versions, "tuna").and_return(double(value: tuna_versions))
+      subject.should_receive(:connection).at_least(1).times.and_return(connection)
+      expect(subject.cookbooks).to eql(expected_value)
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+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)
+      end
+    end
+
+    describe "::register" do
+      it "adds the item to the Hash of types" do
+        worker = double('new-worker')
+        described_class.register("rspec-2", worker)
+        expect(described_class.types["rspec-2"]).to eql(worker)
+      end
+    end
+
+    describe "::types" do
+      subject { described_class.types }
+
+      it "returns a Hash" do
+        expect(subject).to be_a(Hash)
+      end
+    end
+  end
+end
+
+describe Berkshelf::API::CacheBuilder::Worker::Base do
+  describe "ClassMethods" do
+    describe "::worker_type" do
+      let(:klass) { Class.new(described_class) }
+
+      it "registers the worker type and class to Worker.types" do
+        klass.worker_type("rspec")
+        expect(Berkshelf::API::CacheBuilder::Worker.types).to include("rspec")
+      end
+    end
+  end
+
+  let(:cache_manager) { double(:diff => :chicken) }
+  subject { described_class.new }
+
+  describe "#diff" do
+    it "should delegate to the cache_manager to calculate the diff" do
+      subject.should_receive(:cache_manager).and_return(cache_manager)
+      subject.should_receive(:cookbooks).and_return(:cookbooks)
+
+      expect(subject.diff).to eql(:chicken)
+    end
+
+    it "should memoize the diff to prevent recalculating" do
+      subject.should_receive(:cache_manager).exactly(1).times.and_return(cache_manager)
+      subject.should_receive(:cookbooks).and_return(:cookbooks)
+
+      subject.diff
+      subject.diff
+    end
+  end
+
+  describe "#clear_diff" do
+    it "should set the diff to nil" do
+      subject.should_receive(:cache_manager).and_return(cache_manager)
+      subject.should_receive(:cookbooks).and_return(:cookbooks)
+
+      subject.diff
+      expect(subject.instance_variable_get(:@diff)).to eql(:chicken)
+      subject.send(:clear_diff)
+      expect(subject.instance_variable_get(:@diff)).to eql(nil)
+    end
+
+    it "memoizes the diff to prevent recalculating" do
+      subject.should_receive(:cache_manager).exactly(1).times.and_return(cache_manager)
+      subject.should_receive(:cookbooks).and_return(:cookbooks)
+
+      subject.diff
+      subject.diff
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Berkshelf::API::CacheBuilder do
+  let(:instance) { described_class.new }
+
+  describe "#build" do
+    subject(:build) { instance.build }
+    let(:workers) { [ double('worker') ] }
+    let(:future) { double('future', value: nil) }
+
+    before { instance.stub(workers: workers) }
+
+    it "sends a #build message to each worker" do
+      workers.each { |worker| worker.should_receive(:future).with(:build).and_return(future) }
+      build
+    end
+  end
+
+  describe "#workers" do
+    subject(:workers) { instance.workers }
+
+    it "returns an array of workers" do
+      expect(workers).to be_a(Array)
+      workers.each do |worker|
+        expect(worker).to be_a(described_class::Worker::Base)
+      end
+    end
+
+    it "has one worker started by default" do
+      expect(workers).to have(1).item
+    end
+
+    it "has an opscode worker started by default" do
+      expect(workers.first).to be_a(described_class::Worker::Opscode)
+    end
+  end
+end

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

@@ -0,0 +1,123 @@
+require 'spec_helper'
+
+describe Berkshelf::API::CacheManager do
+  describe "ClassMethods" do
+    describe "::new" do
+      subject { described_class.new }
+      its(:cache) { should be_empty }
+
+      context "when a save file exists" do
+        before do
+          @tempfile = Tempfile.new('berkshelf-api-rspec')
+          described_class.stub(:cache_file) { @tempfile.path }
+        end
+        after { @tempfile.close(true) }
+
+        it "loads the saved cache" do
+          described_class.any_instance.should_receive(:load_save)
+          subject
+        end
+      end
+
+      context "when a save file does not exist" do
+        before { described_class.stub(cache_file: tmp_path.join('does_not_exist').to_s) }
+
+        it "skips loading of the saved cache" do
+          described_class.any_instance.should_not_receive(:load_save)
+          subject
+        end
+      end
+    end
+
+    describe "::start" do
+      it "starts and registers a cache manager it with the application" do
+        described_class.start
+
+        expect(Berkshelf::API::Application[:cache_manager]).to be_a(described_class)
+        expect(Berkshelf::API::Application[:cache_manager]).to be_alive
+      end
+    end
+  end
+
+  subject { described_class.new }
+
+  describe "#add" do
+    pending
+  end
+
+  describe "#load_save" do
+    pending
+  end
+
+  describe "#remove" do
+    pending
+  end
+
+  describe "#clear" do
+    it "returns an empty Hash" do
+      result = subject.clear
+      expect(result).to be_a(Hash)
+      expect(result).to be_empty
+    end
+
+    it "empties the cache" do
+      subject.clear
+      expect(subject.cache).to be_empty
+    end
+  end
+
+  describe "#diff" do
+    let(:cookbook_one) { Berkshelf::API::RemoteCookbook.new("ruby", "1.2.3", "opscode") }
+    let(:cookbook_two) { Berkshelf::API::RemoteCookbook.new("elixir", "2.0.0", "opscode") }
+    let(:comparison) { Array.new }
+
+    before do
+      subject.add(cookbook_one, double(dependencies: nil, platforms: nil))
+      subject.add(cookbook_two, double(dependencies: nil, platforms: nil))
+
+      @created, @deleted = @diff = subject.diff(comparison)
+    end
+
+    it "returns two items" do
+      expect(@diff).to have(2).items
+    end
+
+    context "when there are created and deleted cookbooks" do
+      let(:new_cookbook) { Berkshelf::API::RemoteCookbook.new("ruby", "3.0.0", "opscode") }
+      let(:comparison) { [ cookbook_one, new_cookbook ] }
+
+      it "should return created and deleted cookbooks" do
+        expect(@created).to eql([new_cookbook])
+        expect(@deleted).to eql([cookbook_two])
+      end
+    end
+
+    context "when there are only created cookbooks" do
+      let(:new_cookbook) { Berkshelf::API::RemoteCookbook.new("ruby", "3.0.0", "opscode") }
+      let(:comparison) { [ cookbook_one, cookbook_two, new_cookbook ] }
+
+      it "should return only created cookbooks" do
+        expect(@created).to eql([new_cookbook])
+        expect(@deleted).to be_empty
+      end
+    end
+
+    context "when there are only deleted cookbooks" do
+      let(:comparison) { [ cookbook_one ] }
+
+      it "should return only deleted cookbooks" do
+        expect(@created).to be_empty
+        expect(@deleted).to eql([cookbook_two])
+      end
+    end
+
+    context "when there are no differences" do
+      let(:comparison) { [ cookbook_one, cookbook_two ] }
+
+      it "should return empty arrays" do
+        expect(@created).to be_empty
+        expect(@deleted).to be_empty
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe Berkshelf::API::Config do
+  describe "ClassMethods" do
+    describe "::default_path" do
+      it "returns a String" do
+        expect(described_class.default_path).to be_a(String)
+      end
+    end
+  end
+
+  describe "default config" do
+    subject { described_class.new }
+
+    it "has a endpoint configured" do
+      expect(subject.endpoints).to have(1).item
+    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")
+    end
+  end
+end

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

@@ -0,0 +1,109 @@
+require 'spec_helper'
+
+describe Berkshelf::API::DependencyCache do
+  describe "ClassMethods" do
+    describe "::from_file" do
+      let(:filepath) { @tempfile.path }
+      before { @tempfile = Tempfile.new('berkshelf-api-rspec') }
+      after  { @tempfile.close(true) }
+
+      subject { described_class.from_file(filepath) }
+
+      context "when the file contains valid json" do
+        before do
+          @tempfile.write(JSON.generate({brooke: "winsor"}))
+          @tempfile.flush
+        end
+
+        it "returns an instance of DependencyCache" do
+          expect(subject).to be_a(described_class)
+        end
+      end
+
+      context "when the filepath does not exist" do
+        let(:filepath) { nil }
+
+        it "raises a SaveNotFoundError" do
+          expect { subject }.to raise_error(Berkshelf::API::SaveNotFoundError)
+        end
+      end
+
+      context "when the file does not contain valid JSON" do
+        let(:filepath) { @tempfile.path }
+        before do
+          @tempfile.write("asdfasdfasdf")
+          @tempfile.flush
+        end
+
+        it "raises an InvalidSaveError" do
+          expect { subject }.to raise_error(Berkshelf::API::InvalidSaveError)
+        end
+      end
+    end
+  end
+
+  let(:chicken) do
+    { "1.0" =>
+      {
+        dependencies: { "tuna" => "= 3.0.0" },
+        platforms: { "centos" => ">= 0.0.0" }
+      }
+    }
+  end
+  let(:tuna) do
+    { "3.0.0" =>
+      {
+        dependencies: { },
+        platforms: { "centos" => ">= 0.0.0" }
+      }
+    }
+  end
+  let(:contents) do
+    {
+      "chicken" => chicken,
+      "tuna" => tuna,
+    }
+  end
+
+  subject { described_class.new(contents) }
+
+  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")
+      ]
+
+      expect(subject.cookbooks).to eql(expected_value)
+    end
+  end
+
+  describe "#add" do
+    let(:cookbook) { Berkshelf::API::RemoteCookbook.new("ruby", "1.2.3", "opscode") }
+    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
+    end
+  end
+
+  describe "#save" do
+    let(:path) { tmp_path.join('cerch.json') }
+
+    it "saves the contents of the cache as json to the given path" do
+      subject.save(path)
+      expect(File.exist?(path)).to be_true
+    end
+  end
+
+  describe "#clear" do
+    let(:cookbook) { Berkshelf::API::RemoteCookbook.new("ruby", "1.2.3", "opscode") }
+    before { subject.add(cookbook, double(platforms: nil, dependencies: nil)) }
+
+    it "empties items added to the cache" do
+      subject.clear
+      expect(subject).to be_empty
+    end
+  end
+end