praxis 2.0.pre.1 → 2.0.pre.6

data/spec/praxis/media_type_spec.rb

@@ -1,9 +1,9 @@
 require 'spec_helper'
 
 describe Praxis::MediaType do
-  let(:owner_resource) { instance_double(Person, id: 100, name: /[:name:]/.gen, href: '/', links: ['one','two']) }
-  let(:manager_resource) { instance_double(Person, id: 101, name: /[:name:]/.gen, href: '/', links: []) }
-  let(:custodian_resource) { instance_double(Person, id: 102, name: /[:name:]/.gen, href: '/', links: []) }
+  let(:owner_resource) { instance_double(Person, id: 100, name: /[:name:]/.gen, href: '/') }
+  let(:manager_resource) { instance_double(Person, id: 101, name: /[:name:]/.gen, href: '/') }
+  let(:custodian_resource) { instance_double(Person, id: 102, name: /[:name:]/.gen, href: '/') }
   let(:residents_summary_resource) do
     instance_double(Person::CollectionSummary, href: "/people", size: 2)
   end
@@ -27,15 +27,6 @@ describe Praxis::MediaType do
     its(:id)    { should eq(1) }
     its(:name)  { should eq('Home') }
     its(:owner) { should be_instance_of(Person) }
-
-    context 'links' do
-      it 'respects using' do
-        expect(address.links.super).to be_kind_of(Person)
-        expect(address.links.super.object).to be(resource.manager)
-        expect(address.links.caretaker.object).to be(resource.custodian)
-      end
-
-    end
   end
 
 
@@ -52,16 +43,6 @@ describe Praxis::MediaType do
     subject(:address_klass) { address.class }
 
     context '#identifier' do
-      context 'in praxis v0' do
-        it 'should be a kind of String' do
-          if Praxis::VERSION =~ /^0/
-            expect(subject.identifier).to be_kind_of(String)
-          else
-            raise 'Please remove this spec which is no longer pertinent'
-          end
-        end
-      end
-
       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/
@@ -72,36 +53,6 @@ describe Praxis::MediaType do
 
     its(:description) { should be_kind_of(String) }
 
-    context 'links' do
-      context 'with a custom links attribute' do
-        subject(:person) { Person.new(owner_resource) }
-
-        its(:links)  { should be_kind_of(Array) }
-        its(:links)  { should eq(owner_resource.links) }
-      end
-
-      context 'using the links DSL' do
-        subject(:address) { Address.new(resource) }
-        its(:links)  { should be_kind_of(Address::Links) }
-
-        it 'inherits types appropriately' do
-          links_attribute = Address::Links.attributes
-          expect(links_attribute[:owner].type).to be(Person)
-          expect(links_attribute[:super].type).to be(Person)
-          expect(links_attribute[:caretaker].type).to be(Person)
-        end
-
-        context 'loading returned values' do
-          subject(:residents) { address.links.residents }
-          let(:residents_summary_resource) do
-            {href: "/people", size: 2}
-          end
-
-          its(:href) { should eq('/people') }
-          its(:size) { should eq(2) }
-        end
-      end
-    end
   end
 
   context "rendering" do
@@ -112,43 +63,8 @@ describe Praxis::MediaType do
     its([:owner]) { should eq(Person.dump(owner_resource, view: :default)) }
     its([:fields]) { should eq(address.fields.dump ) }
 
-    context 'links' do
-      subject(:links) { output[:links] }
-
-      its([:owner]) { should eq(Person.dump(owner_resource, view: :link)) }
-      its([:super]) { should eq(Person.dump(manager_resource, view: :link)) }
-
-      context 'for a collection summary' do
-        let(:volume) { Volume.example }
-        let(:snapshots_summary) { volume.snapshots_summary }
-        let(:output) { volume.render(view: :default) }
-        subject { links[:snapshots] }
-
-        its([:name]) { should eq(snapshots_summary.name) }
-        its([:size]) { should eq(snapshots_summary.size) }
-        its([:href]) { should eq(snapshots_summary.href) }
-      end
-    end
-
-
   end
 
