graph_spec.rb in solve-0.3.0

- old
+ new

@@ -1,8 +1,54 @@
 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
     context "given a name and version argument" do
       let(:name) { "nginx" }
@@ -76,198 +122,108 @@
         }.should raise_error(ArgumentError, 'A name and version must be specified. You gave: ["nginx", nil].')
       end
     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
+  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
 
-    it "returns false if the given Solve::Artifact is not a member of the collection" do
-      subject.has_artifact?(artifact).should be_false
+    before(:each) do
+      subject.stub(:artifacts).and_return(artifacts)
     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
+    it "returns all the artifacts matching the given name" do
+      subject.versions("nginx").should have(5).items
     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")
+    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
-
-    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
-    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"].')
-      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