lesli 5.0.12 → 5.0.14

data/lib/rspec/helpers/response_request_helper.rb

@@ -0,0 +1,214 @@
+=begin
+    
+Lesli
+
+Copyright (c) 2023, Lesli Technologies, S. A.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program. If not, see http://www.gnu.org/licenses/.
+
+Lesli · Ruby on Rails Development Platform.
+
+Made with ♥ by https://www.lesli.tech
+Building a better future, one line of code at a time.
+
+@contact  hello@lesli.tech
+@website  https://www.lesli.tech
+@license  GPLv3 http://www.gnu.org/licenses/gpl-3.0.en.html
+
+// · ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~
+// ·     
+=end
+
+module ResponseRequestHelper
+
+    # container for the response body parsed as JSON
+    @@response_json = nil
+
+    # shortcut for response_json
+    def response_body
+        response_json
+    end
+
+    # return the body of a request response parsed as JSON
+    def response_json
+        # support empty responses from lesli 3 responder
+        _response_ = response.body.blank? ? "{}" : response.body
+        @@response_json = JSON.parse(_response_) if @@response_json.blank?
+        @@response_json
+    end
+
+    # test a standard successful response for lesli 3
+    def expect_response_with_successful
+        @@response_json = nil
+        expect(response).to have_http_status(:success)
+        expect(response.content_type).to eq("application/json; charset=utf-8")
+        response_json()
+    end
+
+    # test a standard successful response for lesli 3
+    def expect_response_with_pagination
+        @@response_json = nil
+
+        expect(response).to have_http_status(:success)
+        expect(response.content_type).to eq("application/json; charset=utf-8")
+
+        expect(response_json).to have_key("pagination")
+        expect(response_json["pagination"]).to be_an_instance_of(Hash)
+        expect(response_json["pagination"]).to have_key("pages")
+        expect(response_json["pagination"]).to have_key("page")
+        expect(response_json["pagination"]).to have_key("total")
+        expect(response_json["pagination"]).to have_key("results")
+        expect(response_json["pagination"]["pages"]).to be_an_instance_of(Integer)
+
+        expect(response_json).to have_key("records")
+        expect(response_json["records"]).to be_an_instance_of(Array)
+
+        expect(response_json["pagination"]["results"]).to eql(response_json["records"].size)
+
+        response_json()
+    end
+
+    # test a standard error response for lesli 3
+    def expect_response_with_action
+        @@response_json = nil
+        expect(response).to have_http_status(490)
+        expect(response.content_type).to eq('application/json; charset=utf-8')
+        expect(response_json).to be_an_instance_of(Hash)
+        expect(response_json).to have_key('message')
+        expect(response_json).to have_key('action')
+        expect(response_json["action"].keys.first).to be_in(['redirect'])
+
+        response_json()
+    end
+
+    # test a standard error response for lesli 3
+    def expect_response_with_error
+        @@response_json = nil
+        expect(response).to have_http_status(:bad_request)
+        expect(response.content_type).to eq('application/json; charset=utf-8')
+        expect(response_json).to be_an_instance_of(Hash)
+        expect(response_json).to have_key('message')
+        expect(response_json).to have_key('details')
+
+        response_json()
+    end
+
+    # test a standard not found response for lesli 3
+    def expect_response_with_not_found
+        @@response_json = nil
+        expect(response).to have_http_status(:not_found)
+        expect(response.content_type).to eq("application/json; charset=utf-8")
+    end
+
+    # test a standard unauthorized response for lesli 3
+    def expect_response_with_unauthorized
+        @@response_json = nil
+        expect(response).to have_http_status(:unauthorized)
+        expect(response.content_type).to eq("application/json; charset=utf-8")
+        expect(response_json).to have_key('message')
+    end
+
+    # function to expect a response with the given params
+    # example
+    # shared_expects validates the response body with the given arguments
+    # params
+    #   - response_body: the response to validate
+    #   - resquest_body: the payload that was sent to the server
+    #   - expected_response: the expected response is an array of hashes that contain the expected values
+    # example
+    #
+    # shared_expects(response_body, project, [
+    #     { key: "hexid", expected_type: "string" },
+    #     { key: "payment_period", expected_type: "string", expected_value: "no_information" },
+    #     { key: "payment_amount", expected_type: "string", expected_value: "0.0" },
+    #     { key: "payment_amount", expected_type: "string", expected_value: "0.0", or_be_nil: true },
+    #     { key: "quality", expected_type: "integer" },
+    #     { key: "main_file_id", expected_type: "nil" }
+    # ])
+    def shared_expects(response_body, request_body, expected_attrs)
+        expect(response_body).to be_an(Object)
+
+        # iterate over the expected attributes
+        expected_attrs.each do |expected_attr|
+
+            # verify if response has specific attribute
+            expect(response_body).to have_key(expected_attr[:key])
+
+            # verify if response attribute has the expected value type
+            case expected_attr[:expected_type]
+                when "boolean", "bool"
+                    expect(response_body[expected_attr[:key]]).to be_in([true, false]), "expected '#{expected_attr[:key]}' to be a kind of Boolean, but is '#{response_body[expected_attr[:key]].class}'" unless expected_attr[:or_be_nil]
+                    expect(response_body[expected_attr[:key]]).to be_in([true, false]).or(be_nil), "expected '#{expected_attr[:key]}' to be a kind of Boolean or nil, but is '#{response_body[expected_attr[:key]].class}'"
+                when "string", "str"
+                    expect(response_body[expected_attr[:key]]).to be_a(String), "expected '#{expected_attr[:key]}' to be a kind of String, but is '#{response_body[expected_attr[:key]].class}'" unless expected_attr[:or_be_nil]
+                    expect(response_body[expected_attr[:key]]).to be_a(String).or(be_nil), "expected '#{expected_attr[:key]}' to be a kind of String or nil, but is '#{response_body[expected_attr[:key]].class}'"
+                when "integer", "int"
+                    expect(response_body[expected_attr[:key]]).to be_an(Integer), "expected '#{expected_attr[:key]}' to be a kind of Integer, but is '#{response_body[expected_attr[:key]].class}'" unless expected_attr[:or_be_nil]
+                    expect(response_body[expected_attr[:key]]).to be_an(Integer).or(be_nil), "expected '#{expected_attr[:key]}' to be a kind of Integer or nil, but is '#{response_body[expected_attr[:key]].class}'"
+                when "float"
+                    expect(response_body[expected_attr[:key]]).to be_a(Float), "expected '#{expected_attr[:key]}' to be a kind of Float, but is '#{response_body[expected_attr[:key]].class}'" unless expected_attr[:or_be_nil]
+                    expect(response_body[expected_attr[:key]]).to be_a(Float).or(be_nil), "expected '#{expected_attr[:key]}' to be a kind of Float or nil, but is '#{response_body[expected_attr[:key]].class}'"
+                when "nil"
+                    expect(response_body[expected_attr[:key]]).to be_nil
+                when "array"
+                    expect(response_body[expected_attr[:key]]).to be_an_instance_of(Array), "expected '#{expected_attr[:key]}' to be a kind of Array, but is '#{response_body[expected_attr[:key]].class}'" unless expected_attr[:or_be_nil]
+                    expect(response_body[expected_attr[:key]]).to be_an_instance_of(Array).or(be_nil), "expected '#{expected_attr[:key]}' to be a kind of Array or nil, but is '#{response_body[expected_attr[:key]].class}'"
+                when "hash"
+                    expect(response_body[expected_attr[:key]]).to be_an_instance_of(Hash), "expected '#{expected_attr[:key]}' to be a kind of Hash, but is '#{response_body[expected_attr[:key]].class}'" unless expected_attr[:or_be_nil]
+                    expect(response_body[expected_attr[:key]]).to be_an_instance_of(Hash).or(be_nil), "expected '#{expected_attr[:key]}' to be a kind of Hash or nil, but is '#{response_body[expected_attr[:key]].class}'"
+                when "object"
+                    expect(response_body[expected_attr[:key]]).to be_an(Object), "expected '#{expected_attr[:key]}' to be a kind of Object, but is '#{response_body[expected_attr[:key]].class}'" unless expected_attr[:or_be_nil]
+                    expect(response_body[expected_attr[:key]]).to be_an(Object).or(be_nil), "expected '#{expected_attr[:key]}' to be a kind of Object or nil, but is '#{response_body[expected_attr[:key]].class}'"
+            end
+
+            # verify if response value is equal to the expected value
+            if expected_attr[:expected_value].present?
+                expect(response_body[expected_attr[:key]]).to eq(expected_attr[:expected_value]) unless expected_attr[:or_be_nil]
+                expect(response_body[expected_attr[:key]]).to eq(expected_attr[:expected_value]).or be_nil
+            end
+
+            # verify if response value is equal to request value
+            if request_body[expected_attr[:key]].present?
+                expect(response_body[expected_attr[:key]]).to eq(request_body[expected_attr[:key]])
+            end
+        end
+    end
+
+    # test a response that contains a xlsx file
+    def expect_response_with_xlsx
+        @@response_json = nil
+        expect(response).to have_http_status(:success)
+
+        # In the case of Excel files the response has a specific content type
+        # And it's up the version, so we have two posibilities
+        expect(response.content_type).to be_in([
+            "application/vnd.ms-excel",
+            "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet" # For Excel2007 and above
+        ])
+    end
+
+    # test a response that contains a PDF file
+    def expect_response_with_pdf
+        @@response_json = nil
+        expect(response).to have_http_status(:success)
+        expect(response.content_type).to eq("application/pdf")
+    end
+    
+    
+    def expect_to_be_redirected
+        @@response_json = nil
+        expect(response).to have_http_status(:redirect)
+    end
+
+end

