rdf-spec 1.99.0 → 2.0.0.beta1

data/lib/rdf/spec/format.rb

@@ -13,21 +13,21 @@ RSpec.shared_examples 'an RDF::Format' do
   describe ".for" do
     RDF::Format.file_extensions.each do |ext, formats|
       it "detects #{formats.first} using file path foo.#{ext}" do
-        expect(RDF::Format.for("foo.#{ext}")).to eq formats.first
+        expect(RDF::Format.for("foo.#{ext}")).to eq formats.last
       end
 
       it "detects #{formats.first} using file_name foo.#{ext}" do
-        expect(RDF::Format.for(file_name: "foo.#{ext}")).to eq formats.first
+        expect(RDF::Format.for(file_name: "foo.#{ext}")).to eq formats.last
       end
 
       it "detects #{formats.first} using file_extension #{ext}" do
-        expect(RDF::Format.for(file_extension: ext)).to eq formats.first
+        expect(RDF::Format.for(file_extension: ext)).to eq formats.last
       end
     end
 
     RDF::Format.content_types.each do |content_type, formats|
       it "detects #{formats.first} using content_type #{content_type}" do
-        expect(RDF::Format.for(content_type: content_type)).to eq formats.first
+        expect(RDF::Format.for(content_type: content_type)).to eq formats.last
       end
     end
   end
@@ -51,25 +51,3 @@ RSpec.shared_examples 'an RDF::Format' do
     end
   end
 end
-
-##
-# @deprecated use `it_behaves_like "an RDF::Format"` instead
-module RDF_Format
-  extend RSpec::SharedContext
-  include RDF::Spec::Matchers
-
-  def self.included(mod)
-    warn "[DEPRECATION] `RDF_Format` is deprecated. "\
-         "Please use `it_behaves_like 'an RDF::Format'`"
-  end
-
-  describe 'examples for' do
-    include_examples 'an RDF::Format' do
-      let(:format_class) { @format_class }
-
-      before do
-        raise '@format_class must be defined' unless defined?(format_class)
-      end
-    end
-  end
-end

data/lib/rdf/spec/http_adapter.rb

@@ -214,7 +214,7 @@ RSpec.shared_examples 'an RDF::HttpAdapter' do
         end
         expect(WebMock).to have_requested(:get, uri)
       end
-    end
+    end unless ENV['CI']
 
     context "https" do
       let(:uri) {"https://some/secure/uri"}
@@ -291,25 +291,3 @@ RSpec.shared_examples 'an RDF::HttpAdapter' do
   end
 
 end
-
-##
-# @deprecated use `it_behaves_like "an RDF::HttpAdapter"` instead
-module RDF_HttpAdapter
-  extend RSpec::SharedContext
-  include RDF::Spec::Matchers
-
-  def self.included(mod)
-    warn "[DEPRECATION] `RDF_HttpAdapter` is deprecated. "\
-         "Please use `it_behaves_like 'an RDF::HttpAdapter'`"
-  end
-
-  describe 'examples for' do
-    include_examples 'an RDF::HttpAdapter' do
-      let(:http_adapter) { @http_adapter }
-
-      before do
-        raise '@http_adapter must be defined' unless defined?(http_adapter)
-      end
-    end
-  end
-end

data/lib/rdf/spec/indexable.rb

@@ -18,28 +18,6 @@ RSpec.shared_examples 'an RDF::Indexable' do
   end
 
   it "returns self on #index!" do
-    expect(subject.index!).to be
-  end
-end
-
-##
-# @deprecated use `it_behaves_like "an RDF::Indexable"` instead
-module RDF_Indexable
-  extend RSpec::SharedContext
-  include RDF::Spec::Matchers
-
-  def self.included(mod)
-    warn "[DEPRECATION] `RDF_Indexable` is deprecated. "\
-         "Please use `it_behaves_like 'an RDF::Indexable'`"
-  end
-
-  describe 'examples for' do
-    include_examples 'an RDF::Indexable' do
-      let(:indexable) { @indexable }
-
-      before do
-        raise '@indexable must be defined' unless defined?(indexable)
-      end
-    end
+    expect(subject.index!).to eql(subject)
   end
 end

data/lib/rdf/spec/inferable.rb

@@ -5,19 +5,3 @@ RSpec.shared_examples 'an RDF::Inferable' do
 
   it "is_expected.to implement specs" #TODO
 end
