Change skips to conditionals to avoid output clutter.

Author: gkellogg

lib/rdf/spec/enumerable.rb

@@ -48,8 +48,6 @@
         else
           expect {subject.valid?}.to raise_error(NotImplementedError)
         end
-      else
-        skip("can't add statement to immutable enumerable")
       end
     end
   end

lib/rdf/spec/mutable.rb

@@ -48,34 +48,35 @@
       end
 
       it "is_expected.to accept a string filename argument" do
-        skip("mutability") unless subject.mutable?
-        expect { subject.load(RDF::Spec::TRIPLES_FILE) }.not_to raise_error
+        expect { subject.load(RDF::Spec::TRIPLES_FILE) }.not_to raise_error if subject.mutable?
       end
 
       it "is_expected.to accept an optional hash argument" do
-        skip("mutability") unless subject.mutable?
-        expect { subject.load(RDF::Spec::TRIPLES_FILE, {}) }.not_to raise_error
+        expect { subject.load(RDF::Spec::TRIPLES_FILE, {}) }.not_to raise_error if subject.mutable?
       end
 
       it "is_expected.to load statements" do
-        skip("mutability") unless subject.mutable?
-        subject.load RDF::Spec::TRIPLES_FILE
-        expect(subject.size).to eq  File.readlines(RDF::Spec::TRIPLES_FILE).size
-        is_expected.to have_subject(resource)
+        if subject.mutable?
+          subject.load RDF::Spec::TRIPLES_FILE
+          expect(subject.size).to eq  File.readlines(RDF::Spec::TRIPLES_FILE).size
+          is_expected.to have_subject(resource)
+        end
       end
 
       it "is_expected.to load statements with a context override", unless: RDF::VERSION.to_s >= "1.99" do
-        skip("mutability and contextuality") unless (subject.mutable? && @supports_named_graphs)
-        subject.load RDF::Spec::TRIPLES_FILE, context: graph_name
-        is_expected.to have_context(graph_name)
-        expect(subject.query(context: graph_name).size).to eq subject.size
+        if subject.mutable? && @supports_named_graphs
+          subject.load RDF::Spec::TRIPLES_FILE, context: graph_name
+          is_expected.to have_context(graph_name)
+          expect(subject.query(context: graph_name).size).to eq subject.size
+        end
       end
 
       it "is_expected.to load statements with a graph_name override", if: RDF::VERSION.to_s >= "1.99" do
-        skip("mutability and contextuality") unless (subject.mutable? && @supports_named_graphs)
-        subject.load RDF::Spec::TRIPLES_FILE, graph_name: graph_name
-        is_expected.to have_graph(graph_name)
-        expect(subject.query(graph_name: graph_name).size).to eq subject.size
+        if subject.mutable? && @supports_named_graphs
+          subject.load RDF::Spec::TRIPLES_FILE, graph_name: graph_name
+          is_expected.to have_graph(graph_name)
+          expect(subject.query(graph_name: graph_name).size).to eq subject.size
+        end
       end
     end
 
@@ -96,57 +97,60 @@
       end
 
       it "is_expected.to not raise errors" do
-        skip("mutability") unless subject.mutable?
-        expect { subject.delete(@statements.first) }.not_to raise_error
+        expect { subject.delete(@statements.first) }.not_to raise_error if subject.mutable?
       end
 
       it "is_expected.to support deleting one statement at a time" do
-        skip("mutability") unless subject.mutable?
-        subject.delete(@statements.first)
-        is_expected.not_to  have_statement(@statements.first)
+        if subject.mutable?
+          subject.delete(@statements.first)
+          is_expected.not_to  have_statement(@statements.first)
+        end
       end
 
       it "is_expected.to support deleting multiple statements at a time" do
-        skip("mutability") unless subject.mutable?
-        subject.delete(*@statements)
-        expect(subject.find { |s| subject.has_statement?(s) }).to be_nil
+        if subject.mutable?
+          subject.delete(*@statements)
+          expect(subject.find { |s| subject.has_statement?(s) }).to be_nil
+        end
       end
 
       it "is_expected.to support wildcard deletions" do
