rails_stuff 0.5.1 → 0.6.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 16d70694f5a696a150e54aad75558c05441d0c1c
-  data.tar.gz: b12c95387e4bd5593842d8ad4ba3db9d5dc9ad9f
+  metadata.gz: 56cd33390b1d0c5cce251aba39698ef115de3c6c
+  data.tar.gz: 8e7032d8717fae0d1fa44c5f6ea308a150a2e73f
 SHA512:
-  metadata.gz: e179c0f340c95ff4186022d6ab09053d023ae01cee10a0a276e697e02d387d3624626cf0c93b0bd43ee3e305330d747259e4d4a558af5c912cd9a8d336f207bc
-  data.tar.gz: e7e396a2265bb05e1312eaff05d5230788a77a2fc92780b4f8c099f9a40979f502975c2c6b2967fd91b41d2635527cd6ee943fbde73c8541ebb7c4a9537540b4
+  metadata.gz: 9abf798f564088d2bb174e955efdf0cce9b47528b8f0dac7095516a35fcd11752772cd3d691266235698fd5281622db8ce9f5f9d32a3d66a75c8efde2c5da87c
+  data.tar.gz: 3dbbc5a6052014726fba018811d5615d9e9527e913fb14a492d615527f4bbe6bb5312815d55549e613e38c6103728447e7b558c8f1bbf630c18d65eb897bfc13

data/.gitignore

@@ -8,3 +8,4 @@
 /pkg/
 /spec/reports/
 /tmp/
+/log/

data/CHANGELOG.md

@@ -1,5 +1,34 @@
 ## Unreleased
 
+## 0.6.0.rc1
+
+### Controllers
+
+- Don't overwrite :location option if present.
+- Don't overwrite responder and `respond_with`'s mimes.
+- `#current_sort_scope` to access applied sorting rules.
+- `.resource_helper` has `source` option, which accepts lambdas and strings.
+  `class` option is deprecated now in favour of `source`.
+
+### Models
+
+- Improved Statusable:
+
+  - Model are now clear from lot of helper methods.
+    There is single `statuses` method for statusable field which holds all helpers.
+  - `.select_options` supports `:only` option.
+  - Helpers to map/unmap values for mapped statuses from external code.
+
+### Tests
+
+- A lot of new test and rspec helpers and configs (see RSpecHelpers, TestHelpers).
+- `RSpecHelpers.setup` & `TestHelpers.setup` to setup helpers instead of requiring
+  files. This methods accepts `only` & `except` options.
+
+### Misc
+
+- Use AR#update instead of #update_attributes.
+
 ## 0.5.1
 
 Rails 5 support.

data/Gemfile

@@ -16,6 +16,7 @@ group :development do
   gem 'has_scope', '~> 0.7.0'
   gem 'responders', '~> 2.1.0'
   gem 'kaminari', '~> 0.16.3'
+  gem 'hashie', '~> 3.4.0'
 
   gem 'rspec-rails', '~> 3.5.2'
   gem 'rspec-its', '~> 1.2.0'

data/README.md

