puppet 4.8.2-x64-mingw32 → 4.9.0-x64-mingw32

data/lib/puppet/vendor/semantic/spec/unit/semantic/dependency/graph_node_spec.rb

@@ -1,141 +0,0 @@
-require 'spec_helper'
-require 'semantic/dependency/graph_node'
-
-describe Semantic::Dependency::GraphNode do
-  let(:klass) do
-    Class.new do
-      include Semantic::Dependency::GraphNode
-
-      attr_accessor :name
-
-      def initialize(name, *satisfying)
-        @name = name
-        @satisfying = satisfying
-        @satisfying.each { |x| add_dependency(x.name) }
-      end
-
-      # @override
-      def satisfies_dependency?(node)
-        @satisfying.include?(node)
-      end
-    end
-  end
-
-  def instance(*args)
-    name = args.first.name unless args.empty?
-    klass.new(name || 'unnamed', *args)
-  end
-
-  context 'dependencies' do
-    subject { instance() }
-
-    example 'are added by #add_dependency' do
-      subject.add_dependency('foo')
-      subject.add_dependency('bar')
-      subject.add_dependency('baz')
-      expect(subject.dependency_names).to match_array %w[ foo bar baz ]
-    end
-
-    example 'are maintained in the #dependencies Hash' do
-      expect(subject.dependencies).to be_empty
-      subject.add_dependency('foo')
-      expect(subject.dependencies).to have_key 'foo'
-      expect(subject.dependencies).to respond_to :to_a
-    end
-  end
-
-  describe '#<<' do
-    let(:foo) { double('Node', :name => 'foo') }
-    let(:bar1) { double('Node', :name => 'bar', :'<=>' => 0) }
-    let(:bar2) { double('Node', :name => 'bar', :'<=>' => 0) }
-    let(:bar3) { double('Node', :name => 'bar') }
-    let(:baz) { double('Node', :name => 'baz') }
-
-    subject { instance(foo, bar1, bar2) }
-
-    it 'appends satisfying nodes to the dependencies' do
-      subject << foo << bar1 << bar2
-      expect(Array(subject.dependencies['foo'])).to match_array [ foo ]
-      expect(Array(subject.dependencies['bar'])).to match_array [ bar1, bar2 ]
-    end
-
-    it 'does not append nodes with unknown names' do
-      subject << baz
-      expect(Array(subject.dependencies['baz'])).to be_empty
-    end
-
-    it 'does not append unsatisfying nodes' do
-      subject << bar3
-      expect(Array(subject.dependencies['bar'])).to be_empty
-    end
-  end
-
-  describe '#satisfied' do
-    let(:foo) { double('Node', :name => 'foo') }
-    let(:bar) { double('Node', :name => 'bar') }
-
-    subject { instance(foo, bar) }
-
-    it 'is unsatisfied when no nodes have been appended' do
-      expect(subject).to_not be_satisfied
-    end
-
-    it 'is unsatisfied when any dependencies are missing' do
-      subject << foo
-      expect(subject).to_not be_satisfied
-    end
-
-    it 'is satisfied when all dependencies are fulfilled' do
-      subject << foo << bar
-      expect(subject).to be_satisfied
-    end
-  end
-
-  describe '#populate_children' do
-    let(:foo) { double('Node', :name => 'foo') }
-    let(:bar1) { double('Node', :name => 'bar', :'<=>' => 0) }
-    let(:bar2) { double('Node', :name => 'bar', :'<=>' => 0) }
-    let(:baz1) { double('Node', :name => 'baz', :'<=>' => 0) }
-    let(:baz2) { double('Node', :name => 'baz', :'<=>' => 0) }
-    let(:quxx) { double('Node', :name => 'quxx') }
-
-    subject do
-      graph = instance(foo, bar1, bar2, baz1, baz2)
-      graph << foo << bar1 << bar2 << baz1 << baz2
-    end
-
-    it 'saves all relevant nodes as its children' do
-      nodes = [ foo, bar2, baz1, quxx ]
-      nodes.each do |node|
-        allow(node).to receive(:populate_children)
-      end
-
-      subject.populate_children(nodes)
-
-      expected = { 'foo' => foo, 'bar' => bar2, 'baz' => baz1 }
-      expect(subject.children).to eql expected
-    end
-
-    it 'accepts a graph solution and populates it across all nodes' do
-      nodes = [ foo, bar2, baz1 ]
-      nodes.each do |node|
-        expect(node).to receive(:populate_children).with(nodes)
-      end
-
-      subject.populate_children(nodes)
-    end
-  end
-
-  describe '#<=>' do
-    it 'can be compared' do
-      a = instance(double('Node', :name => 'a'))
-      b = instance(double('Node', :name => 'b'))
-
-      expect(a).to be < b
-      expect(b).to be > a
-      expect([b, a].sort).to eql [a, b]
-      expect([a, b].sort).to eql [a, b]
-    end
-  end
-
-end

