relaton 2.1.0 → 2.2.0.pre.alpha.1

data/spec/relaton/registry_spec.rb

@@ -1,138 +1,138 @@
-RSpec.describe Relaton::Registry do
-  before { Relaton.instance_variable_set :@configuration, nil }
+RSpec.describe Relaton::Db::Registry do
+  before { Relaton::Db.instance_variable_set :@configuration, nil }
 
   it "outputs backend not present" do
-    stub_const "Relaton::Registry::SUPPORTED_GEMS", ["not_supported_gem"]
-    expect { Relaton::Registry.clone.instance }.to output(
-      /\[relaton\] ERROR: backend not_supported_gem not present/,
+    stub_const "Relaton::Db::Registry::SUPPORTED_GEMS", ["not_supported_gem"]
+    expect { Relaton::Db::Registry.clone.instance }.to output(
+      /\[relaton-db\] ERROR: backend not_supported_gem not present/,
     ).to_stderr_from_any_process
   end
 
   it "finds ISO processor" do
-    expect(Relaton::Registry.instance.find_processor("relaton_iso"))
+    expect(Relaton::Db::Registry.instance.find_processor("relaton_iso"))
       .to be_instance_of Relaton::Iso::Processor
   end
 
   it "returns supported processors" do
-    processors = Relaton::Registry.instance.supported_processors
+    processors = Relaton::Db::Registry.instance.supported_processors
     expect(processors).to include :relaton_iso
   end
 
   context "finds processor by type" do
     it "CN" do
-      expect(Relaton::Registry.instance.by_type("CN")).to be_instance_of Relaton::Gb::Processor
+      expect(Relaton::Db::Registry.instance.by_type("CN")).to be_instance_of Relaton::Gb::Processor
     end
 
     it "IEC" do
-      expect(Relaton::Registry.instance.by_type("IEC")).to be_instance_of Relaton::Iec::Processor
+      expect(Relaton::Db::Registry.instance.by_type("IEC")).to be_instance_of Relaton::Iec::Processor
     end
 
     it "IETF" do
-      expect(Relaton::Registry.instance.by_type("IETF")).to be_instance_of Relaton::Ietf::Processor
+      expect(Relaton::Db::Registry.instance.by_type("IETF")).to be_instance_of Relaton::Ietf::Processor
     end
 
     it "ISO" do
-      expect(Relaton::Registry.instance.by_type("ISO")).to be_instance_of Relaton::Iso::Processor
+      expect(Relaton::Db::Registry.instance.by_type("ISO")).to be_instance_of Relaton::Iso::Processor
     end
 
     it "ITU" do
-      expect(Relaton::Registry.instance.by_type("ITU")).to be_instance_of Relaton::Itu::Processor
+      expect(Relaton::Db::Registry.instance.by_type("ITU")).to be_instance_of Relaton::Itu::Processor
     end
 
     it "NIST" do
-      expect(Relaton::Registry.instance.by_type("NIST")).to be_instance_of Relaton::Nist::Processor
+      expect(Relaton::Db::Registry.instance.by_type("NIST")).to be_instance_of Relaton::Nist::Processor
     end
 
     it "OGC" do
-      expect(Relaton::Registry.instance.by_type("OGC")).to be_instance_of Relaton::Ogc::Processor
+      expect(Relaton::Db::Registry.instance.by_type("OGC")).to be_instance_of Relaton::Ogc::Processor
     end
 
     it "CC" do
-      expect(Relaton::Registry.instance.by_type("CC")).to be_instance_of Relaton::Calconnect::Processor
+      expect(Relaton::Db::Registry.instance.by_type("CC")).to be_instance_of Relaton::Calconnect::Processor
     end
 
     it "OMG" do
-      expect(Relaton::Registry.instance.by_type("OMG")).to be_instance_of Relaton::Omg::Processor
+      expect(Relaton::Db::Registry.instance.by_type("OMG")).to be_instance_of Relaton::Omg::Processor
     end
 
     it "UN" do
-      expect(Relaton::Registry.instance.by_type("UN")).to be_instance_of Relaton::Un::Processor
+      expect(Relaton::Db::Registry.instance.by_type("UN")).to be_instance_of Relaton::Un::Processor
     end
 
     it "W3C" do
-      expect(Relaton::Registry.instance.by_type("W3C")).to be_instance_of Relaton::W3c::Processor
+      expect(Relaton::Db::Registry.instance.by_type("W3C")).to be_instance_of Relaton::W3c::Processor
     end
 
     it "IEEE" do
-      expect(Relaton::Registry.instance.by_type("IEEE")).to be_instance_of Relaton::Ieee::Processor
+      expect(Relaton::Db::Registry.instance.by_type("IEEE")).to be_instance_of Relaton::Ieee::Processor
     end
 
     it "IHO" do
-      expect(Relaton::Registry.instance.by_type("IHO")).to be_instance_of Relaton::Iho::Processor
+      expect(Relaton::Db::Registry.instance.by_type("IHO")).to be_instance_of Relaton::Iho::Processor
     end
 
     it "BIPM" do
-      expect(Relaton::Registry.instance.by_type("BIPM")).to be_instance_of Relaton::Bipm::Processor
-      expect(Relaton::Registry.instance.processor_by_ref("CCTF"))
+      expect(Relaton::Db::Registry.instance.by_type("BIPM")).to be_instance_of Relaton::Bipm::Processor
+      expect(Relaton::Db::Registry.instance.processor_by_ref("CCTF"))
         .to be_instance_of Relaton::Bipm::Processor
     end
 
     it "ECMA" do
-      expect(Relaton::Registry.instance.by_type("ECMA")).to be_instance_of Relaton::Ecma::Processor
+      expect(Relaton::Db::Registry.instance.by_type("ECMA")).to be_instance_of Relaton::Ecma::Processor
     end
 
     it "CIE" do
-      expect(Relaton::Registry.instance.by_type("CIE")).to be_instance_of Relaton::Cie::Processor
+      expect(Relaton::Db::Registry.instance.by_type("CIE")).to be_instance_of Relaton::Cie::Processor
     end
 
     it "BSI" do
-      expect(Relaton::Registry.instance.by_type("BSI")).to be_instance_of Relaton::Bsi::Processor
+      expect(Relaton::Db::Registry.instance.by_type("BSI")).to be_instance_of Relaton::Bsi::Processor
     end
 
     it "CEN" do
-      expect(Relaton::Registry.instance.by_type("CEN")).to be_instance_of Relaton::Cen::Processor
+      expect(Relaton::Db::Registry.instance.by_type("CEN")).to be_instance_of Relaton::Cen::Processor
     end
 
     it "IANA" do
-      expect(Relaton::Registry.instance.by_type("IANA")).to be_instance_of Relaton::Iana::Processor
+      expect(Relaton::Db::Registry.instance.by_type("IANA")).to be_instance_of Relaton::Iana::Processor
     end
 
     it "3GPP" do
-      expect(Relaton::Registry.instance.by_type("3GPP")).to be_instance_of Relaton::ThreeGpp::Processor
+      expect(Relaton::Db::Registry.instance.by_type("3GPP")).to be_instance_of Relaton::ThreeGpp::Processor
     end
 
     it "OASIS" do
-      expect(Relaton::Registry.instance.by_type("OASIS")).to be_instance_of Relaton::Oasis::Processor
+      expect(Relaton::Db::Registry.instance.by_type("OASIS")).to be_instance_of Relaton::Oasis::Processor
     end
 
     it "DOI" do
-      expect(Relaton::Registry.instance.by_type("DOI")).to be_instance_of Relaton::Doi::Processor
-      expect(Relaton::Registry.instance.processor_by_ref("doi:10.1000/182"))
+      expect(Relaton::Db::Registry.instance.by_type("DOI")).to be_instance_of Relaton::Doi::Processor
+      expect(Relaton::Db::Registry.instance.processor_by_ref("doi:10.1000/182"))
         .to be_instance_of Relaton::Doi::Processor
     end
 
     it "JIS" do
-      expect(Relaton::Registry.instance.by_type("JIS")).to be_instance_of Relaton::Jis::Processor
+      expect(Relaton::Db::Registry.instance.by_type("JIS")).to be_instance_of Relaton::Jis::Processor
     end
 
     it "XSF" do
-      expect(Relaton::Registry.instance.by_type("XEP")).to be_instance_of Relaton::Xsf::Processor
+      expect(Relaton::Db::Registry.instance.by_type("XEP")).to be_instance_of Relaton::Xsf::Processor
     end
 
     it "CCSDS" do
-      expect(Relaton::Registry.instance.by_type("CCSDS")).to be_instance_of Relaton::Ccsds::Processor
+      expect(Relaton::Db::Registry.instance.by_type("CCSDS")).to be_instance_of Relaton::Ccsds::Processor
     end
 
     it "ETSI" do
-      expect(Relaton::Registry.instance.by_type("ETSI")).to be_instance_of Relaton::Etsi::Processor
+      expect(Relaton::Db::Registry.instance.by_type("ETSI")).to be_instance_of Relaton::Etsi::Processor
     end
 
     it "ISBN" do
-      expect(Relaton::Registry.instance.by_type("ISBN")).to be_instance_of Relaton::Isbn::Processor
+      expect(Relaton::Db::Registry.instance.by_type("ISBN")).to be_instance_of Relaton::Isbn::Processor
     end
 
     context "PLATEAU" do
-      let(:processor) { Relaton::Registry.instance.by_type("PLATEAU") }
+      let(:processor) { Relaton::Db::Registry.instance.by_type("PLATEAU") }
       before { processor }
 
       it "finds processor" do
@@ -167,12 +167,12 @@ RSpec.describe Relaton::Registry do
   end
 
   it "find processot by dataset" do
-    expect(Relaton::Registry.instance.find_processor_by_dataset("nist-tech-pubs"))
+    expect(Relaton::Db::Registry.instance.find_processor_by_dataset("nist-tech-pubs"))
       .to be_instance_of Relaton::Nist::Processor
   end
 
   it "find processor by dataset" do
-    expect(Relaton::Registry.instance.find_processor_by_dataset("etsi-csv"))
+    expect(Relaton::Db::Registry.instance.find_processor_by_dataset("etsi-csv"))
       .to be_instance_of Relaton::Etsi::Processor
   end
 end

data/spec/relaton/util_spec.rb

@@ -1,3 +1,3 @@
-describe Relaton::Util do
+describe Relaton::Db::Util do
   it { expect(described_class).to be_a Module }
 end

data/spec/relaton_meta_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+RSpec.describe "relaton top-level entry point" do
+  it "has a version" do
+    expect(Relaton::VERSION).to be_a(String)
+  end
+
+  it "loads Relaton::Db via require 'relaton'" do
+    expect(defined?(Relaton::Db)).to eq("constant")
+    expect(Relaton::Db).to be_a(Class)
+  end
+
+  it "exposes Relaton::Db::Registry" do
+    expect(defined?(Relaton::Db::Registry)).to eq("constant")
+  end
+
+  it "does NOT pull relaton-cli's runtime code via require 'relaton'" do
+    # The gem's lib/relaton.rb requires only relaton/db, not relaton/cli.
+    # Even if Relaton::Cli is defined as a module shell by some other code
+    # path, its runtime classes (Command, ::start) must not be loaded just
+    # from `require 'relaton'`.
+    expect(defined?(Relaton::Cli::Command)).to be_nil
+    expect(Relaton::Cli.respond_to?(:start)).to be(false) if defined?(Relaton::Cli)
+  end
+end

data/spec/relaton_spec.rb

@@ -2,7 +2,7 @@ RSpec.describe Relaton::Db do
   before :each do |example|
     FileUtils.rm_rf %w(testcache testcache2)
     @db = Relaton::Db.new "testcache", "testcache2"
-    Relaton.instance_variable_set :@configuration, nil
+    Relaton::Db.instance_variable_set :@configuration, nil
 
     if example.metadata[:vcr]
       require "relaton/index"
@@ -15,7 +15,7 @@ RSpec.describe Relaton::Db do
 
   it "rejects an illegal reference prefix" do
     expect { @db.fetch("XYZ XYZ", nil, {}) }.to output(
-      /\[relaton\] INFO: \(XYZ XYZ\) `XYZ XYZ` does not/,
+      /\[relaton-db\] INFO: \(XYZ XYZ\) `XYZ XYZ` does not/,
     ).to_stderr_from_any_process
   end
 
@@ -35,40 +35,58 @@ RSpec.describe Relaton::Db do
     end
 
     it "with year in code" do
-      VCR.use_cassette "iso_19133_2005" do
-        bib = @db.fetch("ISO 19133:2005")
-        expect(bib).to be_instance_of Relaton::Iso::ItemData
-        xml = bib.to_xml
-        expect(xml).to include 'id="ISO191332005"'
-        expect(xml).to include 'type="standard"'
-        testcache = Relaton::DbCache.new "testcache"
-        expect(
-          testcache.valid_entry?("ISO(ISO 19133:2005)", Date.today.year.to_s),
-        ).to eq Date.today.year.to_s
-      end
+      docid = Relaton::Bib::Docidentifier.new(content: "ISO 19133:2005",
+                                              type: "ISO", primary: true)
+      item = Relaton::Iso::ItemData.new(
+        docidentifier: [docid], fetched: Date.today.to_s, type: "standard",
+      )
+      expect(Relaton::Iso::Bibliography).to receive(:get)
+        .with("ISO 19133:2005", nil, {}).and_return item
+      bib = @db.fetch("ISO 19133:2005")
+      expect(bib).to be_instance_of Relaton::Iso::ItemData
+      xml = bib.to_xml
+      expect(xml).to include 'id="ISO191332005"'
+      expect(xml).to include 'type="standard"'
+      testcache = Relaton::Db::Cache.new "testcache"
+      expect(
+        testcache.valid_entry?("ISO(ISO 19133:2005)", Date.today.year.to_s),
+      ).to eq Date.today.year.to_s
     end
 
     context "all parts" do
+      let(:all_parts_item) do
+        docid = Relaton::Bib::Docidentifier.new(
+          content: "ISO 19115 (all parts)", type: "ISO", primary: true,
+        )
+        Relaton::Iso::ItemData.new(docidentifier: [docid],
+                                   fetched: Date.today.to_s)
+      end
+
       it "implicity" do
-        VCR.use_cassette "iso_19115_all_parts" do
-          bib = @db.fetch("ISO 19115", nil, all_parts: true)
-          expect(bib.docidentifier[0].content).to eq "ISO 19115 (all parts)"
-        end
+        expect(Relaton::Iso::Bibliography).to receive(:get)
+          .with("ISO 19115", nil, { all_parts: true }).and_return all_parts_item
+        bib = @db.fetch("ISO 19115", nil, all_parts: true)
+        expect(bib.docidentifier[0].content).to eq "ISO 19115 (all parts)"
       end
 
       it "explicity" do
-        VCR.use_cassette "iso_19115_all_parts" do
-          bib = @db.fetch("ISO 19115 (all parts)")
-          expect(bib.docidentifier[0].content).to eq "ISO 19115 (all parts)"
-        end
+        expect(Relaton::Iso::Bibliography).to receive(:get)
+          .with("ISO 19115 (all parts)", nil, {}).and_return all_parts_item
+        bib = @db.fetch("ISO 19115 (all parts)")
+        expect(bib.docidentifier[0].content).to eq "ISO 19115 (all parts)"
       end
     end
 
     it "gets sn ISO/DIS reference" do
-      VCR.use_cassette "iso_dis" do
-        bib = @db.fetch "ISO/DIS 14460"
-        expect(bib.docidentifier[0].content).to eq "ISO/DIS 14460"
-      end
+      docid = Relaton::Bib::Docidentifier.new(content: "ISO/DIS 14460",
+                                              type: "ISO")
+      item = Relaton::Iso::ItemData.new(
+        docidentifier: [docid], fetched: Date.today.to_s,
+      )
+      expect(Relaton::Iso::Bibliography).to receive(:get)
+        .with("ISO/DIS 14460", nil, {}).and_return item
+      bib = @db.fetch "ISO/DIS 14460"
+      expect(bib.docidentifier[0].content).to eq "ISO/DIS 14460"
     end
   end
 
@@ -129,20 +147,26 @@ RSpec.describe Relaton::Db do
       expect(bib).to be_nil
       expect(File.exist?("testcache")).to be true
       expect(File.exist?("testcache2")).to be true
-      testcache = Relaton::DbCache.new "testcache"
+      testcache = Relaton::Db::Cache.new "testcache"
       expect(testcache.fetched("ISO(ISO 111111119115-1)")).to eq Date.today.to_s
       expect(testcache["ISO(ISO 111111119115-1)"]).to include "not_found"
-      testcache = Relaton::DbCache.new "testcache2"
+      testcache = Relaton::Db::Cache.new "testcache2"
       expect(testcache.fetched("ISO(ISO 111111119115-1)")).to eq Date.today.to_s
       expect(testcache["ISO(ISO 111111119115-1)"]).to include "not_found"
     end
   end
 
   it "list all elements as a serialization" do
-    VCR.use_cassette "iso_19115_1_2", match_requests_on: [:path] do
-      @db.fetch "ISO 19115-1", nil, {}
-      @db.fetch "ISO 19115-2", nil, {}
+    %w[ISO\ 19115-1 ISO\ 19115-2].each do |code|
+      docid = Relaton::Bib::Docidentifier.new(content: code, type: "ISO",
+                                              primary: true)
+      item = Relaton::Iso::ItemData.new(docidentifier: [docid],
+                                        fetched: Date.today.to_s)
+      expect(Relaton::Iso::Bibliography).to receive(:get)
+        .with(code, nil, {}).and_return item
     end
+    @db.fetch "ISO 19115-1", nil, {}
+    @db.fetch "ISO 19115-2", nil, {}
     # file = "spec/support/list_entries.xml"
     # File.write file, @db.to_xml unless File.exist? file
     docs = Nokogiri::XML @db.to_xml
@@ -155,9 +179,9 @@ RSpec.describe Relaton::Db do
     expect(@db.load_entry("not existed key")).to be_nil
     @db.save_entry "test key", nil
     expect(@db.load_entry("test key")).to be_nil
-    testcache = Relaton::DbCache.new "testcache"
+    testcache = Relaton::Db::Cache.new "testcache"
     testcache.delete("test_key")
-    testcache2 = Relaton::DbCache.new "testcache2"
+    testcache2 = Relaton::Db::Cache.new "testcache2"
     testcache2.delete("test_key")
     expect(@db.load_entry("test key")).to be_nil
   end
@@ -172,11 +196,11 @@ RSpec.describe Relaton::Db do
         XML
         expect(File.exist?("testcache")).to be true
         expect(File.exist?("testcache2")).to be true
-        testcache = Relaton::DbCache.new "testcache"
+        testcache = Relaton::Db::Cache.new "testcache"
         expect(testcache["CN(GB/T 20223-2006)"]).to include <<~XML
           <project-number origyr="2006">GB/T 20223-2006</project-number>
         XML
-        testcache = Relaton::DbCache.new "testcache2"
+        testcache = Relaton::Db::Cache.new "testcache2"
         expect(testcache["CN(GB/T 20223-2006)"]).to include <<~XML
           <project-number origyr="2006">GB/T 20223-2006</project-number>
         XML
@@ -192,11 +216,11 @@ RSpec.describe Relaton::Db do
         XML
         expect(File.exist?("testcache")).to be true
         expect(File.exist?("testcache2")).to be true
-        testcache = Relaton::DbCache.new "testcache"
+        testcache = Relaton::Db::Cache.new "testcache"
         expect(testcache["CN(GB/T 20223-2006)"]).to include <<~XML
           <project-number origyr="2006">GB/T 20223-2006</project-number>
         XML
-        testcache = Relaton::DbCache.new "testcache2"
+        testcache = Relaton::Db::Cache.new "testcache2"
         expect(testcache["CN(GB/T 20223-2006)"]).to include <<~XML
           <project-number origyr="2006">GB/T 20223-2006</project-number>
         XML
@@ -213,11 +237,11 @@ RSpec.describe Relaton::Db do
       )
       expect(File.exist?("testcache")).to be true
       expect(File.exist?("testcache2")).to be true