data/lib/rspec/helpers/response_service_helper.rb

@@ -0,0 +1,66 @@
+=begin
+    
+Lesli
+
+Copyright (c) 2023, Lesli Technologies, S. A.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program. If not, see http://www.gnu.org/licenses/.
+
+Lesli · Ruby on Rails Development Platform.
+
+Made with ♥ by https://www.lesli.tech
+Building a better future, one line of code at a time.
+
+@contact  hello@lesli.tech
+@website  https://www.lesli.tech
+@license  GPLv3 http://www.gnu.org/licenses/gpl-3.0.en.html
+
+// · ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~
+// ·     
+=end
+
+module ServiceResponseHelpers
+
+    # container for the response body parsed as JSON
+    @@service_response = nil
+
+    def service_response_body
+        @@service_response
+    end
+
+    # test a standard successful response
+    def expect_service_response_with_successful(response)
+        @@service_response = nil
+        expect(response.success?).to eq(true)
+        expect(response.successful?).to eq(true)
+
+        # If the response is successful, the payload could be present, but the error should be nil
+        expect(response.error).to be_nil
+
+        @@service_response = response.payload
+    end
+
+    # test a standard error response
+    def expect_service_response_with_error(response)
+        @@service_response = nil
+        expect(response.success?).to eq(false)
+        expect(response.successful?).to eq(false)
+
+        # If the response is not successful, the error could be present, but the payload should be nil
+        expect(response.payload).to be_nil
+
+        @@service_response = response.error
+    end
+
+end

