haveapi 0.26.5 → 0.27.1

data/spec/model_adapters/active_record_spec.rb

@@ -0,0 +1,413 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require 'active_record'
+require 'sqlite3'
+require_relative '../../lib/haveapi/model_adapters/active_record'
+
+module ARAdapterSpec
+  class Environment < ActiveRecord::Base
+    has_many :groups, class_name: 'ARAdapterSpec::Group'
+  end
+
+  class Group < ActiveRecord::Base
+    belongs_to :environment, class_name: 'ARAdapterSpec::Environment', optional: true
+    has_many :users, class_name: 'ARAdapterSpec::User'
+  end
+
+  class User < ActiveRecord::Base
+    belongs_to :group, class_name: 'ARAdapterSpec::Group', optional: true
+
+    validates :name, length: { minimum: 3, maximum: 20 }
+    validates :email, format: { with: /\A.+@.+\z/ }
+    validates :role, inclusion: { in: %w[user admin] }
+    validates :state, exclusion: { in: %w[banned] }
+    validates :age, numericality: {
+      greater_than_or_equal_to: 18,
+      less_than_or_equal_to: 100
+    }
+    validates :score, numericality: { equal_to: 7 }
+    validates :name, presence: true
+  end
+end
+
+describe HaveAPI::ModelAdapters::ActiveRecord do
+  api do
+    env_resource = define_resource(:Environment) do
+      version 1
+      auth false
+      model ARAdapterSpec::Environment
+
+      define_action(:Index, superclass: HaveAPI::Actions::Default::Index) do
+        authorize { allow }
+
+        output(:object_list) do
+          integer :id
+          string :label
+        end
+
+        def exec
+          self.class.model.order(id: :asc).to_a
+        end
+      end
+
+      define_action(:Show, superclass: HaveAPI::Actions::Default::Show) do
+        authorize { allow }
+
+        output(:object) do
+          integer :id
+          string :label
+          string :note
+        end
+
+        def exec
+          self.class.model.find(params['environment_id'])
+        end
+      end
+    end
+
+    group_resource = define_resource(:Group) do
+      version 1
+      auth false
+      model ARAdapterSpec::Group
+
+      define_action(:Index, superclass: HaveAPI::Actions::Default::Index) do
+        authorize { allow }
+
+        output(:object_list) do
+          integer :id
+          string :label
+        end
+
+        def exec
+          self.class.model.order(id: :asc).to_a
+        end
+      end
+
+      define_action(:Show, superclass: HaveAPI::Actions::Default::Show) do
+        authorize { allow }
+
+        output(:object) do
+          integer :id
+          string :label
+          string :note
+          resource env_resource
+        end
+
+        def exec
+          self.class.model.find(params['group_id'])
+        end
+      end
+    end
+
+    define_resource(:User) do
+      version 1
+      auth false
+      model ARAdapterSpec::User
+
+      define_action(:Index, superclass: HaveAPI::Actions::Default::Index) do
+        authorize { allow }
+
+        output(:object_list) do
+          integer :id
+          string :name
+        end
+
+        def exec
+          with_pagination(self.class.model.order(id: :asc)).to_a
+        end
+      end
+
+      define_action(:IndexDesc, superclass: HaveAPI::Actions::Default::Index) do
+        route 'desc'
+        authorize { allow }
+
+        output(:object_list) do
+          integer :id
+          string :name
+        end
+
+        def exec
+          with_desc_pagination(self.class.model.order(id: :desc)).to_a
+        end
+      end
+
+      define_action(:Show, superclass: HaveAPI::Actions::Default::Show) do
+        authorize { allow }
+
+        output(:object) do
+          integer :id
+          string :name
+          resource group_resource
+        end
+
+        def exec
+          id = params['user_id'].to_i
+          with_includes(self.class.model.where(id: id)).take!
+        end
+      end
+
+      define_action(:Create, superclass: HaveAPI::Actions::Default::Create) do
+        authorize { allow }
+
+        input do
+          string :name
+          string :email
+          string :role
+          string :state
+          integer :age
+          integer :score
+        end
+
+        def exec
+          {}
+        end
+      end
+    end
+  end
+
+  default_version 1
+
+  before(:all) do
+    ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
+    ActiveRecord::Schema.verbose = false
+
+    ActiveRecord::Schema.define do
+      create_table :environments do |t|
+        t.string :label, null: false
+        t.string :note
+      end
+
+      create_table :groups do |t|
+        t.string :label, null: false
+        t.string :note
+        t.integer :environment_id
+      end
+
+      create_table :users do |t|
+        t.string :name
+        t.string :email
+        t.integer :age
+        t.integer :score
+        t.string :role
+        t.string :state
+        t.integer :group_id
+      end
+    end
+  end
+
+  before do
+    ARAdapterSpec::User.delete_all
+    ARAdapterSpec::Group.delete_all
+    ARAdapterSpec::Environment.delete_all
+  end
+
+  let(:dummy_action) do
+    Class.new do
+      include HaveAPI::ModelAdapters::ActiveRecord::Action::InstanceMethods
+
+      def self.model
+        ARAdapterSpec::User
+      end
+
+      def input
+        {}
+      end
+    end.new
+  end
+
+  def create_user(attrs = {})
+    defaults = {
+      name: 'user',
+      email: 'user@example.com',
+      role: 'user',
+      state: 'active',
+      age: 20,
+      score: 7
+    }
+
+    ARAdapterSpec::User.create!(defaults.merge(attrs))
+  end
+
+  def action_class(resource, action)
+    klass, = find_action(1, resource, action)
+    klass
+  end
+
+  def fetch_validator(validators, klass, short_name)
+    validators[klass] || validators[short_name.to_sym] || validators[short_name.to_s]
+  end
+
+  it 'translates ActiveModel validators to HaveAPI validators' do
+    app
+    create_action = action_class(:User, :create)
+
+    name_validators = create_action.input[:name].describe(nil)[:validators]
+    name_length = fetch_validator(name_validators, 'HaveAPI::Validators::Length', :length)
+    expect(name_length).to be_a(Hash)
+    expect(name_length[:min]).to eq(3)
+    expect(name_length[:max]).to eq(20)
+    expect(fetch_validator(name_validators, 'HaveAPI::Validators::Presence', :present)).to be_nil
+
+    email_validators = create_action.input[:email].describe(nil)[:validators]
+    expect(fetch_validator(email_validators, 'HaveAPI::Validators::Format', :format)).to be_a(Hash)
+
+    role_validators = create_action.input[:role].describe(nil)[:validators]
+    role_inclusion = fetch_validator(role_validators, 'HaveAPI::Validators::Inclusion', :include)
+    expect(role_inclusion).to be_a(Hash)
+    expect(role_inclusion[:values]).to include('user', 'admin')
+
+    state_validators = create_action.input[:state].describe(nil)[:validators]
+    state_exclusion = fetch_validator(state_validators, 'HaveAPI::Validators::Exclusion', :exclude)
+    expect(state_exclusion).to be_a(Hash)
+    expect(state_exclusion[:values]).to include('banned')
+
+    age_validators = create_action.input[:age].describe(nil)[:validators]
+    age_number = fetch_validator(age_validators, 'HaveAPI::Validators::Numericality', :number)
+    expect(age_number).to be_a(Hash)
+    expect(age_number[:min]).to eq(18)
+    expect(age_number[:max]).to eq(100)
+
+    score_validators = create_action.input[:score].describe(nil)[:validators]
+    score_acceptance = fetch_validator(score_validators, 'HaveAPI::Validators::Acceptance', :accept)
+    expect(score_acceptance).to be_a(Hash)
+    expect(score_acceptance[:value]).to eq(7)
+  end
+
+  it 'parses nested includes and drops unknown associations' do
+    parsed = dummy_action.ar_parse_includes(%w[group group__environment foo bar__baz])
+
+    expect(parsed).to include(:group)
+    expect(parsed.any? { |v| v.is_a?(Hash) && v.has_key?(:group) }).to be(true)
+
+    nested = parsed.detect { |v| v.is_a?(Hash) && v.has_key?(:group) }
+    expect(nested[:group].flatten).to include(:environment)
+
+    expect(parsed).not_to include(:foo)
+    expect(parsed).not_to include(:bar)
+  end
+
+  it 'returns unresolved associations without includes' do
+    environment = ARAdapterSpec::Environment.create!(label: 'env', note: 'ENV_NOTE')
+    group = ARAdapterSpec::Group.create!(label: 'grp', note: 'GRP_NOTE', environment: environment)
+    user = create_user(name: 'user', group: group)
+
+    get "/v1/users/#{user.id}", {}, input: ''
+
+    expect(api_response).to be_ok
+    ret = api_response[:user]
+    group_data = ret[:group]
+
+    expect(group_data[:_meta][:resolved]).to be(false)
+    expect(group_data).to include(id: group.id, label: group.label)
+    expect(group_data).not_to have_key(:note)
+  end
+
+  it 'resolves direct associations when included' do
+    environment = ARAdapterSpec::Environment.create!(label: 'env', note: 'ENV_NOTE')
+    group = ARAdapterSpec::Group.create!(label: 'grp', note: 'GRP_NOTE', environment: environment)
+    user = create_user(name: 'user', group: group)
+
+    get "/v1/users/#{user.id}", { _meta: { includes: 'group' } }, input: ''
+
+    expect(api_response).to be_ok
+    ret = api_response[:user]
+    group_data = ret[:group]
+
+    expect(group_data[:_meta][:resolved]).to be(true)
+    expect(group_data[:note]).to eq('GRP_NOTE')
+    expect(group_data[:environment][:_meta][:resolved]).to be(false)
+    expect(group_data[:environment]).not_to have_key(:note)
+  end
+
+  it 'resolves nested associations when included' do
+    environment = ARAdapterSpec::Environment.create!(label: 'env', note: 'ENV_NOTE')
+    group = ARAdapterSpec::Group.create!(label: 'grp', note: 'GRP_NOTE', environment: environment)
+    user = create_user(name: 'user', group: group)
+
+    get "/v1/users/#{user.id}", { _meta: { includes: 'group__environment' } }, input: ''
+
+    expect(api_response).to be_ok
+    ret = api_response[:user]
+    group_data = ret[:group]
+    env_data = group_data[:environment]
+
+    expect(group_data[:_meta][:resolved]).to be(true)
+    expect(env_data[:_meta][:resolved]).to be(true)
+    expect(env_data[:note]).to eq('ENV_NOTE')
+  end
+
+  it 'cleans resource input ids and maps invalid values to validation errors' do
+    environment = ARAdapterSpec::Environment.create!(id: 1, label: 'env')
+
+    expect(described_class::Input.clean(ARAdapterSpec::Environment, 1, {})).to eq(environment)
+    expect(described_class::Input.clean(ARAdapterSpec::Environment, '1', {})).to eq(environment)
+    expect(described_class::Input.clean(ARAdapterSpec::Environment, 1.0, {})).to eq(environment)
+    expect(described_class::Input.clean(ARAdapterSpec::Environment, '', { optional: true })).to be_nil
+    expect(described_class::Input.clean(ARAdapterSpec::Environment, '   ', { optional: true })).to be_nil
+
+    expect do
+      described_class::Input.clean(ARAdapterSpec::Environment, 'abc', {})
+    end.to raise_error(HaveAPI::ValidationError, /not a valid id/)
+
+    expect do
+      described_class::Input.clean(ARAdapterSpec::Environment, '', {})
+    end.to raise_error(HaveAPI::ValidationError, /not a valid id/)
+
+    expect do
+      described_class::Input.clean(ARAdapterSpec::Environment, 1.2, {})
+    end.to raise_error(HaveAPI::ValidationError, /not a valid id/)
+
+    expect do
+      described_class::Input.clean(ARAdapterSpec::Environment, false, {})
+    end.to raise_error(HaveAPI::ValidationError, /not a valid id/)
+
+    expect do
+      described_class::Input.clean(ARAdapterSpec::Environment, true, {})
+    end.to raise_error(HaveAPI::ValidationError, /not a valid id/)
+
+    expect do
+      described_class::Input.clean(ARAdapterSpec::Environment, 9999, {})
+    end.to raise_error(HaveAPI::ValidationError, /resource not found/)
+  end
+
+  it 'applies ascending pagination with with_pagination' do
+    5.times do |i|
+      create_user(
+        id: i + 1,
+        name: "user#{i + 1}",
+        email: "user#{i + 1}@example.com",
+        age: 20 + i
+      )
+    end
+
+    get '/v1/users', { user: { from_id: 2, limit: 2 } }, input: ''
+
+    expect(api_response).to be_ok
+    ids = api_response[:users].map { |u| u[:id] }
+    expect(ids).to eq([3, 4])
+  end
+
+  it 'applies descending pagination with with_desc_pagination' do
+    5.times do |i|
+      create_user(
+        id: i + 1,
+        name: "user#{i + 1}",
+        email: "user#{i + 1}@example.com",
+        age: 20 + i
+      )
+    end
+
+    get '/v1/users/desc', { user: { from_id: 4, limit: 2 } }, input: ''
+
+    expect(api_response).to be_ok
+    ids = api_response[:users].map { |u| u[:id] }
+    expect(ids).to eq([3, 2])
+  end
+
+  it 'raises when paginating a composite primary key model' do
+    allow(ARAdapterSpec::User).to receive(:primary_key).and_return(%w[a b])
+
+    expect { dummy_action.with_asc_pagination }.to raise_error(RuntimeError, /composite primary key/)
+  end
+end

