praxis 2.0.pre.19 → 2.0.pre.22

data/spec/praxis/mapper/resources/typed_methods_spec.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Praxis::Mapper::Resources::TypedMethods do
+  let(:resource_class) { TypedResource }
+
+  context '._finalize!' do
+    # The class is already finalized by loading the TypedResource from the spec_resources
+    # So we will simply check that all the right things are created
+    it 'builds the MethodSignatures constant within the class' do
+      expect(TypedResource::MethodSignatures).to_not be_nil
+    end
+
+    it 'builds the inner class type for the defined signatures' do
+      expect(TypedResource::MethodSignatures::UpdateBang).to_not be_nil
+      expect(TypedResource::MethodSignatures::UpdateBang).to be TypedResource.signature(:update!)
+
+      expect(TypedResource::MethodSignatures::SelfCreate).to_not be_nil
+      expect(TypedResource::MethodSignatures::SelfCreate).to be TypedResource.signature(:'self.create')
+    end
+
+    it 'Subsitutes a ! for a Bang when creating the constant' do
+      expect(TypedResource::MethodSignatures::UpdateBang).to be TypedResource.signature(:update!)
+    end
+
+    it 'defines the coercing methods' do
+      expect(TypedResource.methods).to include(:_coerce_params_for_class_create)
+      expect(TypedResource.instance_methods).to include(:_coerce_params_for_update!)
+    end
+  end
+
+  context '.signature' do
+    # We are not creating more classes and signatures, simply checking that the ones created
+    # for TypedResource in the spec_resource_files are correctly processed
+    it 'defines it in the @signatures hash' do
+      expect(TypedResource.signatures.keys).to match_array(
+        %i[
+          self.create
+          self.singlearg_create
+          create
+          update!
+          singlearg_update!
+        ]
+      )
+      expect(TypedResource.signature(:'self.create')).to be < Attributor::Struct
+      expect(TypedResource.signature(:create)).to be < Attributor::Struct
+      expect(TypedResource.signature(:update!)).to be < Attributor::Struct
+    end
+
+    it 'holds the right definition for class create' do
+      definition = TypedResource.signature(:'self.create')
+      expect(definition.attributes.keys).to eq %i[name payload]
+      expect(definition.attributes[:payload].attributes.keys).to eq %i[string_param struct_param]
+    end
+
+    it 'holds the right definition for instance create' do
+      definition = TypedResource.signature(:create)
+      expect(definition.attributes.keys).to eq %i[id]
+    end
+    it 'holds the right definition for update!' do
+      definition = TypedResource.signature(:update!)
+      expect(definition.attributes.keys).to eq %i[string_param struct_param]
+      expect(definition.attributes[:struct_param].attributes.keys).to eq %i[id]
+    end
+  end
+
+  context 'coerce_params_for' do
+    let(:resource_class) do
+      Class.new(Praxis::Mapper::Resource) do
+        include Praxis::Mapper::Resources::TypedMethods
+        def imethod_args(args)
+          args
+        end
+
+        def self.cmethod_args(args)
+          args
+        end
+
+        def imethod_kwargs(**args)
+          args
+        end
+
+        def self.cmethod_kwargs(**args)
+          args
+        end
+      end
+    end
+
+    let(:hook_coercer) { methods.each { |method| resource_class.coerce_params_for(method, type) } }
+    # Note, we're associating the same type signature for both imethod and cmethod signatures!
+    let(:type) do
+      Class.new(Attributor::Struct) do
+        attributes do
+          attribute :id, Integer, required: true
+          attribute :name, String, null: false
+        end
+      end
+    end
+
+    before do
+      # None of our wrappers before invoking the function
+      our_wrappers = resource_class.methods.select { |m| m.to_s =~ /^_coerce_params_for_class_/ }
+      our_wrappers +=  resource_class.instance_methods.select { |m| m.to_s =~ /^_coerce_params_for_/ }
+      expect(our_wrappers).to be_empty
+    end
+    context 'instance methods' do
+      let(:methods) { %i[imethod_args imethod_kwargs] }
+      it 'creates the wrapper methods' do
+        hook_coercer
+        iwrappers = resource_class.instance_methods.select { |m| m.to_s =~ /^_coerce_params_for_/ }
+        expect(iwrappers).to match_array %i[_coerce_params_for_imethod_args _coerce_params_for_imethod_kwargs]
+      end
+
+      it 'sets an around callback for them' do
+        hook_coercer
+        expect(resource_class.around_callbacks[:imethod_args]).to eq([:_coerce_params_for_imethod_args])
+        expect(resource_class.around_callbacks[:imethod_kwargs]).to eq([:_coerce_params_for_imethod_kwargs])
+      end
+
+      context 'when hooking in the callbacks' do
+        before do
+          hook_coercer
+          resource_class._finalize!
+        end
+        context 'calls the wrapper to validate and load' do
+          it 'fails if invalid (id is required)' do
+            expect do
+              resource_class.new(nil).imethod_args({ name: 'Praxis' })
+            end.to raise_error(
+              Praxis::Mapper::Resources::IncompatibleTypeForMethodArguments,
+              /.imethod_args.id is required/
+            )
+            expect do
+              resource_class.new(nil).imethod_kwargs(name: 'Praxis')
+            end.to raise_error(
+              Praxis::Mapper::Resources::IncompatibleTypeForMethodArguments,
+              /.imethod_kwargs.id is required/
+            )
+          end
+
+          it 'succeeds and returns the coerced struct if compatible' do
+            result = resource_class.new(nil).imethod_args({ id: '1', name: 'Praxis' })
+            expect(result[:id]).to eq(1) # Coerces to Integer!
+            expect(result[:name]).to eq('Praxis')
+            result = resource_class.new(nil).imethod_kwargs(id: '1', name: 'Praxis')
+            expect(result[:id]).to eq(1) # Coerces to Integer!
+            expect(result[:name]).to eq('Praxis')
+          end
+        end
+      end
+    end
+
+    context 'class methods' do
+      let(:methods) { %i[self.cmethod_args self.cmethod_kwargs] }
+      it 'creates the wrapper methods' do
+        hook_coercer
+        cwrappers = resource_class.methods.select { |m| m.to_s =~ /^_coerce_params_for_class_/ }
+        expect(cwrappers).to match_array %i[_coerce_params_for_class_cmethod_args _coerce_params_for_class_cmethod_kwargs]
+      end
+
+      it 'sets an around callback for them' do
+        hook_coercer
+        expect(resource_class.around_callbacks[:'self.cmethod_args']).to eq([:_coerce_params_for_class_cmethod_args])
+        expect(resource_class.around_callbacks[:'self.cmethod_kwargs']).to eq([:_coerce_params_for_class_cmethod_kwargs])
+      end
+
+      context 'when hooking in the callbacks' do
+        before do
+          hook_coercer
+          resource_class._finalize!
+        end
+        context 'calls the wrapper to validate and load' do
+          it 'fails if invalid (id is required)' do
+            expect do
+              resource_class.cmethod_args({ name: 'Praxis' })
+            end.to raise_error(
+              Praxis::Mapper::Resources::IncompatibleTypeForMethodArguments,
+              /.cmethod_args.id is required/
+            )
+            expect do
+              resource_class.cmethod_kwargs(name: 'Praxis')
+            end.to raise_error(
+              Praxis::Mapper::Resources::IncompatibleTypeForMethodArguments,
+              /.cmethod_kwargs.id is required/
+            )
+          end
+
+          it 'succeeds and returns the coerced struct if compatible' do
+            result = resource_class.cmethod_args({ id: '1', name: 'Praxis' })
+            expect(result[:id]).to eq(1) # Coerces to Integer!
+            expect(result[:name]).to eq('Praxis')
+            result = resource_class.cmethod_kwargs(id: '1', name: 'Praxis')
+            expect(result[:id]).to eq(1) # Coerces to Integer!
+            expect(result[:name]).to eq('Praxis')
+          end
+        end
+      end
+    end
+  end
+end

