solve 0.8.2 → 1.0.0.rc1

data/spec/acceptance/solutions_spec.rb

@@ -3,9 +3,9 @@ require 'spec_helper'
 describe "Solutions" do
   it "chooses the correct artifact for the demands" do
     graph = Solve::Graph.new
-    graph.artifacts("mysql", "2.0.0")
-    graph.artifacts("mysql", "1.2.0")
-    graph.artifacts("nginx", "1.0.0").depends("mysql", "= 1.2.0")
+    graph.artifact("mysql", "2.0.0")
+    graph.artifact("mysql", "1.2.0")
+    graph.artifact("nginx", "1.0.0").depends("mysql", "= 1.2.0")
 
     result = Solve.it!(graph, [['nginx', '= 1.0.0'], ['mysql']])
 
@@ -14,9 +14,9 @@ describe "Solutions" do
 
   it "chooses the best artifact for the demands" do
     graph = Solve::Graph.new
-    graph.artifacts("mysql", "2.0.0")
-    graph.artifacts("mysql", "1.2.0")
-    graph.artifacts("nginx", "1.0.0").depends("mysql", ">= 1.2.0")
+    graph.artifact("mysql", "2.0.0")
+    graph.artifact("mysql", "1.2.0")
+    graph.artifact("nginx", "1.0.0").depends("mysql", ">= 1.2.0")
 
     result = Solve.it!(graph, [['nginx', '= 1.0.0'], ['mysql']])
 
@@ -25,7 +25,7 @@ describe "Solutions" do
 
   it "raises NoSolutionError when a solution cannot be found" do
     graph = Solve::Graph.new