-      testcache = Relaton::DbCache.new "testcache"
+      testcache = Relaton::Db::Cache.new "testcache"
       expect(testcache["IETF(RFC 8341)"]).to include(
         '<docidentifier type="IETF" primary="true">RFC 8341</docidentifier>',
       )
-      testcache = Relaton::DbCache.new "testcache2"
+      testcache = Relaton::Db::Cache.new "testcache2"
       expect(testcache["IETF(RFC 8341)"]).to include(
         '<docidentifier type="IETF" primary="true">RFC 8341</docidentifier>',
       )
@@ -305,7 +329,13 @@ RSpec.describe Relaton::Db do
     expect(bib.docidentifier.first.content).to eq "CCSDS 230.2-G-1"
   end
 
-  it "get IEEE reference", vcr: "ieee_528_2019" do
+  it "get IEEE reference" do
+    require "relaton/ieee"
+    docid = Relaton::Bib::Docidentifier.new(content: "IEEE Std 528-2019",
+                                            type: "IEEE")
+    item = Relaton::Ieee::ItemData.new docidentifier: [docid]
+    expect(Relaton::Ieee::Bibliography).to receive(:get)
+      .with("IEEE Std 528-2019", nil, {}).and_return item
     bib = @db.fetch "IEEE Std 528-2019"
     expect(bib).to be_instance_of Relaton::Ieee::ItemData
   end