-  context '.example' do
-    subject(:example) { Address.example }
-
-    its('links.owner') { should be(example.owner) }
-    its('links.super') { should be(example.object.manager) }
-
-    it 'does not respond to non-top-level attributes from links' do
-      expect { example.super }.to raise_error(NoMethodError)
-    end
-
-    it 'responds to non-top-level attributes from links on its inner Struct' do
-      expect(example.links.super).to be(example.object.manager)
-    end
-  end
-
-
   context 'describing' do
 
     subject(:described){ Address.describe }
@@ -171,10 +87,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_array([:default, :master, :link])
+      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, :links, :fields])
+      expect( subject[:attributes].keys ).to match_array([:id, :name, :owner, :custodian, :residents, :residents_summary, :fields])
     end
   end
 
@@ -192,56 +108,6 @@ describe Praxis::MediaType do
 
     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

data/spec/praxis/middleware_app_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Praxis::MiddlewareApp do
 
   let(:init_args){ { root: 'here'} }
-  let(:middleware) { Praxis::MiddlewareApp.for( init_args ) }
+  let(:middleware) { Praxis::MiddlewareApp.for( **init_args ) }
   let(:instance){ middleware.new(target)}
 
   context '.for' do

data/spec/praxis/request_spec.rb

@@ -2,8 +2,8 @@ require 'spec_helper'
 
 describe Praxis::Request do
   let(:path) { '/instances/1?junk=foo&api_version=1.0' } 
-  let(:rack_input) { StringIO.new('something=given') }
-  let(:env_content_type){ 'application/x-www-form-urlencoded' }
+  let(:rack_input) { StringIO.new('{"something": "given"}') }
+  let(:env_content_type){ 'application/json' }
   let(:env) do
     env = Rack::MockRequest.env_for(path)
     env['rack.input'] = rack_input
@@ -192,7 +192,7 @@ describe Praxis::Request do
     end
 
     context '#validate_payload' do
-      before { request.load_payload('') }
+      before { request.load_payload('{}') }
       it 'should validate payload' do
         expect(request.payload).to receive(:validate).and_return([])
         request.validate_payload(context[:payload])
@@ -208,22 +208,11 @@ describe Praxis::Request do
       let(:load_context){ context[:payload] }
       let(:parsed_result){ double("parsed") }
 
-      before do
-        Praxis::Application.instance.handler 'xml', Praxis::Handlers::XML
-      end
-
       after do
         expect(request.action.payload).to receive(:load).with(parsed_result, load_context, content_type: request.content_type.to_s )
         request.load_payload( load_context )
       end
 
-      context 'that is url-encoded' do
-        let(:env_content_type){ 'application/x-www-form-urlencoded' }
-        let(:parsed_result) { {"something" => "given"} }
-
-        it 'decodes it the www-form handler' do end
-      end
-
       context 'that is json encoded' do
         let(:rack_input) { StringIO.new('{"one":1,"sub_hash":{"first":"hello"}}') }
         let(:env_content_type){ 'application/json' }
@@ -231,14 +220,6 @@ describe Praxis::Request do
 
         it 'decodes using the JSON handler' do end
       end
-      context 'that is xml encoded' do
-        let(:rack_input) { StringIO.new('<hash><one type="integer">1</one><sub_hash><first>hello</first></sub_hash></hash>') }
-        let(:env_content_type) { 'application/xml' }
-        let(:parsed_result) { Praxis::Handlers::XML.new.parse(request.raw_payload) }
-
-        it 'decodes using the XML handler' do end
-      end
-
     end
   end
 end

data/spec/praxis/request_stages/action_spec.rb

@@ -26,7 +26,14 @@ describe Praxis::RequestStages::Action do
 
   context '.execute' do
     before do
-      expect(controller).to receive(action_stage.name).with(request.params_hash).and_return(controller_response)
+      expect(controller).to receive(action_stage.name) do |args|
+        if args
+          expect(args).to eq({})
+        else
+           expect(args).to eq(nil)
+        end
+      end.and_return(controller_response)
+        
     end
     let(:controller_response){ controller.response }
 

