rdf-tabular 0.1.3.1 → 0.2.0

data/spec/format_spec.rb

@@ -4,19 +4,22 @@ require 'spec_helper'
 require 'rdf/spec/format'
 
 describe RDF::Tabular::Format do
-  before :each do
-    @format_class = described_class
+  it_behaves_like 'an RDF::Format' do
+    let(:format_class) {RDF::Tabular::Format}
   end
 
-  include RDF_Format
-
   describe ".for" do
     formats = [
       :tabular,
       'etc/doap.csv',
-      {:file_name      => 'etc/doap.csv'},
-      {:file_extension => 'csv'},
-      {:content_type   => 'text/csv'},
+      'etc/doap.tsv',
+      {file_name:      'etc/doap.csv'},
+      {file_name:      'etc/doap.tsv'},
+      {file_extension: 'csv'},
+      {file_extension: 'tsv'},
+      {content_type:   'text/csv'},
+      {content_type:   'text/tab-separated-values'},
+      {content_type:   'application/csvm+json'},
     ].each do |arg|
       it "discovers with #{arg.inspect}" do
         expect(RDF::Tabular::Format).to include RDF::Format.for(arg)
@@ -25,6 +28,6 @@ describe RDF::Tabular::Format do
   end
 
   describe "#to_sym" do
-    specify {expect(@format_class.to_sym).to eq :tabular}
+    specify {expect(described_class.to_sym).to eq :tabular}
   end
 end

data/spec/matchers.rb

@@ -47,8 +47,8 @@ RSpec::Matchers.define :be_equivalent_graph do |expected, info|
     else
       "Graph differs\n"
     end +
-    "Expected:\n#{@expected.dump(:ttl, standard_prefixes: true, prefixes: prefixes)}" +
-    "Results:\n#{@actual.dump(:ttl, standard_prefixes: true, prefixes: prefixes)}" +
+    "Expected:\n#{@expected.dump(:ttl, standard_prefixes: true, prefixes: prefixes, literal_shorthand: false)}" +
+    "Results:\n#{@actual.dump(:ttl, standard_prefixes: true, prefixes: prefixes, literal_shorthand: false)}" +
     (@info.metadata ? "\nMetadata:\n#{@info.metadata.to_json(JSON_STATE)}\n" : "") +
     (@info.metadata && !@info.metadata.errors.empty? ? "\nMetadata Errors:\n#{@info.metadata.errors.join("\n")}\n" : "") +
     (@info.debug ? "\nDebug:\n#{@info.debug}" : "")
@@ -85,7 +85,7 @@ RSpec::Matchers.define :pass_query do |expected, info|
       "Query returned true (expected #{@info.result})"
     end +
     "\n#{@expected}" +
-    "\nResults:\n#{@actual.dump(:ttl, standard_prefixes: true, prefixes: {'' => @info.action + '#'})}" +
+    "\nResults:\n#{@actual.dump(:ttl, standard_prefixes: true, prefixes: {'' => @info.action + '#'}, literal_shorthand: false)}" +
     (@info.metadata ? "\nMetadata:\n#{@info.metadata.to_json(JSON_STATE)}\n" : "") +
     (@info.metadata && !@info.metadata.errors.empty? ? "\nMetadata Errors:\n#{@info.metadata.errors.join("\n")}\n" : "") +
     "\nDebug:\n#{@info.debug}"
@@ -103,7 +103,7 @@ RSpec::Matchers.define :pass_query do |expected, info|
       "Query returned true (expected #{@info.result})"
     end +
     "\n#{@expected}" +
-    "\nResults:\n#{@actual.dump(:ttl, standard_prefixes: true, prefixes: {'' => @info.action + '#'})}" +
+    "\nResults:\n#{@actual.dump(:ttl, standard_prefixes: true, prefixes: {'' => @info.action + '#'}, literal_shorthand: false)}" +
     (@info.metadata ? "\nMetadata:\n#{@info.metadata.to_json(JSON_STATE)}\n" : "") +
     (@info.metadata && !@info.metadata.errors.empty? ? "\nMetadata Errors:\n#{@info.metadata.errors.join("\n")}\n" : "") +
     "\nDebug:\n#{@info.debug}"

data/spec/metadata_spec.rb

@@ -14,7 +14,7 @@ describe RDF::Tabular::Metadata do
         end
 
         case file