@@ -322,17 +352,23 @@ RSpec.describe Relaton::Db do
   end
 
   it "get ECMA reference" do
-    VCR.use_cassette "ecma_6" do
-      bib = @db.fetch "ECMA-6"
-      expect(bib).to be_instance_of Relaton::Ecma::ItemData
-    end
+    require "relaton/ecma"
+    docid = Relaton::Bib::Docidentifier.new(content: "ECMA-6", type: "ECMA")
+    item = Relaton::Ecma::ItemData.new docidentifier: [docid]
+    expect(Relaton::Ecma::Bibliography).to receive(:get)
+      .with("ECMA-6", nil, {}).and_return item
+    bib = @db.fetch "ECMA-6"
+    expect(bib).to be_instance_of Relaton::Ecma::ItemData
   end
 
   it "get CIE reference" do
-    VCR.use_cassette "cie_001_1980" do
-      bib = @db.fetch "CIE 001-1980"
-      expect(bib).to be_instance_of Relaton::Cie::ItemData
-    end
+    require "relaton/cie"
+    docid = Relaton::Bib::Docidentifier.new(content: "CIE 001-1980", type: "CIE")
+    item = Relaton::Cie::ItemData.new docidentifier: [docid]
+    expect(Relaton::Cie::Bibliography).to receive(:get)
+      .with("CIE 001-1980", nil, {}).and_return item
+    bib = @db.fetch "CIE 001-1980"
+    expect(bib).to be_instance_of Relaton::Cie::ItemData
   end
 
   it "get BSI reference" do
