snf_core 0.2.94 → 0.2.97

data/spec/models/snf_core/quotation_spec.rb

@@ -0,0 +1,54 @@
+require 'rails_helper'
+
+module SnfCore
+  RSpec.describe Quotation, type: :model do
+    include ActiveSupport::Testing::TimeHelpers
+
+    attributes = [
+      { item_request: :belong_to },
+      { price: [ :presence, :numericality ] },
+      { valid_until: :presence },
+      { delivery_date: :presence },
+      { status: :presence }
+    ]
+    include_examples("model_shared_spec", :quotation, attributes)
+
+    describe 'validations' do
+      it 'validates price is greater than 0' do
+        quotation = build(:quotation, price: 0)
+        expect(quotation).not_to be_valid
+        expect(quotation.errors[:price]).to include('must be greater than 0')
+      end
+
+      it 'validates valid_until is not in the past for new records' do
+        quotation = build(:quotation, valid_until: DateTime.yesterday)
+        expect(quotation).not_to be_valid
+        expect(quotation.errors[:valid_until]).to include("can't be in the past")
+      end
+
+      it 'validates delivery_date is not in the past' do
+        quotation = build(:quotation, delivery_date: Date.yesterday)
+        expect(quotation).not_to be_valid
+        expect(quotation.errors[:delivery_date]).to include("can't be in the past")
+      end
+    end
+
+    describe 'status management' do
+      let(:quotation) { create(:quotation) }
+
+      it 'starts with pending status' do
+        expect(quotation.status).to eq('pending')
+      end
+
+      it 'allows valid status transitions' do
+        valid_statuses = [ :pending, :accepted, :rejected, :expired ]
+        valid_statuses.each do |status|
+          quotation.status = status
+          expect(quotation).to be_valid
+        end
+      end
+    end
+
+
+  end
+end

data/spec/models/snf_core/user_spec.rb

@@ -1,22 +1,18 @@
-require 'rails_helper'
-
-module SnfCore
-  RSpec.describe User, type: :model do
-    attributes = [
-      { first_name: :presence },
-      { middle_name: :presence },
-      { last_name: :presence },
-      { phone_number: %i[presence uniqueness] }
-    ]
-    include_examples("model_shared_spec", :user, attributes)
-
-    describe 'wallet creation' do
-      it 'creates a wallet automatically for the user' do
-        user = create(:user)
-        expect(user.wallet).to be_present
-        expect(user.wallet.balance).to eq(0.0)
-        expect(user.wallet.is_active).to be_truthy
-      end
-    end
-  end
-end
+require 'rails_helper'
+
+module SnfCore
+  RSpec.describe User, type: :model do
+    attributes = [
+      { first_name: :presence },
+      { middle_name: :presence },
+      { last_name: :presence },
+      { address: :belong_to },
+      { date_of_birth: :presence },
+      { nationality: :presence },
+      { phone_number: %i[presence uniqueness] }
+    ]
+    include_examples("model_shared_spec", :user, attributes)
+
+    it { is_expected.to belong_to(:verified_by).class_name('User').optional }
+  end
+end

data/spec/models/snf_core/virtual_account_spec.rb