-        when "metadata.json", "country-codes-and-names.csv-metadata.json"
+        when "csv-metadata.json", "country-codes-and-names.csv-metadata.json"
           {status: 401}
         else
           {
@@ -37,7 +37,15 @@ describe RDF::Tabular::Metadata do
         valid: (%w(anyAtomicType string token language Name NCName boolean gYear number binary datetime any xml html json) +
                [{"base" => "string"}]
                ),
-        invalid: [1, true, "foo", "anyType", "anySimpleType", "IDREFS"]
+        invalid: [1, true, "http://example.org/",
+                 {"base" => "foo"},
+                 {"base" => "anyType"},
+                 {"base" => "anySimpleType"},
+                 {"base" => "IDREFS"},
+                 ],
+        errors: [{"@id" => "_:foo"},
+                 {"@id" => "http://www.w3.org/2001/XMLSchema#string"},
+               ]
       },
       default: {
         valid: ["foo"],
@@ -68,8 +76,8 @@ describe RDF::Tabular::Metadata do
         invalid: [nil, "foo", 1, 0, "true", "false", "TrUe", "fAlSe", "1", "0"],
       },
       separator: {
-        valid: %w(, a | :) + [nil],
-        invalid: [1, false] + %w(foo ::)
+        valid: %w(, a | : foo ::) + [nil],
+        invalid: [1, false]
       },
       "textDirection" => {
         valid: %w(rtl ltr),
@@ -87,19 +95,25 @@ describe RDF::Tabular::Metadata do
       context prop.to_s do
         if allowed
           it "validates" do
-            params[:valid].each do |v|
+            params.fetch(:valid, {}).each do |v|
               subject.send("#{prop}=".to_sym, v)
               expect(subject.errors).to be_empty
               expect(subject.warnings).to be_empty
             end
           end
           it "invalidates" do
-            params[:invalid].each do |v|
+            params.fetch(:invalid, {}).each do |v|
               subject.send("#{prop}=".to_sym, v)
               expect(subject.errors).to be_empty
               expect(subject.warnings).not_to be_empty
             end
           end
+          it "errors" do
+            params.fetch(:error, {}).each do |v|
+              subject.send("#{prop}=".to_sym, v)
+              expect(subject.errors).not_to be_empty
+            end
+          end
         else
           it "does not allow" do
             params[:valid].each do |v|
@@ -588,12 +602,12 @@ describe RDF::Tabular::Metadata do
         invalid: [1, true, nil]
       },
       tableDirection: {
-        valid: %w(rtl ltr default),
+        valid: %w(rtl ltr auto),
         warning: %w(foo true 1)
       },
       transformations: {
-        valid: [[RDF::Tabular::Transformation.new(url: "http://example", targetFormat: "http://example", scriptFormat: "http://example/")]],
-        warning: [RDF::Tabular::Transformation.new(url: "http://example", targetFormat: "http://example", scriptFormat: "http://example/")] +
+        valid: [[RDF::Tabular::Transformation.new({url: "http://example", targetFormat: "http://example", scriptFormat: "http://example/"}, context: "http://www.w3.org/ns/csvw", base: RDF::URI("http://example.org/base"))]],
+        warning: [RDF::Tabular::Transformation.new({url: "http://example", targetFormat: "http://example", scriptFormat: "http://example/"}, context: "http://www.w3.org/ns/csvw", base: RDF::URI("http://example.org/base"))] +
                  %w(foo true 1)
       },
       dialect: {
@@ -643,7 +657,7 @@ describe RDF::Tabular::Metadata do
         warning: [1, true, nil]
       },
       tableDirection: {
-        valid: %w(rtl ltr default),
+        valid: %w(rtl ltr auto),
         warning: %w(foo true 1)
       },
       dialect: {
@@ -651,8 +665,8 @@ describe RDF::Tabular::Metadata do
         warning: [1]
       },
       transformations: {
-        valid: [[RDF::Tabular::Transformation.new(url: "http://example", targetFormat: "http://example", scriptFormat: "http://example/")]],
-        warning: [RDF::Tabular::Transformation.new(url: "http://example", targetFormat: "http://example", scriptFormat: "http://example/")] +
+        valid: [[RDF::Tabular::Transformation.new({url: "http://example", targetFormat: "http://example", scriptFormat: "http://example/"}, context: "http://www.w3.org/ns/csvw", base: RDF::URI("http://example.org/base"))]],
+        warning: [RDF::Tabular::Transformation.new({url: "http://example", targetFormat: "http://example", scriptFormat: "http://example/"}, context: "http://www.w3.org/ns/csvw", base: RDF::URI("http://example.org/base"))] +
                  %w(foo true 1)
       },
       notes: {
@@ -1014,6 +1028,7 @@ describe RDF::Tabular::Metadata do
         # Strings
         "string with no constraints" => {base: "string", value: "foo", result: "foo"},
         "string with matching length" => {base: "string", value: "foo", length: 3, result: "foo"},
+        "string matching null when required" => {base: "string", value: "NULL", null: "NULL", required: true},
         "string with wrong length" => {
           base: "string",
           value: "foo",
@@ -1040,36 +1055,31 @@ describe RDF::Tabular::Metadata do
         },
         "decimal with matching pattern" => {
           base: "decimal",
-          format: {pattern: '\d{3}'},
+          format: {"pattern" => '000'},
           value: "123"
         },
         "decimal with wrong pattern" => {
           base: "decimal",
-          format: {pattern: '\d{4}'},
+          format: {"pattern" => '0000'},
           value: "123",
           errors: [/123 does not match pattern/]
         },
-        "decimal with implicit groupChar" => {
-          base: "decimal",
-          value: %("123,456.789"),
-          result: "123456.789"
-        },
         "decimal with explicit groupChar" => {
           base: "decimal",
-          format: {groupChar: ";"},
+          format: {"groupChar" => ";"},
           value: "123;456.789",
           result: "123456.789"
         },
         "decimal with repeated groupChar" => {
           base: "decimal",
-          format: {groupChar: ";"},
+          format: {"groupChar" => ";"},
           value: "123;;456.789",
           result: "123;;456.789",
           errors: [/has repeating/]
         },
         "decimal with explicit decimalChar" => {
           base: "decimal",
-          format: {decimalChar: ";"},
+          format: {"decimalChar" => ";"},
           value: "123456;789",
           result: "123456.789"
         },
@@ -1081,11 +1091,13 @@ describe RDF::Tabular::Metadata do
         },
         "decimal with percent" => {
           base: "decimal",
+          format: {"groupChar" => ","},
           value: "123456.789%",
           result: "1234.56789"
         },
         "decimal with per-mille" => {
           base: "decimal",
+          format: {"groupChar" => ","},
           value: "123456.789‰",
           result: "123.456789"
         },
