praxis 0.18.1 → 0.19.0

data/spec/praxis/extensions/field_selection/field_selector_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+require 'praxis/extensions/field_selection'
+
+describe Praxis::Extensions::FieldSelection::FieldSelector do
+
+  let(:type) { described_class.for(Address) }
+
+
+  subject(:field_selector) { type.load(fields) }
+
+  context '.example' do
+    subject(:example) { type.example }
+
+    it 'generates a list of 3 random attribute names' do
+      example_attributes = example.fields.keys
+      expect(example_attributes).to have(3).items
+      expect(example_attributes - Address.attributes.keys).to be_empty
+    end
+
+    it 'validates' do
+      expect(type.example.validate).to be_empty
+    end
+
+  end
+
+  context '.load' do
+    let(:parsed_fields) { double('fields') }
+
+    it 'loads nil and an empty string as true' do
+      expect(type.load(nil).fields).to be(true)
+      expect(type.load('').fields).to be(true)
+    end
+
+
+    it 'loads fields' do
+      fields = 'id,name,owner{name}'
+
+      expect(Attributor::FieldSelector).to receive(:load).
+        with(fields).and_return(parsed_fields)
+
+      result = type.load(fields)
+      expect(result.fields).to be parsed_fields
+    end
+
+  end
+
+  context '#dump' do
+    it 'dumps nested fields properly' do
+      fields = 'id,name,owner{name}'
+      result = type.load(fields)
+      expect(result.dump).to eq fields
+    end
+
+    it 'dumps a nil or "" value as ""' do
+      expect(type.load(nil).dump).to eq ''
+      expect(type.load('').dump).to eq ''
+    end
+  end
+  context '.validate' do
+    let(:selector_string) { 'id,name' }
+    it 'loads and calls the instance' do
+      example = double('example')
+      expect(type).to receive(:load).with(selector_string, ['$']).and_return(example)
+      expect(example).to receive(:validate).and_return([])
+      type.validate(selector_string)
+    end
+    context 'validating subattributes' do
+      let(:selector_string) { 'id,resident,owner{age}' }
+      it 'validates subattributes' do
+        errors =  type.validate(selector_string)
+        expect(errors).to match_array([
+          "Attribute with name resident not found in Address",
+          "Attribute with name age not found in Person"
+        ])
+      end
+    end
+
+  end
+
+  context '#validate' do
+    it do
+      expect(type.validate('id,name')).to be_empty
+      expect(type.validate('id,state')).to have(1).items
+      expect(type.validate('id,owner{name}')).to have(0).items
+      expect(type.validate('id,owner{foo}')).to have(1).items
+    end
+  end
+
+
+
+end

data/spec/praxis/extensions/rendering_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+describe Praxis::Extensions::Rendering do
+
+  let(:test_class) do
+    Struct.new(:media_type, :expanded_fields, :response, :request) do |klass|
+      include Praxis::Extensions::Rendering
+    end
+  end
+
+  let(:media_type) { Person }
+  let(:expanded_fields) { {id: true, name: true} }
+  let(:response) { double('response', headers: {}) }
+  let(:request) { double('request') }
+
+  let(:object) { {id: '1', name: 'bob', href: '/people/bob'} }
+  subject(:instance) { test_class.new(media_type, expanded_fields, response, request) }
+
+  context '#render' do
+    subject(:output) { instance.render(object) }
+    it 'loads and renders the object' do
+      expect(output).to eq(id: 1, name: 'bob')
+    end
+  end
+
+  context '#display' do
+    context 'without exception' do
+      before do
+        expect(response).to receive(:body=).with({id: 1, name: 'bob'})
+      end
+
+      subject!(:output) { instance.display(object) }
+
+      it 'returns the response' do
+        expect(output).to be(response)
+      end
+
+      it 'sets the Content-Type header' do
+        expect(response.headers['Content-Type']).to eq 'application/vnd.acme.person'
+      end
+    end
+
+    context 'with a rendering exception' do
+      let(:handler_params) do
+        {
+          summary: "Circular Rendering Error when rendering response. " +
+                 "Please especify a view to narrow the dependent fields, or narrow your field set.",
+          exception: circular_exception,
+          request: request,
+          stage: :action,
+          errors: nil
+        }
+      end
+      let(:circular_exception){ Praxis::Renderer::CircularRenderingError.new(object, "ctx") }
+      it 'catches a circular rendering exception' do
+        expect(instance).to receive(:render).and_raise(circular_exception)
+        expect(Praxis::Application.instance.validation_handler).to receive(:handle!).with(handler_params)
+        instance.display(object)
+      end
+    end
+  end
+
+end