-    graph.artifacts("mysql", "1.2.0")
+    graph.artifact("mysql", "1.2.0")
 
     lambda {
       Solve.it!(graph, ['mysql', '>= 2.0.0'])
@@ -35,27 +35,27 @@ describe "Solutions" do
   it "find the correct solution when backtracking in variables introduced via demands" do
     graph = Solve::Graph.new
 
-    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.artifact("D", "1.2.0")
+    graph.artifact("D", "1.3.0")
+    graph.artifact("D", "1.4.0")
+    graph.artifact("D", "2.0.0")
+    graph.artifact("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.artifact("C", "2.0.0").depends("D", "= 1.2.0")
+    graph.artifact("C", "2.1.0").depends("D", ">= 2.1.0")
+    graph.artifact("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.artifact("B", "1.0.0").depends("D", "= 1.0.0")
+    graph.artifact("B", "1.1.0").depends("D", "= 1.0.0")
+    graph.artifact("B", "2.0.0").depends("D", ">= 1.3.0")
+    graph.artifact("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")
+    graph.artifact("A", "1.0.0").depends("B", "> 2.0.0")
+    graph.artifact("A", "1.0.0").depends("C", "= 2.1.0")
+    graph.artifact("A", "1.0.1").depends("B", "> 1.0.0")
+    graph.artifact("A", "1.0.1").depends("C", "= 2.1.0")
+    graph.artifact("A", "1.0.2").depends("B", "> 1.0.0")
+    graph.artifact("A", "1.0.2").depends("C", "= 2.0.0")
 
     result = Solve.it!(graph, [['A', '~> 1.0.0'], ['D', ">= 2.0.0"]])
 
@@ -69,9 +69,9 @@ describe "Solutions" do
   it "finds the correct solution when there is a circular dependency" do
     graph = Solve::Graph.new
 
-    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")
+    graph.artifact("A", "1.0.0").depends("B", "1.0.0")
+    graph.artifact("B", "1.0.0").depends("C", "1.0.0")
+    graph.artifact("C", "1.0.0").depends("A", "1.0.0")
 
     result = Solve.it!(graph, [["A", "1.0.0"]])
 
@@ -83,9 +83,9 @@ describe "Solutions" do
   it "finds the correct solution when there is a p shaped depenency chain" do
     graph = Solve::Graph.new
 
-    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")
+    graph.artifact("A", "1.0.0").depends("B", "1.0.0")
+    graph.artifact("B", "1.0.0").depends("C", "1.0.0")
+    graph.artifact("C", "1.0.0").depends("B", "1.0.0")
 
     result = Solve.it!(graph, [["A", "1.0.0"]])
 
@@ -97,14 +97,14 @@ describe "Solutions" do
   it "finds the correct solution when there is a diamond shaped dependency" do
     graph = Solve::Graph.new
 
-    graph.artifacts("A", "1.0.0")
+    graph.artifact("A", "1.0.0")
       .depends("B", "1.0.0")
       .depends("C", "1.0.0")
-    graph.artifacts("B", "1.0.0")
+    graph.artifact("B", "1.0.0")
       .depends("D", "1.0.0")
-    graph.artifacts("C", "1.0.0")
+    graph.artifact("C", "1.0.0")
       .depends("D", "1.0.0")
-    graph.artifacts("D", "1.0.0")
+    graph.artifact("D", "1.0.0")
 
     result = Solve.it!(graph, [["A", "1.0.0"]])
 
@@ -114,11 +114,45 @@ describe "Solutions" do
                       "D" => "1.0.0")
   end
 
+  it "solves when packages and constraints have prerelease elements" do
+    graph = Solve::Graph.new
+
+    graph.artifact("A", "1.0.0")
+      .depends("B", ">= 1.0.0-alpha")
+    graph.artifact("B", "1.0.0-alpha")
+      .depends("C", "1.0.0")
+    graph.artifact("C", "1.0.0")
+
+    result = Solve.it!(graph, [["A", "1.0.0"]])
+
+    result.should eql("A" => "1.0.0",
+                      "B" => "1.0.0-alpha",
+                      "C" => "1.0.0")
+
+  end
+
+  it "solves when packages and constraints have build elements" do
+    graph = Solve::Graph.new
+
+    graph.artifact("A", "1.0.0")
+      .depends("B", ">= 1.0.0+build")
+    graph.artifact("B", "1.0.0+build")
+      .depends("C", "1.0.0")
+    graph.artifact("C", "1.0.0")
+
+    result = Solve.it!(graph, [["A", "1.0.0"]])
+
+    result.should eql("A" => "1.0.0",
+                      "B" => "1.0.0+build",
+                      "C" => "1.0.0")
+
+  end
+
   it "fails with a self dependency" do
     graph = Solve::Graph.new
 
-    graph.artifacts("bottom", "1.0.0")
-    graph.artifacts("middle", "1.0.0").depends("top", "= 1.0.0").depends("middle")
+    graph.artifact("bottom", "1.0.0")
+    graph.artifact("middle", "1.0.0").depends("top", "= 1.0.0").depends("middle")
 
     demands = [["bottom", "1.0.0"],["middle", "1.0.0"]]
 
@@ -137,28 +171,28 @@ describe "Solutions" do
 
     graph = Solve::Graph.new
 
-    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.artifact("A", "1.0.0").depends("B", "~> 1.0.0")
+    graph.artifact("A", "1.0.1").depends("B", "~> 1.0.0")
+    graph.artifact("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.artifact("B", "1.0.0").depends("C", "~> 1.0.0")
+    graph.artifact("B", "1.0.1").depends("C", "~> 1.0.0")
+    graph.artifact("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")
+    graph.artifact("C", "1.0.0").depends("D", "1.0.0")
+    graph.artifact("C", "1.0.1").depends("D", "1.0.0")
+    graph.artifact("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")
+    graph.artifact("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")
+    graph.artifact("A", "0.0.0").depends("B", "0.0.0")
+    graph.artifact("B", "0.0.0").depends("C", "0.0.0")
+    graph.artifact("C", "0.0.0").depends("D", "0.0.0")
+    graph.artifact("D", "0.0.0").depends("A", "0.0.0")
 
     demands = [["A"]]
 
@@ -174,33 +208,40 @@ describe "Solutions" do
   it "correctly resolves when a resolution exists but it is not the latest" do
     graph = Solve::Graph.new
 
-    graph.artifacts("get-the-old-one", "1.0.0")
+    graph.artifact("get-the-old-one", "1.0.0")
       .depends("locked-mid-1", ">= 0.0.0")
       .depends("locked-mid-2", ">= 0.0.0")
-    graph.artifacts("get-the-old-one", "0.5.0")
+    graph.artifact("get-the-old-one", "0.5.0")
 
-    graph.artifacts("locked-mid-1", "2.0.0").depends("old-bottom", "= 2.0.0")
-    graph.artifacts("locked-mid-1", "1.3.0").depends("old-bottom", "= 0.5.0")
-    graph.artifacts("locked-mid-1", "1.0.0")
+    graph.artifact("locked-mid-1", "2.0.0").depends("old-bottom", "= 2.0.0")
+    graph.artifact("locked-mid-1", "1.3.0").depends("old-bottom", "= 0.5.0")
+    graph.artifact("locked-mid-1", "1.0.0")
 
-    graph.artifacts("locked-mid-2", "2.0.0").depends("old-bottom", "= 2.1.0")
-    graph.artifacts("locked-mid-2", "1.4.0").depends("old-bottom", "= 0.5.0")
-    graph.artifacts("locked-mid-2", "1.0.0")
+    graph.artifact("locked-mid-2", "2.0.0").depends("old-bottom", "= 2.1.0")
+    graph.artifact("locked-mid-2", "1.4.0").depends("old-bottom", "= 0.5.0")
+    graph.artifact("locked-mid-2", "1.0.0")
 
-    graph.artifacts("old-bottom", "2.1.0")
-    graph.artifacts("old-bottom", "2.0.0")
-    graph.artifacts("old-bottom", "1.0.0")
-    graph.artifacts("old-bottom", "0.5.0")
+    graph.artifact("old-bottom", "2.1.0")
+    graph.artifact("old-bottom", "2.0.0")
+    graph.artifact("old-bottom", "1.0.0")
+    graph.artifact("old-bottom", "0.5.0")
 
     demands = [["get-the-old-one"]]
 
     result = Solve.it!(graph, demands)
 
+    # ruby solver result:
+    #
+    # "get-the-old-one" => "1.0.0",
+    # "locked-mid-1" => "2.0.0",
+    # "locked-mid-2" => "1.0.0",
+    # "old-bottom" => "2.0.0"
+
     result.should eql({
       "get-the-old-one" => "1.0.0",
-      "locked-mid-1" => "2.0.0",
-      "locked-mid-2" => "1.0.0",
-      "old-bottom" => "2.0.0"
+      "locked-mid-1" => "1.0.0",
+      "locked-mid-2" => "2.0.0",
+      "old-bottom" => "2.1.0"
     })
   end
 
@@ -209,9 +250,9 @@ describe "Solutions" do
       it "returns a sorted list of dependencies" do
         graph = Solve::Graph.new
 
-        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")
+        graph.artifact("A", "1.0.0").depends("B", "= 1.0.0")
+        graph.artifact("B", "1.0.0").depends("C", "= 1.0.0")
+        graph.artifact("C", "1.0.0")
 
         demands = [["A"]]
 
@@ -231,11 +272,11 @@ describe "Solutions" do
       it "returns a sorted list of dependencies" do
         graph = Solve::Graph.new
 
-        graph.artifacts("B", "1.0.0").depends("A", "= 1.0.0")
-        graph.artifacts("A", "1.0.0").depends("C", "= 1.0.0")
-        graph.artifacts("C", "1.0.0")
+        graph.artifact("B", "1.0.0").depends("A", "= 1.0.0")
+        graph.artifact("A", "1.0.0").depends("C", "= 1.0.0")
+        graph.artifact("C", "1.0.0")
 
-        demands = [["A"],["B"]] 
+        demands = [["A"],["B"]]
 
         result = Solve.it!(graph, demands, { :sorted => true  } )
 
@@ -251,9 +292,9 @@ describe "Solutions" do
       it "raises a Solve::Errors::UnsortableSolutionError which contains the unsorted solution" do
         graph = Solve::Graph.new
 
-        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")
+        graph.artifact("A", "1.0.0").depends("B", "= 1.0.0")
+        graph.artifact("B", "1.0.0").depends("C", "= 1.0.0")
+        graph.artifact("C", "1.0.0").depends("A", "= 1.0.0")
 
         demands = [["A"]]
 

data/spec/spec_helper.rb

@@ -14,6 +14,9 @@ Spork.prefork do
     config.treat_symbols_as_metadata_keys_with_true_values = true
     config.filter_run focus: true
     config.run_all_when_everything_filtered = true
+
+    # Run specs in a random order
+    config.order = :random
   end
 end
 

data/spec/unit/solve/artifact_spec.rb

@@ -19,7 +19,7 @@ describe Solve::Artifact do
       let(:two) { Solve::Artifact.new(graph, "riot", "1.0.0") }
 
       it "is equal" do
-        one.should be_eql(two)
+        expect(one).to eq(two)
       end
     end
 
@@ -28,7 +28,7 @@ describe Solve::Artifact do
       let(:two) { Solve::Artifact.new(graph, "riot", "2.0.0") }
 
       it "is not equal" do
-        one.should_not be_eql(two)
+        expect(one).to_not eq(two)
       end
     end
 
@@ -37,7 +37,7 @@ describe Solve::Artifact do
       let(:two) { Solve::Artifact.new(graph, "league", "1.0.0") }
 
       it "is not equal" do
-        one.should_not be_eql(two)
+        expect(one).to_not eq(two)
       end
     end
   end
@@ -58,40 +58,69 @@ describe Solve::Artifact do
     it "orders artifacts by their version number" do
       sorted = artifacts.sort
 
-      sorted[0].should eql(one)
-      sorted[1].should eql(two)
-      sorted[2].should eql(three)
+      expect(sorted[0]).to eq(one)
+      expect(sorted[1]).to eq(two)
+      expect(sorted[2]).to eq(three)
+    end
+  end
+
+  describe "#dependency?" do
+    before { subject.depends("nginx", "1.0.0") }
+
+    it "returns false when the dependency does not exist" do
+      expect(subject).to have_dependency("nginx", "1.0.0")
+    end
+
+    it "returns true when the dependendency exists" do
+      expect(subject).to_not have_dependency("apache2", "2.0.0")
+    end
+  end
+
+  describe "#dependency" do
+    before { subject.depends("nginx", "~> 1.2.3") }
+
+    it "returns an instance of Solve::Dependency matching the given name and constraint" do
+      dependency = subject.dependency("nginx", "~> 1.2.3")
+
+      expect(dependency).to be_a(Solve::Dependency)
+      expect(dependency.name).to eq("nginx")
+      expect(dependency.constraint.to_s).to eq("~> 1.2.3")
     end
   end
 
   describe "#dependencies" do
-    context "given no arguments" do
-      it "returns an array" do
-        subject.dependencies.should be_a(Array)
-      end
+    it "returns an array" do
+      expect(subject.dependencies).to be_a(Array)
+    end
 
-      it "returns an empty array if no dependencies have been accessed" do
-        subject.dependencies.should have(0).items
-      end
+    it "returns an empty array if no dependencies have been accessed" do
+      expect(subject.dependencies).to be_empty
+    end
+
+    it "returns all dependencies" do
+      subject.depends("nginx", "1.0.0")
+      subject.depends("nginx", "~> 2.0.0")
+
+      expect(subject.dependencies.size).to eq(2)
     end
   end
 
   describe "#depends" do
     context "given a name and constraint argument" do
       let(:name) { "nginx" }
-      let(:constraint) { "~> 0.101.5" }
+      let(:constraint) { "~> 1.0.0" }
 
       context "given the dependency of the given name and constraint does not exist" do
         it "returns a Solve::Artifact" do
-          subject.depends(name, constraint).should be_a(Solve::Artifact)
+          expect(subject.depends(name, constraint)).to be_a(Solve::Artifact)
         end
 
         it "adds a dependency with the given name and constraint to the list of dependencies" do
           subject.depends(name, constraint)
 
-          subject.dependencies.should have(1).item
-          subject.dependencies.first.name.should eql(name)
-          subject.dependencies.first.constraint.to_s.should eql(constraint)
+          expect(subject.dependencies.size).to eq(1)
+          expect(subject.dependencies.first.name).to eq(name)
+          expect(subject.dependencies.first.constraint.to_s).to eq(constraint)
         end
       end
     end
@@ -100,52 +129,8 @@ describe Solve::Artifact do
       it "adds a dependency with a all constraint (>= 0.0.0)" do
         subject.depends("nginx")
 
-        subject.dependencies.should have(1).item
-        subject.dependencies.first.constraint.to_s.should eql(">= 0.0.0")
-      end
-    end
-  end
-
-  describe "::get_dependency" do
-    before(:each) { subject.depends("nginx", "~> 1.2.3") }
-
-    it "returns an instance of Solve::Dependency matching the given name and constraint" do
-      dependency = subject.get_dependency("nginx", "~> 1.2.3")
-
-      dependency.should be_a(Solve::Dependency)
-      dependency.name.should eql("nginx")
-      dependency.constraint.to_s.should eql("~> 1.2.3")
-    end
-  end
-
-  describe "#delete" do
-    context "given the artifact is a member of a graph" do
-      subject { Solve::Artifact.new(graph, name, version) }
-
-      before(:each) do
-        graph.should_receive(:remove_artifact).with(subject).and_return(subject)
-      end
-
-      it "notifies the graph that the artifact should be removed" do
-        subject.delete
-      end
-
-      it "sets the graph attribute to nil" do
-        subject.delete
-
-        subject.graph.should be_nil
-      end
-
-      it "returns the instance of artifact deleted from the graph" do
-        subject.delete.should eql(subject)
-      end
-    end
-
-    context "given the artifact is not the member of a graph" do
-      subject { Solve::Artifact.new(nil, name, version) }
-
-      it "returns nil" do
-        subject.delete.should be_nil
+        expect(subject.dependencies.size).to eq(1)
+        expect(subject.dependencies.first.constraint.to_s).to eq(">= 0.0.0")
       end
     end
   end