qa-ldf 0.1.0

data/spec/contracts/qa_loc_as_search_service_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+require 'qa/authorities/loc'
+
+# We need to guarantee `Loc.subauthority_for('names')` behaves like a search
+# service
+describe Qa::Authorities::Loc do
+  subject(:search_service) { described_class.subauthority_for('names') }
+  before do
+    # an empty response for 'tove'
+    stub_request(:get, 'http://id.loc.gov/search/?format=json&'\
+                       'q=tove&q=cs:http://id.loc.gov/authorities/names')
+      .with(headers: { 'Accept' => 'application/json' })
+      .to_return(status: 200, body: '[]', headers: {})
+
+    # real responses from fixtures
+    search_config.each do |search|
+      stub_request(:get, 'http://id.loc.gov/search/?format=json' \
+                         "&q=#{search[:query]}&q=cs:" \
+                         'http://id.loc.gov/authorities/names')
+        .with(headers: { 'Accept' => 'application/json' })
+        .to_return(status: 200, body: search[:body], headers: {})
+    end
+  end
+
+  let(:search_config) do
+    [
+      { query: 'moomin', body: '[]', result: [] }, # an empty body
+    ]
+  end
+
+  let(:searches) do
+    search_config.each_with_object({}) do |search, hsh|
+      hsh[search[:query]] = search[:result]
+    end
+  end
+
+  it_behaves_like 'an ldf search service'
+end

data/spec/qa/ldf/authorities/lc_names_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe Qa::LDF::LCNames do
+  it_behaves_like 'an ldf authority'
+
+  subject(:authority) do
+    auth = described_class.new
+
+    auth.client = FakeClient.new do |client|
+      client.graph = RDF::Graph.new
+      client.graph.insert(*statements)
+      client.label = ldf_label
+    end
+
+    auth
+  end
+
+  let(:ldf_label)    { 'Marble Island (Nunavut)' }
+  let(:ldf_uri)      { 'http://id.loc.gov/authorities/subjects/sh2004002557' }
+
+  let(:statements) do
+    [RDF::Statement(RDF::URI(ldf_uri),
+                    RDF::Vocab::SKOS.prefLabel,
+                    RDF::Literal(ldf_label))]
+  end
+
+  before do
+    # mock empty responses for all queries;
+    # see spec/contracts/qa_loc_as_search_service.rb for lc search service tests
+    stub_request(:get, 'http://id.loc.gov/search/?format=json&' \
+                       'q=cs:http://id.loc.gov/authorities/names')
+      .with(headers: { 'Accept' => 'application/json' })
+      .to_return(status: 200, body: '[]', headers: {})
+  end
+
+  describe '#search_service' do
+    it 'hits the upstream loc endpoint by default' do
+      query = 'a query'
+      url   = 'http://id.loc.gov/search/?format=json' \
+              "&q=#{query}&q=cs:http://id.loc.gov/authorities/names"
+      expect(a_request(:get, url))
+
+      authority.search_service.search(query)
+    end
+  end
+
+  describe '#dataset' do
+    it 'defaults to :lcnames' do
+      expect(described_class.new.dataset).to eq :lcnames
+    end
+  end
+end

data/spec/qa/ldf/authority_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Qa::LDF::Authority do
+  it_behaves_like 'an ldf authority'
+
+  subject(:authority) do
+    auth = described_class.new
+
+    auth.client = FakeClient.new do |client|
+      client.graph = RDF::Graph.new << statement
+      client.label = ldf_label
+    end
+
+    auth
+  end
+
+  let(:ldf_label)    { 'Marble Island (Nunavut)' }
+  let(:ldf_uri)      { 'http://id.loc.gov/authorities/subjects/sh2004002557' }
+
+  let(:statement) do
+    [RDF::URI(ldf_uri), RDF::Vocab::SKOS.prefLabel, RDF::Literal(ldf_label)]
+  end
+
+  describe '#dataset' do
+    it 'defaults an empty string symbol' do
+      expect(described_class.new.dataset).to eq :''
+    end
+  end
+end

data/spec/qa/ldf/client_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+##
+# @todo: Stub LDF behavior at this point. Add integration/contract tests for
+#   this interface.
+describe Qa::LDF::Client do
+  subject(:client) { described_class.new }
+
+  let(:uri)        { 'http://id.loc.gov/authorities/subjects/sh2004002557' }
+  let(:graph_stub) { RDF::Graph.new << [RDF::URI(uri), RDF.type, RDF.Property] }
+
+  before do
+    # stub the external request, this behavior is owned by the server,
+    # we just allow it to make the request
+    stub_request(:get, uri)
+      .to_return(status:  200,
+                 body:    graph_stub.dump(:ntriples),
+                 headers: { 'Content-Type' =>
+                            RDF::Format.for(:ntriples).content_type })
+  end
+
+  include_context 'with cache server'
+  it_behaves_like 'an ld cache client'
+end

