solve 0.2.1 → 0.3.0

data/spec/unit/solve/constraint_spec.rb

@@ -7,33 +7,7 @@ describe Solve::Constraint do
   describe "ClassMethods" do
     subject { Solve::Constraint }
 
-    describe "#parse" do
-      it "returns an array containing two items" do
-        subject.parse(valid_string).should have(2).items
-      end
-
-      it "returns the operator at index 0" do
-        subject.parse(valid_string)[0].should eql(">=")
-      end
-
-      it "returns the version string at index 1" do
-        subject.parse(valid_string)[1].should eql("0.0.0")
-      end
-
-      context "given a string that does not match the Constraint REGEXP" do
-        it "returns nil" do
-          subject.parse(invalid_string).should be_nil
-        end
-      end
-
-      context "given a string that does not contain an operator" do
-        it "returns a constraint constraint with a default operator (=)" do
-          subject.parse("1.0.0")[0].should eql("=")
-        end
-      end
-    end
-
-    describe "#initialize" do
+    describe "::new" do
       it "returns a new instance of Constraint" do
         subject.new(valid_string).should be_a(Solve::Constraint)
       end
@@ -53,7 +27,7 @@ describe Solve::Constraint do
         it "raises an InvalidConstraintFormat error" do
           lambda {
             subject.new(invalid_string)
-          }.should raise_error(Solve::InvalidConstraintFormat)
+          }.should raise_error(Solve::Errors::InvalidConstraintFormat)
         end
       end
 
@@ -61,7 +35,39 @@ describe Solve::Constraint do
         it "raises an InvalidConstraintFormat error" do
           lambda {
             subject.new(nil)
-          }.should raise_error(Solve::InvalidConstraintFormat)
+          }.should raise_error(Solve::Errors::InvalidConstraintFormat)
+        end
+      end
+
+      context "given a string containing only a major and minor version" do
+        it "has a nil value for patch" do
+          subject.new("~> 1.2").patch.should be_nil
+        end
+      end
+    end
+
+    describe "::split" do
+      it "returns an array containing two items" do
+        subject.split(valid_string).should have(2).items
+      end
+
+      it "returns the operator at index 0" do
+        subject.split(valid_string)[0].should eql(">=")
+      end
+
+      it "returns the version string at index 1" do
+        subject.split(valid_string)[1].should eql("0.0.0")
+      end
+
+      context "given a string that does not match the Constraint REGEXP" do
+        it "returns nil" do
+          subject.split(invalid_string).should be_nil
+        end
+      end
+
+      context "given a string that does not contain an operator" do
+        it "returns a constraint constraint with a default operator (=)" do
+          subject.split("1.0.0")[0].should eql("=")
         end
       end
     end
@@ -146,7 +152,7 @@ describe Solve::Constraint do
       end
     end
 
-    context "greater than or equal to (~>)" do
+    context "aproximately (~>)" do
       subject { Solve::Constraint.new("~> 1.0.0") }
 
       it "returns true if the given version is equal to the version constraint" do

data/spec/unit/solve/demand_spec.rb

@@ -1,52 +1,61 @@
 require 'spec_helper'
 
 describe Solve::Demand do
-  let(:graph) { double('graph') }
+  let(:solver) { double('solver') }
   let(:name) { "league" }
 
   describe "ClassMethods" do
     subject { Solve::Demand }
 
-    describe "::initialize" do
+    describe "::new" do
       it "accepts a string for the constraint parameter" do
-        subject.new(graph, name, "= 0.0.1").constraint.to_s.should eql("= 0.0.1")
+        subject.new(solver, name, "= 0.0.1").constraint.to_s.should eql("= 0.0.1")
       end
 
       it "accepts a Solve::Constraint for the constraint parameter" do
         constraint = Solve::Constraint.new("= 0.0.1")
 
-        subject.new(graph, name, constraint).constraint.should eql(constraint)
+        subject.new(solver, name, constraint).constraint.should eql(constraint)
+      end
+
+      context "when no value for 'constraint' is given" do
+        it "uses a default of >= 0.0.0" do
+          demand = subject.new(solver, name)
+
+          demand.constraint.operator.should eql(">=")
+          demand.constraint.version.to_s.should eql("0.0.0")
+        end
       end
     end
   end
 
   let(:constraint) { "~> 1.0.0" }