data/spec/praxis/links_spec.rb

@@ -19,6 +19,11 @@ describe Praxis::Links do
     expect(link.for(Address)).to eq(link)
   end
 
+  it 'are marked as anonymous' do
+    described = link.for(Address).describe
+    expect(described[:anonymous]).to be(true)
+  end
+
   context 'contents' do
     subject(:view) { link.view(:default) }
 
@@ -34,6 +39,7 @@ describe Praxis::Links do
       subject(:rendered_links){ example.render(view: :default)[:links] }
 
       it 'should use the :link for rendering its attributes' do
+        example.render(view: :default)[:links]
         expect(rendered_links[:owner]).to eq( example.owner.render(view: :link))
       end
     end

data/spec/praxis/media_type_collection_spec.rb

@@ -100,7 +100,6 @@ describe Praxis::MediaTypeCollection do
       it { should eq(snapshots.collect(&:render)) }
     end
 
-
   end
 
   context '#validate' do

data/spec/praxis/media_type_identifier_spec.rb

@@ -3,9 +3,23 @@ require "spec_helper"
 describe Praxis::MediaTypeIdentifier do
   let(:example) { 'application/ice-cream+sundae; nuts="true"; fudge="true"' }
 
-  subject { described_class.new(example) }
+  subject { described_class.load(example) }
 
   context '.load' do
+    context 'of nil values' do
+      let(:example) { nil }
+      it 'return nil' do
+        expect(subject).to be(nil)
+      end
+    end
+
+    context 'of empty string values' do
+      let(:example) { "" }
+      it 'returns nil' do
+        expect(subject).to be(nil)
+      end
+    end
+
     it 'parses type/subtype' do
       expect(subject.type).to eq('application')
       expect(subject.subtype).to eq('ice-cream')

data/spec/praxis/media_type_spec.rb

@@ -38,6 +38,14 @@ describe Praxis::MediaType do
   end
 
 
+  context 'loading' do
+    it do
+      Person.load({id: 1})
+      Person.load(owner_resource)
+
+    end
+  end
+
 
   context 'accessor methods' do
     subject(:address_klass) { address.class }
@@ -144,7 +152,7 @@ describe Praxis::MediaType do
 
     subject(:described){ Address.describe }
 
-    its(:keys) { should match_array( [:attributes, :description, :display_name, :family, :id, :identifier, :key, :name, :views] ) }
+    its(:keys) { should match_array( [:attributes, :description, :display_name, :family, :id, :identifier, :key, :name, :views, :requirements] ) }
     its([:attributes]) { should be_kind_of(::Hash) }
     its([:description]) { should be_kind_of(::String) }
     its([:display_name]) { should be_kind_of(::String) }
@@ -162,10 +170,10 @@ describe Praxis::MediaType do
     its([:name]) { should eq(Address.name) }
     its([:identifier]) { should eq(Address.identifier.to_s) }
     it 'should include the defined views' do
-      expect( subject[:views].keys ).to match( [:default, :master] )
+      expect( subject[:views].keys ).to match_array([:default, :master, :link])
     end
     it 'should include the defined attributes' do
-      expect( subject[:attributes].keys ).to match( [:id, :name, :owner, :custodian, :residents, :residents_summary, :links] )
+      expect( subject[:attributes].keys ).to match_array([:id, :name, :owner, :custodian, :residents, :residents_summary, :links])
     end
   end
 
@@ -173,4 +181,94 @@ describe Praxis::MediaType do
     it 'has specs'
   end
 
