artifact_spec.rb in solve-0.3.0

- old
+ new
@@ -11,87 +11,111 @@
 
   let(:name) { "league" }
   let(:version) { "1.0.0" }
   subject { Solve::Artifact.new(graph, name, version) }
 
-  describe "#dependencies" do
-    context "given a name and constraint argument" do
-      let(:name) { "nginx" }
-      let(:constraint) { "~> 0.101.5" }
+  describe "equality" do
+    context "given an artifact with the same name and version" do
+      let(:one) { Solve::Artifact.new(graph, "riot", "1.0.0") }
+      let(:two) { Solve::Artifact.new(graph, "riot", "1.0.0") }
 
-      context "given the dependency of the given name and constraint does not exist" do
-        it "returns a Solve::Artifact" do
-          subject.dependencies(name, constraint).should be_a(Solve::Dependency)
-        end
+      it "is equal" do
+        one.should be_eql(two)
+      end
+    end
 
-        it "the dependency has the given name" do
-          subject.dependencies(name, constraint).name.should eql(name)
-        end
+    context "given an artifact with the same name but different version" do
+      let(:one) { Solve::Artifact.new(graph, "riot", "1.0.0") }
+      let(:two) { Solve::Artifact.new(graph, "riot", "2.0.0") }
 
-        it "the dependency has the given constraint" do
-          subject.dependencies(name, constraint).constraint.to_s.should eql(constraint)
-        end
+      it "is not equal" do
+        one.should_not be_eql(two)
+      end
+    end
 
-        it "adds an dependency to the dependency collection" do
-          subject.dependencies(name, constraint)
+    context "given an artifact with the same version but different name" do
+      let(:one) { Solve::Artifact.new(graph, "riot", "1.0.0") }
+      let(:two) { Solve::Artifact.new(graph, "league", "1.0.0") }
 
-          subject.dependencies.should have(1).item
-        end
+      it "is not equal" do
+        one.should_not be_eql(two)
+      end
+    end
+  end
 
-        it "the dependency added matches the given name" do
-          subject.dependencies(name, constraint)
+  describe "sorting" do
+    let(:one) { Solve::Artifact.new(graph, "riot", "1.0.0") }
+    let(:two) { Solve::Artifact.new(graph, "riot", "2.0.0") }
+    let(:three) { Solve::Artifact.new(graph, "riot", "3.0.0") }
 
-          subject.dependencies[0].name.should eql(name)
-        end
+    let(:artifacts) do
+      [
+        one,
+        two,
+        three
+      ].shuffle
+    end
 
-        it "the dependency added matches the given constraint" do
-          subject.dependencies(name, constraint)
+    it "orders artifacts by their version number" do
+      sorted = artifacts.sort
 
-          subject.dependencies[0].constraint.to_s.should eql(constraint)
-        end
-      end
+      sorted[0].should eql(one)
+      sorted[1].should eql(two)
+      sorted[2].should eql(three)
     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 empty array if no dependencies have been accessed" do
         subject.dependencies.should have(0).items
       end
+    end
+  end
 
-      it "returns an array containing an dependency if one was accessed" do
-        subject.dependencies("nginx", "~> 0.101.5")
+  describe "#depends" do
+    context "given a name and constraint argument" do
+      let(:name) { "nginx" }
+      let(:constraint) { "~> 0.101.5" }
 
-        subject.dependencies.should have(1).item
+      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)
+        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)
+        end
       end
     end
 
     context "given only a name argument" do
-      it "returns an array containing a match all constraint (>= 0.0.0)" do
-        subject.dependencies("nginx").constraint.to_s.should eql(">= 0.0.0")
+      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
 
-    context "given an unexpected number of arguments" do
-      it "raises an ArgumentError if more than two are provided" do
-        lambda {
-          subject.dependencies(1, 2, 3)
-        }.should raise_error(ArgumentError, "Unexpected number of arguments. You gave: 3. Expected: 2 or less.")
-      end
+  describe "::get_dependency" do
+    before(:each) { subject.depends("nginx", "~> 1.2.3") }
 
-      it "raises an ArgumentError if a name argument is provided but it is nil" do
-        lambda {
-          subject.dependencies(nil)
-        }.should raise_error(ArgumentError, "A name must be specified. You gave: [nil].")
-      end
+    it "returns an instance of Solve::Dependency matching the given name and constraint" do
+      dependency = subject.get_dependency("nginx", "~> 1.2.3")
 
-      it "raises an ArgumentError if a name and constraint argument are provided but the name is nil" do
-        lambda {
-          subject.dependencies(nil, "= 1.0.0")
-        }.should raise_error(ArgumentError, 'A name must be specified. You gave: [nil, "= 1.0.0"].')
-      end
+      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