praxis 2.0.pre.14 → 2.0.pre.18

data/lib/praxis/tasks/routes.rb

@@ -7,14 +7,14 @@ namespace :praxis do
     table = Terminal::Table.new title: "Routes",
     headings:  [
       "Version", "Path", "Verb",
-      "Resource", "Action", "Implementation", "Options"
+      "Endpoint", "Action", "Implementation", "Options"
     ]
 
     rows = []
-    Praxis::Application.instance.endpoint_definitions.each do |resource_definition|
-      resource_definition.actions.each do |name, action|
+    Praxis::Application.instance.endpoint_definitions.each do |endpoint_definition|
+      endpoint_definition.actions.each do |name, action|
         method = begin
-          m = resource_definition.controller.instance_method(name)
+          m = endpoint_definition.controller.instance_method(name)
         rescue
           nil
         end
@@ -22,13 +22,13 @@ namespace :praxis do
         method_name = method ? "#{method.owner.name}##{method.name}" : 'n/a'
 
         row = {
-          resource: resource_definition.name,
+          resource: endpoint_definition.name,
           action: name,
           implementation: method_name,
         }
 
         unless action.route
-          warn "Warning: No routes defined for #{resource_definition.name}##{name}."
+          warn "Warning: No routes defined for #{endpoint_definition.name}##{name}."
           rows << row
         else
           route = action.route

data/lib/praxis/types/multipart_array.rb

@@ -346,6 +346,10 @@ module Praxis
         end
       end
 
+      def part?(name)
+        self.any?{ |i| i.name == name }
+      end
+
       def validate(context=Attributor::DEFAULT_ROOT_CONTEXT)
         errors = self.each_with_index.each_with_object([]) do |(part, idx), errors|
           sub_context = if part.name
@@ -359,13 +363,18 @@ module Praxis
 
         self.class.attributes.each do |name, attribute|
           payload_attribute = attribute.options[:payload_attribute]
-          next unless payload_attribute.options[:required]
-          next if self.part(name)
 
-          sub_context = self.class.generate_subcontext(context, name)
-          errors.push *payload_attribute.validate_missing_value(sub_context)
+          if !self.part?(name)
+            if payload_attribute.options[:required]
+              sub_context = self.class.generate_subcontext(context, name)
+              errors.push "Attribute #{Attributor.humanize_context(sub_context)} is required"
+            end
+            # Return, don't bother checking nullability as it hasn't been provided
+          elsif !self.part(name) && !Attribute.nullable_attribute?(payload_attribute.options)
+            sub_context = self.class.generate_subcontext(context, name)
+            errors.push "Attribute #{Attributor.humanize_context(sub_context)} is not nullable"
+          end
         end
-
         errors
       end
 

data/lib/praxis/version.rb

@@ -1,3 +1,3 @@
 module Praxis
-  VERSION = '2.0.pre.14'
+  VERSION = '2.0.pre.18'
 end

data/praxis.gemspec

@@ -24,7 +24,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'mustermann', '>=1.1', '<=2'
   spec.add_dependency 'activesupport', '>= 3'
   spec.add_dependency 'mime', '~> 0'
-  spec.add_dependency 'attributor', '>= 5.5'
+  spec.add_dependency 'attributor', '>= 6.0'
   spec.add_dependency 'thor'
   spec.add_dependency 'terminal-table', '~> 1.4'
 

data/spec/praxis/action_definition_spec.rb

@@ -40,7 +40,9 @@ describe Praxis::ActionDefinition do
 
         media_type media_type
         location location
-        headers headers if headers
+        headers&.each do |(name, value)|
+          header(name, value)
+        end
       end
     end
     Praxis::ActionDefinition.new(:foo, endpoint_definition) do
@@ -151,15 +153,16 @@ describe Praxis::ActionDefinition do
       it 'includes the requirements in the param struct type' do
         errors = action.params.load(value).validate
         expect(errors).to have(1).item
-        expect(errors.first).to match(/Key one is required/)
+        expect(errors.first).to match('Attribute $.key(:one) is required.')
       end
     end
 
   end
 
   describe '#payload' do
-    it 'defaults to being required if omitted' do
+    it 'defaults to being required and non nullable if omitted' do
       expect(subject.payload.options[:required]).to be(true)
