praxis 2.0.pre.9 → 2.0.pre.10

data/spec/praxis/media_type_identifier_spec.rb

@@ -42,10 +42,11 @@ describe Praxis::MediaTypeIdentifier do
         expect(described_class.new(unquoted_example).parameters['encoding']).to eq('martian')
       end
 
-      it 'handles quoted semicolons in values' do
-        pending("need to stop using a regexp to do a context-free parser's job")
-        expect(described_class.new(tricky_example).parameters['sauce']).to eq('yes; absolutely')
-      end
+      # TODO: Maybe that's something we want to support in the future? seems a big hammer for such a thing
+      # it 'handles quoted semicolons in values' do
+      #   pending("need to stop using a regexp to do a context-free parser's job")
+      #   expect(described_class.new(tricky_example).parameters['sauce']).to eq('yes; absolutely')
+      # end
 
 
     end

data/spec/praxis/media_type_spec.rb

@@ -22,7 +22,6 @@ describe Praxis::MediaType do
 
   subject(:address) { Address.new(resource) }
 
-
   context 'attributes' do
     its(:id)    { should eq(1) }
     its(:name)  { should eq('Home') }
@@ -30,112 +29,24 @@ 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 }
 
     context '#identifier' do
-      context 'in praxis v1.0 and beyond' do
-        it 'should be a kind of Praxis::MediaTypeIdentifier' do
-          pending('interface-breaking change') if Praxis::VERSION =~ /^0/
-          expect(subject.identifier).to be_kind_of(Praxis::MediaTypeIdentifier)
-        end
+      it 'should be a kind of Praxis::MediaTypeIdentifier' do
+        expect(subject.identifier).to be_kind_of(Praxis::MediaTypeIdentifier)
       end
     end
 
     its(:description) { should be_kind_of(String) }
-
   end
 
   context "rendering" do
-    subject(:output) { address.render(view: :default) }
+    subject(:output) { address.render }
 
     its([:id])    { should eq(address.id) }
     its([:name])  { should eq(address.name) }
-    its([:owner]) { should eq(Person.dump(owner_resource, view: :default)) }
+    its([:owner]) { should eq(Person.dump(owner_resource)) }
     its([:fields]) { should eq(address.fields.dump ) }
-
-  end
-
-  context 'describing' do
-
-    subject(:described){ Address.describe }
-
-    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) }
-    its([:family]) { should be_kind_of(::String) }
-    its([:id]) { should be_kind_of(::String) }
-    its([:name]) { should be_kind_of(::String) }
-    its([:identifier]) { should be_kind_of(::String) }
-    its([:key]) { should be_kind_of(::Hash) }
-    its([:views]) { should be_kind_of(::Hash) }
-
-    its([:description]) { should eq(Address.description) }
-    its([:display_name]) { should eq(Address.display_name) }
-    its([:family]) { should eq(Address.family) }
-    its([:id]) { should eq(Address.id) }
-    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_array([:default, :master])
-    end
-    it 'should include the defined attributes' do
-      expect( subject[:attributes].keys ).to match_array([:id, :name, :owner, :custodian, :residents, :residents_summary, :fields])
-    end
-  end
-
-  context 'using blueprint caching' 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) }
-
-    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/renderer_spec.rb

