doubleshot 0.2.0-java → 0.3.0-java

data/test/resolver/gem_resolver/demand_spec.rb

@@ -0,0 +1,70 @@
+#!/usr/bin/env jruby
+
+# encoding: utf-8
+
+require_relative "../../helper"
+
+describe Doubleshot::Resolver::GemResolver::Demand do
+  before do
+    @solver = MiniTest::Mock.new
+  end
+
+  describe "ClassMethods" do
+    describe "::new" do
+      it "accepts a string for the constraint parameter" do
+        Doubleshot::Resolver::GemResolver::Demand.new(@solver, "listen", "= 0.0.1")
+          .constraint.to_s.must_equal "= 0.0.1"
+      end
+
+      it "accepts a Gem::Requirement for the constraint parameter" do
+        constraint = Gem::Requirement.new("= 0.0.1")
+
+        Doubleshot::Resolver::GemResolver::Demand.new(@solver, "listen", constraint)
+          .constraint.must_equal constraint
+      end
+
+      describe "when no value for 'constraint' is given" do
+        it "uses a default of >= 0" do
+          Doubleshot::Resolver::GemResolver::Demand.new(@solver, "listen")
+            .constraint.to_s.must_equal ">= 0"
+        end
+      end
+    end
+  end
+
+  describe "#delete" do
+    describe "given the demand is not the member of a solver" do
+      it "returns nil" do
+        Doubleshot::Resolver::GemResolver::Demand.new(nil, "listen", "~> 1.0.0")
+          .delete.must_be_nil
+      end
+    end
+  end
+
+  describe "equality" do
+    before do
+      @demand = Doubleshot::Resolver::GemResolver::Demand.new(@solver, "listen", "1.0")
+    end
+
+    it "returns true when other is a Doubleshot::Resolver::GemResolver::Demand with the same name and constriant" do
+      other_demand = Doubleshot::Resolver::GemResolver::Demand.new(@solver, "listen", "1.0")
+      @demand.must_equal other_demand
+    end
+
+    it "returns false when other isn't a Solve::Demand" do
+      @demand.wont_equal "chicken"
+    end
+
+    it "returns false when other is a Solve::Demand with the same name but a different constraint" do
+      other_demand = Doubleshot::Resolver::GemResolver::Demand.new(@solver, "listen", "< 3.4.5")
+
+      @demand.wont_equal other_demand
+    end
+
+    it "returns false when other is a Solve::Demand with the same constraint but a different name" do
+      other_demand = Doubleshot::Resolver::GemResolver::Demand.new(@solver, "chicken", "1.0")
+
+      @demand.wont_equal other_demand
+    end
+  end
+end

data/test/resolver/gem_resolver/dependency_spec.rb

@@ -0,0 +1,33 @@
+#!/usr/bin/env jruby
+
+# encoding: utf-8
+
+require_relative "../../helper"
+
+describe Doubleshot::Resolver::GemResolver::Dependency do
+  before do
+    @dependency = Doubleshot::Resolver::GemResolver::Dependency.new(
+            Doubleshot::Resolver::GemResolver::Artifact.new(nil, "something_using_ntp", "1.0"),
+            "ntp")
+  end
+
+  describe "ClassMethods" do
+    describe "::new" do
+      describe "when no value for 'constraint' is given" do
+        it "uses a default of >= 0" do
+          @dependency.constraint.to_s.must_equal ">= 0"
+        end
+      end
+    end
+  end
+
+  describe "#eql?" do
+    it "returns true if the other object is an instance of Solve::Dependency with the same constraint and artifact" do
+      other = Doubleshot::Resolver::GemResolver::Dependency.new(
+                Doubleshot::Resolver::GemResolver::Artifact.new(nil, "something_using_ntp", "1.0"),
+                "ntp")
+
+      @dependency.must_equal other
+    end
+  end
+end