+  context Praxis::MediaType::FieldResolver do
+    let(:expander) { Praxis::FieldExpander }
+    let(:user_view) { User.views[:default] }
+
+    let(:fields) { expander.expand(user_view) }
+
+    let(:field_resolver) { Praxis::MediaType::FieldResolver }
+
+    subject(:output) { field_resolver.resolve(User,fields) }
+
+
+    it 'merges link stuff in properly' do
+      expect(output).to_not have_key(:links)
+      expect(output).to have_key(:primary_blog)
+
+      expect(output[:primary_blog]).to eq({href: true})
+    end
+
+    it 'resolves link aliases (from link ... using:)' do
+      expect(output).to have_key(:posts_summary)
+      expect(output[:posts_summary]).to eq({href: true})
+    end
+
+    context 'merging top-level attributes with those from links' do
+      let(:user_view) { User.views[:extended] }
+
+      subject(:primary_blog_output) { output[:primary_blog] }
+      it 'merges them' do
+        expected = {
+          href: true,
+          id: true,
+          name: true,
+          description: true
+        }
+        expect(primary_blog_output).to eq(expected)
+      end
+    end
+
+    context 'deep-merging fields' do
+      let(:fields) do
+        {
+          primary_blog: {
+            owner: { first: true, last: true }
+          },
+          links: {
+            primary_blog: {
+              owner: { href: true }
+            }
+          }
+        }
+      end
+
+      it 'does a deep-merge for sub-attributes' do
+        expected = {
+          owner: {first: true, last: true, href: true}
+        }
+        expect(output[:primary_blog]).to eq(expected)
+      end
+    end
+
+    context 'resolving collections' do
+      let(:fields) { {:id=>true, :posts=>[{:href=>true}]}}
+      it 'strips arrays from the incoming fields' do
+        expect(output).to eq(id: true, posts: {href: true})
+      end
+
+      it 'supports multi-dimensional collections' do
+        fields = {
+          id: true,
+          post_matrix:[[{title: true, href: true}]]
+        }
+        output = field_resolver.resolve(User,fields)
+        expect(output).to eq(id: true, post_matrix:{href: true, title: true})
+      end
+
+      it 'supports nesting structs and arrays collections' do
+        fields = {
+         id: true,
+         daily_posts: [
+           {day: true, posts: [{id: true}]}
+         ]
+        }
+        output = field_resolver.resolve(User,fields)
+        expect(output).to eq(id: true, daily_posts:{day: true, posts: {id:true}})
+      end
+    end
+
+  end
+
+
 end

data/spec/praxis/plugins/praxis_mapper_plugin_spec.rb

@@ -8,7 +8,7 @@ describe Praxis::Plugins::PraxisMapperPlugin do
   context 'Plugin' do
     context 'configuration' do
       subject { config }
-      its(:log_stats) { should eq 'skip' }
+      its(:log_stats) { should eq 'detailed' }
       its(:stats_log_level) { should eq :info }
       its(:repositories) { should have_key("default") }
 
@@ -24,11 +24,11 @@ describe Praxis::Plugins::PraxisMapperPlugin do
   end
 
   context 'Request' do
-    
+
     it 'should have identity_map accessors' do
       expect(Praxis::Plugins::PraxisMapperPlugin::Request.instance_methods).to include(:identity_map,:identity_map=)
     end
-    
+
     it 'should have silence_mapper_stats accessors' do
       expect(Praxis::Plugins::PraxisMapperPlugin::Request.instance_methods)
             .to include(:silence_mapper_stats,:silence_mapper_stats=)
@@ -45,20 +45,29 @@ describe Praxis::Plugins::PraxisMapperPlugin do
     around(:each) do |example|
       orig_level = Praxis::Application.instance.logger.level
       Praxis::Application.instance.logger.level = 2
-      config.log_stats = 'detailed'; plugin.setup!
       example.run
-      config.log_stats = 'skip'; plugin.setup!
       Praxis::Application.instance.logger.level = orig_level
     end
 
-    it 'logs stats' do
-      expect(Praxis::Plugins::PraxisMapperPlugin::Statistics).to receive(:log).
-        with(kind_of(Praxis::Request),kind_of(Praxis::Mapper::IdentityMap), 'detailed').
-        and_call_original
-      the_body = StringIO.new("{}") # This is a funny, GET request expecting a body
-      get '/api/clouds/1/instances/2?junk=foo&api_version=1.0', nil, 'rack.input' => the_body,'CONTENT_TYPE' => "application/json", 'global_session' => session
+    context 'with no identity_map set in the request' do
+      it 'does not log stats' do
+        expect(Praxis::Plugins::PraxisMapperPlugin::Statistics).to_not receive(:log)
+        the_body = StringIO.new("{}") # This is a funny, GET request expecting a body
+        get '/api/clouds/1/instances/2?api_version=1.0', nil, 'rack.input' => the_body,'CONTENT_TYPE' => "application/json", 'global_session' => session
 
