ansr_dpla 0.0.4

data/spec/lib/relation/where_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+describe Ansr::Relation do
+  before do
+    @kittens = read_fixture('kittens.jsonld')
+    @faceted = read_fixture('kittens_faceted.jsonld')
+    @empty = read_fixture('empty.jsonld')
+    @mock_api = double('api')
+    Item.config{ |x| x[:api_key] = :foo}
+    Item.engine.api= @mock_api
+  end
+  describe '#where' do
+    it "do a single field, single value where" do
+      test = Ansr::Relation.new(Item, Item.table).where(:q=>'kittens')
+      @mock_api.should_receive(:items).with(:q => 'kittens').and_return('')
+      test.load
+    end
+    it "do a single field, multiple value where" do
+      test = Ansr::Relation.new(Item, Item.table).where(:q=>['kittens', 'cats'])
+      @mock_api.should_receive(:items).with(:q => ['kittens','cats']).and_return('')
+      test.load
+    end
+    it "do merge single field, multiple value wheres" do
+      test = Ansr::Relation.new(Item, Item.table).where(:q=>'kittens').where(:q=>'cats')
+      @mock_api.should_receive(:items).with(:q => ['kittens','cats']).and_return('')
+      test.load
+    end
+    it "do a multiple field, single value where" do
+      test = Ansr::Relation.new(Item, Item.table).where(:q=>'kittens',:foo=>'bears')
+      @mock_api.should_receive(:items).with(:q => 'kittens', :foo=>'bears').and_return('')
+      test.load
+    end
+    it "should keep scope distinct from spawned Relations" do
+      test = Ansr::Relation.new(Item, Item.table).where(:q=>'kittens')
+      test.where(:q=>'cats')
+      @mock_api.should_receive(:items).with(:q => 'kittens').and_return('')
+      test.load
+    end
+    describe '#not' do
+      it 'should exclude a specified map of field values' do
+        test = Ansr::Relation.new(Item, Item.table)
+        test = test.where(:foo =>'kittens')
+        test = test.where.not(:foo => 'cats')
+        @mock_api.should_receive(:items).with(:foo => ['kittens', 'NOT cats']).and_return('')
+        test.load
+      end
+
+      pending 'should exclude a value from the default query' do
+        test = Ansr::Relation.new(Item, Item.table)
+        test = test.where('kittens')
+        test = test.where.not('cats')
+        @mock_api.should_receive(:items).with(:q => ['kittens', 'NOT cats']).and_return('')
+        test.load
+      end
+
+      pending 'should exclude a specified field' do
+        test = Ansr::Relation.new(Item, Item.table)
+        test = test.where(:foo => 'kittens')
+        test = test.where.not('cats')
+        @mock_api.should_receive(:items).with(:foo => 'kittens', :q => 'NOT cats').and_return('')
+        test.load
+      end
+    end
+    describe '#or' do
+      it 'should union a specified map of field values' do
+        test = Ansr::Relation.new(Item, Item.table)
+        test = test.where(:foo =>'kittens')
+        test = test.where.or(:foo => 'cats')
+        @mock_api.should_receive(:items).with(:foo => ['kittens', 'OR cats']).and_return('')
+        test.load
+      end
+    end
+  end
+end

data/spec/lib/relation_spec.rb