-
-##
-# @deprecated use `it_behaves_like "an RDF::Inferable"` instead
-module RDF_Inferable
-  extend RSpec::SharedContext
-  include RDF::Spec::Matchers
-
-  def self.included(mod)
-    warn "[DEPRECATION] `RDF_Inferable` is deprecated. "\
-         "Please use `it_behaves_like 'an RDF::Inferable'`"
-  end
-
-  describe 'examples for' do
-    include_examples 'an RDF::Inferable'
-  end
-end

data/lib/rdf/spec/inspects.rb

@@ -1,28 +1,27 @@
 require 'rdf'
-require 'rdf/ntriples'
 # override several inspect functions to improve output for what we're doing
 
 class RDF::Literal
   def inspect
-    RDF::NTriples::Writer.serialize(self) + " R:L:(#{self.class.to_s.match(/([^:]*)$/)})"
+    "\"#{escape(value)}\" R:L:(#{self.class.to_s.match(/([^:]*)$/)})"
   end
 end
 
 class RDF::URI
   def inspect
-    RDF::NTriples::Writer.serialize(self)
+    "RDF::URI(#{to_base})"
   end
 end
 
 class RDF::Node
   def inspect
-    RDF::NTriples::Writer.serialize(self) + "(#{object_id})"
+    "RDF::Node(#{to_base})"
   end
 end
 
 class RDF::Graph
   def inspect
-    "\n" + dump(RDF.const_defined?(:Turtle) ? :ttl : :ntriples, standard_prefixes: true) + "\n"
+    "RDF::Graph(graph_name: #{self.graph_name || 'nil'})"
   end
 end
 

data/lib/rdf/spec/matchers.rb

@@ -184,12 +184,18 @@ module RDF; module Spec
       end
     end
 
-    RSpec::Matchers.define :write do |message|
-      chain(:to) do |io|
-        @io = io
+    RSpec::Matchers.define :write_each do |*messages|
+      supports_block_expectations { true }
+
+      match do |block|
+        messages.each { |message| expect(&block).to write(message) }
       end
+    end
 
-      supports_block_expectations {true}
+    RSpec::Matchers.define :write do |message|
+      chain(:to) { |io| @io = io }
+
+      supports_block_expectations { true }
 
       match do |block|
         @output =
@@ -258,6 +264,91 @@ module RDF; module Spec
         {:output => "standard output", :error => "standard error"}[io]
       end
     end
+
+    Info = Struct.new(:id, :logger, :action, :result)
+
+    RSpec::Matchers.define :be_equivalent_graph do |expected, info|
+      match do |actual|
+        def normalize(graph)
+          case graph
+          when RDF::Enumerable then graph
+          when IO, StringIO
+            RDF::Repository.new(graph, base_uri: @info.action)
+          else
+            # Figure out which parser to use
+            r = RDF::Repository.new
+            reader_class = RDF::Reader.for() {graph}
+            reader_class.new(graph, base_uri: @info.action).each {|s| r << s}
+            r
+          end
+        end
+
+        @info = if (info.id rescue false)
+          info
+        elsif info.is_a?(Logger)
+          Info.new("", info)
+        elsif info.is_a?(Hash)
+          Info.new(info[:id], info[:logger], info[:action], info[:result])
+        else
+          Info.new(info)
+        end
+        @expected = normalize(expected)
+        @actual = normalize(actual)
+        @actual.isomorphic_with?(@expected) rescue false
+      end
+
+      failure_message do |actual|
+        format = case
+        when RDF.const_defined?(:TriG) then :trig
+        when RDF.const_defined?(:Turtle) then :ttl
+        else :nquads
+        end
+        info = @info.respond_to?(:information) ? @info.information : @info.inspect
+        if @expected.is_a?(RDF::Enumerable) && @actual.size != @expected.size
+          "Graph entry counts differ:\nexpected: #{@expected.size}\nactual:   #{@actual.size}\n"
+        else
+          "Graphs differ\n"
+        end +
+        "\n#{info + "\n" unless info.empty?}" +
+        "Expected:\n#{@expected.dump(format, standard_prefixes: true, literal_shorthand: false, validate: false) rescue @expected.inspect}" +
+        "Results:\n#{@actual.dump(format, standard_prefixes: true, literal_shorthand: false, validate: false) rescue @actual.inspect}" +
+        "\nDebug:\n#{@info.logger}"
+      end
+    end
+
+    require 'json'
+    JSON_STATE = ::JSON::State.new(
+       indent:        "  ",
+       space:         " ",
+       space_before:  "",
+       object_nl:     "\n",
+       array_nl:      "\n"
+     )
+
+    RSpec::Matchers.define :produce do |expected, info|
+      match do |actual|
+        @info = if (info.id rescue false)
+          info
+        elsif info.is_a?(Logger)
+          Info.new("", info)
+        elsif info.is_a?(Hash)
+          Info.new(info[:id], info[:logger], info[:action], info[:result])
+        else
+          Info.new(info)
+        end
+        expect(actual).to eq expected
+      end
+
+      failure_message do |actual|
+        info = @info.respond_to?(:information) ? @info.information : @info.inspect
+
+        "Expected: #{expected.is_a?(String) ? expected : expected.to_json(JSON_STATE) rescue 'malformed json'}\n" +
+        "Actual  : #{actual.is_a?(String) ? actual : actual.to_json(JSON_STATE) rescue 'malformed json'}\n" +
+        "\n#{info + "\n" unless info.empty?}" +
+        "\nDebug:\n#{@info.logger}"
+      end
+    end
+
   end # Matchers
 end; end # RDF::Spec
 

