rdf-spec 1.0.5 → 1.0.6

data/lib/rdf/spec.rb

@@ -46,5 +46,25 @@ module RDF
   module Spec
     autoload :Matchers, 'rdf/spec/matchers'
     autoload :VERSION,  'rdf/spec/version'
+    TRIPLES_FILE = File.expand_path("../../../etc/triples.nt", __FILE__)
+    QUADS_FILE = File.expand_path("../../../etc/quads.nq", __FILE__)
+
+    ##
+    # Return quads for tests
+    #
+    # @return [Array<RDF::Statement>]
+    def self.quads
+      require 'rdf/nquads'
+      (@quads ||=  RDF::NQuads::Reader.new(File.open(QUADS_FILE)).to_a).dup
+    end
+
+    ##
+    # Return triples for tests
+    #
+    # @return [Array<RDF::Statement>]
+    def self.triples
+      require 'rdf/ntriples'
+      (@triples ||=  RDF::NTriples::Reader.new(File.open(TRIPLES_FILE)).to_a).dup
+    end
   end # Spec
 end # RDF

data/lib/rdf/spec/countable.rb

@@ -7,43 +7,38 @@ module RDF_Countable
   before :each do
     raise '+@countable+ must be defined in a before(:each) block' unless instance_variable_get('@countable')
 
-    @filename   = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'etc', 'doap.nt'))
-    @statements = RDF::NTriples::Reader.new(File.open(@filename)).to_a
+    @statements = RDF::Spec.quads
 
     if @countable.empty?
-      if @countable.respond_to?(:<<)
+      if @countable.respond_to?(:<<) && (@countable.writable? rescue true)
         @statements.each { |statement| @countable << statement }
       else
-        raise "+@countable+ must respond to #<< or be pre-populated with the statements in #{@filename} in a before(:each) block"
+        raise "+@countable+ must respond to #<< or be pre-populated with the statements in #{RDF::Spec::TRIPLES_FILE} in a before(:each) block"
       end
     end
   end
 
   describe RDF::Countable do
-    it "responds to #empty?" do
-      @countable.should respond_to(:empty?)
+    subject {@countable}
+
+    it {should respond_to(:empty?)}
+    it {should_not be_empty}
+    it {should respond_to(:count)}
+    its(:count) {should == @statements.size}
+    it {should respond_to(:size)}
+    its(:size) {should == @statements.size}
+
+    context "when empty" do
+      subject {[].extend(RDF::Countable)}
+      it {should be_empty}
+      its(:count) {should == 0}
+      its(:size) {should == 0}
     end
 
-    it "responds to #count and #size" do
-      @countable.should respond_to(:count, :size)
-    end
-
-    it "implements #empty?" do
-      ([].extend(RDF::Countable)).empty?.should be_true
-      ([42].extend(RDF::Countable)).empty?.should be_false
-      @countable.empty?.should be_false
-    end
-
-    it "implements #count and #size" do
-      %w(count size).each do |method|
-        @countable.send(method).should >= @statements.size
-      end
-    end
-
-    it "returns countable enumerators" do
-      @countable.to_enum.should be_countable
-      @countable.enum_for.should be_countable
-      @countable.enum_for(:each).should be_countable
+    its(:to_enum) {should be_countable}
+    its(:enum_for) {should be_countable}
+    it "#enum_for(:each)" do
+      subject.enum_for(:each).should be_countable
     end
   end
 end

data/lib/rdf/spec/durable.rb

@@ -23,29 +23,25 @@ module RDF_Durable
 
   before :each do
     raise '+@load_durable+ must be defined in a before(:each) block' unless instance_variable_get('@load_durable')
-    # RDF::Queryable cares about the contents of this file too much to let someone set it
-    @filename   = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'etc', 'doap.nt'))
   end
 
   describe RDF::Durable do
+    subject {@load_durable.call}
+    it {should respond_to(:durable?)}
     it "should support #durable?" do
