librarian-puppet-lmco 0.9.8.2

data/vendor/librarian/spec/unit/lockfile/parser_spec.rb

@@ -0,0 +1,162 @@
+require "librarian/helpers"
+require "librarian/lockfile/parser"
+require "librarian/mock"
+
+module Librarian
+  describe Lockfile::Parser do
+
+    let(:env) { Mock::Environment.new }
+    let(:parser) { described_class.new(env) }
+    let(:resolution) { parser.parse(lockfile) }
+
+    context "a mock lockfile with one source and no dependencies" do
+      let(:lockfile) do
+        Helpers.strip_heredoc <<-LOCKFILE
+          MOCK
+            remote: source-a
+            specs:
+
+          DEPENDENCIES
+
+        LOCKFILE
+      end
+
+      it "should give an empty list of dependencies" do
+        resolution.dependencies.should be_empty
+      end
+
+      it "should give an empty list of manifests" do
+        resolution.manifests.should be_empty
+      end
+    end
+
+    context "a mock lockfile with one source and one dependency" do
+      let(:lockfile) do
+        Helpers.strip_heredoc <<-LOCKFILE
+          MOCK
+            remote: source-a
+            specs:
+              jelly (1.3.5)
+
+          DEPENDENCIES
+            jelly (!= 1.2.6, ~> 1.1)
+
+        LOCKFILE
+      end
+
+      it "should give a list of one dependency" do
+        resolution.should have(1).dependencies
+      end
+
+      it "should give a dependency with the expected name" do
+        dependency = resolution.dependencies.first
+
+        dependency.name.should == "jelly"
+      end
+
+      it "should give a dependency with the expected requirement" do
+        dependency = resolution.dependencies.first
+
+        # Note: it must be this order because this order is lexicographically sorted.
+        dependency.requirement.to_s.should == "!= 1.2.6, ~> 1.1"
+      end
+
+      it "should give a dependency wth the expected source" do
+        dependency = resolution.dependencies.first
+        source = dependency.source
+
+        source.name.should == "source-a"
+      end
+
+      it "should give a list of one manifest" do
+        resolution.should have(1).manifests
+      end
+
+      it "should give a manifest with the expected name" do
+        manifest = resolution.manifests.first
+
+        manifest.name.should == "jelly"
+      end
+
+      it "should give a manifest with the expected version" do
+        manifest = resolution.manifests.first
+
+        manifest.version.to_s.should == "1.3.5"
+      end
+
+      it "should give a manifest with no dependencies" do
+        manifest = resolution.manifests.first
+
+        manifest.dependencies.should be_empty
+      end
+
+      it "should give a manifest with the expected source" do
+        manifest = resolution.manifests.first
+        source = manifest.source
+
+        source.name.should == "source-a"
+      end
+
+      it "should give the dependency and the manifest the same source instance" do
+        dependency = resolution.dependencies.first
+        manifest = resolution.manifests.first
+
+        dependency_source = dependency.source
+        manifest_source = manifest.source
+
+        manifest_source.should be dependency_source
+      end
+    end
+
+    context "a mock lockfile with one source and a complex dependency" do
+      let(:lockfile) do
+        Helpers.strip_heredoc <<-LOCKFILE
+          MOCK
+            remote: source-a
+            specs:
+              butter (2.5.3)
+              jelly (1.3.5)
+                butter (< 3, >= 1.1)
+
+          DEPENDENCIES
+            jelly (!= 1.2.6, ~> 1.1)
+
+        LOCKFILE
+      end
+
+      it "should give a list of one dependency" do
+        resolution.should have(1).dependencies
+      end
+
+      it "should have the expected dependency" do
+        dependency = resolution.dependencies.first
+
+        dependency.name.should == "jelly"
+      end
+
+      it "should give a list of all the manifests" do
+        resolution.should have(2).manifests
+      end
+
+      it "should include all the expected manifests" do
+        manifests = ManifestSet.new(resolution.manifests)
+
+        manifests.to_hash.keys.should =~ %w(butter jelly)
+      end
+
+      it "should have an internally consistent set of manifests" do
+        manifests = ManifestSet.new(resolution.manifests)
+
+        manifests.should be_consistent
+      end
+
+      it "should have an externally consistent set of manifests" do
+        dependencies = resolution.dependencies
+        manifests = ManifestSet.new(resolution.manifests)
+
+        manifests.should be_in_compliance_with dependencies
+      end
+    end
+
+  end
+end