data/spec/praxis/response_spec.rb

@@ -61,9 +61,15 @@ describe Praxis::Response do
       end
 
       it 'should raise an error' do
+        resp = nil
         expect do
-          response.validate(action)
-        end.to raise_error(Praxis::Exceptions::Validation, /response definition with that name can be found/)
+          resp = response.validate(action)
+        end.to_not raise_error
+
+        expect(resp.status).to eq(500)
+        expect(resp.body[:name]).to eq('ValidationError')
+        expect(resp.body[:summary]).to eq('Error validating response')
+        expect(resp.body[:errors]).to include(/response definition with that name can be found/)
       end
     end
 

data/spec/support/spec_resources.rb

@@ -77,6 +77,12 @@ class YamlArrayModel < OpenStruct
   end
 end
 
+class TypedModel < OpenStruct
+  def self._praxis_associations
+    {}
+  end
+end
+
 # A set of resource classes for use in specs
 class BaseResource < Praxis::Mapper::Resource
   def href
@@ -100,6 +106,8 @@ class ParentResource < BaseResource
 end
 
 class SimpleResource < BaseResource
+  include Praxis::Mapper::Resources::Callbacks
+
   model SimpleModel
 
   resource_delegate other_model: [:other_attribute]
@@ -123,8 +131,132 @@ class SimpleResource < BaseResource
   property :no_deps, dependencies: []
 
   property :deep_nested_deps, dependencies: ['parent.simple_children.other_model.parent.display_name']
