bscf-core 0.1.0

data/spec/dummy/config/puma.rb

@@ -0,0 +1,38 @@
+# This configuration file will be evaluated by Puma. The top-level methods that
+# are invoked here are part of Puma's configuration DSL. For more information
+# about methods provided by the DSL, see https://puma.io/puma/Puma/DSL.html.
+#
+# Puma starts a configurable number of processes (workers) and each process
+# serves each request in a thread from an internal thread pool.
+#
+# You can control the number of workers using ENV["WEB_CONCURRENCY"]. You
+# should only set this value when you want to run 2 or more workers. The
+# default is already 1.
+#
+# The ideal number of threads per worker depends both on how much time the
+# application spends waiting for IO operations and on how much you wish to
+# prioritize throughput over latency.
+#
+# As a rule of thumb, increasing the number of threads will increase how much
+# traffic a given process can handle (throughput), but due to CRuby's
+# Global VM Lock (GVL) it has diminishing returns and will degrade the
+# response time (latency) of the application.
+#
+# The default is set to 3 threads as it's deemed a decent compromise between
+# throughput and latency for the average Rails application.
+#
+# Any libraries that use a connection pool or another resource pool should
+# be configured to provide at least as many connections as the number of
+# threads. This includes Active Record's `pool` parameter in `database.yml`.
+threads_count = ENV.fetch("RAILS_MAX_THREADS", 3)
+threads threads_count, threads_count
+
+# Specifies the `port` that Puma will listen on to receive requests; default is 3000.
+port ENV.fetch("PORT", 3000)
+
+# Allow puma to be restarted by `bin/rails restart` command.
+plugin :tmp_restart
+
+# Specify the PID file. Defaults to tmp/pids/server.pid in development.
+# In other environments, only set the PID file if requested.
+pidfile ENV["PIDFILE"] if ENV["PIDFILE"]

data/spec/dummy/config/routes.rb

@@ -0,0 +1,3 @@
+Rails.application.routes.draw do
+  mount Bscf::Core::Engine => "/bscf-core"
+end

data/spec/dummy/config/storage.yml

@@ -0,0 +1,34 @@
+test:
+  service: Disk
+  root: <%= Rails.root.join("tmp/storage") %>
+
+local:
+  service: Disk
+  root: <%= Rails.root.join("storage") %>
+
+# Use bin/rails credentials:edit to set the AWS secrets (as aws:access_key_id|secret_access_key)
+# amazon:
+#   service: S3
+#   access_key_id: <%= Rails.application.credentials.dig(:aws, :access_key_id) %>
+#   secret_access_key: <%= Rails.application.credentials.dig(:aws, :secret_access_key) %>
+#   region: us-east-1
+#   bucket: your_own_bucket-<%= Rails.env %>
+
+# Remember not to checkin your GCS keyfile to a repository
+# google:
+#   service: GCS
+#   project: your_project
+#   credentials: <%= Rails.root.join("path/to/gcs.keyfile") %>
+#   bucket: your_own_bucket-<%= Rails.env %>
+
+# Use bin/rails credentials:edit to set the Azure Storage secret (as azure_storage:storage_access_key)
+# microsoft:
+#   service: AzureStorage
+#   storage_account_name: your_account_name
+#   storage_access_key: <%= Rails.application.credentials.dig(:azure_storage, :storage_access_key) %>
+#   container: your_container_name-<%= Rails.env %>
+
+# mirror:
+#   service: Mirror
+#   primary: local
+#   mirrors: [ amazon, google, microsoft ]

data/spec/dummy/config.ru

@@ -0,0 +1,6 @@
+# This file is used by Rack-based servers to start the application.
+
+require_relative "config/environment"
+
+run Rails.application
+Rails.application.load_server

data/spec/dummy/log/development.log

@@ -0,0 +1,17 @@
+  SQL (10.8ms)  SET search_path TO public /*application='Dummy'*/
+   (722.5ms)  CREATE DATABASE "bscf_dev" ENCODING = 'unicode' /*application='Dummy'*/
+  SQL (0.1ms)  SET search_path TO public /*application='Dummy'*/
+   (105.0ms)  CREATE DATABASE "bscf_test" ENCODING = 'unicode' /*application='Dummy'*/
+   (26.1ms)  CREATE TABLE "schema_migrations" ("version" character varying NOT NULL PRIMARY KEY) /*application='Dummy'*/
+   (4.5ms)  CREATE TABLE "ar_internal_metadata" ("key" character varying NOT NULL PRIMARY KEY, "value" character varying, "created_at" timestamp(6) NOT NULL, "updated_at" timestamp(6) NOT NULL) /*application='Dummy'*/
+   (0.2ms)  SELECT pg_try_advisory_lock(7136077842679658775) /*application='Dummy'*/
+  ActiveRecord::SchemaMigration Load (1.0ms)  SELECT "schema_migrations"."version" FROM "schema_migrations" ORDER BY "schema_migrations"."version" ASC /*application='Dummy'*/
+  ActiveRecord::InternalMetadata Load (3.4ms)  SELECT * FROM "ar_internal_metadata" WHERE "ar_internal_metadata"."key" = 'environment' ORDER BY "ar_internal_metadata"."key" ASC LIMIT 1 /*application='Dummy'*/
+  ActiveRecord::InternalMetadata Create (1.7ms)  INSERT INTO "ar_internal_metadata" ("key", "value", "created_at", "updated_at") VALUES ('environment', 'development', '2025-03-24 13:19:53.793527', '2025-03-24 13:19:53.793529') RETURNING "key" /*application='Dummy'*/
+Migrating to CreateBscfCorePeople (20250324131935)
+  TRANSACTION (0.1ms)  BEGIN /*application='Dummy'*/
+   (9.7ms)  CREATE TABLE "bscf_core_people" ("id" bigserial primary key, "name" character varying, "created_at" timestamp(6) NOT NULL, "updated_at" timestamp(6) NOT NULL) /*application='Dummy'*/
+  ActiveRecord::SchemaMigration Create (0.5ms)  INSERT INTO "schema_migrations" ("version") VALUES ('20250324131935') RETURNING "version" /*application='Dummy'*/
+  TRANSACTION (1.4ms)  COMMIT /*application='Dummy'*/
+   (0.6ms)  SELECT pg_advisory_unlock(7136077842679658775) /*application='Dummy'*/
+  ActiveRecord::SchemaMigration Load (0.3ms)  SELECT "schema_migrations"."version" FROM "schema_migrations" ORDER BY "schema_migrations"."version" ASC /*application='Dummy'*/

data/spec/dummy/tmp/local_secret.txt

@@ -0,0 +1 @@
+3a22c82420f040930f412554d7919569ed231f0c16026a0795faffcbd126ec78eccdd546cacca4a594cfb3770ba0380c4da0352d5af1c3b7483f2f35bdff4ed0

data/spec/examples.txt

@@ -0,0 +1,3 @@
+example_id                 | status | run_time        |
+-------------------------- | ------ | --------------- |
+./spec/sample_spec.rb[1:1] | passed | 0.00068 seconds |

data/spec/rails_helper.rb

@@ -0,0 +1,46 @@
+# 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

@@ -0,0 +1,34 @@
+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.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 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

@@ -0,0 +1,126 @@
+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