data/lib/rspec/helpers/spec_helper.rb

@@ -0,0 +1,99 @@
+# This file was generated by the `rails generate rspec:install` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+
+RSpec.configure do |config|
+    # rspec-expectations config goes here. You can use an alternate
+    # assertion/expectation library such as wrong or the stdlib/minitest
+    # assertions if you prefer.
+    config.expect_with :rspec do |expectations|
+        # This option will default to `true` in RSpec 4. It makes the `description`
+        # and `failure_message` of custom matchers include text for helper methods
+        # defined using `chain`, e.g.:
+        #     be_bigger_than(2).and_smaller_than(4).description
+        #     # => "be bigger than 2 and smaller than 4"
+        # ...rather than:
+        #     # => "be bigger than 2"
+        expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+    end
+
+    # rspec-mocks config goes here. You can use an alternate test double
+    # library (such as bogus or mocha) by changing the `mock_with` option here.
+    config.mock_with :rspec do |mocks|
+        # Prevents you from mocking or stubbing a method that does not exist on
+        # a real object. This is generally recommended, and will default to
+        # `true` in RSpec 4.
+        mocks.verify_partial_doubles = true
+    end
+
+    # This option will default to `:apply_to_host_groups` in RSpec 4 (and will
+    # have no way to turn it off -- the option exists only for backwards
+    # compatibility in RSpec 3). It causes shared context metadata to be
+    # inherited by the metadata hash of host groups and examples, rather than
+    # triggering implicit auto-inclusion in groups with matching metadata.
+    config.shared_context_metadata_behavior = :apply_to_host_groups
+
+    # The settings below are suggested to provide a good initial experience
+    # with RSpec, but feel free to customize to your heart's content.
+=begin
+    # This allows you to limit a spec run to individual examples or groups
+    # you care about by tagging them with `:focus` metadata. When nothing
+    # is tagged with `:focus`, all examples get run. RSpec also provides
+    # aliases for `it`, `describe`, and `context` that include `:focus`
+    # metadata: `fit`, `fdescribe` and `fcontext`, respectively.
+    config.filter_run_when_matching :focus
+
+    # Allows RSpec to persist some state between runs in order to support
+    # the `--only-failures` and `--next-failure` CLI options. We recommend
+    # you configure your source control system to ignore this file.
+    config.example_status_persistence_file_path = "spec/examples.txt"
+
+    # Limits the available syntax to the non-monkey patched syntax that is
+    # recommended. For more details, see:
+    #   - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
+    #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+    #   - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
+    config.disable_monkey_patching!
+
+    # Many RSpec users commonly either run the entire suite or an individual
+    # file, and it's useful to allow more verbose output when running an
+    # individual spec file.
+    if config.files_to_run.one?
+        # Use the documentation formatter for detailed output,
+        # unless a formatter has already been configured
+        # (e.g. via a command-line flag).
+        config.default_formatter = "doc"
+    end
+
+    # Print the 10 slowest examples and example groups at the
+    # end of the spec run, to help surface which specs are running
+    # particularly slow.
+    config.profile_examples = 10
+
+    # Seed global randomization in this process using the `--seed` CLI option.
+    # Setting this allows you to use `--seed` to deterministically reproduce
+    # test failures related to randomization by passing the same `--seed` value
+    # as the one that triggered the failure.
+    Kernel.srand config.seed
+=end
+
+    # Run specs in random order to surface order dependencies. If you find an
+    # order dependency and want to debug it, you can fix the order by providing
+    # the seed, which is printed after each run.
+    #     --seed 1234
+    #config.order = :random
+
+end
+