data/spec/parameters/typed_spec.rb

@@ -16,7 +16,7 @@ describe 'Parameters::Typed' do
       required: true
     }
     p_arg(kwargs)
-    expect(kwargs.keys).to contain_exactly(*%i[label desc required])
+    expect(kwargs.keys).to match_array(%i[label desc required])
   end
 
   it 'automatically sets label' do
@@ -38,16 +38,34 @@ describe 'Parameters::Typed' do
   it 'can be required' do
     p = p_arg(required: true)
     expect(p.required?).to be true
+    expect(p.optional?).to be false
   end
 
   it 'can be optional' do
     p = p_arg
+    expect(p.required?).to be false
     expect(p.optional?).to be true
 
     p = p_arg(required: false)
+    expect(p.required?).to be false
     expect(p.optional?).to be true
 
     p = p_arg(required: nil)
+    expect(p.required?).to be false
+    expect(p.optional?).to be true
+  end
+
+  it 'updates optional? when required is patched' do
+    p = p_arg(required: false)
+    expect(p.required?).to be false
+    expect(p.optional?).to be true
+
+    p.patch(required: true)
+    expect(p.required?).to be true
+    expect(p.optional?).to be false
+
+    p.patch(required: nil)
+    expect(p.required?).to be false
     expect(p.optional?).to be true
   end
 
