supplejack_api 1

data/spec/routing/partner_routing_spec.rb

@@ -0,0 +1,34 @@
+# The majority of the Supplejack API code is Crown copyright (C) 2014, New Zealand Government,
+# and is licensed under the GNU General Public License, version 3.
+# One component is a third party component. See https://github.com/DigitalNZ/supplejack_api 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 SupplejackApi
+  describe "Partner routes", type: :routing do
+    routes { SupplejackApi::Engine.routes }
+
+    before(:each) do
+      allow_any_instance_of(HarvesterConstraint).to receive(:matches?).and_return(true)
+    end
+
+    it "routes /partners to partners#create" do
+      expect(post("/partners")).to route_to(controller: 'supplejack_api/partners', action: 'create')
+    end
+
+    it "routes /partners/1 to partners#show" do
+      expect(get("/partners/1")).to route_to(controller: 'supplejack_api/partners', action: 'show', id: '1')
+    end
+
+    it "routes /partners to partners#index" do
+      expect(get("/partners")).to route_to(controller: 'supplejack_api/partners', action: 'index')
+    end
+
+    it "routes /partners/1 to partners#update" do
+      expect(put("/partners/1")).to route_to(controller: 'supplejack_api/partners', action: 'update', id: '1')
+    end
+  end
+end

data/spec/routing/records_routing_spec.rb

@@ -0,0 +1,26 @@
+# The majority of the Supplejack API code is Crown copyright (C) 2014, New Zealand Government,
+# and is licensed under the GNU General Public License, version 3.
+# One component is a third party component. See https://github.com/DigitalNZ/supplejack_api 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 SupplejackApi
+  describe 'Records route', type: :routing do
+    routes { SupplejackApi::Engine.routes }
+
+    it 'routes /records.format to records#index' do
+      expect(get '/records.json').to route_to(controller: 'supplejack_api/records', action: 'index', format: 'json', version: nil)
+    end
+
+    it 'routes /records/1.format to records#index' do
+      expect(get '/records/99.json').to route_to(controller: 'supplejack_api/records', action: 'show', id: '99', format: 'json', version: nil)
+    end
+    
+    it 'routes /records/multiple.json records#multiple' do
+      expect(get: '/records/multiple.json').to route_to(controller: 'supplejack_api/records', action: 'multiple', format: 'json', version: nil)
+    end
+  end
+end

data/spec/routing/sets_routing_spec.rb

@@ -0,0 +1,44 @@
+# The majority of the Supplejack API code is Crown copyright (C) 2014, New Zealand Government,
+# and is licensed under the GNU General Public License, version 3.
+# One component is a third party component. See https://github.com/DigitalNZ/supplejack_api 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'
+
+describe 'Sets routes', type: :routing do
+  routes { SupplejackApi::Engine.routes }
+
+  it 'routes /sets.format to user_sets#index' do
+    expect({ get: '/sets.json' }).to route_to(controller: 'supplejack_api/user_sets', action: 'index', format: 'json', version: nil)
+  end
+
+  it 'routes /users/123/sets.format to user_sets#index' do
+    expect({ get: '/users/123/sets.json' }).to route_to(controller: 'supplejack_api/user_sets', action: 'admin_index', format: 'json', version: nil, user_id: '123')
+  end
+
+  it 'routes /sets/public.format to user_sets#public_index' do
+    expect({ get: '/sets/public.json' }).to route_to(controller: 'supplejack_api/user_sets', action: 'public_index', format: 'json', version: nil)
+  end
+
+  it 'routes /sets/1.format to user_sets#show' do
+    expect({ get: '/sets/10.json' }).to route_to(controller: 'supplejack_api/user_sets', action: 'show', format: 'json', version: nil, id: '10')
+  end
+
+  it 'routes /sets.format to user_sets#create' do
+    expect({post: '/sets.json' }).to route_to(controller: 'supplejack_api/user_sets', action: 'create', format: 'json', version: nil)
+  end
+
+  it 'routes /sets/123abc.json to user_sets#update' do
+    expect({ put: '/sets/123abc.json' }).to route_to(controller: 'supplejack_api/user_sets', action: 'update', format: 'json', version: nil, id: '123abc')
+  end
+
+  it 'routes /sets/123abc/records.json to set_items#create' do
+    expect({ post: '/sets/123abc/records.json' }).to route_to(controller: 'supplejack_api/set_items', action: 'create', format: 'json', version: nil, user_set_id: '123abc')
+  end
+
+  it 'routes /sets/123abc/records/666.json to set_items#destroy' do
+    expect({ delete: '/sets/123abc/records/666.json' }).to route_to(controller: 'supplejack_api/set_items', action: 'destroy', format: 'json', version: nil, user_set_id: '123abc', id: '666')
+  end
+end

