relaton 1.7.pre7 → 1.7.0

data/spec/relaton/db_spec.rb

@@ -1,121 +1,6 @@
 RSpec.describe Relaton::Db do
   before(:each) { FileUtils.rm_rf %w[testcache testcache2] }
 
-  context "modifing database" do
-    let(:db) { Relaton::Db.new "testcache", "testcache2" }
-
-    before(:each) do
-      db.save_entry "ISO(ISO 123)", "<bibitem id='ISO123></bibitem>"
-    end
-
-    context "move to new dir" do
-      let(:db) { Relaton::Db.new "global_cache", "local_cache" }
-
-      after(:each) do
-        FileUtils.rm_rf "global_cache"
-        FileUtils.rm_rf "local_cache"
-      end
-
-      it "global cache" do
-        expect(File.exist?("global_cache")).to be true
-        expect(db.mv("testcache")).to eq "testcache"
-        expect(File.exist?("testcache")).to be true
-        expect(File.exist?("global_cache")).to be false
-      end
-
-      it "local cache" do
-        expect(File.exist?("local_cache")).to be true
-        expect(db.mv("testcache2", type: :local)).to eq "testcache2"
-        expect(File.exist?("testcache2")).to be true
-        expect(File.exist?("local_cache")).to be false
-      end
-    end
-
-    it "warn if moving in existed dir" do
-      expect(File).to receive(:exist?).with("new_cache_dir")
-        .and_return true
-      expect do
-        expect(db.mv("new_cache_dir")).to be_nil
-      end.to output(/\[relaton\] WARNING: target directory exists/).to_stderr
-    end
-
-    it "clear" do
-      expect(File.exist?("testcache/iso")).to be true
-      expect(File.exist?("testcache2/iso")).to be true
-      db.clear
-      expect(File.exist?("testcache/iso")).to be false
-      expect(File.exist?("testcache2/iso")).to be false
-    end
-  end
-
-  context "query in local DB" do
-    let(:db) { Relaton::Db.new "testcache", "testcache2" }
-
-    before(:each) do
-      db.save_entry "ISO(ISO 123)", <<~DOC
-        <bibitem id='ISO123'>
-          <title>The first test</title><edition>2</edition><date type="published"><on>2011-10-12</on></date>
-        </bibitem>
-      DOC
-      db.save_entry "IEC(IEC 123)", <<~DOC
-        <bibitem id="IEC123">
-          <title>The second test</title><edition>1</edition><date type="published"><on>2015-12</on></date>
-        </bibitem>
-      DOC
-    end
-
-    after(:each) { db.clear }
-
-    it "one document" do
-      item = db.fetch_db "ISO((ISO 124)"
-      expect(item).to be_nil
-      item = db.fetch_db "ISO(ISO 123)"
-      expect(item).to be_instance_of RelatonIsoBib::IsoBibliographicItem
-    end
-
-    it "all documents" do
-      items = db.fetch_all
-      expect(items.size).to be 9
-      expect(items[7]).to be_instance_of RelatonIec::IecBibliographicItem
-      expect(items[8]).to be_instance_of RelatonIsoBib::IsoBibliographicItem
-    end
-
-    context "search for text" do
-      it do
-        items = db.fetch_all "test"
-        expect(items.size).to eq 2
-        items = db.fetch_all "first"
-        expect(items.size).to eq 1
-        expect(items[0].id).to eq "ISO123"
-      end
-
-      it "in attributes" do
-        items = db.fetch_all "123"
-        expect(items.size).to eq 2
-        items = db.fetch_all "ISO"
-        expect(items.size).to eq 8
-        expect(items[7].id).to eq "ISO123"
-      end
-
-      it "and fail" do
-        items = db.fetch_all "bibitem"
-        expect(items.size).to eq 0
-      end
-
-      it "and edition" do
-        items = db.fetch_all "123", edition: "2"
-        expect(items.size).to eq 1
-        expect(items[0].id).to eq "ISO123"
-      end
-
-      it "and year" do
-        items = db.fetch_all "123", year: 2015
-        expect(items.size).to eq 1
-        expect(items[0].id).to eq "IEC123"
-      end
-    end
-  end
-
   it "returns docid type" do
     db = Relaton::Db.new "testcache", "testcache2"
     expect(db.docid_type("CN(GB/T 1.1)")).to eq ["Chinese Standard", "GB/T 1.1"]
@@ -145,36 +30,6 @@ RSpec.describe Relaton::Db do
     end
   end
 