+      expect(subject.payload.options[:null]).to be(false)
     end
 
 

data/spec/praxis/extensions/attribute_filtering/active_record_filter_query_builder_spec.rb

@@ -111,6 +111,48 @@ describe Praxis::Extensions::AttributeFiltering::ActiveRecordFilterQueryBuilder
           let(:filters_string) { 'tags.name=blue' }
           it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:tags).where('active_tags.name' => 'blue')
         end
+
+        context 'by just an association filter condition' do
+          context 'for a belongs_to association with NO ROWS' do
+            let(:filters_string) { 'category!!'}
+            it_behaves_like 'subject_equivalent_to', ActiveBook.where.missing(:category)
+          end
+
+          context 'for a direct has_many association asking for missing rows' do
+            let(:filters_string) { 'primary_tags!!' }
+            it_behaves_like 'subject_equivalent_to', 
+              ActiveBook.where.missing(:primary_tags)
+          end
+          context 'for a direct has_many association asking for non-missing rows' do
+            let(:filters_string) { 'primary_tags!' }
+            it_behaves_like 'subject_equivalent_to', 
+              ActiveBook.left_outer_joins(:primary_tags).where.not('primary_tags.id' => nil)
+          end
+
+          context 'for a has_many through association with NO ROWS' do
+            let(:filters_string) { 'tags!!' }
+            it_behaves_like 'subject_equivalent_to', ActiveBook.where.missing(:tags)
+          end
+
+          context 'for a has_many through association with SOME ROWS' do
+            let(:filters_string) { 'tags!' }
+            it_behaves_like 'subject_equivalent_to', ActiveBook.left_outer_joins(:tags).where.not('tags.id' => nil)
+          end
+
+          context 'for a 3 levels deep has_many association with NO ROWS' do
+            let(:filters_string) { 'category.books.taggings!!' }
+            it_behaves_like 'subject_equivalent_to', 
+              ActiveBook.left_outer_joins(category: { books: :taggings }).where('category.books.taggings.id' => nil)
+          end
+          
+          context 'for a 3 levels deep has_many association WITH SIME ROWS' do
+            let(:filters_string) { 'category.books.taggings!' }
+            it_behaves_like 'subject_equivalent_to', 
+              ActiveBook.left_outer_joins(category: { books: :taggings }).where.not('category.books.taggings.id' => nil)
+          end
+          
+        end
+  
       end
 
       # NOTE: apparently AR when conditions are build with strings in the where clauses (instead of names, etc)
@@ -120,77 +162,77 @@ describe Praxis::Extensions::AttributeFiltering::ActiveRecordFilterQueryBuilder
         PREF = Praxis::Extensions::AttributeFiltering::ALIAS_TABLE_PREFIX
         COMMON_SQL_PREFIX = <<~SQL
               SELECT "active_books".* FROM "active_books"
-              INNER JOIN
+              LEFT OUTER JOIN
                 "active_authors" "#{PREF}/author" ON "#{PREF}/author"."id" = "active_books"."author_id"
             SQL
         context '=' do
           let(:filters_string) { 'author.id=11'}
           it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.id = 11')
           it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
-              WHERE ("#{PREF}/author"."id" = 11)
+              WHERE ("#{PREF}/author"."id" IS NOT NULL) AND ("#{PREF}/author"."id" = 11)
             SQL
         end
         context '= (with array)' do
           let(:filters_string) { 'author.id=11,22'}
           it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.id IN (11,22)')
           it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
-              WHERE ("#{PREF}/author"."id" IN (11,22))
+              WHERE ("#{PREF}/author"."id" IS NOT NULL) AND ("#{PREF}/author"."id" IN (11,22))
             SQL
         end      
         context '!=' do
           let(:filters_string) { 'author.id!=11'}
           it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.id <> 11')
           it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
-              WHERE ("#{PREF}/author"."id" <> 11)
+              WHERE ("#{PREF}/author"."id" IS NOT NULL) AND ("#{PREF}/author"."id" <> 11)
             SQL
         end
         context '!= (with array)' do
           let(:filters_string) { 'author.id!=11,888'}
           it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.id NOT IN (11,888)')
           it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
