rdf-spec 1.99.0 → 2.0.0.beta1

data/lib/rdf/spec/queryable.rb

@@ -26,6 +26,98 @@ RSpec.shared_examples 'an RDF::Queryable' do
     let(:resource) {RDF::URI('http://rubygems.org/gems/rdf')}
     let(:literal) {RDF::Literal.new('J. Random Hacker')}
     let(:query) {RDF::Query.new {pattern [:s, :p, :o]}}
+    
+    shared_examples 'query execution' do |method|
+      it "requires an argument" do
+        expect { subject.send(method) }.to raise_error(ArgumentError)
+      end
+
+      it "yields to the given block" do
+        expect {|b| subject.send(method, query, &b)}.to yield_control.exactly(queryable.count).times
+      end
+
+      it "yields solutions" do
+        subject.send(method, query) do |solution|
+          expect(solution).to be_a RDF::Query::Solution
+        end
+      end
+    end
+
+    shared_examples 'query pattern' do |method|
+      it "requires an argument" do
+        expect { subject.send(method) }.to raise_error(ArgumentError)
+      end
+
+      it "yields to the given block" do
+        expect {|b| subject.send(method, RDF::Query::Pattern.new, &b)}.to yield_control.exactly(queryable.count).times
+      end
+
+      it "yields statements" do
+        subject.send(method, RDF::Query::Pattern.new) do |statement|
+          expect(statement).to be_a_statement
+        end
+      end
+
+      context "with specific patterns" do
+        # Note that "01" should not match 1, per data-r2/expr-equal/sameTerm
+        {
+          [RDF::URI("http://example.org/xi1"), RDF::URI("http://example.org/p"), 1] => [RDF::Statement.from([RDF::URI("http://example.org/xi1"), RDF::URI("http://example.org/p"), 1])],
+          [RDF::URI("http://example.org/xi1"), RDF::URI("http://example.org/p"), nil] => [RDF::Statement.from([RDF::URI("http://example.org/xi1"), RDF::URI("http://example.org/p"), 1])],
+          [RDF::URI("http://example.org/xi1"), nil, 1] => [RDF::Statement.from([RDF::URI("http://example.org/xi1"), RDF::URI("http://example.org/p"), 1])],
+          [nil, RDF::URI("http://example.org/p"), 1] => [RDF::Statement.from([RDF::URI("http://example.org/xi1"), RDF::URI("http://example.org/p"), 1]), RDF::Statement.from([RDF::URI("http://example.org/xi2"), RDF::URI("http://example.org/p"), 1])],
+          [nil, nil, 1] => [RDF::Statement.from([RDF::URI("http://example.org/xi1"), RDF::URI("http://example.org/p"), 1]), RDF::Statement.from([RDF::URI("http://example.org/xi2"), RDF::URI("http://example.org/p"), 1])],
+          [nil, RDF::URI("http://example.org/p"), RDF::Literal::Double.new("1.0e0")] => [RDF::Statement.from([RDF::URI("http://example.org/xd1"), RDF::URI("http://example.org/p"), RDF::Literal::Double.new("1.0e0")])],
+        }.each do |pattern, result|
+          pattern = RDF::Query::Pattern.from(pattern)
+          it "returns #{result.inspect} given #{pattern.inspect}" do
+            solutions = []
+            subject.send(method, pattern) {|s| solutions << s}
+            expect(solutions).to contain_exactly(*result)
+          end
+        end
+      end
+
+      context "with graph_name" do
+        it "returns statements from all graphs with no graph_name" do
+          pattern = RDF::Query::Pattern.new(nil, nil, nil, graph_name: nil)
+          solutions = []
+          subject.send(method, pattern) {|s| solutions << s}
+          expect(solutions.size).to eq @statements.size
+        end
+
+        it "returns statements from unnamed graphs with false graph_name" do
+          pattern = RDF::Query::Pattern.new(nil, nil, nil, graph_name: false)
+          solutions = []
+          subject.send(method, pattern) {|s| solutions << s}
+
+          named_statements = subject.statements
+          named_statements.reject! {|st| st.has_name?} unless
+            subject.respond_to?(:graph_name) && !subject.graph_name.nil?
+
+          expect(solutions.size).to eq named_statements.size
+        end
+
+        it "returns statements from named graphs with variable graph_name" do
+          unless subject.graph_names.to_a.empty?
+            pattern = RDF::Query::Pattern.new(nil, nil, nil, graph_name: :c)
+            solutions = []
+            subject.send(method, pattern) {|s| solutions << s}
+            named_statements = subject.statements.select {|st| st.has_name?}
+            expect(solutions.size).to eq named_statements.size
+          end
+        end
+
+        it "returns statements from specific graph with URI graph_name" do
+          unless subject.graph_names.to_a.empty? || 
+                 (subject.respond_to?(:graph_name) && !subject.graph_name.nil?)
+            pattern = RDF::Query::Pattern.new(nil, nil, nil, graph_name: RDF::URI("http://ar.to/#self"))
+            solutions = []
+            subject.send(method, pattern) {|s| solutions << s}
+            expect(solutions.size).to eq File.readlines(@doap).grep(/^<http:\/\/ar.to\/\#self>/).size
+          end
+        end
+      end
+    end
 
     ##
     # @see RDF::Queryable#query
@@ -33,6 +125,9 @@ RSpec.shared_examples 'an RDF::Queryable' do
       it {is_expected.to respond_to(:query)}
 
       context "when called" do
+        include_examples 'query execution', :query
+        include_examples 'query pattern',   :query
+
         it "requires an argument" do
           expect { subject.query }.to raise_error(ArgumentError)
         end
@@ -81,27 +176,20 @@ RSpec.shared_examples 'an RDF::Queryable' do
                 expect(statement).not_to  be_a RDF::Query::Solution
               end
             end
-
-            it "calls #query_pattern" do
-              is_expected.to receive(:query_pattern)
-              is_expected.not_to receive(:query_execute)
-              subject.query([:s, :p, :o]) {}
-            end
           end
 
           context "with a Query argument" do
+            it "yields to the given block" do
+              expect { |b| subject.query(query, &b) }
+                .to yield_control.exactly(queryable.count).times
+            end
+
             it "yields statements" do
               subject.query(query) do |solution|
                 expect(solution).not_to  be_a_statement
                 expect(solution).to be_a RDF::Query::Solution
               end
             end
-
-            it "calls #query_execute" do
-              is_expected.to receive(:query_execute)
-              is_expected.not_to receive(:query_pattern)
-              subject.query(query) {}
-            end
           end
         end
 
@@ -223,140 +311,26 @@ RSpec.shared_examples 'an RDF::Queryable' do
     ##
     # @see RDF::Queryable#query_execute
     describe "#query_execute" do
+      before { skip unless subject.respond_to?(:query_execute, true ) }
+
       it "defines a protected #query_execute method" do
-        expect(subject.class.protected_method_defined?(:query_execute)).to be_truthy
+        expect(subject.class.protected_method_defined?(:query_execute))
+          .to be_truthy
       end
 
-      context "when called" do
-        it "requires an argument" do
-          expect { subject.send(:query_execute) }.to raise_error(ArgumentError)
-        end
-
-        it "yields to the given block" do
-          expect {|b| subject.send(:query_execute, query, &b)}.to yield_control.exactly(queryable.count).times
-        end
-
-        it "yields solutions" do
-          subject.send(:query_execute, query) do |solution|
-            expect(solution).to be_a RDF::Query::Solution
-          end
-        end
-      end
+      include_examples 'query execution', :query_execute
     end
 
     ##
     # @see RDF::Queryable#query_pattern
     describe "#query_pattern" do
+      before { skip unless subject.respond_to?(:query_pattern, true ) }
+
       it "defines a protected #query_pattern method" do
         expect(subject.class.protected_method_defined?(:query_pattern)).to be_truthy
       end
-
-      context "when called" do
-        it "requires an argument" do
-          expect { subject.send(:query_pattern) }.to raise_error(ArgumentError)
-        end
-
-        it "yields to the given block" do
-          expect {|b| subject.send(:query_pattern, RDF::Query::Pattern.new, &b)}.to yield_control.exactly(queryable.count).times
-        end
-
-        it "yields statements" do
-          subject.send(:query_pattern, RDF::Query::Pattern.new) do |statement|
-            expect(statement).to be_a_statement
-          end
-        end
-
-        context "with specific patterns" do
-          # Note that "01" should not match 1, per data-r2/expr-equal/sameTerm
-          {
-            [RDF::URI("http://example.org/xi1"), RDF::URI("http://example.org/p"), 1] => [RDF::Statement.from([RDF::URI("http://example.org/xi1"), RDF::URI("http://example.org/p"), 1])],
-            [RDF::URI("http://example.org/xi1"), RDF::URI("http://example.org/p"), nil] => [RDF::Statement.from([RDF::URI("http://example.org/xi1"), RDF::URI("http://example.org/p"), 1])],
-            [RDF::URI("http://example.org/xi1"), nil, 1] => [RDF::Statement.from([RDF::URI("http://example.org/xi1"), RDF::URI("http://example.org/p"), 1])],
-            [nil, RDF::URI("http://example.org/p"), 1] => [RDF::Statement.from([RDF::URI("http://example.org/xi1"), RDF::URI("http://example.org/p"), 1]), RDF::Statement.from([RDF::URI("http://example.org/xi2"), RDF::URI("http://example.org/p"), 1])],
-            [nil, nil, 1] => [RDF::Statement.from([RDF::URI("http://example.org/xi1"), RDF::URI("http://example.org/p"), 1]), RDF::Statement.from([RDF::URI("http://example.org/xi2"), RDF::URI("http://example.org/p"), 1])],
-            [nil, RDF::URI("http://example.org/p"), RDF::Literal::Double.new("1.0e0")] => [RDF::Statement.from([RDF::URI("http://example.org/xd1"), RDF::URI("http://example.org/p"), RDF::Literal::Double.new("1.0e0")])],
-          }.each do |pattern, result|
-            pattern = RDF::Query::Pattern.from(pattern)
-            it "returns #{result.inspect} given #{pattern.inspect}" do
-              solutions = []
-              subject.send(:query_pattern, pattern) {|s| solutions << s}
-              expect(solutions).to eq result
-            end
-          end
-        end
-
-        context "with context", unless: RDF::VERSION.to_s >= "1.99" do
-          it "returns statements from all contexts with no context" do
-            pattern = RDF::Query::Pattern.new(nil, nil, nil, context: nil)
-            solutions = []
-            subject.send(:query_pattern, pattern) {|s| solutions << s}
-            expect(solutions.size).to eq @statements.size
-          end
-
-          it "returns statements from unnamed contexts with false context" do
-            pattern = RDF::Query::Pattern.new(nil, nil, nil, context: false)
-            solutions = []
-            subject.send(:query_pattern, pattern) {|s| solutions << s}
-            context_statements = subject.statements.reject {|st| st.has_context?}.length
-            expect(solutions.size).to eq context_statements
-          end
-
-          it "returns statements from named contexts with variable context" do
-            unless subject.contexts.to_a.empty?
-              pattern = RDF::Query::Pattern.new(nil, nil, nil, context: :c)
-              solutions = []
-              subject.send(:query_pattern, pattern) {|s| solutions << s}
-              context_statements = subject.statements.select {|st| st.has_context?}.length
-              expect(solutions.size).to eq context_statements
-            end
-          end
-
-          it "returns statements from specific context with URI context" do
-            unless subject.contexts.to_a.empty?
-              pattern = RDF::Query::Pattern.new(nil, nil, nil, context: RDF::URI("http://ar.to/#self"))
-              solutions = []
-              subject.send(:query_pattern, pattern) {|s| solutions << s}
-              expect(solutions.size).to eq File.readlines(@doap).grep(/^<http:\/\/ar.to\/\#self>/).size
-            end
-          end
-        end
-
-        context "with graph_name", if: RDF::VERSION.to_s >= "1.99" do
-          it "returns statements from all graphs with no graph_name" do
-            pattern = RDF::Query::Pattern.new(nil, nil, nil, graph_name: nil)
-            solutions = []
-            subject.send(:query_pattern, pattern) {|s| solutions << s}
-            expect(solutions.size).to eq @statements.size
-          end
-
-          it "returns statements from unnamed graphss with false graph_name" do
-            pattern = RDF::Query::Pattern.new(nil, nil, nil, graph_name: false)
-            solutions = []
-            subject.send(:query_pattern, pattern) {|s| solutions << s}
-            named_statements = subject.statements.reject {|st| st.has_name?}.length
-            expect(solutions.size).to eq named_statements
-          end
-
-          it "returns statements from named graphss with variable graph_name" do
-            unless subject.graph_names.to_a.empty?
-              pattern = RDF::Query::Pattern.new(nil, nil, nil, graph_name: :c)
-              solutions = []
-              subject.send(:query_pattern, pattern) {|s| solutions << s}
-              named_statements = subject.statements.select {|st| st.has_name?}.length
-              expect(solutions.size).to eq named_statements
-            end
-          end
-
-          it "returns statements from specific graph with URI graph_name" do
-            unless subject.graph_names.to_a.empty?
-              pattern = RDF::Query::Pattern.new(nil, nil, nil, graph_name: RDF::URI("http://ar.to/#self"))
-              solutions = []
-              subject.send(:query_pattern, pattern) {|s| solutions << s}
-              expect(solutions.size).to eq File.readlines(@doap).grep(/^<http:\/\/ar.to\/\#self>/).size
-            end
-          end
-        end
-      end
+      
+      include_examples 'query pattern', :query_pattern 
     end
 
     ##
@@ -405,10 +379,11 @@ RSpec.shared_examples 'an RDF::Queryable' do
         expect(subject.first_subject).to eq subject.first.subject
       end
 
-      it "returns the correct value when the pattern matches" do
+      it "returns an appropriate value when the pattern matches" do
         matching_patterns = [[nil, nil, nil], [RDF::URI("http://rubygems.org/gems/rdf"), nil, nil]]
         matching_patterns.each do |matching_pattern|
-          expect(subject.first_subject(matching_pattern)).to eq subject.query(matching_pattern).first.subject
+          matching_values = subject.query(matching_pattern).map(&:subject)
+          expect(matching_values).to include subject.first_subject(matching_pattern)
         end
       end
 
@@ -436,10 +411,11 @@ RSpec.shared_examples 'an RDF::Queryable' do
         expect(subject.first_predicate).to eq subject.first.predicate
       end
 
-      it "returns the correct value when the pattern matches" do
+      it "returns an appropriate value when the pattern matches" do
         matching_patterns = [[nil, nil, nil], [nil, subject.first.predicate, nil]]
         matching_patterns.each do |matching_pattern|
-          expect(subject.first_predicate(matching_pattern)).to eq subject.query(matching_pattern).first.predicate
+          matching_values = subject.query(matching_pattern).map(&:predicate)
+          expect(matching_values).to include subject.first_predicate(matching_pattern)
         end
       end
 
@@ -466,10 +442,11 @@ RSpec.shared_examples 'an RDF::Queryable' do
         expect(subject.first_object).to eq subject.first.object
       end
 
-      it "returns the correct value when the pattern matches" do
+      it "returns an appropriate value when the pattern matches" do
         matching_patterns = [[nil, nil, nil], [nil, nil, subject.first.object]]
         matching_patterns.each do |matching_pattern|
-          expect(subject.first_object(matching_pattern)).to eq subject.query(matching_pattern).first.object
+          matching_values = subject.query(matching_pattern).map(&:object)
+          expect(matching_values).to include subject.first_object(matching_pattern)
         end
       end
 
@@ -534,14 +511,16 @@ RSpec.shared_examples 'an RDF::Queryable' do
         expect(subject.first_value).to eq subject.first_literal.value
       end
 
-      it "returns the correct value when the pattern matches" do
+      it "returns an appropriate value when the pattern matches" do
         matching_patterns = []
         subject.each do |statement|
           if statement.object.is_a?(RDF::Literal)
             matching_pattern = [statement.subject, statement.predicate, nil]
             unless matching_patterns.include?(matching_pattern)
               matching_patterns << matching_pattern
-              expect(subject.first_value(matching_pattern)).to eq subject.first_literal(matching_pattern).value
+              matching_values = subject.query(matching_pattern).map(&:object).map(&:value)
+              first_value = subject.first_value(matching_pattern)
+              expect(matching_values).to include(first_value)
             end
           end
         end
@@ -559,25 +538,3 @@ RSpec.shared_examples 'an RDF::Queryable' do
     end
   end
 end
-
-##
-# @deprecated use `it_behaves_like "an RDF::Queryable"` instead
-module RDF_Queryable
-  extend RSpec::SharedContext
-  include RDF::Spec::Matchers
-
-  def self.included(mod)
-    warn "[DEPRECATION] `RDF_Queryable` is deprecated. "\
-         "Please use `it_behaves_like 'an RDF::Queryable'`"
-  end
-
-  describe 'examples for' do
-    include_examples 'an RDF::Queryable' do
-      let(:queryable) { @queryable }
-
-      before do
-        raise '@queryable must be defined' unless defined?(queryable)
-      end
-    end
-  end
-end

data/lib/rdf/spec/readable.rb

@@ -15,25 +15,3 @@ RSpec.shared_examples 'an RDF::Readable' do
     its(:readable?) { is_expected.to eq subject.readable? }
   end
 end
-
-##
-# @deprecated use `it_behaves_like "an RDF::Readable"` instead
-module RDF_Readable
-  extend RSpec::SharedContext
-  include RDF::Spec::Matchers
-
-  def self.included(mod)
-    warn "[DEPRECATION] `RDF_Readable` is deprecated. "\
-         "Please use `it_behaves_like 'an RDF::Readable'`"
-  end
-
-  describe 'examples for' do
-    include_examples 'an RDF::Readable' do
-      let(:readable) { @readable }
-
-      before do
-        raise '@readable must be defined' unless defined?(readable)
-      end
-    end
-  end
-end

data/lib/rdf/spec/reader.rb

@@ -7,6 +7,7 @@ RSpec.shared_examples 'an RDF::Reader' do
     raise 'reader must be defined with let(:reader)' unless defined? reader
     raise 'reader_input must be defined with let(:reader_input)' unless defined? reader_input
     raise 'reader_count must be defined with let(:reader_count)' unless defined? reader_count
+    # define reader_invalid_input for invalid input
   end
 
   let(:reader_class) { reader.class }
@@ -107,12 +108,31 @@ RSpec.shared_examples 'an RDF::Reader' do
       end
     end
 
-    it "sets validate given validate: true" do
+    it "validates given validate: true" do
       reader_class.new(reader_input, validate: true) do |r|
         expect(r).to be_valid
       end
     end
 
+    it "invalidates on any logged error if validate: true" do
+      logger = RDF::Spec.logger
+      reader_class.new(reader_input, validate: true, logger: logger) do |r|
+        expect(r).to be_valid
+        r.log_error("some error")
+        expect(r).not_to be_valid
+      end
+      expect(logger.to_s).to include("ERROR")
+    end
+
+    it "invalidates given invalid input and validate: true" do
+      invalid_input = reader_invalid_input rescue "!!invalid input??"
+      logger = RDF::Spec.logger
+      reader_class.new(invalid_input, validate: true, logger: logger) do |r|
+        expect(r).not_to be_valid
+        expect(logger.to_s).to include("ERROR")
+      end
+    end
+
     it "sets canonicalize given canonicalize: true" do
       reader_mock = double("reader")
       expect(reader_mock).to receive(:got_here)
@@ -204,31 +224,3 @@ RSpec.shared_examples 'an RDF::Reader' do
 
   end
 end
-
-##
-# @deprecated use `it_behaves_like "an RDF::Reader"` instead
-module RDF_Reader
-  extend RSpec::SharedContext
-  include RDF::Spec::Matchers
-
-  def self.included(mod)
-    warn "[DEPRECATION] `RDF_Reader` is deprecated. "\
-         "Please use `it_behaves_like 'an RDF::Reader'`"
-  end
-
-  describe 'examples for' do
-    include_examples 'an RDF::Reader' do
-      let(:reader) { @reader }
-      let(:reader_input) { @reader_input }
-      let(:reader_count) { @reader_count }
-      let(:reader_class) { @reader_class }
-
-      before do
-        raise '@reader must be defined' unless defined?(reader)
-        raise '@reader_input must be defined' unless defined?(reader_input)
-        raise '@reader_count must be defined' unless defined?(reader_count)
-        raise '@reader_class must be defined' unless defined?(reader_class)
-      end
-    end
-  end
-end