qa 0.3.0 → 0.4.0

data/spec/internal/test/test_helper.rb

@@ -4,9 +4,6 @@ require 'rails/test_help'
 
 class ActiveSupport::TestCase
   # Setup all fixtures in test/fixtures/*.yml for all tests in alphabetical order.
-  #
-  # Note: You'll currently still have to declare fixtures explicitly in integration tests
-  # -- they do not yet inherit this setting
   fixtures :all
 
   # Add more helper methods to be used by all tests here...

data/spec/lib/authorities_getty_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+describe Qa::Authorities::Getty do
+
+  describe "#new" do
+    context "without a sub-authority" do
+      it "should raise an exception" do
+        expect { described_class.new }.to raise_error
+      end
+    end
+    context "with an invalid sub-authority" do
+      it "should raise an exception" do
+        expect { described_class.new("foo") }.to raise_error
+      end
+    end
+    context "with a valid sub-authority" do
+      it "should create the authority" do
+        expect(described_class.new("aat")).to be_kind_of described_class
+      end
+    end
+  end
+
+  let(:authority) { described_class.new("aat") }
+  describe "#build_query_url" do
+    subject { authority.build_query_url("foo") }
+    it { is_expected.to  match /^http:\/\/vocab\.getty\.edu\// }
+  end
+
+  describe "#find_url" do
+    subject { authority.find_url("300053264") }
+    it { is_expected.to eq "http://vocab.getty.edu/aat/300053264.json" }
+  end
+
+  describe "#search" do
+    context "authorities" do
+      before do
+        stub_request(:get, /vocab\.getty\.edu.*/).
+            with(:headers => {'Accept'=>'application/json'}).
+            to_return(:body => webmock_fixture("aat-response.txt"), :status => 200)
+      end
+
+      subject { authority.search('whatever') }
+
+      it "should have id and label keys" do
+        expect(subject.first).to eq("id" => 'http://vocab.getty.edu/aat/300053264', "label" => "photocopying")
+        expect(subject.last).to eq("id" => 'http://vocab.getty.edu/aat/300265560', "label" => "photoscreenprints")
+        expect(subject.size).to eq(10)
+      end
+    end
+  end
+
+  describe "#find" do
+    context "using a subject id" do
+      before do
+        stub_request(:get, "http://vocab.getty.edu/aat/300265560.json").
+          with(headers: { 'Accept'=>'application/json' }).
+          to_return(status: 200, body: webmock_fixture("getty-aat-find-response.json"))
+      end
+      subject { described_class.new("aat").find("300265560") }
+
+      it "returns the complete record for a given subject" do
+        expect(subject['results']['bindings'].size).to eq 189
+        expect(subject['results']['bindings']).to all(have_key('Subject'))
+        expect(subject['results']['bindings']).to all(have_key('Predicate'))
+        expect(subject['results']['bindings']).to all(have_key('Object'))
+      end
+    end
+  end
+
+end
+

data/spec/lib/authorities_loc_spec.rb

@@ -2,90 +2,123 @@ require 'spec_helper'
 
 describe Qa::Authorities::Loc do
 
-  before :all do
-    stub_request(:get, "http://id.loc.gov/search/?format=json&q=haw*&q=cs:http://id.loc.gov/vocabulary/geographicAreas").
-      with(:headers => {'Accept'=>'application/json'}).
-      to_return(:body => webmock_fixture("loc-response.txt"), :status => 200)
-    @authority = Qa::Authorities::Loc.new
-    @authority.search("haw*", "geographicAreas")
+  describe "#new" do
+    context "without a sub-authority" do
+      it "should raise an exception" do
+        expect { Qa::Authorities::Loc.new }.to raise_error
+      end
+    end
+    context "with an invalid sub-authority" do
+      it "should raise an exception" do
+        expect { Qa::Authorities::Loc.new("foo") }.to raise_error
+      end
+    end
+    context "with a valid sub-authority" do
+      it "should create the authority" do
+        expect(Qa::Authorities::Loc.new("subjects")).to be_kind_of Qa::Authorities::Loc
+      end
+    end
   end
+    
+  describe "urls" do
 
-  describe "geographic areas" do
-  
-    it "should instantiate with a query and return data" do
-      expect(@authority).not_to be_nil
-      @authority.raw_response.to_s.should include("id")
-    end  
-  
-    it "should return a sub_authority url" do
-      @authority.should_not be_nil
-      url = @authority.sub_authorityURL("geographicAreas")
-      expect(url).not_to be_nil
+    let :authority do
+      Qa::Authorities::Loc.new("subjects")
     end
-  
-    it "should not return a url for an invalid sub_authority" do
-      @authority.should_not be_nil
-      url = @authority.sub_authorityURL("invalid sub_authority")
-      expect(url).to eq("")
-    end
-  
-    it "should return JSON" do
-      @authority.should_not be_nil
-      json = @authority.parse_authority_response(@authority.raw_response)
-      expect(json).not_to be_empty
+    
+    context "for searching" do
+      it "should return a url" do
+        url = 'http://id.loc.gov/search/?q=foo&q=cs%3Ahttp%3A%2F%2Fid.loc.gov%2Fauthorities%2Fsubjects&format=json'
+        expect(authority.build_query_url("foo")).to eq(url)
+      end
     end
 
+    context "for returning single terms" do
+      it "returns a url with an authority and id" do
+        url = "http://id.loc.gov/authorities/subjects/sh2002003586.json"
+        expect(authority.find_url("sh2002003586")).to eq(url)
+      end
+    end
+  
   end
 
-  describe "subject headings" do
+  describe "#search" do
 
-    before :all do
-      stub_request(:get, "http://id.loc.gov/search/?format=json&q=History--&q=cs:http://id.loc.gov/authorities/subjects").
-        with(:headers => {'Accept'=>'application/json'}).
-        to_return(:body => webmock_fixture("loc-subjects-response.txt"), :status => 200)
-    end
+    context "any LOC authorities" do
+      let :authority do
+        stub_request(:get, "http://id.loc.gov/search/?format=json&q=s&q=cs:http://id.loc.gov/vocabulary/geographicAreas").
+            with(:headers => {'Accept'=>'application/json'}).
+            to_return(:body => webmock_fixture("loc-response.txt"), :status => 200)
+        Qa::Authorities::Loc.new("geographicAreas")
+      end
 
-    it "should be retrieved via search" do
-      @authority.search("History--", "subjects")
-      @authority.results.first["label"].should == "History--Philosophy--History--20th century"
-    end
+      it "should retain the raw respsonse from the LC service in JSON" do
+        expect(authority.raw_response).to be_nil
+        json = Qa::Authorities::WebServiceBase.new.get_json(authority.build_query_url("s"))
+        authority.search("s")
+        expect(authority.raw_response).to eq(json)
+      end
 
-  end
+      describe "the returned results" do
 
-  describe "name headings" do
+        let :results do
+          authority.search("s")
+        end
 
-    before :all do
-      stub_request(:get, "http://id.loc.gov/search/?format=json&q=Berry&q=cs:http://id.loc.gov/authorities/names").
-        with(:headers => {'Accept'=>'application/json'}).
-        to_return(:body => webmock_fixture("loc-names-response.txt"), :status => 200)
-    end
+        it "should have :id and :label elements" do
+          expect(results.first["label"]).to eq("West (U.S.)")
+          expect(results.first["id"]).to eq("info:lc/vocabulary/geographicAreas/n-usp")
+          expect(results.last["label"]).to eq("Baltic States")
+          expect(results.last["id"]).to eq("info:lc/vocabulary/geographicAreas/eb")
+          expect(results.size).to eq(20)
+        end
 
-    it "should be retrieved via search" do
-      @authority.search("Berry", "names")
-      @authority.results.first["label"].should == "Berry, James W. (James William), 1938-"
+      end
     end
- 
-  end
 
-  describe "#parse_authority_response" do
-    before :all  do
-      stub_request(:get, "http://id.loc.gov/search/?format=json&q=h&q=cs:http://id.loc.gov/authorities/subjects").
-        with(:headers => {'Accept'=>'application/json'}).
-        to_return(:body => webmock_fixture("loc-response.txt"), :status => 200)
-      @authority.search("h", "subjects")
+    context "subject terms" do
+      let :results do
+        stub_request(:get, "http://id.loc.gov/search/?format=json&q=History--&q=cs:http://id.loc.gov/authorities/subjects").
+            with(:headers => {'Accept'=>'application/json'}).
+            to_return(:body => webmock_fixture("loc-subjects-response.txt"), :status => 200)
+        Qa::Authorities::Loc.new("subjects").search("History--")
+      end
+      it "should have a URI for the id and a string label" do
+        expect(results.count).to eq(20)
+        expect(results.first["label"]).to eq("History--Philosophy--History--20th century")
+        expect(results.first["id"]).to eq("info:lc/authorities/subjects/sh2008121753")
+        expect(results[1]["label"]).to eq("History--Philosophy--History--19th century")
+        expect(results[1]["id"]).to eq("info:lc/authorities/subjects/sh2008121752")
+      end
     end
 
-    let(:parsed_response) { @authority.parse_authority_response(@authority.raw_response) }
-
-    it "should return an array of entries returned in the JSON" do
-      expect(parsed_response.length).to eq(2)
+    context "name terms" do
+      let :results do
+        stub_request(:get, "http://id.loc.gov/search/?format=json&q=Berry&q=cs:http://id.loc.gov/authorities/names").
+            with(:headers => {'Accept'=>'application/json'}).
+            to_return(:body => webmock_fixture("loc-names-response.txt"), :status => 200)
+            Qa::Authorities::Loc.new("names").search("Berry")
+      end
+      it "should retrieve names via search" do
+        expect(results.first["label"]).to eq("Berry, James W. (James William), 1938-")
+      end
     end
 
-    it "should have a URI for the id and a string label" do
-      expect(parsed_response[0]["id"]).to eq("info:lc/authorities/names/n2008008718")
-      expect(parsed_response[0]["label"]).to eq("Haw, Lily, 1890?-1915")
-      expect(parsed_response[1]["id"]).to eq("info:lc/vocabulary/geographicAreas/n-us-hi")
-      expect(parsed_response[1]["label"]).to eq("Hawaii")
+  end
+
+  describe "#find" do
+    context "using a subject id" do
+      let :results do
+        stub_request(:get, "http://id.loc.gov/authorities/subjects/sh2002003586.json").
+          with(:headers => {'Accept'=>'application/json', 'Accept-Encoding'=>'gzip, deflate', 'User-Agent'=>'Ruby'}).
+          to_return(:status => 200, :body => webmock_fixture("loc-subject-find-response.txt"), :headers => {})
+        Qa::Authorities::Loc.new("subjects").find("sh2002003586")
+      end
+      it "returns the complete record for a given subject" do
+        expect(results.count).to eq(20)
+        expect(results.first).to be_kind_of(Hash)
+      end
     end
   end
+
 end

data/spec/lib/authorities_loc_subauthorities.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+describe Qa::Authorities::LocSubauthority do
+
+  let(:subject) do
+    class TestAuthority
+      include Qa::Authorities::LocSubauthority
+    end
+    TestAuthority.new
+  end
+
+  context "with a valid subauthority" do
+    it "should return a url" do
+      sub_authority_table.keys.each do |authority|
+        expect(subject.get_url_for_authority(authority)).to eq(sub_authority_table[authority])
+      end
+    end
+  end
+
+  context "with a non-existent subauthority" do
+    it "should return nil" do
+      expect(subject.get_url_for_authority("fake")).to be_nil
+    end
+  end
+
+  # This is the original data structure that was used to define subauthority urls
+  # It is retained here to ensure our refactor succeeded
+  def sub_authority_table
+    begin
+      vocab_base_url = 'cs%3Ahttp%3A%2F%2Fid.loc.gov%2Fvocabulary%2F'
+      authority_base_url = 'cs%3Ahttp%3A%2F%2Fid.loc.gov%2Fauthorities%2F'
+      datatype_base_url = 'cs%3Ahttp%3A%2F%2Fid.loc.gov%2Fdatatypes%2F'
+      vocab_preservation_base_url = 'cs%3Ahttp%3A%2F%2Fid.loc.gov%2Fvocabulary%2Fpreservation%2F'
+      {
+        'subjects' => authority_base_url,
+        'names' => authority_base_url,
+        'classification' => authority_base_url,
+        'childrensSubjects' => authority_base_url,
+        'genreForms' => authority_base_url,
+        'performanceMediums' => authority_base_url,
+        'graphicMaterials' => vocab_base_url,
+        'organizations' => vocab_base_url,
+        'relators' => vocab_base_url,
+        'countries' => vocab_base_url,
+        'ethnographicTerms' => vocab_base_url,
+        'geographicAreas' => vocab_base_url,
+        'languages' => vocab_base_url,
+        'iso639-1' => vocab_base_url,
+        'iso639-2' => vocab_base_url,
+        'iso639-5' => vocab_base_url,
+        'edtf' => datatype_base_url,
+        'preservation' => vocab_base_url,
+        'actionsGranted' => vocab_base_url,
+        'agentType' => vocab_base_url,
+        'contentLocationType' => vocab_preservation_base_url,
+        'copyrightStatus' => vocab_preservation_base_url,
+        'cryptographicHashFunctions' => vocab_preservation_base_url,
+        'environmentCharacteristic' => vocab_preservation_base_url,
+        'environmentPurpose' => vocab_preservation_base_url,
+        'eventRelatedAgentRole' => vocab_preservation_base_url,
+        'eventRelatedObjectRole' => vocab_preservation_base_url,
+        'eventType' => vocab_preservation_base_url,
+        'formatRegistryRole' => vocab_preservation_base_url,
+        'hardwareType' => vocab_preservation_base_url,
+        'inhibitorTarget' => vocab_preservation_base_url,
+        'inhibitorType' => vocab_preservation_base_url,
+        'objectCategory' => vocab_preservation_base_url,
+        'preservationLevelRole' => vocab_preservation_base_url,
+        'relationshipSubType' => vocab_preservation_base_url,
+        'relationshipType' => vocab_preservation_base_url,
+        'rightsBasis' => vocab_preservation_base_url,
+        'rightsRelatedAgentRole' => vocab_preservation_base_url,
+        'signatureEncoding' => vocab_preservation_base_url,
+        'signatureMethod' => vocab_preservation_base_url,
+        'softwareType' => vocab_preservation_base_url,
+        'storageMedium' => vocab_preservation_base_url
+      }
+    end
+  end
+
+end

data/spec/lib/authorities_local_spec.rb

@@ -2,136 +2,110 @@ require 'spec_helper'
 
 describe Qa::Authorities::Local do
 
-  context "valid local sub_authorities" do
-    it "should validate the sub_authority" do
-      Qa::Authorities::Local.sub_authorities.should include "authority_A"
-      Qa::Authorities::Local.sub_authorities.should include "authority_B"
-    end    
+  let(:authority_a) { Qa::Authorities::Local.new("authority_A") }
+  let(:authority_b) { Qa::Authorities::Local.new("authority_B") }
+  let(:authority_c) { Qa::Authorities::Local.new("authority_C") }
+  let(:authority_d) { Qa::Authorities::Local.new("authority_D") }
 
-    describe "the class" do
-      subject { Qa::Authorities::Local }
-      it "should return a sub_authority" do
-        expect { subject.sub_authority('authority_Z')}.to raise_error ArgumentError, "Invalid sub-authority 'authority_Z'"
-        expect(subject.sub_authority('authority_A')).to be_kind_of Qa::Authorities::Subauthority
+  describe "::new" do
+    context "without a sub-authority" do
+      it "should raise an error is the sub-authority is not provided" do
+        expect { Qa::Authorities::Local.new }.to raise_error
+      end
+      it "should raise an error is the sub-authority does not exist" do
+        expect { Qa::Authorities::Local.new("foo") }.to raise_error
       end
-    end
-
-    it "should return a sub_authority" do
-      expect { subject.sub_authority('authority_Z')}.to raise_error ArgumentError, "Invalid sub-authority 'authority_Z'"
-      expect(subject.sub_authority('authority_A')).to be_kind_of Qa::Authorities::Subauthority
     end
   end
 
-  context "retrieve all entries for a local sub_authority" do
+  describe "#all" do
     let(:expected) { [ { 'id'=> "A1", 'label' => "Abc Term A1" },
                        { 'id' => "A2", 'label'=> "Term A2" },
                        { 'id' => "A3", 'label' => "Abc Term A3" } ] }
     it "should return all the entries" do
-      authorities = Qa::Authorities::Local.new
-      expect(authorities.search("", "authority_A")).to eq(expected)
+      expect(authority_a.all).to eq(expected)
     end
-  end
-
-  context "a malformed authority file " do
-    it "should raise an error" do
-      authorities = Qa::Authorities::Local.new
-      expect{ authorities.search("", "authority_D") }.to raise_error Psych::SyntaxError
+    context "when terms do not have ids" do
+      let(:expected) { [ { 'id' => "Term B1", 'label' => "Term B1" },
+                         { 'id' => "Term B2", 'label' => "Term B2" },
+                         { 'id' => "Term B3", 'label' => "Term B3" } ] }
+      it "should set the id to be same as the label" do
+        expect(authority_b.all).to eq(expected)
+      end
+    end
+    context "authority YAML file is a list of terms" do
+      let(:expected) { [ { 'id' => "Term C1", 'label' => "Term C1" }, 
+                         { 'id' => "Term C2", 'label' => "Term C2" },
+                         { 'id' => "Term C3", 'label' => "Term C3" } ] }
+      it "should use the terms as labels" do
+        expect(authority_c.all).to eq(expected)
+      end   
+    end
+    context "YAML file is malformed" do
+      it "should raise an error" do
+        expect { authority_d.all }.to raise_error
+      end
     end
   end
-  
-  context "retrieve a subset of entries for a local sub_authority" do
 
-    context "at least one matching entry" do
+  describe "#search" do
+    context "with an empty query string" do
+      let(:expected) { [] }
+      it "should return no results" do
+        expect(authority_a.search("")).to eq(expected)
+      end
+    end
+    context "with at least one matching entry" do
       let(:expected) { [ { 'id' => "A1", 'label' => "Abc Term A1" },
                          { 'id' => "A3", 'label' => "Abc Term A3" } ] }
       it "should return only entries matching the query term" do
-        authorities = Qa::Authorities::Local.new
-        expect(authorities.search("Abc", "authority_A")).to eq(expected)
+        expect(authority_a.search("Abc")).to eq(expected)
       end
-
       it "should match parts of words in the middle of the term" do
-        authorities = Qa::Authorities::Local.new
-        expect(authorities.search("Term A1", "authority_A")).to eq([{"id"=>"A1", "label"=>"Abc Term A1"}])
+        expect(authority_a.search("Term A1")).to eq([{"id"=>"A1", "label"=>"Abc Term A1"}])
+      end
+      it "should be case insensitive" do
+        expect(authority_a.search("aBc")).to eq(expected)
       end
     end
-    
-    context "no matching entries" do
+    context "with no matching entries" do
       let(:expected) { [] }
       it "should return an empty array" do
-        authorities = Qa::Authorities::Local.new
-        expect(authorities.search("def", "authority_A")).to eq(expected)
+        expect(authority_a.search("def")).to eq(expected)
       end
     end
-    
-    context "search not case-sensitive" do
-      let(:expected) { [ { 'id' => "A1", 'label' => "Abc Term A1" },
-                         { 'id' => "A3", 'label' => "Abc Term A3" } ] }
-      it "should return entries matching the query term without regard to case" do
-        authorities = Qa::Authorities::Local.new
-        expect(authorities.search("aBc", "authority_A")).to eq(expected)
-      end
-    end
-    
   end
   
-  context "retrieve full record for term" do
-
-    let(:authorities) { Qa::Authorities::Local.new }
-    
+  describe "#find" do
     context "source is a hash" do
       let(:id) { "A2" }
       let(:expected) { { 'id' => "A2", 'term' => "Term A2", 'active' => false } }
       it "should return the full term record" do
-        record = authorities.full_record(id, "authority_A")
+        record = authority_a.find(id)
         expect(record).to be_a HashWithIndifferentAccess
         expect(record).to eq(expected)
       end
     end
     context "source is a list" do
       it "should be indifferent access" do
-        record = authorities.full_record('Term C1', "authority_C")
+        record = authority_c.find("Term C1")
         expect(record).to be_a HashWithIndifferentAccess
       end
     end
-    
     context "term does not exist" do
       let(:id) { "NonID" }
       let(:expected) { {} }
       it "should return an empty hash" do
-        expect(authorities.full_record(id, "authority_A")).to eq(expected)
+        expect(authority_a.find(id)).to eq(expected)
       end
     end
-
     context "on a sub-authority" do
       it "should return the full term record" do
-        record = authorities.sub_authority('authority_A').full_record('A2')
+        record = authority_a.find("A2")
         expect(record).to be_a HashWithIndifferentAccess
         expect(record).to eq('id' => "A2", 'term' => "Term A2", 'active' => false)
       end
     end
-
-  end
-  
-  context "term does not an id" do
-    let(:authorities) { Qa::Authorities::Local.new }
-    let(:expected) { [ { 'id' => "Term B1", 'label' => "Term B1" },
-                       { 'id' => "Term B2", 'label' => "Term B2" },
-                       { 'id' => "Term B3", 'label' => "Term B3" } ] }
-    it "should set the id to be same as the label" do
-      expect(authorities.search("", "authority_B")).to eq(expected)
-    end
-  end
-  
-  context "authority YAML is a list of terms" do
-    let(:authorities) { Qa::Authorities::Local.new }
-    let(:expected) { [ { 'id' => "Term C1", 'label' => "Term C1" }, 
-                       { 'id' => "Term C2", 'label' => "Term C2" },
-                       { 'id' => "Term C3", 'label' => "Term C3" } ] }
-
-    it "should use the terms as labels" do
-      expect(authorities.search("", "authority_C")).to eq(expected)
-    end
-
   end
 
 end