@@ -0,0 +1,307 @@
+require 'spec_helper'
+
+describe Ansr::Dpla::Relation do
+  before do
+    @kittens = read_fixture('kittens.jsonld')
+    @faceted = read_fixture('kittens_faceted.jsonld')
+    @empty = read_fixture('empty.jsonld')
+    @mock_api = double('api')
+    Item.config {|x| x[:api_key] = :foo }
+    Item.engine.api= @mock_api
+  end
+
+  subject { Ansr::Dpla::Relation.new(Item, Item.table) }
+
+  describe "#initialize" do
+    it "should identify the correct resource for the model" do
+      class Foo
+        def self.table
+          nil
+        end
+      end
+
+      test = Ansr::Dpla::Relation.new(Foo, Foo.table)
+      expect(test.resource).to eql(:foos)
+    end
+  end
+
+  describe ".load" do
+    it "should fetch the appropriate REST resource" do
+      test = subject.where(:q=>'kittens')
+      @mock_api.should_receive(:items).with(:q => 'kittens').and_return('')
+      test.load
+    end
+
+    describe "Relation attributes" do
+      it "should set attributes correctly from a response" do
+        test = subject.where(:q=>'kittens')
+        @mock_api.stub(:items).and_return(@kittens)
+        test.load
+        expect(test.count).to eql(144)
+        expect(test.offset_value).to eql(0)
+        expect(test.limit_value).to eql(10)
+      end
+
+      it "should set attributes correctly for an empty response" do
+        test = subject.where(:q=>'kittens')
+        @mock_api.stub(:items).and_return(@empty)
+        test.load
+        expect(test.count).to eql(0)
+        expect(test.offset_value).to eql(0)
+        expect(test.limit_value).to eql(10)
+      end
+    end
+  end
+
+  describe '#all' do
+    it 'should fail because we don\'t have a test yet'
+  end
+
+  describe '#none' do
+    it 'should fail because we don\'t have a test yet'
+  end
+
+  describe '.order' do
+    describe 'with symbol parms' do
+      it "should add sort clause to query" do
+        test = subject.where(:q=>'kittens').order(:foo)
+        expect(test).to be_a(Ansr::Relation)
+        @mock_api.should_receive(:items).with(:q => 'kittens',:sort_by=>:foo).and_return('')
+        test.load
+      end
+
+      it "should add multiple sort clauses to query" do
+        test = subject.where(:q=>'kittens').order(:foo).order(:bar)
+        expect(test).to be_a(Ansr::Relation)
+        @mock_api.should_receive(:items).with(:q => 'kittens',:sort_by=>[:foo,:bar]).and_return('')
+        test.load
+      end
+
+      it "should sort in descending order if necessary" do
+        test = subject.where(:q=>'kittens').order(:foo => :desc)
+        expect(test).to be_a(Ansr::Relation)
+        @mock_api.should_receive(:items).with(:q => 'kittens',:sort_by=>:foo, :sort_order=>:desc).and_return('')
+        test.load
+      end
+    end
+    describe 'with String parms' do
+      it "should add sort clause to query" do
+        test = subject.where(q:'kittens').order("foo")
+        expect(test).to be_a(Ansr::Relation)
+        @mock_api.should_receive(:items).with(:q => 'kittens',:sort_by=>:foo).and_return('')
+        test.load
+      end
+
+      it "should sort in descending order if necessary" do
+        test = subject.where(q:'kittens').order("foo DESC")
+        expect(test).to be_a(Ansr::Relation)
+        @mock_api.should_receive(:items).with(:q => 'kittens',:sort_by=>:foo, :sort_order=>:desc).and_return('')
+        test.load
+      end
+    end
+  end
+
+  describe '#reorder' do
+    it "should replace existing order" do
+      test = subject.where(q:'kittens').order("foo DESC")
+      test = test.reorder("foo ASC")
+      expect(test).to be_a(Ansr::Relation)
+      @mock_api.should_receive(:items).with(:q => 'kittens',:sort_by=>:foo).and_return('')
+      test.load
+    end
+  end
+
+  describe '#reverse_order' do
+    it "should replace existing DESC order" do
+      test = subject.where(q:'kittens').order("foo DESC")
+      test = test.reverse_order
+      expect(test).to be_a(Ansr::Relation)
+      @mock_api.should_receive(:items).with(:q => 'kittens',:sort_by=>:foo).and_return('')
+      test.load
+    end
+
+    it "should replace existing ASC order" do
+      test = subject.where(q:'kittens').order("foo ASC")
+      test = test.reverse_order
+      expect(test).to be_a(Ansr::Relation)
+      @mock_api.should_receive(:items).with(:q => 'kittens',:sort_by=>:foo, :sort_order=>:desc).and_return('')
+      test.load
+    end
+  end
+
+  describe '#unscope' do
+    it 'should remove clauses only from spawned Relation' do
+      test = subject.where(q:'kittens').order("foo DESC")
+      test2 = test.unscope(:order)
+      expect(test2).to be_a(Ansr::Relation)
+      @mock_api.should_receive(:items).with(:q => 'kittens').and_return('')
+      test2.load
+      expect(test.order_values.empty?).to be_false
+    end
+    # ActiveRecord::QueryMethods.VALID_UNSCOPING_VALUES =>
+    # Set.new([:where, :select, :group, :order, :lock, :limit, :offset, :joins, :includes, :from, :readonly, :having])
+    it 'should reject bad scope keys' do
+      test = subject.where(q:'kittens').order("foo DESC")
+      expect { test.unscope(:foo) }.to raise_error
+    end
+  end
+
+  describe '#select' do
+    describe 'with a block given' do
+      it "should build an array" do
+        test = subject.where(q:'kittens')
+        @mock_api.should_receive(:items).with(:q => 'kittens').and_return(@kittens)
+        actual = test.select {|d| true}
+        expect(actual).to be_a(Array)
+        expect(actual.length).to eql(test.limit_value)
+        actual = test.select {|d| false}
+        expect(actual).to be_a(Array)
+        expect(actual.length).to eql(0)
+      end
+    end
+    describe 'with a String or Symbol key given' do
+      it 'should change the requested document fields' do
+        test = subject.where(q:'kittens')
+        @mock_api.should_receive(:items).with(:q => 'kittens', :fields=>:name).and_return('')
+        test = test.select('name')
+        test.load
+      end
+    end
+    describe 'with a list of keys' do
+      it "should add all the requested document fields" do
+        test = subject.where(q:'kittens')
+        @mock_api.should_receive(:items).with(:q => 'kittens', :fields=>[:name,:foo]).and_return('')
+        test = test.select(['name','foo'])
+        test.load
+      end
+      it "should add all the requested document fields and proxy them" do
+        test = subject.where(q:'kittens')
+        @mock_api.should_receive(:items).with(:q => 'kittens', :fields=>:object).and_return(@kittens)
+        test = test.select('object AS my_object')
+        test.load
+        expect(test.to_a.first['object']).to be_nil
+        expect(test.to_a.first['my_object']).to eql('http://ark.digitalcommonwealth.org/ark:/50959/6682xj30d/thumbnail')
+      end
+    end
+  end
+
+  describe '#limit' do
+    it "should add page_size to the query params" do
+      test = subject.where(q:'kittens')
+      @mock_api.should_receive(:items).with(:q => 'kittens', :page_size=>17).and_return('')
+      test = test.limit(17)
+      test.load
+    end
+    it "should raise an error if limit > 500" do
+      test = subject.where(q:'kittens')
+      test = test.limit(500)
+      expect {test.load }.to raise_error
+    end
+  end
+
+  describe '#offset' do
+    it "should add page to the query params when page_size is defaulted" do
+      test = subject.where(q:'kittens')
+      @mock_api.should_receive(:items).with(:q => 'kittens', :page=>3).and_return('')
+      test = test.offset(20)
+      test.load
+    end
+    it 'should raise an error if an offset is requested that is not a multiple of the page size' do
+      test = subject.where(q:'kittens').limit(12)
+      expect{test.offset(17)}.to raise_error(/^Bad/)
+      test.offset(24)
+    end
+  end
+
+  describe '#to_a' do
+    it 'should load the records and return them' do
+    end
+  end
+
+  describe '#loaded?' do
+    it 'should be false before and true after' do
+      test = subject.where(q:'kittens')
+      @mock_api.stub(:items).with(:q => 'kittens').and_return('')
+      expect(test.loaded?).to be_false
+      test.load
+      expect(test.loaded?).to be_true
+    end
+  end
+
+
+  describe '#any?'
+
+
+  describe '#blank?' do
+    it 'should load the records via to_a'
+
+  end
+
+  describe '#count' do
+  end
+
+  describe '#empty?' do
+    it 'should not make another call if records are loaded' do
+      test = subject.where(q:'kittens')
+      @mock_api.should_receive(:items).with(:q => 'kittens').once.and_return(@empty)
+      test.load
+      expect(test.loaded?).to be_true
+      expect(test.empty?).to be_true
+    end
+
+  end
+
+  describe "#spawn" do
+    it "should create new, independent Relations from Query methods"
+
+  end
+
+  describe 'RDBMS-specific methods' do
+    describe '#references' do
+      it 'should not do anything at all'
+    end
+    describe '#joins' do
+      it 'should not do anything at all'
+    end
+    describe '#distinct and #uniq' do
+      it 'should not do anything at all'
+    end
+    describe '#preload' do
+      it 'should not do anything at all'
+    end
+    describe '#includes' do
+      it 'should not do anything at all'
+    end
+    describe '#having' do
+      it 'should not do anything at all'
+    end
+  end
+
+  describe 'read-write methods' do
+    describe '#readonly' do
+      it "should blissfully ignore no-args or true"
+
+      it "should refuse values of false"
+
+    end
+    describe '#create_with' do
+      it 'should not do anything at all'
+    end
+    describe '#insert' do
+      it 'should not do anything at all'
+    end
+    describe '#delete' do
+      it 'should not do anything at all'
+    end
+    describe '#delete_all' do
+      it 'should not do anything at all'
+    end
+    describe '#destroy' do
+      it 'should not do anything at all'
+    end
+    describe '#destroy_all' do
+      it 'should not do anything at all'
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,36 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', '..', 'lib'))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'app/models'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'rspec/autorun'
+require 'loggable'
+require 'ansr'
+require 'ansr_dpla'
+require 'adpla_test_api'
+require 'blacklight'
+require 'item'
+require 'collection'
+
+RSpec.configure do |config|
+
+end
+
+def fixture_path(path)
+  File.join(File.dirname(__FILE__), '..', 'fixtures', path)
+end
+
+def fixture path, &block
+  if block_given?
+    open(fixture_path(path)) &block
+  else
+    open(fixture_path(path))
+  end
+end
+
+def read_fixture(path)
+  _f = fixture(path)
+  _f.read
+ensure
+  _f and _f.close
+end