@@ -55,10 +73,26 @@ describe 'Parameters::Typed' do
     # Integer
     p = p_type(Integer)
     expect(p.clean('42')).to eq(42)
+    expect(p.clean('  -7  ')).to eq(-7)
+    expect(p.clean(12)).to eq(12)
+    expect(p.clean(12.0)).to eq(12)
+    expect { p.clean('abc') }.to raise_error(HaveAPI::ValidationError)
+    expect { p.clean('12abc') }.to raise_error(HaveAPI::ValidationError)
+    expect { p.clean('') }.to raise_error(HaveAPI::ValidationError)
+    expect { p.clean('12.0') }.to raise_error(HaveAPI::ValidationError)
+    expect { p.clean(12.3) }.to raise_error(HaveAPI::ValidationError)
+    expect { p.clean(true) }.to raise_error(HaveAPI::ValidationError)
 
     # Float
     p = p_type(Float)
     expect(p.clean('3.1456')).to eq(3.1456)
+    expect(p.clean('1e3')).to eq(1000.0)
+    expect(p.clean(3)).to eq(3.0)
+    expect { p.clean('abc') }.to raise_error(HaveAPI::ValidationError)
+    expect { p.clean('') }.to raise_error(HaveAPI::ValidationError)
+    expect { p.clean('NaN') }.to raise_error(HaveAPI::ValidationError)
+    expect { p.clean(Float::NAN) }.to raise_error(HaveAPI::ValidationError)
+    expect { p.clean(Float::INFINITY) }.to raise_error(HaveAPI::ValidationError)
 
     # Boolean
     p = p_type(Boolean)