-      @load_durable.call.should respond_to(:durable?)
-      [true,false].member?(@load_durable.call.durable?).should be_true
+      [true,false].member?(subject.durable?).should be_true
     end
 
+    it {should respond_to(:nondurable?)}
     it "should support #nondurable?" do
-      @load_durable.call.should respond_to(:nondurable?)
       [true,false].member?(@load_durable.call.nondurable?).should be_true
     end
-
-    it "should not be both durable and nondurable" do
-      @load_durable.call.nondurable?.should_not == @load_durable.call.durable?
-    end
+    its(:nondurable?) {should_not == subject.durable?}
 
     it "should save contents between instantiations" do
-      if @load_durable.call.durable?
-        @load_durable.call.load(@filename)
-        @load_durable.call.count.should == File.readlines(@filename).size
+      if subject.durable?
+       subject.load(RDF::Spec::TRIPLES_FILE)
+       subject.count.should == File.readlines(RDF::Spec::TRIPLES_FILE).size
       end
     end
   end

data/lib/rdf/spec/enumerable.rb

@@ -7,444 +7,417 @@ module RDF_Enumerable
   before :each do
     raise '+@enumerable+ must be defined in a before(:each) block' unless instance_variable_get('@enumerable')
 
-    @filename   = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'etc', 'doap.nt'))
-    @statements ||= RDF::NTriples::Reader.new(File.open(@filename)).to_a
+    @statements ||= RDF::Spec.quads
 
     if @enumerable.empty?
-      if @enumerable.respond_to?(:<<)
+      if @enumerable.respond_to?(:<<) && (@enumerable.writable? rescue true)
         @statements.each { |statement| @enumerable << statement }
       else
-        raise "@enumerable must respond to #<< or be pre-populated with the statements in #{@filename} in a before(:each) block"
+        raise "@enumerable must respond to #<< or be pre-populated with the statements in #{RDF::Spec::TRIPLES_FILE} in a before(:each) block"
       end
     end
 
-    @supports_context = @enumerable.respond_to?(:supports?) && @enumerable.supports?(:context)
+    @supports_context = @enumerable.supports?(:context) rescue true
   end
 
   describe RDF::Enumerable do
     subject {@enumerable}
     it {should respond_to(:supports?)}
-    it {should respond_to(:count)}
-    it {should respond_to(:size)}
-
-    it {should respond_to(:statements)}
-    it {should respond_to(:has_statement?)}
-    it {should respond_to(:each_statement)}
-    it {should respond_to(:enum_statement)}
-
-    it {should respond_to(:triples)}
-    it {should respond_to(:has_triple?)}
-    it {should respond_to(:each_triple)}
-    it {should respond_to(:enum_triple)}
-
-    it {should respond_to(:quads)}
-    it {should respond_to(:has_quad?)}
-    it {should respond_to(:each_quad)}
-    it {should respond_to(:enum_quad)}
-
-    it {should respond_to(:subjects)}
-    it {should respond_to(:has_subject?)}
-    it {should respond_to(:each_subject)}
-    it {should respond_to(:enum_subject)}
-
-    it {should respond_to(:predicates)}
-    it {should respond_to(:has_predicate?)}
-    it {should respond_to(:each_predicate)}
-    it {should respond_to(:enum_predicate)}
-
-    it {should respond_to(:objects)}
-    it {should respond_to(:has_object?)}
-    it {should respond_to(:each_object)}
-    it {should respond_to(:enum_object)}
-
-    it {should respond_to(:contexts)}
-    it {should respond_to(:has_context?)}
-    it {should respond_to(:each_context)}
-    it {should respond_to(:enum_context)}
-
-    it {should respond_to(:each_graph)}
-    it {should respond_to(:enum_graph)}
-
-    it {should respond_to(:to_hash)}
-    it {should respond_to(:dump)}
-
-    it {should be_valid}
-    it {should_not be_empty}
-    its(:size) {should == @statements.size}
-    its(:count) {should == @statements.size}
-
-    it "returns is_invalid if any statement is invalid" do
-      if subject.respond_to?(:<<)
-        s = RDF::Statement.from([nil, nil, nil])
-        s.should_not be_valid
-        subject << s
-        subject.should_not be_valid
+
+    describe "valid?" do
+      it {should be_valid}
+      
+      it "returns false if any statement is invalid" do
+        if subject.respond_to?(:<<) && (subject.writable? rescue true)
+          s = RDF::Statement.from([nil, nil, nil])
+          s.should_not be_valid
+          subject << s
+          subject.should_not be_valid
+        else
+          pending("can't add statement to immutable enumerable")
+        end
       end
     end
 
