qa 3.1.0 → 4.0.0.rc1

data/spec/services/iri_template_service_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+RSpec.describe Qa::IriTemplateService do
+  let(:url_template) do
+    {
+      :'@context' => 'http://www.w3.org/ns/hydra/context.jsonld',
+      :'@type' => 'IriTemplate',
+      template: 'http://localhost/test_default/search?{?subauth}&{?query}&{?max_records}&{?language}',
+      variableRepresentation: 'BasicRepresentation',
+      mapping: [
+        {
+          :'@type' => 'IriTemplateMapping',
+          variable: 'query',
+          property: 'hydra:freetextQuery',
+          required: true
+        },
+        {
+          :'@type' => 'IriTemplateMapping',
+          variable: 'subauth',
+          property: 'hydra:freetextQuery',
+          required: false,
+          default: 'personal_names'
+        },
+        {
+          :'@type' => 'IriTemplateMapping',
+          variable: 'max_records',
+          property: 'hydra:freetextQuery',
+          required: false,
+          default: 20
+        },
+        {
+          :'@type' => 'IriTemplateMapping',
+          variable: 'language',
+          property: 'hydra:freetextQuery',
+          required: false,
+          default: 'en'
+        }
+      ]
+    }
+  end
+  let(:url_config) { Qa::IriTemplate::UrlConfig.new(url_template) }
+
+  describe '.build_url' do
+    context 'when all substitutions specified' do
+      let(:substitutions) do
+        HashWithIndifferentAccess.new(
+          query: 'mark twain',
+          subauth: 'corporate_names',
+          max_records: 10,
+          language: 'fr'
+        )
+      end
+
+      it 'returns template with substitutions' do
+        expected_url = 'http://localhost/test_default/search?subauth=corporate_names&query=mark twain&max_records=10&language=fr'
+        expect(described_class.build_url(url_config: url_config, substitutions: substitutions)).to eq expected_url
+      end
+    end
+
+    context 'when minimal substitutions specified' do
+      let(:substitutions) { HashWithIndifferentAccess.new(query: 'mark twain') }
+
+      it 'returns template with substitutions' do
+        expected_url = 'http://localhost/test_default/search?subauth=personal_names&query=mark twain&max_records=20&language=en'
+        expect(described_class.build_url(url_config: url_config, substitutions: substitutions)).to eq expected_url
+      end
+    end
+  end
+end