@@ -71,6 +105,13 @@ describe 'Parameters::Typed' do
       expect(p.clean(v)).to be false
     end
 
+    expect(p.clean(0)).to be false
+    expect(p.clean(1)).to be true
+    expect(p.clean('  YES ')).to be true
+    expect { p.clean('maybe') }.to raise_error(HaveAPI::ValidationError)
+    expect { p.clean('') }.to raise_error(HaveAPI::ValidationError)
+    expect { p.clean(2) }.to raise_error(HaveAPI::ValidationError)
+
     # Datetime
     p = p_type(Datetime)
     t = Time.now
@@ -78,10 +119,22 @@ describe 'Parameters::Typed' do
 
     expect(p.clean(t.iso8601)).to eq(t2)
     expect { p.clean('bzz') }.to raise_error(HaveAPI::ValidationError)
+    expect { p.clean('') }.to raise_error(HaveAPI::ValidationError)
 
     # String, Text
     p = p_type(String)
     expect(p.clean('bzz')).to eq('bzz')
+    expect(p.clean(123)).to eq('123')
+    expect(p.clean(true)).to eq('true')
+    expect { p.clean([]) }.to raise_error(HaveAPI::ValidationError)
+    expect { p.clean({}) }.to raise_error(HaveAPI::ValidationError)
+
+    p = p_type(Text)
+    expect(p.clean('bzz')).to eq('bzz')
+    expect(p.clean(123)).to eq('123')
+    expect(p.clean(true)).to eq('true')
+    expect { p.clean([]) }.to raise_error(HaveAPI::ValidationError)
+    expect { p.clean({}) }.to raise_error(HaveAPI::ValidationError)
 
     # Defaults
     p = p_type(String)