data/spec/routing/source_routing_spec.rb

@@ -0,0 +1,38 @@
+# The majority of the Supplejack API code is Crown copyright (C) 2014, New Zealand Government,
+# and is licensed under the GNU General Public License, version 3.
+# One component is a third party component. See https://github.com/DigitalNZ/supplejack_api 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 SupplejackApi
+  describe 'Source routes', type: :routing do
+    routes { SupplejackApi::Engine.routes }
+
+    before(:each) do
+      allow_any_instance_of(HarvesterConstraint).to receive(:matches?).and_return(true)
+    end
+
+    it 'routes /partners/123/sources to sources#create' do
+      expect(post('/partners/123/sources.json')).to route_to(controller: 'supplejack_api/sources', action: 'create', partner_id: '123', format: 'json')
+    end
+
+    it 'routes /sources/1234 to sources#show' do
+      expect(get('/sources/1234.json')).to route_to(controller: 'supplejack_api/sources', action: 'show', id: '1234', format: 'json')
+    end
+
+    it "routes /sources to sources#index" do
+      expect(get('/sources.json')).to route_to(controller: 'supplejack_api/sources', action: 'index', format: 'json')
+    end
+
+    it "routes /sources/1234 to sources#update" do
+      expect(put('/sources/1234.json')).to route_to(controller: 'supplejack_api/sources', action: 'update', id: '1234', format: 'json')
+    end
+
+    it "routes /sources/1234/reindex to sources#reindex" do
+     expect(get('/sources/1234/reindex.json')).to route_to(controller: 'supplejack_api/sources', action: 'reindex', id: '1234', format: 'json')
+    end
+  end
+end

data/spec/routing/users_routing_spec.rb

@@ -0,0 +1,18 @@
+# The majority of the Supplejack API code is Crown copyright (C) 2014, New Zealand Government,
+# and is licensed under the GNU General Public License, version 3.
+# One component is a third party component. See https://github.com/DigitalNZ/supplejack_api 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 SupplejackApi
+  describe "User routes", type: :routing do
+    routes { SupplejackApi::Engine.routes }
+
+    it "routes /users/1.format to users#show" do
+      expect(get('/users/1.json')).to route_to(controller: 'supplejack_api/users', action: 'show', format: 'json', id: '1', version: nil)
+    end
+  end
+end

data/spec/serializers/concept_record_serializer_spec.rb

@@ -0,0 +1,30 @@
+# The majority of the Supplejack API code is Crown copyright (C) 2014, New Zealand Government, 
+# and is licensed under the GNU General Public License, version 3.
+# One component is a third party component. See https://github.com/DigitalNZ/supplejack_api 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 SupplejackApi
+  describe ConceptRecordSerializer do
+    let(:record) { SupplejackApi::Record.new(title: 'Wellington', description: 'New Zealand', date: '2015-06-05', 
+      display_content_partner: 'Television New Zealand', display_collection: 'TVNZ', thumbnail_url: 'http://example.com') }
+    let(:serializer) { ConceptRecordSerializer.new(record) }
+  
+   it 'includes the basic record information' do
+      allow(record).to receive(:id) { 'abc' }
+      allow(record).to receive(:record_id) { '123' }
+      json = serializer.as_json[:concept_record]
+
+      expect(json['@id']).to eq 'http://test.host/records/123'
+      expect(json['title']).to eq record.title
+      expect(json['description']).to eq record.description
+      expect(json['date']).to eq record.date
+      expect(json['display_content_partner']).to eq record.display_content_partner
+      expect(json['display_collection']).to eq record.display_collection
+      expect(json['thumbnail_url']).to eq record.thumbnail_url
+    end
+  end
+end

