librarianp 0.1.2

data/spec/unit/action/base_spec.rb

@@ -0,0 +1,18 @@
+require "librarian/action/base"
+
+module Librarian
+  describe Action::Base do
+
+    let(:env) { double }
+    let(:action) { described_class.new(env) }
+
+    subject { action }
+
+    it { should respond_to :environment }
+
+    it "should have the environment that was assigned to it" do
+      expect(action.environment).to be env
+    end
+
+  end
+end

data/spec/unit/action/clean_spec.rb

@@ -0,0 +1,102 @@
+require "librarian/action/clean"
+
+module Librarian
+  describe Action::Clean do
+
+    let(:env) { double }
+    let(:action) { described_class.new(env) }
+
+    before do
+      action.stub(:debug)
+    end
+
+    describe "#run" do
+
+      describe "behavior" do
+
+        after do
+          action.run
+        end
+
+        describe "clearing the cache path" do
+
+          before do
+            action.stub(:clean_install_path)
+          end
+
+          context "when the cache path is missing" do
+            before do
+              env.stub_chain(:cache_path, :exist?) { false }
+            end
+
+            it "should not try to clear the cache path" do
+              expect(env.cache_path).to receive(:rmtree).never
+            end
+          end
+
+          context "when the cache path is present" do
+            before do
+              env.stub_chain(:cache_path, :exist?) { true }
+            end
+
+            it "should try to clear the cache path" do
+              expect(env.cache_path).to receive(:rmtree).exactly(:once)
+            end
+          end
+
+        end
+
+        describe "clearing the install path" do
+
+          before do
+            action.stub(:clean_cache_path)
+          end
+
+          context "when the install path is missing" do
+            before do
+              env.stub_chain(:install_path, :exist?) { false }
+            end
+
+            it "should not try to clear the install path" do
+              expect(env.install_path).to receive(:children).never
+            end
+          end
+
+          context "when the install path is present" do
+            before do
+              env.stub_chain(:install_path, :exist?) { true }
+            end
+
+            it "should try to clear the install path" do
+              children = [double, double, double]
+              children.each do |child|
+                child.stub(:file?) { false }
+              end
+              env.stub_chain(:install_path, :children) { children }
+
+              children.each do |child|
+                expect(child).to receive(:rmtree).exactly(:once)
+              end
+            end
+
+            it "should only try to clear out directories from the install path, not files" do
+              children = [double(:file? => false), double(:file? => true), double(:file? => true)]
+              env.stub_chain(:install_path, :children) { children }
+
+              children.select(&:file?).each do |child|
+                expect(child).to receive(:rmtree).never
+              end
+              children.reject(&:file?).each do |child|
+                expect(child).to receive(:rmtree).exactly(:once)
+              end
+            end
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+end

data/spec/unit/action/ensure_spec.rb

@@ -0,0 +1,37 @@
+require "tmpdir"
+
+require "librarian/error"
+require "librarian/action/ensure"
+
+module Librarian
+  describe Action::Ensure do
+
+    let(:env) { double }
+    let(:action) { described_class.new(env) }
+
+    before do
+      env.stub(:specfile_name) { "Specfile" }
+    end
+
+    describe "#run" do
+
+      context "when the environment does not know its project path" do
+        before { env.stub(:project_path) { nil } }
+
+        it "should raise an error describing that the specfile is mising" do
+          expect { action.run }.to raise_error(Error, "Cannot find Specfile!")
+        end
+      end
+
+      context "when the environment knows its project path" do
+        before { env.stub(:project_path) { Dir.tmpdir } }
+
+        it "should not raise an error" do
+          expect { action.run }.to_not raise_error
+        end
+      end
+
+    end
+
+  end
+end

data/spec/unit/action/install_spec.rb

@@ -0,0 +1,111 @@
+require "librarian/error"
+require "librarian/action/install"
+
+module Librarian
+  describe Action::Install do
+
+    let(:env) { double(:specfile_name => "Specfile", :lockfile_name => "Specfile.lock") }
+    let(:action) { described_class.new(env) }
+
+    describe "#run" do
+
+      describe "behavior" do
+
+        describe "checking preconditions" do
+
+          context "when the specfile is missing" do
+            before do
+              env.stub_chain(:specfile_path, :exist?) { false }
+            end
+
+            it "should raise an error explaining that the specfile is missing" do
+              expect { action.run }.to raise_error(Error, "Specfile missing!")
+            end
+          end
+
+          context "when the specfile is present but the lockfile is missing" do
+            before do
+              env.stub_chain(:specfile_path, :exist?) { true }
+              env.stub_chain(:lockfile_path, :exist?) { false }
+            end
+
+            it "should raise an error explaining that the lockfile is missing" do
+              expect { action.run }.to raise_error(Error, "Specfile.lock missing!")
+            end
+          end
+
+          context "when the specfile and lockfile are present but inconsistent" do
+            before do
+              env.stub_chain(:specfile_path, :exist?) { true }
+              env.stub_chain(:lockfile_path, :exist?) { true }
+              action.stub(:spec_consistent_with_lock?) { false }
+            end
+
+            it "should raise an error explaining the inconsistenty" do
+              expect { action.run }.to raise_error(Error, "Specfile and Specfile.lock are out of sync!")
+            end
+          end
+
+          context "when the specfile and lockfile are present and consistent" do
+            before do
+              env.stub_chain(:specfile_path, :exist?) { true }
+              env.stub_chain(:lockfile_path, :exist?) { true }
+              action.stub(:spec_consistent_with_lock?) { true }
+              action.stub(:perform_installation)
+            end
+
+            it "should not raise an error" do
+              expect { action.run }.to_not raise_error
+            end
+          end
+
+        end
+
+        describe "performing the install" do
+
+          def mock_manifest(i)
+            double(:name => "manifest-#{i}")
+          end
+
+          let(:manifests) { 3.times.map{|i| mock_manifest(i)} }
+          let(:sorted_manifests) { 4.times.map{|i| mock_manifest(i + 3)} }
+          let(:install_path) { double }
+
+          before do
+            env.stub(:install_path) { install_path }
+            action.stub(:check_preconditions)
+            action.stub_chain(:lock, :manifests) { manifests }
+          end
+
+          after do
+            action.run
+          end
+
+          it "should sort and install the manifests" do
+            expect(ManifestSet).to receive(:sort).with(manifests).exactly(:once).ordered { sorted_manifests }
+
+            install_path.stub(:exist?) { false }
+            expect(install_path).to receive(:mkpath).exactly(:once).ordered
+
+            sorted_manifests.each do |manifest|
+              expect(manifest).to receive(:install!).exactly(:once).ordered
+            end
+          end
+
+          it "should recreate the install path if it already exists" do
+            action.stub(:sorted_manifests) { sorted_manifests }
+            action.stub(:install_manifests)
+
+            install_path.stub(:exist?) { true }
+            expect(install_path).to receive(:rmtree)
+            expect(install_path).to receive(:mkpath)
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+end

