beyond_the_api_test_helpers 0.0.1

data/lib/beyond_the_api_test_helpers/request/destroy_assertions.rb

@@ -0,0 +1,67 @@
+module BeyondTheApiTestHelpers
+  module Request
+    module DestroyAssertions
+      def assert_request_destroy_valid(url, options = {})
+        request_instance_variables_set options
+        if required_login
+          assert_request_needs_to_be_logged(url, :delete)
+          @headers.merge!(logged_in_headers)
+        end
+
+        assert_i18n_for_all_locales do
+          do_destroy_request_with_transaction(url)
+        end
+      end
+
+      def assert_request_destroy_not_found(urls_not_found, options = {})
+        request_instance_variables_set options
+        @headers.merge!(logged_in_headers) if required_login
+
+        urls_not_found.each do |url_not_found|
+          assert_request_destroy_not_found_i18n_all(url_not_found)
+        end
+      end
+
+      private
+
+      def do_destroy_request_with_transaction(url)
+        ActiveRecord::Base.transaction do
+          do_destroy_request_and_assert(url)
+          Redis.current.flushdb if @flush_redis_db_between_i18n_tests
+          raise ActiveRecord::Rollback
+        end
+      end
+
+      # :reek:DuplicateMethodCall: { max_calls: 2 }
+      def do_destroy_request_and_assert(url)
+        subject_id = subject.id unless @skip_destroyed_validate
+        delete(url, params: @params, headers: @headers)
+        response_assertions(status: 200)
+        assert_destroyed(subject_id) unless @skip_destroyed_validate
+        assert_equal I18n.t(*@message), json['success']
+      end
+
+      def assert_destroyed(subject_id)
+        if subject.respond_to? :deleted_at
+          assert_not_nil subject.reload.deleted_at
+        elsif subject.respond_to? :active
+          assert_active_destroyed
+        else
+          klass = @klass || subject.class
+          assert_equal false, klass.exists?(subject_id)
+        end
+      end
+
+      def assert_active_destroyed
+        assert_equal false, subject.reload.active?
+      end
+
+      def assert_request_destroy_not_found_i18n_all(url_not_found)
+        assert_i18n_for_all_locales do
+          delete(url_not_found, params: @params, headers: @headers)
+          assert_not_found_request
+        end
+      end
+    end
+  end
+end

data/lib/beyond_the_api_test_helpers/request/helpers.rb

@@ -0,0 +1,45 @@
+module BeyondTheApiTestHelpers
+  module Request
+    module Helpers
+
+      def api_url
+        '/'
+      end
+
+      def json
+        @json = JSON.parse(response.body)
+      end
+
+      def logged_in_headers
+        {
+          client: 'client_id_test',
+          'access-token': 'token_test',
+          uid: user_authorizations(:logged).uid,
+          'HTTP_USER_AGENT': 'Rails Testing'
+        }
+      end
+
+      def not_logged_in_headers
+        { 'HTTP_USER_AGENT': 'Rails Testing' }
+      end
+
+      def response_assertions(options)
+        assert_equal response.content_type, Mime[:json]
+        assert_meta_now
+        assert_meta_version
+        assert_response options[:status]
+      end
+
+      # rubocop:disable Rails/Date
+      def assert_meta_now
+        assert_kind_of Time, json['meta']['now'].to_time
+      end
+      # rubocop:enable Rails/Date
+
+      def assert_meta_version
+        assert_equal json['meta']['version'], api_version
+      end
+
+    end
+  end
+end

data/lib/beyond_the_api_test_helpers/request/index_assertions.rb