data/spec/serializers/supplejack_api/application_serializer_spec.rb

@@ -0,0 +1,14 @@
+# The majority of the Supplejack API code is Crown copyright (C) 2014, New Zealand Government, 
+# and is licensed under the GNU General Public License, version 3.
+# One component is a third party component. See https://github.com/DigitalNZ/supplejack_api 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 SupplejackApi
+  describe ApplicationSerializer do 
+  
+  end
+end

data/spec/serializers/supplejack_api/concept_search_serializer_spec.rb

@@ -0,0 +1,34 @@
+# The majority of the Supplejack API code is Crown copyright (C) 2014, New Zealand Government,
+# and is licensed under the GNU General Public License, version 3.
+# One component is a third party component. See https://github.com/DigitalNZ/supplejack_api 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 SupplejackApi
+  describe ConceptSearchSerializer do
+
+    # def serializer(options={}, attributes={})
+    #   @user = FactoryGirl.build(:user, attributes)
+    #   @serializer = ConceptSearchSerializer.new(@user, options)
+    # end
+
+    # describe '#default?' do
+    #   it 'should return true when default is part of the groups' do
+    #     expect(serializer(groups: [:default]).default?).to be_truthy
+    #   end
+
+    #   it 'should return false when the group is verbose' do
+    #     expect(serializer(groups: [:verbose]).default?).to be_falsey
+    #   end
+
+    #   it 'should return false' do
+    #     expect(serializer(groups: nil).default?).to be_falsey
+    #     expect(serializer(groups: []).default?).to be_falsey
+    #   end
+    # end
+  end
+
+end

data/spec/serializers/supplejack_api/concept_serializer_spec.rb

@@ -0,0 +1,92 @@
+# The majority of the Supplejack API code is Crown copyright (C) 2014, New Zealand Government,
+# and is licensed under the GNU General Public License, version 3.
+# One component is a third party component. See https://github.com/DigitalNZ/supplejack_api 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 SupplejackApi
+  describe ConceptSerializer do
+    before { allow(ConceptSchema).to receive(:roles) { double(:developer).as_null_object } }
+
+    def serializer(options={}, attributes={})
+      concept_fields = Concept.fields.keys
+      concept_attributes = Hash[attributes.map {|k, v| [k, v] if concept_fields.include?(k.to_s)}.compact]
+      attributes.delete_if {|k, v| concept_fields.include?(k.to_s) }
+
+      @concept = FactoryGirl.build(:concept, concept_attributes)
+      @concept.id = "http://localhost/concepts/#{@concept.concept_id}"
+      @serializer = ConceptSerializer.new(@concept, options)
+    end
+
+    describe '#include_context_fields!' do
+      before {
+        @hash = {'@context' => {}, name: 'McCahon'}
+      }
+
+      it 'include inline context in concept' do
+        s = serializer({ inline_context: 'true'})
+        s.include_context_fields!(@hash)
+        concept = {
+          '@context'=>{
+              :foaf => 'http://xmlns.com/foaf/0.1/',
+              :dc => 'http://purl.org/dc/elements/1.1/',
+              :edm => 'http://www.europeana.eu/schemas/edm/',
+              :dcterms => 'http://purl.org/dc/terms/',
+              :concept_id => {
+                '@id' => 'dcterms:identifier'
+              },
+              :name => {
+                '@id' => 'foaf:name'
+              },
+              :title => {
+                '@id' => 'dc:title'
+              },
+              :date => {
+                '@id' => 'dc:date'
+              },
+              :description => {
+                '@id' => 'dc:description'
+              },
+              :agents => {
+                '@id'=>'edm:agents'
+              },
+              :source_authority=> {
+                '@id' => 'foaf:source_authority'
+              },
+          },
+          :name => 'McCahon'
+        }
+        expect(@hash).to eq concept
+      end
+
+      it 'show context document url' do
+        s = serializer()
+        s.include_context_fields!(@hash)
+        expect(@hash['@context']).to eq "#{ENV['HTTP_HOST']}/schema"
+        expect(@hash[:name]).to eq 'McCahon'
+      end
+    end
+
+    describe '#include_individual_fields!' do
+      it 'merges in the hash the requested fields' do
+        hash = {}
+        s = serializer({ fields: [:name] }, { name: 'McCahon' })
+        s.include_individual_fields!(hash)
+        expect(hash).to eq({ name: 'McCahon', concept_id: 1})
+      end
+    end
+
+    describe '#include_reverse_fields!' do
+      it 'includes reverse field' do
+        hash = {}
+        s = serializer({ fields: [:name] }, { name: 'McCahon' })
+        s.include_reverse_fields!(hash)
+        expect(hash['@reverse']).to include 'agents'
+        expect(hash['@reverse']['agents']).to eq []
+      end
+    end
+  end
+end