data/spec/params_spec.rb

@@ -1,4 +1,4 @@
-describe HaveAPI::Params do
+module ParamsSpec
   class MyResource < HaveAPI::Resource
     params(:all) do
       string :res_param1
@@ -17,63 +17,65 @@ describe HaveAPI::Params do
     class Create < HaveAPI::Actions::Default::Create
     end
   end
+end
 
+describe HaveAPI::Params do
   it 'executes all blocks' do
-    p = HaveAPI::Params.new(:input, MyResource::Index)
+    p = described_class.new(:input, ParamsSpec::MyResource::Index)
     p.add_block proc { string :param1 }
     p.add_block proc { string :param2 }
     p.add_block proc { string :param3 }
     p.exec
-    expect(p.params.map(&:name)).to contain_exactly(*%i[param1 param2 param3])
+    expect(p.params.map(&:name)).to match_array(%i[param1 param2 param3])
   end
 
   it 'returns deduced singular namespace' do
-    p = HaveAPI::Params.new(:input, MyResource::Index)
+    p = described_class.new(:input, ParamsSpec::MyResource::Index)
     expect(p.namespace).to eq(:my_resource)
   end
 
   it 'returns deduced plural namespace' do
-    p = HaveAPI::Params.new(:input, MyResource::Index)
+    p = described_class.new(:input, ParamsSpec::MyResource::Index)
     p.layout = :object_list
     expect(p.namespace).to eq(:my_resources)
   end
 
   it 'returns set namespace' do
-    p = HaveAPI::Params.new(:input, MyResource::Index)
+    p = described_class.new(:input, ParamsSpec::MyResource::Index)
     p.namespace = :custom_ns
     expect(p.namespace).to eq(:custom_ns)
   end
 
   it 'uses params from parent resource' do
-    p = HaveAPI::Params.new(:input, MyResource::Index)
+    p = described_class.new(:input, ParamsSpec::MyResource::Index)
     p.add_block proc { use :all }
     p.exec
-    expect(p.params.map(&:name)).to contain_exactly(*%i[res_param1 res_param2])
+    expect(p.params.map(&:name)).to match_array(%i[res_param1 res_param2])
   end
 
   it 'has param requires' do
-    p = HaveAPI::Params.new(:input, MyResource::Index)
+    p = described_class.new(:input, ParamsSpec::MyResource::Index)
     p.add_block proc { requires :p_required }
     p.exec
     expect(p.params.first.required?).to be true
   end
 
   it 'has param optional' do
-    p = HaveAPI::Params.new(:input, MyResource::Index)
+    p = described_class.new(:input, ParamsSpec::MyResource::Index)
     p.add_block proc { optional :p_optional }
     p.exec
     expect(p.params.first.required?).to be false
   end
 
   it 'has param string' do
-    p = HaveAPI::Params.new(:input, MyResource::Index)
+    p = described_class.new(:input, ParamsSpec::MyResource::Index)
     p.add_block proc { string :p_string }
     p.exec
     expect(p.params.first.type).to eq(String)
   end
 
   it 'has param text' do
