ansr 0.0.1

data/ansr_dpla/lib/ansr_dpla/model/querying.rb

@@ -0,0 +1,38 @@
+require 'active_record'
+module Ansr::Dpla
+  module Model
+  	module Querying
+    extend ActiveSupport::Concern
+
+      module ClassMethods
+        def api
+          @api ||= begin
+            a = (config[:api] || Ansr::Dpla::Api).new
+            a.config(self.config)
+            a
+          end
+        end
+
+        def api=(api)
+          @api = api
+        end
+
+        def table
+          @big_table ||= Ansr::Dpla::Arel::BigTable.new(model(), {:config => config()})
+        end
+
+        def table=(val)
+          @big_table = val
+        end
+
+        def connection_handler
+          @connection_handler ||= Ansr::Model::ConnectionHandler.new(Ansr::Dpla::Arel::Connection)
+        end
+
+        def references
+          ['provider', 'object']
+        end
+      end
+    end
+  end
+end

data/ansr_dpla/spec/adpla_test_api.rb

@@ -0,0 +1,9 @@
+module Ansr::Dpla
+  class TestApi
+  	include Ansr::Configurable
+    def items(opts={})
+    end
+    def collections(opts={})
+    end
+  end
+end

data/ansr_dpla/spec/lib/api_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+
+describe Ansr::Dpla::Api do
+
+  describe '#config' do
+    before do
+      @test = Ansr::Dpla::Api.new
+    end
+
+    it "should be configurable with a Hash" do
+      config_fixture = {:api_key => :foo, :url => :bar}
+      @test.config(config_fixture)
+      expect(@test.url).to eql(:bar)
+    end
+
+    it "should be configurable with a path to a yaml" do
+      @test.config(fixture_path('dpla.yml'))
+      expect(@test.url).to eql('http://fake.dp.la/v0/')
+    end
+
+    it "should raise an error of the config doesn't have required fields" do
+      expect { Ansr::Dpla::Api.new.config({:url => :foo})}.to raise_error
+      Ansr::Dpla::Api.new.config({:url => :foo, :api_key => :foo})
+    end
+
+  end
+
+  describe '#path_for' do
+    before do
+      @test = Ansr::Dpla::Api.new
+      @test.config({:api_key => :testing})
+    end
+
+
+    describe 'queries' do
+      it "should build paths for basic queries" do
+        fixture = {:foo => ['kittens', 'cats'], :bar => ['puppies', 'dogs']}
+        expected = 'tests?api_key=testing&foo=kittens+AND+cats&bar=puppies+AND+dogs'
+        expect(@test.path_for('tests', fixture)).to eql(expected)
+        expect(@test.items_path(fixture)).to eql(expected.sub(/^tests/,'items'))
+        expect(@test.collections_path(fixture)).to eql(expected.sub(/^tests/,'collections'))
+        expect(@test.item_path('foo')).to eql('items/foo?api_key=testing')
+        expect(@test.collection_path('foo')).to eql('collections/foo?api_key=testing')
+      end
+
+      it "should build paths for OR and NOT queries" do
+        fixture = {:foo => ['kittens', 'NOT cats']}
+        expected = 'tests?api_key=testing&foo=kittens+AND+NOT+cats'
+        expect(@test.path_for('tests', fixture)).to eql(expected)
+
+        fixture = {:foo => ['NOT kittens', 'cats']}
+        expected = 'tests?api_key=testing&foo=NOT+kittens+AND+cats'
+        expect(@test.path_for('tests', fixture)).to eql(expected)
+
+        fixture = {:foo => ['kittens', 'OR cats']}
+        expected = 'tests?api_key=testing&foo=kittens+OR+cats'
+        expect(@test.path_for('tests', fixture)).to eql(expected)
+
+        fixture = {:foo => ['OR kittens', 'cats']} 
+        expected = 'tests?api_key=testing&foo=kittens+AND+cats'
+        expect(@test.path_for('tests', fixture)).to eql(expected)
+      end
+    end
+
+    it "should build paths for facets right" do
+      fixture = {:foo => 'kittens', :facets => :bar}
+      expected = 'tests?api_key=testing&foo=kittens&facets=bar'
+      expect(@test.path_for('tests', fixture)).to eql(expected)
+
+      fixture = {:foo => 'kittens', :facets => [:bar, :baz]}
+      expected = 'tests?api_key=testing&foo=kittens&facets=bar%2Cbaz'
+      expect(@test.path_for('tests', fixture)).to eql(expected)
+
+      fixture = {:foo => 'kittens', :facets => 'bar,baz'}
+      expected = 'tests?api_key=testing&foo=kittens&facets=bar%2Cbaz'
+      expect(@test.path_for('tests', fixture)).to eql(expected)
+    end
+
+    it "should build paths for sorts right" do
+      fixture = {:foo => 'kittens', :sort_by => [:bar, :baz]}
+      expected = 'tests?api_key=testing&foo=kittens&sort_by=bar%2Cbaz'
+      expect(@test.path_for('tests', fixture)).to eql(expected)
+
+      fixture = {:foo => 'kittens', :sort_by => 'bar,baz'}
+      expected = 'tests?api_key=testing&foo=kittens&sort_by=bar%2Cbaz'
+      expect(@test.path_for('tests', fixture)).to eql(expected)
+
+      fixture = {:foo => 'kittens', :sort_by => 'bar,baz', :sort_order => :desc}
+      expected = 'tests?api_key=testing&foo=kittens&sort_by=bar%2Cbaz&sort_order=desc'
+      expect(@test.path_for('tests', fixture)).to eql(expected)
+    end
+
+    it "should build paths for field selections right" do
+      fixture = {:foo => 'kittens', :fields => [:bar, :baz]}
+      expected = 'tests?api_key=testing&foo=kittens&fields=bar%2Cbaz'
+      expect(@test.path_for('tests', fixture)).to eql(expected)
+
+      fixture = {:foo => 'kittens', :fields => 'bar,baz'}
+      expected = 'tests?api_key=testing&foo=kittens&fields=bar%2Cbaz'
+      expect(@test.path_for('tests', fixture)).to eql(expected)
+    end
+
+    it "should build paths for limits and page sizes right" do
+      fixture = {:foo => 'kittens', :page_size=>25, :page=>4}
+      expected = 'tests?api_key=testing&foo=kittens&page_size=25&page=4'
+      expect(@test.path_for('tests', fixture)).to eql(expected)
+    end
+
+  end
+end

