praxis 0.16.1 → 0.17.0

data/spec/praxis/route_spec.rb

@@ -3,17 +3,19 @@ require 'spec_helper'
 describe Praxis::Route do
 
   let(:verb) { 'GET' }
-  let(:path) { '/stuff' }
+  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, **options) }
+  subject(:route) { Praxis::Route.new(verb, path, version, name: name, 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

data/spec/praxis/router_spec.rb

@@ -19,14 +19,14 @@ describe Praxis::Router do
       let(:env){ {"HTTP_X_API_VERSION" => request_version } }
       let(:request) {Praxis::Request.new(env)}
 
-      #let(:request){ double("request", version: request_version, env: env ) }
       context 'with matching versions' do
         let(:request_version) { "1.0" }
         it 'calls the target' do
-          expect( target ).to receive(:call).with(request)
+          expect(target).to receive(:call).with(request)
           matcher.call(request)
         end
       end
+
       context 'with non-matching versions' do
         let(:request_version) { "4.0" }
         before do
@@ -80,14 +80,21 @@ describe Praxis::Router do
     let(:target){ double('target') }
     let(:verb_router){ double('verb_router') }
 
-    it 'wraps the target with a VersionMatcher' do
-      router.instance_variable_set( :@routes, {'verb'=>verb_router} ) # Ugly, but no need to have a reader
-      expect(verb_router).to receive(:on) do|path, args|# .with(route.path, call: "foo")
-        expect(path).to eq(route.path)
-        expect(args).to be_kind_of(Hash)
-        expect(args[:call]).to be_kind_of(Praxis::Router::VersionMatcher)
+    let(:resource_definition) { double('resource_definition', version_options: {using: [:header, :params]} ) }
+    let(:action) { double('action', resource_definition: resource_definition) }
+    let(:target) { double('target', action: action) }
+
+
+    context 'with params or header versioning' do
+      it 'wraps the target with a VersionMatcher' do
+        router.instance_variable_set( :@routes, {'verb'=>verb_router} ) # Ugly, but no need to have a reader
+        expect(verb_router).to receive(:on) do|path, args|# .with(route.path, call: "foo")
+          expect(path).to eq(route.path)
+          expect(args).to be_kind_of(Hash)
+          expect(args[:call]).to be_kind_of(Praxis::Router::VersionMatcher)
+        end
+        router.add_route(target, route)
       end
-      router.add_route(target ,route)
     end
 
   end
@@ -103,13 +110,18 @@ describe Praxis::Router do
     let(:router_response_for_wildcard){ "* result" }
     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(:target) { double('target', action: action) }
+
     before do
       env['HTTP_X_API_VERSION'] = request_version if request_version
       allow_any_instance_of(Praxis::Router::RequestRouter).
         to receive(:call).with(request).and_return(router_response)
-      router.add_route(double("P"),double("route1", verb: 'POST', path: '/', options: {} , version: request_version))
+      router.add_route(target,double("route1", verb: 'POST', path: '/', options: {} , version: request_version))
       # Hijack the callable block in the routes (since there's no way to point back to the registered route object)
-      router.instance_variable_get( :@routes )['POST'] = post_target_router
+      router.instance_variable_get(:@routes)['POST'] = post_target_router
 
     end
 
@@ -130,8 +142,12 @@ 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(:target) { double('target', action: action) }
+
       before do
-        router.add_route(double("*"),double("route2", verb: 'ANY', path: '/*', options: {} , version: request_version))
+        router.add_route(target,double("route2", verb: 'ANY', path: '/*', options: {} , version: request_version))
         # Hijack the callable block in the routes (since there's no way to point back to the registered route object)
         router.instance_variable_get( :@routes )['ANY'] = any_target_router
       end

data/spec/praxis/routing_config_spec.rb

@@ -10,9 +10,10 @@ describe Praxis::RoutingConfig do
   end
 
   let(:routing_block) { Proc.new{} }
+  let(:base_path){ '' }
   let(:default_route_prefix) { "/" + resource_definition.name.split("::").last.underscore }
 
-  subject(:routing_config){ Praxis::RoutingConfig.new(&routing_block) }
+  subject(:routing_config){ Praxis::RoutingConfig.new(base: base_path, &routing_block) }
 
   its(:version) { should eq('n/a') }
   its(:prefix ) { should eq('') }
@@ -40,6 +41,7 @@ describe Praxis::RoutingConfig do
   context '#add_route' do
     let(:path) { '/people' }
     let(:options) { {} }
+    let(:base_path){ '/api' }
     let(:route) { routing_config.add_route 'GET', path, **options}
 
     it 'returns a corresponding Praxis::Route' do
@@ -58,12 +60,12 @@ describe Praxis::RoutingConfig do
       end
 
       it 'does NOT pass the name option down to mustermann' do
-        expect(Mustermann).to receive(:new).with(path, hash_excluding({name: 'alternative'}))
+        expect(Mustermann).to receive(:new).with(base_path + path, hash_excluding({name: 'alternative'}))
         expect(route.name).to eq('alternative')
       end
 
       it 'passes them through the underlying mustermann object (telling it to ignore unknown ones)' do
-        expect(Mustermann).to receive(:new).with(path, hash_including(ignore_unknown_options: true, except: '/special'))
+        expect(Mustermann).to receive(:new).with(base_path + path, hash_including(ignore_unknown_options: true, except: '/special'))
         expect(route.options).to eq( { except: '/special' })
       end
     end
@@ -74,13 +76,17 @@ describe Praxis::RoutingConfig do
       end
 
       it 'includes the prefix in the route path' do
-        expect(route.path.to_s).to eq '/parents/:parent_id/people'
+        expect(route.path.to_s).to eq '/api/parents/:parent_id/people'
+      end
+
+      it 'has the right prefixed_path' do
+        expect(route.prefixed_path).to eq '/parents/:parent_id/people'
       end
 
       context 'for paths beginning with //' do
         let(:path) { '//people' }
         it 'does not include the prefix in the route path' do
-          expect(route.path.to_s).to eq '/people'
+          expect(route.path.to_s).to eq '/api/people'
         end
       end
     end

data/spec/praxis/types/collection_spec.rb

@@ -90,7 +90,7 @@ describe Praxis::Collection do
 
 
     context 'for members' do
-      let(:volume_output) { example.render(:default) }
+      let(:volume_output) { example.render(view: :default) }
 
       subject(:output) { volume_output[:snapshots] } 
 

data/spec/praxis/types/fuzzy_hash_spec.rb

@@ -0,0 +1,20 @@
+require "spec_helper"
+
+describe Praxis::Types::FuzzyHash do
+
+  let(:initial_value) {{
+    'key' => 'value',
+    /bob/ => 'rob',
+    /\d+/ => 'one'
+  }}
+
+  subject(:hash) { Praxis::Types::FuzzyHash.new(initial_value) }
+
+  its(['key']) { should eq 'value' }
+  its([/bob/]) { should eq 'rob' }
+  its(['bobby']) { should eq 'rob' }
+  
+  its([1]) { should eq 'one' }
+  its(['1']) { should eq 'one' }
+end
+

data/spec/praxis/types/multipart_array/part_definition_spec.rb

@@ -0,0 +1,5 @@
+require "spec_helper"
+
+describe Praxis::Types::MultipartArray::PartDefinition do
+end
+

data/spec/praxis/types/multipart_array_spec.rb

@@ -0,0 +1,334 @@
+require "spec_helper"
+
+describe Praxis::Types::MultipartArray do
+
+  let(:type) do
+    Class.new(Praxis::Types::MultipartArray) do
+      self.options[:case_insensitive_load] = true
+
+      part 'title', String, required: true
+      part(/nam/, String, regexp: /Bob/i)
+
+      part /stuff/ do
+        payload Hash
+      end
+
+      file 'files', multiple: true do
+        header 'Content-Type', 'application/octet-stream'
+        filename String, regexp: /file/
+        payload Attributor::Tempfile
+      end
+
+      part 'image', Attributor::Tempfile, filename: true
+
+    end
+  end
+
+
+  let(:form) do
+    form_data = MIME::Multipart::FormData.new
+    entity = MIME::Text.new('Bob')
+    form_data.add entity,'name'
+
+    entity = MIME::Text.new('Captain')
+    form_data.add entity,'title'
+
+    entity = MIME::Application.new('file1')
+    form_data.add entity,'files', 'file1'
+
+    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'
+
+    entity = MIME::Application.new('', 'jpg')
+    form_data.add entity,'image', 'image.jpg'
+
+    form_data
+  end
+
+  let(:content_type) { form.headers.get('Content-Type') }
+  let(:body) { form.body.to_s }
+
+  subject(:payload) { type.load(body, content_type: content_type) }
+
+  it 'validates' do
+    part = payload.part('files').first
+    expect(payload.validate).to be_empty
+  end
+
+  it 'loads parts correctly' do
+    expect(payload.part('name')).to be_kind_of(Praxis::MultipartPart)
+    expect(payload.part('name').payload).to eq 'Bob'
+
+    title = payload.part('title')
+    expect(title.payload).to eq 'Captain'
+
+    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'
+
+    image = payload.part('image')
+    expect(image.filename).to eq 'image.jpg'
+  end
+
+  context 'with only payload_type defined' do
+    let(:type) do
+      Class.new(Praxis::Types::MultipartArray) do
+        name_type String
+        payload_type Hash do
+          key 'sub_hash', Hash
+        end
+      end
+    end
+
+    let(:json_payload) { {sub_hash: {key:'value'}}.to_json }
+    let(:body) { StringIO.new("--boundary\r\nContent-Disposition: form-data; name=blah\r\n\r\n#{json_payload}\r\n--boundary--") }
+    let(:content_type) { "multipart/form-data; boundary=boundary" }
+
+    it do
+      expect(payload.part('blah').payload['sub_hash']).to eq('key' => 'value')
+    end
+  end
+
+  context '.describe' do
+    subject(:description) { type.describe(false) }
+
+    its([:name]) { should eq 'Praxis::Types::MultipartArray' }
+
+    it { should have_key :part_name }
+    it { should have_key :attributes }
+    it { should have_key :pattern_attributes }
+
+    context 'attributes' do
+      subject(:attributes) { description[:attributes] }
+      its(:keys) { should match_array ['title', 'files', 'image']}
+
+      context 'the "title" part' do
+        subject(:title_description) { attributes['title'] }
+
+        it 'describes the options' do
+          expect(title_description[:options][:required]).to be true
+        end
+
+        it 'describes the payload' do
+          expect(title_description[:type][:payload][:type]).to eq Attributor::String.describe
+        end
+      end
+
+      context 'the "files" part' do
+        subject(:files_description) { attributes['files'] }
+
+        it 'describes the options' do
+          expect(files_description[:options][:multiple]).to be true
+        end
+
+        it 'describes the payload' do
+          expect(files_description[:type][:payload][:type]).to eq Attributor::Tempfile.describe
+        end
+
+        it 'describes the filename' do
+          filename = files_description[:type][:filename]
+          expect(filename[:options]).to eq(regexp: /file/)
+          expect(filename[:type]).to eq Attributor::String.describe
+        end
+
+      end
+    end
+
+    context 'pattern attributes' do
+      subject(:pattern_attributes) { description[:pattern_attributes] }
+      its(:keys) { should match_array ['nam', 'stuff']}
+    end
+
+    context 'with no parts defined' do
+      let(:type) do
+        Class.new(Praxis::Types::MultipartArray) do
+          name_type DateTime
+          payload_type Hash
+        end
+      end
+      its([:name]) { should eq 'Praxis::Types::MultipartArray' }
+
+      it { should_not have_key :attributes }
+      it { should_not have_key :pattern_attributes }
+
+      it { should have_key :part_name }
+      it { should have_key :part_payload }
+    end
+
+    context 'with an example passed in' do
+      let(:example) { type.example }
+      subject(:description) { type.describe(false, example: example) }
+
+      it 'uses the example values' do
+        expect(
+          description[:attributes]['title'][:type][:payload][:example]
+        ).to eq example.part('title').payload
+
+        file_example = example.part('files').first.payload
+        file_example.rewind
+        expect(
+          description[:attributes]['files'][:type][:payload][:example]
+        ).to eq file_example.read
+
+        image_example = example.part('image').payload
+        image_example.rewind
+        expect(
+          description[:attributes]['image'][:type][:payload][:example]
+        ).to eq image_example.read
+      end
+    end
+  end
+
+  context 'dumping' do
+    subject(:dumped) { payload.dump }
+
+    it 'dumps' do
+      loaded = type.load(dumped, content_type: payload.content_type)
+    end
+    context 'an example' do
+      let(:payload) { type.example }
+
+      it 'dumps' do
+        loaded = type.load(dumped, content_type: payload.content_type)
+      end
+    end
+  end
+
+  context 'with errors' do
+    let(:form) do
+      form_data = MIME::Multipart::FormData.new
+
+      entity = MIME::Text.new('James')
+      form_data.add entity,'name'
+
+
+      entity = MIME::Text.new('file1')
+      form_data.add entity,'files', 'file1'
+
+      form_data
+    end
+
+    subject(:errors) { payload.validate }
+
+    it 'validates part headers' do
+      expect(errors).to have(3).items
+      expect(errors).to match_array([
+                                      %r|\.name\.payload value .* does not match regexp|,
+                                      %r|\.files\.headers.* is not within the allowed values|,
+                                      %r|\.title is required|
+      ])
+    end
+  end
+
+  context '.example' do
+    subject(:payload) { type.example }
+
+    it 'generates parts' do
+      title = payload.part('title')
+      expect(title).to_not be_nil
+      expect(title.payload).to match /\w+/
+
+      files = payload.part('files')
+      expect(files).to have(2).items
+
+      files.each do |file|
+        expect(file.payload).to be_kind_of(Tempfile)
+        expect(file.filename).to match /\w+/
+
+        expect(file.headers['Content-Type']).to eq 'application/octet-stream'
+      end
+    end
+
+    it 'is valid' do
+      expect(payload.validate).to have(0).items
+    end
+
+  end
+
+  context 'with a hackish default part definition' do
+    let(:type) do
+      Class.new(Praxis::Types::MultipartArray) do
+        self.options[:case_insensitive_load] = true
+
+        part /\d+/, Instance
+      end
+    end
+
+    let(:form) do
+      form_data = MIME::Multipart::FormData.new
+
+      (1..5).each do |i|
+        instance = Instance.example("instance-#{i}")
+        body = JSON.pretty_generate(instance.render)
+        entity = MIME::Text.new(body)
+        form_data.add entity,i.to_s
+      end
+
+      form_data
+    end
+
+    it 'loads the parts as the proper type' do
+      payload.each do |part|
+        expect(part.payload).to be_kind_of(Instance)
+      end
+    end
+
+  end
+
+
+  context 'anonymous generation' do
+    let(:definition_block) do
+      proc do
+        name_type Integer
+        payload_type Instance
+      end
+    end
+
+    let(:attribute) do
+      Attributor::Attribute.new(Praxis::Types::MultipartArray, &definition_block)
+    end
+
+    let(:form) do
+      form_data = MIME::Multipart::FormData.new
+
+      (1..5).each do |i|
+        instance = Instance.example("instance-#{i}")
+        body = JSON.pretty_generate(instance.render)
+        entity = MIME::Text.new(body)
+        form_data.add entity,i.to_s
+      end
+
+      form_data
+    end
+
+    let(:payload) { attribute.load(body, content_type: content_type) }
+
+    it 'loads the parts as the proper type' do
+      expect(payload).to have(5).items
+      payload.each do |part|
+        expect(part.name).to be_kind_of(Integer)
+        expect(part.payload).to be_kind_of(Instance)
+      end
+    end
+
+
+  end
+
+
+end