data/spec/unit/algorithms_spec.rb

@@ -0,0 +1,131 @@
+require "librarian/algorithms"
+
+module Librarian
+  module Algorithms
+
+    describe AdjacencyListDirectedGraph do
+
+      describe :cyclic? do
+        subject(:result) { described_class.cyclic?(graph) }
+
+        context "with an empty graph" do
+          let(:graph) { { } }
+          it { should be false }
+        end
+
+        context "with a 1-node acyclic graph" do
+          let(:graph) { { ?a => nil } }
+          it { should be false }
+        end
+
+        context "with a 1-node cyclic graph" do
+          let(:graph) { { ?a => [?a] } }
+          it { should be true }
+        end
+
+        context "with a 2-node no-edge graph" do
+          let(:graph) { { ?a => nil, ?b => nil } }
+          it { should be false }
+        end
+
+        context "with a 2-node acyclic graph" do
+          let(:graph) { { ?a => [?b], ?b => nil } }
+          it { should be false }
+        end
+
+        context "with a 2-node cyclic graph" do
+          let(:graph) { { ?a => [?b], ?b => [?a] } }
+          it { should be true }
+        end
+
+        context "with a 2-scc graph" do
+          let(:graph) { { ?a => [?b], ?b => [?a], ?c => [?d, ?b], ?d => [?c] } }
+          it { should be true }
+        end
+
+      end
+
+      describe :feedback_arc_set do
+        subject(:result) { described_class.feedback_arc_set(graph) }
+
+        context "with an empty graph" do
+          let(:graph) { { } }
+          it { should be_empty }
+        end
+
+        context "with a 1-node acyclic graph" do
+          let(:graph) { { ?a => nil } }
+          it { should be_empty }
+        end
+
+        context "with a 1-node cyclic graph" do
+          let(:graph) { { ?a => [?a] } }
+          it { should be == [[?a, ?a]] }
+        end
+
+        context "with a 2-node no-edge graph" do
+          let(:graph) { { ?a => nil, ?b => nil } }
+          it { should be_empty }
+        end
+
+        context "with a 2-node acyclic graph" do
+          let(:graph) { { ?a => [?b], ?b => nil } }
+          it { should be_empty }
+        end
+
+        context "with a 2-node cyclic graph" do
+          let(:graph) { { ?a => [?b], ?b => [?a] } }
+          it { should be == [[?a, ?b]] } # based on the explicit sort
+        end
+
+        context "with a 2-scc graph" do
+          let(:graph) { { ?a => [?b], ?b => [?a], ?c => [?d, ?b], ?d => [?c] } }
+          it { should be == [[?a, ?b], [?c, ?d]] }
+        end
+
+      end
+
+      describe :tsort_cyclic do
+        subject(:result) { described_class.tsort_cyclic(graph) }
+
+        context "with an empty graph" do
+          let(:graph) { { } }
+          it { should be == [] }
+        end
+
+        context "with a 1-node acyclic graph" do
+          let(:graph) { { ?a => nil } }
+          it { should be == [?a] }
+        end
+
+        context "with a 1-node cyclic graph" do
+          let(:graph) { { ?a => [?a] } }
+          it { should be == [?a] }
+        end
+
+        context "with a 2-node no-edge graph" do
+          let(:graph) { { ?a => nil, ?b => nil } }
+          it { should be == [?a, ?b] }
+        end
+
+        context "with a 2-node acyclic graph" do
+          let(:graph) { { ?a => [?b], ?b => nil } }
+          it { should be == [?b, ?a] } # based on the explicit sort
+        end
+
+        context "with a 2-node cyclic graph" do
+          let(:graph) { { ?a => [?b], ?b => [?a] } }
+          it { should be == [?a, ?b] } # based on the explicit sort
+        end
+
+        context "with a 2-scc graph" do
+          let(:graph) { { ?a => [?b], ?b => [?a], ?c => [?d, ?b], ?d => [?c] } }
+          it { should be == [?a, ?b, ?c, ?d] }
+        end
+
+      end
+
+    end
+
+  end
+end