@@ -1121,7 +1133,7 @@ describe RDF::Tabular::Metadata do
         "NaN number" => {base: "number", value: "NaN"},
         "INF number" => {base: "number", value: "INF"},
         "-INF number" => {base: "number", value: "-INF"},
-        "valid float" => {base: "float", value: "1234.456E789"},
+        "valid float" => {base: "float", value: "1234.456E7"},
         "invalid float" => {base: "float", value: "1z", errors: ["1z is not a valid float"]},
         "NaN float" => {base: "float", value: "NaN"},
         "INF float" => {base: "float", value: "INF"},
@@ -1152,6 +1164,7 @@ describe RDF::Tabular::Metadata do
         "validate date M.d.yyyy" => {base: "date", value: "3.22.2015", format: "M.d.yyyy", result: "2015-03-22"},
 
         # Times
+        "valid time HH:mm:ss.S" => {base: "time", value: "15:02:37.1", format: "HH:mm:ss.S", result: "15:02:37.1"},
         "valid time HH:mm:ss" => {base: "time", value: "15:02:37", format: "HH:mm:ss", result: "15:02:37"},
         "valid time HHmmss" => {base: "time", value: "150237", format: "HHmmss", result: "15:02:37"},
         "valid time HH:mm" => {base: "time", value: "15:02", format: "HH:mm", result: "15:02:00"},
@@ -1159,6 +1172,7 @@ describe RDF::Tabular::Metadata do
 
         # DateTimes
         "valid dateTime yyyy-MM-ddTHH:mm:ss" => {base: "dateTime", value: "2015-03-15T15:02:37", format: "yyyy-MM-ddTHH:mm:ss", result: "2015-03-15T15:02:37"},