data/spec/services/linked_data/authority_url_service_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+
+RSpec.describe Qa::LinkedData::AuthorityUrlService do
+  let(:authority) { :OCLC_FAST }
+  let(:search_config) { Qa::Authorities::LinkedData::Config.new(authority).search }
+  let(:term_config) { Qa::Authorities::LinkedData::Config.new(authority).term }
+  let(:action_config) { search_config }
+
+  let(:subauthority) { nil }
+  let(:action) { :search }
+  let(:action_request) { "mark+twain" }
+  let(:substitutions) do
+    {}
+  end
+
+  describe '.build_url' do
+    context 'when authority is not registered' do
+      let(:authority) { :BAD_AUTHORITY }
+
+      it 'raises error' do
+        expected_error = Qa::InvalidLinkedDataAuthority
+        expected_error_message = "Unable to initialize linked data authority 'BAD_AUTHORITY'"
+        expect { described_class.build_url(action_config: action_config, subauthority: subauthority, action: action, action_request: action_request, substitutions: substitutions) }
+          .to raise_error(expected_error, expected_error_message)
+      end
+    end
+
+    # TODO: elr - currently uses the default subauthority if the one passed in isn't supported
+    context 'when subauthority is not supported' do
+      let(:subauthority) { :BAD_SUBAUTHORITY }
+
+      it 'raises error' do
+        skip "Pending better handling of unsupported subauthorities"
+        expected_error = Qa::InvalidLinkedDataAuthority
+        expected_error_message = "Unable to initialize linked data sub-authority BAD_SUBAUTHORITY"
+        expect { described_class.build_url(action_config: action_config, subauthority: subauthority, action: action, action_request: action_request, substitutions: substitutions) }
+          .to raise_error(expected_error, expected_error_message)
+      end
+    end
+
+    context 'when invalid action is specified' do
+      let(:action) { :BAD_ACTION }
+
+      it 'raises error' do
+        expected_error = Qa::UnsupportedAction
+        expected_error_message = "BAD_ACTION Not Supported - Action must be one of the supported actions (e.g. :term, :search)"
+        expect { described_class.build_url(action_config: action_config, subauthority: subauthority, action: action, action_request: action_request, substitutions: substitutions) }
+          .to raise_error(expected_error, expected_error_message)
+      end
+    end
+
+    context 'when action_request is missing' do
+      let(:action_request) { nil }
+
+      it 'raises error' do
+        expected_error = Qa::IriTemplate::MissingParameter
+        expected_error_message = "query is required, but missing"
+        expect { described_class.build_url(action_config: action_config, subauthority: subauthority, action: action, action_request: action_request, substitutions: substitutions) }
+          .to raise_error(expected_error, expected_error_message)
+      end
+    end
+
+    subject do
+      described_class.build_url(action_config: action_config, subauthority: subauthority, action: action, action_request: action_request, substitutions: substitutions)
+    end
+
+    context 'when no errors' do
+      context 'and performing search action' do
+        context 'and all substitutions specified' do
+          let(:substitutions) do
+            HashWithIndifferentAccess.new(
+              maximumRecords: 10,
+              language: 'fr'
+            )
+          end
+          let(:subauthority) { 'personal_name' }
+          let(:action_request) { 'mark twain' }
+
+          it 'returns template with substitutions' do
+            expected_url = 'http://experimental.worldcat.org/fast/search?query=oclc.personalName+all+%22mark twain%22&sortKeys=usage&maximumRecords=10'
+            expect(subject).to eq expected_url
+          end
+        end
+
+        context 'when no substitutions specified' do
+          let(:action_request) { 'mark twain' }
+
+          it 'returns template with substitutions' do
+            expected_url = 'http://experimental.worldcat.org/fast/search?query=cql.any+all+%22mark twain%22&sortKeys=usage&maximumRecords=20'
+            expect(subject).to eq expected_url
+          end
+        end
+      end
+
+      context 'and performing term action' do
+        let(:action) { :term }
+        let(:action_config) { term_config }
+        let(:action_request) { 'n79021164' }
+
+        it 'returns template with substitutions' do
+          expected_url = 'http://id.worldcat.org/fast/n79021164'
+          expect(subject).to eq expected_url
+        end
+      end
+    end
+  end
+end

data/spec/services/linked_data/deep_sort_service_spec.rb