-              WHERE ("#{PREF}/author"."id" NOT IN (11,888))
+              WHERE ("#{PREF}/author"."id" IS NOT NULL) AND ("#{PREF}/author"."id" NOT IN (11,888))
             SQL
         end
         context '>' do
           let(:filters_string) { 'author.id>1'}
           it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.id > 1')
           it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
-              WHERE ("#{PREF}/author"."id" > 1)
+              WHERE ("#{PREF}/author"."id" IS NOT NULL) AND ("#{PREF}/author"."id" > 1)
             SQL
         end
         context '<' do
           let(:filters_string) { 'author.id<22'}
           it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.id < 22')
           it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
-              WHERE ("#{PREF}/author"."id" < 22)
+              WHERE ("#{PREF}/author"."id" IS NOT NULL) AND ("#{PREF}/author"."id" < 22)
             SQL
         end
         context '>=' do
           let(:filters_string) { 'author.id>=22'}
           it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.id >= 22')
           it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
-              WHERE ("#{PREF}/author"."id" >= 22)
+              WHERE ("#{PREF}/author"."id" IS NOT NULL) AND ("#{PREF}/author"."id" >= 22)
             SQL
         end
         context '<=' do
           let(:filters_string) { 'author.id<=22'}
           it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.id <= 22')
           it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
-              WHERE ("#{PREF}/author"."id" <= 22)
+              WHERE ("#{PREF}/author"."id" IS NOT NULL) AND ("#{PREF}/author"."id" <= 22)
             SQL
         end
         context '!' do
           let(:filters_string) { 'author.id!'}
           it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.id IS NOT NULL')
           it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
-              WHERE ("#{PREF}/author"."id" IS NOT NULL)
+              WHERE ("#{PREF}/author"."id" IS NOT NULL) AND ("#{PREF}/author"."id" IS NOT NULL)
             SQL
         end
         context '!!' do
           let(:filters_string) { 'author.name!!'}
           it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.name IS NULL')
           it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
-              WHERE ("#{PREF}/author"."name" IS NULL)
+              WHERE ("#{PREF}/author"."id" IS NOT NULL) AND ("#{PREF}/author"."name" IS NULL)
             SQL
         end      
         context 'including LIKE fuzzy queries' do
@@ -198,14 +240,14 @@ describe Praxis::Extensions::AttributeFiltering::ActiveRecordFilterQueryBuilder
             let(:filters_string) { 'author.name=author*'}
             it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.name LIKE "author%"')
             it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
-              WHERE ("#{PREF}/author"."name" LIKE 'author%')
+              WHERE ("#{PREF}/author"."id" IS NOT NULL) AND ("#{PREF}/author"."name" LIKE 'author%')
             SQL
           end
           context 'NOT LIKE' do
             let(:filters_string) { 'author.name!=foobar*'}
             it_behaves_like 'subject_equivalent_to', ActiveBook.joins(:author).where('active_authors.name NOT LIKE "foobar%"')
             it_behaves_like 'subject_matches_sql', COMMON_SQL_PREFIX + <<~SQL
-              WHERE ("#{PREF}/author"."name" NOT LIKE 'foobar%')
+              WHERE ("#{PREF}/author"."id" IS NOT NULL) AND ("#{PREF}/author"."name" NOT LIKE 'foobar%')
             SQL
           end
         end
@@ -227,10 +269,10 @@ describe Praxis::Extensions::AttributeFiltering::ActiveRecordFilterQueryBuilder
             ActiveBook.joins(category: { books: :taggings }).where('active_taggings.tag_id': 1).where('active_taggings.label': 'primary')
           it_behaves_like 'subject_matches_sql', <<~SQL
               SELECT "active_books".* FROM "active_books"