-    context "when extending an empty array" do
-      subject {[].extend(RDF::Enumerable)}
-      it {should be_empty}
-      its(:size) {should == 0}
-      its(:count) {should == 0}
+    context "when counting statements" do
+      it {should respond_to(:empty?)}
+      it {should_not be_empty}
+      it {should respond_to(:count)}
+      its(:count) {should == @statements.size}
+      it {should respond_to(:size)}
+      its(:size) {should == @statements.size}
+
+      context "and empty" do
+        subject {[].extend(RDF::Enumerable)}
+        it {should be_empty}
+        its(:count) {should == 0}
+        its(:size) {should == 0}
+      end
     end
 
-    describe "#statements" do
-      subject {@enumerable.statements}
-      it {should be_an_enumerator}
-      its(:size) {should == @statements.size}
-      it "should iterrate statements" do
-        subject.statements.each { |statement| statement.should be_a_statement }
+    context "when enumerating statements" do
+      it {should respond_to(:statements)}
+      its(:statements) {should be_an_enumerator}
+
+      context "#statements" do
+        specify {subject.statements.to_a.size.should == @statements.size}
+        specify {subject.statements.each { |statement| statement.should be_a_statement }}
       end
-      it "should have all statements" do
-        @statements.each do |statement|
-          subject.should have_statement(statement)
+
+      it {should respond_to(:has_statement?)}
+      context "#has_statement?" do
+        let(:unknown_statement) {RDF::Statement.new(RDF::Node.new, RDF::URI.new("http://example.org/unknown"), RDF::Node.new)}
+        it "should have all statements" do
+          # Don't check for BNodes, as equivalence depends on their being exactly the same, not just the same identifier. If subject is loaded separately, these won't match.
+          @statements.reject {|s| s.to_a.any?(&:node?)}.each do |statement|
+            subject.has_statement?(statement).should be_true
+          end
         end
-      end
 
-      it "should not have statements in a different context" do
-        if @supports_context
-          context = RDF::URI.new("urn:context:1")
-          @statements.each do |statement|
-            s = statement.dup
-            s.context = context
-            subject.should_not have_statement(s)
+        it "does not have statement in different context" do
+          if @supports_context
+            context = RDF::URI.new("urn:context:1")
+            @statements.each do |statement|
+              s = statement.dup
+              s.context = context
+              subject.has_statement?(s).should be_false
+            end
           end
         end
+
+        it "does not have an unknown statement" do
+          subject.has_statement?(unknown_statement).should be_false
+        end
       end
 
-      it "should not have an unknown statement" do
-        unknown_statement = RDF::Statement.new(RDF::Node.new, RDF::URI.new("http://example.org/unknown"), RDF::Node.new)
-        subject.has_statement?(unknown_statement).should be_false
+      it {should respond_to(:each_statement)}
+      its(:each_statement) {should be_an_enumerator}
+      it "should implement #each_statement" do
+        subject.each_statement { |statement| statement.should be_a_statement }
       end
-    end
 
