solve 0.8.2 → 1.0.0.rc1

data/spec/unit/solve/demand_spec.rb

@@ -4,27 +4,25 @@ describe Solve::Demand do
   let(:solver) { double('solver') }
   let(:name) { "league" }
 
-  describe "ClassMethods" do
-    subject { Solve::Demand }
-
-    describe "::new" do
-      it "accepts a string for the constraint parameter" do
-        subject.new(solver, name, "= 0.0.1").constraint.to_s.should eql("= 0.0.1")
-      end
+  describe "#initialize" do
+    it "accepts a string for the constraint parameter" do
+      demand = Solve::Demand.new(solver, name, "= 0.0.1")
+      expect(demand.constraint.to_s).to eq("= 0.0.1")
+    end
 
-      it "accepts a Solve::Constraint for the constraint parameter" do
-        constraint = Solve::Constraint.new("= 0.0.1")
+    it "accepts a Semverse::Constraint for the constraint parameter" do
+      constraint = Semverse::Constraint.new("= 0.0.1")
+      demand = Solve::Demand.new(solver, name, constraint)
 
-        subject.new(solver, name, constraint).constraint.should eql(constraint)
-      end
+      expect(demand.constraint).to eq(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)
+    context "when no value for 'constraint' is given" do
+      it "uses a default of >= 0.0.0" do
+        demand = Solve::Demand.new(solver, name)
 
-          demand.constraint.operator.should eql(">=")
-          demand.constraint.version.to_s.should eql("0.0.0")
-        end
+        expect(demand.constraint.operator).to eq(">=")
+        expect(demand.constraint.version.to_s).to eq("0.0.0")
       end
     end
   end
@@ -32,59 +30,24 @@ describe Solve::Demand do
   let(:constraint) { "~> 1.0.0" }
   subject { Solve::Demand.new(solver, name, constraint) }
 
-  describe "#delete" do
-    context "given the demand is related to a solver" do
-      subject { Solve::Demand.new(solver, name, constraint) }
-
-      before(:each) do
-        solver.should_receive(:remove_demand).with(subject).and_return(subject)
-      end
-
-      it "notifies the solver that the demand should be removed" do
-        subject.delete
-      end
-
-      it "sets the solver attribute to nil" do
-        subject.delete
-
-        subject.solver.should be_nil
-      end
-
-      it "returns the instance of demand deleted from the solver" do
-        subject.delete.should eql(subject)
-      end
-    end
-
-    context "given the demand is not the member of a solver" do
-      subject { Solve::Demand.new(nil, name, constraint) }
-
-      it "returns nil" do
-        subject.delete.should be_nil
-      end
-    end
-  end
-
   describe "equality" do
     it "returns true when other is a Solve::Demand with the same name and constriant" do
       other = Solve::Demand.new(solver, name, constraint)
-
-      subject.should eql(other)
+      expect(subject).to eq(other)
     end
 
     it "returns false when other isn't a Solve::Demand" do
-      subject.should_not eql("chicken")
+      expect(subject).to_not eq("chicken")
     end
 
     it "returns false when other is a Solve::Demand with the same name but a different constraint" do
       other = Solve::Demand.new(solver, name, "< 3.4.5")
-
-      subject.should_not eql(other)
+      expect(subject).to_not eq(other)
     end
 
     it "returns false when other is a Solve::Demand with the same constraint but a different name" do
       other = Solve::Demand.new(solver, "chicken", constraint)
-
-      subject.should_not eql(other)
+      expect(subject).to_not eq(other)
     end
   end
 end

data/spec/unit/solve/dependency_spec.rb

@@ -1,18 +1,12 @@
 require 'spec_helper'
 
 describe Solve::Dependency do
-  describe "ClassMethods" do
-    subject { Solve::Dependency }
+  describe "#initialize" do
+    it "uses a default of >= 0.0.0" do
+      dep = Solve::Dependency.new(double("artifact"), "ntp")
 
-    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
+      expect(dep.constraint.operator).to eq(">=")
+      expect(dep.constraint.version.to_s).to eq("0.0.0")
     end
   end
 
@@ -22,43 +16,10 @@ describe Solve::Dependency do
 
   subject { Solve::Dependency.new(artifact, name, constraint) }
 