@@ -348,10 +384,13 @@ RSpec.describe Relaton::Db do
   end
 
   it "get CEN reference" do
-    VCR.use_cassette "en_10160_1999" do
-      bib = @db.fetch "EN 10160:1999"
-      expect(bib).to be_instance_of Relaton::Cen::ItemData
-    end
+    require "relaton/cen"
+    docid = Relaton::Bib::Docidentifier.new(content: "EN 10160:1999", type: "CEN")
+    item = Relaton::Cen::ItemData.new docidentifier: [docid]
+    expect(Relaton::Cen::Bibliography).to receive(:get)
+      .with("EN 10160:1999", nil, {}).and_return item
+    bib = @db.fetch "EN 10160:1999"
+    expect(bib).to be_instance_of Relaton::Cen::ItemData
   end
 
   it "get IANA reference" do
@@ -368,10 +407,15 @@ RSpec.describe Relaton::Db do
   end
 
   it "get 3GPP reference" do
-    VCR.use_cassette "3gpp_tr_00_01u_umts_3_0_0" do
-      bib = @db.fetch "3GPP TR 00.01U:UMTS/3.0.0"
-      expect(bib).to be_instance_of Relaton::ThreeGpp::ItemData
-    end
+    require "relaton/3gpp"
+    docid = Relaton::Bib::Docidentifier.new(
+      content: "3GPP TR 00.01U:UMTS/3.0.0", type: "3GPP",
+    )
+    item = Relaton::ThreeGpp::ItemData.new docidentifier: [docid]
+    expect(Relaton::ThreeGpp::Bibliography).to receive(:get)
+      .with("3GPP TR 00.01U:UMTS/3.0.0", nil, {}).and_return item
+    bib = @db.fetch "3GPP TR 00.01U:UMTS/3.0.0"
+    expect(bib).to be_instance_of Relaton::ThreeGpp::ItemData
   end
 
   it "get OASIS reference" do
