ff-tbl-macros 0.1.8

data/spec/lib/auth/sign_in_spec.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+RSpec.describe Macros::Auth::SignIn do
+  include Warden::Test::Mock
+
+  subject(:sign_in_step) { described_class.new }
+
+  let(:user) { mock_model('User') }
+  let(:scope) { :user }
+  let(:ctx) { { model: user, warden: warden } }
+
+  before do
+    fake_class = Class.new
+    dm = stub_const('Devise::Mapping', fake_class, transfer_nested_constants: true)
+    allow(dm).to receive(:find_scope!).with(user).and_return(scope)
+  end
+
+  context 'user not signed in' do
+    it 'expects to sign in' do
+      sign_in_step.call(ctx, model: user, warden: warden)
+
+      expect(ctx[:current_user]).to eql user
+    end
+  end
+
+  context 'user already signed in' do
+    before do
+      warden.set_user(user, scope: scope)
+    end
+
+    it 'expects to keep user signed in' do
+      sign_in_step.call(ctx, model: user, warden: warden)
+
+      expect(ctx[:current_user]).to eql user
+    end
+  end
+end

data/spec/lib/auth/sign_out_spec.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+RSpec.describe Macros::Auth::SignOut do
+  include Warden::Test::Mock
+
+  subject(:sign_out_step) { described_class.new }
+
+  let(:user) { mock_model('User') }
+  let(:scope) { :user }
+  let(:ctx) { { warden: warden } }
+
+  before do
+    fake_class = Class.new
+    dm = stub_const('Devise::Mapping', fake_class, transfer_nested_constants: true)
+    allow(dm).to receive(:find_scope!).with(scope).and_return(scope)
+  end
+
+  context 'user signed in' do
+    before do
+      warden.set_user(user, scope: scope)
+    end
+
+    it 'expects to sign out user' do
+      sign_out_step.call(ctx, warden: warden)
+
+      expect(ctx[:current_user]).to be nil
+    end
+  end
+
+  context 'user not signed in' do
+    it 'expects to keep user signed out' do
+      sign_out_step.call(ctx, warden: warden)
+
+      expect(ctx[:current_user]).to be nil
+    end
+  end
+end

data/spec/lib/auth_spec.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+RSpec.describe Macros::Auth do
+  describe '#Authenticate()' do
+    it { expect(described_class::Authenticate()).to be_a described_class::Authenticate }
+  end
+
+  describe '#SignIn()' do
+    it { expect(described_class::SignIn()).to be_a described_class::SignIn }
+  end
+
+  describe '#SignOut()' do
+    it { expect(described_class::SignOut()).to be_a described_class::SignOut }
+  end
+end

data/spec/lib/contract/extract_params_spec.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+RSpec.describe Macros::Contract::ExtractParams do
+  subject(:extract_params_step) { described_class.new(params) }
+
+  let(:params) { { from: from } }
+
+  class self::UserForm < Reform::Form # rubocop:disable Style/ClassAndModuleChildren
+    property :password
+
+    def build_errors; end
+  end
+
+  let(:user) { stub_model(User) }
+  let(:contract) { self.class::UserForm.new(user) }
+  let(:scope) { :user }
+  let(:password) { '$3cr3t' }
+  let(:from) { :scope }
+  let(:ctx) { { scope: :user, params: { user: { password: password } } } }
+
+  it 'expects to set params in contract' do
+    extract_params_step.call(ctx, params: params)
+
+    expect(ctx['contract.default.params'][:password]).to eql password
+  end
+
+  context 'from key does not exist' do
+    let(:from) { :scoped_to }
+
+    it 'expects to fail and do not set any params in contract' do
+      expect(extract_params_step.call(ctx, params: params)).to eql false
+      expect(ctx['contract.default.params']).to be nil
+    end
+  end
+end