data/spec/serializers/supplejack_api/record_search_serializer_spec.rb

@@ -0,0 +1,34 @@
+# The majority of the Supplejack API code is Crown copyright (C) 2014, New Zealand Government,
+# and is licensed under the GNU General Public License, version 3.
+# One component is a third party component. See https://github.com/DigitalNZ/supplejack_api 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 SupplejackApi
+  describe RecordSearchSerializer do
+
+    def serializer(options={}, attributes={})
+      @user = FactoryGirl.build(:user, attributes)
+      @serializer = RecordSearchSerializer.new(@user, options)
+    end
+
+    describe '#default?' do
+      it 'should return true when default is part of the groups' do
+        expect(serializer(groups: [:default]).default?).to be_truthy
+      end
+
+      it 'should return false when the group is verbose' do
+        expect(serializer(groups: [:verbose]).default?).to be_falsey
+      end
+
+      it 'should return false' do
+        expect(serializer(groups: nil).default?).to be_falsey
+        expect(serializer(groups: []).default?).to be_falsey
+      end
+    end
+  end
+
+end

data/spec/serializers/supplejack_api/record_serializer_spec.rb

@@ -0,0 +1,271 @@
+# The majority of the Supplejack API code is Crown copyright (C) 2014, New Zealand Government,
+# and is licensed under the GNU General Public License, version 3.
+# One component is a third party component. See https://github.com/DigitalNZ/supplejack_api 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 SupplejackApi
+  describe RecordSerializer do
+
+    before(:each) do
+      allow(RecordSchema).to receive(:roles) { double(:developer).as_null_object }
+    end
+
+    def record_hash(attributes={}, method=nil, options={})
+      record_fields = Record.fields.keys
+      record_attributes = Hash[attributes.map {|k,v| [k,v] if record_fields.include?(k.to_s)}.compact]
+      attributes.delete_if {|k,v| record_fields.include?(k.to_s) }
+
+      @record = FactoryGirl.build(:record, record_attributes)
+      @record.fragments.build(attributes)
+      @serializer = RecordSerializer.new(@record, options)
+
+      if method
+        @serializer.send(method)
+      else
+        @serializer.as_json[:record]
+      end
+    end
+
+    def serializer(options={}, attributes={})
+      record_fields = Record.fields.keys
+      record_attributes = Hash[attributes.map {|k,v| [k,v] if record_fields.include?(k.to_s)}.compact]
+      attributes.delete_if {|k,v| record_fields.include?(k.to_s) }
+
+      @record = FactoryGirl.build(:record, record_attributes)
+      @record.fragments.build(attributes)
+      @serializer = RecordSerializer.new(@record, options)
+    end
+
+    describe '#as_json' do
+      let(:record) { FactoryGirl.build(:record) }
+      let(:serializer) { RecordSerializer.new(record) }
+
+      [:next_record, :previous_record, :next_page, :previous_page].each do |attribute|
+        it "should include #{attribute} when present" do
+          record.send("#{attribute}=", 2)
+          expect(serializer.as_json[:record][attribute]).to eq 2
+        end
+
+        it "should not include #{attribute} when null" do
+          record.send("#{attribute}=", nil)
+          expect(serializer.as_json[:record]).to_not have_key(attribute)
+        end
+      end
+    end
+
+    describe '#include_individual_fields!' do
+      before { @hash = {} }
+
+      it 'merges in the hash the requested fields' do
+        s = serializer({ fields: [:age] }, { age: 22 })
+        s.include_individual_fields!(@hash)
+        expect(@hash).to eq({ age: 22 })
+      end
+    end
+
+    describe '#remove_restricted_fields!' do
+      let(:hash) { {name: 'John Doe', address: "Wellington", email: ["johndoe@example.com"], age: 30} }
+      let(:user) { User.new(role: "developer") }
+      let(:restrictions) { { address: {"Wellington"=>["name"], "Auckland"=>["email"]},
+                             email: {/example.com/ => ["address", "age"]} } }
+      let(:developer_role) { double(:developer_role, field_restrictions: restrictions) }
+      let(:admin_role) { double(:admin_role, field_restrictions: nil) }
+
+      before(:each) do
+        allow(RecordSchema).to receive(:roles).and_return({ developer: developer_role, admin: admin_role })
+      end
+
+      context "string conditions" do
+        context "Wellington" do
+          let(:s) { serializer({scope: user}, {address: ["Wellington"]}) }
+
+          it "removes name field" do
+            s.remove_restricted_fields!(hash)
+            expect(hash[:name]).to be_nil
+          end
+
+          it "doesn't remove non-restriected fields" do
+            s.remove_restricted_fields!(hash)
+            expect(hash[:age]).to eq 30
+          end
+        end
+
+        context "Auckland" do
+          let(:s) { serializer({scope: user}, {address: ["Auckland"]}) }
+
+          it "removes email field" do
+            s.remove_restricted_fields!(hash)
+            expect(hash[:email]).to be_nil
+          end
+        end
+      end
+
+      context "regex conditions" do
+        let(:s) { serializer({scope: user}, {email: ["johndoe@example.com"]}) }
+
+        it "removes address field" do
+          s.remove_restricted_fields!(hash)
+          expect(hash[:address]).to be_nil
+        end
+      end
+
+      context "remove multiple fields" do
+        let(:s) { serializer({scope: user}, {email: ['johndoe@example.com']}) }
+
+        it "removes all fields that match the restrictions" do
+          s.remove_restricted_fields!(hash)
+          expect(hash[:large_thumbnail_url]).to be_nil
+          expect(hash[:thumbnail_url]).to be_nil
+        end
+      end
+
+      context "field value is empty" do
+        let(:s) { serializer({scope: user}, {address: nil}) }
+
+        it "doesn't fail when a string condition field value is empty" do
+          s.remove_restricted_fields!(hash)
+          expect(hash[:name]).to eq 'John Doe'
+        end
+
+        it "doesn't fail when a regex condition field value is empty" do
+          s.remove_restricted_fields!(hash)
+          expect(hash[:email]).to eq ['johndoe@example.com']
+        end
+      end
+
+      context "no restrictions for role" do
+        let(:admin_user) { User.new(role: "admin") }
+        let(:s) { serializer({scope: admin_user}) }
+
+        it "returns all fields" do
+          s.remove_restricted_fields!(hash)
+          expect(hash.keys).to eq [:name, :address, :email, :age]
+        end
+      end
+    end
+
+    describe '#serializable_hash' do
+      context 'include groups of fields' do
+        let(:default_group) { double(:default_group, fields: [:name, :email]) }
+        let(:details_group) { double(:details_group, fields: [:name, :email, :age]) }
+        let(:s) { serializer({groups: [:default]}) }
+        let(:record) { double(:record).as_null_object }
+
+        before(:each) do
+          @hash = {}
+          allow(RecordSchema).to receive(:groups) { {default: default_group, details: details_group} }
+          allow(s).to receive(:record) { record }
+          allow(s).to receive(:field_value)
+        end
+
+        context 'handling groups' do
+          it 'should include fields from given group' do
+            expect(default_group).to receive(:fields)
+            expect(details_group).to_not receive(:fields)
+            s.serializable_hash
+          end
+
+          it 'should handle non-existent groups' do
+            allow(s).to receive(:options) { { groups: [:dogs] } }
+            expect(s.serializable_hash.size).to eq 0
+          end
+
+          it 'should remove non-existent groups (or field names)' do
+            allow(s).to receive(:options) { { groups: [:default, :description] } }
+            allow(s).to receive(:field_value).with(:name, anything()) { 'John Doe' }
+            expect(s.serializable_hash[:name]).to eq 'John Doe'
+          end
+
+          it 'should include fields from multiple groups' do
+            allow(s).to receive(:options) { { groups: [:default, :details] } }
+            [:name, :email, :age].each do |field|
+              expect(s.serializable_hash.keys).to include field
+            end
+          end
+        end
+
+        it 'should remove restricted fields' do
+          expect(s).to receive(:remove_restricted_fields!)
+          s.serializable_hash
+        end
+
+        context 'field/group doesn\'t exist' do
+          it 'returns an empty record hash' do
+            allow(s).to receive(:options) { { groups: [:dogs] } }
+            expect(s.serializable_hash).to be_empty
+          end
+        end
+      end
+    end
+
+    describe '#field_restricted?' do
+    	let(:s) { serializer({groups: [:default]}) }
+
+  		it 'returns true if the field is restricted' do
+  			allow(s).to receive(:field_value) { 'Wellington' }
+  			expect(s.send(:field_restricted?, 'address', "Wellington")).to be_truthy
+  		end
+
+  		it 'returns false if the field is not restricted' do
+  			allow(s).to receive(:field_value) { 'Auckland' }
+  			expect(s.send(:field_restricted?, 'address', "Wellington")).to be_falsey
+  		end
+
+  		it 'handles multi-value fields' do
+  			allow(s).to receive(:field_value) { ['jdoe@test.com', 'johndoe@example.com'] }
+  			expect(s.send(:field_restricted?, 'email', /test.com/)).to be_truthy
+  		end
+    end
+
+    describe "#format_date" do
+      let(:s) { serializer({groups: [:default]}) }
+
+      it "returns formated date for a date string" do
+        date_time = Time.now
+        expect(s.send(:format_date, date_time, "%y/%d/%m")).to eq (date_time.strftime("%y/%d/%m"))
+      end
+    end
+
+    describe "#field_value" do
+      let(:s) { serializer({groups: [:default]}) }
+      let(:record) { double(:record, name: 'John Doe', address: nil, email: ['johndoe@example.com', 'jdoe@test.com'], children: ['Sara', 'Bob']) }
+
+      before(:each) do
+        allow(s).to receive(:object) { record }
+      end
+
+      it "should return the single field value" do
+        expect(s.field_value(:name)).to eq 'John Doe'
+      end
+
+      it "should return the multipe field value" do
+        expect(s.field_value(:email)).to eq ['johndoe@example.com', 'jdoe@test.com']
+      end
+
+      it "return nil for nil value" do
+        expect(s.field_value(:address)).to be_nil
+      end
+
+      context 'search_value defined' do
+        context 'field not stored in mongo' do
+          it 'uses the value of the search_value block' do
+            allow(RecordSchema).to receive(:fields) { { age: double(:field, store: false, search_value: Proc.new{ 21 }) } }
+            expect(s.field_value(:age)).to eq 21
+          end
+        end
+
+        context 'field stored in mongo' do
+          it "uses the value from mongo" do
+            allow(RecordSchema).to receive(:fields) { {children: double(:field, search_value: Proc.new{1}).as_null_object} }
+            expect(s.field_value(:children)).to eq ['Sara', 'Bob']
+          end
+        end
+      end
+    end
+  end
+
+end