data/lib/puppet/vendor/semantic/spec/unit/semantic/dependency/graph_spec.rb

@@ -1,162 +0,0 @@
-require 'spec_helper'
-require 'semantic/dependency/graph'
-
-describe Semantic::Dependency::Graph do
-  Graph         = Semantic::Dependency::Graph
-  GraphNode     = Semantic::Dependency::GraphNode
-  ModuleRelease = Semantic::Dependency::ModuleRelease
-  Version       = Semantic::Version
-  VersionRange  = Semantic::VersionRange
-
-  describe '#initialize' do
-    it 'can be called without arguments' do
-      expect { Graph.new }.to_not raise_error
-    end
-
-    it 'implements the GraphNode protocol' do
-      expect(Graph.new).to be_a GraphNode
-    end
-
-    it 'adds constraints for every key in the passed hash' do
-      graph = Graph.new('foo' => 1, 'bar' => 2, 'baz' => 3)
-      expect(graph.constraints.keys).to match_array %w[ foo bar baz ]
-    end
-
-    it 'adds the named dependencies for every key in the passed hash' do
-      graph = Graph.new('foo' => 1, 'bar' => 2, 'baz' => 3)
-      expect(graph.dependency_names).to match_array %w[ foo bar baz ]
-    end
-  end
-
-  describe '#add_constraint' do
-    let(:graph) { Graph.new }
-
-    it 'can create a new constraint on a module' do
-      expect(graph.constraints.keys).to be_empty
-
-      graph.add_constraint('test', 'module-name', 'nil') { }
-      expect(graph.constraints.keys).to match_array %w[ module-name ]
-    end
-
-    it 'permits multiple constraints against the same module name' do
-      expect(graph.constraints.keys).to be_empty
-
-      graph.add_constraint('test', 'module-name', 'nil') { }
-      graph.add_constraint('test', 'module-name', 'nil') { }
-
-      expect(graph.constraints.keys).to match_array %w[ module-name ]
-    end
-  end
-
-  describe '#satisfies_dependency?' do
-    it 'is not satisfied by modules it does not depend on' do
-      graph = Graph.new('foo' => VersionRange.parse('1.x'))
-      release = ModuleRelease.new(nil, 'bar', Version.parse('1.0.0'))
-
-      expect(graph.satisfies_dependency?(release)).to_not be true
-    end
-
-    it 'is not satisfied by modules that do not fulfill the constraint' do
-      graph = Graph.new('foo' => VersionRange.parse('1.x'))
-      release = ModuleRelease.new(nil, 'foo', Version.parse('2.3.1'))
-
-      expect(graph.satisfies_dependency?(release)).to_not be true
-    end
-
-    it 'is not satisfied by modules that do not fulfill all the constraints' do
-      graph = Graph.new('foo' => VersionRange.parse('1.x'))
-      graph.add_constraint('me', 'foo', '1.2.3') do |node|
-        node.version.to_s == '1.2.3'
-      end
-
-      release = ModuleRelease.new(nil, 'foo', Version.parse('1.2.1'))
-
-      expect(graph.satisfies_dependency?(release)).to_not be true
-    end
-
-    it 'is satisfied by modules that do fulfill all the constraints' do
-      graph = Graph.new('foo' => VersionRange.parse('1.x'))
-      graph.add_constraint('me', 'foo', '1.2.3') do |node|
-        node.version.to_s == '1.2.3'
-      end
-
-      release = ModuleRelease.new(nil, 'foo', Version.parse('1.2.3'))
-
-      expect(graph.satisfies_dependency?(release)).to be true
-    end
-  end
-
-  describe '#add_graph_constraint' do
-    let(:graph) { Graph.new }
-
-    it 'can create a new constraint on a graph' do
-      expect(graph.constraints.keys).to be_empty
-
-      graph.add_graph_constraint('test') { }
-      expect(graph.constraints.keys).to match_array [ :graph ]
-    end
-
-    it 'permits multiple graph constraints' do
-      expect(graph.constraints.keys).to be_empty
-
-      graph.add_graph_constraint('test') { }
-      graph.add_graph_constraint('test') { }
-
-      expect(graph.constraints.keys).to match_array [ :graph ]
-    end
-  end
-
-  describe '#satisfies_graph?' do
-    it 'returns false if the solution violates a graph constraint' do
-      graph = Graph.new
-      graph.add_graph_constraint('me') do |nodes|
-        nodes.none? { |node| node.name =~ /z/ }
-      end
-
-      releases = [
-        double('Node', :name => 'foo'),
-        double('Node', :name => 'bar'),
-        double('Node', :name => 'baz'),
-      ]
-
-      expect(graph.satisfies_graph?(releases)).to_not be true
-    end
-
-    it 'returns false if the solution violates any graph constraint' do
-      graph = Graph.new
-      graph.add_graph_constraint('me') do |nodes|
-        nodes.all? { |node| node.name.length < 5 }
-      end
-      graph.add_graph_constraint('me') do |nodes|
-        nodes.none? { |node| node.name =~ /z/ }
-      end
-
-      releases = [
-        double('Node', :name => 'foo'),
-        double('Node', :name => 'bar'),
-        double('Node', :name => 'bangerang'),
-      ]
-
-      expect(graph.satisfies_graph?(releases)).to_not be true
-    end
-
-    it 'returns true if the solution violates no graph constraints' do
-      graph = Graph.new
-      graph.add_graph_constraint('me') do |nodes|
-        nodes.all? { |node| node.name.length < 5 }
-      end
-      graph.add_graph_constraint('me') do |nodes|
-        nodes.none? { |node| node.name =~ /z/ }
-      end
-
-      releases = [
-        double('Node', :name => 'foo'),
-        double('Node', :name => 'bar'),
-        double('Node', :name => 'boom'),
-      ]
-
-      expect(graph.satisfies_graph?(releases)).to be true
-    end
-  end
-
-end

