semantic_puppet 0.1.0

data/spec/unit/semantic_puppet/dependency/source_spec.rb

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

data/spec/unit/semantic_puppet/dependency/unsatisfiable_graph_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+require 'semantic_puppet/dependency/unsatisfiable_graph'
+
+describe SemanticPuppet::Dependency::UnsatisfiableGraph do
+
+  let(:modules) { %w[ foo bar baz ] }
+  let(:graph) { double('Graph', :modules => modules) }
+  let(:instance) { described_class.new(graph) }
+
+  subject { instance }
+
+  describe '#message' do
+    subject { instance.message }
+
+    it { should match /#{instance.send(:sentence_from_list, modules)}/ }
+  end
+
+  describe '#sentence_from_list' do
+
+    subject { instance.send(:sentence_from_list, modules) }
+
+    context 'with a list of one item' do
+      let(:modules) { %w[ foo ] }
+      it { should eql 'foo' }
+    end
+
+    context 'with a list of two items' do
+      let(:modules) { %w[ foo bar ] }
+      it { should eql 'foo and bar' }
+    end
+
+    context 'with a list of three items' do
+      let(:modules) { %w[ foo bar baz ] }
+      it { should eql 'foo, bar, and baz' }
+    end
+
+    context 'with a list of more than three items' do
+      let(:modules) { %w[ foo bar baz quux ] }
+      it { should eql 'foo, bar, baz, and quux' }
+    end
+
+  end
+
+end

data/spec/unit/semantic_puppet/dependency_spec.rb

@@ -0,0 +1,383 @@
+require 'spec_helper'
+require 'semantic_puppet/dependency'
+
+describe SemanticPuppet::Dependency do
+  def create_release(source, name, version, deps = {})
+    SemanticPuppet::Dependency::ModuleRelease.new(
+      source,
+      name,
+      SemanticPuppet::Version.parse(version),
+      Hash[deps.map { |k, v| [k, SemanticPuppet::VersionRange.parse(v) ] }]
+    )
+  end
+
+  describe '.sources' do
+    it 'defaults to an empty list' do
+      expect(subject.sources).to be_empty
+    end
+
+    it 'is frozen' do
+      expect(subject.sources).to be_frozen
+    end
+
+    it 'can be modified by using #add_source' do
+      subject.add_source(SemanticPuppet::Dependency::Source.new)
+      expect(subject.sources).to_not be_empty
+    end
+
+    it 'can be emptied by using #clear_sources' do
+      subject.add_source(SemanticPuppet::Dependency::Source.new)
+      subject.clear_sources
+      expect(subject.sources).to be_empty
+    end
+  end
+
+  describe '.query' do
+    context 'without sources' do
+      it 'returns an unsatisfied ModuleRelease' do
+        expect(subject.query('module_name' => '1.0.0')).to_not be_satisfied
+      end
+    end
+
+    context 'with one source' do
+      let(:source) { double('Source') }
+
+      before { SemanticPuppet::Dependency.add_source(source) }
+
+      it 'queries the source for release information' do
+        source.should_receive(:fetch).with('module_name').and_return([])
+
+        SemanticPuppet::Dependency.query('module_name' => '1.0.0')
+      end
+
+      it 'queries the source for each dependency' do
+        source.should_receive(:fetch).with('module_name').and_return([
+          create_release(source, 'module_name', '1.0.0', 'bar' => '1.0.0')
+        ])
+        source.should_receive(:fetch).with('bar').and_return([])
+
+        SemanticPuppet::Dependency.query('module_name' => '1.0.0')
+      end
+
+      it 'queries the source for each dependency only once' do
+        source.should_receive(:fetch).with('module_name').and_return([
+          create_release(
+            source,
+            'module_name',
+            '1.0.0',
+            'bar' => '1.0.0', 'baz' => '0.0.2'
+          )
+        ])
+        source.should_receive(:fetch).with('bar').and_return([
+          create_release(source, 'bar', '1.0.0', 'baz' => '0.0.3')
+        ])
+        source.should_receive(:fetch).with('baz').once.and_return([])
+
+        SemanticPuppet::Dependency.query('module_name' => '1.0.0')
+      end
+
+      it 'returns a ModuleRelease with the requested dependencies' do
+        source.stub(:fetch).and_return([])
+
+        result = SemanticPuppet::Dependency.query('foo' => '1.0.0', 'bar' => '1.0.0')
+        expect(result.dependency_names).to match_array %w[ foo bar ]
+      end
+
+      it 'populates the returned ModuleRelease with related dependencies' do
+        source.stub(:fetch).and_return(
+          [ foo = create_release(source, 'foo', '1.0.0', 'bar' => '1.0.0') ],
+          [ bar = create_release(source, 'bar', '1.0.0') ]
+        )
+
+        result = SemanticPuppet::Dependency.query('foo' => '1.0.0', 'bar' => '1.0.0')
+        expect(result.dependencies['foo']).to eql SortedSet.new([ foo ])
+        expect(result.dependencies['bar']).to eql SortedSet.new([ bar ])
+      end
+
+      it 'populates all returned ModuleReleases with related dependencies' do
+        source.stub(:fetch).and_return(
+          [ foo = create_release(source, 'foo', '1.0.0', 'bar' => '1.0.0') ],
+          [ bar = create_release(source, 'bar', '1.0.0', 'baz' => '0.1.0') ],
+          [ baz = create_release(source, 'baz', '0.1.0', 'baz' => '1.0.0') ]
+        )
+
+        result = SemanticPuppet::Dependency.query('foo' => '1.0.0')
+        expect(result.dependencies['foo']).to eql SortedSet.new([ foo ])
+        expect(foo.dependencies['bar']).to eql SortedSet.new([ bar ])
+        expect(bar.dependencies['baz']).to eql SortedSet.new([ baz ])
+      end
+    end
+
+    context 'with multiple sources' do
+      let(:source1) { double('SourceOne') }
+      let(:source2) { double('SourceTwo') }
+      let(:source3) { double('SourceThree') }
+
+      before do
+        SemanticPuppet::Dependency.add_source(source1)
+        SemanticPuppet::Dependency.add_source(source2)
+        SemanticPuppet::Dependency.add_source(source3)
+      end
+
+      it 'queries each source in turn' do
+        source1.should_receive(:fetch).with('module_name').and_return([])
+        source2.should_receive(:fetch).with('module_name').and_return([])
+        source3.should_receive(:fetch).with('module_name').and_return([])
+
+        SemanticPuppet::Dependency.query('module_name' => '1.0.0')
+      end
+
+      it 'resolves all dependencies against all sources' do
+        source1.should_receive(:fetch).with('module_name').and_return([
+          create_release(source1, 'module_name', '1.0.0', 'bar' => '1.0.0')
+        ])
+        source2.should_receive(:fetch).with('module_name').and_return([])
+        source3.should_receive(:fetch).with('module_name').and_return([])
+
+        source1.should_receive(:fetch).with('bar').and_return([])
+        source2.should_receive(:fetch).with('bar').and_return([])
+        source3.should_receive(:fetch).with('bar').and_return([])
+
+        SemanticPuppet::Dependency.query('module_name' => '1.0.0')
+      end
+    end
+  end
+
+  describe '.resolve' do
+    def add_source_modules(name, versions, deps = {})
+      versions = Array(versions)
+      releases = versions.map { |ver| create_release(source, name, ver, deps) }
+      source.stub(:fetch).with(name).and_return(modules[name].concat(releases))
+    end
+
+    def subject(specs)
+      graph = SemanticPuppet::Dependency.query(specs)
+      yield graph if block_given?
+      expect(graph.dependencies).to_not be_empty
+      result = SemanticPuppet::Dependency.resolve(graph)
+      expect(graph.dependencies).to_not be_empty
+      result.map { |rel| [ rel.name, rel.version.to_s ] }
+    end
+
+    let(:modules) { Hash.new { |h,k| h[k] = [] }}
+    let(:source) { double('Source', :priority => 0) }
+
+    before { SemanticPuppet::Dependency.add_source(source) }
+
+    context 'for a module without dependencies' do
+      def foo(range)
+        subject('foo' => range).map { |x| x.last }
+      end
+
+      it 'returns the greatest release matching the version range' do
+        add_source_modules('foo', %w[ 0.9.0 1.0.0 1.1.0 2.0.0 ])
+
+        expect(foo('1.x')).to eql %w[ 1.1.0 ]
+      end
+
+      context 'when the query includes both stable and prerelease versions' do
+        it 'returns the greatest stable release matching the range' do
+          add_source_modules('foo', %w[ 0.9.0 1.0.0 1.1.0 1.2.0-pre 2.0.0 ])
+
+          expect(foo('1.x')).to eql %w[ 1.1.0 ]
+        end
+      end
+
+      context 'when the query omits all stable versions' do
+        it 'returns the greatest prerelease version matching the range' do
+          add_source_modules('foo', %w[ 1.0.0 1.1.0-a 1.1.0-b 2.0.0 ])
+
+          expect(foo('1.1.x')).to   eql %w[ 1.1.0-b ]
+          expect(foo('1.1.0-a')).to eql %w[ 1.1.0-a ]
+        end
+      end
+
+      context 'when the query omits all versions' do
+        it 'fails with an appropriate message' do
+          add_source_modules('foo', %w[ 1.0.0 1.1.0-a 1.1.0 ])
+
+          with_message = /Could not find satisfying releases/
+          expect { foo('2.x') }.to raise_exception with_message
+          expect { foo('2.x') }.to raise_exception /\bfoo\b/
+        end
+      end
+    end
+
+    context 'for a module with dependencies' do
+      def foo(range)
+        subject('foo' => range)
+      end
+
+      it 'returns the greatest releases matching the dependency range' do
+        add_source_modules('foo', '1.1.0', 'bar' => '1.x')
+        add_source_modules('bar', %w[ 0.9.0 1.0.0 1.1.0 1.2.0 2.0.0 ])
+
+        expect(foo('1.1.0')).to include %w[ foo 1.1.0 ], %w[ bar 1.2.0 ]
+      end
+
+      context 'when the dependency has both stable and prerelease versions' do
+        it 'returns the greatest stable release matching the range' do
+          add_source_modules('foo', '1.1.0', 'bar' => '1.x')
+          add_source_modules('bar', %w[ 0.9.0 1.0.0 1.1.0 1.2.0-pre 2.0.0 ])
+
+          expect(foo('1.1.0')).to include %w[ foo 1.1.0 ], %w[ bar 1.1.0 ]
+        end
+      end
+
+      context 'when the dependency has no stable versions' do
+        it 'returns the greatest prerelease version matching the range' do
+          add_source_modules('foo', '1.1.0', 'bar' => '1.1.x')
+          add_source_modules('foo', '1.1.1', 'bar' => '1.1.0-a')
+          add_source_modules('bar', %w[ 1.0.0 1.1.0-a 1.1.0-b 2.0.0 ])
+
+          expect(foo('1.1.0')).to include %w[ foo 1.1.0 ], %w[ bar 1.1.0-b ]
+          expect(foo('1.1.1')).to include %w[ foo 1.1.1 ], %w[ bar 1.1.0-a ]
+        end
+      end
+
+      context 'when the dependency cannot be satisfied' do
+        it 'fails with an appropriate message' do
+          add_source_modules('foo', %w[ 1.1.0 ], 'bar' => '1.x')
+          add_source_modules('bar', %w[ 0.0.1 0.1.0-a 0.1.0 ])
+
+          with_message = /Could not find satisfying releases/
+          expect { foo('1.1.0') }.to raise_exception with_message
+          expect { foo('1.1.0') }.to raise_exception /\bfoo\b/
+        end
+      end
+    end
+
+    context 'for a module with competing dependencies' do
+      def foo(range)
+        subject('foo' => range)
+      end
+
+      context 'that overlap' do
+        it 'returns the greatest release satisfying all dependencies' do
+          add_source_modules('foo', '1.1.0', 'bar' => '1.0.0', 'baz' => '1.0.0')
+          add_source_modules('bar', '1.0.0', 'quxx' => '1.x')
+          add_source_modules('baz', '1.0.0', 'quxx' => '1.1.x')
+          add_source_modules('quxx', %w[ 0.9.0 1.0.0 1.1.0 1.1.1 1.2.0 2.0.0 ])
+
+          expect(foo('1.1.0')).to_not include %w[ quxx 1.2.0 ]
+          expect(foo('1.1.0')).to include %w[ quxx 1.1.1 ]
+        end
+      end
+
+      context 'that do not overlap' do
+        it 'fails with an appropriate message' do
+          add_source_modules('foo','1.1.0', 'bar' => '1.0.0', 'baz' => '1.0.0')
+          add_source_modules('bar','1.0.0', 'quxx' => '1.x')
+          add_source_modules('baz','1.0.0', 'quxx' => '2.x')
+          add_source_modules('quxx', %w[ 0.9.0 1.0.0 1.1.0 1.1.1 1.2.0 2.0.0 ])
+
+          with_message = /Could not find satisfying releases/
+          expect { foo('1.1.0') }.to raise_exception with_message
+          expect { foo('1.1.0') }.to raise_exception /\bfoo\b/
+        end
+      end
+    end
+
+    context 'for a module with circular dependencies' do
+      def foo(range)
+        subject('foo' => range)
+      end
+
+      context 'that can be resolved' do
+        it 'terminates' do
+          add_source_modules('foo', '1.1.0', 'foo' => '1.x')
+
+          expect(foo('1.1.0')).to include %w[ foo 1.1.0 ]
+        end
+      end
+
+      context 'that cannot be resolved' do
+        it 'fails with an appropriate message' do
+          add_source_modules('foo', '1.1.0', 'foo' => '1.0.0')
+
+          with_message = /Could not find satisfying releases/
+          expect { foo('1.1.0') }.to raise_exception with_message
+          expect { foo('1.1.0') }.to raise_exception /\bfoo\b/
+        end
+      end
+    end
+
+    context 'for a module with dependencies' do
+      context 'that violate module constraints on the graph' do
+        def foo(range)
+          subject('foo' => range) do |graph|
+            graph.add_constraint('no downgrade', 'bar', '> 3.0.0') do |node|
+              SemanticPuppet::VersionRange.parse('> 3.0.0') === node.version
+            end
+          end
+        end
+
+        context 'that can be resolved' do
+          it 'terminates' do
+            add_source_modules('foo', '1.1.0', 'bar' => '1.x')
+            add_source_modules('foo', '1.2.0', 'bar' => '>= 2.0.0')
+            add_source_modules('bar', '1.0.0')
+            add_source_modules('bar', '2.0.0', 'baz' => '>= 1.0.0')
+            add_source_modules('bar', '3.0.0')
+            add_source_modules('bar', '3.0.1')
+            add_source_modules('baz', '1.0.0')
+
+            expect(foo('1.x')).to include %w[ foo 1.2.0 ], %w[ bar 3.0.1 ]
+          end
+        end
+
+        context 'that cannot be resolved' do
+          it 'fails with an appropriate message' do
+            add_source_modules('foo', '1.1.0', 'bar' => '1.x')
+            add_source_modules('foo', '1.2.0', 'bar' => '2.x')
+            add_source_modules('bar', '1.0.0', 'baz' => '1.x')
+            add_source_modules('bar', '2.0.0', 'baz' => '1.x')
+            add_source_modules('baz', '1.0.0')
+            add_source_modules('baz', '3.0.0')
+            add_source_modules('baz', '3.0.1')
+
+            with_message = /Could not find satisfying releases/
+            expect { foo('1.x') }.to raise_exception with_message
+            expect { foo('1.x') }.to raise_exception /\bfoo\b/
+          end
+        end
+      end
+    end
+
+    context 'that violate graph constraints' do
+      def foo(range)
+        subject('foo' => range) do |graph|
+          graph.add_graph_constraint('uniqueness') do |nodes|
+            nodes.none? { |node| node.name =~ /z/ }
+          end
+        end
+      end
+
+      context 'that can be resolved' do
+        it 'terminates' do
+          add_source_modules('foo', '1.1.0', 'bar' => '1.x')
+          add_source_modules('foo', '1.2.0', 'bar' => '2.x')
+          add_source_modules('bar', '1.0.0')
+          add_source_modules('bar', '2.0.0', 'baz' => '1.0.0')
+          add_source_modules('baz', '1.0.0')
+
+          expect(foo('1.x')).to include %w[ foo 1.1.0 ], %w[ bar 1.0.0 ]
+        end
+      end
+
+      context 'that cannot be resolved' do
+        it 'fails with an appropriate message' do
+          add_source_modules('foo', '1.1.0', 'bar' => '1.x')
+          add_source_modules('foo', '1.2.0', 'bar' => '2.x')
+          add_source_modules('bar', '1.0.0', 'baz' => '1.0.0')
+          add_source_modules('bar', '2.0.0', 'baz' => '1.0.0')
+          add_source_modules('baz', '1.0.0')
+
+          with_message = /Could not find satisfying releases/
+          expect { foo('1.1.0') }.to raise_exception with_message
+          expect { foo('1.1.0') }.to raise_exception /\bfoo\b/
+        end
+      end
+    end
+  end
+end

data/spec/unit/semantic_puppet/version_range_spec.rb

@@ -0,0 +1,307 @@
+require 'spec_helper'
+require 'semantic_puppet/version'
+
+describe SemanticPuppet::VersionRange do
+
+  describe '.parse' do
+    def self.test_range(range_list, str, includes, excludes)
+      Array(range_list).each do |expr|
+        example "#{expr.inspect} stringifies as #{str}" do
+          range = SemanticPuppet::VersionRange.parse(expr)
+          expect(range.to_s).to eql str
+        end
+
+        includes.each do |vstring|
+          example "#{expr.inspect} includes #{vstring}" do
+            range = SemanticPuppet::VersionRange.parse(expr)
+            expect(range).to include(SemanticPuppet::Version.parse(vstring))
+          end
+
+          example "parse(#{expr.inspect}).to_s includes #{vstring}" do
+            range = SemanticPuppet::VersionRange.parse(expr)
+            range = SemanticPuppet::VersionRange.parse(range.to_s)
+            expect(range).to include(SemanticPuppet::Version.parse(vstring))
+          end
+        end
+
+        excludes.each do |vstring|
+          example "#{expr.inspect} excludes #{vstring}" do
+            range = SemanticPuppet::VersionRange.parse(expr)
+            expect(range).to_not include(SemanticPuppet::Version.parse(vstring))
+          end
+
+          example "parse(#{expr.inspect}).to_s excludes #{vstring}" do
+            range = SemanticPuppet::VersionRange.parse(expr)
+            range = SemanticPuppet::VersionRange.parse(range.to_s)
+            expect(range).to_not include(SemanticPuppet::Version.parse(vstring))
+          end
+        end
+      end
+    end
+
+    context 'loose version expressions' do
+      expressions = {
+        [ '1.2.3-alpha' ] => {
+          :to_str   => '1.2.3-alpha',
+          :includes => [ '1.2.3-alpha'  ],
+          :excludes => [ '1.2.3-999', '1.2.3-beta' ],
+        },
+        [ '1.2.3' ] => {
+          :to_str   => '1.2.3',
+          :includes => [ '1.2.3-alpha', '1.2.3' ],
+          :excludes => [ '1.2.2', '1.2.4-alpha' ],
+        },
+        [ '1.2', '1.2.x', '1.2.X' ] => {
+          :to_str   => '1.2.x',
+          :includes => [ '1.2.0-alpha', '1.2.0', '1.2.999' ],
+          :excludes => [ '1.1.999', '1.3.0-0' ],
+        },
+        [ '1', '1.x', '1.X' ] => {
+          :to_str   => '1.x',
+          :includes => [ '1.0.0-alpha', '1.999.0' ],
+          :excludes => [ '0.999.999', '2.0.0-0' ],
+        },
+      }
+
+      expressions.each do |range, vs|
+        test_range(range, vs[:to_str], vs[:includes], vs[:excludes])
+      end
+    end
+
+    context 'open-ended expressions' do
+      expressions = {
+        [ '>1.2.3', '> 1.2.3' ] => {
+          :to_str   => '>=1.2.4',
+          :includes => [ '1.2.4-0', '999.0.0' ],
+          :excludes => [ '1.2.3' ],
+        },
+        [ '>1.2.3-alpha', '> 1.2.3-alpha' ] => {
+          :to_str   => '>1.2.3-alpha',
+          :includes => [ '1.2.3-alpha.0', '1.2.3-alpha0', '999.0.0' ],
+          :excludes => [ '1.2.3-alpha' ],
+        },
+
+        [ '>=1.2.3', '>= 1.2.3' ] => {
+          :to_str   => '>=1.2.3',
+          :includes => [ '1.2.3-0', '999.0.0' ],
+          :excludes => [ '1.2.2' ],
+        },
+        [ '>=1.2.3-alpha', '>= 1.2.3-alpha' ] => {
+          :to_str   => '>=1.2.3-alpha',
+          :includes => [ '1.2.3-alpha', '1.2.3-alpha0', '999.0.0' ],
+          :excludes => [ '1.2.3-alph' ],
+        },
+
+        [ '<1.2.3', '< 1.2.3' ] => {
+          :to_str   => '<1.2.3',
+          :includes => [ '0.0.0-0', '1.2.2' ],
+          :excludes => [ '1.2.3-0', '2.0.0' ],
+        },
+        [ '<1.2.3-alpha', '< 1.2.3-alpha' ] => {
+          :to_str   => '<1.2.3-alpha',
+          :includes => [ '0.0.0-0', '1.2.3-alph' ],
+          :excludes => [ '1.2.3-alpha', '2.0.0' ],
+        },
+
+        [ '<=1.2.3', '<= 1.2.3' ] => {
+          :to_str   => '<1.2.4',
+          :includes => [ '0.0.0-0', '1.2.3' ],
+          :excludes => [ '1.2.4-0' ],
+        },
+        [ '<=1.2.3-alpha', '<= 1.2.3-alpha' ] => {
+          :to_str   => '<=1.2.3-alpha',
+          :includes => [ '0.0.0-0', '1.2.3-alpha' ],
+          :excludes => [ '1.2.3-alpha0', '1.2.3-alpha.0', '1.2.3-alpha'.next ],
+        },
+      }
+
+      expressions.each do |range, vs|
+        test_range(range, vs[:to_str], vs[:includes], vs[:excludes])
+      end
+    end
+
+    context '"reasonably close" expressions' do
+      expressions = {
+        [ '~ 1', '~1' ] => {
+          :to_str   => '1.x',
+          :includes => [ '1.0.0-0', '1.999.999' ],
+          :excludes => [ '0.999.999', '2.0.0-0' ],
+        },
+        [ '~ 1.2', '~1.2' ] => {
+          :to_str   => '1.2.x',
+          :includes => [ '1.2.0-0', '1.2.999' ],
+          :excludes => [ '1.1.999', '1.3.0-0' ],
+        },
+        [ '~ 1.2.3', '~1.2.3' ] => {
+          :to_str   => '>=1.2.3 <1.3.0',
+          :includes => [ '1.2.3-0', '1.2.5' ],
+          :excludes => [ '1.2.2', '1.3.0-0' ],
+        },
+        [ '~ 1.2.3-alpha', '~1.2.3-alpha' ] => {
+          :to_str   => '>=1.2.3-alpha <1.2.4',
+          :includes => [ '1.2.3-alpha', '1.2.3' ],
+          :excludes => [ '1.2.3-alph', '1.2.4-0' ],
+        },
+      }
+
+      expressions.each do |range, vs|
+        test_range(range, vs[:to_str], vs[:includes], vs[:excludes])
+      end
+    end
+
+    context 'inclusive range expressions' do
+      expressions = {
+        '1.2.3 - 1.3.4' => {
+          :to_str   => '>=1.2.3 <1.3.5',
+          :includes => [ '1.2.3-0', '1.3.4' ],
+          :excludes => [ '1.2.2', '1.3.5-0' ],
+        },
+        '1.2.3 - 1.3.4-alpha' => {
+          :to_str   => '>=1.2.3 <=1.3.4-alpha',
+          :includes => [ '1.2.3-0', '1.3.4-alpha' ],
+          :excludes => [ '1.2.2', '1.3.4-alpha0', '1.3.5' ],
+        },
+
+        '1.2.3-alpha - 1.3.4' => {
+          :to_str   => '>=1.2.3-alpha <1.3.5',
+          :includes => [ '1.2.3-alpha', '1.3.4' ],
+          :excludes => [ '1.2.3-alph', '1.3.5-0' ],
+        },
+        '1.2.3-alpha - 1.3.4-alpha' => {
+          :to_str   => '>=1.2.3-alpha <=1.3.4-alpha',
+          :includes => [ '1.2.3-alpha', '1.3.4-alpha' ],
+          :excludes => [ '1.2.3-alph', '1.3.4-alpha0', '1.3.5' ],
+        },
+      }
+
+      expressions.each do |range, vs|
+        test_range(range, vs[:to_str], vs[:includes], vs[:excludes])
+      end
+    end
+
+    context 'unioned expressions' do
+      expressions = {
+        [ '1.2 <1.2.5' ] => {
+          :to_str   => '>=1.2.0 <1.2.5',
+          :includes => [ '1.2.0-0', '1.2.4' ],
+          :excludes => [ '1.1.999', '1.2.5-0', '1.9.0' ],
+        },
+        [ '1 <=1.2.5' ] => {
+          :to_str   => '>=1.0.0 <1.2.6',
+          :includes => [ '1.0.0-0', '1.2.5' ],
+          :excludes => [ '0.999.999', '1.2.6-0', '1.9.0' ],
+        },
+        [ '>1.0.0 >2.0.0 >=3.0.0 <5.0.0' ] => {
+          :to_str   => '>=3.0.0 <5.0.0',
+          :includes => [ '3.0.0-0', '4.999.999' ],
+          :excludes => [ '2.999.999', '5.0.0-0' ],
+        },
+        [ '<1.0.0 >2.0.0' ] => {
+          :to_str   => '<0.0.0',
+          :includes => [  ],
+          :excludes => [ '0.0.0-0' ],
+        },
+      }
+
+      expressions.each do |range, vs|
+        test_range(range, vs[:to_str], vs[:includes], vs[:excludes])
+      end
+    end
+
+    context 'invalid expressions' do
+      example 'raise an appropriate exception' do
+        ex = [ ArgumentError, 'Unparsable version range: "invalid"' ]
+        expect { SemanticPuppet::VersionRange.parse('invalid') }.to raise_error(*ex)
+      end
+    end
+  end
+
+  describe '#intersection' do
+    def self.v(num)
+      SemanticPuppet::Version.parse("#{num}.0.0")
+    end
+
+    def self.range(x, y, ex = false)
+      SemanticPuppet::VersionRange.new(v(x), v(y), ex)
+    end
+
+    EMPTY_RANGE = SemanticPuppet::VersionRange::EMPTY_RANGE
+
+    tests = {
+      # This falls entirely before the target range
+      range(1, 4) => [ EMPTY_RANGE ],
+
+      # This falls entirely after the target range
+      range(11, 15) => [ EMPTY_RANGE ],
+
+      # This overlaps the beginning of the target range
+      range(1, 6) => [ range(5, 6) ],
+
+      # This overlaps the end of the target range
+      range(9, 15) => [ range(9, 10), range(9, 10, true) ],
+
+      # This shares the first value of the target range
+      range(1, 5) => [ range(5, 5) ],
+
+      # This shares the last value of the target range
+      range(10, 15)  => [ range(10, 10), EMPTY_RANGE ],
+
+      # This shares both values with the target range
+      range(5, 10) => [ range(5, 10), range(5, 10, true) ],
+
+      # This is a superset of the target range
+      range(4, 11) => [ range(5, 10), range(5, 10, true) ],
+
+      # This is a subset of the target range
+      range(6, 9) => [ range(6, 9) ],
+
+      # This shares the first value of the target range, but excludes it
+      range(1, 5, true)   => [ EMPTY_RANGE ],
+
+      # This overlaps the beginning of the target range, with an excluded end
+      range(1, 7, true)   => [ range(5, 7, true) ],
+
+      # This shares both values with the target range, and excludes the end
+      range(5, 10, true)  => [ range(5, 10, true) ],
+    }
+
+    inclusive = range(5, 10)
+    context "between #{inclusive} &" do
+      tests.each do |subject, result|
+        result = result.first
+
+        example subject do
+          expect(inclusive & subject).to eql(result)
+        end
+      end
+    end
+
+    exclusive = range(5, 10, true)
+    context "between #{exclusive} &" do
+      tests.each do |subject, result|
+        result = result.last
+
+        example subject do
+          expect(exclusive & subject).to eql(result)
+        end
+      end
+    end
+
+    context 'is commutative' do
+      tests.each do |subject, _|
+        example "between #{inclusive} & #{subject}" do
+          expect(inclusive & subject).to eql(subject & inclusive)
+        end
+        example "between #{exclusive} & #{subject}" do
+          expect(exclusive & subject).to eql(subject & exclusive)
+        end
+      end
+    end
+
+    it 'cannot intersect with non-VersionRanges' do
+      msg = "value must be a SemanticPuppet::VersionRange"
+      expect { inclusive.intersection(1..2) }.to raise_error(msg)
+    end
+  end
+
+end