-      expect(last_response.status).to eq(200)
+        expect(last_response.status).to eq(200)
+      end
+    end
+    context 'with an identity_map set in the request' do
+      it 'logs stats' do
+        expect(Praxis::Plugins::PraxisMapperPlugin::Statistics).to receive(:log).
+          with(kind_of(Praxis::Request),kind_of(Praxis::Mapper::IdentityMap), 'detailed').
+          and_call_original
+        the_body = StringIO.new("{}") # This is a funny, GET request expecting a body
+        get '/api/clouds/1/instances/2?create_identity_map=true&api_version=1.0', nil, 'rack.input' => the_body,'CONTENT_TYPE' => "application/json", 'global_session' => session
+
+        expect(last_response.status).to eq(200)
+      end
     end
 
   end
@@ -77,39 +86,39 @@ describe Praxis::Plugins::PraxisMapperPlugin do
       context 'when the request silences mapper stats' do
         let(:request){ double('request', silence_mapper_stats: true ) }
         it 'should not log anything' do
-          expect(Praxis::Plugins::PraxisMapperPlugin::Statistics).to_not receive(:to_logger) 
+          expect(Praxis::Plugins::PraxisMapperPlugin::Statistics).to_not receive(:to_logger)
         end
       end
-      
+
       context 'without the request silencing mapper stats' do
         context 'when log_stats = detailed' do
           it 'should call the detailed method' do
-             expect(Praxis::Plugins::PraxisMapperPlugin::Statistics).to receive(:detailed).with(identity_map) 
+             expect(Praxis::Plugins::PraxisMapperPlugin::Statistics).to receive(:detailed).with(identity_map)
            end
         end
-      
+
         context 'when log_stats = short' do
           let(:log_stats){ 'short' }
           it 'should call the short method' do
-             expect(Praxis::Plugins::PraxisMapperPlugin::Statistics).to receive(:short).with(identity_map) 
+             expect(Praxis::Plugins::PraxisMapperPlugin::Statistics).to receive(:short).with(identity_map)
            end
         end
-      
+
         context 'when log_stats = skip' do
           let(:log_stats){ 'skip' }
-          
+
           it 'should not log anything' do
-            expect(Praxis::Plugins::PraxisMapperPlugin::Statistics).to_not receive(:to_logger) 
+            expect(Praxis::Plugins::PraxisMapperPlugin::Statistics).to_not receive(:to_logger)
           end
         end
-      
+
         context 'when there is no identity map' do
           let(:identity_map) { nil }
           it 'should not log anything' do
             expect(Praxis::Plugins::PraxisMapperPlugin::Statistics).to_not receive(:to_logger)
-          end        
+          end
         end
-      
+
         context 'when no queries are logged in the identity map' do
           let(:queries){ {} }
           it 'should log a special message' do
@@ -117,7 +126,7 @@ describe Praxis::Plugins::PraxisMapperPlugin do
                                                                    .with("No database interactions observed.")
           end
         end
-        
+
       end
     end
 

data/spec/praxis/request_stages/request_stage_spec.rb

@@ -10,7 +10,7 @@ describe Praxis::RequestStages::RequestStage do
 
   let(:stage_class) { Class.new(Praxis::RequestStages::RequestStage) }
 
-  let(:request) { instance_double("Praxis::Request") }
+  let(:request) { Praxis::Request.new({}) }
   let(:controller){ controller_class.new(request) }
 
 

data/spec/praxis/types/multipart_array_spec.rb

@@ -19,6 +19,8 @@ describe Praxis::Types::MultipartArray do
         payload Attributor::Tempfile
       end
 
+      file 'thumbnail', Attributor::Tempfile
+
       part 'image', Attributor::Tempfile, filename: true
 
     end