-                INNER JOIN "active_categories" ON "active_categories"."uuid" = "active_books"."category_uuid"
-                INNER JOIN "active_books" "books_active_categories" ON "books_active_categories"."category_uuid" = "active_categories"."uuid"
-                INNER JOIN "active_taggings" "#{PREF}/category/books/taggings" ON "/category/books/taggings"."book_id" = "books_active_categories"."id"
-                WHERE ("#{PREF}/category/books/taggings"."tag_id" = 1)
+                LEFT OUTER JOIN "active_categories" ON "active_categories"."uuid" = "active_books"."category_uuid"
+                LEFT OUTER JOIN "active_books" "books_active_categories" ON "books_active_categories"."category_uuid" = "active_categories"."uuid"
+                LEFT OUTER JOIN "active_taggings" "#{PREF}/category/books/taggings" ON "/category/books/taggings"."book_id" = "books_active_categories"."id"
+                WHERE ("#{PREF}/category/books/taggings"."id" IS NOT NULL) AND ("#{PREF}/category/books/taggings"."tag_id" = 1)
                 AND ("#{PREF}/category/books/taggings"."label" = 'primary')
             SQL
         end
@@ -260,14 +302,14 @@ describe Praxis::Extensions::AttributeFiltering::ActiveRecordFilterQueryBuilder
                                                     .where('books_active_categories.simple_name': 'Book3')
           it_behaves_like 'subject_matches_sql', <<~SQL
               SELECT "active_books".* FROM "active_books"
-                INNER JOIN "active_categories" ON "active_categories"."uuid" = "active_books"."category_uuid"
-                INNER JOIN "active_books" "#{PREF}/category/books" ON "#{PREF}/category/books"."category_uuid" = "active_categories"."uuid"    
+                LEFT OUTER JOIN "active_categories" ON "active_categories"."uuid" = "active_books"."category_uuid"
+                LEFT OUTER JOIN "active_books" "#{PREF}/category/books" ON "#{PREF}/category/books"."category_uuid" = "active_categories"."uuid"    
               WHERE ("active_books"."simple_name" = 'Book1')
-              AND ("#{PREF}/category/books"."simple_name" = 'Book3')
+              AND ("#{PREF}/category/books"."id" IS NOT NULL) AND ("#{PREF}/category/books"."simple_name" = 'Book3')
             SQL
         end
 
-        context 'it qualifis them even if there are no joined tables/conditions at all' do
+        context 'it qualifies them even if there are no joined tables/conditions at all' do
           let(:filters_string) { 'id=11'}
           it_behaves_like 'subject_matches_sql', <<~SQL
             SELECT "active_books".* FROM "active_books"
@@ -310,20 +352,31 @@ describe Praxis::Extensions::AttributeFiltering::ActiveRecordFilterQueryBuilder
                                                 .or(ActiveBook.joins(:taggings).where('active_taggings.tag_id' => 2))
         it_behaves_like 'subject_matches_sql', <<~SQL
           SELECT "active_books".* FROM "active_books"
