praxis 2.0.pre.29 → 2.0.pre.30

data/spec/praxis/extensions/pagination/ordering_params_spec.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require_relative '../../../support/spec_media_types'
+
+describe Praxis::Extensions::Pagination::OrderingParams do
+  let(:blog_ordering_type) { Praxis::Types::OrderingParams.for(Blog) }
+
+  context '#validate' do
+    context 'full enforcement and nested relationships' do
+      let(:order_attr) do
+        Attributor::Attribute.new(blog_ordering_type) do
+          by_fields :id, 'recent_posts.title', 'recent_posts.author.first'
+          enforce_for :all
+        end
+      end
+      it 'works for allowed fields' do
+        ['id', 'recent_posts.title', 'recent_posts.author.first'].each do |str|
+          expect(order_attr.load(str).validate).to be_empty
+        end
+      end
+      it 'enforces all components' do
+        # Allowed at any position
+        expect(order_attr.load('recent_posts.title,id').validate).to be_empty
+        # Not allowed even in second position if it isn't on the list
+        expect(order_attr.load('recent_posts.title,name').validate).to_not be_empty
+      end
+      it 'fails for valid but unallowed fields' do
+        ['name', 'recent_posts.id'].each do |str|
+          expect(order_attr.load(str).validate).to_not be_empty
+        end
+      end
+      it 'fails for invalid fields' do
+        ['nothing', 'badassoc.none'].each do |str|
+          expect(order_attr.load(str).validate).to_not be_empty
+        end
+      end
+    end
+    context 'first-only enforcement' do
+      let(:order_attr) do
+        Attributor::Attribute.new(blog_ordering_type) do
+          by_fields :id, 'recent_posts.title'
+          enforce_for :first
+        end
+      end
+      it 'enforces only first components' do
+        # It does not allow 'name' if it is in the first position
+        expect(order_attr.load('name,recent_posts.title').validate).to_not be_empty
+        # Allows 'name' if it is not in the first position
+        expect(order_attr.load('recent_posts.title,name').validate).to be_empty
+      end
+    end
+    context 'default enforcement' do
+      let(:order_attr) do
+        Attributor::Attribute.new(blog_ordering_type)
+      end
+      it 'allows any attribute of the mediatype' do
+        %w[id name href description].each do |str|
+          expect(order_attr.load(str).validate).to be_empty
+        end
+      end
+      it 'enforces only first components' do
+        # It allows non-defined field in second position
+        expect(order_attr.load('name,recent_posts.title').validate).to be_empty
+        # It does not allow non-defined field in first position
+        expect(order_attr.load('recent_posts.title,name').validate).to_not be_empty
+      end
+    end
+  end
+end

data/spec/praxis/mapper/resource_spec.rb

@@ -18,19 +18,55 @@ describe Praxis::Mapper::Resource do
       subject(:properties) { resource.properties }
 
       it 'includes directly-set properties' do
-        expect(properties[:other_resource]).to eq(dependencies: [:other_model], through: nil, as: :other_resource)
+        expect(properties[:other_resource]).to eq(dependencies: [:other_model])
       end
 
       it 'includes aliases as well if different from name' do
-        expect(properties[:aliased_association]).to eq(dependencies: [:name], through: nil, as: :other_model)
+        expect(properties[:aliased_association]).to eq(dependencies: nil, as: :other_model)
       end
 
       it 'inherits from a superclass' do
-        expect(properties[:href]).to eq(dependencies: [:id], through: nil, as: :href)
+        expect(properties[:href]).to eq(dependencies: [:id])
       end
 
       it 'properly overrides a property from the parent' do
-        expect(properties[:name]).to eq(dependencies: [:simple_name], through: nil, as: :name)
+        expect(properties[:name]).to eq(dependencies: [:nested_name])
+      end
+    end
+
+    context 'using strings for names' do
+      let(:bad_resource) do
+        Class.new(Praxis::Mapper::Resource) do
+          property 'iamastring', dependencies: %i[foo]
+        end
+      end
+      it 'complains with the proper message right at definition time' do
+        expect { bad_resource }.to raise_error(
+          RuntimeError,
+          /Error defining property 'iamastring'.*Property names must be symbols, not strings/
+        )
+      end
+    end
+    context 'detect_invalid_properties' do
+      subject { resource.detect_invalid_properties }
+      let(:resource) do
+        Class.new(Praxis::Mapper::Resource) do
+          model SimpleModel
+          property :parent
+          property :other_model, dependencies: %i[foo bar]
+          def other_model
+            _something = foo && bar
+            record.other_model
+          end
+        end
+      end
+      # Validates that defining properties that are direct associations shouldn't be done unless
+      # there is an overriden method that takes over (and therefore might need the dependencies defined for what it needs)
+      it 'detects the invalid ones' do
+        # Parent is defined, but it is already an association (and no overriden method for it)
+        expect(subject).to match(/Bad definition of property 'parent'/)
+        # Other model is an association, but it is overriden, so that's a valid way to specify properties
+        expect(subject).to_not match(/Bad definition of property 'other_model'/)
       end
     end
   end