data/test/debug.rb

@@ -0,0 +1,14 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'app/models'))
+require 'rails'
+require 'adpla'
+require 'item'
+class Logger
+	def info(msg)
+		puts msg
+	end
+	alias :warn :info
+	alias :error :info
+	alias :debug :info
+end
+
+puts Item.table.inspect

data/test/system.rb

@@ -0,0 +1,52 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'app/models'))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', '..', 'lib'))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'ansr_dpla'
+require 'item'
+
+# you config the model with a hash including an API key for dp.la/v2, or the path to a YAML file
+open('config/dpla.yml') do |blob|
+  Item.config {|x| x.merge! YAML.load(blob)}
+end
+
+# then you can find single items with known IDs
+puts Item.find("7eb617e559007e1ad6d95bd30a30b16b")
+
+
+# or you can search with ActiveRecord::Relations
+opts = {q: 'kittens', facets: 'sourceResource.contributor'}
+rel = Item.where(opts)
+# this means the results are lazy-loaded, #load or #to_a will load them
+rel.to_a
+# you can also assemble the queries piecemeal with the Relation's decorator pattern
+# the where decorator adds query fields
+# the select decorator adds response fields
+# the limit decorator adds a page size limit
+# the offset decorator adds a non-zero starting point in the response set
+# the filter decorator adds filter/facet fields and optionally values to query them on
+rel = Item.where(q: 'kittens').limit(2).facet('sourceResource.contributor').select('sourceResource.title')
+rel.to_a.each do |item|
+  puts "#{item["id"]} \"#{item['sourceResource.title']}\""
+end
+# the filter values for the query are available on the relation after it is loaded
+rel.filters.each do |k,f|
+  puts "#{k} values"
+  f.items.each do |item|
+    puts "filter:  \"#{item.value}\" : #{item.hits}"
+  end
+end
+# the loaded Relation has attributes describing the response set
+rel.count # the size of the response
+# the where decorator can be negated
+rel = rel.where.not(q: 'cats')
+
+rel.to_a.each do |item|
+  puts "#{item["id"]} \"#{item['sourceResource.title']}\" \"#{item['originalRecord']}\""
+end
+
+rel.filters.each do |k,f|
+  puts "#{k} values"
+  f.items.each do |item|
+    puts "  \"#{item.value}\" : #{item.hits}"
+  end
+end