-  describe "#delete" do
-    context "given the dependency is a member of an artifact" do
-      subject { Solve::Dependency.new(artifact, name, constraint) }
-
-      before(:each) do
-        artifact.should_receive(:remove_dependency).with(subject).and_return(subject)
-      end
-
-      it "notifies the artifact that the dependency should be removed" do
-        subject.delete
-      end
-
-      it "sets the artifact attribute to nil" do
-        subject.delete
-
-        subject.artifact.should be_nil
-      end
-
-      it "returns the instance of dependency deleted from the artifact" do
-        subject.delete.should eql(subject)
-      end
-    end
-
-    context "given the dependency is not the member of an artifact" do
-      subject { Solve::Dependency.new(nil, name, constraint) }
-
-      it "returns nil" do
-        subject.delete.should be_nil
-      end
-    end
-  end
-
-  describe "#eql?" do
+  describe "#==" do
     it "returns true if the other object is an instance of Solve::Dependency with the same constraint and artifact" do
       other = Solve::Dependency.new(artifact, name, constraint)
-
-      subject.should eql(other)
+      expect(subject).to eq(other)
     end
   end
 end

data/spec/unit/solve/graph_spec.rb

@@ -1,267 +1,130 @@
-require 'spec_helper'
+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
+  describe "#artifact?" do
+    it "returns true if the given Solve::Artifact is a member of the collection" do
+      subject.artifact("nginx", "1.0.0")
+      expect(subject).to have_artifact("nginx", "1.0.0")
     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
+    it "returns false if the given Solve::Artifact is not a member of the collection" do
+      expect(subject).to_not have_artifact("apache", "1.0.0")
+      expect(subject).to_not have_artifact("nginx", "11.4.4")
     end
   end
 
-  subject { Solve::Graph.new }
-
-  describe "#artifacts" do
-    context "given a name and version argument" do
-      let(:name) { "nginx" }
-      let(:version) { "0.101.5" }
-
-      context "given the artifact of the given name and version does not exist" do
-        it "returns a Solve::Artifact" do
-          subject.artifacts(name, version).should be_a(Solve::Artifact)
-        end
-
-        it "the artifact has the given name" do
-          subject.artifacts(name, version).name.should eql(name)
-        end
-
-        it "the artifact has the given version" do
-          subject.artifacts(name, version).version.to_s.should eql(version)
-        end
-
-        it "adds an artifact to the artifacts collection" do
-          subject.artifacts(name, version)
+  describe "#find" do
+    before { subject.artifact("nginx", "1.0.0") }
 
-          subject.artifacts.should have(1).item
-        end
-
-        it "the artifact added matches the given name" do
-          subject.artifacts(name, version)
-
-          subject.artifacts[0].name.should eql(name)
-        end
-
-        it "the artifact added matches the given version" do
-          subject.artifacts(name, version)
+    it "returns an instance of artifact of the matching name and version" do
+      artifact = subject.find("nginx", "1.0.0")
 
-          subject.artifacts[0].version.to_s.should eql(version)
-        end
-      end
+      expect(artifact).to be_a(Solve::Artifact)
+      expect(artifact.name).to eq("nginx")
+      expect(artifact.version.to_s).to eq("1.0.0")
     end
 
-    context "given no arguments" do
-      it "returns an array" do
-        subject.artifacts.should be_a(Array)
-      end
-
-      it "returns an empty array if no artifacts have been accessed" do
-        subject.artifacts.should have(0).items
-      end
+    it "returns nil when the artifact does not exist" do
+      expect(subject.find("notthere", "1.0.0")).to be_nil
+    end
+  end
 
-      it "returns an array containing an artifact if one was accessed" do
-        subject.artifacts("nginx", "0.101.5")
+  describe "#artifact" do
+    let(:name)    { "nginx" }
+    let(:version) { "1.0.0" }
 
-        subject.artifacts.should have(1).item
+    context "given the artifact of the given name and version does not exist" do
+      it "returns a Solve::Artifact" do
+        expect(subject.artifact(name, version)).to be_a(Solve::Artifact)
       end
-    end
 
-    context "given an unexpected number of arguments" do
-      it "raises an ArgumentError if more than two are provided" do
-        lambda {
-          subject.artifacts(1, 2, 3)
-        }.should raise_error(ArgumentError, "Unexpected number of arguments. You gave: 3. Expected: 0 or 2.")
+      it "the artifact has the given name" do
+        artifact = subject.artifact(name, version)
+        expect(artifact.name).to eq(name)
       end
 
-      it "raises an ArgumentError if one argument is provided" do
-        lambda {
-          subject.artifacts(nil)
-        }.should raise_error(ArgumentError, "Unexpected number of arguments. You gave: 1. Expected: 0 or 2.")
+      it "the artifact has the given version" do
+        artifact = subject.artifact(name, version)
+        expect(artifact.version.to_s).to eq(version)
       end
 