-    describe "#has_statement?" do
-      it "has all statements" do
-        @statements.each do |statement|
-          subject.should have_statement(statement)
+      it {should respond_to(:enum_statement)}
+      its(:enum_statement) {should be_an_enumerator}
+      its(:enum_statement) {should be_countable}
+      its(:enum_statement) {should be_enumerable}
+      its(:enum_statement) {should be_queryable}
+      context "#enum_statement" do
+        it "should enumerate all statements" do
+          subject.enum_statement.to_a.should == @enumerable.each_statement.to_a
         end
       end
     end
 
-    describe "#each_statement" do
-      subject {@enumerable.each_statement}
-      it {should be_an_enumerator}
-      it "should all be statements" do
-        subject { |statement| statement.should be_a_statement }
-      end
-    end
+    context "when enumerating triples" do
+      it {should respond_to(:triples)}
+      it {should respond_to(:has_triple?)}
+      it {should respond_to(:each_triple)}
+      it {should respond_to(:enum_triple)}
 
-    describe "#enum_statement" do
-      subject {@enumerable.enum_statement}
-      it {should be_an_enumerator}
-      it {should be_countable}
-      it {should be_enumerable}
-      it {should be_queryable}
-      it "should all be statements" do
-        subject { |statement| statement.should be_a_statement }
-      end
-      it "should have all statements" do
-        subject.to_a.should =~ @statements.to_a
+      its(:triples) {should be_an_enumerator}
+      context "#triples" do
+        specify {subject.triples.to_a.size.should == @statements.size}
+        specify {subject.triples.each { |triple| triple.should be_a_triple }}
       end
-    end
 
-    describe "#triples" do
-      subject {@enumerable.triples}
-      it {should be_an_enumerator}
-      it {subject.to_a.size.should == @statements.size}
-      it "should all be triples" do
-        subject.each {|triple| triple.should be_a_triple}
+      context "#has_triple?" do
+        specify do
+          @statements.each do |statement|
+            subject.has_triple?(statement.to_triple).should be_true
+          end
+        end
       end
-    end
 
-    describe "#has_triple?" do
-      it "has all triples" do
-        @statements.each do |statement|
-          subject.should have_triple(statement.to_triple)
-        end
+      its(:each_triple) {should be_an_enumerator}
+      context "#each_triple" do
+        specify {subject.each_triple { |*triple| triple.should be_a_triple }}
       end
-    end
 
-    describe "#each_triple" do
-      subject {@enumerable.each_triple}
-      it {should be_an_enumerator}
-      it "has all triples" do
-        subject do |*triple|
-          triple.should be_a_triple
+      its(:enum_triple) {should be_an_enumerator}
+      its(:enum_triple) {should be_countable}
+      context "#enum_triple" do
+        it "should enumerate all triples" do
+          subject.enum_triple.to_a.should == @enumerable.each_triple.to_a
         end
       end
     end
 
-    describe "#enum_triple" do
-      subject {@enumerable.enum_triple}
-      it {should be_an_enumerator}
-      it {should be_countable}
-      it "should have all triples" do
-        subject.to_a.should =~ @enumerable.each_triple.to_a
-      end
-    end
+    context "when enumerating quads" do
+      it {should respond_to(:quads)}
+      it {should respond_to(:has_quad?)}
+      it {should respond_to(:each_quad)}
+      it {should respond_to(:enum_quad)}
 
-    describe "#quads" do
-      subject {@enumerable.quads}
-      it {should be_an_enumerator}
-      it {subject.to_a.size.should == @statements.size}
-      it "should all be quads" do
-        subject.each {|quad| quad.should be_a_quad}
+      its(:quads) {should be_an_enumerator}
+      context "#quads" do
+        specify {subject.quads.to_a.size.should == @statements.size}
+        specify {subject.quads.each { |quad| quad.should be_a_quad }}
       end
-    end
 
-    describe "#has_quad?" do
-      it "has all quads" do
-        @statements.each do |statement|
-          subject.should have_quad(statement.to_quad)
+      context "#has_quad?" do
+        specify do
+          if @supports_context
+            @statements.each do |statement|
+              subject.has_quad?(statement.to_quad).should be_true
+            end
+          end
         end
       end