@@ -401,7 +445,14 @@ RSpec.describe Relaton::Db do
     expect(bib.docidentifier.first.content).to eq "BIPM Metrologia 29 6 373"
   end
 
-  it "get DOI reference", vcr: "doi_10_6028_nist_ir_8245" do
+  it "get DOI reference" do
+    require "relaton/doi"
+    docid = Relaton::Bib::Docidentifier.new(
+      content: "10.6028/nist.ir.8245", type: "DOI",
+    )
+    item = Relaton::Bib::ItemData.new docidentifier: [docid]
+    expect(Relaton::Doi::Crossref).to receive(:get)
+      .with("doi:10.6028/nist.ir.8245").and_return item
     bib = @db.fetch "doi:10.6028/nist.ir.8245"
     expect(bib).to be_instance_of Relaton::Bib::ItemData
   end
@@ -469,39 +520,54 @@ RSpec.describe Relaton::Db do
 
   context "get combined documents" do
     context "ISO" do
+      # combine_doc (Db's own logic) fetches the base + amendment separately
+      # and assembles the relation graph; only the per-part lookups are stubbed,
+      # so the relation types/descriptions assembled here stay fully exercised.
+      def iso_item(content)
+        docid = Relaton::Bib::Docidentifier.new(content: content, type: "ISO",
+                                                primary: true)
+        Relaton::Iso::ItemData.new(docidentifier: [docid],
+                                   fetched: Date.today.to_s)
+      end
+
+      before do
+        expect(Relaton::Iso::Bibliography).to receive(:get)
+          .with("ISO 19115-1:2014", nil, {})
+          .and_return iso_item("ISO 19115-1:2014")
+        expect(Relaton::Iso::Bibliography).to receive(:get)
+          .with("ISO 19115-1:2014/Amd 1", nil, {})
+          .and_return iso_item("ISO 19115-1:2014/Amd 1:2018")
+      end
+
       it "included" do