+        "valid dateTime yyyy-MM-ddTHH:mm:ss.S" => {base: "dateTime", value: "2015-03-15T15:02:37.1", format: "yyyy-MM-ddTHH:mm:ss.S", result: "2015-03-15T15:02:37.1"},
         "valid dateTime yyyy-MM-dd HH:mm:ss" => {base: "dateTime", value: "2015-03-15 15:02:37", format: "yyyy-MM-dd HH:mm:ss", result: "2015-03-15T15:02:37"},
         "valid dateTime yyyyMMdd HHmmss"   => {base: "dateTime", value: "20150315 150237",   format: "yyyyMMdd HHmmss",   result: "2015-03-15T15:02:37"},
         "valid dateTime dd-MM-yyyy HH:mm" => {base: "dateTime", value: "15-03-2015 15:02", format: "dd-MM-yyyy HH:mm", result: "2015-03-15T15:02:00"},
@@ -1210,17 +1224,6 @@ describe RDF::Tabular::Metadata do
         "valid Name" => {base: "Name", value: "someThing", result: RDF::Literal("someThing", datatype: RDF::XSD.Name)},
         "valid NMTOKEN" => {base: "NMTOKEN", value: "someThing", result: RDF::Literal("someThing", datatype: RDF::XSD.NMTOKEN)},
 
-        # Unsupported datatypes
-        "anyType not allowed" => {base: "anyType", value: "some thing", errors: [/unsupported datatype/]},
-        "anySimpleType not allowed" => {base: "anySimpleType", value: "some thing", errors: [/unsupported datatype/]},
-        "ENTITIES not allowed" => {base: "ENTITIES", value: "some thing", errors: [/unsupported datatype/]},
-        "IDREFS not allowed" => {base: "IDREFS", value: "some thing", errors: [/unsupported datatype/]},
-        "NMTOKENS not allowed" => {base: "NMTOKENS", value: "some thing", errors: [/unsupported datatype/]},
-        "ENTITY not allowed" => {base: "ENTITY", value: "something", errors: [/unsupported datatype/]},
-        "ID not allowed" => {base: "ID", value: "something", errors: [/unsupported datatype/]},
-        "IDREF not allowed" => {base: "IDREF", value: "something", errors: [/unsupported datatype/]},
-        "NOTATION not allowed" => {base: "NOTATION", value: "some:thing", errors: [/unsupported datatype/]},
-
         # Aliases
         "number is alias for double" => {base: "number", value: "1234.456E789", result: RDF::Literal("1234.456E789", datatype: RDF::XSD.double)},
         "binary is alias for base64Binary" => {base: "binary", value: "Tm93IGlzIHRoZSB0aW1lIGZvciBhbGwgZ29vZCBjb2RlcnMKdG8gbGVhcm4g", result: RDF::Literal("Tm93IGlzIHRoZSB0aW1lIGZvciBhbGwgZ29vZCBjb2RlcnMKdG8gbGVhcm4g", datatype: RDF::XSD.base64Binary)},
@@ -1270,6 +1273,72 @@ describe RDF::Tabular::Metadata do
           specify {expect(subject.value).to eql result}
         end
       end