@@ -50,6 +52,9 @@ describe Praxis::Types::MultipartArray do
     entity = MIME::Application.new('{"first_name": "Frank"}', 'json')
     form_data.add entity,'stuff2'
 
+    entity = MIME::Application.new('SOMEBINARYDATA', 'jpg')
+    form_data.add entity,'thumbnail', 'thumb.jpg'
+
     entity = MIME::Application.new('', 'jpg')
     form_data.add entity,'image', 'image.jpg'
 
@@ -82,6 +87,10 @@ describe Praxis::Types::MultipartArray do
     stuff2 = payload.part('stuff2')
     expect(stuff2.payload['first_name']).to eq 'Frank'
 
+    thumb = payload.part('thumbnail')
+    thumb.payload.rewind
+    expect(thumb.payload.read).to eq 'SOMEBINARYDATA'
+
     image = payload.part('image')
     expect(image.filename).to eq 'image.jpg'
   end
@@ -144,7 +153,7 @@ describe Praxis::Types::MultipartArray do
 
     context 'attributes' do
       subject(:attributes) { description[:attributes] }
-      its(:keys) { should match_array ['title', 'files', 'image']}
+      its(:keys) { should match_array ['title', 'files', 'thumbnail', 'image']}
 
       context 'the "title" part' do
         subject(:title_description) { attributes['title'] }
@@ -176,6 +185,7 @@ describe Praxis::Types::MultipartArray do
         end
 
       end
+
     end
 
     context 'pattern attributes' do
@@ -266,7 +276,7 @@ describe Praxis::Types::MultipartArray do
 
       let(:default_format) { 'xml' }
 
-      let(:output) { example.dump(default_format: default_format) } 
+      let(:output) { example.dump(default_format: default_format) }
 
       let(:parts) { Praxis::MultipartParser.parse({'Content-Type'=>example.content_type}, output).last }
 
@@ -288,8 +298,8 @@ describe Praxis::Types::MultipartArray do
         stuff = parts.find { |part| part.name == 'stuff' }
         expect(stuff.content_type.to_s).to eq 'application/json'
         expect(stuff.payload).to eq json_handler.generate(example.part('stuff').payload.dump)
-        
-        # instances just specify 'application/vnd.acme.instance', and should 
+
+        # instances just specify 'application/vnd.acme.instance', and should
         # have xml suffix appended
         instances = parts.select { |part| part.name == 'instances' }
         instances.each_with_index do |instance, i|

data/spec/spec_app/app/controllers/instances.rb

@@ -46,8 +46,13 @@ class Instances < BaseClass
     response
   end
 
-  def show(cloud_id:, id:, junk:, **other_params)
+  def show(cloud_id:, id:, junk:, create_identity_map:, **other_params)
+    if create_identity_map
+      request.identity_map
+    end
+
     payload = request.payload
+
     response.body = {cloud_id: cloud_id, id: id, junk: junk, other_params: other_params, payload: payload && payload.dump}
     response.headers['Content-Type'] = 'application/json'
     response

data/spec/spec_app/config/environment.rb

@@ -23,7 +23,8 @@ Praxis::Application.configure do |application|
 
   application.bootloader.use Praxis::Plugins::PraxisMapperPlugin, {
     config_data: {
-      repositories: { default: {adapter: 'sqlite', database: ':memory:'} }
+      repositories: { default: {adapter: 'sqlite', database: ':memory:'} },
+      log_stats: 'detailed'
     }
   }
 

data/spec/spec_app/design/resources/instances.rb

@@ -55,6 +55,7 @@ module ApiResources
         attribute :junk, String, default: ''
         attribute :some_date, DateTime, default: DateTime.parse('2012-12-21')
         attribute :fail_filter, Attributor::Boolean, default: false
+        attribute :create_identity_map, Attributor::Boolean, default: false
       end
 
       payload required: false do

data/spec/spec_helper.rb

@@ -1,10 +1,12 @@
+require 'coveralls'
+Coveralls.wear!
+
 $:.unshift File.expand_path(__dir__)
 $:.unshift File.expand_path('../lib',__dir__)
 $:.unshift File.expand_path('support',__dir__)
 
 require 'bundler'
 Bundler.setup :default, :test
-
 require 'simplecov'
 SimpleCov.start 'praxis'