commons_yellowme 0.11.0 → 0.15.0

data/lib/commons/services/concerns/callable.rb

@@ -5,8 +5,13 @@ module Commons
         extend ActiveSupport::Concern
 
         class_methods do
-          def call(*args)
-            new(*args).call
+          def call(*args, **kwargs)
+            # This approach allows thge class initializer to use regular arguments,
+            # named argumets or the mix of both.
+            # This at the same time allows the usage of Dry::Initializer
+            # https://dry-rb.org/gems/dry-initializer/3.0/
+            # And perhaps this can eventually be a defualt part of Callable Module
+            new(*args, **kwargs).call
           end
         end
       end

data/lib/commons/version.rb

@@ -1,3 +1,3 @@
 module Commons
-  VERSION = '0.11.0'
+  VERSION = '0.15.0'.freeze
 end

data/spec/commons/authentication/authenticate_by_jwt_spec.rb

@@ -0,0 +1,37 @@
+RSpec.describe Commons::Authentication::AuthenticateByJWT, type: :request do
+  describe 'when calling /misc/application_parameters' do
+    context 'raises error as an unauthenticated user' do
+      subject do
+        get "/misc/application_parameters",
+            params: {}.to_json,
+            headers: {
+              'content-type': 'application/json'
+            }
+        response
+      end
+
+      it do
+        is_expected.to have_http_status(:unauthorized)
+      end
+    end
+
+    context 'works ok as an authenticated user' do
+      let(:user) { create(:user) }
+      let(:jwt) { Commons::Authentication::JSONWebToken.encode(user_id: user.id) }
+
+      subject do
+        get "/misc/application_parameters",
+            params: {}.to_json,
+            headers: {
+              'content-type': 'application/json',
+              'Authorization': 'Bearer ' + jwt
+            }
+        response
+      end
+
+      it do
+        is_expected.to have_http_status(:ok)
+      end
+    end
+  end
+end

data/spec/commons/authentication/json_web_token_spec.rb

@@ -0,0 +1,41 @@
+RSpec.describe Commons::Authentication::JSONWebToken do
+  let(:user) { create(:user) }
+  let(:exp) { 24.hours.from_now }
+  let(:jwt) { Commons::Authentication::JSONWebToken.encode({ user_id: user.id }, exp) }
+
+  describe 'decode' do
+    subject { Commons::Authentication::JSONWebToken.decode(jwt) }
+
+    context 'works ok' do
+      it do
+        expect { subject }.not_to raise_error
+        expect(subject[:user_id]).not_to be_nil
+        expect(subject[:expires_at]).not_to be_nil
+        expect(subject[:user_id]).to eq user.id
+        expect(subject[:expires_at]).to eq exp.to_i
+      end
+    end
+
+    context 'raises error when invalid' do
+      let(:jwt) { Faker::Name.last_name }
+      it do
+        expect { subject }.to raise_error JWT::DecodeError
+      end
+    end
+  end
+
+  describe 'encode' do
+    subject { Commons::Authentication::JSONWebToken.encode({ user_id: user.id }, exp) }
+
+    context 'works ok' do
+      it { expect { subject }.not_to raise_error }
+      it do
+        token = Commons::Authentication::JSONWebToken.decode(subject)
+        expect(token[:user_id]).not_to be_nil
+        expect(token[:user_id]).to eq user.id
+        expect(token[:expires_at]).not_to be_nil
+        expect(token[:expires_at]).to eq exp.to_i
+      end
+    end
+  end
+end

data/spec/commons/concerns/attributes/sex_spec.rb

@@ -0,0 +1,24 @@
+RSpec.describe Commons::Concerns::Attributes::Sex do
+  let(:sex) { Commons::Concerns::Attributes::Sex::FEMALE }
+  let(:user) { build(:user, name: 'rosa del barrio', last_name: 'hernandez', sex: sex) }
+
+  subject do
+    user
+  end
+
+  describe 'works ok!' do
+    it 'when valid data' do
+      expect(subject.sex).to eq sex
+      expect(subject.female_sex?).to be true
+    end
+  end
+
+  describe 'fails' do
+    subject do
+      user = User.new(sex: 'sex')
+    end
+    it 'when invalid sex' do
+      expect{ subject }.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/commons/concerns/extensions/deleted_spec.rb