@@ -0,0 +1,260 @@
+require 'spec_helper'
+
+RSpec.describe Qa::LinkedData::DeepSortService do
+  describe "#deep_sort" do
+    subject { described_class.new(the_array, :sort, preferred_language).sort }
+
+    let(:preferred_language) { nil }
+
+    context 'as numeric sort' do
+      context 'when sort values are integers' do
+        let(:term_1) { RDF::Literal.new(1) }
+        let(:term_2) { RDF::Literal.new(15) }
+        let(:term_3) { RDF::Literal.new(20) }
+        let(:the_array) do
+          [{ sort: [term_2] },
+           { sort: [term_3] },
+           { sort: [term_1] }]
+        end
+
+        it "does numeric sort" do
+          expected_results = [{ sort: [term_1] },
+                              { sort: [term_2] },
+                              { sort: [term_3] }]
+          expect(subject).to eq expected_results
+        end
+      end
+
+      context 'when sort values are string representations of integers' do
+        let(:term_1) { RDF::Literal.new('1') }
+        let(:term_2) { RDF::Literal.new('15') }
+        let(:term_3) { RDF::Literal.new('20') }
+        let(:the_array) do
+          [{ sort: [term_2] },
+           { sort: [term_3] },
+           { sort: [term_1] }]
+        end
+
+        it "does numeric sort" do
+          expected_results = [{ sort: [term_1] },
+                              { sort: [term_2] },
+                              { sort: [term_3] }]
+          expect(subject).to eq expected_results
+        end
+      end
+
+      context 'when sort values are a mix of integer representations' do
+        let(:term_1) { RDF::Literal.new(1) }
+        let(:term_2) { RDF::Literal.new('15') }
+        let(:term_3) { RDF::Literal.new(20) }
+        let(:term_4) { RDF::Literal.new('201') }
+        let(:the_array) do
+          [{ sort: [term_2] },
+           { sort: [term_3] },
+           { sort: [term_1] },
+           { sort: [term_4] }]
+        end
+
+        it "does numeric sort" do
+          expected_results = [{ sort: [term_1] },
+                              { sort: [term_2] },
+                              { sort: [term_3] },
+                              { sort: [term_4] }]
+          expect(subject).to eq expected_results
+        end
+      end
+    end
+
+    context 'as single value sort' do
+      context 'when sort values do not have the language markers' do
+        let(:term_1) { RDF::Literal.new("apple") }
+        let(:term_2) { RDF::Literal.new("Banana") }
+        let(:term_3) { RDF::Literal.new("carrot") }
+        let(:the_array) do
+          [{ sort: [term_2] },
+           { sort: [term_3] },
+           { sort: [term_1] }]
+        end
+
+        it 'does alpha sort ignoring case' do
+          expected_results = [{ sort: [term_1] },
+                              { sort: [term_2] },
+                              { sort: [term_3] }]
+          expect(subject).to eq expected_results
+        end
+      end
+
+      context 'when sort values all have the same language marker' do
+        let(:term_1) { RDF::Literal.new("apple", language: :en) }
+        let(:term_2) { RDF::Literal.new("Banana", language: :en) }
+        let(:term_3) { RDF::Literal.new("carrot", language: :en) }
+        let(:the_array) do
+          [{ sort: [term_2] },
+           { sort: [term_3] },
+           { sort: [term_1] }]
+        end
+
+        it 'does alpha sort ignoring case' do
+          expected_results = [{ sort: [term_1] },
+                              { sort: [term_2] },
+                              { sort: [term_3] }]
+          expect(subject).to eq expected_results
+        end
+      end
+
+      context 'when sort values all have different language markers and no preferred language' do
+        let(:term_1) { RDF::Literal.new("Kuh", language: :de) }
+        let(:term_2) { RDF::Literal.new("Rind", language: :de) }
+        let(:term_3) { RDF::Literal.new("bovine", language: :en) }
+        let(:term_4) { RDF::Literal.new("cow", language: :en) }
+        let(:term_5) { RDF::Literal.new("vache", language: :fr) }
+        let(:term_6) { RDF::Literal.new("mucca") }
+        let(:term_7) { RDF::Literal.new("vaca") }
+        let(:the_array) do
+          [{ sort: [term_5] },
+           { sort: [term_7] },
+           { sort: [term_2] },
+           { sort: [term_6] },
+           { sort: [term_1] },
+           { sort: [term_4] },
+           { sort: [term_3] }]
+        end
+
+        it 'does alpha sort of languages and alpha sort of terms within each language' do
+          expected_results = [{ sort: [term_1] },
+                              { sort: [term_2] },
+                              { sort: [term_3] },
+                              { sort: [term_4] },
+                              { sort: [term_5] },
+                              { sort: [term_6] },
+                              { sort: [term_7] }]
+          expect(subject).to eq expected_results
+        end
+      end
+
+      context 'when sort values all have different language markers and has preferred language' do
+        let(:preferred_language) { :en }
+
+        let(:term_1) { RDF::Literal.new("bovine", language: :en) }
+        let(:term_2) { RDF::Literal.new("cow", language: :en) }
+        let(:term_3) { RDF::Literal.new("Kuh", language: :de) }
+        let(:term_4) { RDF::Literal.new("Rind", language: :de) }
+        let(:term_5) { RDF::Literal.new("vache", language: :fr) }
+        let(:term_6) { RDF::Literal.new("mucca") }
+        let(:term_7) { RDF::Literal.new("vaca") }
+        let(:the_array) do
+          [{ sort: [term_5] },
+           { sort: [term_7] },
+           { sort: [term_2] },
+           { sort: [term_6] },
+           { sort: [term_1] },
+           { sort: [term_4] },
+           { sort: [term_3] }]
+        end
+
+        it 'does alpha sort of languages shifting perferred language to the front and alpha sort of terms within each language' do
+          expected_results = [{ sort: [term_1] },
+                              { sort: [term_2] },
+                              { sort: [term_3] },
+                              { sort: [term_4] },
+                              { sort: [term_5] },
+                              { sort: [term_6] },
+                              { sort: [term_7] }]
+          expect(subject).to eq expected_results
+        end
+      end
+    end
+
+    context 'as multiple value sort' do
+      context 'when all the terms in both lists have no language markers' do
+        let(:term_1) { RDF::Literal.new("apple") }
+        let(:term_2) { RDF::Literal.new("Banana") }
+        let(:term_3) { RDF::Literal.new("carrot") }
+        let(:term_4) { RDF::Literal.new("Woof Woof") }
+        let(:the_array) do
+          [{ sort: [term_2, term_1] },
+           { sort: [term_3, term_2] },
+           { sort: [term_1, term_3, term_4, term_2] }]
+        end
+
+        it 'does alpha sort ignoring case' do
+          expected_results = [{ sort: [term_1, term_2] },
+                              { sort: [term_1, term_2, term_3, term_4] },
+                              { sort: [term_2, term_3] }]
+          expect(subject).to eq expected_results
+        end
+      end
+
+      context 'when all the terms in both lists have the same language markers' do
+        let(:term_1) { RDF::Literal.new("bovine", language: :en) }
+        let(:term_2) { RDF::Literal.new("Cow", language: :en) }
+        let(:term_3) { RDF::Literal.new("hefer", language: :en) }
+        let(:term_4) { RDF::Literal.new("Moo Moo", language: :en) }
+        let(:the_array) do
+          [{ sort: [term_2, term_1] },
+           { sort: [term_3, term_2] },
+           { sort: [term_1, term_3, term_4, term_2] }]
+        end
+
+        it 'does alpha sort ignoring case' do
+          expected_results = [{ sort: [term_1, term_2] },
+                              { sort: [term_1, term_2, term_3, term_4] },
+                              { sort: [term_2, term_3] }]
+          expect(subject).to eq expected_results
+        end
+      end
+
+      context 'when terms exist in both lists that match the preferred language' do
+        let(:preferred_language) { :en }
+
+        let(:term_1) { RDF::Literal.new("bovine", language: :en) }
+        let(:term_2) { RDF::Literal.new("cow", language: :en) }
+        let(:term_3) { RDF::Literal.new("heffer", language: :en) }
+        let(:term_4) { RDF::Literal.new("Kuh", language: :de) }
+        let(:term_5) { RDF::Literal.new("Rind", language: :de) }
+        let(:term_6) { RDF::Literal.new("vache", language: :fr) }
+        let(:term_7) { RDF::Literal.new("mucca") }
+        let(:term_8) { RDF::Literal.new("vaca") }
+        let(:the_array) do
+          [{ sort: [term_4, term_5, term_2, term_1] },
+           { sort: [term_3, term_5, term_4, term_7, term_2] },
+           { sort: [term_1, term_6, term_4, term_2, term_5, term_8, term_7, term_3] }]
+        end
+
+        it 'does alpha sort ignoring case on the preferred language only' do
+          expected_results = [{ sort: [term_1, term_2, term_4, term_5] },
+                              { sort: [term_1, term_2, term_3, term_4, term_5, term_6, term_7, term_8] },
+                              { sort: [term_2, term_3, term_4, term_5, term_7] }]
+          expect(subject).to eq expected_results
+        end
+      end
+
+      context 'when there is complete chaos under heaven and all things are rotten' do
+        let(:preferred_language) { :en }
+
+        let(:term_1) { RDF::Literal.new("Kuh", language: :de) }
+        let(:term_2) { RDF::Literal.new("Rind", language: :de) }
+        let(:term_3) { RDF::Literal.new("hembra", language: :es) }
+        let(:term_4) { RDF::Literal.new("res vacuna", language: :es) }
+        let(:term_5) { RDF::Literal.new("vaca", language: :es) }
+        let(:term_6) { RDF::Literal.new("vache", language: :fr) }
+        let(:term_7) { RDF::Literal.new("ko") }
+        let(:term_8) { RDF::Literal.new("mucca") }
+        let(:the_array) do
+          [{ sort: [term_4, term_5, term_2, term_1] }, # res vacuna, vaca, Rind, Kuh
+           { sort: [term_3, term_5, term_4, term_7, term_2] }, # hembra, vaca, res vacuna, ko, Rind
+           { sort: [term_3, term_6, term_5] }, # hembra, vache, vaca
+           { sort: [term_1, term_6, term_4, term_2, term_5, term_8, term_7, term_3] }] # Kuh, vache, res vacuna, Rind, vaca, mucca, ko, hembra
+        end
+
+        it 'does alpha sort ignoring case on the preferred language only' do
+          expected_results = [{ sort: [term_1, term_2, term_3, term_4, term_5, term_6, term_7, term_8] }, # Kuh, Rind, hembra, res vacuna, vaca, vache, ko, mucca
+                              { sort: [term_2, term_3, term_4, term_5, term_7] }, # Kuh, Rind, res vacuna, vaca
+                              { sort: [term_3, term_5, term_6] }, # hembra, vaca, vache
+                              { sort: [term_1, term_2, term_4, term_5] }] # Rind, hembra, res vacuna, vaca, mucca
+          expect(subject).to eq expected_results
+        end
+      end
+    end
+  end
+end

