bscf-core 0.2.0 → 0.2.1

data/spec/models/bscf/core/virtual_account_spec.rb

@@ -1,111 +0,0 @@
-require 'rails_helper'
-
-module Bscf
-  module Core
-    RSpec.describe VirtualAccount, type: :model do
-      attributes = [
-        { account_number: %i[presence uniqueness] },
-        { cbs_account_number: %i[presence uniqueness] },
-        { balance: [ :presence, :numericality ] },
-        { interest_rate: [ :presence, :numericality ] },
-        { interest_type: :presence },
-        { branch_code: :presence },
-        { product_scheme: [ :presence ] },
-        { voucher_type: [ :presence ] },
-        { status: :presence },
-        { user: :belong_to }
-      ]
-
-      include_examples("model_shared_spec", :virtual_account, attributes)
-
-      it { should validate_numericality_of(:balance).is_greater_than_or_equal_to(0) }
-      it { should validate_numericality_of(:interest_rate).is_greater_than_or_equal_to(0) }
-      it { should validate_inclusion_of(:product_scheme).in_array(VirtualAccount::PRODUCT_SCHEMES) }
-      it { should validate_inclusion_of(:voucher_type).in_array(VirtualAccount::VOUCHER_TYPES) }
-
-      describe 'scopes' do
-        let!(:active_account) { create(:virtual_account, :active_status) }
-        let!(:pending_account) { create(:virtual_account) }
-        let!(:savings_account) { create(:virtual_account) }
-        let!(:current_account) { create(:virtual_account, :current_account) }
-        let!(:loan_account) { create(:virtual_account, :loan_account) }
-
-        it 'filters active accounts' do
-          expect(described_class.active_accounts).to include(active_account)
-          expect(described_class.active_accounts).not_to include(pending_account)
-        end
-
-        it 'filters by branch' do
-          expect(described_class.by_branch('BR001')).to include(active_account)
-        end
-
-        it 'filters by product scheme' do
-          expect(described_class.by_product('SAVINGS')).to include(savings_account)
-          expect(described_class.by_product('SAVINGS')).not_to include(current_account)
-          expect(described_class.by_product('CURRENT')).to include(current_account)
-          expect(described_class.by_product('LOAN')).to include(loan_account)
-        end
-      end
-
-      describe '#generate_account_number' do
-        let(:virtual_account) { build(:virtual_account) }
-
-        it 'generates account number on create' do
-          expect(virtual_account.account_number).to be_nil
-          virtual_account.save
-          expect(virtual_account.account_number).to be_present
-          expect(virtual_account.account_number).to match(/\ABR001SAVINGSREGULAR\d{6}\z/)
-        end
-
-        it 'maintains existing account number' do
-          existing_number = 'BR001SAVINGSREGULAR000001'
-          virtual_account.account_number = existing_number
-          virtual_account.save
-          expect(virtual_account.account_number).to eq(existing_number)
-        end
-
-        it 'increments sequence number' do
-          first_account = create(:virtual_account)
-          second_account = create(:virtual_account)
-
-          first_seq = first_account.account_number[-6..-1].to_i
-          second_seq = second_account.account_number[-6..-1].to_i
-
-          expect(second_seq).to eq(first_seq + 1)
-        end
-      end
-
-      describe 'interest types' do
-        it 'supports simple interest' do
-          account = build(:virtual_account)
-          expect(account.interest_type).to eq('simple')
-        end
-
-        it 'supports compound interest' do
-          account = build(:virtual_account, :compound_interest)
-          expect(account.interest_type).to eq('compound')
-        end
-      end
-
-      describe 'account types' do
-        it 'creates savings account by default' do
-          account = create(:virtual_account)
-          expect(account.product_scheme).to eq('SAVINGS')
-          expect(account.interest_rate).to eq(2.5)
-        end
-
-        it 'creates current account' do
-          account = create(:virtual_account, :current_account)
-          expect(account.product_scheme).to eq('CURRENT')
-          expect(account.interest_rate).to eq(0.0)
-        end
-
-        it 'creates loan account' do
-          account = create(:virtual_account, :loan_account)
-          expect(account.product_scheme).to eq('LOAN')
-          expect(account.interest_rate).to eq(12.5)
-        end
-      end
-    end
-  end
-end