@@ -0,0 +1,40 @@
+RSpec.describe Commons::Concerns::Extensions::SoftDeleted do
+  let(:user) { create(:user) }
+
+  subject do
+    user
+  end
+
+  describe 'works ok!' do
+    it 'when existing user' do
+      expect(subject.deleted?).to eq false
+    end
+
+    it 'when existing user allows save' do
+      subject.name = Faker::Name.first_name
+      expect{ subject.save }.not_to raise_error
+    end
+
+    it 'when deleted user' do
+      # given
+      user = subject
+      user = UserRepository.instance.destroy!(user)
+      # do
+      expect(user.deleted?).to eq true
+    end
+
+    it 'when deleted user denies save' do
+      # given
+      user = subject
+      user = UserRepository.instance.destroy!(user)
+      user.name = Faker::Name.first_name
+      # do
+      expect{ user.save }.to raise_error(ActiveRecord::RecordInvalid)
+    end
+
+    it 'when model is not soft_deletable' do
+      # do
+      expect{ Employee.new }.to raise_error(ActiveModel::MissingAttributeError)
+    end
+  end
+end

data/spec/commons/concerns/guard/capitalizable_spec.rb

@@ -0,0 +1,13 @@
+RSpec.describe Commons::Concerns::Guard::Capitalizable do
+  let(:user) { build(:user, name: 'rosa del barrio', last_name: 'hernandez') }
+
+  subject do
+    user.valid?
+    user
+  end
+
+  it 'works ok!' do
+    expect(subject.name).to eq 'Rosa del Barrio'
+    expect(subject.last_name).to eq 'hernandez'
+  end
+end

data/spec/commons/concerns/validations/undestroyable_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+RSpec.describe Commons::Concerns::Validations::Undestroyable do
+  let(:user) { create(:user) }
+
+  it 'works ok!' do
+    expect { user.destroy }.to raise_error Commons::Errors::Unauthorized
+  end
+end

data/spec/commons/errors/bad_request_spec.rb

@@ -0,0 +1,62 @@
+describe Commons::Errors::BadRequest do
+  describe 'handle_error' do
+    context 'works with no message or validation_errors' do
+      it do
+        expect do
+          raise described_class
+        end.to raise_error(described_class)
+      end
+    end
+
+    context 'default values works ok' do
+      subject { described_class.new }
+
+      it do
+        expect do
+          raise subject
+        end.to raise_error(described_class)
+      end
+      it { expect(subject.detail).to eq I18n.t('status_code.IER4003_bad_request.detail') }
+    end
+
+    context 'works with message but no validation_errors' do
+      let(:message) { 'my totally non-existent message' }
+
+      subject { described_class.new(message) }
+
+      it do
+        expect do
+          raise subject
+        end.to raise_error(described_class)
+      end
+      it { expect(subject.message).to eq message }
+    end
+
+    context 'works with message & validation_errors' do
+      let(:message) { 'my totally non-existent message' }
+      let(:detail) { { errors: 'my totally non-existent error' } }
+
+      subject { described_class.new(message, nil, detail: detail) }
+
+      it do
+        expect do
+          raise subject
+        end.to raise_error(described_class)
+      end
+      it { expect(subject.detail).to eq detail }
+    end
+
+    context 'works with message & backtrace' do
+      let(:message) { 'my totally non-existent message' }
+
+      subject { described_class.new(message, [message]) }
+
+      it do
+        expect do
+          raise subject
+        end.to raise_error(described_class)
+      end
+      it { expect(subject.backtrace).to eq [message] }
+    end
+  end
+end

data/spec/commons/errors/conflict_spec.rb