@@ -0,0 +1,85 @@
+require 'rails_helper'
+
+module SnfCore
+  RSpec.describe VirtualAccount, type: :model do
+    attributes = [
+      { user: :belong_to },
+      { account_number: %i[presence] },
+      { cbs_account_number: %i[presence uniqueness] },
+      { balance: %i[presence numericality] },
+      { interest_rate: %i[presence numericality] },
+      { interest_type: :presence },
+      { branch_code: :presence },
+      { product_scheme: :presence },
+      { voucher_type: :presence },
+      { active: :presence }
+    ]
+    include_examples("model_shared_spec", :virtual_account, attributes)
+
+    describe 'validations' do
+      it 'validates interest_rate is between 0 and 1' do
+        virtual_account = build(:virtual_account, interest_rate: 1.5)
+        expect(virtual_account).not_to be_valid
+        expect(virtual_account.errors[:interest_rate]).to include('must be less than or equal to 1')
+      end
+
+      it 'validates branch_code length is 3' do
+        virtual_account = build(:virtual_account, branch_code: '1234')
+        expect(virtual_account).not_to be_valid
+        expect(virtual_account.errors[:branch_code]).to include('is the wrong length (should be 3 characters)')
+      end
+
+      it 'validates product_scheme length is 1' do
+        virtual_account = build(:virtual_account, product_scheme: '12')
+        expect(virtual_account).not_to be_valid
+        expect(virtual_account.errors[:product_scheme]).to include('is the wrong length (should be 1 character)')
+      end
+
+      it 'validates voucher_type length is 1' do
+        virtual_account = build(:virtual_account, voucher_type: '12')
+        expect(virtual_account).not_to be_valid
+        expect(virtual_account.errors[:voucher_type]).to include('is the wrong length (should be 1 character)')
+      end
+
+      it 'validates account_number uniqueness case sensitively' do
+        existing_account = create(:virtual_account)
+        new_account = build(:virtual_account, account_number: existing_account.account_number)
+
+        expect(new_account).not_to be_valid
+        expect(new_account.errors[:account_number]).to include('has already been taken')
+      end
+
+      it 'validates account_number format' do
+        virtual_account = build(:virtual_account, account_number: '12345678901')
+        expect(virtual_account.account_number).to match(/\A\d{3}\d\d\d{6}\z/)
+      end
+    end
+
+    describe 'account_number generation' do
+      it 'generates account number before validation' do
+        virtual_account = create(:virtual_account)
+        expect(virtual_account.account_number).to be_present
+        expect(virtual_account.account_number).to match(/\A\d{3}\d\d\d{6}\z/)
+      end
+
+      it 'uses branch_code, product_scheme, and voucher_type in account number' do
+        virtual_account = create(:virtual_account,
+          branch_code: '002',
+          product_scheme: '3',
+          voucher_type: '5'
+        )
+        expect(virtual_account.account_number).to start_with('00235')
+      end
+
+      it 'increments sequence number for each new account' 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 be > first_seq
+      end
+    end
+  end
+end

data/spec/models/snf_core/virtual_account_transaction_spec.rb

@@ -0,0 +1,72 @@
+require 'rails_helper'
+
+module SnfCore
+  RSpec.describe VirtualAccountTransaction, type: :model do
+    attributes = [
+      { amount: %i[presence numericality] },
+      { reference_number: %i[presence uniqueness] },
+      { transaction_type: :presence },
+      { status: :presence }
+    ]
+    include_examples("model_shared_spec", :virtual_account_transaction, attributes)
+
+    describe 'validations' do
+      describe 'transaction type validations' do
+        it 'requires both accounts for transfer' do
+          transaction = build(:virtual_account_transaction, :transfer, from_account: nil)
+          expect(transaction).not_to be_valid
+          expect(transaction.errors[:base]).to include('Transfer requires both from and to accounts')
+        end
+
+        it 'requires to_account for deposit' do
+          transaction = build(:virtual_account_transaction, :deposit, to_account: nil)
+          expect(transaction).not_to be_valid
+          expect(transaction.errors[:base]).to include('Deposit requires to_account')
+        end
+
+        it 'requires from_account for withdrawal' do
+          transaction = build(:virtual_account_transaction, :withdrawal, from_account: nil)
+          expect(transaction).not_to be_valid
+          expect(transaction.errors[:base]).to include('Withdrawal requires from_account')
+        end
+
+        it 'prevents transfer to same account' do
+          account = create(:virtual_account)
+          transaction = build(:virtual_account_transaction, from_account: account, to_account: account)
+          expect(transaction).not_to be_valid
+          expect(transaction.errors[:base]).to include('Cannot transfer to same account')
+        end
+      end
+
+      describe 'balance validation' do
+        it 'validates sufficient balance for transfer' do
+          from_account = create(:virtual_account, balance: 100)
+          transaction = build(:virtual_account_transaction,
+            from_account: from_account,
+            amount: 150
+          )
+          expect(transaction).not_to be_valid
+          expect(transaction.errors[:amount]).to include('Insufficient balance')
+        end
+
+        it 'validates sufficient balance for withdrawal' do
+          from_account = create(:virtual_account, balance: 100)
+          transaction = build(:virtual_account_transaction, :withdrawal,
+            from_account: from_account,
+            amount: 150
+          )
+          expect(transaction).not_to be_valid
+          expect(transaction.errors[:amount]).to include('Insufficient balance')
+        end
+      end
+    end
+
+    describe 'transaction types' do
+      it { is_expected.to define_enum_for(:transaction_type).with_values(transfer: 0, deposit: 1, withdrawal: 2) }
+    end
+
+    describe 'status types' do
+      it { is_expected.to define_enum_for(:status).with_values(pending: 0, completed: 1, failed: 2, reversed: 3) }
+    end
+  end
+end

