supplejack_client 1.0.1

data/spec/supplejack/url_formats/item_hash_spec.rb

@@ -0,0 +1,341 @@
+# The Supplejack Client code is Crown copyright (C) 2014, New Zealand Government,
+# and is licensed under the GNU General Public License, version 3.
+# See https://github.com/DigitalNZ/supplejack_client for details.
+#
+# Supplejack was created by DigitalNZ at the National Library of NZ
+# and the Department of Internal Affairs. http://digitalnz.org/supplejack
+
+require 'spec_helper'
+
+def item_hash(params={}, search=nil)
+  Supplejack::UrlFormats::ItemHash.new(params, search)
+end
+
+module Supplejack
+  module UrlFormats
+    describe ItemHash do
+
+      describe '#to_api_hash' do
+        it 'doesn\'t return blank text' do
+          item_hash({:text => '' }).to_api_hash.should_not have_key(:text)
+        end
+
+        it 'returns the text in the params' do
+          item_hash({:text => 'dog'}).to_api_hash.should include(:text => 'dog')
+        end
+
+        it 'returns the geo_bbox in the params' do
+          item_hash({:geo_bbox => '1,2,3,4'}).to_api_hash.should include(:geo_bbox => '1,2,3,4')
+        end
+
+        it 'type casts the record_type' do
+          item_hash({:record_type => '1'}).to_api_hash.should include(:record_type => 1)
+        end
+
+        it 'returns by default page 1' do
+          item_hash.to_api_hash.should include(:page => 1)
+        end
+
+        it 'returns the page parameter' do
+          item_hash({:page => '3'}).to_api_hash.should include(:page => 3)
+        end
+
+        it 'returns the per_page set in the initializer' do
+          Supplejack.stub(:per_page) { 15 }
+          item_hash.to_api_hash.should include(:per_page => 15)
+        end
+
+        it 'returns the per_page in the parameters' do
+          item_hash({:per_page => '22'}).to_api_hash.should include(:per_page => 22)
+        end
+
+        it 'returns the and_filters in the :and key' do
+          item_hash({:i => {:description => 'Weird one'}}).to_api_hash.should include(:and => {:description => 'Weird one'})
+        end
+
+        it 'returns the without_filters in the :without key' do
+          item_hash({:i => {'-description' => 'Weird one'}}).to_api_hash.should include(:without => {:description => 'Weird one'})
+        end
+
+        it 'returns the facets' do
+          item_hash({:facets => 'description,creator'}).to_api_hash.should include(:facets => 'description,creator')
+        end
+
+        it 'returns the facets per page' do
+          item_hash({:facets_per_page => '12'}).to_api_hash.should include(:facets_per_page => 12)
+        end
+
+        it 'returns the sort and direction' do
+          item_hash({:sort => 'title', :direction => 'desc'}).to_api_hash.should include(:sort => 'title', :direction => 'desc')
+        end
+
+        it 'doesn\'t return either sort nor direction when sort not present' do
+          item_hash({:direction => 'desc'}).to_api_hash.should_not include(:direction => 'desc')
+        end
+
+        it 'returns default direction "asc"' do
+          item_hash({:sort => 'title'}).to_api_hash.should include(:direction => 'asc')
+        end
+
+        it 'returns the default set of fields from config' do
+          Supplejack.stub(:fields) { [:default,:atl] }
+          item_hash.to_api_hash.should include(:fields => 'default,atl')
+        end
+
+        it 'overrides the fields from the parameters' do
+          item_hash({:fields => 'verbose,authorities'}).to_api_hash.should include(:fields => 'verbose,authorities')
+        end
+
+        it 'doesn\'t break when nil options hash' do
+          item_hash(nil).to_api_hash.should be_a Hash
+        end
+
+        it 'sends the solr_query option to the api' do
+          item_hash({:solr_query => 'dc_type:Images'}).to_api_hash.should include(:solr_query => 'dc_type:Images')
+        end
+
+        it 'shouldn\'t send the solr_query if empty' do
+          item_hash({:solr_query => ''}).to_api_hash.should_not have_key(:solr_query)
+        end
+
+        # it 'adds query_fields to the hash if present' do
+        #   convert(@search, {:i => {:creator_text => 'john'}}).should include(:query_fields => [:creator])
+        # end
+        #
+        # it 'doesn't add empty query fields' do
+        #   convert(@search, {:i => {:display_collection => 'nzlnz'}}).should_not have_key(:query_fields)
+        # end
+      end
+
+      describe '#and_filters' do
+        it 'returns every filter' do
+          item_hash({:i => {'sample_filter' => 'Groups'}}).and_filters.should eq({:sample_filter => 'Groups'})
+        end
+
+        it 'returns every filter' do
+          item_hash({:i => {'sample_filter' => 'Groups', '-content_partner' => 'nlnz'}}).and_filters.should eq({:sample_filter => 'Groups'})
+        end
+
+        it 'removes any _text filters' do
+          item_hash({:i => {'filter_with_text' => 'dog'}}).and_filters.should eq({})
+        end
+
+        it 'returns only item filters if filter_type is :items' do
+          item_hash({:i => {'subject' => 'dog'}, :h => {'heading_type' => 'record_type'}, :record_type => 1}).and_filters(:items).should eq({:subject => 'dog'})
+        end
+
+        it 'returns only headings filters if filter_type is :headings' do
+          item_hash({:i => {'subject' => 'dog'}, :h => {'heading_type' => 'record_type'}, :record_type => 0}).and_filters(:headings).should eq({:heading_type => 'record_type'})
+        end
+
+        it 'memoizes :i and :h filters seperatly' do
+          hash = item_hash({:i => {'subject' => 'dog'}, :h => {'heading_type' => 'record_type'}})
+          hash.and_filters(:items).should eq({:subject => 'dog'})
+          hash.and_filters(:headings).should eq({:heading_type => 'record_type'})
+        end
+      end
+
+      describe '#is_text_field?' do
+        it 'returns true when the passed field is text' do
+          item_hash.is_text_field?('title_text').should be_true
+        end
+
+        it 'returns false when the passed field is not text' do
+          item_hash.is_text_field?('title_authority').should be_false
+        end
+
+        it 'returns false when the passed field is nil' do
+          item_hash.is_text_field?(nil).should be_false
+        end
+      end
+
+      describe '#without_filters' do
+        it 'returns only negative filters' do
+          item_hash({:i => {'-negative_category' => 'Groups', 'positive_category' => 'nlnz'}}).without_filters.should eq({:negative_category => 'Groups'})
+        end
+
+        it 'returns only item filters if filter_type is :items' do
+          item_hash({:i => {'-subject' => 'dog'}, :h => {'-heading_type' => 'record_type'}, :record_type => 1}).without_filters(:items).should eq({:subject => 'dog'})
+        end
+
+        it 'returns only headings filters if filter_type is :headings' do
+          item_hash({:i => {'-subject' => 'dog'}, :h => {'-heading_type' => 'record_type'}, :record_type => 0}).without_filters(:headings).should eq({:heading_type => 'record_type'})
+        end
+
+        it 'memoizes :i and :h filters seperatly' do
+          hash = item_hash({:i => {'-subject' => 'dog'}, :h => {'-heading_type' => 'record_type'}})
+          hash.without_filters(:items).should eq({:subject => 'dog'})
+          hash.without_filters(:headings).should eq({:heading_type => 'record_type'})
+        end
+
+      end
+
+      describe '#text' do
+        it 'returns the text if present' do
+          item_hash.text('dog').should eq 'dog'
+        end
+
+        it 'returns nil when text is not present' do
+          item_hash().text('').should be_nil
+        end
+
+        it 'extracts the text from name_text' do
+          item_hash({:i => {:name_text => 'john'}}).text.should eq 'john'
+        end
+      end
+
+      describe '#query_fields' do
+        it 'returns all fields that end with _text' do
+          item_hash(:i => {:name_text => 'john', :location_text => 'New Zealand'}).query_fields.should include(:name, :location)
+        end
+
+        it 'returns nil when no filters match _text' do
+          item_hash(:i => {:sample_collection => 'nlnz'}).query_fields.should be_nil
+        end
+
+        it 'returns only _text filters' do
+          item_hash(:i => {:name_text => 'john', :sample_collection => 'nlnz'}).query_fields.should eq [:name]
+        end
+      end
+
+      describe '#filters' do
+        context 'default records' do
+          it 'returns the hash within the :i key and symbolizes them' do
+            item_hash({:i => {'location' => 'NZ'}}).filters.should eq({:location => 'NZ'})
+          end
+
+          it 'merges in the locked filters' do
+            result = {:location => 'NZ', :category => 'Images'}
+            item_hash({:i => {'location' => 'NZ'}, :il => {'category' => 'Images'}}).filters.should eq(result)
+          end
+
+          it 'returns :h filters with record_type parameter' do
+            item_hash({:i => {'location' => 'NZ'}, :h => {:dc_type => 'Names'}}).filters(:headings).should eq({:dc_type => 'Names'})
+          end
+
+          it 'memoizes the :i and :h filters separately' do
+            @hash = item_hash({:i => {'location' => 'NZ'}, :h => {:dc_type => 'Names'}})
+            @hash.filters.should eq({:location => 'NZ'})
+            @hash.filters(:headings).should eq({:dc_type => 'Names'})
+          end
+
+          it 'handles a string in the :i hash' do
+            item_hash({:i => ''}).filters.should be_empty
+          end
+
+          it 'handles a string in the :il hash' do
+            item_hash({:il => ''}).filters.should be_empty
+          end
+        end
+
+        context 'headings tab' do
+          it 'returns the hash within the :h key' do
+            item_hash({:h => {'heading_type' => 'Name'}, :record_type => '1'}).filters.should eq({:heading_type => 'Name'})
+          end
+
+          it 'merges in the locked filters' do
+            result = {:heading_type => 'Name', :year => '1900'}
+            item_hash({:h => {'heading_type' => 'Name'}, :hl => {'year' => '1900'}, :record_type => '1'}).filters.should eq(result)
+          end
+        end
+      end
+
+      describe '#filter_symbol' do
+        context 'when filter_type is nil' do
+          it 'returns "i" when record_type is 0' do
+            item_hash(:record_type => 0).filter_symbol.should eq 'i'
+          end
+
+          it 'returns "h" when record_type is 1' do
+            item_hash(:record_type => 1).filter_symbol.should eq 'h'
+          end
+        end
+
+        context 'filter_type is provided' do
+          it 'returns "i" when filter_type is :items' do
+            item_hash(:record_type => 1).filter_symbol(:items).should eq 'i'
+          end
+
+          it 'returns "h" when filter_type is :headings' do
+            item_hash(:record_type => 0).filter_symbol(:headings).should eq 'h'
+          end
+        end
+      end
+
+      describe '#filters_of_type' do
+        it 'returns item unlocked filters' do
+          item_hash({:i => {:category => 'Images'}}).filters_of_type(:i).should eq({:category => 'Images'})
+        end
+      end
+
+      describe '#options' do
+        before(:each) do
+          @search = Supplejack::Search.new
+        end
+
+        it 'returns a hash with the search parameters' do
+          params = {:i => {:name => 'John'}, :il => {:type => 'Person'}, :h => {:heading_type => 'Name'}, :hl => {:year => '1900'}}
+          item_hash(params, @search).options.should eq params
+        end
+
+        it 'doesnt return any empty values' do
+          item_hash({:i => {:name => '', :type => nil, :location => 'Wellington'}}, @search).options.should eq(:i => {:location => 'Wellington'})
+        end
+
+        it 'returns a empty hash when filters are empty' do
+          item_hash({:i => {:name => '', :type => nil}}, @search).options.should eq({})
+        end
+
+        it 'doesn\'t return page parameter when page 1' do
+          item_hash({:page => 1}, @search).options.should eq({})
+        end
+
+        it 'doesn\'t return page parameter is empty' do
+          item_hash({}, @search).options.should eq({})
+        end
+
+        it 'removes the filters in the :except parameter' do
+          item_hash({:i => {:name => 'John'}, :il => {:type => 'Person'}}, @search).options(:except => [:name]).should eq(:il => {:type => 'Person'})
+        end
+
+        it 'includes the record_type when is 1' do
+          search = Supplejack::Search.new(:record_type => 1)
+          item_hash({:record_type => 1}, search).options.should include(:record_type => 1)
+        end
+
+        it 'excludes the page parameter' do
+          search = Supplejack::Search.new(:page => 3)
+          item_hash({}, search).options(:except => [:page]).should_not include(:page => 3)
+        end
+        
+        it 'adds multiple values to the same facet' do
+          search = Supplejack::Search.new(:i => {:name => 'John'})
+          item_hash({:i => {:name => 'John'}}, search).options(:plus => {:i => {:name => 'James'}})[:i].should include(:name => ['John', 'James'])
+        end
+        
+        it 'only removes one value from the same facet' do
+          search = Supplejack::Search.new(:i => {:name => ['John', 'James']})
+          item_hash({:i => {:name => ['John', 'James']}}, search).options(:except => [{:name => 'James'}])[:i].should include(:name => 'John')
+        end
+        
+        it 'only removes one value from the same facet' do
+          search = Supplejack::Search.new(:i => {:name => ['John', 'James', 'Jake']})
+          item_hash({:i => {:name => ['John', 'James', 'Jake']}}, search).options(:except => [{:name => 'James'}])[:i].should include(:name => ['John', 'Jake'])
+        end
+        
+        it 'removes the whole facet if there is no remaining values' do
+          params = {:i => {:name => ['John', 'James'], :type => 'Person'}}
+          search = Supplejack::Search.new(params)
+          item_hash(params, search).options(:except => [{:name => ['James', 'John']}])[:i].should_not have_key(:name)
+        end
+
+        context 'in the items tab' do
+          it 'merges filters in the :plus parameter to the unlocked hash' do
+            item_hash({}, @search).options(:plus => {:i => {'type' => 'Something'}})[:i].should include(:type => 'Something')
+          end
+        end
+      end
+
+    end
+  end
+end