data/spec/praxis/resource_definition_spec.rb

@@ -137,7 +137,7 @@ describe Praxis::ResourceDefinition do
     it 'are applied to actions' do
       action = resource_definition.actions[:show]
       expect(action.params.attributes).to have_key(:id)
-      expect(action.routes.first.path.to_s).to eq '/api/:base_param/people/:id'
+      expect(action.route.path.to_s).to eq '/api/:base_param/people/:id'
     end
 
     context 'includes base_params from the APIDefinition' do

data/spec/praxis/response_definition_spec.rb

@@ -448,7 +448,7 @@ describe Praxis::ResponseDefinition 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'},{}) }
+          let(:part) { Praxis::MultipartPart.new('done', {'Status' => 200, 'Content-Type' => 'application/special'},**{}) }
 
           before do
             response_definition.parts like: :ok, media_type: 'application/special'
@@ -463,7 +463,7 @@ describe Praxis::ResponseDefinition do
           end
 
           context 'with invalid part' do
-            let(:part) { Praxis::MultipartPart.new('done', {'Status' => 200, "Location" => "somewhere"},{}) }
+            let(:part) { Praxis::MultipartPart.new('done', {'Status' => 200, "Location" => "somewhere"}) }
 
             it 'validates' do
               expect {
@@ -494,6 +494,7 @@ describe Praxis::ResponseDefinition do
     let(:location) { %r{/my/url/} }
     let(:headers) { {'Header1' => 'Value1'} }
     let(:parts) { nil }
+    let(:parts_block) { nil }
 
     let(:response) do
       Praxis::ResponseDefinition.new(:custom) do
@@ -505,28 +506,26 @@ describe Praxis::ResponseDefinition do
     before do
       response.description(description) if description
       response.location(location) if location
-      response.parts(parts) if parts
+      if parts || parts_block
+        parts ? response.parts(nil, **parts, &parts_block) : response.parts(nil, &parts_block) 
+      end
       response.headers(headers) if headers
     end
 
     context 'for a definition with a media type' do
       let(:media_type) { Instance }
-      subject(:payload) { output[:payload] }
+      subject(:payload) { output[:payload][:type] }
 
       before do
         response.media_type Instance
       end
-
       its([:name]) { should eq 'Instance' }
       context 'examples' do
         subject(:examples) { payload[:examples] }
         its(['json', :content_type]) { should eq('application/vnd.acme.instance+json') }
-        its(['xml', :content_type]) { should eq('application/vnd.acme.instance+xml') }
 
         it 'properly encodes the example bodies' do
-          json = Praxis::Application.instance.handlers['json'].parse(examples['json'][:body])
-          xml = Praxis::Application.instance.handlers['xml'].parse(examples['xml'][:body])
-          expect(json).to eq xml
+          expect(JSON.parse(examples['json'][:body])).to be_kind_of(Hash)
         end
 
       end
@@ -539,7 +538,6 @@ describe Praxis::ResponseDefinition do
 
         it 'still renders examples but as pure handler types for contents' do
           expect(subject['json'][:content_type]).to eq('application/json')
-          expect(subject['xml'][:content_type]).to eq('application/xml')
         end
       end
 
@@ -568,11 +566,13 @@ describe Praxis::ResponseDefinition do
         end
 
         it{ should be_kind_of(::Hash) }
-        its([:payload]){ should ==  {id: 'Praxis-SimpleMediaType', name: 'Praxis::SimpleMediaType', family: 'string', identifier: 'foobar' } }
+        it 'has the right type info' do
+          expect(subject[:payload][:type]).to match(id: 'Praxis-SimpleMediaType', name: 'Praxis::SimpleMediaType', family: 'string', identifier: 'foobar')
+        end
         its([:status]){ should == 200 }
       end
       context 'using a full response definition block' do
-        let(:parts) do
+        let(:parts_block) do
           Proc.new do
             status 234
             media_type 'custom_media'
@@ -584,7 +584,9 @@ describe Praxis::ResponseDefinition do
         end
 
         it{ should be_kind_of(::Hash) }
-        its([:payload]) { should == {id: 'Praxis-SimpleMediaType', name: 'Praxis::SimpleMediaType', family: 'string', identifier: 'custom_media'} }
+        it 'has the right type info' do
+          expect(subject[:payload][:type]).to match(id: 'Praxis-SimpleMediaType', name: 'Praxis::SimpleMediaType', family: 'string', identifier: 'custom_media')
+        end
         its([:status]) { should == 234 }
       end
     end

data/spec/praxis/response_spec.rb

@@ -117,7 +117,7 @@ describe Praxis::Response do
   end
 
   context 'multipart responses' do
-    let(:part) { Praxis::MultipartPart.new('not so ok', {'Status' => 400, "Location" => "somewhere"}, {}) }
+    let(:part) { Praxis::MultipartPart.new('not so ok', {'Status' => 400, "Location" => "somewhere"}) }
 
     context '#add_part' do
 

data/spec/praxis/route_spec.rb

@@ -5,21 +5,19 @@ describe Praxis::Route do
   let(:verb) { 'GET' }
   let(:path) { '/base/stuff' }
   let(:prefixed_path) { '/stuff' }
-  let(:name) { nil }
   let(:version) { '1.0' }
   let(:options) { {} }
 
-  subject(:route) { Praxis::Route.new(verb, path, version, name: name, prefixed_path: prefixed_path, **options) }
+  subject(:route) { Praxis::Route.new(verb, path, version, prefixed_path: prefixed_path, **options) }
 
   its(:verb) { should be(verb) }
   its(:path) { should be(path) }
-  its(:name) { should be(name) }
   its(:version) { should be(version) }
   its(:prefixed_path) { should eq(prefixed_path) }
   its(:options) { should eq(options) }
 
   it 'defaults version to "n/a"' do
-    route = Praxis::Route.new(verb, path, name: name, **options)
+    route = Praxis::Route.new(verb, path, **options)
     expect(route.version).to eq('n/a')
   end
 
@@ -27,11 +25,6 @@ describe Praxis::Route do
     subject(:description) { route.describe }
     it { should eq({verb:verb, path:path , version:version}) }
 
-    context 'with a named route' do
-      let(:name) { :stuff }
-      its([:name]) { should eq(name) }
-    end
-
     context 'with options' do
       let(:options) { {option: 'value'} }
       its([:options]) { should eq(options) }

data/spec/praxis/router_spec.rb

@@ -6,7 +6,7 @@ describe Praxis::Router do
     let(:action){ double("action", resource_definition: resource_definition ) }
     let(:target){ double("target", action: action ) }
     let(:args){ {version: "1.0"} }
-    subject(:matcher){ Praxis::Router::VersionMatcher.new(target,args) }
+    subject(:matcher){ Praxis::Router::VersionMatcher.new(target,**args) }
 
     context '.initialize' do
       let(:args){ {} }

data/spec/praxis/routing_config_spec.rb

@@ -43,26 +43,17 @@ describe Praxis::RoutingConfig do
     let(:options) { {} }
     let(:base_path){ '/api' }
     let(:route) { routing_config.add_route 'GET', path, **options}
-
+    
     it 'returns a corresponding Praxis::Route' do
       expect(route).to be_kind_of(Praxis::Route)
     end
 
-    it 'appends the Route to the set of routes' do
-      expect(routing_config.routes).to include(route)
+    it 'sets the Route to its route' do
+      expect(route).to eq(routing_config.route)
     end
 
     context 'passing  options' do
-      let(:options){ {name: 'alternative', except: '/special' } }
-
-      it 'uses :name to name the route' do
-        expect(route.name).to eq('alternative')
-      end
-
-      it 'does NOT pass the name option down to mustermann' do
-        expect(Mustermann).to receive(:new).with(base_path + path, hash_excluding({name: 'alternative'}))
-        expect(route.name).to eq('alternative')
-      end
+      let(:options){ { except: '/special' } }
 
       it 'passes them through the underlying mustermann object (telling it to ignore unknown ones)' do
         expect(Mustermann).to receive(:new).with(base_path + path, hash_including(ignore_unknown_options: true, except: '/special'))