-  subject { Solve::Demand.new(graph, name, constraint) }
+  subject { Solve::Demand.new(solver, name, constraint) }
 
   describe "#delete" do
-    context "given the artifact is a member of a graph" do
-      subject { Solve::Demand.new(graph, name, constraint) }
+    context "given the demand is related to a solver" do
+      subject { Solve::Demand.new(solver, name, constraint) }
 
       before(:each) do
-        graph.should_receive(:remove_demand).with(subject).and_return(subject)
+        solver.should_receive(:remove_demand).with(subject).and_return(subject)
       end
 
-      it "notifies the graph that the artifact should be removed" do
+      it "notifies the solver that the demand should be removed" do
         subject.delete
       end
 
-      it "sets the graph attribute to nil" do
+      it "sets the solver attribute to nil" do
         subject.delete
 
-        subject.graph.should be_nil
+        subject.solver.should be_nil
       end
 
-      it "returns the instance of artifact deleted from the graph" do
+      it "returns the instance of demand deleted from the solver" do
         subject.delete.should eql(subject)
       end
     end
 
-    context "given the artifact is not the member of a graph" do
+    context "given the demand is not the member of a solver" do
       subject { Solve::Demand.new(nil, name, constraint) }
 
       it "returns nil" do

data/spec/unit/solve/dependency_spec.rb

@@ -1,6 +1,21 @@
 require 'spec_helper'
 
 describe Solve::Dependency do
+  describe "ClassMethods" do
+    subject { Solve::Dependency }
+
+    describe "::new" do
+      context "when no value for 'constraint' is given" do
+        it "uses a default of >= 0.0.0" do
+          dep = subject.new(double('artifact'), "ntp")
+
+          dep.constraint.operator.should eql(">=")
+          dep.constraint.version.to_s.should eql("0.0.0")
+        end
+      end
+    end
+  end
+
   let(:artifact) { double('artifact') }
   let(:name) { 'nginx' }
   let(:constraint) { "~> 0.0.1" }

data/spec/unit/solve/graph_spec.rb

@@ -1,6 +1,52 @@
 require 'spec_helper'
 
 describe Solve::Graph do
+  describe "ClassMethods" do
+    subject { Solve::Graph }
+
+    describe "::key_for" do
+      context "given a Solve::Artifact" do
+        let(:artifact) { Solve::Artifact.new(double('graph'), "nginx", "1.2.3") }
+
+        it "delegates to ::artifact_key with the name and version of the artifact" do
+          subject.should_receive(:artifact_key).with(artifact.name, artifact.version)
+
+          subject.key_for(artifact)
+        end
+      end
+
+      context "given a Solve::Dependency" do
+        let(:demand) { Solve::Dependency.new(double('artifact'), "ntp", "= 2.3.4") }
+
+        it "delegates to ::dependency_key with the name and constraint of the dependency" do
+          subject.should_receive(:dependency_key).with(demand.name, anything)
+
+          subject.key_for(demand)
+        end
+      end
+
+      context "given an unknown object" do
+        it "raises an ArgumentError" do
+          lambda {
+            subject.key_for("hello")
+          }.should raise_error(ArgumentError)
+        end
+      end
+    end
+
+    describe "::artifact_key" do
+      it "returns a symbol containing the name and version of the artifact" do
+        subject.artifact_key("nginx", "1.2.3").should eql(:'nginx-1.2.3')
+      end
+    end
+
+    describe "::dependency_key" do
+      it "returns a symbol containing the name and constraint of the dependency" do
+        subject.dependency_key("ntp", "= 2.3.4").should eql(:'ntp-= 2.3.4')
+      end
+    end
+  end
+
   subject { Solve::Graph.new }
 
   describe "#artifacts" do
@@ -78,196 +124,106 @@ describe Solve::Graph do
     end
   end
 
