lesli 5.0.13 → 5.0.14

data/lib/rspec/helpers/rails_helper.rb

@@ -0,0 +1,134 @@
+=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
+
+
+# ·
+ENV["RAILS_ENV"] ||= "test"
+
+
+# Prevent database truncation if the environment is production
+abort("The Rails environment is running in production mode!") if Rails.env.production?
+
+
+# ·
+require "L2"
+require "faker"
+require "rspec/rails"
+require Lesli::Engine.root.join("lib/rspec/helpers/spec_helper")
+require Lesli::Engine.root.join("lib/rspec/config/spec_coverage")
+
+
+# ·
+Dir.glob(Lesli::Engine.root.join("lib/rspec/factories/*.rb")).sort.each do |factory|
+    require_dependency factory
+end
+
+
+# Add additional requires below this line. Rails is not loaded until this point!
+
+# Requires supporting ruby files with custom matchers and macros, etc, in
+# lib/rspec/ and its subdirectories. Files matching `spec/**/*_spec.rb` are
+# run as spec files by default. This means that files in lib/rspec that end
+# in _spec.rb will both be required and run as specs, causing the specs to be
+# run twice. It is recommended that you do not name files matching this glob to
+# end with _spec.rb. You can configure this pattern with the --pattern
+# option on the command line or in ~/.rspec, .rspec or `.rspec-local`.
+#
+# The following line is provided for convenience purposes. It has the downside
+# of increasing the boot-up time by auto-requiring all files in the support
+# directory. Alternatively, in the individual `*_spec.rb` files, manually
+# require only the support files necessary.
+#
+# Dir[Rails.root.join('spec', 'support', '**', '*.rb')].each { |f| require f }
+
+# This is not require as we use an updated version of the database and the schema is always up to date
+
+# Checks for pending migrations and applies them before tests are run.
+# If you are not using ActiveRecord, you can remove these lines.
+# begin
+#     ActiveRecord::Migration.maintain_test_schema!
+# rescue ActiveRecord::PendingMigrationError => e
+#     abort e.to_s.strip
+# end
+
+
+# ·
+RSpec.configure do |config|
+    
+    # Remove this line if you're not using ActiveRecord or ActiveRecord fixtures
+    #config.fixture_path = "#{::Rails.root}/spec/fixtures"
+    #config.fixture_paths << "#{::Rails.root}/spec/fixtures"
+
+    # If you're not using ActiveRecord, or you'd prefer not to run each of your
+    # examples within a transaction, remove the following line or assign false
+    # instead of true.
+    config.use_transactional_fixtures = false
+
+    # RSpec Rails can automatically mix in different behaviours to your tests
+    # based on their file location, for example enabling you to call `get` and
+    # `post` in specs under `spec/controllers`.
+    #
+    # You can disable this behaviour by removing the line below, and instead
+    # explicitly tag your specs with their type, e.g.:
+    #
+    #     RSpec.describe UsersController, :type => :controller do
+    #       # ...
+    #     end
+    #
+    # The different available types are documented in the features, such as in
+    # https://relishapp.com/rspec/rspec-rails/docs
+    config.infer_spec_type_from_file_location!
+
+    # Filter lines from Rails gems in backtraces.
+    config.filter_rails_from_backtrace!
+    # arbitrary gems may also be filtered via:
+    # config.filter_gems_from_backtrace("gem name")
+
+end
+
+
+# ·
+L2.br(2)
+
+
+# Notify to user...
+L2.info(
+    "Running RSpec tests...", 
+    "For a better result run test over a clean database", 
+    "You can use rake dev:db:reset test before rspec."
+)
+
+# Check if index of controllers exists (needed for authorization)
+if Lesli::SystemController.count <= 0
+    L2.msg "Building controllers index..."
+    Lesli::ControllerOperator.new.build 
+end

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