data/spec/lib/contract/prepopulate_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+RSpec.describe Macros::Contract::Prepopulate do
+  subject(:prepopulate_step) { described_class.new(options_key: options_key) }
+
+  class self::AlbumForm < Reform::Form # rubocop:disable Style/ClassAndModuleChildren
+    property :title
+
+    def build_errors; end
+  end
+
+  let(:album) { mock_model('Album', title: title) }
+  let(:contract) { self.class::AlbumForm.new(album) }
+
+  let(:ctx) { { 'contract.default' => contract, options_key => { title: new_title } } }
+
+  let(:options_key) { :params }
+
+  let(:title) { 'Lorem' }
+  let(:new_title) { 'Ipsum' }
+
+  it 'expects to prepopulate contract' do
+    expect(ctx['contract.default']).to receive(:prepopulate!).with(title: new_title)
+
+    prepopulate_step.call(ctx)
+  end
+end

data/spec/lib/contract_spec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+RSpec.describe Macros::Contract do
+  describe '#Prepopulate()' do
+    let(:options_key) { :foo }
+
+    it { expect(described_class::Prepopulate(options_key: options_key)).to be_a described_class::Prepopulate }
+  end
+
+  describe '#ExtractParams()' do
+    let(:from) { :scope }
+    it { expect(described_class::ExtractParams(from: from)).to be_a described_class::ExtractParams }
+  end
+end

data/spec/lib/ctx/copy_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+RSpec.describe Macros::Ctx::Copy do
+  subject(:copy_step) { described_class.new(origin_key, destination_key) }
+
+  let(:origin_key) { :foo }
+  let(:destination_key) { :bar }
+  let(:value) { :lorem }
+
+  let(:ctx) { { origin_key => value } }
+
+  it 'expects to copy origin value to destination one in ctx' do
+    copy_step.call(ctx)
+
+    expect(ctx[destination_key]).to eq value
+  end
+
+  context 'source key not present in ctx' do
+    let(:ctx) { { dolor: :se } }
+
+    it 'expects to keep destination value to be nil' do
+      copy_step.call(ctx)
+
+      expect(ctx[destination_key]).to be nil
+    end
+  end
+end

data/spec/lib/ctx/inspect_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+RSpec.describe Macros::Ctx::Inspect do
+  subject(:inspect_step) { described_class.new(key: key) }
+
+  let(:key) { :foo }
+  let(:value) { { lorem: :ipsum } }
+
+  let(:ctx) { { foo: value, dolor: :se } }
+
+  it 'expects to print only specified pair key and value' do
+    inspect_step.call(ctx)
+
+    expect { print(key => value) }.to output.to_stdout
+  end
+
+  context 'key not passed' do
+    let(:key) { nil }
+
+    it 'expects to print whole ctx' do
+      inspect_step.call(ctx)
+
+      expect { print(ctx) }.to output.to_stdout
+    end
+  end
+end

data/spec/lib/ctx/validate_presence_spec.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+RSpec.describe Macros::Ctx::ValidatePresence do
+  subject(:validate_presence_step) { described_class.new(key) }
+
+  let(:key) { :foo }
+  let(:ctx) { { foo: 'Lorem' } }
+
+  it 'expects to pass' do
+    expect(validate_presence_step.call(ctx)).to be true
+  end
+
+  context 'key does not exist' do
+    let(:key) { :bar }
+
+    it 'expects to fail' do
+      expect(validate_presence_step.call(ctx)).to be false
+    end
+  end
+end

data/spec/lib/ctx_spec.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+RSpec.describe Macros::Ctx do
+  let(:key) { :lorem }
+
+  describe '#Copy()' do
+    let(:destination_key) { :bar }
+
+    it { expect(described_class::Copy(key, destination_key)).to be_a described_class::Copy }
+  end
+
+  describe '#Inspect()' do
+    it { expect(described_class::Inspect(key: key)).to be_a described_class::Inspect }
+  end
+
+  describe '#ValidatePresence()' do
+    it { expect(described_class::ValidatePresence(key: key)).to be_a described_class::ValidatePresence }
+  end
+end

data/spec/lib/current_user.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+RSpec.describe Macros::CurrentUser do
+  describe '#Set()' do
+    it { expect(described_class::Set()).to be_a described_class::Set }
+  end
+end