+
+      context "Unsupported datatypes" do
+        %w(anyType anySimpleType ENTITIES IDREFS NMTOKENS ENTITY ID IDREF NOTATAION foo).each do |base|
+          it "detects #{base} as unsupported" do
+            md = RDF::Tabular::Table.new({
+             url: "http://example.com/table.csv",
+              tableSchema: {
+                columns: [{
+                  name: "name",
+                  datatype: base
+                }]
+              }
+            })
+            expect(md.warnings).not_to be_empty
+          end
+        end
+      end
+    end
+  end
+
+  describe "#build_number_re" do
+    subject {RDF::Tabular::Datatype.new({})}
+    {
+      '#,##0.##'   => /^\d{1,}\.\d{,2}$/,
+      '#,##0.###'  => /^\d{1,}\.\d{,3}$/,
+      '###0.#####' => /^\d{1,}\.\d{,5}$/,
+      '###0.0000#' => /^\d{1,}\.\d{4,5}$/,
+      '00000.0000' => /^\d{5}\.\d{4}$/,
+      
+      '0'          => /^\d{1}$/,
+      '00'         => /^\d{2}$/,
+      '#'          => /^\d*$/,
+      '##'         => /^\d*$/,
+      
+      '.0'         => /^\.\d{1}$/,
+      '.00'        => /^\.\d{2}$/,
+      '.#'         => /^\.\d{,1}$/,
+      '.##'        => /^\.\d{,2}$/,
+      
+      '+0'         => /^+\d{1}$/,
+      '-0'         => /^-\d{1}$/,
+      '%0'         => /^%\d{1}$/,
+      '‰0'         => /^‰\d{1}$/,
+      '0%'         => /^\d{1}%$/,
+      '0‰'         => /^\d{1}‰$/,
+      '0.0%'       => /^\d{1}\.\d{1}%$/,
+
+      '#0.0#E#0'   => /^\d{1,}\.\d{1,2}E\d{1,2}$/,
+      '#0.0#E+#'   => /^\d{1,}\.\d{1,2}E+\d{,1}$/,
+      '#0.0#E-00'  => /^\d{1,}\.\d{1,2}E-\d{2}$/,
+      '#0.0#E#0%'  => /^\d{1,}\.\d{1,2}E\d{1,2}%$/,
+    }.each do |pattern,regexp|
+      it "generates #{regexp} for #{pattern}" do
+        expect(subject.build_number_re(pattern, ",", ".")).to eql regexp
+      end
+    end
+
+    %W{
+      +%0
+      0#
+      0E0
+      0-
+    }.each do |pattern|
+      it "recognizes bad pattern #{pattern}" do
+        expect{subject.build_number_re(pattern, ",", ".")}.to raise_error(ArgumentError)
+      end
     end
   end
 
@@ -1511,11 +1580,26 @@ describe RDF::Tabular::Metadata do
           "url": "http://example.org/table1",
           "tableSchema": {"columns": [{"titles": "foo"}]}
         }),
-        R: true
+        R: false
+      },
+      "tables with mismatch columns on name/titles" => {
+        A: %({
+          "@context": "http://www.w3.org/ns/csvw",
+          "@type": "Table",
+          "url": "http://example.org/table1",
+          "tableSchema": {"columns": [{"name": "foo"}]}
+        }),
+        B: %({
+          "@context": "http://www.w3.org/ns/csvw",
+          "@type": "Table",
+          "url": "http://example.org/table1",
+          "tableSchema": {"columns": [{"titles": "bar"}]}
+        }),
+        R: false
       },
     }.each do |name, props|
       it name do
-        a = described_class.new(::JSON.parse(props[:A]))
+        a = described_class.new(::JSON.parse(props[:A]), validate: true)
         b = described_class.new(::JSON.parse(props[:B]))
         if props[:R]
           expect {a.verify_compatible!(b)}.not_to raise_error

data/spec/reader_spec.rb

@@ -3,12 +3,10 @@ require File.join(File.dirname(__FILE__), 'spec_helper')
 require 'rdf/spec/reader'
 
 describe RDF::Tabular::Reader do
-  let!(:doap) {File.expand_path("../../etc/doap.ttl", __FILE__)}
-  let!(:doap_count) {File.open(doap).each_line.to_a.length}
+  let!(:doap) {File.expand_path("../../etc/doap.csv", __FILE__)}
+  let!(:doap_count) {9}
 
   before(:each) do
-    @reader = RDF::Tabular::Reader.new(StringIO.new(""), base_uri: "file:#{File.expand_path("..", __FILE__)}")
-
     WebMock.stub_request(:any, %r(.*example.org.*)).
       to_return(lambda {|request|
         file = request.uri.to_s.split('/').last
@@ -18,15 +16,15 @@ describe RDF::Tabular::Reader do
         else 'text/plain'
         end
 
-        case file
-        when "metadata.json", "country-codes-and-names.csv-metadata.json"
-          {status: 401}
-        else
+        path = File.expand_path("../data/#{file}", __FILE__)
+        if File.exist?(path)
           {
-            body: File.read(File.expand_path("../data/#{file}", __FILE__)),
+            body: File.read(path),
             status: 200,
             headers: {'Content-Type' => content_type}
           }
+        else
+          {status: 401}
         end
       })
 
@@ -34,7 +32,12 @@ describe RDF::Tabular::Reader do
   end
   
   # @see lib/rdf/spec/reader.rb in rdf-spec