@@ -0,0 +1,103 @@
+module BeyondTheApiTestHelpers
+  module Request
+    module IndexAssertions
+      def assert_request_index_valid(url, options = {})
+        request_instance_variables_set_pluralize options
+
+        if required_login
+          assert_request_needs_to_be_logged(url, :get)
+          @headers.merge!(logged_in_headers)
+        end
+
+        get(url, params: @params, headers: @headers)
+        response_assertions(status: 200)
+        assert_kind_of Array, json_response_name
+        assert_request_index_should_include if @should_include || @should_not_include
+      end
+
+      def assert_request_index_total_count(url, options = {})
+        request_instance_variables_set_pluralize options
+        @headers.merge!(logged_in_headers) if required_login
+        get(url, params: @params.merge(total_count: true), headers: @headers)
+        assert_kind_of Integer, meta['total_count']
+      end
+
+      def assert_request_index_paginated(url, params = {})
+        request_instance_variables_set_pluralize params
+        @headers.merge!(logged_in_headers) if required_login
+
+        get(url, params: @params.merge(page: 1, per_page: 1, total_pages: true), headers: @headers)
+        assert_equal 1, json_response_name.size
+        assert_kind_of Integer, meta['total_pages']
+      end
+
+      def assert_request_index_with_filters(url, filters, params = {})
+        request_instance_variables_set_pluralize params
+        @headers.merge!(logged_in_headers) if required_login
+
+        filters.each do |key, options|
+          assert_request_index_filter(url, key, options)
+        end
+      end
+
+      def assert_request_index_not_found(urls_not_found, options = {})
+        request_instance_variables_set options
+        @headers.merge!(logged_in_headers) if required_login
+
+        urls_not_found.each do |url_not_found|
+          assert_request_index_not_found_i18n_all(url_not_found)
+        end
+      end
+
+      private
+
+      def assert_request_index_should_include
+        @should_include&.each do |object|
+          assert_request_includes_should_include(object)
+        end
+        @should_not_include&.each do |object|
+          assert_request_not_includes_should_not_include(object)
+        end
+      end
+
+      def assert_request_includes_should_include(object)
+        serialized = object.serialize_to_json(current_user: users(:logged))
+        assert_includes json_response_name, serialized
+      end
+
+      def assert_request_not_includes_should_not_include(object)
+        serialized = object.serialize_to_json(current_user: users(:logged))
+        assert_not_includes json_response_name, serialized
+      end
+
+      def assert_request_index_filter(url, key, options)
+        options.each do |option|
+          get(url, params: { key => option[:value] }, headers: @headers)
+          assert_request_include_filter(option[:include])
+          assert_request_exclude_filter(option[:exclude])
+        end
+      end
+
+      def assert_request_include_filter(objects)
+        objects.each do |object|
+          serialized = object.serialize_to_json(current_user: users(:logged))
+          assert_includes json_response_name, serialized
+        end
+      end
+
+      def assert_request_exclude_filter(objects)
+        objects.each do |object|
+          serialized = object.serialize_to_json(current_user: users(:logged))
+          assert_not_includes json_response_name, serialized
+        end
+      end
+
+      def assert_request_index_not_found_i18n_all(url_not_found)
+        assert_i18n_for_all_locales do
+          get(url_not_found, params: @params, headers: @headers)
+          assert_not_found_request
+        end
+      end
+    end
+  end
+end

data/lib/beyond_the_api_test_helpers/request/restore_assertions.rb

@@ -0,0 +1,53 @@
+module BeyondTheApiTestHelpers
+  module Request
+    module RestoreAssertions
+      def assert_request_restore_valid(url, options = {})
+        request_instance_variables_set options
+        if required_login
+          assert_request_needs_to_be_logged(url, :patch)
+          assert_request_needs_to_be_logged(url, :put)
+          @headers.merge!(logged_in_headers)
+        end
+
+        assert_i18n_for_all_locales do
+          do_restore_request_with_transaction(url)
+        end
+      end
+
+      def assert_request_restore_not_found(urls_not_found, options = {})
+        request_instance_variables_set options
+        @headers.merge!(logged_in_headers) if required_login
+
+        urls_not_found.each do |url_not_found|
+          assert_request_restore_not_found_i18n_all(url_not_found)
+        end
+      end
+
+      private
+
+      def do_restore_request_with_transaction(url)
+        ActiveRecord::Base.transaction do
+          do_restore_request_and_assert(url)
+          raise ActiveRecord::Rollback
+        end
+      end
+
+      # :reek:DuplicateMethodCall: { max_calls: 2 }
+      def do_restore_request_and_assert(url)
+        patch(url, params: @params, headers: @headers)
+        assert_nil subject.reload.deleted_at
+        response_assertions(status: 200)
+        assert_equal I18n.t(@message), json['success']
+      end
+
+      def assert_request_restore_not_found_i18n_all(url_not_found)
+        assert_i18n_for_all_locales do
+          patch(url_not_found, params: @params, headers: @headers)
+          assert_not_found_request
+          put(url_not_found, params: @params, headers: @headers)
+          assert_not_found_request
+        end
+      end
+    end
+  end
+end

data/lib/beyond_the_api_test_helpers/request/show_assertions.rb

@@ -0,0 +1,36 @@
+module BeyondTheApiTestHelpers
+  module Request
+    module ShowAssertions
+      def assert_request_show_valid(url, options = {})
+        request_instance_variables_set options
+
+        if required_login
+          assert_request_needs_to_be_logged(url, :get)
+          @headers.merge!(logged_in_headers)
+        end
+
+        get(url, params: @params, headers: @headers)
+        response_assertions(status: 200)
+        assert_kind_of Hash, json_response_name
+      end
+
+      def assert_request_show_not_found(urls_not_found, options = {})
+        request_instance_variables_set options
+        @headers.merge!(logged_in_headers) if required_login
+
+        urls_not_found.each do |url_not_found|
+          assert_request_show_not_found_i18n_all(url_not_found)
+        end
+      end
+
+      private
+
+      def assert_request_show_not_found_i18n_all(url_not_found)
+        assert_i18n_for_all_locales do
+          get(url_not_found, params: @params, headers: @headers)
+          assert_not_found_request
+        end
+      end
+    end
+  end
+end