-  describe "#add_artifact" do
-    let(:artifact) { double('artifact', name: "nginx", version: "1.0.0") }
-
-    it "adds a Solve::Artifact to the collection of artifacts" do
-      subject.add_artifact(artifact)
-
-      subject.should have_artifact(artifact)
-      subject.artifacts.should have(1).item
+  describe "#get_artifact" do
+    before(:each) do
+      subject.artifacts("nginx", "1.0.0")
     end
 
-    it "should not add the same artifact twice to the collection" do
-      subject.add_artifact(artifact)
-      subject.add_artifact(artifact)
+    it "returns an instance of artifact of the matching name and version" do
+      artifact = subject.get_artifact("nginx", "1.0.0")
 
-      subject.artifacts.should have(1).item
+      artifact.should be_a(Solve::Artifact)
+      artifact.name.should eql("nginx")
+      artifact.version.to_s.should eql("1.0.0")
     end
-  end
-
-  describe "#remove_artifact" do
-    let(:artifact) { double('artifact', name: "nginx", version: "1.0.0") }
-
-    context "given the artifact is a member of the collection" do
-      before(:each) { subject.add_artifact(artifact) }
 
-      it "removes the Solve::Artifact from the collection of artifacts" do
-        subject.remove_artifact(artifact)
-
-        subject.artifacts.should have(0).items
+    context "when an artifact of the given name is not in the collection of artifacts" do
+      it "returns nil" do
+        subject.get_artifact("nothere", "1.0.0").should be_nil
       end
-
-      it "returns the removed Solve::Artifact" do
-        subject.remove_artifact(artifact).should eql(artifact)
-      end
-    end
-
-    context "given the artifact is not a member of the collection" do
-      it "should return nil" do
-        subject.remove_artifact(artifact).should be_nil
-      end
-    end
-  end
-
-  describe "#has_artifact?" do
-    let(:artifact) { double('artifact', name: "nginx", version: "1.0.0") }
-
-    it "returns true if the given Solve::Artifact is a member of the collection" do
-      subject.add_artifact(artifact)
-
-      subject.has_artifact?(artifact).should be_true
-    end
-
-    it "returns false if the given Solve::Artifact is not a member of the collection" do
-      subject.has_artifact?(artifact).should be_false
     end
   end
 
-  describe "#demands" do
-    context "given a name and constraint argument" do
-      let(:name) { "nginx" }
-      let(:constraint) { "~> 0.101.5" }
-
-      context "given the artifact of the given name and constraint does not exist" do
-        it "returns a Solve::Demand" do
-          subject.demands(name, constraint).should be_a(Solve::Demand)
-        end
-
-        it "the artifact has the given name" do
-          subject.demands(name, constraint).name.should eql(name)
-        end
-
-        it "the artifact has the given constraint" do
-          subject.demands(name, constraint).constraint.to_s.should eql(constraint)
-        end
-
-        it "adds an artifact to the demands collection" do
-          subject.demands(name, constraint)
-
-          subject.demands.should have(1).item
-        end
-
-        it "the artifact added matches the given name" do
-          subject.demands(name, constraint)
-
-          subject.demands[0].name.should eql(name)
-        end
-
-        it "the artifact added matches the given constraint" do
-          subject.demands(name, constraint)
-
-          subject.demands[0].constraint.to_s.should eql(constraint)
-        end
-      end
+  describe "#versions" do
+    let(:artifacts) do
+      [
+        double('artifact', name: 'nginx', version: Solve::Version.new('1.0.0')),
+        double('artifact', name: 'nginx', version: Solve::Version.new('2.0.0')),
+        double('artifact', name: 'nginx', version: Solve::Version.new('3.0.0')),
+        double('artifact', name: 'nginx', version: Solve::Version.new('4.0.0')),
+        double('artifact', name: 'nginx', version: Solve::Version.new('5.0.0')),
+        double('artifact', name: 'mysql', version: Solve::Version.new('4.0.0'))
+      ]
     end
 
-    context "given only a name argument" do
-      it "returns a demand with a match all version constraint (>= 0.0.0)" do
-        subject.demands("nginx").constraint.to_s.should eql(">= 0.0.0")
-      end
+    before(:each) do
+      subject.stub(:artifacts).and_return(artifacts)
     end
 