data/test/resolver/gem_resolver/gem_source_spec.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/env jruby
+
+# encoding: utf-8
+
+require_relative "../../helper"
+
+describe Doubleshot::Resolver::GemResolver::Source do
+
+  before do
+    @source = Doubleshot::Resolver::GemResolver::Source.new Doubleshot::Resolver::GemResolver::DEFAULT_REPOSITORY
+  end
+
+  describe "versions" do
+    it "must return a list of available versions for a gem name" do
+      versions = @source.versions("rack")
+      versions.size.must_be :>, 10
+      versions.must_include Gem::Version.new "1.2.0"
+    end
+  end
+
+  describe "spec" do
+    it "must return a gemspec for a given gem name and version" do
+      gemspec = @source.spec "rack", "1.2.0"
+      gemspec.name.must_equal "rack"
+      gemspec.version.to_s.must_equal "1.2.0"
+    end
+  end
+end

data/test/resolver/gem_resolver/graph_spec.rb

@@ -0,0 +1,239 @@
+#!/usr/bin/env jruby
+
+# encoding: utf-8
+
+require_relative "../../helper"
+
+describe Doubleshot::Resolver::GemResolver::Graph do
+  before do
+    @graph = Doubleshot::Resolver::GemResolver::Graph.new
+  end
+
+  describe "ClassMethods" do
+    describe "::artifact_key" do
+      it "returns a symbol containing the name and version of the artifact" do
+        Doubleshot::Resolver::GemResolver::Graph::artifact_key("nginx", "1.2.3").must_equal :'nginx-1.2.3'
+      end
+    end
+
+    describe "::dependency_key" do
+      it "returns a symbol containing the name and constraint of the dependency" do
+        Doubleshot::Resolver::GemResolver::Graph::dependency_key("ntp", "= 2.3.4").must_equal :'ntp-= 2.3.4'
+      end
+    end
+  end
+
+  describe "#artifacts" do
+    describe "given a name and version argument" do
+      before do
+        @name = "nginx"
+        @version = "0.101.5"
+      end
+
+      describe "given the artifact of the given name and version does not exist" do
+        it "returns a Doubleshot::Resolver::GemResolver::Artifact" do
+          @graph.artifacts(@name, @version).must_be_kind_of Doubleshot::Resolver::GemResolver::Artifact
+        end
+
+        it "the artifact has the given name" do
+          @graph.artifacts(@name, @version).name.must_equal @name
+        end
+
+        it "the artifact has the given version" do
+          @graph.artifacts(@name, @version).version.to_s.must_equal @version
+        end
+
+        it "adds an artifact to the artifacts collection" do
+          @graph.artifacts(@name, @version)
+
+          @graph.artifacts.size.must_equal 1
+        end
+
+        it "the artifact added matches the given name" do
+          @graph.artifacts(@name, @version)
+
+          @graph.artifacts[0].name.must_equal @name
+        end
+
+        it "the artifact added matches the given version" do
+          @graph.artifacts(@name, @version)
+
+          @graph.artifacts[0].version.to_s.must_equal @version
+        end
+      end
+    end
+
+    describe "given no arguments" do
+      it "returns an array" do
+        @graph.artifacts.must_be_kind_of Array
+      end
+
+      it "returns an empty array if no artifacts have been accessed" do
+        @graph.artifacts.size.must_equal 0
+      end
+
+      it "returns an array containing an artifact if one was accessed" do
+        @graph.artifacts("nginx", "0.101.5")
+
+        @graph.artifacts.size.must_equal 1
+      end
+    end
+
+    describe "given an unexpected number of arguments" do
+      it "raises an ArgumentError if more than two are provided" do
+        -> { @graph.artifacts(1, 2, 3) }.must_raise ArgumentError, "Unexpected number of arguments. You gave: 3. Expected: 0 or 2."
+      end
+
+      it "raises an ArgumentError if one argument is provided" do
+        -> { @graph.artifacts(nil) }.must_raise ArgumentError, "Unexpected number of arguments. You gave: 1. Expected: 0 or 2."
+      end
+
+      it "raises an ArgumentError if one of the arguments provided is nil" do
+        -> { @graph.artifacts("nginx", nil) }.must_raise ArgumentError, 'A name and version must be specified. You gave: ["nginx", nil].'
+      end
+    end
+  end
+
+  describe "#get_artifact" do
+    before do
+      @graph.artifacts("nginx", "1.0.0")
+    end
+
+    it "returns an instance of artifact of the matching name and version" do
+      artifact = @graph.get_artifact("nginx", "1.0.0")
+
+      artifact.must_be_kind_of Doubleshot::Resolver::GemResolver::Artifact
+      artifact.name.must_equal "nginx"
+      artifact.version.to_s.must_equal "1.0.0"
+    end
+
+    describe "when an artifact of the given name is not in the collection of artifacts" do
+      it "returns nil" do
+        @graph.get_artifact("nothere", "1.0.0").must_be_nil
+      end
+    end
+  end
+
+  describe "#versions" do
+    before do
+      @graph.artifacts("nginx", "1.0.0")
+      @graph.artifacts("nginx", "2.0.0")
+      @graph.artifacts("nginx", "3.0.0")
+      @graph.artifacts("nginx", "4.0.0")
+      @graph.artifacts("nginx", "5.0.0")
+      @graph.artifacts("nginx", "4.0.0")
+    end
+
+    it "returns all the artifacts matching the given name" do
+      @graph.versions("nginx").size.must_equal 5
+    end
+
+    describe "given an optional constraint value" do
+      it "returns only the artifacts matching the given constraint value and name" do
+        @graph.versions("nginx", ">= 4.0.0").size.must_equal 2
+      end
+    end
+  end
+
+  describe "#add_artifact" do
+    before do
+      @artifact = Doubleshot::Resolver::GemResolver::Artifact.new(@graph, "nginx", "1.0.0")
+    end
+
+    it "adds a Doubleshot::Resolver::GemResolver::Artifact to the collection of artifacts" do
+      @graph.add_artifact @artifact
+
+      @graph.artifacts.must_include @artifact
+      @graph.artifacts.size.must_equal 1
+    end
+
+    it "should not add the same artifact twice to the collection" do
+      @graph.add_artifact @artifact
+      @graph.add_artifact @artifact
+
+      @graph.artifacts.size.must_equal 1
+    end
+  end
+
+  describe "#remove_artifact" do
+    before do
+      @artifact = Doubleshot::Resolver::GemResolver::Artifact.new(@graph, "nginx", "1.0.0")
+    end
+
+    describe "given the artifact is a member of the collection" do
+      before do
+        @graph.add_artifact @artifact
+      end
+
+      it "removes the Solve::Artifact from the collection of artifacts" do
+        @graph.remove_artifact(@artifact)
+
+        @graph.artifacts.size.must_equal 0
+      end
+
+      it "returns the removed Solve::Artifact" do
+        @graph.remove_artifact(@artifact).must_equal @artifact
+      end
+    end
+
+    describe "given the artifact is not a member of the collection" do
+      it "should return nil" do
+        @graph.remove_artifact(@artifact).must_be_nil
+      end
+    end
+  end
+
+  describe "#has_artifact?" do
+    before do
+      @artifact = Doubleshot::Resolver::GemResolver::Artifact.new(@graph, "nginx", "1.0.0")
+    end
+
+    it "returns true if the given Solve::Artifact is a member of the collection" do
+      @graph.add_artifact @artifact
+
+      @graph.has_artifact?(@artifact.name, @artifact.version).must_equal true
+    end
+
+    it "returns false if the given Solve::Artifact is not a member of the collection" do
+      @graph.has_artifact?(@artifact.name, @artifact.version).must_equal false
+    end
+  end
+
+  describe "eql?" do
+    before do
+      @graph = Doubleshot::Resolver::GemResolver::Graph.new
+      @graph.artifacts("A", "1.0.0").depends("B", "1.0.0")
+      @graph.artifacts("A", "2.0.0").depends("C", "1.0.0")
+      @graph
+    end
+
+    it "returns false if other isn't a Solve::Graph" do
+      @graph.wont_equal "chicken"
+    end
+
+    it "returns true if other is a Solve::Graph with the same artifacts and dependencies" do
+      other = Doubleshot::Resolver::GemResolver::Graph.new
+      other.artifacts("A", "1.0.0").depends("B", "1.0.0")
+      other.artifacts("A", "2.0.0").depends("C", "1.0.0")
+
+      @graph.must_equal other
+    end
+
+    it "returns false if the other is a Solve::Graph with the same artifacts but different dependencies" do
+      other = Doubleshot::Resolver::GemResolver::Graph.new
+      other.artifacts("A", "1.0.0")
+      other.artifacts("A", "2.0.0")
+
+      @graph.wont_equal other
+    end
+
+    it "returns false if the other is a Solve::Graph with the same dependencies but different artifacts" do
+      other = Doubleshot::Resolver::GemResolver::Graph.new
+      other.artifacts("A", "1.0.0").depends("B", "1.0.0")
+      other.artifacts("A", "2.0.0").depends("C", "1.0.0")
+      other.artifacts("B", "1.0.0")
+
+      @graph.wont_equal other
+    end
+  end
+end