data/lib/rdf/spec/mutable.rb

@@ -8,11 +8,15 @@ RSpec.shared_examples 'an RDF::Mutable' do
     raise 'mutable must be defined with let(:mutable)' unless
       defined? mutable
 
+    skip "Immutable resource" unless mutable.mutable?
+    @statements = RDF::Spec.triples
     @supports_named_graphs = mutable.respond_to?(:supports?) && mutable.supports?(:graph_name)
+    @supports_literal_equality = mutable.respond_to?(:supports?) && mutable.supports?(:literal_equality)
   end
 
   let(:resource) { RDF::URI('http://rubygems.org/gems/rdf') }
   let(:graph_name) { RDF::URI('http://example.org/graph_name') }
+  let(:non_bnode_statements) {@statements.reject(&:node?)}
 
   describe RDF::Mutable do
     subject { mutable }
@@ -43,36 +47,26 @@ RSpec.shared_examples 'an RDF::Mutable' do
     its(:count) {is_expected.to be_zero}
 
     context "#load" do
-      it "is_expected.to require an argument" do
+      it "should require an argument" do
         expect { subject.load }.to raise_error(ArgumentError)
       end
 
-      it "is_expected.to accept a string filename argument" do
-        expect { subject.load(RDF::Spec::TRIPLES_FILE) }.not_to raise_error if subject.mutable?
+      it "should accept a string filename argument" do
+        expect { subject.load(RDF::Spec::TRIPLES_FILE) }.not_to raise_error
       end
 
-      it "is_expected.to accept an optional hash argument" do
-        expect { subject.load(RDF::Spec::TRIPLES_FILE, {}) }.not_to raise_error if subject.mutable?
+      it "should accept an optional hash argument" do
+        expect { subject.load(RDF::Spec::TRIPLES_FILE, {}) }.not_to raise_error
       end
 
-      it "is_expected.to load statements" do
-        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
-        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
+      it "should load statements" do
+        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
 
-      it "is_expected.to load statements with a graph_name override", if: RDF::VERSION.to_s >= "1.99" do
-        if subject.mutable? && @supports_named_graphs
+      it "should load statements with a graph_name override" do
+        if @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
@@ -81,7 +75,7 @@ RSpec.shared_examples 'an RDF::Mutable' do
     end
 
     context "#from_{reader}" do
-      it "is_expected.to instantiate a reader" do
+      it "should instantiate a reader" do
         reader = double("reader")
         expect(reader).to receive(:new).and_return(RDF::Spec.quads.first)
         allow(RDF::Reader).to receive(:for).and_call_original
@@ -90,89 +84,241 @@ RSpec.shared_examples 'an RDF::Mutable' do
       end
     end
 
