librarianp 0.1.2

data/spec/unit/manifest_set_spec.rb

@@ -0,0 +1,202 @@
+require 'librarian'
+
+module Librarian
+  describe ManifestSet do
+
+    describe ".new" do
+      let(:jelly) { double(:name => "jelly") }
+      let(:butter) { double(:name => "butter") }
+      let(:jam) { double(:name => "jam") }
+
+      let(:array) { [jelly, butter, jam] }
+      let(:hash) { {"jelly" => jelly, "butter" => butter, "jam" => jam} }
+
+      context "with an array" do
+        let(:set) { described_class.new(array) }
+
+        it "should give back the array" do
+          expect(set.to_a).to match_array( array )
+        end
+
+        it "should give back the hash" do
+          expect(set.to_hash).to eq hash
+        end
+      end
+
+      context "with a hash" do
+        let(:set) { described_class.new(hash) }
+
+        it "should give back the array" do
+          expect(set.to_a).to match_array( array )
+        end
+
+        it "should give back the hash" do
+          expect(set.to_hash).to eq hash
+        end
+      end
+    end
+
+    # Does not trace dependencies.
+    # That's why it's "shallow".
+    describe "#shallow_strip!" do
+      let(:jelly) { double(:name => "jelly") }
+      let(:butter) { double(:name => "butter") }
+      let(:jam) { double(:name => "jam") }
+
+      let(:set) { described_class.new([jelly, butter, jam]) }
+
+      it "should not do anything when given no names" do
+        set.shallow_strip!([])
+
+        expect(set.to_a).to match_array( [jelly, butter, jam] )
+      end
+
+      it "should remove only the named elements" do
+        set.shallow_strip!(["butter", "jam"])
+
+        expect(set.to_a).to match_array( [jelly] )
+      end
+
+      it "should allow removing all the elements" do
+        set.shallow_strip!(["jelly", "butter", "jam"])
+
+        expect(set.to_a).to match_array( [] )
+      end
+    end
+
+    # Does not trace dependencies.
+    # That's why it's "shallow".
+    describe "#shallow_keep!" do
+      let(:jelly) { double(:name => "jelly") }
+      let(:butter) { double(:name => "butter") }
+      let(:jam) { double(:name => "jam") }
+
+      let(:set) { described_class.new([jelly, butter, jam]) }
+
+      it "should empty the set when given no names" do
+        set.shallow_keep!([])
+
+        expect(set.to_a).to match_array( [] )
+      end
+
+      it "should keep only the named elements" do
+        set.shallow_keep!(["butter", "jam"])
+
+        expect(set.to_a).to match_array( [butter, jam] )
+      end
+
+      it "should allow keeping all the elements" do
+        set.shallow_keep!(["jelly", "butter", "jam"])
+
+        expect(set.to_a).to match_array( [jelly, butter, jam] )
+      end
+    end
+
+    describe "#deep_strip!" do
+      def man(o)
+        k, v = o.keys.first, o.values.first
+        double(k, :name => k, :dependencies => deps(v))
+      end
+
+      def deps(names)
+        names.map{|n| double(:name => n)}
+      end
+
+      let(:a) { man("a" => %w[b c]) }
+      let(:b) { man("b" => %w[c d]) }
+      let(:c) { man("c" => %w[   ]) }
+      let(:d) { man("d" => %w[   ]) }
+
+      let(:e) { man("e" => %w[f g]) }
+      let(:f) { man("f" => %w[g h]) }
+      let(:g) { man("g" => %w[   ]) }
+      let(:h) { man("h" => %w[   ]) }
+
+      let(:set) { described_class.new([a, b, c, d, e, f, g, h]) }
+
+      it "should not do anything when given no names" do
+        set.deep_strip!([])
+
+        expect(set.to_a).to match_array( [a, b, c, d, e, f, g, h] )
+      end
+
+      it "should remove just the named elements if they have no dependencies" do
+        set.deep_strip!(["c", "h"])
+
+        expect(set.to_a).to match_array( [a, b, d, e, f, g] )
+      end
+
+      it "should remove the named elements and all their dependencies" do
+        set.deep_strip!(["b"])
+
+        expect(set.to_a).to match_array( [a, e, f, g, h] )
+      end
+
+      it "should remove an entire tree of dependencies" do
+        set.deep_strip!(["e"])
+
+        expect(set.to_a).to match_array( [a, b, c, d] )
+      end
+
+      it "should allow removing all the elements" do
+        set.deep_strip!(["a", "e"])
+
+        expect(set.to_a).to match_array( [] )
+      end
+    end
+
+    describe "#deep_keep!" do
+      def man(o)
+        k, v = o.keys.first, o.values.first
+        double(k, :name => k, :dependencies => deps(v))
+      end
+
+      def deps(names)
+        names.map{|n| double(:name => n)}
+      end
+
+      let(:a) { man("a" => %w[b c]) }
+      let(:b) { man("b" => %w[c d]) }
+      let(:c) { man("c" => %w[   ]) }
+      let(:d) { man("d" => %w[   ]) }
+
+      let(:e) { man("e" => %w[f g]) }
+      let(:f) { man("f" => %w[g h]) }
+      let(:g) { man("g" => %w[   ]) }
+      let(:h) { man("h" => %w[   ]) }
+
+      let(:set) { described_class.new([a, b, c, d, e, f, g, h]) }
+
+      it "should remove all the elements when given no names" do
+        set.deep_keep!([])
+
+        expect(set.to_a).to match_array( [] )
+      end
+
+      it "should keep just the named elements if they have no dependencies" do
+        set.deep_keep!(["c", "h"])
+
+        expect(set.to_a).to match_array( [c, h] )
+      end
+
+      it "should keep the named elements and all their dependencies" do
+        set.deep_keep!(["b"])
+
+        expect(set.to_a).to match_array( [b, c, d] )
+      end
+
+      it "should keep an entire tree of dependencies" do
+        set.deep_keep!(["e"])
+
+        expect(set.to_a).to match_array( [e, f, g, h] )
+      end
+
+      it "should allow keeping all the elements" do
+        set.deep_keep!(["a", "e"])
+
+        expect(set.to_a).to match_array( [a, b, c, d, e, f, g, h] )
+      end
+    end
+
+  end
+end

