praxis 2.0.pre.4 → 2.0.pre.9

data/spec/praxis/extensions/{field_selection/support → support}/spec_resources_active_model.rb

@@ -36,6 +36,7 @@ def create_tables
       create_table :active_taggings do |table|
         table.column :book_id, :integer
         table.column :tag_id, :integer
+        table.column :label, :string, null: true
       end
     end
   end
@@ -48,8 +49,12 @@ class ActiveBook < ActiveRecord::Base
 
   belongs_to :category, class_name: 'ActiveCategory', foreign_key: :category_uuid, primary_key: :uuid
   belongs_to :author, class_name: 'ActiveAuthor'
+
   has_many :taggings, class_name: 'ActiveTagging', foreign_key: :book_id
+  has_many :primary_taggings, lambda { where(label: 'primary')}, class_name: 'ActiveTagging', foreign_key: :book_id
+
   has_many :tags, class_name: 'ActiveTag', through: :taggings
+  has_many :primary_tags, class_name: 'ActiveTag', through: :primary_taggings, source: :tag
 end
 
 class ActiveAuthor < ActiveRecord::Base
@@ -64,6 +69,8 @@ end
 
 class ActiveTag < ActiveRecord::Base
   include Praxis::Mapper::ActiveModelCompat
+  has_many :taggings, class_name: 'ActiveTagging', foreign_key: :tag_id
+  has_many :books, class_name: 'ActiveBook', through: :taggings, source: :book
 end
 
 class ActiveTagging < ActiveRecord::Base
@@ -94,6 +101,26 @@ end
 class ActiveBookResource < ActiveBaseResource
   model ActiveBook
 
+  filters_mapping(
+    id: :id,
+    category_uuid: :category_uuid,
+    'fake_nested.name': 'simple_name',
+    'name': 'simple_name',
+    'name_is_not': lambda do |spec| # Silly way to use a proc, but good enough for testing
+      { name: :simple_name, value: spec[:value] , op: '!=' } # Can be an array for multiple conditions as well
+      end,
+    'author.id': 'author.id',
+    'author.name': 'author.name',
+    'taggings.label': 'taggings.label',
+    'taggings.tag_id': 'taggings.tag_id',
+    'taggings.tag.taggings.tag_id': 'taggings.tag.taggings.tag_id',
+    'tags.name': 'tags.name',
+    'primary_tags.name': 'primary_tags.name',
+    'category.name': 'category.name',
+    'category.books.name': 'category.books.simple_name',
+    'category.books.taggings.tag_id': 'category.books.taggings.tag_id',
+    'category.books.taggings.label': 'category.books.taggings.label',
+  )
   # Forces to add an extra column (added_column)...and yet another (author_id) that will serve
   # to check that if that's already automatically added due to an association, it won't interfere or duplicate
   property :author, dependencies: [:author, :added_column, :author_id]
@@ -108,23 +135,39 @@ def seed_data
   
   author1 = ActiveAuthor.create(  id: 11, name: 'author1' )
   author2 = ActiveAuthor.create(  id: 22, name: 'author2' )
+  author3 = ActiveAuthor.create(  id: 33, name: nil )
   
   tag_blue = ActiveTag.create(id: 1 , name: 'blue' )
   tag_red = ActiveTag.create(id: 2 , name: 'red' )
+  tag_green = ActiveTag.create(id: 3 , name: 'green' )
 
   book1 = ActiveBook.create( id: 1 , simple_name: 'Book1', category_uuid: 'deadbeef1')
   book1.author = author1
   book1.category = cat1
   book1.save
-  ActiveTagging.create(book: book1, tag: tag_blue)
+  ActiveTagging.create(book: book1, tag: tag_blue, label: 'primary')
   ActiveTagging.create(book: book1, tag: tag_red)
+  ActiveTagging.create(book: book1, tag: tag_green, label: 'primary')
   
 
   book2 = ActiveBook.create( id: 2 , simple_name: 'Book2', category_uuid: 'deadbeef1')
   book2.author = author2
   book2.category = cat2
   book2.save
-  ActiveTagging.create(book: book2, tag: tag_red)
+  ActiveTagging.create(book: book2, tag: tag_red, label: 'primary')
+
+  book3 = ActiveBook.create( id: 3 , simple_name: 'Book3', category_uuid: 'deadbeef1')
+  book3.author = author3
+  book3.save
+  ActiveTagging.create(book: book3, tag: tag_red, label: 'primary')
+
+  # More stuff
+
+  10.times do |i|
+    bid = 1000+i
+    ActiveBook.create( id: bid , simple_name: "Book#{bid}")
+  end
+
 end
 
 seed_data

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

@@ -514,22 +514,18 @@ describe Praxis::ResponseDefinition do
 
     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
@@ -542,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
 
@@ -571,7 +566,9 @@ 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
@@ -587,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/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'))