data/spec/models/bscf/core/virtual_account_transaction_spec.rb

@@ -1,133 +0,0 @@
-require 'rails_helper'
-
-module Bscf
-  module Core
-    RSpec.describe VirtualAccountTransaction, type: :model do
-      attributes = [
-        { amount: [ :presence, :numericality ] },
-        { transaction_type: :presence },
-        { status: :presence },
-        { reference_number: [ :presence, :uniqueness ] }
-      ]
-
-      include_examples("model_shared_spec", :virtual_account_transaction, attributes)
-
-      describe 'validations' do
-        it { should validate_numericality_of(:amount).is_greater_than(0) }
-      end
-
-      describe 'enums' do
-        it { should define_enum_for(:transaction_type).with_values(transfer: 0, deposit: 1, withdrawal: 2) }
-        it { should define_enum_for(:status).with_values(pending: 0, completed: 1, failed: 2, cancelled: 3) }
-      end
-
-      describe '#generate_reference_number' do
-        let(:transaction) { build(:virtual_account_transaction) }
-
-        it 'generates reference number before validation on create' do
-          transaction.save
-          expect(transaction.reference_number).to be_present
-          expect(transaction.reference_number).to match(/\ATXN\d{14}[0-9a-f]{6}\z/)
-        end
-
-        it 'does not override existing reference number' do
-          existing_ref = 'TXN20230101123456abc123'
-          transaction.reference_number = existing_ref
-          transaction.save
-          expect(transaction.reference_number).to eq(existing_ref)
-        end
-      end
-
-      describe 'transaction processing' do
-        let(:from_account) { create(:virtual_account, balance: 1000.00, status: :active) }
-        let(:to_account) { create(:virtual_account, balance: 500.00, status: :active) }
-        let(:transaction) do
-          build(:virtual_account_transaction,
-                from_account: from_account,
-                to_account: to_account,
-                amount: 300.00)
-        end
-
-        context 'when processing transfer' do
-          it 'updates account balances on successful transfer' do
-            expect(transaction.save).to be true
-            expect(transaction.process!).to be true
-
-            expect(from_account.reload.balance.round(2)).to eq(700.00)
-            expect(to_account.reload.balance.round(2)).to eq(800.00)
-            expect(transaction.reload.status).to eq('completed')
-          end
-
-          it 'validates sufficient balance' do
-            transaction.amount = 2000.00
-            expect(transaction.save).to be false
-            expect(transaction.errors[:from_account]).to include('insufficient balance')
-          end
-
-          it 'validates account status' do
-            from_account.update!(status: :suspended)
-            expect(transaction.save).to be false
-            expect(transaction.errors[:from_account]).to include('must be active')
-          end
-        end
-
-        context 'when processing deposit' do
-          let(:transaction) do
-            build(:virtual_account_transaction, :deposit,
-                  to_account: to_account,
-                  amount: 300.00)
-          end
-
-          it 'updates recipient account balance' do
-            expect(transaction.save).to be true
-            expect(transaction.process!).to be true
-
-            expect(to_account.reload.balance.round(2)).to eq(800.00)
-            expect(transaction.reload.status).to eq('completed')
-          end
-
-          it 'validates recipient account status' do
-            to_account.update!(status: :suspended)
-            expect(transaction.save).to be false
-            expect(transaction.errors[:to_account]).to include('must be active')
-          end
-        end
-
-        context 'when processing withdrawal' do
-          let(:transaction) do
-            build(:virtual_account_transaction, :withdrawal,
-                  from_account: from_account,
-                  amount: 300.00)
-          end
-
-          it 'updates source account balance' do
-            expect(transaction.save).to be true
-            expect(transaction.process!).to be true
-
-            expect(from_account.reload.balance.round(2)).to eq(700.00)
-            expect(transaction.reload.status).to eq('completed')
-          end
-
-          it 'validates source account status' do
-            from_account.update!(status: :suspended)
-            expect(transaction.save).to be false
-            expect(transaction.errors[:from_account]).to include('must be active')
-          end
-        end
-      end
-
-      describe '#cancel!' do
-        it 'cancels pending transaction' do
-          transaction = create(:virtual_account_transaction)
-          expect(transaction.cancel!).to be true
-          expect(transaction.status).to eq('cancelled')
-        end
-
-        it 'cannot cancel completed transaction' do
-          transaction = create(:virtual_account_transaction, :completed)
-          expect(transaction.cancel!).to be false
-        end
-      end
-    end
-  end
-end