data/test/resolver/gem_resolver/solver_spec.rb

@@ -0,0 +1,449 @@
+#!/usr/bin/env jruby
+
+# encoding: utf-8
+
+require_relative "../../helper"
+
+describe Doubleshot::Resolver::GemResolver::Solver do
+  before do
+    @graph = Doubleshot::Resolver::GemResolver::Graph.new
+    @solver = Doubleshot::Resolver::GemResolver::Solver.new(@graph)
+  end
+
+  describe "ClassMethods" do
+    describe "::new" do
+
+      it "adds a demand for each element in the array" do
+        solver = Doubleshot::Resolver::GemResolver::Solver.new(@graph, ["nginx", "ntp"])
+        solver.demands.size.must_equal 2
+      end
+
+      describe "when demand_array is an array of array" do
+        it "creates a new demand with the name and constraint of each element in the array" do
+          solver = Doubleshot::Resolver::GemResolver::Solver.new(@graph, [["nginx", "= 1.2.3"], ["ntp", "= 1.0.0"]])
+
+          solver.demands[0].name.must_equal "nginx"
+          solver.demands[0].constraint.to_s.must_equal "= 1.2.3"
+          solver.demands[1].name.must_equal "ntp"
+          solver.demands[1].constraint.to_s.must_equal "= 1.0.0"
+        end
+      end
+
+      describe "when demand_array is an array of strings" do
+        it "creates a new demand with the name and a default constraint of each element in the array" do
+          solver = Doubleshot::Resolver::GemResolver::Solver.new(@graph, ["nginx", "ntp"])
+
+          solver.demands[0].name.must_equal "nginx"
+          solver.demands[0].constraint.to_s.must_equal ">= 0"
+          solver.demands[1].name.must_equal "ntp"
+          solver.demands[1].constraint.to_s.must_equal ">= 0"
+        end
+      end
+
+      describe "when demand_array is a mix between an array of arrays and an array of strings" do
+        let(:demand_array) { [["nginx", "= 1.2.3"], "ntp"] }
+
+        it "creates a new demand with the name and default constraint or constraint of each element in the array" do
+          solver = Doubleshot::Resolver::GemResolver::Solver.new(@graph, [["nginx", "= 1.2.3"], "ntp"])
+
+          solver.demands[0].name.must_equal "nginx"
+          solver.demands[0].constraint.to_s.must_equal "= 1.2.3"
+          solver.demands[1].name.must_equal "ntp"
+          solver.demands[1].constraint.to_s.must_equal ">= 0"
+        end
+      end
+    end
+
+    describe "::demand_key" do
+      it "returns a symbol containing the name and constraint of the demand" do
+        demand = Doubleshot::Resolver::GemResolver::Demand.new(MiniTest::Mock.new, "nginx", "= 1.2.3")
+        Doubleshot::Resolver::GemResolver::Solver::demand_key(demand).must_equal :'nginx-= 1.2.3'
+      end
+    end
+
+    describe "::satisfy_all" do
+      before do
+        @version_1 = Gem::Version.new("3.1.1")
+        @version_2 = Gem::Version.new("3.1.2")
+
+        @constraints = [
+          Gem::Requirement.new("> 3.0.0"),
+          Gem::Requirement.new("<= 3.1.2")
+        ]
+
+        @versions = [
+          Gem::Version.new("0.0.1"),
+          Gem::Version.new("0.1.0"),
+          Gem::Version.new("1.0.0"),
+          Gem::Version.new("2.0.0"),
+          Gem::Version.new("3.0.0"),
+          @version_1,
+          @version_2,
+          Gem::Version.new("4.1.0")
+        ].shuffle
+      end
+
+      it "returns all of the versions which satisfy all of the given constraints" do
+        solution = Doubleshot::Resolver::GemResolver::Solver::satisfy_all(@constraints, @versions)
+
+        solution.size.must_equal 2
+        solution.must_include @version_1
+        solution.must_include @version_2
+      end
+
+      it "does not return duplicate satisfied versions given multiple duplicate versions" do
+        solution = Doubleshot::Resolver::GemResolver::Solver::satisfy_all(@constraints, [@version_1, @version_1, @version_1])
+
+        solution.size.must_equal 1
+        solution.must_include @version_1
+      end
+    end
+
+    describe "::satisfy_best" do
+      before do
+        @versions = [
+          Gem::Version.new("0.0.1"),
+          Gem::Version.new("0.1.0"),
+          Gem::Version.new("1.0.0"),
+          Gem::Version.new("2.0.0"),
+          Gem::Version.new("3.0.0"),
+          Gem::Version.new("3.1.1"),
+          Gem::Version.new("3.1.2"),
+          Gem::Version.new("4.1.0")
+        ].shuffle
+      end
+
+      it "returns the best possible match for the given constraints" do
+        Doubleshot::Resolver::GemResolver::Solver::satisfy_best([">= 1.0.0", "< 4.1.0"], @versions)
+          .to_s.must_equal "3.1.2"
+      end
+
+      it "raises a NoSolutionError error given no version matches a constraint" do
+        -> {
+          Doubleshot::Resolver::GemResolver::Solver::satisfy_best(">= 5.0.0", [Gem::Version.new("4.1.0")])
+        }.must_raise Doubleshot::Resolver::GemResolver::Errors::NoSolutionError
+      end
+    end
+  end
+
+  describe "#resolve" do
+    before do
+      @graph.artifacts("nginx", "1.0.0")
+      @solver.demands("nginx", "= 1.0.0")
+    end
+
+    it "returns a solution in the form of a Hash" do
+      @solver.resolve.must_be_kind_of Hash
+    end
+  end
+
+  describe "#demands" do
+    describe "given a name and constraint argument" do
+      before do
+        @name = "nginx"
+        @constraint = "~> 0.101.5"
+        @demand = @solver.demands(@name, @constraint)
+      end
+
+      describe "given the artifact of the given name and constraint does not exist" do
+        it "returns a Solve::Demand" do
+          @demand.must_be_kind_of Doubleshot::Resolver::GemResolver::Demand
+        end
+
+        it "the artifact has the given name" do
+          @demand.name.must_equal @name
+        end
+
+        it "the artifact has the given constraint" do
+          @demand.constraint.to_s.must_equal @constraint
+        end
+
+        it "adds an artifact to the demands collection" do
+          @solver.demands.size.must_equal 1
+        end
+
+        it "the artifact added matches the given name" do
+          @solver.demands[0].name.must_equal @name
+        end
+
+        it "the artifact added matches the given constraint" do
+          @solver.demands[0].constraint.to_s.must_equal @constraint
+        end
+      end
+    end
+
+    describe "given only a name argument" do
+      it "returns a demand with a match all version constraint (>= 0)" do
+        @solver.demands("nginx").constraint.to_s.must_equal ">= 0"
+      end
+    end
+
+    describe "given no arguments" do
+      it "returns an array" do
+        @solver.demands.must_be_kind_of Array
+      end
+
+      it "returns an empty array if no demands have been accessed" do
+        @solver.demands.size.must_equal 0
+      end
+
+      it "returns an array containing a demand if one was accessed" do
+        @solver.demands("nginx", "~> 0.101.5")
+        @solver.demands.size.must_equal 1
+      end
+    end
+
+    describe "given an unexpected number of arguments" do
+      it "raises an ArgumentError if more than two are provided" do
+        -> {
+          @solver.demands(1, 2, 3)
+        }.must_raise ArgumentError, "Unexpected number of arguments. You gave: 3. Expected: 2 or less."
+      end
+
+      it "raises an ArgumentError if a name argument of nil is provided" do
+        -> {
+          @solver.demands(nil)
+        }.must_raise ArgumentError, "A name must be specified. You gave: [nil]."
+      end
+
+      it "raises an ArgumentError if a name and constraint argument are provided but name is nil" do
+        -> {
+          @solver.demands(nil, "= 1.0.0")
+        }.must_raise ArgumentError, 'A name must be specified. You gave: [nil, "= 1.0.0"].'
+      end
+    end
+  end
+
+  describe "#add_demand" do
+    before do
+      @demand = Doubleshot::Resolver::GemResolver::Demand.new(MiniTest::Mock, "ntp")
+    end
+
+    it "adds a Solve::Artifact to the collection of artifacts" do
+      @solver.add_demand @demand
+
+      @solver.demands.must_include @demand
+      @solver.demands.size.must_equal 1
+    end
+
+    it "should not add the same demand twice to the collection" do
+      @solver.add_demand @demand
+      @solver.add_demand @demand
+
+      @solver.demands.must_include @demand
+      @solver.demands.size.must_equal 1
+    end
+  end
+
+  describe "#remove_demand" do
+    before do
+      @demand = Doubleshot::Resolver::GemResolver::Demand.new(MiniTest::Mock, "ntp")
+    end
+
+    describe "given the demand is a member of the collection" do
+      before do
+        @solver.add_demand @demand
+      end
+
+      it "removes the Solve::Artifact from the collection of demands" do
+        @solver.remove_demand @demand
+        @solver.demands.size.must_equal 0
+      end
+
+      it "returns the removed Solve::Artifact" do
+        @solver.remove_demand(@demand).must_equal @demand
+      end
+    end
+
+    it "should return nil given the demand is not a member of the collection" do
+      @solver.remove_demand(@demand).must_be_nil
+    end
+  end
+
+  describe "#has_demand?" do
+    before do
+      @demand = Doubleshot::Resolver::GemResolver::Demand.new(MiniTest::Mock, "ntp")
+    end
+
+    it "returns true if the given Solve::Artifact is a member of the collection" do
+      @solver.add_demand @demand
+
+      @solver.has_demand?(@demand).must_equal true
+    end
+
+    it "returns false if the given Solve::Artifact is not a member of the collection" do
+      @solver.has_demand?(@demand).must_equal false
+    end
+  end
+
+  describe "solutions" do
+    it "chooses the correct artifact for the demands" do
+      @graph.artifacts("mysql", "2.0.0")
+      @graph.artifacts("mysql", "1.2.0")
+      @graph.artifacts("nginx", "1.0.0").depends("mysql", "= 1.2.0")
+
+      result = Doubleshot::Resolver::GemResolver::Solver.new(@graph, [['nginx', '= 1.0.0'], ['mysql']]).resolve
+
+      result.must_equal({"nginx" => "1.0.0", "mysql" => "1.2.0"})
+    end
+
+    it "chooses the best artifact for the demands" do
+      @graph.artifacts("mysql", "2.0.0")
+      @graph.artifacts("mysql", "1.2.0")
+      @graph.artifacts("nginx", "1.0.0").depends("mysql", ">= 1.2.0")
+
+      result = Doubleshot::Resolver::GemResolver::Solver.new(@graph, [['nginx', '= 1.0.0'], ['mysql']]).resolve
+
+      result.must_equal({"nginx" => "1.0.0", "mysql" => "2.0.0"})
+    end
+
+    it "raises NoSolutionError when a solution cannot be found" do
+      @graph.artifacts("mysql", "1.2.0")
+
+      -> {
+        Doubleshot::Resolver::GemResolver::Solver.new(@graph, ['mysql', '>= 2.0.0']).resolve
+      }.must_raise Doubleshot::Resolver::GemResolver::Errors::NoSolutionError
+    end
+
+    it "find the correct solution when backtracking in variables introduced via demands" do
+      @graph.artifacts("D", "1.2.0")
+      @graph.artifacts("D", "1.3.0")
+      @graph.artifacts("D", "1.4.0")
+      @graph.artifacts("D", "2.0.0")
+      @graph.artifacts("D", "2.1.0")
+
+      @graph.artifacts("C", "2.0.0").depends("D", "= 1.2.0")
+      @graph.artifacts("C", "2.1.0").depends("D", ">= 2.1.0")
+      @graph.artifacts("C", "2.2.0").depends("D", "> 2.0.0")
+
+      @graph.artifacts("B", "1.0.0").depends("D", "= 1.0.0")
+      @graph.artifacts("B", "1.1.0").depends("D", "= 1.0.0")
+      @graph.artifacts("B", "2.0.0").depends("D", ">= 1.3.0")
+      @graph.artifacts("B", "2.1.0").depends("D", ">= 2.0.0")
+
+      @graph.artifacts("A", "1.0.0").depends("B", "> 2.0.0")
+      @graph.artifacts("A", "1.0.0").depends("C", "= 2.1.0")
+      @graph.artifacts("A", "1.0.1").depends("B", "> 1.0.0")
+      @graph.artifacts("A", "1.0.1").depends("C", "= 2.1.0")
+      @graph.artifacts("A", "1.0.2").depends("B", "> 1.0.0")
+      @graph.artifacts("A", "1.0.2").depends("C", "= 2.0.0")
+
+      result = Doubleshot::Resolver::GemResolver::Solver.new(@graph, [['A', '~> 1.0.0'], ['D', ">= 2.0.0"]]).resolve
+
+      result.must_equal({"A" => "1.0.1",
+                         "B" => "2.1.0",
+                         "C" => "2.1.0",
+                         "D" => "2.1.0"})
+    end
+
+    it "must correctly resolve when one resolution exists but it is not the latest" do
+      skip "pending: https://github.com/reset/solve/pull/7"
+      
+      @graph.artifacts("get-the-old-one", "1.0")
+        .depends("locked-mid-1", ">= 0")
+        .depends("locked-mid-2", ">= 0")
+      @graph.artifacts("get-the-old-one", "0.5")
+
+      @graph.artifacts("locked-mid-1", "2.0").depends("old-bottom", "= 2.0")
+      @graph.artifacts("locked-mid-1", "1.3").depends("old-bottom", "= 0.5")
+      @graph.artifacts("locked-mid-1", "1.0")
+
+      @graph.artifacts("locked-mid-2", "2.0").depends("old-bottom", "= 2.1")
+      @graph.artifacts("locked-mid-2", "1.4").depends("old-bottom", "= 0.5")
+      @graph.artifacts("locked-mid-2", "1.0")
+
+      @graph.artifacts("old-bottom", "2.1")
+      @graph.artifacts("old-bottom", "2.0")
+      @graph.artifacts("old-bottom", "1.0")
+      @graph.artifacts("old-bottom", "0.5")
+
+      Doubleshot::Resolver::GemResolver::Solver.new(@graph, ["get-the-old-one"]).resolve.must_equal(
+        {
+          "get-the-old-one" => "1.0",
+          "locked-mid-1" => "1.3",
+          "locked-mid-2" => "1.4",
+          "old-bottom" => "0.5"
+        })
+    end
+
+    it "finds the correct solution when there is a circular dependency" do
+      @graph.artifacts("A", "1.0.0").depends("B", "1.0.0")
+      @graph.artifacts("B", "1.0.0").depends("C", "1.0.0")
+      @graph.artifacts("C", "1.0.0").depends("A", "1.0.0")
+
+      result = Doubleshot::Resolver::GemResolver::Solver.new(@graph, [["A", "1.0.0"]]).resolve
+
+      result.must_equal({"A" => "1.0.0",
+                         "B" => "1.0.0",
+                         "C" => "1.0.0"})
+    end
+
+    it "finds the correct solution when there is a p shaped dependency chain" do
+      @graph.artifacts("A", "1.0.0").depends("B", "1.0.0")
+      @graph.artifacts("B", "1.0.0").depends("C", "1.0.0")
+      @graph.artifacts("C", "1.0.0").depends("B", "1.0.0")
+
+      result = Doubleshot::Resolver::GemResolver::Solver.new(@graph, [["A", "1.0.0"]]).resolve
+
+      result.must_equal({"A" => "1.0.0",
+                         "B" => "1.0.0",
+                         "C" => "1.0.0"})
+    end
+
+    it "finds the correct solution when there is a diamond shaped dependency" do
+      @graph.artifacts("A", "1.0.0")
+        .depends("B", "1.0.0")
+        .depends("C", "1.0.0")
+      @graph.artifacts("B", "1.0.0")
+        .depends("D", "1.0.0")
+      @graph.artifacts("C", "1.0.0")
+        .depends("D", "1.0.0")
+      @graph.artifacts("D", "1.0.0")
+
+      result = Doubleshot::Resolver::GemResolver::Solver.new(@graph, [["A", "1.0.0"]]).resolve
+
+      result.must_equal({"A" => "1.0.0",
+                         "B" => "1.0.0",
+                         "C" => "1.0.0",
+                         "D" => "1.0.0"})
+    end
+
+    it "gives an empty solution when there are no demands" do
+      result = Doubleshot::Resolver::GemResolver::Solver.new(@graph, []).resolve
+      result.must_equal({})
+    end
+
+    it "tries all combinations until it finds a solution" do
+      @graph.artifacts("A", "1.0.0").depends("B", "~> 1.0.0")
+      @graph.artifacts("A", "1.0.1").depends("B", "~> 1.0.0")
+      @graph.artifacts("A", "1.0.2").depends("B", "~> 1.0.0")
+
+      @graph.artifacts("B", "1.0.0").depends("C", "~> 1.0.0")
+      @graph.artifacts("B", "1.0.1").depends("C", "~> 1.0.0")
+      @graph.artifacts("B", "1.0.2").depends("C", "~> 1.0.0")
+
+      @graph.artifacts("C", "1.0.0").depends("D", "1.0.0")
+      @graph.artifacts("C", "1.0.1").depends("D", "1.0.0")
+      @graph.artifacts("C", "1.0.2").depends("D", "1.0.0")
+
+      # ensure we can't find a solution in the above
+      @graph.artifacts("D", "1.0.0").depends("A", "< 0.0.0")
+
+      # Add a solution to the graph that should be reached only after
+      #   all of the others have been tried
+      #   it must be circular to ensure that no other branch can find it
+      @graph.artifacts("A", "0.0.0").depends("B", "0.0.0")
+      @graph.artifacts("B", "0.0.0").depends("C", "0.0.0")
+      @graph.artifacts("C", "0.0.0").depends("D", "0.0.0")
+      @graph.artifacts("D", "0.0.0").depends("A", "0.0.0")
+
+      result = Doubleshot::Resolver::GemResolver::Solver.new(@graph, [["A"]]).resolve
+
+      result.must_equal({ "A" => "0.0.0",
+                          "B" => "0.0.0",
+                          "C" => "0.0.0",
+                          "D" => "0.0.0"})
+
+    end
+  end
+end