snf_core 0.2.8 → 0.2.92

data/spec/requests/snf_core/auth_spec.rb

@@ -0,0 +1,139 @@
+require 'rails_helper'
+
+module SnfCore
+  RSpec.describe "Auth", type: :request do
+    let(:user) { create(:user, password: 'password123', password_changed: true) }
+    let(:role) { create(:role, name: 'User') }
+    let(:user_role) { create(:user_role, user: user, role: role) }
+    let(:valid_credentials) { { auth: { phone_number: user.phone_number, password: 'password123' } } }
+    let(:invalid_credentials) { { auth: { phone_number: user.phone_number, password: 'wrong_password' } } }
+
+    describe "POST /login" do
+      before { user_role }
+
+      context 'with valid credentials' do
+        it 'returns success with token' do
+          post '/snf_core/auth/login', params: valid_credentials
+          expect(response).to have_http_status(:success)
+          expect(json_response[:success]).to be true
+          expect(json_response[:token]).to be_present
+        end
+      end
+
+      context 'with invalid credentials' do
+        it 'returns unauthorized for wrong password' do
+          post '/snf_core/auth/login', params: invalid_credentials
+          expect(response).to have_http_status(:unauthorized)
+          expect(json_response[:success]).to be false
+          expect(json_response[:error]).to eq('Invalid email or password')
+        end
+
+        it 'returns unauthorized for non-existent user' do
+          post '/snf_core/auth/login', params: { auth: { phone_number: 'nonexistent', password: 'password123' } }
+          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
+
+        it 'returns unauthorized for user without password change' do
+          user.update(password_changed: false)
+          post '/snf_core/auth/login', params: valid_credentials
+          expect(response).to have_http_status(:unauthorized)
+          expect(json_response[:success]).to be false
+          expect(json_response[:warn]).to be true
+        end
+      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
+
+    private
+
+    def json_response
+      JSON.parse(response.body, symbolize_names: true)
+    end
+  end
+end

data/spec/sample_spec.rb

@@ -0,0 +1,5 @@
+RSpec.describe "Sample Spec" do
+  it "runs spec successfully" do
+    expect(1).to eq 1
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,36 @@
+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.formatter = RSpec::Core::Formatters::DocumentationFormatter
+
+  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.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

@@ -0,0 +1,49 @@
+module Scf
+  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

@@ -0,0 +1,130 @@
+module Scf
+  module Core
+    RSpec.shared_examples "request_shared_spec" do |controller, field_count, exclude = []|
+      include Scf::Core::Engine.routes.url_helpers
+
+      let(:factory) { controller.classify.underscore.to_sym }
+      let(:clazz) { "Scf::Core::#{controller.classify}".constantize }
+      let!(:user) { create(:user) }
+      let!(:headers) do
+        "token"
+      end
+
+      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