data/vendor/librarian/spec/unit/lockfile_spec.rb

@@ -0,0 +1,65 @@
+require 'librarian'
+require 'librarian/mock'
+
+module Librarian
+  describe Lockfile do
+
+    let(:env) { Mock::Environment.new }
+
+    before do
+      env.registry :clear => true do
+        source 'source-1' do
+          spec 'alpha', '1.1'
+        end
+      end
+    end
+
+    let(:spec) do
+      env.dsl do
+        src 'source-1'
+        dep 'alpha', '1.1'
+      end
+    end
+
+    let(:resolver) { env.resolver }
+    let(:resolution) { resolver.resolve(spec) }
+
+    context "sanity" do
+      context "the resolution" do
+        subject { resolution }
+
+        it { should be_correct }
+        it { should have(1).manifests }
+      end
+    end
+
+    describe "#save" do
+      let(:lockfile) { env.ephemeral_lockfile }
+      let(:lockfile_text) { lockfile.save(resolution) }
+
+      context "just saving" do
+        it "should return the lockfile text" do
+          lockfile_text.should_not be_nil
+        end
+      end
+
+      context "saving and reloading" do
+        let(:reloaded_resolution) { lockfile.load(lockfile_text) }
+
+        it "should have the expected manifests" do
+          reloaded_resolution.manifests.count.should == resolution.manifests.count
+        end
+      end
+
+      context "bouncing" do
+        let(:bounced_resolution) { lockfile.load(lockfile_text) }
+        let(:bounced_lockfile_text) { lockfile.save(bounced_resolution) }
+
+        it "should return the same lockfile text after bouncing as before bouncing" do
+          bounced_lockfile_text.should == lockfile_text
+        end
+      end
+    end
+
+  end
+end

data/vendor/librarian/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
+          set.to_a.should =~ array
+        end
+
+        it "should give back the hash" do
+          set.to_hash.should == hash
+        end
+      end
+
+      context "with a hash" do
+        let(:set) { described_class.new(hash) }
+
+        it "should give back the array" do
+          set.to_a.should =~ array
+        end
+
+        it "should give back the hash" do
+          set.to_hash.should == 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!([])
+
+        set.to_a.should =~ [jelly, butter, jam]
+      end
+
+      it "should remove only the named elements" do
+        set.shallow_strip!(["butter", "jam"])
+
+        set.to_a.should =~ [jelly]
+      end
+
+      it "should allow removing all the elements" do
+        set.shallow_strip!(["jelly", "butter", "jam"])
+
+        set.to_a.should =~ []
+      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!([])
+
+        set.to_a.should =~ []
+      end
+
+      it "should keep only the named elements" do
+        set.shallow_keep!(["butter", "jam"])
+
+        set.to_a.should =~ [butter, jam]
+      end
+
+      it "should allow keeping all the elements" do
+        set.shallow_keep!(["jelly", "butter", "jam"])
+
+        set.to_a.should =~ [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!([])
+
+        set.to_a.should =~ [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"])
+
+        set.to_a.should =~ [a, b, d, e, f, g]
+      end
+
+      it "should remove the named elements and all their dependencies" do
+        set.deep_strip!(["b"])
+
+        set.to_a.should =~ [a, e, f, g, h]
+      end
+
+      it "should remove an entire tree of dependencies" do
+        set.deep_strip!(["e"])
+
+        set.to_a.should =~ [a, b, c, d]
+      end
+
+      it "should allow removing all the elements" do
+        set.deep_strip!(["a", "e"])
+
+        set.to_a.should =~ []
+      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!([])
+
+        set.to_a.should =~ []
+      end
+
+      it "should keep just the named elements if they have no dependencies" do
+        set.deep_keep!(["c", "h"])
+
+        set.to_a.should =~ [c, h]
+      end
+
+      it "should keep the named elements and all their dependencies" do
+        set.deep_keep!(["b"])
+
+        set.to_a.should =~ [b, c, d]
+      end
+
+      it "should keep an entire tree of dependencies" do
+        set.deep_keep!(["e"])
+
+        set.to_a.should =~ [e, f, g, h]
+      end
+
+      it "should allow keeping all the elements" do
+        set.deep_keep!(["a", "e"])
+
+        set.to_a.should =~ [a, b, c, d, e, f, g, h]
+      end
+    end
+
+  end
+end

data/vendor/librarian/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