data/spec/supplejack/user_set_relation_spec.rb

@@ -0,0 +1,149 @@
+# The Supplejack Client code is Crown copyright (C) 2014, New Zealand Government,
+# and is licensed under the GNU General Public License, version 3.
+# See https://github.com/DigitalNZ/supplejack_client for details.
+#
+# Supplejack was created by DigitalNZ at the National Library of NZ
+# and the Department of Internal Affairs. http://digitalnz.org/supplejack
+
+require 'spec_helper'
+
+module Supplejack
+  describe UserSetRelation do
+    let(:user) { Supplejack::User.new({authentication_token: '123abc'}) }
+    let(:relation) { Supplejack::UserSetRelation.new(user) }
+
+    before :each do
+      relation.stub(:get) { {'sets' => [{'id' => '1', 'name' => 'dogs', 'count' => 1, 'priority' => 2}, {'id' => '2', 'name' => 'Favourites', 'count' => 1, 'priority' => 1}]} }
+    end
+    
+    describe '#initialize' do
+      it 'initializes with a UserSet object' do
+        @user = user
+        Supplejack::UserSetRelation.new(@user).user.should eq @user
+      end
+    end
+
+    describe '#fetch_sets' do
+      it 'fetches the user sets with the App api_key' do
+        relation.should_receive(:get).with('/users/123abc/sets', {})
+        relation.fetch_sets
+      end
+
+      it 'returns a array of UserSet objects' do
+        relation.fetch_sets.should be_a Array
+        relation.fetch_sets.each do |set|
+          set.should be_a Supplejack::UserSet
+        end
+      end
+      
+      it 'should order the user sets by priority' do
+        relation.fetch_sets.first.name.should eq 'Favourites'
+        relation.fetch_sets.last.name.should eq 'dogs'
+      end
+    end
+
+    describe 'sets_response' do
+      context 'caching disabled' do
+        before :each do
+          Supplejack.stub(:enable_caching) { false }
+        end
+
+        it 'fetches the user sets with the App api_key' do
+          relation.should_receive(:get).with('/users/123abc/sets', {})
+          relation.sets_response
+        end
+
+        context 'user with use_own_api_key set to true' do
+          it 'fetches the user sets with it\'s own API Key' do
+            user.stub(:use_own_api_key?) { true }
+            relation.should_receive(:get).with('/sets', {api_key: '123abc'})
+            relation.sets_response
+          end
+        end
+      end
+    end
+
+    describe '#sets' do
+      it 'memoizes the sets array' do
+        relation.should_receive(:fetch_sets).once { [] }
+        relation.sets
+        relation.sets
+      end
+    end
+
+    describe '#find' do
+      it 'finds a user and sets the correct api_key' do
+        Supplejack::UserSet.should_receive(:find).with('555', '123abc')
+        relation.find('555')
+      end
+    end
+
+    describe '#build' do
+      it 'initializes a new UserSet with the user\'s api_key' do
+        user_set = relation.build
+        user_set.should be_a UserSet
+        user_set.api_key.should eq '123abc'
+      end
+
+      it 'initializes the UserSet with the provided attributes' do
+        user_set = relation.build({name: 'Dogs', description: 'Hi'})
+        user_set.name.should eq 'Dogs'
+        user_set.description.should eq 'Hi'
+      end
+    end
+
+    describe '#create' do
+      it 'initializes the UserSet and saves it' do
+        user_set = relation.build({name: 'Dogs'})
+        relation.should_receive(:build).with(name: 'Dogs') { user_set }
+        user_set.should_receive(:save) { true }
+        relation.create({name: 'Dogs'}).should be_a Supplejack::UserSet
+      end
+    end
+
+    describe '#order' do
+      before :each do
+        relation.stub(:get) { {'sets' => [{'name' => 'dogs', 'priority' => 2, 'count' => 3}, { 'name' => 'zavourites', 'priority' => 1, 'count' => 2},{ 'name' => 'Favourites', 'priority' => 2, 'count' => 1}]} }      
+      end
+      it 'orders the sets based on the name' do
+        relation.order(:name)[0].name.should eq 'zavourites'
+        relation.order(:name)[1].name.should eq 'dogs'
+        relation.order(:name)[2].name.should eq 'Favourites'
+      end
+      it 'orders the sets based on the count' do
+        relation.order(:count)[0].name.should eq 'zavourites'
+        relation.order(:count)[1].name.should eq 'Favourites'
+        relation.order(:count)[2].name.should eq 'dogs' 
+      end
+
+      it 'orders the sets based on the updated_at ignoring the priority' do
+        relation.stub(:get) { {'sets' => [{'name' => '1', 'updated_at' => Time.now.to_s, 'priority' => 2}, {'name' => '3', 'updated_at' => (Time.now-4.hours).to_s, 'priority' => 1},{'name' => '2', 'updated_at' => (Time.now-1.hours).to_s, 'priority' => 2}]} }
+        relation.order(:updated_at)[0].name.should eq '1'
+        relation.order(:updated_at)[1].name.should eq '2'
+        relation.order(:updated_at)[2].name.should eq '3'
+      end
+    end
+
+    describe '#all' do
+      it 'returns the actual array with the sets' do
+        relation.all.should be_a Array
+      end
+    end
+
+    context 'user sets array behaviour' do
+      it 'executes array methods on the @sets array' do
+        sets = relation.stub(:sets) { [] }
+        relation.size.should eq 0
+      end
+
+      it 'should be able to iterate through the user sets relation' do
+        relation.stub(:sets) { [Supplejack::UserSet.new] }
+        relation.each do |set|
+          set.should be_a Supplejack::UserSet
+        end
+        relation.size.should eq 1
+      end
+    end
+
+  end
+end