-    end
 
-    describe "#each_quad" do
-      subject {@enumerable.each_quad}
-      it {should be_an_enumerator}
-      it "has all quads" do
-        subject do |*quad|
-          quad.should be_a_quad
-        end
+      its(:each_quad) {should be_an_enumerator}
+      context "#each_quad" do
+        specify {subject.each_quad {|*quad| quad.should be_a_quad }}
       end
-    end
 
-    describe "#enum_quad" do
-      subject {@enumerable.enum_quad}
-      it {should be_an_enumerator}
-      it {should be_countable}
-      it "should have all triples" do
-        subject.to_a.should =~ @enumerable.each_quad.to_a
+      its(:enum_quad) {should be_an_enumerator}
+      its(:enum_quad) {should be_countable}
+      context "#enum_quad" do
+        it "should enumerate all quads" do
+          subject.enum_quad.to_a.should == @enumerable.each_quad.to_a
+        end
       end
     end
 
-    describe "#subjects" do
-      subject {@enumerable.subjects}
-      specify {subject.should be_an_enumerator}
-      specify {subject.each { |value| value.should be_a_resource }}
-      context ":unique => false" do
-        subject {@enumerable.subjects(:unique => false)}
+    context "when enumerating subjects" do
+      it {should respond_to(:subjects)}
+      it {should respond_to(:has_subject?)}
+      it {should respond_to(:each_subject)}
+      it {should respond_to(:enum_subject)}
+
+      its(:subjects) {should be_an_enumerator}
+      context "#subjects" do
+        subject {@enumerable.subjects}
         specify {subject.should be_an_enumerator}
         specify {subject.each { |value| value.should be_a_resource }}
+        context ":unique => false" do
+          subject {@enumerable.subjects(:unique => false)}
+          specify {subject.should be_an_enumerator}
+          specify {subject.each { |value| value.should be_a_resource }}
+        end
       end
-    end
 
-    describe "#has_subject?" do
-      it "has all subjects" do
-        checked = []
-        @statements.each do |statement|
-          subject.should have_subject(statement.subject) unless checked.include?(statement.subject)
-          checked << statement.subject
+      context "#has_subject?" do
+        specify do
+          checked = []
+          @statements.each do |statement|
+            @enumerable.has_subject?(statement.subject).should be_true unless checked.include?(statement.subject)
+            checked << statement.subject
+          end
+          uri = RDF::URI.new('http://example.org/does/not/have/this/uri')
+          @enumerable.has_subject?(uri).should be_false
         end
-        uri = RDF::URI.new('http://example.org/does/not/have/this/uri')
-        subject.should_not have_subject(uri)
       end
-    end
 
-    describe "#each_subject" do
-      subject {@enumerable.each_subject}
-      it {should be_an_enumerator}
-      it "has all subjects" do
-        subjects = @statements.map { |s| s.subject }.uniq
-        subject.to_a.size.should == subjects.size
-        subject do |term|
-          term.should be_a_term
-          subjects.should include(term)
-        end
+      its(:each_subject) {should be_an_enumerator}
+      context "#each_subject" do
+        let(:subjects) {@statements.map { |s| s.subject }.uniq}
+        specify {subject.each_subject.to_a.size.should == subjects.size}
+        specify {subject.each_subject {|value| value.should be_a_resource}}
+        specify {subject.each_subject {|value| subjects.should include(value)}}
       end
-    end
 
-    describe "#enum_subject" do
-      subject {@enumerable.enum_subject}
-      it {should be_an_enumerator}
-      it {should be_countable}
-      it "should have all subjects" do
-        subject.to_a.should =~ @enumerable.each_subject.to_a
+      its(:enum_subject) {should be_an_enumerator}
+      its(:enum_subject) {should be_countable}
+      context "#enum_subject" do
+        it "should enumerate all subjects" do
+          subject.enum_subject.to_a.should == @enumerable.each_subject.to_a
+        end
       end
     end
 