-        skip("mutability") unless subject.mutable?
-        # nothing deleted
-        require 'digest/sha1'
-        count = subject.count
-        subject.delete([nil, nil, Digest::SHA1.hexdigest(File.read(__FILE__))])
-        is_expected.not_to  be_empty
-        expect(subject.count).to eq count
-
-        # everything deleted
-        subject.delete([nil, nil, nil])
-        is_expected.to be_empty
+        if subject.mutable?
+          # nothing deleted
+          require 'digest/sha1'
+          count = subject.count
+          subject.delete([nil, nil, Digest::SHA1.hexdigest(File.read(__FILE__))])
+          is_expected.not_to  be_empty
+          expect(subject.count).to eq count
+
+          # everything deleted
+          subject.delete([nil, nil, nil])
+          is_expected.to be_empty
+        end
       end
 
       it "is_expected.to only delete statements when the graph_name matches" do
-        skip("mutability") unless subject.mutable?
-        # Setup three statements identical except for graph_name
-        count = subject.count + (@supports_named_graphs ? 3 : 1)
-        s1 = RDF::Statement.new(resource, RDF::URI.new("urn:predicate:1"), RDF::URI.new("urn:object:1"))
-        s2 = s1.dup
-        s2.graph_name = RDF::URI.new("urn:graph_name:1")
-        s3 = s1.dup
-        s3.graph_name = RDF::URI.new("urn:graph_name:2")
-        subject.insert(s1)
-        subject.insert(s2)
-        subject.insert(s3)
-        expect(subject.count).to eq count
-
-        # Delete one by one
-        subject.delete(s1)
-        expect(subject.count).to eq count - (@supports_named_graphs ? 1 : 1)
-        subject.delete(s2)
-        expect(subject.count).to eq count - (@supports_named_graphs ? 2 : 1)
-        subject.delete(s3)
-        expect(subject.count).to eq count - (@supports_named_graphs ? 3 : 1)
+        if subject.mutable?
+          # Setup three statements identical except for graph_name
+          count = subject.count + (@supports_named_graphs ? 3 : 1)
+          s1 = RDF::Statement.new(resource, RDF::URI.new("urn:predicate:1"), RDF::URI.new("urn:object:1"))
+          s2 = s1.dup
+          s2.graph_name = RDF::URI.new("urn:graph_name:1")
+          s3 = s1.dup
+          s3.graph_name = RDF::URI.new("urn:graph_name:2")
+          subject.insert(s1)
+          subject.insert(s2)
+          subject.insert(s3)
+          expect(subject.count).to eq count
+
+          # Delete one by one
+          subject.delete(s1)
+          expect(subject.count).to eq count - (@supports_named_graphs ? 1 : 1)
+          subject.delete(s2)
+          expect(subject.count).to eq count - (@supports_named_graphs ? 2 : 1)
+          subject.delete(s3)
+          expect(subject.count).to eq count - (@supports_named_graphs ? 3 : 1)
+        end
       end
     end
   end

lib/rdf/spec/writable.rb

@@ -20,112 +20,121 @@
 
   describe "#<<" do
     it "inserts a reader" do
-      skip("writability") unless subject.writable?
-      reader = RDF::NTriples::Reader.new(File.open(filename)).to_a
-      subject << reader
-      is_expected.to have_statement(statement)
-      expect(subject.count).to eq count
+      if subject.writable?
+        reader = RDF::NTriples::Reader.new(File.open(filename)).to_a
+        subject << reader
+        is_expected.to have_statement(statement)
+        expect(subject.count).to eq count
+      end
     end
 
     it "inserts a graph" do
-      skip("writability") unless subject.writable?
-      graph = RDF::Graph.new << statements
-      subject << graph
-      is_expected.to have_statement(statement)
-      expect(subject.count).to eq count
+      if subject.writable?
+        graph = RDF::Graph.new << statements
+        subject << graph
+        is_expected.to have_statement(statement)
+        expect(subject.count).to eq count
+      end
     end
 
     it "inserts an enumerable" do
-      skip("writability") unless subject.writable?
-      enumerable = statements.dup.extend(RDF::Enumerable)
-      subject << enumerable
-      is_expected.to have_statement(statement)
-      expect(subject.count).to eq count
+      if subject.writable?
+        enumerable = statements.dup.extend(RDF::Enumerable)
+        subject << enumerable
+        is_expected.to have_statement(statement)
+        expect(subject.count).to eq count
+      end
     end
 
     it "inserts data responding to #to_rdf" do
-      skip("writability") unless subject.writable?
-      mock = double('mock')
-      allow(mock).to receive(:to_rdf).and_return(statements)
-      subject << mock
-      is_expected.to have_statement(statement)
-      expect(subject.count).to eq count
+      if subject.writable?
+        mock = double('mock')
+        allow(mock).to receive(:to_rdf).and_return(statements)
+        subject << mock
+        is_expected.to have_statement(statement)
+        expect(subject.count).to eq count
+      end
     end
 
     it "inserts a statement" do