@@ -0,0 +1,62 @@
+describe Commons::Errors::Conflict do
+  describe 'handle_error' do
+    context 'works with no message or validation_errors' do
+      it do
+        expect do
+          raise described_class
+        end.to raise_error(described_class)
+      end
+    end
+
+    context 'default values works ok' do
+      subject { described_class.new }
+
+      it do
+        expect do
+          raise subject
+        end.to raise_error(described_class)
+      end
+      it { expect(subject.detail).to eq I18n.t('status_code.IER4004_conflict.detail') }
+    end
+
+    context 'works with message but no validation_errors' do
+      let(:message) { 'my totally non-existent message' }
+
+      subject { described_class.new(message) }
+
+      it do
+        expect do
+          raise subject
+        end.to raise_error(described_class)
+      end
+      it { expect(subject.message).to eq message }
+    end
+
+    context 'works with message & validation_errors' do
+      let(:message) { 'my totally non-existent message' }
+      let(:detail) { { errors: 'my totally non-existent error' } }
+
+      subject { described_class.new(message, nil, detail: detail) }
+
+      it do
+        expect do
+          raise subject
+        end.to raise_error(described_class)
+      end
+      it { expect(subject.detail).to eq detail }
+    end
+
+    context 'works with message & backtrace' do
+      let(:message) { 'my totally non-existent message' }
+
+      subject { described_class.new(message, [message]) }
+
+      it do
+        expect do
+          raise subject
+        end.to raise_error(described_class)
+      end
+      it { expect(subject.backtrace).to eq [message] }
+    end
+  end
+end

data/spec/commons/errors/forbidden_spec.rb

@@ -0,0 +1,62 @@
+describe Commons::Errors::Forbidden do
+  describe 'handle_error' do
+    context 'works with no message or validation_errors' do
+      it do
+        expect do
+          raise described_class
+        end.to raise_error(described_class)
+      end
+    end
+
+    context 'default values works ok' do
+      subject { described_class.new }
+
+      it do
+        expect do
+          raise subject
+        end.to raise_error(described_class)
+      end
+      it { expect(subject.detail).to eq I18n.t('status_code.IER4005_forbidden.detail') }
+    end
+
+    context 'works with message but no validation_errors' do
+      let(:message) { 'my totally non-existent message' }
+
+      subject { described_class.new(message) }
+
+      it do
+        expect do
+          raise subject
+        end.to raise_error(described_class)
+      end
+      it { expect(subject.message).to eq message }
+    end
+
+    context 'works with message & validation_errors' do
+      let(:message) { 'my totally non-existent message' }
+      let(:detail) { { errors: 'my totally non-existent error' } }
+
+      subject { described_class.new(message, nil, detail: detail) }
+
+      it do
+        expect do
+          raise subject
+        end.to raise_error(described_class)
+      end
+      it { expect(subject.detail).to eq detail }
+    end
+
+    context 'works with message & backtrace' do
+      let(:message) { 'my totally non-existent message' }
+
+      subject { described_class.new(message, [message]) }
+
+      it do
+        expect do
+          raise subject
+        end.to raise_error(described_class)
+      end
+      it { expect(subject.backtrace).to eq [message] }
+    end
+  end
+end

data/spec/commons/errors/internal_server_error_spec.rb

@@ -0,0 +1,62 @@
+describe Commons::Errors::InternalServerError do
+  describe 'handle_error' do
+    context 'works with no message or validation_errors' do
+      it do
+        expect do
+          raise described_class
+        end.to raise_error(described_class)
+      end
+    end
+
+    context 'default values works ok' do
+      subject { described_class.new }
+
+      it do
+        expect do
+          raise subject
+        end.to raise_error(described_class)
+      end
+      it { expect(subject.detail).to eq I18n.t('status_code.IER5000_internal_server_error.detail') }
+    end
+
+    context 'works with message but no validation_errors' do
+      let(:message) { 'my totally non-existent message' }
+
+      subject { described_class.new(message) }
+
+      it do
+        expect do
+          raise subject
+        end.to raise_error(described_class)
+      end
+      it { expect(subject.message).to eq message }
+    end
+
+    context 'works with message & validation_errors' do
+      let(:message) { 'my totally non-existent message' }
+      let(:detail) { { errors: 'my totally non-existent error' } }
+
+      subject { described_class.new(message, nil, detail: detail) }
+
+      it do
+        expect do
+          raise subject
+        end.to raise_error(described_class)
+      end
+      it { expect(subject.detail).to eq detail }
+    end
+
+    context 'works with message & backtrace' do
+      let(:message) { 'my totally non-existent message' }
+
+      subject { described_class.new(message, [message]) }
+
+      it do
+        expect do
+          raise subject
+        end.to raise_error(described_class)
+      end
+      it { expect(subject.backtrace).to eq [message] }
+    end
+  end
+end