data/ansr_dpla/spec/lib/item_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe Item do
+  describe '.configure' do
+    it "should store the configured Api class" do
+    	Item.configure({:api=>Ansr::Dpla::TestApi, :api_key => :dummy})
+    	expect(Item.api).to be_a Ansr::Dpla::TestApi
+    end
+  end
+
+  describe '.find' do
+    it "should find an item given an id" do
+      mock_api = double('api')
+      Item.api = mock_api
+      mock_api.should_receive(:items).with(:id=>"123", :page_size=>1).and_return(read_fixture('item.jsonld'))
+      Item.find('123')
+    end
+    it "should raise an exception for a bad id" do
+      mock_api = double('api')
+      Item.api = mock_api
+      mock_api.should_receive(:items).with(:id=>"123", :page_size=>1).and_return(read_fixture('empty.jsonld'))
+      expect {Item.find('123')}.to raise_error
+    end
+  end
+
+  describe '.where' do
+  	before do
+    	Item.configure({:api=>Ansr::Dpla::TestApi, :api_key => :dummy})
+    end
+  	it 'should return a Relation when there is query information' do
+      expect(Item.where({:q=>'kittens'})).to be_a Ansr::Relation
+  	end
+    it 'should return itself when there is no query information' do
+      expect(Item.where({})).to be Item
+    end
+  end
+
+  describe 'accessor methods' do
+    before do
+      mock_api = double('api')
+      Item.api = mock_api
+      @hash = JSON.parse(read_fixture('item.jsonld'))['docs'][0]
+      @test = Item.new(@hash)
+    end
+
+    it 'should dispatch method names to the hash' do
+      @test.dataProvider.should == "Boston Public Library"
+      @test.sourceResource.identifier.should == [ "Local accession: 08_06_000884" ]
+    end
+
+    it 'should miss methods for undefined fields' do
+      expect {@test.foo}.to raise_error
+    end
+  end
+
+
+end