data/spec/unit/manifest_spec.rb

@@ -0,0 +1,36 @@
+require "librarian/manifest"
+
+describe Librarian::Manifest do
+
+  describe "validations" do
+
+    context "when the name is blank" do
+      it "raises" do
+        expect { described_class.new(nil, "") }.
+          to raise_error(ArgumentError, %{name ("") must be sensible})
+      end
+    end
+
+    context "when the name has leading whitespace" do
+      it "raises" do
+        expect { described_class.new(nil, "  the-name") }.
+          to raise_error(ArgumentError, %{name ("  the-name") must be sensible})
+      end
+    end
+
+    context "when the name has trailing whitespace" do
+      it "raises" do
+        expect { described_class.new(nil, "the-name  ") }.
+          to raise_error(ArgumentError, %{name ("the-name  ") must be sensible})
+      end
+    end
+
+    context "when the name is a single character" do
+      it "passes" do
+        described_class.new(nil, "R")
+      end
+    end
+
+  end
+
+end

data/spec/unit/mock/environment_spec.rb

@@ -0,0 +1,25 @@
+require "librarian/mock/environment"
+
+module Librarian::Mock
+  describe Environment do
+
+    let(:env) { described_class.new }
+
+    describe "#version" do
+      specify { expect(env.version).to eq Librarian::VERSION }
+    end
+
+    describe "#adapter_module" do
+      specify { expect(env.adapter_module).to eq Librarian::Mock }
+    end
+
+    describe "#adapter_name" do
+      specify { expect(env.adapter_name).to eq "mock" }
+    end
+
+    describe "#adapter_version" do
+      specify { expect(env.adapter_version).to eq Librarian::Mock::VERSION }
+    end
+
+  end
+end

data/spec/unit/mock/source/mock_spec.rb

@@ -0,0 +1,22 @@
+require "librarian/mock"
+
+module Librarian
+  module Mock
+    module Source
+      describe Mock do
+
+        let(:env) { Librarian::Mock::Environment.new }
+
+        describe ".new" do
+
+          let(:source) { described_class.new(env, "source-a", {}) }
+          subject { source }
+
+          its(:environment) { should_not be_nil }
+
+        end
+
+      end
+    end
+  end
+end

data/spec/unit/resolver_spec.rb