-    describe "#predicates" do
-      subject {@enumerable.predicates}
-      specify {subject.should be_an_enumerator}
-      specify {subject.each { |value| value.should be_a_resource }}
-      context ":unique => false" do
-        subject {@enumerable.predicates(:unique => false)}
+    context "when enumerating predicates" do
+      it {should respond_to(:predicates)}
+      it {should respond_to(:has_predicate?)}
+      it {should respond_to(:each_predicate)}
+      it {should respond_to(:enum_predicate)}
+
+      its(:predicates) {should be_an_enumerator}
+      context "#predicates" do
+        subject {@enumerable.predicates}
         specify {subject.should be_an_enumerator}
-        specify {subject.each { |value| value.should be_a_resource }}
+        specify {subject.each { |value| value.should be_a_uri }}
+        context ":unique => false" do
+          subject {@enumerable.predicates(:unique => false)}
+          specify {subject.should be_an_enumerator}
+          specify {subject.each { |value| value.should be_a_uri }}
+        end
       end
-    end
 
-    describe "#has_predicate?" do
-      it "has all predicates" do
-        checked = []
-        @statements.each do |statement|
-          subject.should have_predicate(statement.predicate) unless checked.include?(statement.predicate)
-          checked << statement.predicate
+      context "#has_predicate?" do
+        specify do
+          checked = []
+          @statements.each do |statement|
+            @enumerable.has_predicate?(statement.predicate).should be_true unless checked.include?(statement.predicate)
+            checked << statement.predicate
+          end
+          uri = RDF::URI.new('http://example.org/does/not/have/this/uri')
+          @enumerable.has_predicate?(uri).should be_false
         end
-        uri = RDF::URI.new('http://example.org/does/not/have/this/uri')
-        subject.should_not have_predicate(uri)
       end
-    end
 
-    describe "#each_predicate" do
-      subject {@enumerable.each_predicate}
-      it {should be_an_enumerator}
-      it "has all predicates" do
-        predicates = @statements.map { |s| s.predicate }.uniq
-        subject.to_a.size.should == predicates.size
-        subject do |term|
-          term.should be_a_term
-          predicates.should include(term)
-        end
+      its(:each_predicate) {should be_an_enumerator}
+      context "#each_predicate" do
+        let(:predicates) {@statements.map { |s| s.predicate }.uniq}
+        specify {subject.each_predicate.to_a.size.should == predicates.size}
+        specify {subject.each_predicate {|value| value.should be_a_uri}}
+        specify {subject.each_predicate {|value| predicates.should include(value)}}
       end
-    end
 
-    describe "#enum_predicate" do
-      subject {@enumerable.enum_predicate}
-      it {should be_an_enumerator}
-      it {should be_countable}
-      it "should have all predicates" do
-        subject.to_a.should =~ @enumerable.each_predicate.to_a
+      its(:enum_predicate) {should be_an_enumerator}
+      its(:enum_predicate) {should be_countable}
+      context "#enum_predicate" do
+        it "should enumerate all predicates" do
+          subject.enum_predicate.to_a.should == @enumerable.each_predicate.to_a
+        end
       end
     end
 
-    describe "#objects" do
-      subject {@enumerable.objects}
-      specify {subject.should be_an_enumerator}
-      specify {subject.each { |value| value.should be_a_term }}
-      context ":unique => false" do
-        subject {@enumerable.objects(:unique => false)}
+    context "when enumerating objects" do
+      it {should respond_to(:objects)}
+      it {should respond_to(:has_object?)}
+      it {should respond_to(:each_object)}
+      it {should respond_to(:enum_object)}
+
+      its(:objects) {should be_an_enumerator}
+      context "#objects" do
+        subject {@enumerable.objects}
         specify {subject.should be_an_enumerator}
         specify {subject.each { |value| value.should be_a_term }}