+
+  before(:update!, :do_before_update)
+  around(:update!, :do_around_update_nested)
+  around(:update!, :do_around_update)
+  # Define an after as a proc
+  after(:update!) do |number:|
+    _unused = number
+    record.after_count += 1
+  end
+
+  def do_before_update(number:)
+    _unused = number
+    record.before_count += 1
+  end
+
+  def do_around_update_nested(number:)
+    record.around_count += 100
+    yield(number: number)
+  end
+
+  def do_around_update(number:)
+    record.around_count += 50
+    yield(number: number)
+  end
+
+  around(:change_name, :do_around_change_name)
+  after(:change_name, :do_after_change_name)
+  # Define a before as a proc
+  before(:change_name) do |name, force:|
+    _unused = force
+    record.before_count += 1
+    record.name = name
+    record.force = false # Force always false in before
+  end
+
+  def do_after_change_name(name, force:)
+    _unused = force
+    record.after_count += 1
+    record.name += "-#{name}"
+  end
+
+  def do_around_change_name(name, force:)
+    record.around_count += 50
+
+    record.name += "-#{name}"
+    yield(name, force: force)
+  end
+
+  # Appends the name and overrides the force
+  def change_name(name, force:)
+    record.name += "-#{name}"
+    record.force = force
+    self
+  end
+
+  around(:argsonly, :do_around_argsonly)
+  def do_around_argsonly(name)
+    record.around_count += 50
+    record.name += name.to_s
+    yield(name)
+  end
+
+  def argsonly(name)
+    record.name += "-#{name}"
+    self
+  end
+
+  # Adds 1000 to the around count, plus whatever has been accumulated in before_count
+  def update!(number:)
+    record.around_count += number + record.before_count
+    self
+  end
 end
 
 class YamlArrayResource < BaseResource
   model YamlArrayModel
 end
+
+class TypedResource < BaseResource
+  include Praxis::Mapper::Resources::TypedMethods
+
+  model TypedModel
+
+  signature(:update!) do
+    attribute :string_param, String, null: false
+    attribute :struct_param do
+      attribute :id, Integer
+    end
+  end
+  def update!(**payload)
+    payload
+  end
+
+  signature(:singlearg_update!) do
+    attribute :string_param, String, null: false
+    attribute :struct_param do
+      attribute :id, Integer
+    end
+  end
+  def singlearg_update!(payload)
+    payload
+  end
+
+  # Instance method: create, to make sure we support both an instance and a class method signature
+  signature(:create) do
+    attribute :id, String
+  end
+  def create(id:)
+    id
+  end
+
+  signature('self.create') do
+    attribute :name, String, regexp: /Praxis/
+    attribute :payload, TypedResource.signature(:update!), required: true
+  end
+
+  def self.create(**payload)
+    payload
+  end
+
+  signature('self.singlearg_create') do
+    attribute :name, String, regexp: /Praxis/
+    attribute :payload, TypedResource.signature(:update!), required: true
+  end
+
+  def self.singlearg_create(payload)
+    payload
+  end
+end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: praxis
 version: !ruby/object:Gem::Version
-  version: 2.0.pre.19
+  version: 2.0.pre.22
 platform: ruby
 authors:
 - Josep M. Blanquer
 - Dane Jensen
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-01-10 00:00:00.000000000 Z
+date: 2022-05-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -31,14 +31,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '6.2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '6.2'
 - !ruby/object:Gem::Dependency
   name: mime
   requirement: !ruby/object:Gem::Requirement
@@ -359,7 +359,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5'
-description: 
+description:
 email:
 - blanquer@gmail.com
 - dane.jensen@gmail.com
@@ -463,6 +463,10 @@ files:
 - lib/praxis/handlers/xml_sample.rb
 - lib/praxis/mapper/active_model_compat.rb
 - lib/praxis/mapper/resource.rb
+- lib/praxis/mapper/resources/callbacks.rb
+- lib/praxis/mapper/resources/query_methods.rb
+- lib/praxis/mapper/resources/query_proxy.rb
+- lib/praxis/mapper/resources/typed_methods.rb
 - lib/praxis/mapper/selector_generator.rb
 - lib/praxis/mapper/sequel_compat.rb
 - lib/praxis/media_type.rb
@@ -543,6 +547,9 @@ files:
 - spec/praxis/file_group_spec.rb
 - spec/praxis/handlers/json_spec.rb
 - spec/praxis/mapper/resource_spec.rb
+- spec/praxis/mapper/resources/callbacks_spec.rb
+- spec/praxis/mapper/resources/query_proxy_spec.rb
+- spec/praxis/mapper/resources/typed_methods_spec.rb
 - spec/praxis/mapper/selector_generator_spec.rb
 - spec/praxis/media_type_identifier_spec.rb
 - spec/praxis/media_type_spec.rb
@@ -660,7 +667,7 @@ homepage: https://github.com/praxis/praxis
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -675,8 +682,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
-rubygems_version: 3.1.2
-signing_key: 
+rubygems_version: 3.3.7
+signing_key:
 specification_version: 4
 summary: Building APIs the way you want it.
 test_files: []