@@ -0,0 +1,188 @@
+# frozen_string_literal: true
+require_relative '../spec_helper'
+
+describe Praxis::Renderer do
+  let(:address) { AddressBlueprint.example }
+  let(:prior_addresses) { Array.new(2) { AddressBlueprint.example } }
+  let(:alias_one) { FullName.example }
+  let(:alias_two) { FullName.example }
+  let(:aliases) { [alias_one, alias_two] }
+  let(:metadata_hash) { { something: 'here' } }
+  let(:metadata) { Attributor::Hash.load(metadata_hash) }
+
+  let(:person) do
+    PersonBlueprint.example(
+      address: address,
+      email: nil,
+      prior_addresses: prior_addresses,
+      alive: false,
+      work_address: nil,
+      aliases: aliases,
+      metadata: metadata
+    )
+  end
+
+  let(:fields) do
+    {
+      name: true,
+      email: true,
+      full_name: { first: true, last: true },
+      address: {
+        state: true,
+        street: true,
+        resident:  { name: true }
+      },
+      prior_addresses: { name: true },
+      work_address: true,
+      alive: true,
+      metadata: true,
+      aliases: true
+    }
+  end
+
+  let(:renderer) { Praxis::Renderer.new }
+
+  subject(:output) { renderer.render(person, fields) }
+
+  it 'renders existing attributes' do
+    expect(output.keys).to match_array([:name, :full_name, :alive, :address, :prior_addresses, :metadata, :aliases])
+
+    expect(output[:name]).to eq person.name
+    expect(output[:full_name]).to eq(first: person.full_name.first, last: person.full_name.last)
+    expect(output[:alive]).to be false
+
+    expect(output[:address]).to eq(state: person.address.state,
+                               street: person.address.street,
+                               resident: { name: person.address.resident.name })
+
+    expected_prior_addresses = prior_addresses.collect { |addr| { name: addr.name } }
+    expect(output[:prior_addresses]).to match_array(expected_prior_addresses)
+
+    expect(output[:aliases]).to match_array(aliases.collect(&:dump))
+    expect(output[:metadata]).to eq(metadata.dump)
+  end
+
+  context 'calls dump for non-Blueprint, but still Dumpable instances' do
+    it 'when rendering them in full as array members' do
+      expect(alias_one).to receive(:dump).and_call_original
+      expect(output[:aliases].first).to eq(first: alias_one.first, last: alias_one.last)
+    end
+    it 'when rendering them in full as leaf object' do
+      expect(metadata).to receive(:dump).and_call_original
+      expect(output[:metadata]).to eq(metadata_hash)
+    end
+  end
+
+  it 'does not render attributes with nil values' do
+    expect(output).to_not have_key(:email)
+  end
+
+  context 'with include_nil: true' do
+    let(:renderer) { Praxis::Renderer.new(include_nil: true) }
+    let(:address) { nil }
+
+    it 'renders attributes with nil values' do
+      expect(output).to have_key :email
+      expect(output[:email]).to be_nil
+
+      expect(output).to have_key :work_address
+      expect(output[:work_address]).to be_nil
+    end
+
+    it 'renders nil directly for nil subobjects' do
+      expect(output).to have_key :address
+      expect(output[:address]).to be_nil
+    end
+  end
+
+  context 'rendering a two-dimmensional collection' do
+    let(:names) { Array.new(9) { |i| AddressBlueprint.example(i.to_s, name: i.to_s) } }
+    let(:matrix_type) do
+      Attributor::Collection.of(Attributor::Collection.of(AddressBlueprint))
+    end
+
+    let(:matrix) { matrix_type.load(names.each_slice(3).collect { |slice| slice }) }
+
+    let(:fields) { { name: true } }
+
+    it 'renders with render_collection and per-element field spec' do
+      rendered = renderer.render(matrix, fields)
+      expect(rendered.flatten.collect { |r| r[:name] }).to eq((0..8).collect(&:to_s))
+    end
+
+    it 'renders with render and proper field spec' do
+      rendered = renderer.render(matrix, fields)
+      expect(rendered.flatten.collect { |r| r[:name] }).to eq((0..8).collect(&:to_s))
+    end
+  end
+
+  context 'rendering stuff that breaks badly' do
+    it 'does not break badly' do
+      expect{renderer.render(person, {tags: true})}.to_not raise_error
+    end
+  end
+
+  context 'caching rendered objects' do
+    let(:fields) { {full_name: true} }
+    it 'caches and returns identical results for the same field objects' do
+      expect(person).to receive(:full_name).once.and_call_original
+
+      render_1 = renderer.render(person, fields)
+      render_2 = renderer.render(person, fields)
+      expect(render_1).to be(render_2)
+    end
+  end
+
+  context 'rendering hashes' do
+    let(:fields) do
+      {
+        id: true,
+        hash: true
+      }
+    end
+
+    let(:data) { { id: 10, hash: { foo: 'bar' } } }
+    let(:object) { SimpleHash.load(data) }
+    let(:renderer) { Praxis::Renderer.new }
+
+    subject(:output) { renderer.render(object, fields) }
+
+    its([:id]) { should eq data[:id] }
+    its([:hash]) { should eq data[:hash] }
+    its([:hash]) { should be_kind_of(Hash) }
+  end
+
+  context 'rendering collections of hashes' do
+    let(:fields) do
+      {
+        id: true,
+        hash_collection: true
+      }
+    end
+
+    let(:data) { { id: 10, hash_collection: [{ foo: 'bar' }] } }
+    let(:object) { SimpleHashCollection.load(data) }
+    let(:renderer) { Praxis::Renderer.new }
+
+    subject(:output) { renderer.render(object, fields) }
+
+    its([:id]) { should eq data[:id] }
+    its([:hash_collection]) { should eq data[:hash_collection] }
+    its([:hash_collection]) { should be_kind_of(Array) }
+
+    it 'renders the hashes' do
+      expect(output[:hash_collection].first).to be_kind_of(Hash)
+    end
+  end
+
+  context 'rendering a Blueprint with fields true' do
+    let(:fields) do
+      {
+        name: true,
+        address: true
+      }
+    end
+
+    its([:address]) { should eq person.address.dump }
+  end
+end