-    p = HaveAPI::Params.new(:input, MyResource::Index)
+    p = described_class.new(:input, ParamsSpec::MyResource::Index)
     p.add_block proc { text :p_text }
     p.exec
     expect(p.params.first.type).to eq(Text)
@@ -81,7 +83,7 @@ describe HaveAPI::Params do
 
   %i[id integer foreign_key].each do |type|
     it "has param #{type}" do
-      p = HaveAPI::Params.new(:input, MyResource::Index)
+      p = described_class.new(:input, ParamsSpec::MyResource::Index)
       p.add_block proc { send(type, :"p_#{type}") }
       p.exec
       expect(p.params.first.type).to eq(Integer)
@@ -89,42 +91,42 @@ describe HaveAPI::Params do
   end
 
   it 'has param float' do
-    p = HaveAPI::Params.new(:input, MyResource::Index)
+    p = described_class.new(:input, ParamsSpec::MyResource::Index)
     p.add_block proc { float :p_float }
     p.exec
     expect(p.params.first.type).to eq(Float)
   end
 
   it 'has param bool' do
-    p = HaveAPI::Params.new(:input, MyResource::Index)
+    p = described_class.new(:input, ParamsSpec::MyResource::Index)
     p.add_block proc { bool :p_bool }
     p.exec
     expect(p.params.first.type).to eq(Boolean)
   end
 
   it 'has param datetime' do
-    p = HaveAPI::Params.new(:input, MyResource::Index)
+    p = described_class.new(:input, ParamsSpec::MyResource::Index)
     p.add_block proc { datetime :p_datetime }
     p.exec
     expect(p.params.first.type).to eq(Datetime)
   end
 
   it 'has param param' do
-    p = HaveAPI::Params.new(:input, MyResource::Index)
+    p = described_class.new(:input, ParamsSpec::MyResource::Index)
     p.add_block proc { param :p_param, type: Integer }
     p.exec
     expect(p.params.first.type).to eq(Integer)
   end
 
   it 'has param resource' do
-    p = HaveAPI::Params.new(:input, MyResource::Index)
-    p.add_block proc { resource MyResource }
+    p = described_class.new(:input, ParamsSpec::MyResource::Index)
+    p.add_block proc { resource ParamsSpec::MyResource }
     p.exec
     expect(p.params.first).to be_an_instance_of(HaveAPI::Parameters::Resource)
   end
 
   it 'patches params' do
-    p = HaveAPI::Params.new(:input, MyResource::Index)
+    p = described_class.new(:input, ParamsSpec::MyResource::Index)
     p.add_block(proc do
       string :param1, label: 'Param 1'
       string :param2, label: 'Param 2', desc: 'Implicit description'
@@ -137,15 +139,15 @@ describe HaveAPI::Params do
   end
 
   it 'validates upon build' do
-    p = HaveAPI::Params.new(:output, MyResource::Index)
-    p.add_block proc { resource MyResource }
+    p = described_class.new(:output, ParamsSpec::MyResource::Index)
+    p.add_block proc { resource ParamsSpec::MyResource }
     p.exec
     expect(p.params.first).to be_an_instance_of(HaveAPI::Parameters::Resource)
     expect { p.validate_build }.to raise_error(RuntimeError)
   end
 
   it 'accepts valid input layout' do
-    p = HaveAPI::Params.new(:input, MyResource::Index)
+    p = described_class.new(:input, ParamsSpec::MyResource::Index)
     p.add_block(proc do
       string :param1, required: true
       string :param2
@@ -160,7 +162,7 @@ describe HaveAPI::Params do
   end
 
   it 'rejects invalid input layout' do
-    p = HaveAPI::Params.new(:input, MyResource::Index)
+    p = described_class.new(:input, ParamsSpec::MyResource::Index)
     p.add_block(proc do
       string :param1, required: true
       string :param2
@@ -175,7 +177,7 @@ describe HaveAPI::Params do
   end
 
   it 'indexes parameters by name' do
-    p = HaveAPI::Params.new(:input, MyResource::Index)
+    p = described_class.new(:input, ParamsSpec::MyResource::Index)
     p.add_block(proc do
       string :param1
       string :param2