+        context ":unique => false" do
+          subject {@enumerable.objects(:unique => false)}
+          specify {subject.should be_an_enumerator}
+          specify {subject.each { |value| value.should be_a_term }}
+        end
       end
-    end
 
-    describe "#has_object?" do
-      it "has all objects" do
-        checked = []
-        @statements.each do |statement|
-          subject.should have_object(statement.object) unless checked.include?(statement.object)
-          checked << statement.object
+      context "#has_object?" do
+        specify do
+          checked = []
+          @statements.each do |statement|
+            @enumerable.has_object?(statement.object).should be_true unless checked.include?(statement.object)
+            checked << statement.object
+          end
+          uri = RDF::URI.new('http://example.org/does/not/have/this/uri')
+          @enumerable.has_object?(uri).should be_false
         end
-        uri = RDF::URI.new('http://example.org/does/not/have/this/uri')
-        subject.should_not have_object(uri)
       end
-    end
 
-    describe "#each_object" do
-      subject {@enumerable.each_object}
-      it {should be_an_enumerator}
-      it "has all objects" do
-        objects = @statements.map { |s| s.object }.uniq
-        subject.to_a.size.should == objects.size
-        subject do |term|
-          term.should be_a_term
-          objects.should include(term)
-        end
+      its(:each_object) {should be_an_enumerator}
+      context "#each_object" do
+        let(:objects) {@statements.map { |s| s.object }.uniq}
+        specify {subject.each_object.to_a.size.should == objects.size}
+        specify {subject.each_object {|value| value.should be_a_term}}
+        specify {subject.each_object {|value| objects.should include(value)}}
       end
-    end
 
-    describe "#enum_object" do
-      subject {@enumerable.enum_object}
-      it {should be_an_enumerator}
-      it {should be_countable}
-      it "should have all objects" do
-        subject.to_a.should =~ @enumerable.each_object.to_a
+      its(:enum_object) {should be_an_enumerator}
+      its(:enum_object) {should be_countable}
+      context "#enum_object" do
+        it "should enumerate all objects" do
+          subject.enum_object.to_a.should == @enumerable.each_object.to_a
+        end
       end
     end
 
-    describe "#contexts" do
-      subject {@enumerable.contexts}
-      specify {subject.should be_an_enumerator}
-      specify {subject.each { |value| value.should be_a_resource }}
-      context ":unique => false" do
-        subject {@enumerable.contexts(:unique => false)}
+    context "when enumerating contexts" do
+      it {should respond_to(:contexts)}
+      it {should respond_to(:has_context?)}
+      it {should respond_to(:each_context)}
+      it {should respond_to(:enum_context)}
+
+      its(:contexts) {should be_an_enumerator}
+      describe "#contexts" do
+        subject {@enumerable.contexts}
         specify {subject.should be_an_enumerator}
-        specify {subject.each { |value| value.should be_a_resource }}
+        it "values should be resources" do
+          subject.each { |value| value.should be_a_resource }
+        end
+        context ":unique => false" do
+          subject {@enumerable.contexts(:unique => false)}
+          specify {subject.should be_an_enumerator}
+          it "values should be resources" do
+            subject.each { |value| value.should be_a_resource }
+          end
+        end
       end
-    end
 
-    describe "#has_context?" do
-      it "has all contexts" do
-        checked = []
-        @statements.each do |statement|
-          subject.should have_context(statement.context) if statement.has_context?
+      it "should implement #has_context?" do
+        if @supports_context
+          @statements.each do |statement|
+            if statement.has_context?
+              @enumerable.has_context?(statement.context).should be_true
+            end
+          end
+          uri = RDF::URI.new('http://example.org/does/not/have/this/uri')
+          @enumerable.has_context?(uri).should be_false
         end
-        uri = RDF::URI.new('http://example.org/does/not/have/this/uri')
-        subject.should_not have_context(uri)
       end
-    end
 