-  it "fetch document with net retries" do
-    db = Relaton::Db.new nil, nil
-    expect(db.instance_variable_get(:@registry).processors[:relaton_ietf]).to receive(:get)
-      .and_raise(RelatonBib::RequestError).exactly(3).times
-    expect { db.fetch "RFC 8341", nil, retries: 3 }.to raise_error RelatonBib::RequestError
-  end
-
-  context "async fetch" do
-    let(:db) { Relaton::Db.new nil, nil }
-    let(:queue) { Queue.new }
-
-    it "success" do
-      result = nil
-      VCR.use_cassette "rfc_8341" do
-        db.fetch_async("RFC 8341") { |r| queue << r }
-        Timeout.timeout(5) { result = queue.pop }
-      end
-      expect(result).to be_instance_of RelatonIetf::IetfBibliographicItem
-    end
-
-    it "prefix not found" do
-      result = ""
-      VCR.use_cassette "rfc_unsuccess" do
-        db.fetch_async("ABC 123456") { |r| queue << r }
-        Timeout.timeout(5) { result = queue.pop }
-      end
-      expect(result).to be_nil
-    end
-  end
-
   context "fetch documents form static cache" do
     let(:db) { Relaton::Db.new nil, nil }
 

data/spec/relaton/processor_spec.rb

@@ -23,9 +23,5 @@ RSpec.describe Relaton::Processor do
     it "hash_to_bib method should be implemented" do
       expect { subject.hash_to_bib({}) }.to raise_error StandardError
     end
-
-    it "grammar_hash method should be implemented" do
-      expect { subject.grammar_hash }.to raise_error StandardError
-    end
   end
 end

data/spec/relaton/regirtry_spec.rb

@@ -2,82 +2,72 @@ RSpec.describe Relaton::Registry do
   it "outputs backend not present" do
     stub_const "Relaton::Registry::SUPPORTED_GEMS", ["not_supported_gem"]
     expect { Relaton::Registry.clone.instance }.to output(
-      /backend not_supported_gem not present/
+      /backend not_supported_gem not present/,
     ).to_stdout
   end
 
   it "finds ISO processor" do