-  #include RDF_Reader
+  # two failures specific to the way @input is handled in rdf-tabular make this a problem
+  #it_behaves_like 'an RDF::Reader' do
+  #  let(:reader_input) {doap}
+  #  let(:reader) {RDF::Tabular::Reader.new(StringIO.new(""))}
+  #  let(:reader_count) {doap_count}
+  #end
 
   it "should be discoverable" do
     readers = [
@@ -67,7 +70,7 @@ describe RDF::Tabular::Reader do
       expect_any_instance_of(RDF::Tabular::Dialect).to receive(:encoding=).with("ISO-8859-4")
       RDF::Tabular::Reader.new(input) {|r| r.each_statement {}}
     end
-    it "sets lang to de in metadata given Content-Language=de" do
+    it "sets lang to de in metadata given Content-Language=de", pending: "affecting some RSpec matcher" do
       input = double("input", content_type: "text/csv", headers: {content_language: "de"}, charset: nil)
       expect_any_instance_of(RDF::Tabular::Metadata).to receive(:lang=).with("de")
       RDF::Tabular::Reader.new(input) {|r| r.each_statement {}}
@@ -82,12 +85,12 @@ describe RDF::Tabular::Reader do
   context "non-file input" do
     let(:expected) {
       JSON.parse(%({
-        "table": [
+        "tables": [
           {
-            "url": "http://example.org/default-metadata",
+            "url": "",
             "row": [
               {
-                "url": "http://example.org/default-metadata#row=2",
+                "url": "#row=2",
                 "rownum": 1,
                 "describes": [
                   {
@@ -97,7 +100,7 @@ describe RDF::Tabular::Reader do
                 ]
               },
               {
-                "url": "http://example.org/default-metadata#row=3",
+                "url": "#row=3",
                 "rownum": 2,
                 "describes": [
                   {
@@ -107,7 +110,7 @@ describe RDF::Tabular::Reader do
                 ]
               },
               {
-                "url": "http://example.org/default-metadata#row=4",
+                "url": "#row=4",
                 "rownum": 3,
                 "describes": [
                   {
@@ -117,7 +120,7 @@ describe RDF::Tabular::Reader do
                 ]
               },
               {
-                "url": "http://example.org/default-metadata#row=5",
+                "url": "#row=5",
                 "rownum": 4,
                 "describes": [
                   {
@@ -168,7 +171,7 @@ describe RDF::Tabular::Reader do
 
           it "standard mode" do
             expected = File.expand_path("../data/#{ttl}", __FILE__)
-            RDF::Reader.open(input, format: :tabular, base_uri: about, noProv: true, validate: true, debug: @debug) do |reader|
+            RDF::Reader.open(input, format: :tabular, base_uri: about, noProv: true, debug: @debug) do |reader|
               graph = RDF::Graph.new << reader
               graph2 = RDF::Graph.load(expected, base_uri: about)
               expect(graph).to be_equivalent_graph(graph2,
@@ -258,6 +261,41 @@ describe RDF::Tabular::Reader do
     end
   end
 
+  context "Primary Keys" do
+    it "has expected primary keys" do
+      RDF::Reader.open("http://example.org/countries.json", format: :tabular, validate: true) do |reader|
+        reader.each_statement {}
+        pks = reader.metadata.tables.first.object[:rows].map(&:primaryKey)
+
+        # Each entry is an array of cells
+        expect(pks.map {|r| r.map(&:value).join(",")}).to eql %w(AD AE AF)
+      end
+    end
+
+    it "errors on duplicate primary keys" do
+      RDF::Reader.open("http://example.org/test232-metadata.json", format: :tabular, validate: true, errors: []) do |reader|
+        expect {reader.validate!}.to raise_error(RDF::Tabular::Error)
+
+        pks = reader.metadata.tables.first.object[:rows].map(&:primaryKey)
+
+        # Each entry is an array of cells
+        expect(pks.map {|r| r.map(&:value).join(",")}).to eql %w(1 1)
+
+        expect(reader.options[:errors]).to eq ["Table http://example.org/test232.csv has duplicate primary key 1"]
+      end
+    end
+  end
+
+  context "Foreign Keys" do
+    let(:path) {File.expand_path("../data/countries.json", __FILE__)}
+    it "validates consistent foreign keys" do
+      RDF::Reader.open(path, format: :tabular, validate: true, warnings: []) do |reader|
+        reader.each_statement {}
+        expect(reader.options[:warnings]).to be_empty
+      end
+    end
+  end
+
   context "Provenance" do
     {
       "country-codes-and-names.csv" => %(