data/lib/rspec/lesli_api_tester.rb

@@ -0,0 +1,133 @@
+=begin
+    
+Lesli
+
+Copyright (c) 2023, Lesli Technologies, S. A.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program. If not, see http://www.gnu.org/licenses/.
+
+Lesli · Ruby on Rails Development Platform.
+
+Made with ♥ by https://www.lesli.tech
+Building a better future, one line of code at a time.
+
+@contact  hello@lesli.tech
+@website  https://www.lesli.tech
+@license  GPLv3 http://www.gnu.org/licenses/gpl-3.0.en.html
+
+// · ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~
+// ·     
+=end
+
+require "faker"
+require "rails_helper"
+require "support/helpers/response_helper"
+
+
+# · Authentication context
+RSpec.shared_context "request api authentication" do
+
+    password = Rails.application.config.lesli.dig(:security, :password)
+    password = password + Time.now.year.to_s + "$"
+
+    @token = nil
+
+    # Creates a new valid user session
+    before(:each) do
+        @query = {
+            search: "",
+            filters: {},
+            pagination: {
+                perPage: 15,
+                page: 1,
+                order: "desc",
+                orderBy: "id",
+                orderColumn: "id"
+            }
+        }
+
+        @current_user = User.first
+
+        if @token.blank?
+
+            # get JWT for api authentication
+            post('/api/v2.0/auth/login', params: {
+                "email": @current_user.email,
+                "password": password,
+                "source": "rspec_tests"
+            })
+
+            @token = JSON.parse(response.body).dig("token")
+
+        end
+
+    end
+
+    # Overwrite get method to include authorization headers
+    def get(path, params:nil, headers:nil)
+
+        # push authorization headers
+        headers ||= {'Authorization' => "Bearer #{ @token }"}
+
+        # execute base get method with our custom headers
+        super(path, :params => params, :headers => headers)
+
+    end
+
+    # Overwrite post method to include authorization headers
+    def post(path, params:nil, headers:nil)
+
+        if path == '/api/users/authentication'
+            super(path, :params => params)
+            return 0
+        end
+
+        # push authorization headers
+        headers ||= {'Authorization' => "Bearer #{ @token }"}
+
+        # execute base post method with our custom headers
+        super(path, :params => params, :headers => headers)
+
+    end
+
+    # Overwrite delete method to include authorization headers
+    def delete(path, params:nil, headers:nil)
+        # add authorization headers
+        headers ||= { "Authorization" => "Bearer #{ @token }" }
+
+        # execute base delete request with our custom headers
+        super(path, :params => params, :headers => headers)
+    end
+
+    # Overwrite put method to include authorization headers
+    def put(path, params:nil, headers:nil)
+        # add authorization headers
+        headers ||= { "Authorization" => "Bearer #{ @token }" }
+
+        # execute base put request with our custom headers
+        super(path, :params => params, :headers => headers)
+    end
+end
+
+
+# · Configuration
+RSpec.configure do |config|
+
+    # Include devise helpers to be able to login on test runtime
+    config.include Devise::Test::IntegrationHelpers
+
+    # Include helper methods
+    config.include ResponseHelpers
+
+end