-    expect(Relaton::Registry.instance.find_processor("relaton_iso"))
-      .to be_instance_of RelatonIso::Processor
+    expect(Relaton::Registry.instance.find_processor("relaton_iso")).
+      to be_instance_of RelatonIso::Processor
   end
 
   it "returns supported processors" do
     expect(Relaton::Registry.instance.supported_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 RelatonGb::Processor
-    end
-
-    it "IEC" do
-      expect(Relaton::Registry.instance.by_type("IEC")).to be_instance_of RelatonIec::Processor
-    end
-
-    it "IETF" do
-      expect(Relaton::Registry.instance.by_type("IETF")).to be_instance_of RelatonIetf::Processor
-    end
+  it "finds processor by type" do
+    expect(Relaton::Registry.instance.by_type("CN")).to be_instance_of RelatonGb::Processor
+  end
 
-    it "ISO" do
-      expect(Relaton::Registry.instance.by_type("ISO")).to be_instance_of RelatonIso::Processor
-    end
+  it "finds processor by type" do
+    expect(Relaton::Registry.instance.by_type("IEC")).to be_instance_of RelatonIec::Processor
+  end
 
-    it "ITU" do
-      expect(Relaton::Registry.instance.by_type("ITU")).to be_instance_of RelatonItu::Processor
-    end
+  it "finds processor by type" do
+    expect(Relaton::Registry.instance.by_type("IETF")).to be_instance_of RelatonIetf::Processor
+  end
 
-    it "NIST" do
-      expect(Relaton::Registry.instance.by_type("NIST")).to be_instance_of RelatonNist::Processor
-    end
+  it "finds processor by type" do
+    expect(Relaton::Registry.instance.by_type("ISO")).to be_instance_of RelatonIso::Processor
+  end
 
-    it "OGC" do
-      expect(Relaton::Registry.instance.by_type("OGC")).to be_instance_of RelatonOgc::Processor
-    end
+  it "finds processor by type" do
+    expect(Relaton::Registry.instance.by_type("ITU")).to be_instance_of RelatonItu::Processor
+  end
 
-    it "CC" do
-      expect(Relaton::Registry.instance.by_type("CC")).to be_instance_of RelatonCalconnect::Processor
-    end
+  it "finds processor by type" do
+    expect(Relaton::Registry.instance.by_type("NIST")).to be_instance_of RelatonNist::Processor
+  end
 
-    it "OMG" do
-      expect(Relaton::Registry.instance.by_type("OMG")).to be_instance_of RelatonOmg::Processor
-    end
+  it "finds processor by type" do
+    expect(Relaton::Registry.instance.by_type("OGC")).to be_instance_of RelatonOgc::Processor
+  end
 
-    it "UN" do
-      expect(Relaton::Registry.instance.by_type("UN")).to be_instance_of RelatonUn::Processor
-    end
+  it "finds processor by type" do
+    expect(Relaton::Registry.instance.by_type("CC")).to be_instance_of RelatonCalconnect::Processor
+  end
 
-    it "W3C" do
-      expect(Relaton::Registry.instance.by_type("W3C")).to be_instance_of RelatonW3c::Processor
-    end
+  it "finds processor by type" do
+    expect(Relaton::Registry.instance.by_type("OMG")).to be_instance_of RelatonOmg::Processor
+  end
 
-    it "IEEE" do
-      expect(Relaton::Registry.instance.by_type("IEEE")).to be_instance_of RelatonIeee::Processor
-    end
+  it "finds processor by type" do
+    expect(Relaton::Registry.instance.by_type("UN")).to be_instance_of RelatonUn::Processor
+  end
 
-    it "IHO" do
-      expect(Relaton::Registry.instance.by_type("IHO")).to be_instance_of RelatonIho::Processor
-    end
+  it "finds processor by type" do
+    expect(Relaton::Registry.instance.by_type("W3C")).to be_instance_of RelatonW3c::Processor
+  end
 
-    it "BIPM" do
-      expect(Relaton::Registry.instance.by_type("BIPM")).to be_instance_of RelatonBipm::Processor
-    end
+  it "finds processor by type" do
+    expect(Relaton::Registry.instance.by_type("IEEE")).to be_instance_of RelatonIeee::Processor
+  end
 
-    it "ECMA" do
-      expect(Relaton::Registry.instance.by_type("ECMA")).to be_instance_of RelatonEcma::Processor
-    end
+  it "finds processor by type" do
+    expect(Relaton::Registry.instance.by_type("IHO")).to be_instance_of RelatonIho::Processor
+  end
 
-    it "CIE" do
-      expect(Relaton::Registry.instance.by_type("CIE")).to be_instance_of RelatonCie::Processor
-    end
+  it "finds processor by type" do
+    expect(Relaton::Registry.instance.by_type("BIPM")).to be_instance_of RelatonBipm::Processor
   end
 end

data/spec/relaton_spec.rb

@@ -58,28 +58,12 @@ RSpec.describe Relaton::Db do
         end
       end
     end
-
-    it "gets sn ISO/AWI reference" do
-      VCR.use_cassette "iso_awi_24229" do
-        bib = @db.fetch "ISO/AWI 24229"
-        expect(bib).not_to be_nil
-      end
-    end
   end
 
-  context "IEC" do
-    it "get by reference" do
-      VCR.use_cassette "iec_60050_102_2007" do
-        bib = @db.fetch "IEC 60050-102:2007"
-        expect(bib.docidentifier[0].id).to eq "IEC 60050-102:2007"
-      end
-    end
-
-    it "get by URN" do
-      VCR.use_cassette "iec_60050_102_2007" do
-        bib = @db.fetch "urn:iec:std:iec:60050-102:2007:::"
-        expect(bib.docidentifier[0].id).to eq "IEC 60050-102:2007"
-      end
+  it "gets sn ISO/AWI reference" do
+    VCR.use_cassette "iso_awi_24229" do
+      bib = @db.fetch "ISO/AWI 24229"
+      expect(bib).not_to be_nil
     end
   end
 
@@ -264,115 +248,30 @@ RSpec.describe Relaton::Db do
     end
   end
 
-  it "get ECMA reference" do
-    VCR.use_cassette "ecma_6" do
-      bib = @db.fetch "ECMA-6"
-      expect(bib).to be_instance_of RelatonBib::BibliographicItem
-    end
-  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 RelatonBib::BibliographicItem
-    end
-  end
-
-  context "get combined documents" do
-    context "ISO" do
-      it "included" do
-        VCR.use_cassette "iso_combined_included" do
-          bib = @db.fetch "ISO 19115-1 + Amd 1"
-          expect(bib.docidentifier[0].id).to eq "ISO 19115-1 + Amd 1"
-          expect(bib.relation[0].type).to eq "updates"
-          expect(bib.relation[0].bibitem.docidentifier[0].id).to eq "ISO 19115-1"
-          expect(bib.relation[1].type).to eq "derivedFrom"
-          expect(bib.relation[1].description).to be_nil
-          expect(bib.relation[1].bibitem.docidentifier[0].id).to eq "ISO 19115-1/Amd 1:2018"
-        end
-      end
-
-      it "applied" do
-        VCR.use_cassette "iso_combined_applied" do
-          bib = @db.fetch "ISO 19115-1, Amd 1"
-          expect(bib.docidentifier[0].id).to eq "ISO 19115-1, Amd 1"
-          expect(bib.relation[0].type).to eq "updates"
-          expect(bib.relation[0].bibitem.docidentifier[0].id).to eq "ISO 19115-1"
-          expect(bib.relation[1].type).to eq "complements"
-          expect(bib.relation[1].description.content).to eq "amendment"
-          expect(bib.relation[1].bibitem.docidentifier[0].id).to eq "ISO 19115-1/Amd 1:2018"
-        end
-      end
-    end
-
-    context "IEC" do
-      it "included" do
-        VCR.use_cassette "iec_combined_included" do
-          bib = @db.fetch "IEC 60027-1, Amd 1, Amd 2"
-          expect(bib.docidentifier[0].id).to eq "IEC 60027-1, Amd 1, Amd 2"
-          expect(bib.relation[0].type).to eq "updates"
-          expect(bib.relation[0].bibitem.docidentifier[0].id).to eq "IEC 60027-1"
-          expect(bib.relation[1].type).to eq "complements"
-          expect(bib.relation[1].description.content).to eq "amendment"
-          expect(bib.relation[1].bibitem.docidentifier[0].id).to eq "IEC 60027-1/AMD1:1997"
-          expect(bib.relation[2].type).to eq "complements"
-          expect(bib.relation[2].description.content).to eq "amendment"
-          expect(bib.relation[2].bibitem.docidentifier[0].id).to eq "IEC 60027-1/AMD2:2005"
-        end
-      end
-    end
-
-    context "ITU" do
-      it "included" do
-        VCR.use_cassette "itu_combined_included" do
-          bib = @db.fetch "ITU-T G.989.2, Amd 1, Amd 2"
-          expect(bib.docidentifier[0].id).to eq "ITU-T G.989.2, Amd 1, Amd 2"
-          expect(bib.relation[0].type).to eq "updates"
-          expect(bib.relation[0].bibitem.docidentifier[0].id).to eq "ITU-T G.989.2"
-          expect(bib.relation[1].type).to eq "complements"
-          expect(bib.relation[1].description.content).to eq "amendment"
-          expect(bib.relation[1].bibitem.docidentifier[0].id).to eq "ITU-T G.989.2/Amd 1"
-          expect(bib.relation[2].type).to eq "complements"
-          expect(bib.relation[2].description.content).to eq "amendment"
-          expect(bib.relation[2].bibitem.docidentifier[0].id).to eq "ITU-T G.989.2/Amd 2"
-        end
-      end
-    end
-
-    context "HIST" do
-      it "included" do
-        VCR.use_cassette "hist_cmbined_included" do
-          bib = @db.fetch "NIST SP 800-38A, Add"
-          expect(bib.docidentifier[0].id).to eq "NIST SP 800-38A, Add"
-          expect(bib.relation[0].type).to eq "updates"
-          expect(bib.relation[0].bibitem.docidentifier[0].id).to eq "SP 800-38A"
-          expect(bib.relation[1].type).to eq "complements"
-          expect(bib.relation[1].description.content).to eq "amendment"
-          expect(bib.relation[1].bibitem.docidentifier[0].id).to eq "SP 800-38A-Add"
-        end
-      end
-    end
-  end
-
   context "version control" do
-    before(:each) { @db.save_entry "iso(test_key)", "<bibitem><title>test_value</title></bibitem>" }
+    before(:each) { @db.save_entry "iso(test_key)", value: "test_value" }
 
     it "shoudn't clear cacho if version isn't changed" do
-      testcache = @db.instance_variable_get :@db
+      db = Relaton::Db.new "testcache", "testcache2"
+      testcache = db.instance_variable_get :@db
       expect(testcache.all).to be_any
-      testcache = @db.instance_variable_get :@local_db
+      testcache = db.instance_variable_get :@local_db
       expect(testcache.all).to be_any
     end
 
     it "should clear cache if version is changed" do
-      expect(File.read("testcache/iso/version", encoding: "UTF-8")).not_to eq "new_version"
-      expect(File.read("testcache2/iso/version", encoding: "UTF-8")).not_to eq "new_version"
+      expect(File.exist?("testcache")).to be true
+      expect(File.exist?("testcache2")).to be true
       processor = double
-      expect(processor).to receive(:grammar_hash).and_return("new_version").exactly(2).times
-      expect(Relaton::Registry.instance).to receive(:by_type).and_return(processor).exactly(2).times
-      Relaton::Db.new "testcache", "testcache2"
-      expect(File.exist?("testcache/iso/version")).to eq false
-      expect(File.exist?("testcache2/iso/version")).to eq false
+      expect(processor).to receive(:grammar_hash).and_return("new_version")
+        .exactly(2).times
+      expect(Relaton::Registry.instance).to receive(:by_type)
+        .and_return(processor).exactly(2).times
+      db = Relaton::Db.new "testcache", "testcache2"
+      testcache = db.instance_variable_get :@db
+      expect(testcache.all).not_to be_any
+      testcache = db.instance_variable_get :@local_db
+      expect(testcache.all).not_to be_any
     end
   end
 end