-    context "given no arguments" do
-      it "returns an array" do
-        subject.demands.should be_a(Array)
-      end
-
-      it "returns an empty array if no demands have been accessed" do
-        subject.demands.should have(0).items
-      end
-
-      it "returns an array containing a demand if one was accessed" do
-        subject.demands("nginx", "~> 0.101.5")
-
-        subject.demands.should have(1).item
-      end
+    it "returns all the artifacts matching the given name" do
+      subject.versions("nginx").should have(5).items
     end
 
-    context "given an unexpected number of arguments" do
-      it "raises an ArgumentError if more than two are provided" do
-        lambda {
-          subject.demands(1, 2, 3)
-        }.should raise_error(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
-        lambda {
-          subject.demands(nil)
-        }.should raise_error(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
-        lambda {
-          subject.demands(nil, "= 1.0.0")
-        }.should raise_error(ArgumentError, 'A name must be specified. You gave: [nil, "= 1.0.0"].')
+    context "given an optional constraint value" do
+      it "returns only the artifacts matching the given constraint value and name" do
+        subject.versions("nginx", ">= 4.0.0").should have(2).items
       end
     end
   end
 
-  describe "#add_demand" do
-    let(:demand) { double('demand') }
+  describe "#add_artifact" do
+    let(:artifact) { Solve::Artifact.new(double('graph'), "nginx", "1.0.0") }
 
     it "adds a Solve::Artifact to the collection of artifacts" do
-      subject.add_demand(demand)
+      subject.add_artifact(artifact)
 
-      subject.should have_demand(demand)
-      subject.demands.should have(1).item
+      subject.should have_artifact(artifact.name, artifact.version)
+      subject.artifacts.should have(1).item
     end
 
-    it "should not add the same demand twice to the collection" do
-      subject.add_demand(demand)
-      subject.add_demand(demand)
+    it "should not add the same artifact twice to the collection" do
+      subject.add_artifact(artifact)
+      subject.add_artifact(artifact)
 
-      subject.demands.should have(1).item
+      subject.artifacts.should have(1).item
     end
   end
 
-  describe "#remove_demand" do
-    let(:demand) { double('demand') }
+  describe "#remove_artifact" do
+    let(:artifact) { Solve::Artifact.new(double('graph'), "nginx", "1.0.0") }
 
-    context "given the demand is a member of the collection" do
-      before(:each) { subject.add_demand(demand) }
+    context "given the artifact is a member of the collection" do
+      before(:each) { subject.add_artifact(artifact) }
 
-      it "removes the Solve::Artifact from the collection of demands" do
-        subject.remove_demand(demand)
+      it "removes the Solve::Artifact from the collection of artifacts" do
+        subject.remove_artifact(artifact)
 
-        subject.demands.should have(0).items
+        subject.artifacts.should have(0).items
       end
 
       it "returns the removed Solve::Artifact" do
-        subject.remove_demand(demand).should eql(demand)
+        subject.remove_artifact(artifact).should eql(artifact)
       end
     end
 
-    context "given the demand is not a member of the collection" do
+    context "given the artifact is not a member of the collection" do
       it "should return nil" do
-        subject.remove_demand(demand).should be_nil
+        subject.remove_artifact(artifact).should be_nil
       end
     end
   end
 
-  describe "#has_demand?" do
-    let(:demand) { double('demand') }
+  describe "#has_artifact?" do
+    let(:artifact) { Solve::Artifact.new(double('graph'), "nginx", "1.0.0") }
 
     it "returns true if the given Solve::Artifact is a member of the collection" do
-      subject.add_demand(demand)
+      subject.add_artifact(artifact)
 
-      subject.has_demand?(demand).should be_true
+      subject.has_artifact?(artifact.name, artifact.version).should be_true
     end
 
     it "returns false if the given Solve::Artifact is not a member of the collection" do
-      subject.has_demand?(demand).should be_false
+      subject.has_artifact?(artifact.name, artifact.version).should be_false
     end
   end
 end