-        VCR.use_cassette "iso_combined_included" do
-          bib = @db.fetch "ISO 19115-1:2014 + Amd 1"
-          expect(bib.docidentifier[0].content)
-            .to eq "ISO 19115-1:2014 + Amd 1"
-          expect(bib.relation[0].type).to eq "updates"
-          rel0 = bib.relation[0].bibitem
-          expect(rel0.docidentifier[0].content)
-            .to eq "ISO 19115-1:2014"
-          expect(bib.relation[1].type).to eq "derivedFrom"
-          expect(bib.relation[1].description).to be_nil
-          rel1 = bib.relation[1].bibitem
-          expect(rel1.docidentifier[0].content)
-            .to eq "ISO 19115-1:2014/Amd 1:2018"
-        end
+        bib = @db.fetch "ISO 19115-1:2014 + Amd 1"
+        expect(bib.docidentifier[0].content)
+          .to eq "ISO 19115-1:2014 + Amd 1"
+        expect(bib.relation[0].type).to eq "updates"
+        rel0 = bib.relation[0].bibitem
+        expect(rel0.docidentifier[0].content)
+          .to eq "ISO 19115-1:2014"
+        expect(bib.relation[1].type).to eq "derivedFrom"
+        expect(bib.relation[1].description).to be_nil
+        rel1 = bib.relation[1].bibitem
+        expect(rel1.docidentifier[0].content)
+          .to eq "ISO 19115-1:2014/Amd 1:2018"
       end
 
       it "applied" do