data/spec/praxis/response_definition_spec.rb

@@ -443,37 +443,6 @@ describe Praxis::ResponseDefinition do
           end
         end
       end
-
-      describe '#validate_parts!' do
-        context 'with legacy multipart response' do
-          subject(:response) { Praxis::Responses::Ok.new(status: response_status, headers: response_headers) }
-
-          let(:part) { Praxis::MultipartPart.new('done', {'Status' => 200, 'Content-Type' => 'application/special'},**{}) }
-
-          before do
-            response_definition.parts like: :ok, media_type: 'application/special'
-            response.add_part(part)
-          end
-
-          it 'validates each part' do
-            response_definition.parts
-            expect {
-              response_definition.validate_parts!(response)
-            }.to_not raise_error
-          end
-
-          context 'with invalid part' do
-            let(:part) { Praxis::MultipartPart.new('done', {'Status' => 200, "Location" => "somewhere"}) }
-
-            it 'validates' do
-              expect {
-                response_definition.validate_parts!(response)
-              }.to raise_error(Praxis::Exceptions::Validation)
-            end
-
-          end
-        end
-      end
     end
 
   end

data/spec/praxis/response_spec.rb

@@ -29,7 +29,7 @@ describe Praxis::Response do
   let(:action) do
     instance_double(
       Praxis::ActionDefinition,
-      :resource_definition => config_class
+      :endpoint_definition => config_class
     )
   end
 

data/spec/praxis/router_spec.rb

@@ -2,8 +2,8 @@ require 'spec_helper'
 
 describe Praxis::Router do
   describe Praxis::Router::VersionMatcher do
-    let(:resource_definition){ double("resource_definition", version_options: { using: [:header, :params] }) }
-    let(:action){ double("action", resource_definition: resource_definition ) }
+    let(:endpoint_definition){ double("endpoint_definition", version_options: { using: [:header, :params] }) }
+    let(:action){ double("action", endpoint_definition: endpoint_definition ) }
     let(:target){ double("target", action: action ) }
     let(:args){ {version: "1.0"} }
     subject(:matcher){ Praxis::Router::VersionMatcher.new(target,**args) }