data/lib/beyond_the_api_test_helpers/request/update_assertions.rb

@@ -0,0 +1,91 @@
+module BeyondTheApiTestHelpers
+  module Request
+    module UpdateAssertions
+      def assert_request_update_valid(url, options = {})
+        request_instance_variables_set options
+        if required_login
+          assert_request_needs_to_be_logged(url, :put)
+          assert_request_needs_to_be_logged(url, :patch)
+          @headers.merge!(logged_in_headers)
+        end
+
+        assert_i18n_for_all_locales do
+          do_update_request_with_transaction(url)
+        end
+      end
+
+      def assert_request_update_missing_param(url, options = {})
+        request_instance_variables_set options
+        @headers.merge!(logged_in_headers) if required_login
+        patch(url, params: {}, headers: @headers)
+        assert_parameter_missing_request
+        put(url, params: {}, headers: @headers)
+        assert_parameter_missing_request
+      end
+
+      def assert_request_update_with_errors(url, invalid_params, params = {})
+        request_instance_variables_set params
+        # pp @headers
+        # pp user_authorizations(:logged)
+        # abort
+        @headers.merge!(logged_in_headers) if required_login
+
+        ActiveRecord::Base.transaction do
+          do_update_request_and_assert_invalid(url, invalid_params)
+          raise ActiveRecord::Rollback
+        end
+      end
+
+      def assert_request_update_not_found(urls_not_found, options = {})
+        request_instance_variables_set options
+        @headers.merge!(logged_in_headers) if required_login
+
+        urls_not_found.each do |url_not_found|
+          assert_request_update_not_found_i18n_all(url_not_found)
+        end
+      end
+
+      private
+
+      def do_update_request_with_transaction(url)
+        ActiveRecord::Base.transaction do
+          do_update_request_and_assert(url)
+          raise ActiveRecord::Rollback
+        end
+      end
+
+      def do_update_request_and_assert(url)
+        patch(url, params: @params, headers: @headers)
+        subject.reload
+        changes.each do |key, value|
+          assert_equal subject.send(key), value
+        end
+        update_assertions_status_and_message
+      end
+
+      def update_assertions_status_and_message
+        response_assertions(status: 200)
+        assert_equal I18n.t(*@message), json['success']
+        assert_kind_of Hash, json_response_name unless @skip_json_response_name
+      end
+
+      def do_update_request_and_assert_invalid(url, invalid_params)
+        patch(url, params: invalid_params, headers: @headers)
+        subject.reload
+        changes.each do |key, value|
+          assert_not_equal subject.send(key), value
+        end
+        response_assertions(status: 422)
+        assert_kind_of Hash, json['errors']
+        assert_kind_of Array, json['full_error_messages']
+      end
+
+      def assert_request_update_not_found_i18n_all(url_not_found)
+        assert_i18n_for_all_locales do
+          patch(url_not_found, params: @params, headers: @headers)
+          assert_not_found_request
+        end
+      end
+    end
+  end
+end

data/lib/beyond_the_api_test_helpers/shoulda/have_foreign_key.rb

@@ -0,0 +1,59 @@
+module Shoulda
+  module Matchers
+    module ActiveRecord
+      def have_foreign_key(table, fk)
+        HaveForeignKeyMatcher.new(table, fk)
+      end
+
+      # @private
+      class HaveForeignKeyMatcher
+        def initialize(table, fk)
+          @table = table
+          @fk = fk
+          @options = {}
+        end
+
+        def matches?(subject)
+          @subject = subject
+
+          foreign_keys = ::ActiveRecord::Base.connection
+                                             .foreign_keys(table_name)
+                                             .map do |foreign_key|
+            { to_table: foreign_key['to_table'].to_sym,
+              fk: foreign_key['options'][:column].to_sym }
+          end
+
+          foreign_keys.include? to_table: @table, fk: @fk
+        end
+
+        def failure_message
+          "Expected #{expectation} (#{@missing})"
+        end
+        alias failure_message_for_should failure_message
+
+        def failure_message_when_negated
+          "Did not expect #{expectation}"
+        end
+        alias failure_message_for_should_not failure_message_when_negated
+
+        def description
+          "have a foreign_key to table #{@table}"
+        end
+
+        private
+
+        def expectation
+          "#{model_class.name} to #{description}"
+        end
+
+        def model_class
+          @subject.class
+        end
+
+        def table_name
+          model_class.table_name
+        end
+      end
+    end
+  end
+end