data/spec/qa/ldf/configuration_spec.rb

@@ -0,0 +1,93 @@
+require 'spec_helper'
+
+describe Qa::LDF::Configuration do
+  subject(:config) { described_class.instance }
+
+  shared_context 'with configuration' do
+    before { config.configure!(**options) }
+    after  { config.reset! }
+
+    let(:options) do
+      { option: :moomin }
+    end
+  end
+
+  describe '#[]' do
+    include_context 'with configuration'
+
+    it 'gives nil for unconfigured options' do
+      expect(config[:fake]).to be_nil
+    end
+
+    it 'accesses options' do
+      options.each { |k, v| expect(config[k]).to eq v }
+    end
+  end
+
+  describe '#configure!' do
+    it 'configures the options' do
+      expect { config.configure!(key: :value) }
+        .to change { config[:key] }.from(nil).to(:value)
+    end
+
+    it 'overrides the options' do
+      config.configure!(key: :value)
+
+      expect { config.configure!(key: :new_value) }
+        .to change { config[:key] }.from(:value).to(:new_value)
+    end
+
+    it 'overrides options not in new config' do
+      config.configure!(key: :value)
+
+      expect { config.configure!(new_key: :new_value) }
+        .to change { config[:key] }.from(:value).to(nil)
+    end
+
+    it 'yields itself' do
+      expect { |b| config.configure!(&b) }.to yield_with_args(config)
+    end
+
+    it 'yields configured self' do
+      options = { key1: :value, key2: :value }
+
+      config.configure!(**options) { |c| expect(c.to_h).to eq options }
+    end
+
+    it 'returns self' do
+      expect(config.configure!).to eql config
+    end
+  end
+
+  describe '#each' do
+    include_context 'with configuration'
+
+    it 'enumerates the options hash' do
+      expect(config.each).to contain_exactly(*options.each)
+    end
+  end
+
+  describe '#reset!' do
+    include_context 'with configuration'
+
+    it 'resets options hash' do
+      expect { config.reset! }.to change { config.to_a }.to be_empty
+    end
+  end
+
+  describe '#to_a' do
+    include_context 'with configuration'
+
+    it 'returns the configured options as an array' do
+      expect(config.to_a).to eq options.to_a
+    end
+  end
+
+  describe '#to_h' do
+    include_context 'with configuration'
+
+    it 'returns the configured options as a hash' do
+      expect(config.to_h).to eq options
+    end
+  end
+end

data/spec/qa/ldf/empty_search_service_spec.rb

@@ -0,0 +1,11 @@
+# coding: utf-8
+require 'spec_helper'
+require 'qa/ldf/empty_search_service'
+
+describe Qa::LDF::EmptySearchService do
+  it_behaves_like 'an ldf search service'
+
+  subject(:search_service) { described_class.new }
+
+  let(:searches) { { '-NonSensE\ !QUERY' => [], 'Bărăganul (Romania)' => [] } }
+end

data/spec/qa/ldf/json_mapper_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Qa::LDF::JsonMapper do
+  subject(:mapper) { described_class.new }
+
+  let(:uri)    { 'http://example.com/moomin' }
+  let(:label)  { RDF::Literal('Moomin') }
+
+  let(:graph) do
+    RDF::Graph.new << [RDF::URI(uri), RDF::Vocab::SKOS.prefLabel, label]
+  end
+
+  describe '#map_resource' do
+    it 'maps with an id' do
+      expect(mapper.map_resource(uri, graph)[:id]).to eq uri
+    end
+
+    it 'maps with a label' do
+      expect(mapper.map_resource(uri, graph)[:label]).to eq label
+    end
+  end
+end