data/spec/rails_helper.rb

@@ -1,46 +0,0 @@
-# This file is copied to spec/ when you run 'rails generate rspec:install'
-require "spec_helper"
-ENV["RAILS_ENV"] ||= "test"
-require_relative "../spec/dummy/config/environment"
-abort("The Rails environment is running in production mode!") if Rails.env.production?
-
-require "rspec/rails"
-require "database_cleaner/active_record"
-require "factory_bot_rails"
-require "faker"
-require "shoulda-matchers"
-
-begin
-  ActiveRecord::Migration.maintain_test_schema!
-rescue ActiveRecord::PendingMigrationError => e
-  abort e.to_s.strip
-end
-
-RSpec.configure do |config|
-  config.before(:suite) do
-    DatabaseCleaner.strategy = :transaction
-    DatabaseCleaner.clean_with(:truncation)
-  end
-
-  config.before do
-    DatabaseCleaner.strategy = :transaction
-    DatabaseCleaner.start
-  end
-
-  config.append_after do
-    DatabaseCleaner.clean
-  end
-
-  config.fixture_path = "#{::Rails.root}/spec/fixtures"
-  config.use_transactional_fixtures = true
-  config.infer_spec_type_from_file_location!
-  config.filter_rails_from_backtrace!
-  config.include FactoryBot::Syntax::Methods
-end
-
-Shoulda::Matchers.configure do |config|
-  config.integrate do |with|
-    with.test_framework(:rspec)
-    with.library(:rails)
-  end
-end

data/spec/spec_helper.rb

@@ -1,37 +0,0 @@
-require "simplecov"
-require "./spec/support/models/shared_examples"
-# require "./spec/support/requests/shared_requests"
-require "rspec/retry"
-
-RSpec.configure do |config|
-  config.expect_with :rspec do |expectations|
-    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
-  end
-
-  config.mock_with :rspec do |mocks|
-    mocks.verify_partial_doubles = true
-  end
-
-  config.shared_context_metadata_behavior = :apply_to_host_groups
-  config.example_status_persistence_file_path = "spec/examples.txt"
-  config.disable_monkey_patching!
-
-  config.formatter = RSpec::Core::Formatters::DocumentationFormatter
-
-  config.profile_examples = 10
-  config.order = :random
-  Kernel.srand config.seed
-
-  config.verbose_retry = true
-  config.display_try_failure_messages = true
-  config.around :each, :js do |ex|
-    ex.run_with_retry retry: 3
-  end
-end
-
-SimpleCov.start("rails") do
-  add_filter("/lib/")
-  add_filter("/bin/")
-  add_filter("/db/")
-  add_filter("/spec/")
-end

data/spec/support/models/shared_examples.rb

@@ -1,49 +0,0 @@
-module Bscf
-  module Core
-    VALIDATIONS = {
-      presence: "validate_presence_of",
-      uniqueness: "validate_uniqueness_of",
-      numericality: "validate_numericality_of",
-      inclusion: "validate_inclusion_of",
-      belong_to: "belong_to",
-      have_many: "have_many",
-      have_and_belong_to_many: "have_and_belong_to_many",
-      have_one: "have_one",
-      delegate: "delegate_method"
-    }.freeze
-
-    RSpec.shared_examples "model_shared_spec" do |factory, attribs, subj = true|
-      subject { create(factory) } if subj
-
-      it "has a valid factory" do
-        expect(create(factory)).to be_valid
-      end
-
-      attribs.each do |attr|
-        attr.each do |k, v|
-          if v.instance_of?(Array)
-            v.each do |validation|
-              if validation.instance_of?(Hash)
-                method = validation.keys[0]
-                options = validation.values[0]
-                it {
-                  expect(subject).to(
-                    options.inject(
-                      send(VALIDATIONS[method], k)
-                    ) do |o, p|
-                      p[1].nil? ? o.send(p[0]) : o.send(p[0], p[1])
-                    end
-                  )
-                }
-              else
-                it { is_expected.to(send(VALIDATIONS[validation], k)) }
-              end
-            end
-          else
-            it { is_expected.to(send(VALIDATIONS[v], k)) }
-          end
-        end
-      end
-    end
-  end
-end