-            INNER JOIN "active_taggings" "/taggings" ON "/taggings"."book_id" = "active_books"."id"
-            WHERE ("/taggings"."label" = 'primary' OR "/taggings"."tag_id" = 2)
+            LEFT OUTER JOIN "active_taggings" "/taggings" ON "/taggings"."book_id" = "active_books"."id"
+            WHERE ("/taggings"."id" IS NOT NULL) AND ("/taggings"."label" = 'primary' OR "/taggings"."tag_id" = 2)
+        SQL
+      end
+
+      context 'works well with ORs at a parent table along with joined associations with no rows' do
+        let(:filters_string) { 'name=Book1005|category!!' }
+        it_behaves_like 'subject_equivalent_to', ActiveBook.where.missing(:category)
+                                                .or(ActiveBook.where.missing(:category).where(simple_name: "Book1005"))
+        it_behaves_like 'subject_matches_sql', <<~SQL
+          SELECT "active_books".* FROM "active_books"
+            LEFT OUTER JOIN "active_categories" "/category" ON "/category"."uuid" = "active_books"."category_uuid"
+            WHERE ("active_books"."simple_name" = 'Book1005' OR "/category"."uuid" IS NULL)
         SQL
       end
 
       context '3-deep AND and OR conditions' do
         let(:filters_string) { '(category.name=cat2|(taggings.label=primary&tags.name=red))&category_uuid=deadbeef1' }
         it_behaves_like('subject_equivalent_to', Proc.new do
-          base=ActiveBook.joins(:category,:taggings,:tags)
+          base=ActiveBook.left_outer_joins(:category,:taggings,:tags)
 
-          and1_or1 = base.where('category.name': 'cat2')
+          and1_or1 = base.where('category.name': 'cat2').where.not('category.uuid': nil)
 
-          and1_or2_and1 = base.where('taggings.label': 'primary')
-          and1_or2_and2 = base.where('tags.name': 'red')
+          and1_or2_and1 = base.where('taggings.label': 'primary').where.not('taggings.id': nil)
+          and1_or2_and2 = base.where('tags.name': 'red').where.not('tags.id': nil)
           and1_or2 = and1_or2_and1.and(and1_or2_and2)
 
           and1 = and1_or1.or(and1_or2)
@@ -334,11 +387,16 @@ describe Praxis::Extensions::AttributeFiltering::ActiveRecordFilterQueryBuilder
 
         it_behaves_like 'subject_matches_sql', <<~SQL
         SELECT "active_books".* FROM "active_books" 
-          INNER JOIN "active_categories" "/category" ON "/category"."uuid" = "active_books"."category_uuid" 
-          INNER JOIN "active_taggings" "/taggings" ON "/taggings"."book_id" = "active_books"."id" 
-          INNER JOIN "active_taggings" "taggings_active_books_join" ON "taggings_active_books_join"."book_id" = "active_books"."id" 
-          INNER JOIN "active_tags" "/tags" ON "/tags"."id" = "taggings_active_books_join"."tag_id"         
-          WHERE ("/category"."name" = 'cat2' OR ("/taggings"."label" = 'primary') AND ("/tags"."name" = 'red')) AND ("active_books"."category_uuid" = 'deadbeef1')
+          LEFT OUTER JOIN "active_categories" "/category" ON "/category"."uuid" = "active_books"."category_uuid" 
+          LEFT OUTER JOIN "active_taggings" "/taggings" ON "/taggings"."book_id" = "active_books"."id" 
+          LEFT OUTER JOIN "active_tags" "/tags" ON "/tags"."id" = "/taggings"."tag_id"         
+          WHERE (("/category"."uuid" IS NOT NULL)
+                AND ("/category"."name" = 'cat2')
+                  OR ("/taggings"."id" IS NOT NULL)
+                      AND ("/taggings"."label" = 'primary')
+                      AND ("/tags"."id" IS NOT NULL)
+                      AND ("/tags"."name" = 'red'))
+                AND ("active_books"."category_uuid" = 'deadbeef1') 
         SQL
       end
     end
@@ -391,9 +449,9 @@ describe Praxis::Extensions::AttributeFiltering::ActiveRecordFilterQueryBuilder
         # This is slightly incorrect in AR 6.1+ (since the picked aliases for active_taggings tables vary)
         # it_behaves_like 'subject_matches_sql', <<~SQL
         #   SELECT "active_books".* FROM "active_books"
-        #     INNER JOIN "active_taggings" ON "active_taggings"."label" = 'primary'
+        #     LEFT OUTER JOIN "active_taggings" ON "active_taggings"."label" = 'primary'
         #                 AND "active_taggings"."book_id" = "active_books"."id"
-        #     INNER JOIN "active_tags" "/primary_tags" ON "/primary_tags"."id" = "active_taggings"."tag_id"
+        #     LEFT OUTER JOIN "active_tags" "/primary_tags" ON "/primary_tags"."id" = "active_taggings"."tag_id"
         #     WHERE ("/primary_tags"."name" = 'blue')
         # SQL
       end

data/spec/praxis/extensions/attribute_filtering/filtering_params_spec.rb

@@ -161,9 +161,9 @@ describe Praxis::Extensions::AttributeFiltering::FilteringParams do
       # construct it propertly by applying the block. Seems easier than creating the type alone, and 
       # then manually apply the block
       Attributor::Attribute.new(described_class.for(Post)) do
-        filter 'id', using: ['=', '!=']
+        filter 'id', using: ['=', '!=', '!']
         filter 'title', using: ['=', '!='], fuzzy: true
-        filter 'content', using: ['=', '!=']
+        filter 'content', using: ['=', '!=', '!']
       end.type
     end
     let(:loaded_params) { filtering_params_type.load(filters_string) }
@@ -194,6 +194,21 @@ describe Praxis::Extensions::AttributeFiltering::FilteringParams do
         end
       end
     end
+
+    context 'non-valued operators' do
+      context 'for string typed fields' do
+        let(:filters_string) { 'content!'}
+        it 'validates properly' do
+          expect(subject).to be_empty
+        end
+      end
+      context 'for non-string typed fields' do
+        let(:filters_string) { 'id!'}
+        it 'validates properly' do
+          expect(subject).to be_empty
+        end
+      end
+    end
     context 'fuzzy matches' do
       context 'when allowed' do
         context 'given a fuzzy string' do

data/spec/praxis/extensions/support/spec_resources_active_model.rb

@@ -120,6 +120,8 @@ class ActiveBookResource < ActiveBaseResource
     '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',
+    'primary_tags': 'primary_tags',
+    'category.books.taggings': 'category.books.taggings',
   )
   # 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