-      skip("writability") unless subject.writable?
-      subject << statement
-      is_expected.to have_statement(statement)
-      expect(subject.count).to eq 1
+      if subject.writable?
+        subject << statement
+        is_expected.to have_statement(statement)
+        expect(subject.count).to eq 1
+      end
     end
   end
 
   context "when inserting statements" do
     it "is_expected.to support #insert" do
-      skip("writability") unless subject.writable?
-      is_expected.to respond_to(:insert)
+      is_expected.to respond_to(:insert) if subject.writable?
     end
 
     it "is_expected.to not raise errors" do
-      skip("writability") unless subject.writable?
-      expect { subject.insert(statement) }.not_to raise_error
+      expect { subject.insert(statement) }.not_to raise_error if subject.writable?
     end
 
     it "is_expected.to support inserting one statement at a time" do
-      skip("writability") unless subject.writable?
-      subject.insert(statement)
-      is_expected.to have_statement(statement)
+      if subject.writable?
+        subject.insert(statement)
+        is_expected.to have_statement(statement)
+      end
     end
 
     it "is_expected.to support inserting multiple statements at a time" do
-      skip("writability") unless subject.writable?
-      subject.insert(*statements)
-      statements.each do |statement|
-        is_expected.to have_statement(statement) unless statement.to_a.any?(&:node?)
+      if subject.writable?
+        subject.insert(*statements)
+        statements.each do |statement|
+          is_expected.to have_statement(statement) unless statement.to_a.any?(&:node?)
+        end
       end
     end
 
     it "is_expected.to insert statements successfully" do
-      skip("writability") unless subject.writable?
-      subject.insert(*statements)
-      expect(subject.count).to eq count
+      if subject.writable?
+        subject.insert(*statements)
+        expect(subject.count).to eq count
+      end
     end
 
     it "is_expected.to not insert a statement twice" do
-      skip("writability") unless subject.writable?
-      subject.insert(statement)
-      subject.insert(statement)
-      expect(subject.count).to eq 1
+      if subject.writable?
+        subject.insert(statement)
+        subject.insert(statement)
+        expect(subject.count).to eq 1
+      end
     end
 
     it "is_expected.to treat statements with a different context as distinct", unless: RDF::VERSION.to_s >= "1.99" do
-      skip("writability") unless subject.writable?
-      s1 = statement.dup
-      s1.context = nil
-      s2 = statement.dup
-      s2.context = RDF::URI.new("urn:context:1")
-      s3 = statement.dup
-      s3.context = RDF::URI.new("urn:context:2")
-      subject.insert(s1)
-      subject.insert(s2)
-      subject.insert(s3)
-      # If contexts are not suported, all three are redundant
-      expect(subject.count).to eq (supports_graph_name ? 3 : 1)
+      if subject.writable?
+        s1 = statement.dup
+        s1.context = nil
+        s2 = statement.dup
+        s2.context = RDF::URI.new("urn:context:1")
+        s3 = statement.dup
+        s3.context = RDF::URI.new("urn:context:2")
+        subject.insert(s1)
+        subject.insert(s2)
+        subject.insert(s3)
+        # If contexts are not suported, all three are redundant
+        expect(subject.count).to eq (supports_graph_name ? 3 : 1)
+      end
     end
 
     it "is_expected.to treat statements with a different graph_name as distinct", if: RDF::VERSION.to_s >= "1.99" do
-      skip("writability") unless subject.writable?
-      s1 = statement.dup
-      s1.graph_name = nil
-      s2 = statement.dup
-      s2.graph_name = RDF::URI.new("urn:context:1")
-      s3 = statement.dup
-      s3.graph_name = RDF::URI.new("urn:context:2")
-      subject.insert(s1)
-      subject.insert(s2)
-      subject.insert(s3)
-      # If graph_names are not suported, all three are redundant
-      expect(subject.count).to eq (supports_graph_name ? 3 : 1)
+      if subject.writable?
+        s1 = statement.dup
+        s1.graph_name = nil
+        s2 = statement.dup
+        s2.graph_name = RDF::URI.new("urn:context:1")
+        s3 = statement.dup
+        s3.graph_name = RDF::URI.new("urn:context:2")
+        subject.insert(s1)
+        subject.insert(s2)
+        subject.insert(s3)
+        # If graph_names are not suported, all three are redundant
+        expect(subject.count).to eq (supports_graph_name ? 3 : 1)
+      end
     end
   end
 end