data/spec/qa/ldf/model_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe Qa::LDF::Model do
+  define :be_term do |expected|
+    match { |actual| expect(actual.to_term).to eq expected }
+  end
+
+  let(:id)    { 'http://example.com/authority/moomin' }
+  let(:label) { 'moomin' }
+
+  describe '.from_graph' do
+    let(:graph) do
+      graph = RDF::Graph.new
+      graph.insert(*statements)
+      graph
+    end
+
+    let(:statements) do
+      [RDF::Statement(RDF::URI(id),  RDF::Vocab::SKOS.prefLabel, label),
+       RDF::Statement(RDF::URI(id),  RDF::Vocab::DC.title, 'Moomin Papa'),
+       RDF::Statement(RDF::Node.new, RDF::Vocab::DC.title, 'Moomin Papa')]
+    end
+
+    it 'builds a model with the id as uri' do
+      expect(described_class.from_graph(uri: id, graph: graph))
+        .to be_term RDF::URI(id)
+    end
+
+    it 'builds a model with the label as label' do
+      expect(described_class.from_graph(uri: id, graph: graph))
+        .to have_attributes rdf_label: a_collection_containing_exactly(label)
+    end
+
+    it 'contains passed graph' do
+      expect(described_class.from_graph(uri: id, graph: graph).statements)
+        .to include(*statements)
+    end
+  end
+
+  describe '.from_qa_result' do
+    let(:json_hash) { { id: id, label: label, papa: 'moomin papa' } }
+
+    it 'builds a model with the id as uri' do
+      expect(described_class.from_qa_result(qa_result: json_hash))
+        .to be_term RDF::URI(id)
+    end
+
+    it 'builds a model with the label as label' do
+      expect(described_class.from_qa_result(qa_result: json_hash))
+        .to have_attributes rdf_label: a_collection_containing_exactly(label)
+    end
+  end
+end

data/spec/qa/ldf_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Qa::LDF do
+  subject(:mod) { described_class }
+
+  it 'has a version' do
+    expect(mod::VERSION.to_str).to be_a String
+  end
+
+  describe '#version' do
+    it 'returns VERISON' do
+      expect(mod.version).to eql mod::VERSION
+    end
+  end
+
+  describe '.config' do
+    it 'defaults to an empty config' do
+      expect(mod.config).not_to be_any
+    end
+
+    context 'when configured' do
+      before { mod.configure!(**options) }
+
+      let(:options) { { opt: :value, opt2: :value2 } }
+
+      it 'returns the configuration instance' do
+        expect(mod.config.to_h).to eq options
+      end
+    end
+  end
+
+  describe '#configure!' do
+    it 'dispatches arguments to the configuration instance' do
+      opts  = { opt: :value }
+      block = proc {}
+
+      expect(Qa::LDF::Configuration.instance)
+        .to receive(:configure!).with(**opts, &block).once
+
+      mod.configure!(**opts, &block)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+require 'bundler/setup'
+Bundler.setup
+
+require 'pry' unless ENV['CI']
+require 'webmock/rspec'
+
+require 'qa/ldf'
+require 'qa/ldf/spec'
+
+Dir['./spec/support/**/*.rb'].each { |f| require f }
+
+RSpec.configure do |config|
+  config.color = true
+  config.tty = true
+
+  config.formatter = :progress
+end

data/spec/support/cache_server.rb

@@ -0,0 +1,25 @@
+require 'sham_rack'
+
+require 'linked_data_fragments/cache_server'
+require 'linked_data_fragments/repository'
+
+shared_context 'with cache server' do
+  let(:server_endpoint) { 'http://ldcache.example.com/' }
+
+  before(:context) do
+    server_endpoint = 'ldcache.example.com'
+
+    ShamRack
+      .at(server_endpoint)
+      .mount(LinkedDataFragments::CacheServer::APPLICATION)
+
+    Qa::LDF.configure! do |config|
+      config[:endpoint] = "http://#{server_endpoint}"
+    end
+  end
+
+  after(:context) do
+    ShamRack.reset
+    Qa::LDF::Configuration.instance.reset!
+  end
+end

data/spec/support/fake_client.rb

@@ -0,0 +1,31 @@
+require 'support/shared_examples/ld_cache_client'
+
+require 'rdf'
+require 'rdf/vocab/skos'
+
+##
+# A fake version of `Qa::LDF::Client`.
+class FakeClient
+  attr_accessor :label, :graph
+
+  def initialize
+    yield self if block_given?
+  end
+
+  def get(uri:, dataset: :'')
+    graph ||= RDF::Graph.new
+    # Use dataset just to satisfy rubocop.
+    # Is there a better config setting for this; exclude this cop from fakes?
+    graph =
+      graph.dup <<
+      [RDF::URI(uri), RDF::Vocab::SKOS.prefLabel, label || "#{dataset}: moomin"]
+    graph
+  end
+end
+
+describe FakeClient do
+  subject(:client) { described_class.new }
+
+  let(:uri) { 'http://id.loc.gov/authorities/subjects/sh2004002557' }
+  it_behaves_like 'an ld cache client'
+end