praxis 2.0.pre.5 → 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
 
 
@@ -62,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
@@ -102,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 }
@@ -161,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
 
@@ -182,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/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/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

@@ -523,12 +523,9 @@ describe Praxis::ResponseDefinition do
       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
@@ -541,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
 

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/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'))

data/spec/praxis/types/multipart_array_spec.rb

@@ -41,14 +41,6 @@ describe Praxis::Types::MultipartArray do
     entity = MIME::Application.new('file2')
     form_data.add entity,'files', 'file2'
 
-    entity = MIME::Application.new('
-      <?xml version="1.0" encoding="UTF-8"?>
-      <hash>
-        <first_name>James</first_name>
-      </hash>
-      ', 'xml')
-    form_data.add entity,'stuff1'
-
     entity = MIME::Application.new('{"first_name": "Frank"}', 'json')
     form_data.add entity,'stuff2'
 
@@ -81,9 +73,6 @@ describe Praxis::Types::MultipartArray do
     files = payload.part('files')
     expect(files).to have(2).items
 
-    stuff1 = payload.part('stuff1')
-    expect(stuff1.payload['first_name']).to eq 'James'
-
     stuff2 = payload.part('stuff2')
     expect(stuff2.payload['first_name']).to eq 'Frank'
 
@@ -274,7 +263,7 @@ describe Praxis::Types::MultipartArray do
 
       let(:example) { type.example }
 
-      let(:default_format) { 'xml' }
+      let(:default_format) { 'json' }
 
       let(:output) { example.dump(default_format: default_format) }
 
@@ -282,29 +271,23 @@ describe Praxis::Types::MultipartArray do
 
       it 'dumps the parts with the proper handler' do
         json_handler = Praxis::Application.instance.handlers['json']
-        xml_handler = Praxis::Application.instance.handlers['xml']
 
         # title is simple string, so should keep text/plain
         title = parts.find { |part| part.name == 'title' }
         expect(title.content_type.to_s).to eq 'text/plain'
         expect(title.payload).to eq example.part('title').payload
 
-        # things are structs with no content-type header defined
-        thing = parts.find { |part| part.name == 'thing' }
-        expect(thing.content_type.to_s).to eq 'application/xml'
-        expect(thing.payload).to eq xml_handler.generate(example.part('thing').payload.dump)
-
         # stuff has hardcoded 'application/json' content-type, and should remain such
         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
-        # have xml suffix appended
+        # have json suffix appended
         instances = parts.select { |part| part.name == 'instances' }
         instances.each_with_index do |instance, i|
-          expect(instance.content_type.to_s).to eq 'application/vnd.acme.instance+xml'
-          expect(instance.payload).to eq xml_handler.generate(example.part('instances')[i].payload.dump)
+          expect(instance.content_type.to_s).to eq 'application/vnd.acme.instance+json'
+          expect(instance.payload).to eq json_handler.generate(example.part('instances')[i].payload.dump)
         end
       end
 

data/spec/spec_app/config/environment.rb

@@ -14,8 +14,6 @@ end
 
 Praxis::Application.configure do |application|
 
-  application.handler 'xml', Praxis::Handlers::XML
-
   application.middleware SetHeader, 'Spec-Middleware', 'used'
 
   application.bootloader.use SimpleAuthenticationPlugin, config_file: 'config/authentication.yml'

data/spec/spec_app/design/api.rb

@@ -24,7 +24,7 @@ Praxis::ApiDefinition.define do
     description "This example API should really be replaced by a set of more full-fledged example apps in the future"
 
     base_path "/api"
-    produces 'json','xml'
+    produces 'json'
     #version_with :path
     #base_path "/v:api_version"
 

data/spec/spec_app/design/media_types/instance.rb

@@ -14,16 +14,11 @@ class Instance < Praxis::MediaType
 
     attribute :volumes, Volume::Collection
     
-    links do
-      link :root_volume
-      link :other_volume, Volume, using: :data_volume
-    end
   end
 
   view :default do
     attribute :id
     attribute :root_volume
-    attribute :links
   end
 
   view :link do
@@ -40,9 +35,6 @@ class Instance < Praxis::MediaType
     attribute :id
     attribute :name
     attribute :root_volume
-    attribute :links do
-      attribute :root_volume
-    end
   end