+    context "when updating statements" do
+      let(:s1) { RDF::Statement(resource, RDF::URI.new("urn:predicate:1"), RDF::URI.new("urn:object:1")) }
+      let(:s2) { RDF::Statement(resource, RDF::URI.new("urn:predicate:2"), RDF::URI.new("urn:object:2")) }
+
+      before :each do
+        subject.insert(*[s1,s2])
+      end
+
+      after :each do
+        subject.delete(*[s1,s2])
+      end
+
+      it "should not raise errors" do
+        s1_updated = RDF::Statement(resource, RDF::URI.new("urn:predicate:1"), RDF::URI.new("urn:object:2"))
+        expect { subject.update(s1_updated) }.not_to raise_error
+      end
+
+      it "should support updating one statement at a time with an object" do
+        s1_updated = RDF::Statement(resource, RDF::URI.new("urn:predicate:1"), RDF::URI.new("urn:object:2"))
+        subject.update(s1_updated)
+        expect(subject.has_statement?(s1_updated)).to be true
+        expect(subject.has_statement?(s1)).to be false
+      end
+
+      it "should support updating one statement at a time without an object" do
+        s1_deleted = RDF::Statement(resource, RDF::URI.new("urn:predicate:1"), nil)
+        subject.update(s1_deleted)
+        expect(subject.has_statement?(s1)).to be false
+      end
+
+      it "should support updating an array of statements at a time" do
+        s1_updated = RDF::Statement(resource, RDF::URI.new("urn:predicate:1"), RDF::URI.new("urn:object:2"))
+        s2_updated = RDF::Statement(resource, RDF::URI.new("urn:predicate:2"), RDF::URI.new("urn:object:3"))
+        subject.update(*[s1_updated, s2_updated])
+        expect(subject.has_statement?(s1_updated)).to be true
+        expect(subject.has_statement?(s2_updated)).to be true
+        expect(subject.has_statement?(s1)).to be false
+        expect(subject.has_statement?(s2)).to be false
+      end
+
+      it "should support updating an enumerable of statements at a time" do
+        s1_updated = RDF::Statement(resource, RDF::URI.new("urn:predicate:1"), RDF::URI.new("urn:object:2"))
+        s2_updated = RDF::Statement(resource, RDF::URI.new("urn:predicate:2"), RDF::URI.new("urn:object:3"))
+        updates = [s1_updated, s2_updated]
+        updates.extend(RDF::Enumerable)
+        subject.update(updates)
+        expect(subject.has_statement?(s1_updated)).to be true
+        expect(subject.has_statement?(s2_updated)).to be true
+        expect(subject.has_statement?(s1)).to be false
+        expect(subject.has_statement?(s2)).to be false
+      end
+    end
+
     context "when deleting statements" do
       before :each do
-        @statements = RDF::NTriples::Reader.new(File.open(RDF::Spec::TRIPLES_FILE)).to_a
         subject.insert(*@statements)
       end
 
-      it "is_expected.to not raise errors" do
-        expect { subject.delete(@statements.first) }.not_to raise_error if subject.mutable?
+      it "should not raise errors" do
+        expect { subject.delete(non_bnode_statements.first) }.not_to raise_error
+      end
+
+      it "should support deleting one statement at a time" do
+        subject.delete(non_bnode_statements.first)
+        is_expected.not_to  have_statement(non_bnode_statements.first)
       end
 
-      it "is_expected.to support deleting one statement at a time" do
+      it "should support deleting multiple statements at a time" do
+        subject.delete(*@statements)
+        expect(subject.find { |s| subject.has_statement?(s) }).to be_nil
+      end
+
+      it "should support wildcard deletions" do
+        # 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
+
+      it "should only delete statements when the graph_name matches" do
+        # 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
+
+      it 'does not delete literal with different language' do
         if subject.mutable?
-          subject.delete(@statements.first)
-          is_expected.not_to  have_statement(@statements.first)
+          en = RDF::Literal('abc', language: 'en')
+          fi = RDF::Literal('abc', language: 'fi')
+
+          subject.insert([RDF::URI('http://example.com/s'), RDF::URI('http://example.com/p'), en])
+          expect { subject.delete([RDF::URI('http://example.com/s'), RDF::URI('http://example.com/p'), fi]) }
+            .not_to change { subject.count }
         end
       end
 
-      it "is_expected.to support deleting multiple statements at a time" do
-        if subject.mutable?
-          subject.delete(*@statements)
-          expect(subject.find { |s| subject.has_statement?(s) }).to be_nil
+      it 'does not delete literal with different datatype' do
+        if subject.mutable? && @supports_literal_equality
+          dec = RDF::Literal::Decimal.new(1)
+          int = RDF::Literal::Integer.new(1)
+
+          subject.insert([RDF::URI('http://example.com/s'), RDF::URI('http://example.com/p'), dec])
+          
+          expect { subject.delete([RDF::URI('http://example.com/s'), RDF::URI('http://example.com/p'), int]) }
+            .not_to change { subject.count }
         end
       end
 