@@ -58,8 +58,7 @@ __[Helpers usage](#helpers-usage)__
 
 - __Response__
   `#json_body` to test json responses.
-- __Configurator__
-  Provides useful basic configuration for RSpec.
+- Useful RSpec configurations, helpers and matchers for better experience.
 - __Concurrency__
   Helpers for testing with concurrent requests.
 
@@ -166,6 +165,9 @@ has_sort_scope by: [:name, :created_at, :balance], default: [:name]
 #   - `sort=name&sort_desc=true`
 #   - `sort[name]&sort[created_at]`
 #   - `sort[name]&sort[created_at]=desc
+
+# access current sort scope hash with
+current_sort_scope # => {'name' => :desc} or {'name' => :asc, 'id' => :desc}
 ```
 
 Requires `gem 'has_scope'`.
@@ -249,10 +251,12 @@ User.with_status(param[:status]).with_subscription_status(params[:subs_status])
 Order.with_status(:confirmed)
 
 # Translation & select helpers (requires activemodel_translation gem)
-User.status_name(:active)
+User.statuses.translate(:active)
 user.subscription_status_name # translates current status
-User.status_select_options
-User.subscription_status_select_options except: [:expired]
+User.statuses.select_options
+User.subscription_statuses.select_options except: [:expired]
+Order.statuses.map([:submitted, :delivered]) # => [1, 3]
+Order.statuses.unmap([1, 3]) # => [:submitted, :delivered]
 
 # Accessors
 user.status = 'confirmed' or user.confirmed!
@@ -409,8 +413,13 @@ switch locales while rendering single view.
 
 ### Test helpers usage
 
-Add `require 'rails_stuff/test_helpers/rails'` to `test_helper.rb`.
+Add `RailsStuff::RSpec.setup` to `rails_helper.rb` to load all the stuff or
+pick from `rails_stuff/test_helpers/` and `rails_stuff/rspec`.
+
+Please check the source for complete list of helpers, while this section is not
+well-documented.
 
+#### `json_body`
 ```ruby
 assert_equal({'id' => 1, 'name' => 'John'}, response.json_body)
 assert_equal('John', response.json_body['name'])
@@ -430,17 +439,29 @@ Use `json_body['key']` instead.
 
 There is `Configurator` with useful RSpec configs:
 
+#### RSpec configurations
+
 ```ruby
-RSpec.configure do |config|
-  RailsStuff::TestHelpers::Configurator.tap do |configurator|
-    # Setup DatabaseCleaner with basic settings:
-    configurator.database_cleaner(config)
-    # Flush redis after suite and exampes with `flush_redis: true`:
-    configurator.redis(config)
-    # Run debugger after failed tests:
-    configurator.debug(config)
-  end
-end
+# Setup DatabaseCleaner with basic settings:
+RailsStuff::RSpec.database_cleaner
+
+# Flush redis after suite and exampes with `flush_redis: true`:
+RailsStuff::RSpec.redis
+
+# Run debugger after failed tests:
+RailsStuff::RSpec.debug
+
+# Clear log/test.log after suite:
+RailsStuff::RSpec.clear_logs
+
+# Raise errors from threads:
+RailsStuff::RSpec.thread
+
+# Raise errors for all missing I18n translation:
+RailsStuff::RSpec.i18n
+
+# Freeze time with for group/example with `:frozen_time` metadata (requires timecop gem):
+RailsStuff::RSpec.frozen_time
 ```
 
 ### PluginManager

data/gemfiles/rails_4.gemfile

@@ -15,6 +15,7 @@ group :development do
   gem "has_scope", "~> 0.7.0"
   gem "responders", "~> 2.1.0"
   gem "kaminari", "~> 0.16.3"
+  gem "hashie", "~> 3.4.0"
   gem "rspec-rails", "~> 3.5.2"
   gem "rspec-its", "~> 1.2.0"
   gem "rubocop", "~> 0.37.2"

data/gemfiles/rails_5.gemfile

@@ -15,6 +15,7 @@ group :development do
   gem "has_scope", "~> 0.7.0"
   gem "responders", "~> 2.1.0"
   gem "kaminari", "~> 0.16.3"
+  gem "hashie", "~> 3.4.0"
   gem "rspec-rails", "~> 3.5.2"
   gem "rspec-its", "~> 1.2.0"
   gem "rubocop", "~> 0.37.2"

data/lib/rails_stuff/engine.rb

@@ -8,7 +8,7 @@ module RailsStuff
     random_uniq_attr:     :model,
     statusable:           :model,
     resources_controller: [
-      :controller,
+      -> { defined?(::Responders) && :controller },
       -> { ResourcesController.use_kaminari! if defined?(::Kaminari) },
     ],
     sort_scope: -> { defined?(::HasScope) && :controller },

data/lib/rails_stuff/resources_controller/actions.rb

@@ -8,21 +8,21 @@ module RailsStuff
 
       def create(options = {}, &block)
         if create_resource
-          options[:location] = after_save_url
+          options[:location] ||= after_save_url
         end
         respond_with(resource, options, &block)
       end
 
       def update(options = {}, &block)
         if update_resource
-          options[:location] = after_save_url
+          options[:location] ||= after_save_url
         end
         respond_with(resource, options, &block)
       end
 
       def destroy(options = {}, &block)
         resource.destroy
-        options[:location] = after_destroy_url
+        options[:location] ||= after_destroy_url
         flash_errors!
         respond_with(resource, options, &block)
       end

data/lib/rails_stuff/resources_controller/basic_helpers.rb

@@ -82,7 +82,7 @@ module RailsStuff
 
       # Updates resource with `resource_params`.
       def update_resource(attrs = resource_params)
-        resource.update_attributes(attrs)
+        resource.update(attrs)
       end
 
       # Flashes errors in a safe way. Joins `full_messages` and truncates

data/lib/rails_stuff/resources_controller/resource_helper.rb

@@ -2,6 +2,15 @@ module RailsStuff
   module ResourcesController
     # Defines resource helper and finder method.
     module ResourceHelper
+      class << self
+        def deprecation
+          @deprecation ||= begin
+            require 'active_support/deprecation'
+            ActiveSupport::Deprecation.new('0.7', 'RailsStuff')
+          end
+        end
+      end
+
       # Defines protected helper method. Ex. for `:user`
       #
       #     helper_method :user
@@ -12,26 +21,35 @@ module RailsStuff
       #
       # #### Options
       #
-      # - `class` - class name, default to `resource_name.classify`
+      # - `source` - class name or Proc returning relation, default to `resource_name.classify`.
       # - `param` - param name, default to `resource_name.foreign_key`
-      def resource_helper(resource_name, **options)
-        helper_method resource_name, :"#{resource_name}?"
-        resource_name = resource_name.to_s
-        class_name = options[:class] || resource_name.classify
-        param_key = options[:param] || resource_name.foreign_key
+      #
+      # rubocop:disable CyclomaticComplexity, PerceivedComplexity, AbcSize
+      def resource_helper(name, param: nil, source: nil, **options)
+        ResourceHelper.deprecation.warn('use :source instead of :class') if options.key?(:class)
 
-        class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          protected
+        param ||= name.to_s.foreign_key.to_sym
+        define_method("#{name}?") { params.key?(param) }
 
-          def #{resource_name}
-            @#{resource_name} ||= #{class_name}.find(params[:#{param_key}])
+        ivar = :"@#{name}"
+        source ||= options[:class] || name.to_s.classify
+        if source.is_a?(Proc)
+          define_method(name) do
+            instance_variable_get(ivar) ||
+              instance_variable_set(ivar, instance_exec(&source).find(params[param]))
           end
-
-          def #{resource_name}?
-            params.key?(:#{param_key})
+        else
+          source = Object.const_get(source) unless source.is_a?(Class)
+          define_method(name) do
+            instance_variable_get(ivar) ||
+              instance_variable_set(ivar, source.find(params[param]))
           end
-        RUBY
+        end
+
+        helper_method name, :"#{name}?"
+        protected name, :"#{name}?"
       end
+      # rubocop:enable CyclomaticComplexity, PerceivedComplexity, AbcSize
     end
   end
 end

data/lib/rails_stuff/resources_controller.rb

@@ -41,8 +41,6 @@ module RailsStuff
     def resources_controller(**options)
       ResourcesController.inject(self, **options)
 
-      respond_to :html
-      self.responder = Responder
       self.after_save_action = options[:after_save_action] || after_save_action
 
       resource_belongs_to(*options[:belongs_to]) if options[:belongs_to]

data/lib/rails_stuff/responders/turbolinks.rb

@@ -0,0 +1,13 @@
+module RailsStuff
+  module Responders
+    module Turbolinks
+      # Bypasses `:turbolinks` from options.
+      def redirect_to(url, opts = {})
+        if !opts.key?(:turbolinks) && options.key?(:turbolinks)
+          opts[:turbolinks] = options[:turbolinks]
+        end
+        super
+      end
+    end
+  end
+end

data/lib/rails_stuff/responders.rb

@@ -0,0 +1,19 @@
+require 'rails_stuff/responders/turbolinks'
+
+module RailsStuff
+  # Here are some useful responders extensions.
+  #
+  # Previous versions had responder with SJR helpers, which has been removed.
+  # To achieve same result define responder with:
+  #
+  #   class CustomResponder < ActionController::Responder
+  #     include Responders::HttpCacheResponder
+  #     include RailsStuff::Responders::Turbolinks
+  #
+  #     # SJR: render action on failures, redirect on success
+  #     alias_method :to_js, :to_html
+  #   end
+  #
+  module Responders
+  end
+end

data/lib/rails_stuff/rspec_helpers/concurrency.rb

@@ -0,0 +1,45 @@
+require 'active_support/concern'
+require 'rails_stuff/test_helpers/concurrency'
+
+module RailsStuff
+  module RSpecHelpers
+    module Concurrency
+      extend ActiveSupport::Concern
+      include RailsStuff::TestHelpers::Concurrency
+
+      module ClassMethods
+        # Defines subject which runs parent's value in multiple threads concurrently.
+        # Define `thread_args` or `threads_count` with `let` to configure it.
+        #
+        # Sets metadata `concurrent: true` so database cleaner uses right strategy.
+        def concurrent_subject!
+          metadata[:concurrent] = true
+          subject do
+            super_proc = super()
+            args = defined?(thread_args) && thread_args
+            args ||= defined?(threads_count) && threads_count
+            -> { concurrently(args, &super_proc) }
+          end
+        end
+
+        # Runs given block in current context and nested context with concurrent subject.
+        #
+        #     subject { -> { increment_value_once } }
+        #     # This will create 2 examples. One for current contex, and one
+        #     # for current context where subject will run multiple times concurrently.
+        #     check_concurrent do
+        #       it { should change { value }.by(1) }
+        #     end
+        def check_concurrent(&block)
+          instance_eval(&block)
+          context 'running multiple times concurrently' do
+            concurrent_subject!
+            instance_eval(&block)
+          end
+        end
+      end
+
+      ::RSpec.configuration.include(self) if defined?(::RSpec)
+    end
+  end
+end

data/lib/rails_stuff/rspec_helpers/groups/feature.rb

@@ -0,0 +1,25 @@
+module RailsStuff
+  module RSpecHelpers
+    module Groups
+      module Feature
+        def wait_for_ajax
+          Timeout.timeout(Capybara.default_max_wait_time) do
+            loop until finished_all_ajax_requests?
+          end
+        end
+
+        # Tuned for jQuery, override it if you don't use jQuery.
+        def finished_all_ajax_requests?
+          page.evaluate_script('jQuery.active').zero?
+        end
+
+        def pause
+          $stderr.write 'Press enter to continue'
+          $stdin.gets
+        end
+
+        ::RSpec.configuration.include self, type: :feature
+      end
+    end
+  end
+end

data/lib/rails_stuff/rspec_helpers/groups/request.rb

@@ -0,0 +1,79 @@
+require 'active_support/concern'
+
+module RailsStuff
+  module RSpecHelpers
+    module Groups
+      module Request
+        extend ActiveSupport::Concern
+
+        included do
+          # Define default params for ResourcesController.
+          #
+          #   subject { -> { patch(resource_path, params: params) } }
+          #   let(:resource) { create(:user) }
+          #   let(:resource_params) { {name: 'new name'} }
+          #   # params will be {user: {name: 'new name'}}
+          if described_class.respond_to?(:resource_param_name)
+            let(:params) { {described_class.resource_param_name => resource_params} }
+          end
+        end
+
+        module ClassMethods
+          # Adds `referer`, `referer_path` and `headers` with `let`.
+          # Requires `root_url`
+          def set_referer
+            let(:referer) { root_url.sub(%r{/$}, referer_path) }
+            let(:referer_path) { '/test_referer' }
+            let(:headers) do
+              headers = {Referer: referer}
+              defined?(super) ? super().merge(headers) : headers
+            end
+          end
+
+          # Perform simple request to initialize session.
+          # Useful for `change` matchers.
+          def init_session
+            before do
+              path = defined?(init_session_path) ? init_session_path : '/'
+              get(path)
+            end
+          end
+
+          def with_csrf_protection!
+            around do |ex|
+              begin
+                old = ActionController::Base.allow_forgery_protection
+                ActionController::Base.allow_forgery_protection = true
+                ex.run
+              ensure
+                ActionController::Base.allow_forgery_protection = old
+              end
+            end
+            let(:csrf_response) do
+              path = defined?(csrf_response_path) ? csrf_response_path : '/'
+              get(path) && response.body
+            end
+            let(:csrf_param) { csrf_response.match(/meta name="csrf-param" content="([^"]*)"/)[1] }
+            let(:csrf_token) { csrf_response.match(/<meta name="csrf-token" content="([^"]*)"/)[1] }
+          end
+        end
+
+        # Generate url to current controller.
+        def controller_path(**options)
+          url_for(controller: described_class.controller_path, only_path: true, **options)
+        end
+
+        # Generate url to current controller with resource and default action to `:show`.
+        # It uses `resource` method by default:
+        #
+        #   expect(resource_path).to eq resource_path(resource)
+        #   resource_path(other_user, action: :edit)
+        def resource_path(resource = self.resource, **options)
+          controller_path(action: :show, id: resource, **options)
+        end
+
+        ::RSpec.configuration.include self, type: :request
+      end
+    end
+  end
+end

data/lib/rails_stuff/rspec_helpers/matchers/be_valid_js.rb

@@ -0,0 +1,12 @@
+RSpec::Matchers.define :be_valid_js do
+  match_unless_raises do |actual|
+    ExecJS.exec("var test = function(){\n#{actual}\n}")
+  end
+
+  failure_message do |actual|
+    js_error = rescued_exception.message
+    line = js_error.lines[0].split(':').last.to_i - 1
+    js_error = /SyntaxError.*$/.match(js_error)[0] if js_error.include?('SyntaxError')
+    "expected string to be valid js, got '#{js_error}' on line #{line} for\n\n#{actual}"
+  end
+end

data/lib/rails_stuff/rspec_helpers/matchers/redirect_with_turbolinks.rb

@@ -0,0 +1,53 @@
+module RailsStuff
+  module RSpecHelpers
+    module Matchers
+      module RedirectWithTurbolinks
+        include ::RSpec::Matchers
+
+        class XhrFailure < StandardError; end
+
+        def matches?(response)
+          return unless @scope.request
+          if @scope.request.xhr?
+            match_unless_raises(XhrFailure) { matches_xhr?(response) }
+          else
+            super
+          end
+        end
+
+        def failure_message
+          @scope.request ? super : 'Request was not performed'
+        end
+
+        def matches_xhr?(response)
+          unless be_ok.matches?(response)
+            raise XhrFailure, "Expect #{response.inspect} to be OK for Turbolinks redirect"
+          end
+          location, _options = turbolinks_location(response)
+          raise XhrFailure, "No Turbolinks redirect in\n\n#{response.body}" unless location
+          active_support_assertion(location)
+        end
+
+        def turbolinks_location(response)
+          body = response.body
+          return unless body
+          match_data = /Turbolinks\.visit\(([^,]+)(,\s*([^)]+))?\)/.match(body)
+          return unless match_data
+          [match_data[1], match_data[3]].map { |x| JSON.parse("[#{x}]")[0] }
+        end
+
+        def active_support_assertion(location)
+          redirect_is       = @scope.send(:normalize_argument_to_redirection, location)
+          redirect_expected = @scope.send(:normalize_argument_to_redirection, @expected)
+          message = "Expected response to be a Turbolinks redirect to <#{redirect_expected}>" \
+            " but was a redirect to <#{redirect_is}>"
+          @scope.assert_operator redirect_expected, :===, redirect_is, message
+        rescue ActiveSupport::TestCase::Assertion => e
+          raise XhrFailure, e
+        end
+
+        ::RSpec::Rails::Matchers::RedirectTo::RedirectTo.prepend(self) if defined?(::RSpec::Rails)
+      end
+    end
+  end
+end

data/lib/rails_stuff/rspec_helpers/signinable.rb

@@ -0,0 +1,21 @@
+module RailsStuff
+  module RSpecHelpers
+    module Signinable
+      # Context-level helper to add before filter to sign in user.
+      # Adds `current_user` with let if not defined yet or with gven block.
+      #
+      # Instance-level `sign_in(user_or_nil)` method must be defined, so
+      # this module can be used in any of feature, request or controller groups.
+      #
+      #     sign_in { owner }
+      #     sign_in # will call current_user or define it with nil
+      def sign_in(&block)
+        if block || !instance_methods.include?(:current_user)
+          block ||= ->(*) {}
+          let(:current_user, &block)
+        end
+        before { sign_in(instance_eval { current_user }) }
+      end
+    end
+  end
+end