data/spec/support/requests/shared_requests.rb

@@ -1,126 +0,0 @@
-module Bscf
-  module Core
-    RSpec.shared_examples "request_shared_spec" do |controller, field_count, exclude = []|
-      include Comee::Core::Engine.routes.url_helpers
-
-      let(:factory) { controller.classify.underscore.to_sym }
-      let(:clazz) { "Bscf::Core::#{controller.classify}".constantize }
-
-      unless exclude.include?(:index)
-        describe "GET /index" do
-          it "returns success response" do
-            count = clazz.count
-            3.times { create(factory) }
-            get(send("#{controller}_url"), headers: headers)
-            expect(response).to be_successful
-            result = JSON(response.body)
-
-            expect(result["success"]).to be_truthy
-            expect(result["data"].count - count).to eq 3
-          end
-        end
-      end
-
-      unless exclude.include?(:show)
-        describe "GET /show" do
-          it "returns a success response" do
-            obj = create(factory)
-            get(send("#{controller.singularize}_url", obj), headers: headers)
-            expect(response).to be_successful
-            result = JSON(response.body)
-            expect(result["success"]).to be_truthy
-            expect(result["data"].count).to eq field_count
-            expect(result["data"]["id"]).to eq obj.id
-          end
-        end
-      end
-
-      unless exclude.include?(:create)
-        describe "POST /create" do
-          context "with valid params" do
-            it "creates a new object" do
-              params = { payload: valid_attributes }
-              expect do
-                post(
-                  send("#{controller}_url"),
-                  headers: headers,
-                  params: params,
-                  as: :json
-                )
-              end.to change(clazz, :count).by(1)
-              expect(response).to have_http_status(:created)
-              expect(response.content_type).to eq("application/json; charset=utf-8")
-
-              result = JSON(response.body)
-              expect(result["success"]).to be_truthy
-            end
-          end
-
-          context "with invalid params" do
-            it "renders a JSON response with errors for the new object" do
-              params = { payload: invalid_attributes }
-              post(
-                send("#{controller}_url"),
-                params: params,
-                headers: headers,
-                as: :json
-              )
-
-              expect(response).to have_http_status(422)
-              expect(response.content_type).to eq("application/json; charset=utf-8")
-
-              result = JSON(response.body)
-              expect(result["success"]).to be_falsey
-              expect(result["error"]).not_to be_blank
-            end
-          end
-        end
-      end
-
-      unless exclude.include?(:update)
-        describe "PUT /update" do
-          context "with valid params" do
-            it "updates the requested object" do
-              obj = create(factory)
-              params = { id: obj.to_param, payload: new_attributes }
-              put(
-                send("#{controller.singularize}_url", obj),
-                headers: headers,
-                params: params, as: :json
-              )
-              obj.reload
-
-              expect(response).to have_http_status(:ok)
-              expect(obj.send(new_attributes.keys[0])).to eq new_attributes.values[0]
-              expect(response.content_type).to eq("application/json; charset=utf-8")
-
-              result = JSON(response.body)
-              expect(result["success"]).to be_truthy
-              expect(result["data"]["id"]).to eq obj.id
-            end
-          end
-
-          context "with invalid params" do
-            it "renders a JSON response with errors for the object" do
-              obj = create(factory)
-              params = { id: obj.to_param, payload: invalid_attributes }
-              put(
-                send("#{controller.singularize}_url", obj),
-                headers: headers,
-                params: params,
-                as: :json
-              )
-
-              expect(response).to have_http_status(422)
-              expect(response.content_type).to eq("application/json; charset=utf-8")
-
-              result = JSON(response.body)
-              expect(result["success"]).to be_falsey
-              expect(result["error"]).not_to be_blank
-            end
-          end
-        end
-      end
-    end
-  end
-end