data/lib/puppet/vendor/semantic/spec/unit/semantic/dependency/module_release_spec.rb

@@ -1,143 +0,0 @@
-require 'spec_helper'
-require 'semantic/dependency/module_release'
-
-describe Semantic::Dependency::ModuleRelease do
-  def source
-    @source ||= Semantic::Dependency::Source.new
-  end
-
-  def make_release(name, version, deps = {})
-    source.create_release(name, version, deps)
-  end
-
-  let(:no_dependencies) do
-    make_release('module', '1.2.3')
-  end
-
-  let(:one_dependency) do
-    make_release('module', '1.2.3', 'foo' => '1.0.0')
-  end
-
-  let(:three_dependencies) do
-    dependencies = { 'foo' => '1.0.0', 'bar' => '2.0.0', 'baz' => '3.0.0' }
-    make_release('module', '1.2.3', dependencies)
-  end
-
-  describe '#dependency_names' do
-
-    it "lists the names of all the release's dependencies" do
-      expect(no_dependencies.dependency_names).to    match_array %w[]
-      expect(one_dependency.dependency_names).to     match_array %w[foo]
-      expect(three_dependencies.dependency_names).to match_array %w[foo bar baz]
-    end
-
-  end
-
-  describe '#to_s' do
-
-    let(:name) { 'foobarbaz' }
-    let(:version) { '1.2.3' }
-
-    subject { make_release(name, version).to_s }
-
-    it { should =~ /#{name}/ }
-    it { should =~ /#{version}/ }
-
-  end
-
-  describe '#<<' do
-
-    it 'marks matching dependencies as satisfied' do
-      one_dependency << make_release('foo', '1.0.0')
-      expect(one_dependency).to be_satisfied
-    end
-
-    it 'does not mark mis-matching dependency names as satisfied' do
-      one_dependency << make_release('WAT', '1.0.0')
-      expect(one_dependency).to_not be_satisfied
-    end
-
-    it 'does not mark mis-matching dependency versions as satisfied' do
-      one_dependency << make_release('foo', '0.0.1')
-      expect(one_dependency).to_not be_satisfied
-    end
-
-  end
-
-  describe '#<=>' do
-
-    it 'considers releases with greater version numbers greater' do
-      expect(make_release('foo', '1.0.0')).to be > make_release('foo', '0.1.0')
-    end
-
-    it 'considers releases with lesser version numbers lesser' do
-      expect(make_release('foo', '0.1.0')).to be < make_release('foo', '1.0.0')
-    end
-
-    it 'orders releases with different names lexographically' do
-      expect(make_release('bar', '1.0.0')).to be < make_release('foo', '1.0.0')
-    end
-
-    it 'orders releases by name first' do
-      expect(make_release('bar', '2.0.0')).to be < make_release('foo', '1.0.0')
-    end
-
-  end
-
-  describe '#satisfied?' do
-
-    it 'returns true when there are no dependencies to satisfy' do
-      expect(no_dependencies).to be_satisfied
-    end
-
-    it 'returns false when no dependencies have been satisified' do
-      expect(one_dependency).to_not be_satisfied
-    end
-
-    it 'returns false when not all dependencies have been satisified' do
-      releases = %w[ 0.9.0 1.0.0 1.0.1 ].map { |ver| make_release('foo', ver) }
-      three_dependencies << releases
-
-      expect(three_dependencies).to_not be_satisfied
-    end
-
-    it 'returns false when not all dependency versions have been satisified' do
-      releases = %w[ 0.9.0 1.0.1 ].map { |ver| make_release('foo', ver) }
-      one_dependency << releases
-
-      expect(one_dependency).to_not be_satisfied
-    end
-
-    it 'returns true when all dependencies have been satisified' do
-      releases = %w[ 0.9.0 1.0.0 1.0.1 ].map { |ver| make_release('foo', ver) }
-      one_dependency << releases
-
-      expect(one_dependency).to be_satisfied
-    end
-
-  end
-
-  describe '#satisfies_dependency?' do
-
-    it 'returns false when there are no dependencies to satisfy' do
-      release = make_release('foo', '1.0.0')
-      expect(no_dependencies.satisfies_dependency?(release)).to_not be true
-    end
-
-    it 'returns false when the release does not match the dependency name' do
-      release = make_release('bar', '1.0.0')
-      expect(one_dependency.satisfies_dependency?(release)).to_not be true
-    end
-
-    it 'returns false when the release does not match the dependency version' do
-      release = make_release('foo', '4.0.0')
-      expect(one_dependency.satisfies_dependency?(release)).to_not be true
-    end
-
-    it 'returns true when the release matches the dependency' do
-      release = make_release('foo', '1.0.0')
-      expect(one_dependency.satisfies_dependency?(release)).to be true
-    end
-
-  end
-end

data/lib/puppet/vendor/semantic/spec/unit/semantic/dependency/source_spec.rb

@@ -1,5 +0,0 @@
-require 'spec_helper'
-require 'semantic/dependency/source'
-
-describe Semantic::Dependency::Source do
-end