data/lib/rspec/lesli_service_tester.rb

@@ -0,0 +1,46 @@
+=begin
+    
+Lesli
+
+Copyright (c) 2023, Lesli Technologies, S. A.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program. If not, see http://www.gnu.org/licenses/.
+
+Lesli · Ruby on Rails Development Platform.
+
+Made with ♥ by https://www.lesli.tech
+Building a better future, one line of code at a time.
+
+@contact  hello@lesli.tech
+@website  https://www.lesli.tech
+@license  GPLv3 http://www.gnu.org/licenses/gpl-3.0.en.html
+
+// · ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~
+// ·     
+=end
+
+
+require "faker"
+require "support/config/rails_helper"
+require "support/helpers/service_response_helper"
+
+
+# · Configuration
+RSpec.configure do |config|
+
+    # Include helper methods
+    config.include ServiceResponseHelpers
+    config.include LesliHelper
+
+end

data/{db/tables/0010001410_create_account_files.rb → lib/rspec/testers/controller.rb}

@@ -1,5 +1,5 @@
 =begin
-
+    
 Lesli
 
 Copyright (c) 2023, Lesli Technologies, S. A.
@@ -27,26 +27,37 @@ Building a better future, one line of code at a time.
 @license  GPLv3 http://www.gnu.org/licenses/gpl-3.0.en.html
 
 // · ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~
-// ·
+// ·     
 =end
 
-class CreateAccountFiles < ActiveRecord::Migration[6.1]
-    def change
-        # table_base_structure = JSON.parse(File.read(Rails.root.join("db","structure","00000006_files.json")))
-
-        gem_path = Lesli::System.engine("lesli")
-        table_base_structure = JSON.parse(File.read(File.join(gem_path, "db", "structure", "00000006_files.json")))
-        create_table :account_files do |t|
-            table_base_structure.each do |column|
-                t.send(
-                    column["type"].parameterize.underscore.to_sym,
-                    column["name"].parameterize.underscore.to_sym
-                )
-            end
-            t.timestamps
-        end
-
-        add_reference(:account_files, :user, foreign_key: { to_table: :users })
-        add_reference(:account_files, :account, foreign_key: { to_table: :accounts })
+
+require Lesli::Engine.root.join("spec/support/helpers/rails_helper")
+require Lesli::Engine.root.join("spec/support/helpers/lesli_helper")
+require Lesli::Engine.root.join("spec/support/helpers/response_request_helper")
+
+
+# · Authentication context
+RSpec.shared_context "controller user authentication" do 
+
+    # Creates a new valid user session
+    before :each do
+        #request.env["HTTP_ACCEPT"] = 'application/json'
+        request.env["devise.mapping"] = Devise.mappings[:user]
+        @current_user = User.first
+        sign_in(@current_user)
     end
+
+end
+
+
+# · Configuration
+RSpec.configure do |config|
+
+    # Include devise helpers to be able to login on test runtime
+    config.include Devise::Test::IntegrationHelpers
+    config.include Devise::Test::ControllerHelpers, type: :controller
+
+    # Include helper methods 
+    config.include ResponseRequestHelper
+
 end

data/lib/rspec/testers/model.rb

@@ -0,0 +1,36 @@
+=begin
+    
+Lesli
+
+Copyright (c) 2023, Lesli Technologies, S. A.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program. If not, see http://www.gnu.org/licenses/.
+
+Lesli · Ruby on Rails Development Platform.
+
+Made with ♥ by https://www.lesli.tech
+Building a better future, one line of code at a time.
+
+@contact  hello@lesli.tech
+@website  https://www.lesli.tech
+@license  GPLv3 http://www.gnu.org/licenses/gpl-3.0.en.html
+
+// · ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~     ~·~
+// ·     
+=end
+
+
+require Lesli::Engine.root.join("lib/rspec/helpers/rails_helper")
+require Lesli::Engine.root.join("lib/rspec/helpers/lesli_helper")
+require Lesli::Engine.root.join("lib/rspec/helpers/response_request_helper")