data/spec/praxis/mapper/resource_spec.rb

@@ -14,15 +14,15 @@ describe Praxis::Mapper::Resource do
       subject(:properties) { resource.properties }
 
       it 'includes directly-set properties' do
-        expect(properties[:other_resource]).to eq(dependencies: [:other_model])
+        expect(properties[:other_resource]).to eq(dependencies: [:other_model], through: nil)
       end
 
       it 'inherits from a superclass' do
-        expect(properties[:href]).to eq(dependencies: [:id])
+        expect(properties[:href]).to eq(dependencies: [:id], through: nil)
       end
 
       it 'properly overrides a property from the parent' do
-        expect(properties[:name]).to eq(dependencies: [:simple_name])
+        expect(properties[:name]).to eq(dependencies: [:simple_name], through: nil)
       end
     end
   end

data/spec/praxis/mapper/selector_generator_spec.rb

@@ -320,6 +320,40 @@ describe Praxis::Mapper::SelectorGenerator do
         it_behaves_like 'a proper selector'
       end      
 
+      context 'that are several attriutes deep' do
+        let(:fields) { { deep_nested_deps: true } }
+        let(:selectors) do
+          {
+            model: SimpleModel,
+            columns: [:parent_id],
+            tracks: {
+              parent: {
+                model: ParentModel,
+                columns: [:id], # No FKs in the source model for one_to_many
+                tracks: {
+                  simple_children: { 
+                    columns: [:parent_id, :other_model_id],
+                    model: SimpleModel,
+                    tracks: {
+                      other_model: {
+                        model: OtherModel,
+                        columns: [:id, :parent_id],
+                        tracks: {
+                          parent: {
+                            model: ParentModel,
+                            columns: [:id, :simple_name, :other_attribute]
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        end
+        it_behaves_like 'a proper selector'
+      end
     end
   end
 end

data/spec/praxis/media_type_identifier_spec.rb

@@ -218,7 +218,21 @@ describe Praxis::MediaTypeIdentifier do
 
     it 'replaces suffix and parameters and adds new ones' do
       expect(complex_subject + 'json; nuts=false; cherry=true').to \
-      eq(described_class.new('application/vnd.icecream+json; cherry=true; nuts=false'))
+        eq(described_class.new('application/vnd.icecream+json; cherry=true; nuts=false'))
+    end
+
+    context 'does not add json for an already json identifier' do
+      it 'non-parameterized mediatypes simply ignore adding the suffix' do
+        plain_application_json = described_class.new('application/json')
+
+        expect(plain_application_json + 'json').to \
+          eq(plain_application_json)
+      end
+      it 'parameterized mediatypes still keeps them' do
+        parameterized_application_json = described_class.new('application/json; cherry=true; nuts=false')
+        expect(parameterized_application_json + 'json').to \
+          eq(parameterized_application_json)
+      end
     end
   end
 end

data/spec/praxis/request_spec.rb

@@ -17,9 +17,9 @@ describe Praxis::Request do
 
   let(:context) do
     {
-      params: [Attributor::AttributeResolver::ROOT_PREFIX, "params".freeze],
-      headers: [Attributor::AttributeResolver::ROOT_PREFIX, "headers".freeze],
-      payload: [Attributor::AttributeResolver::ROOT_PREFIX, "payload".freeze]
+      params: [Attributor::ROOT_PREFIX, "params".freeze],
+      headers: [Attributor::ROOT_PREFIX, "headers".freeze],
+      payload: [Attributor::ROOT_PREFIX, "payload".freeze]
     }.freeze
   end