-    describe "#each_context" do
-      subject {@enumerable.each_context}
-      it {should be_an_enumerator}
-      it "has all contexts" do
-        contexts = @statements.map { |s| s.context }.uniq
-        contexts.delete nil
-        subject.to_a.size.should == contexts.size
-        subject do |term|
-          term.should be_a_resource
-          contexts.should include(term)
+      its(:each_context) {should be_an_enumerator}
+      context "#each_context" do
+        let(:contexts) {@statements.map { |s| s.context }.uniq.compact}
+        it "has appropriate number of contexts" do
+          if @supports_context
+            subject.each_context.to_a.size.should == contexts.size
+          end
+        end
+        it "values should be resources" do
+          subject.each_context {|value| value.should be_a_resource}
+        end
+        it "should have all contexts" do
+          subject.each_context {|value| contexts.should include(value)}
         end
       end
-    end
 
-    describe "#enum_context" do
-      subject {@enumerable.enum_context}
-      it {should be_an_enumerator}
-      it {should be_countable}
-      it "should have all contexts" do
-        subject.to_a.should =~ @enumerable.each_context.to_a
+      its(:enum_context) {should be_an_enumerator}
+      its(:enum_context) {should be_countable}
+      context "#enum_context" do
+        it "should enumerate all contexts" do
+          subject.enum_context.to_a.should == @enumerable.each_context.to_a
+        end
       end
     end
 
-    describe "#each_graph" do
-      subject {@enumerable.each_graph}
-      it {should be_an_enumerator}
-      it "has all graphs" do
-        subject {|value| value.should be_a_graph}
+    context "when enumerating graphs" do
+      it {should respond_to(:each_graph)}
+      it {should respond_to(:enum_graph)}
+
+      describe "#each_graph" do
+        subject {@enumerable.each_graph}
+        it {should be_an_enumerator}
+        specify {subject.each { |value| value.should be_a_graph }}
       end
-    end
 
-    describe "#enum_graph" do
-      subject {@enumerable.enum_graph}
-      it {should be_an_enumerator}
-      it {should be_countable}
-      it "should have all graphs" do
-        subject.to_a.should =~ @enumerable.each_graph.to_a
+      describe "#enum_graph" do
+        subject {@enumerable.enum_graph}
+        it {subject.should be_an_enumerator}
+        it {subject.should be_countable}
+        it "enumerates the same as #each_graph" do
+          subject.to_a.should == @enumerable.each_graph.to_a
+        end
       end
     end
 
-    describe "#to_hash" do
-      subject {@enumerable.to_hash}
-      it {should be_a(Hash)}
-      it "should have keys for each subject" do
-        subject.keys.size.should == @enumerable.subjects.to_a.size
+    context "when converting" do
+      it {should respond_to(:to_hash)}
+      its(:to_hash) {should be_instance_of(Hash)}
+      context "#to_hash" do
+        it "should have as many keys as subjects" do
+          subject.to_hash.keys.size.should == @enumerable.subjects.to_a.size
+        end
       end
     end
   
-    describe "#dump" do
-      subject {@enumerable.dump(:ntriples)}
-      it "has N-Triples representation" do
-        subject.should == RDF::NTriples::Writer.buffer() {|w| w << @enumerable}
+    context "when dumping" do
+      it {should respond_to(:dump)}
+    
+      it "should implement #dump" do
+        subject.dump(:ntriples).should == RDF::NTriples::Writer.buffer() {|w| w << @enumerable}
       end
-      
+    
       it "raises error on unknown format" do
-        lambda {@enumerable.dump(:foobar)}.should raise_error(RDF::WriterError, /No writer found/)
+        lambda {subject.dump(:foobar)}.should raise_error(RDF::WriterError, /No writer found/)
       end
     end
-
-    context "#to_{writer}" do
-      it "should write to a writer" do
-        writer = mock("writer")
-        writer.should_receive(:buffer)
-        RDF::Writer.should_receive(:for).with(:a_writer).and_return(writer)
-        subject.send(:to_a_writer)
-      end
-    end
-
   end
 end