data/spec/requests/snf_core/auth_spec.rb

@@ -17,7 +17,17 @@ module SnfCore
           password: Faker::Internet.password(min_length: 8),
           business_name: Faker::Company.name,
           tin_number: Faker::Company.ein,
-          business_type: "retailer"        }
+          business_type: "retailer",
+          date_of_birth: Date.today,
+          gender: "male",
+          verified_at: DateTime.now,
+          verified_by_id: nil,
+          address_id: create(:address).id,
+          nationality: Faker::Address.country,
+          occupation: Faker::Job.title,
+          source_of_funds: "Salary",
+          kyc_status: "pending"
+        }
       }
     end
 
@@ -58,90 +68,6 @@ module SnfCore
       end
     end
 
-    describe "POST /reset_password_request" do
-      context 'with invalid email' do
-        it 'returns error for non-existent user' do
-          post '/snf_core/auth/reset_password_request', params: { auth: { email: 'nonexistent@email.com' } }
-          expect(response).to have_http_status(:unauthorized)
-          expect(json_response[:success]).to be false
-          expect(json_response[:error]).to eq("User doesn't exist")
-        end
-      end
-    end
-
-    describe "POST /reset_password" do
-      let(:reset_token) { SecureRandom.hex }
-      before { user.update(reset_password_token: reset_token) }
-
-      context 'with valid token' do
-        it 'successfully resets password' do
-          post '/snf_core/auth/reset_password', params: {
-            auth: {
-              reset_password_token: reset_token,
-              password: 'new_password123'
-            }
-          }
-
-          expect(response).to have_http_status(:success)
-          expect(json_response[:success]).to be true
-          expect(user.reload.reset_password_token).to be_nil
-          expect(user.password_changed).to be true
-        end
-      end
-
-      context 'with invalid token' do
-        it 'returns error for invalid token' do
-          post '/snf_core/auth/reset_password', params: {
-            auth: {
-              reset_password_token: 'invalid_token',
-              password: 'new_password123'
-            }
-          }
-
-          expect(response).to have_http_status(:unauthorized)
-          expect(json_response[:success]).to be false
-        end
-      end
-    end
-
-    describe "POST /change_password" do
-      let(:auth_token) { TokenService.new.encode({ user: user.as_json, role: role.name }) }
-
-      before do
-        allow_any_instance_of(ApplicationController).to receive(:current_user).and_return(user)
-      end
-
-      context 'with valid current password' do
-        it 'successfully changes password' do
-          post '/snf_core/auth/change_password', params: {
-            auth: {
-              password: 'password123',
-              new_password: 'new_password123'
-            }
-          }, headers: { 'Authorization': "Bearer #{auth_token}" }
-
-          expect(response).to have_http_status(:success)
-          expect(json_response[:success]).to be true
-          expect(user.reload.password_changed).to be true
-        end
-      end
-
-      context 'with invalid current password' do
-        it 'returns error for wrong current password' do
-          post '/snf_core/auth/change_password', params: {
-            auth: {
-              password: 'wrong_password',
-              new_password: 'new_password123'
-            }
-          }, headers: { 'Authorization': "Bearer #{auth_token}" }
-
-          expect(response).to have_http_status(:success)
-          expect(json_response[:success]).to be false
-          expect(json_response[:error]).to eq('Invalid password')
-        end
-      end
-    end
-
 
     describe "POST /signup" do
       context 'with valid parameters' do