-        VCR.use_cassette "iso_combined_applied" do
-          bib = @db.fetch "ISO 19115-1:2014, Amd 1"
-          expect(bib.docidentifier[0].content)
-            .to eq "ISO 19115-1:2014, Amd 1"
-          expect(bib.relation[0].type).to eq "updates"
-          rel0 = bib.relation[0].bibitem
-          expect(rel0.docidentifier[0].content)
-            .to eq "ISO 19115-1:2014"
-          expect(bib.relation[1].type).to eq "complements"
-          expect(bib.relation[1].description.content)
-            .to eq "amendment"
-          rel1 = bib.relation[1].bibitem
-          expect(rel1.docidentifier[0].content)
-            .to eq "ISO 19115-1:2014/Amd 1:2018"
-        end
+        bib = @db.fetch "ISO 19115-1:2014, Amd 1"
+        expect(bib.docidentifier[0].content)
+          .to eq "ISO 19115-1:2014, Amd 1"
+        expect(bib.relation[0].type).to eq "updates"
+        rel0 = bib.relation[0].bibitem
+        expect(rel0.docidentifier[0].content)
+          .to eq "ISO 19115-1:2014"
+        expect(bib.relation[1].type).to eq "complements"
+        expect(bib.relation[1].description.content)
+          .to eq "amendment"
+        rel1 = bib.relation[1].bibitem
+        expect(rel1.docidentifier[0].content)
+          .to eq "ISO 19115-1:2014/Amd 1:2018"
       end
     end
 
