librarian-puppet-maestrodev 0.9.7.5 → 0.9.8.1

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

@@ -1,202 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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/vendor/librarian/spec/unit/mock/source/mock_spec.rb

@@ -1,22 +0,0 @@
-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/vendor/librarian/spec/unit/resolver_spec.rb

@@ -1,192 +0,0 @@
-require 'librarian/resolver'
-require 'librarian/spec_change_set'
-require 'librarian/mock'
-
-module Librarian
-  describe Resolver do
-
-    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 { resolution.should 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 { resolution.should be_correct }
-
-    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 { resolution.should_not be_correct }
-
-    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 { resolution.should_not be_correct }
-
-    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)
-        first_resolution.should be_correct
-        first_manifests = first_resolution.manifests
-        first_manifests_index = Hash[first_manifests.map{|m| [m.name, m]}]
-        first_manifests_index['butter'].version.to_s.should == '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)
-        second_resolution.should be_correct
-        second_manifests = second_resolution.manifests
-        second_manifests_index = Hash[second_manifests.map{|m| [m.name, m]}]
-        second_manifests_index['butter'].version.to_s.should == '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)
-        lock.should be_correct
-
-        spec = env.dsl do
-          src 'source-1'
-          dep 'butter', :src => 'source-2'
-        end
-        changes = SpecChangeSet.new(env, spec, lock)
-        changes.should_not be_same
-        manifests = ManifestSet.new(changes.analyze).to_hash
-        manifests.should_not have_key('butter')
-        lock = resolver.resolve(spec, changes.analyze)
-        lock.should be_correct
-        lock.manifests.map{|m| m.name}.should include('butter')
-        manifest = lock.manifests.find{|m| m.name == 'butter'}
-        manifest.should_not be_nil
-        manifest.source.name.should == 'source-2'
-      end
-
-    end
-
-  end
-end