data/ansr_dpla/spec/lib/relation/facet_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({:api_key => :foo})
+    Item.engine.api= @mock_api
+  end
+  describe '#filter' do
+	  it "do a single field, single value filter" do
+	    test = Ansr::Relation.new(Item, Item.table).filter(:object=>'kittens')
+	    @mock_api.should_receive(:items).with(:object => 'kittens', :facets => :object).and_return('')
+	    test.load
+	  end
+	  it "do a single field, multiple value filter" do
+	    test = Ansr::Relation.new(Item, Item.table).filter(:object=>['kittens', 'cats'])
+	    @mock_api.should_receive(:items).with(:object => ['kittens','cats'], :facets => :object).and_return('')
+	    test.load
+	  end
+	  it "do merge single field, multiple value filters" do
+	    test = Ansr::Relation.new(Item, Item.table).filter(:"provider.name"=>'kittens').filter(:"provider.name"=>'cats')
+	    @mock_api.should_receive(:items).with(:"provider.name" => ['kittens','cats'], :facets => :"provider.name").and_return('')
+	    test.load
+	  end
+	  it "do a multiple field, single value filter" do
+	    test = Ansr::Relation.new(Item, Item.table).filter(:object=>'kittens',:isShownAt=>'bears')
+	    @mock_api.should_receive(:items).with(:object => 'kittens', :isShownAt=>'bears', :facets => [:object, :isShownAt]).and_return('')
+	    test.load
+	  end
+	  it "should keep scope distinct from spawned Relations" do
+	    test = Ansr::Relation.new(Item, Item.table).filter(:"provider.name"=>'kittens')
+	    test.where(:q=>'cats')
+	    @mock_api.should_receive(:items).with(:"provider.name" => 'kittens', :facets => :"provider.name").and_return('')
+	    test.load
+	  end
+	  it "should raise an error if the requested field is not a filtered field" do
+	    test = Ansr::Relation.new(Item, Item.table)
+	    expect {test.filter(:foo=>'kittens')}.to raise_error
+	  end
+    it "should not require a search value for the filter" do
+      test = Ansr::Relation.new(Item, Item.table).filter(:object)
+      @mock_api.should_receive(:items).with(:facets => :object).and_return('')
+      test.load
+    end
+  end
+
+  describe '#filters' do
+    it 'should return Blacklight types' do
+      # Blacklight::SolrResponse::Facets::FacetItem.new(:value => s, :hits => v)
+      # options = {:sort => 'asc', :offset => 0}
+      # Blacklight::SolrResponse::Facets::FacetField.new name, items, options
+      test = Ansr::Relation.new(Item, Item.table).where(:q=>'kittens')
+      @mock_api.should_receive(:items).with(:q => 'kittens').and_return(@faceted)
+      test.load
+      fkey = test.filters.keys.first
+      facet = test.filters[fkey]
+      expect(facet).to be_a(Blacklight::SolrResponse::Facets::FacetField)
+      facet.items
+    end
+    it 'should dispatch a query with no docs requested if not loaded' do
+      test = Ansr::Relation.new(Item, Item.table).where(:q=>'kittens')
+      @mock_api.should_receive(:items).with(:q => 'kittens', :page_size=>0).once.and_return(@faceted)
+      fkey = test.filters.keys.first
+      facet = test.filters[fkey]
+      expect(facet).to be_a(Blacklight::SolrResponse::Facets::FacetField)
+      expect(test.loaded?).to be_false
+      test.filters # make sure we memoized the facet values
+    end
+  end
+
+end

data/ansr_dpla/spec/lib/relation/select_spec.rb

@@ -0,0 +1,52 @@
+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({:api_key => :foo})
+    Item.engine.api= @mock_api
+  end
+
+  describe '#select' do
+    describe 'with a block given' do
+      it "should build an array" do
+        test = Ansr::Relation.new(Item, Item.table).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 = Ansr::Relation.new(Item, Item.table).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 = Ansr::Relation.new(Item, Item.table).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 = Ansr::Relation.new(Item, Item.table).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
+
+end

data/ansr_dpla/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({: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/ansr_dpla/spec/lib/relation_spec.rb

@@ -0,0 +1,305 @@
+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({:api_key => :foo})
+    Item.engine.api= @mock_api
+  end
+
+  describe "#initialize" do
+    it "should identify the correct resource for the model" do
+      class Foo
+        def self.table
+          nil
+        end
+      end
+
+      test = Ansr::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 = Ansr::Relation.new(Item, Item.table).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 = Ansr::Relation.new(Item, Item.table).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 = Ansr::Relation.new(Item, Item.table).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 = Ansr::Relation.new(Item, Item.table).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 = Ansr::Relation.new(Item, Item.table).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 = Ansr::Relation.new(Item, Item.table).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 = Ansr::Relation.new(Item, Item.table).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 = Ansr::Relation.new(Item, Item.table).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 = Ansr::Relation.new(Item, Item.table).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 = Ansr::Relation.new(Item, Item.table).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 = Ansr::Relation.new(Item, Item.table).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 = Ansr::Relation.new(Item, Item.table).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 = Ansr::Relation.new(Item, Item.table).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 = Ansr::Relation.new(Item, Item.table).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 = Ansr::Relation.new(Item, Item.table).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 = Ansr::Relation.new(Item, Item.table).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 = Ansr::Relation.new(Item, Item.table).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 = Ansr::Relation.new(Item, Item.table).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 = Ansr::Relation.new(Item, Item.table).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 = Ansr::Relation.new(Item, Item.table).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 = Ansr::Relation.new(Item, Item.table).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 = Ansr::Relation.new(Item, Item.table).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 = Ansr::Relation.new(Item, Item.table).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