@@ -80,8 +80,8 @@ describe Praxis::Router do
     let(:target){ double('target') }
     let(:verb_router){ double('verb_router') }
 
-    let(:resource_definition) { double('resource_definition', version_options: {using: [:header, :params]} ) }
-    let(:action) { double('action', resource_definition: resource_definition) }
+    let(:endpoint_definition) { double('endpoint_definition', version_options: {using: [:header, :params]} ) }
+    let(:action) { double('action', endpoint_definition: endpoint_definition) }
     let(:target) { double('target', action: action) }
 
 
@@ -111,8 +111,8 @@ describe Praxis::Router do
     let(:post_target_router){ double("POST target", call: router_response_for_post) }
     let(:any_target_router){ double("ANY target", call: router_response_for_wildcard) }
 
-    let(:resource_definition) { double('resource_definition', version_options: {using: [:header, :params]} ) }
-    let(:action) { double('action', resource_definition: resource_definition) }
+    let(:endpoint_definition) { double('endpoint_definition', version_options: {using: [:header, :params]} ) }
+    let(:action) { double('action', endpoint_definition: endpoint_definition) }
     let(:target) { double('target', action: action) }
 
     before do
@@ -142,8 +142,8 @@ describe Praxis::Router do
     end
 
     context 'for routes with wildcards (a POST and a * route)' do
-      let(:resource_definition) { double('resource_definition', version_options: {using: [:header, :params]} ) }
-      let(:action) { double('action', resource_definition: resource_definition) }
+      let(:endpoint_definition) { double('endpoint_definition', version_options: {using: [:header, :params]} ) }
+      let(:action) { double('action', endpoint_definition: endpoint_definition) }
       let(:target) { double('target', action: action) }
 
       before do

data/spec/praxis/routing_config_spec.rb

@@ -2,16 +2,16 @@ require 'spec_helper'
 
 describe Praxis::RoutingConfig do
 
-  let(:resource_definition) do
+  let(:endpoint_definition) do
     Class.new do
-      include Praxis::ResourceDefinition
+      include Praxis::EndpointDefinition
       def self.name; 'MyResource'; end
     end
   end
 
   let(:routing_block) { Proc.new{} }
   let(:base_path){ '' }
-  let(:default_route_prefix) { "/" + resource_definition.name.split("::").last.underscore }
+  let(:default_route_prefix) { "/" + endpoint_definition.name.split("::").last.underscore }
 
   subject(:routing_config){ Praxis::RoutingConfig.new(base: base_path, &routing_block) }
 

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

@@ -68,7 +68,7 @@ class Instances < BaseClass
 
       part_body = {
         key: instance_id,
-        value: instance.render(view: :create)
+        value: instance.render(fields: {id: true, name: true})
       }
 
       headers = {
@@ -78,7 +78,6 @@ class Instances < BaseClass
       }
 
       part = Praxis::MultipartPart.new(part_body, headers, name: instance_id)
-
       response.body.push(part)
     end
 
@@ -89,13 +88,20 @@ class Instances < BaseClass
   def attach_file(id:, cloud_id:)
     response.headers['Content-Type'] = 'application/json'
 
-    destination_path = request.payload['destination_path']
-    file = request.payload['file']
-
+    destination_path = request.payload.part('destination_path').payload
+    file = request.payload.part('file')
+    file.payload.rewind # Ensure contents is at the beggining.
+    extra_part_names = request.payload.map(&:name) - ['destination_path', 'file']
+    extra_parts = extra_part_names.each_with_object({}) do |pname, hash|
+      hash[pname] = request.payload.part(pname).body
+    end
     result = {
       destination_path: destination_path,
-      file: file.dump,
-      options: request.payload['options'].dump
+      name: file.name,
+      filename: file.filename,
+      type: file.content_type.to_s,
+      contents: file.payload.read,
+      options: extra_parts
     }
 
     response.body = JSON.pretty_generate(result)