-      it "is_expected.to support wildcard deletions" do
-        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
+      it 'does not delete literal with different lexical value' do
+        if subject.mutable? && @supports_literal_equality
+          one      = RDF::Literal::Integer.new("1")
+          zero_one = RDF::Literal::Integer.new("01")
+
+          subject.insert([RDF::URI('http://example.com/s'), RDF::URI('http://example.com/p'), one])
+          
+          expect { subject.delete([RDF::URI('http://example.com/s'), RDF::URI('http://example.com/p'), zero_one]) }
+            .not_to change { subject.count }
         end
       end
 
-      it "is_expected.to only delete statements when the graph_name matches" do
-        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)
+      describe '#delete_insert' do
+        let(:statement) do
+          RDF::Statement.new(resource, 
+                             RDF::URI.new("urn:predicate:1"), 
+                             RDF::URI.new("urn:object:1"))
+        end
+
+        it 'deletes and inserts' do
+          subject.delete_insert(@statements, [statement])
+          is_expected.to contain_exactly statement
+        end
+
+        it 'deletes before inserting' do
+          subject.delete_insert(@statements, [@statements.first])
+          is_expected.to contain_exactly @statements.first
+        end
+
+        it 'deletes patterns' do
+          pattern = [non_bnode_statements.first.subject, nil, nil]
+          expect { subject.delete_insert([pattern], []) }
+            .to change { subject.has_subject?(non_bnode_statements.first.subject) }
+            .from(true).to(false)
+        end
+
+        it 'handles Enumerables' do
+          dels = non_bnode_statements.take(10)
+          dels.extend(RDF::Enumerable)
+          ins = RDF::Graph.new << statement
+          expect { subject.delete_insert(dels, ins) }
+            .to change { dels.find { |s| subject.include?(s) } }.to be_nil
+          is_expected.to include statement
+        end
+
+        it 'handles Graph names' do
+          if @supports_named_graphs
+            dels = non_bnode_statements.take(10).map do |st|
+              RDF::Statement.from(st.to_hash.merge(graph_name: RDF::URI('http://example.com/fake')))
+            end
+            dels.map! { |st| st.graph_name = RDF::URI('http://example.com/fake'); st }
+            dels.extend(RDF::Enumerable)
+            expect { subject.delete_insert(dels, []) }
+              .not_to change { subject.statements.count }
+          end
+        end
+
+        context 'when transactions are supported' do
+          it 'updates atomically' do
+            if subject.mutable? && subject.supports?(:atomic_write)
+              contents = subject.statements.to_a
+
+              expect { subject.delete_insert(@statements, [nil]) }
+                .to raise_error ArgumentError
+              expect(subject.statements).to contain_exactly(*contents)
+            end
+          end
         end
       end
     end
-  end
-end
+    
+    describe '#apply_changeset' do
+      let(:changeset) { RDF::Changeset.new }
 
-##
-# @deprecated use `it_behaves_like "an RDF::Mutable"` instead
-module RDF_Mutable
-  extend RSpec::SharedContext
-  include RDF::Spec::Matchers
+      it 'is a no-op when changeset is empty' do
+        expect { subject.apply_changeset(changeset) }
+          .not_to change { subject.statements }
+      end
 
-  def self.included(mod)
-    warn "[DEPRECATION] `RDF_Mutable` is deprecated. "\
-         "Please use `it_behaves_like 'an RDF::Mutable'`"
-  end
+      it 'inserts statements' do
+        changeset.insert(*non_bnode_statements)
+
+        expect { subject.apply_changeset(changeset) }
+          .to change { subject.statements }
+               .to contain_exactly(*non_bnode_statements)
+      end
+
+      it 'deletes statements' do
+        subject.insert(*non_bnode_statements)
+        deletes = non_bnode_statements.take(10)
+        
+        changeset.delete(*deletes)
+        subject.apply_changeset(changeset)
+
+        expect(subject).not_to include(*deletes)
+      end
 
-  describe 'examples for' do
-    include_examples 'an RDF::Mutable' do
-      let(:mutable) { @mutable }
+      it 'deletes before inserting' do
+        statement = non_bnode_statements.first
+        
+        changeset.insert(statement)
+        changeset.delete(statement)
+        subject.apply_changeset(changeset)
 
-      before do
-        raise '@mutable must be defined' unless defined?(mutable)
+        expect(subject).to include(statement)
       end
     end
   end