data/spec/services/linked_data/graph_service_spec.rb

@@ -0,0 +1,232 @@
+require 'spec_helper'
+
+RSpec.describe Qa::LinkedData::GraphService do
+  describe '.load_graph' do
+    subject { described_class.load_graph(url: url) }
+    let(:url) { 'http://experimental.worldcat.org/fast/search?maximumRecords=3&query=cql.any%20all%20%22cornell%22&sortKeys=usage' }
+
+    context 'when graph can be loaded' do
+      before do
+        stub_request(:get, 'http://experimental.worldcat.org/fast/search?maximumRecords=3&query=cql.any%20all%20%22cornell%22&sortKeys=usage')
+          .to_return(status: 200, body: webmock_fixture('lod_oclc_all_query_3_results.rdf.xml'), headers: { 'Content-Type' => 'application/rdf+xml' })
+      end
+
+      it 'builds a graph with many statements' do
+        expect(subject).to be_kind_of RDF::Graph
+        expect(subject.statements.size).to be > 10
+      end
+    end
+
+    context 'when term is not found' do
+      let(:url) { 'http://experimental.worldcat.org/fast/search?maximumRecords=3&query=cql.any%20all%20%22cornell%22&sortKeys=usage' }
+
+      before do
+        stub_request(:get, 'http://experimental.worldcat.org/fast/search?maximumRecords=3&query=cql.any%20all%20%22cornell%22&sortKeys=usage')
+          .to_return(status: 404)
+      end
+
+      it 'raises error' do
+        expect { described_class.load_graph(url: url) }.to raise_error(Qa::TermNotFound, "#{url} Not Found - Term may not exist at LOD Authority. (HTTPNotFound - 404)")
+      end
+    end
+
+    context 'when service error' do
+      subject { described_class.load_graph(url: url) }
+
+      let(:url) { 'http://experimental.worldcat.org/fast/search?maximumRecords=3&query=cql.any%20all%20%22cornell%22&sortKeys=usage' }
+      let(:uri) { URI(url) }
+
+      before do
+        stub_request(:get, 'http://experimental.worldcat.org/fast/search?maximumRecords=3&query=cql.any%20all%20%22cornell%22&sortKeys=usage')
+          .to_return(status: 500)
+      end
+
+      it 'raises error' do
+        expect { subject }.to raise_error(Qa::ServiceError, "#{uri.hostname} on port #{uri.port} is not responding.  Try again later. (HTTPServerError - 500)")
+      end
+    end
+
+    context 'when service unavailable' do
+      subject { described_class.load_graph(url: url) }
+
+      let(:url) { 'http://experimental.worldcat.org/fast/search?maximumRecords=3&query=cql.any%20all%20%22cornell%22&sortKeys=usage' }
+      let(:uri) { URI(url) }
+
+      before do
+        stub_request(:get, 'http://experimental.worldcat.org/fast/search?maximumRecords=3&query=cql.any%20all%20%22cornell%22&sortKeys=usage')
+          .to_return(status: 503)
+      end
+
+      it 'raises error' do
+        expect { subject }.to raise_error(Qa::ServiceUnavailable, "#{uri.hostname} on port #{uri.port} is not responding.  Try again later. (HTTPServiceUnavailable - 503)")
+      end
+    end
+
+    context "when error isn't specifically handled" do
+      subject { described_class.load_graph(url: url) }
+
+      let(:url) { 'http://experimental.worldcat.org/fast/search?maximumRecords=3&query=cql.any%20all%20%22cornell%22&sortKeys=usage' }
+      let(:uri) { URI(url) }
+
+      before do
+        stub_request(:get, 'http://experimental.worldcat.org/fast/search?maximumRecords=3&query=cql.any%20all%20%22cornell%22&sortKeys=usage')
+          .to_return(status: 504)
+      end
+
+      it 'raises error' do
+        expect { subject }.to raise_error(Qa::ServiceError, "Unknown error for #{uri.hostname} on port #{uri.port}.  Try again later. (Cause - <#{url}>: (504))")
+      end
+    end
+  end
+
+  describe '.filter' do
+    context 'with language filter' do
+      subject { described_class.filter(graph: graph, language: language) }
+
+      let(:url) { 'http://authority.with.language/search?query=foo' }
+      let(:graph) { described_class.load_graph(url: url) }
+
+      let(:en_dried_milk) { RDF::Literal.new("dried milk", language: :en) }
+      let(:fr_dried_milk) { RDF::Literal.new("lait en poudre", language: :fr) }
+      let(:de_dried_milk) { RDF::Literal.new("getrocknete Milch", language: :de) }
+
+      let(:en_buttermilk) { RDF::Literal.new("buttermilk", language: :en) }
+      let(:fr_buttermilk) { RDF::Literal.new("Babeurre", language: :fr) }
+      let(:de_buttermilk) { RDF::Literal.new("Buttermilch", language: :de) }
+
+      let(:en_condensed_milk) { RDF::Literal.new("condensed milk", language: :en) }
+      let(:fr_condensed_milk) { RDF::Literal.new("lait condensé", language: :fr) }
+      let(:de_condensed_milk) { RDF::Literal.new("Kondensmilch", language: :de) }
+
+      before do
+        stub_request(:get, 'http://authority.with.language/search?query=foo')
+          .to_return(status: 200, body: webmock_fixture('lod_lang_search_enfrde.rdf.xml'), headers: { 'Content-Type' => 'application/rdf+xml' })
+      end
+
+      context 'when one language passed in' do
+        let(:language) { [:fr] }
+
+        it 'returns the graph with only the French subset of triples' do
+          expect(subject.has_object?(en_dried_milk)).to be false
+          expect(subject.has_object?(en_buttermilk)).to be false
+          expect(subject.has_object?(en_condensed_milk)).to be false
+
+          expect(subject.has_object?(fr_dried_milk)).to be true
+          expect(subject.has_object?(fr_buttermilk)).to be true
+          expect(subject.has_object?(fr_condensed_milk)).to be true
+
+          expect(subject.has_object?(de_dried_milk)).to be false
+          expect(subject.has_object?(de_buttermilk)).to be false
+          expect(subject.has_object?(de_condensed_milk)).to be false
+        end
+      end
+
+      context "when mix of language markers on graph statements" do
+        let(:nomarker_de_buttermilk) { RDF::Literal.new("Buttermilch") }
+        let(:language) { [:fr] }
+
+        before do
+          stub_request(:get, 'http://authority.with.language/search?query=foo')
+            .to_return(status: 200, body: webmock_fixture('lod_lang_search_filtering.nt'), headers: { 'Content-Type' => 'application/n-triples' })
+        end
+
+        it 'filters down to the expected size' do
+          expect(graph.size).to eq 11
+          expect(subject.size).to eq 8
+        end
+
+        it 'the graph includes triples where object has the targeted language marker (e.g. :fr)' do
+          expect(subject.has_object?(fr_dried_milk)).to be true
+          expect(subject.has_object?(fr_buttermilk)).to be true
+        end
+
+        it 'the graph includes triples where object does not have a language marker' do
+          expect(subject.has_object?(nomarker_de_buttermilk)).to be true
+        end
+
+        it "the graph includes triples regardless of language when there are no object's for the predicate that have the targeted language marker" do
+          expect(subject.has_object?(en_condensed_milk)).to be true
+          expect(subject.has_object?(de_condensed_milk)).to be true
+        end
+
+        it 'filters out the rest' do
+          expect(subject.has_object?(en_dried_milk)).to be false
+          expect(subject.has_object?(en_buttermilk)).to be false
+          expect(subject.has_object?(de_dried_milk)).to be false
+        end
+      end
+
+      context 'when multiple languages passed in' do
+        let(:language) { [:en, :fr] }
+
+        it 'returns the graph with English and French subset of triples' do
+          expect(subject.has_object?(en_dried_milk)).to be true
+          expect(subject.has_object?(en_buttermilk)).to be true
+          expect(subject.has_object?(en_condensed_milk)).to be true
+
+          expect(subject.has_object?(fr_dried_milk)).to be true
+          expect(subject.has_object?(fr_buttermilk)).to be true
+          expect(subject.has_object?(fr_condensed_milk)).to be true
+
+          expect(subject.has_object?(de_dried_milk)).to be false
+          expect(subject.has_object?(de_buttermilk)).to be false
+          expect(subject.has_object?(de_condensed_milk)).to be false
+        end
+      end
+    end
+
+    context 'with filter out subject blanknodes' do
+      subject { described_class.filter(graph: graph, remove_blanknode_subjects: true) }
+
+      let(:url) { 'http://experimental.worldcat.org/fast/search?maximumRecords=3&query=cql.any%20all%20%22cornell%22&sortKeys=usage' }
+      let(:graph) { described_class.load_graph(url: url) }
+
+      before do
+        stub_request(:get, 'http://experimental.worldcat.org/fast/search?maximumRecords=3&query=cql.any%20all%20%22cornell%22&sortKeys=usage')
+          .to_return(status: 200, body: webmock_fixture('lod_search_with_blanknode_subjects.nt'), headers: { 'Content-Type' => 'application/n-triples' })
+      end
+
+      it 'removes statements where the subject is a blanknode' do
+        expect(graph.size).to be 18
+        expect(subject.size).to be 12
+      end
+    end
+  end
+
+  describe '.object_values' do
+    subject { described_class.object_values(graph: graph, subject: subject_uri, predicate: predicate_uri) }
+
+    let(:url) { 'http://experimental.worldcat.org/fast/search?maximumRecords=3&query=cql.any%20all%20%22cornell%22&sortKeys=usage' }
+    let(:graph) { described_class.load_graph(url: url) }
+    let(:subject_uri) { RDF::URI('http://id.worldcat.org/fast/530369') }
+    let(:predicate_uri) { RDF::URI('http://schema.org/sameAs') }
+
+    before do
+      stub_request(:get, 'http://experimental.worldcat.org/fast/search?maximumRecords=3&query=cql.any%20all%20%22cornell%22&sortKeys=usage')
+        .to_return(status: 200, body: webmock_fixture('lod_oclc_all_query_3_results.rdf.xml'), headers: { 'Content-Type' => 'application/rdf+xml' })
+    end
+
+    it 'returns all values for the subject-predicate pair' do
+      expect(subject.size).to be 2
+      expect(subject.map(&:to_s)).to match_array ['http://id.loc.gov/authorities/names/n79021621', 'https://viaf.org/viaf/126293486']
+    end
+  end
+
+  describe '.deep_copy' do
+    subject { described_class.object_values(graph: graph, subject: subject_uri, predicate: predicate_uri) }
+
+    let(:url) { 'http://experimental.worldcat.org/fast/search?maximumRecords=3&query=cql.any%20all%20%22cornell%22&sortKeys=usage' }
+    let(:graph) { described_class.load_graph(url: url) }
+    let(:copied_graph) { described_class.deep_copy(graph: graph) }
+
+    before do
+      stub_request(:get, 'http://experimental.worldcat.org/fast/search?maximumRecords=3&query=cql.any%20all%20%22cornell%22&sortKeys=usage')
+        .to_return(status: 200, body: webmock_fixture('lod_oclc_all_query_3_results.rdf.xml'), headers: { 'Content-Type' => 'application/rdf+xml' })
+    end
+
+    it 'returns a copy of the graph' do
+      expect(copied_graph).to be_kind_of RDF::Graph
+      expect(copied_graph.statements.count).to eq graph.statements.count
+    end
+  end
+end