@@ -679,7 +745,7 @@ RSpec.describe Relaton::Db do
       processor = double "processor", short: :relaton_iso
       expect(processor).to receive(:grammar_hash)
         .and_return("new_version").exactly(2).times
-      expect(Relaton::Registry.instance)
+      expect(Relaton::Db::Registry.instance)
         .to receive(:by_type)
         .and_return(processor).exactly(2).times
       Relaton::Db.new "testcache", "testcache2"
@@ -690,14 +756,14 @@ RSpec.describe Relaton::Db do
 
   context "api.relaton.org" do
     before(:each) do
-      Relaton.configure do |config|
+      Relaton::Db.configure do |config|
         config.use_api = true
         # config.api_host = "http://0.0.0.0:9292"
       end
     end
 
     after(:each) do
-      Relaton.configure do |config|
+      Relaton::Db.configure do |config|
         config.use_api = false
       end
     end
@@ -710,6 +776,15 @@ RSpec.describe Relaton::Db do
     end
 
     it "if unavailable then get document directly" do
+      docid = Relaton::Bib::Docidentifier.new(content: "ISO 19115-2:2019",
+                                              type: "ISO", primary: true)
+      item = Relaton::Iso::ItemData.new(docidentifier: [docid],
+                                        fetched: Date.today.to_s)
+      # api.relaton.org is refused below, so the fetch must fall back to the
+      # flavor's direct lookup -- stub that so the fallback path is exercised
+      # without depending on the live ISO index.
+      expect(Relaton::Iso::Bibliography).to receive(:get)
+        .with("ISO 19115-2", "2019", {}).and_return item
       expect(Net::HTTP).to receive(:get_response)
         .and_wrap_original do |m, *args|
         raise Errno::ECONNREFUSED if args[0].host == "api.relaton.org"

data/spec/spec_helper.rb

@@ -24,9 +24,9 @@ SimpleCov.start do
   add_filter "/spec/"
 end
 
-require "relaton"
+require "relaton/db"
 
-Relaton.configure do |config|
+Relaton::Db.configure do |config|
   config.use_api = false
 end