@@ -0,0 +1,299 @@
+require "pathname"
+require "tmpdir"
+
+require "support/fakefs"
+
+require 'librarian/resolver'
+require 'librarian/spec_change_set'
+require 'librarian/mock'
+
+module Librarian
+  describe Resolver do
+    include ::Support::FakeFS
+
+    let(:env) { Mock::Environment.new }
+    let(:resolver) { env.resolver }
+
+    context "a simple specfile" do
+
+      before do
+        env.registry :clear => true do
+          source 'source-1' do
+            spec 'butter', '1.1'
+          end
+        end
+      end
+
+      let(:spec) do
+        env.dsl do
+          src 'source-1'
+          dep 'butter'
+        end
+      end
+
+      let(:resolution) { resolver.resolve(spec) }
+
+      specify { expect(resolution).to be_correct }
+
+    end
+
+    context "a specfile with a dep from one src depending on a dep from another src" do
+
+      before do
+        env.registry :clear => true do
+          source 'source-1' do
+            spec 'butter', '1.1'
+          end
+          source 'source-2' do
+            spec 'jam', '1.2' do
+              dependency 'butter', '>= 1.0'
+            end
+          end
+        end
+      end
+
+      let(:spec) do
+        env.dsl do
+          src 'source-1'
+          src 'source-2' do
+            dep 'jam'
+          end
+        end
+      end
+
+      let(:resolution) { resolver.resolve(spec) }
+
+      specify { expect(resolution).to be_correct }
+
+    end
+
+    context "a specfile with a dep in multiple sources" do
+
+      before do
+        env.registry :clear => true do
+          source 'source-1' do
+            spec 'butter', '1.0'
+            spec 'butter', '1.1'
+          end
+          source 'source-2' do
+            spec 'butter', '1.0'
+            spec 'butter', '1.1'
+          end
+          source 'source-3' do
+            spec 'butter', '1.0'
+          end
+        end
+      end
+
+      let(:spec) do
+        env.dsl do
+          src 'source-1'
+          src 'source-2'
+          dep 'butter', '>= 1.1'
+        end
+      end
+
+      it "should have the expected number of sources" do
+        expect(spec).to have(2).sources
+      end
+
+      let(:resolution) { resolver.resolve(spec) }
+
+      specify { expect(resolution).to be_correct }
+
+      it "should have the manifest from the final source with a matching manifest" do
+        manifest = resolution.manifests.find{|m| m.name == "butter"}
+        expect(manifest.source.name).to eq "source-2"
+      end
+
+    end
+
+    context "a specfile with a dep depending on a nonexistent dep" do
+
+      before do
+        env.registry :clear => true do
+          source 'source-1' do
+            spec 'jam', '1.2' do
+              dependency 'butter', '>= 1.0'
+            end
+          end
+        end
+      end
+
+      let(:spec) do
+        env.dsl do
+          src 'source-1'
+          dep 'jam'
+        end
+      end
+
+      let(:resolution) { resolver.resolve(spec) }
+
+      specify { expect(resolution).to be_nil }
+
+    end
+
+    context "a specfile with conflicting constraints" do
+
+      before do
+        env.registry :clear => true do
+          source 'source-1' do
+            spec 'butter', '1.0'
+            spec 'butter', '1.1'
+            spec 'jam', '1.2' do
+              dependency 'butter', '1.1'
+            end
+          end
+        end
+      end
+
+      let(:spec) do
+        env.dsl do
+          src 'source-1'
+          dep 'butter', '1.0'
+          dep 'jam'
+        end
+      end
+
+      let(:resolution) { resolver.resolve(spec) }
+
+      specify { expect(resolution).to be_nil }
+
+    end
+
+    context "a specfile with cyclic constraints" do
+
+      before do
+        env.registry :clear => true do
+          source 'source-1' do
+            spec 'butter', '1.0' do
+              dependency 'jam', '2.0'
+            end
+            spec 'jam', '2.0' do
+              dependency 'butter', '1.0'
+            end
+          end
+        end
+      end
+
+      let(:spec) do
+        env.dsl do
+          src 'source-1'
+          dep 'butter'
+        end
+      end
+
+      let(:resolution) { resolver.resolve(spec) }
+
+      context "when cyclic resolutions are forbidden" do
+        let(:resolver) { env.resolver(:cyclic => false) }
+
+        specify { expect(resolution).to be_nil }
+      end
+
+      context "when cyclic resolutions are permitted" do
+        let(:resolver) { env.resolver(:cyclic => true) }
+
+        it "should have all the manifests" do
+          manifest_names = resolution.manifests.map(&:name).sort
+          expect(manifest_names).to be == %w[butter jam]
+        end
+      end
+
+    end
+
+    context "updating" do
+
+      it "should not work" do
+        env.registry :clear => true do
+          source 'source-1' do
+            spec 'butter', '1.0'
+            spec 'butter', '1.1'
+            spec 'jam', '1.2' do
+              dependency 'butter'
+            end
+          end
+        end
+        first_spec = env.dsl do
+          src 'source-1'
+          dep 'butter', '1.1'
+          dep 'jam'
+        end
+        first_resolution = resolver.resolve(first_spec)
+        expect(first_resolution).to be_correct
+        first_manifests = first_resolution.manifests
+        first_manifests_index = Hash[first_manifests.map{|m| [m.name, m]}]
+        expect(first_manifests_index['butter'].version.to_s).to eq '1.1'
+
+        second_spec = env.dsl do
+          src 'source-1'
+          dep 'butter', '1.0'
+          dep 'jam'
+        end
+        locked_manifests = ManifestSet.deep_strip(first_manifests, ['butter'])
+        second_resolution =resolver.resolve(second_spec, locked_manifests)
+        expect(second_resolution).to be_correct
+        second_manifests = second_resolution.manifests
+        second_manifests_index = Hash[second_manifests.map{|m| [m.name, m]}]
+        expect(second_manifests_index['butter'].version.to_s).to eq '1.0'
+      end
+
+    end
+
+    context "a change to the spec" do
+
+      it "should work" do
+        env.registry :clear => true do
+          source 'source-1' do
+            spec 'butter', '1.0'
+          end
+          source 'source-2' do
+            spec 'butter', '1.0'
+          end
+        end
+        spec = env.dsl do
+          src 'source-1'
+          dep 'butter'
+        end
+        lock = resolver.resolve(spec)
+        expect(lock).to be_correct
+
+        spec = env.dsl do
+          src 'source-1'
+          dep 'butter', :src => 'source-2'
+        end
+        changes = SpecChangeSet.new(env, spec, lock)
+        expect(changes).to_not be_same
+        manifests = ManifestSet.new(changes.analyze).to_hash
+        expect(manifests).to_not have_key('butter')
+        lock = resolver.resolve(spec, changes.analyze)
+        expect(lock).to be_correct
+        expect(lock.manifests.map{|m| m.name}).to include('butter')
+        manifest = lock.manifests.find{|m| m.name == 'butter'}
+        expect(manifest).to_not be_nil
+        expect(manifest.source.name).to eq 'source-2'
+      end
+
+    end
+
+    context "a pathname to a simple specfile" do
+      let(:pwd) { Pathname(Dir.tmpdir) }
+      let(:specfile_path) { pwd + "Mockfile" }
+      before { FileUtils.mkpath(pwd) }
+
+      def write!(path, text)
+        Pathname(path).open("wb"){|f| f.write(text)}
+      end
+
+      it "loads the specfile with the __FILE__" do
+        write! specfile_path, "src __FILE__"
+        spec = env.dsl(specfile_path)
+        expect(spec.sources).to have(1).item
+        source = spec.sources.first
+        expect(source.name).to eq specfile_path.to_s
+      end
+
+    end
+
+  end
+end

data/spec/unit/source/git_spec.rb

@@ -0,0 +1,29 @@
+require "librarian"
+
+module Librarian
+  module Source
+    describe Git do
+
+      let(:env) { Environment.new }
+
+      describe "validating options for the specfile" do
+
+        context "with only known options" do
+          it "should not raise" do
+            expect { described_class.from_spec_args(env, "some://git/repo.git", :ref => "megapatches") }.
+              to_not raise_error
+          end
+        end
+
+        context "with an unknown option" do
+          it "should raise" do
+            expect { described_class.from_spec_args(env, "some://git/repo.git", :branch => "megapatches") }.
+              to raise_error Error, "unrecognized options: branch"
+          end
+        end
+
+      end
+
+    end
+  end
+end