data/spec/lib/current_user/set_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+RSpec.describe Macros::CurrentUser::Set do
+  subject(:set_step) { described_class.new }
+
+  let(:user) { mock_model('User') }
+  let(:ctx) { { model: user } }
+
+  it 'should set current user in ctx' do
+    set_step.call(ctx)
+
+    expect(ctx[:current_user]).to eql user
+  end
+
+  context 'model key does not exists in the context' do
+    let(:ctx) { { admin: user } }
+
+    it 'should not set current user in ctx' do
+      set_step.call(ctx)
+
+      expect(ctx[:current_user]).to be nil
+    end
+  end
+end

data/spec/lib/error/set_from_contract_spec.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+RSpec.describe Macros::Error::SetFromContract do
+  subject(:step) { described_class.new }
+
+  let(:ctx) do
+    { 'contract.default' => RecursiveOpenStruct.new(errors: { messages: { email: ["can't be blank"] } }) }
+  end
+
+  it 'should set error messages in context' do
+    result = step.call(ctx)
+
+    expect(result).to be true
+    expect(ctx[:error_messages][:email]).to include "can't be blank"
+  end
+
+  context 'contract errors not set' do
+    let(:ctx) { { 'contract.default' => RecursiveOpenStruct.new } }
+
+    it 'should not set any error messages' do
+      result = step.call(ctx)
+
+      expect(result).to be false
+      expect(ctx[:error_messages]).to be nil
+    end
+  end
+end

data/spec/lib/error_spec.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+RSpec.describe Macros::Error do
+  describe '#SetFromContract()' do
+    it { expect(described_class::SetFromContract()).to be_a described_class::SetFromContract }
+  end
+end

data/spec/lib/ff_tbl_macros_spec.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+RSpec.describe Macros do
+  subject(:macros) { described_class }
+
+  describe '#gem_root' do
+    it 'expect to point to root of the gem' do
+      expect(macros.gem_root).to eq File.expand_path('../..', __dir__)
+    end
+  end
+end

data/spec/lib/model/build_spec.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+RSpec.describe Macros::Model::Build do
+  subject(:build_step) { described_class.new(params) }
+
+  let(:params) { { from: from } }
+  let(:scope) { :foobar }
+  let(:from) { :scope }
+  let(:ctx) { { scope: scope } }
+
+  before do
+    mock_model('Foobar')
+  end
+
+  it 'should build model' do
+    build_step.call(ctx)
+
+    expect(ctx[:model].class.name).to eql 'Foobar'
+  end
+
+  context 'respond to passed in params' do
+    let(:params) { { from: from, respond_to: :loremised_by_id } }
+
+    context 'model responds to specified method' do
+      before do
+        allow_any_instance_of(Foobar).to receive(:loremised_by_id).and_return(rand)
+      end
+
+      it 'should build model' do
+        build_step.call(ctx)
+
+        expect(ctx[:model].class).to eql Foobar
+      end
+    end
+
+    context 'model do not respond to specified method' do
+      it 'should fail' do
+        expect(build_step.call(ctx)).to be false
+
+        expect(ctx[:model]).to be nil
+      end
+    end
+  end
+
+  context 'key does not exist in ctx' do
+    let(:ctx) { {} }
+
+    it 'should fail' do
+      expect(build_step.call(ctx)).to be false
+      expect(ctx[:model]).to be nil
+    end
+  end
+end

data/spec/lib/model/copy_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+RSpec.describe Macros::Model::Copy do
+  let(:user) { mock_model('User') }
+
+  let(:ctx) { { current_user: user } }
+  let(:ctx_key) { :current_user }
+
+  subject(:copy_step) { described_class.new(ctx_key) }
+
+  it 'expects to copy current user to ctx model' do
+    copy_step.call(ctx)
+
+    expect(ctx[:model]).to eq user
+  end
+
+  context 'source does not exist' do
+    let(:ctx_key) { :administrator }
+
+    it 'expects ctx model to keep nil' do
+      copy_step.call(ctx)
+
+      expect(ctx[:model]).to be nil
+    end
+  end
+end

data/spec/lib/model/destroy_spec.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+RSpec.describe Macros::Model::Destroy do
+  subject(:destroy_step) { described_class.new }
+
+  let(:ctx) { { model: user } }
+  let(:user) { mock_model('User', destroy: true, destroyed?: true) }
+
+  it 'expect to destroy model' do
+    destroy_step.call(ctx, model: user)
+    expect(ctx[:model].destroyed?).to be true
+  end
+end