-      it "raises an ArgumentError if one of the arguments provided is nil" do
-        lambda {
-          subject.artifacts("nginx", nil)
-        }.should raise_error(ArgumentError, 'A name and version must be specified. You gave: ["nginx", nil].')
+      it "adds an artifact to the artifacts collection" do
+        subject.artifact(name, version)
+        expect(subject).to have_artifact(name, version)
       end
     end
   end
 
-  describe "#get_artifact" do
-    before(:each) do
-      subject.artifacts("nginx", "1.0.0")
+  describe "#artifacts" do
+    it "returns an array" do
+      expect(subject.artifacts).to be_a(Array)
     end
 
-    it "returns an instance of artifact of the matching name and version" do
-      artifact = subject.get_artifact("nginx", "1.0.0")
-
-      artifact.should be_a(Solve::Artifact)
-      artifact.name.should eql("nginx")
-      artifact.version.to_s.should eql("1.0.0")
+    it "returns an empty array if no artifacts have been accessed" do
+      expect(subject.artifacts).to be_empty
     end
 
-    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 an array containing an artifact if one was accessed" do
+      subject.artifact("nginx", "1.0.0")
+      expect(subject.artifacts.size).to eq(1)
     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
+    before do
+      subject.artifact('nginx', '1.0.0')
+      subject.artifact('nginx', '2.0.0')
+      subject.artifact('nginx', '3.0.0')
+      subject.artifact('nginx', '4.0.0')
 
-    before(:each) do
-      subject.stub(:artifacts).and_return(artifacts)
+      subject.artifact('other', '1.0.0')
     end
 
     it "returns all the artifacts matching the given name" do
-      subject.versions("nginx").should have(5).items
-    end
-
-    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_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_artifact(artifact)
-
-      subject.should have_artifact(artifact.name, artifact.version)
-      subject.artifacts.should have(1).item
-    end
-
-    it "should not add the same artifact twice to the collection" do
-      subject.add_artifact(artifact)
-      subject.add_artifact(artifact)
-
-      subject.artifacts.should have(1).item
-    end
-  end
-
-  describe "#remove_artifact" do
-    let(:artifact) { Solve::Artifact.new(double('graph'), "nginx", "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
-      end
-
-      it "returns the removed Solve::Artifact" do
-        subject.remove_artifact(artifact).should eql(artifact)
-      end
+      expect(subject.versions("nginx").size).to eq(4)
     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
+    it "does not satisfy constraints if it is the default" do
+      constraint = Semverse::Constraint.new(Semverse::DEFAULT_CONSTRAINT.to_s)
+      expect(constraint).to_not receive(:satisfies?)
+      subject.versions("nginx")
     end
-  end
 
-  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_artifact(artifact)
-
-      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_artifact?(artifact.name, artifact.version).should be_false
+    it "returns only matching constraints if one is given" do
+      expect(subject.versions("nginx", ">= 3.0.0").size).to eq(2)
     end
   end
 
-  describe "eql?" do
-    subject do
+  describe "==" do
+    def make_graph
       graph = Solve::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.artifact("A" ,"1.0.0").depends("B", "1.0.0")
+      graph.artifact("A" ,"2.0.0").depends("C", "1.0.0")
       graph
     end
 
+    subject { make_graph }
+
     it "returns false if other isn't a Solve::Graph" do
-      subject.should_not be_eql("chicken")
+      expect(subject).to_not eq("chicken")
     end
 
-    it "returns true if other is a Solve::Graph with the same artifacts and dependencies" do
-      other = Solve::Graph.new
-      other.artifacts("A", "1.0.0").depends("B", "1.0.0")
-      other.artifacts("A", "2.0.0").depends("C", "1.0.0")
-
-      subject.should eql(other)
+    it "returns true if the other is the same" do
+      expect(subject).to eq(make_graph)
     end
 
-    it "returns false if the other is a Solve::Graph with the same artifacts but different dependencies" do
-      other = Solve::Graph.new
-      other.artifacts("A", "1.0.0")
-      other.artifacts("A", "2.0.0")
+    it "returns false if the other has the same artifacts but different dependencies" do
+      other = make_graph
+      other.artifact("A", "1.0.0").depends("D", "1.0.0")
 
-      subject.should_not eql(other)
+      expect(subject).to_not eq(other)
     end
 
-    it "returns false if the other is a Solve::Graph with the same dependencies but different artifacts" do
-      other = Solve::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")
+    it "returns false if the other has the same dependencies but different artifacts" do
+      other = make_graph
+      other.artifact("E", "1.0.0")
 
-      subject.should_not eql(other)
+      expect(subject).to_not eq(other)
     end
   end
 end