rack-transaction 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7344d9a199dd181db1cef5252d21aa6b4b11ff51
-  data.tar.gz: 4e50793aef557b46c300ce3f0fa2940ae8af2d93
+  metadata.gz: 9de5a130671b3c2f6b5d8c8759041bf5cf02ac4a
+  data.tar.gz: 3781fdb23e87f0e354cf15470894ad864561ef19
 SHA512:
-  metadata.gz: db561213fd61612450a54cfb64a5ca4905d22e5d01210e7a0b7be7ae9094f1ae9606e321a4d12288641938c040a31690374e0a4c704854bd7093f78e55654ac6
-  data.tar.gz: 2d91aa10d58c39b847c99543af4ef29f05b517d8aeb9de4f439ebfe1a5f327efe114620a39a01f96bbae41091372ad614aec704bac88ce14052a9ae3a22968d3
+  metadata.gz: 634286289f23079d01c71a22f1be081620db2526db1ce0a8f1840826ed1001aab820b67c0d0602fd4ee5d7875973ebf38951aca6d73b5e8a16f08ca124675039
+  data.tar.gz: 95b539b35d3106bb46282b8c2c6af403572aaf89fce5b8a3fc50c76455566268fd5551c3b50bd5dd6f07e91ffed324a55c7f62578c37a8ba08f8d75330f6a6fc

data/README.md

@@ -22,29 +22,67 @@ gem install rack-transaction
 Add the following:
 
 ```ruby
-use Rack::Transaction,
-  provider: Sequel.connect('sqlite:///')  #required
-  rollback: Sequel::Rollback              #required (it also accepts the string version of the constant)
+config = Rack::Transaction::Configuration.new do
+  provided_by Sequel.connect('sqlite:///')  #required
+  rollback_with Sequel::Rollback            #required (it also accepts the string version of the constant)
+end
+
+use Rack::Transaction, config
+```
+
+or, with the shorthand form:
+
+```ruby
+use Rack::Transaction do
+  provided_by Sequel.connect('sqlite:///')  #required
+  rollback_with Sequel::Rollback            #required (it also accepts the string version of the constant)
+end
+```
+
+Do note that `rollback_with` will use the type specified to raise an error,
+which in turn, causes the transaction to rollback. Depending on the provider,
+passed into `provided_by`, providing the transaction, you may want to specify
+an error type provided by the library being used to allow for more graceful
+error handling. For example, Sequel has `Sequel::Rollback` and ActiveRecord has
+`ActiveRecord::Rollback`.
+
+It also supports an optional callback to validate that an action was
+successful, even if it wasn't recognized as a client or server error. For
+example, Sinatra sets `sinatra.error` on the `env` in the event of an error, so
+we'll probably want to rollback.  We can specify the validation callback with
+`ensure_success_with`. The callback will have the `Rack::Response` and `env`
+passed to it as arguments.
+
+```ruby
+use Rack::Transaction do
+  provided_by Sequel.connect('sqlite:///')
+  rollback_with Sequel::Rollback
+  ensure_success_with { |response, env| env['sinatra.error'] }
 ```
 
-Do note that `:rollback` will use the type specified to raise an error, which
-in turn, causes the transaction to rollback. Depending on the `:provider`
-providing the transaction, you may want to specify an error type provided by
-the library being used to allow for more graceful error handling. For example,
-Sequel has `Sequel::Rollback` and ActiveRecord has `ActiveRecord::Rollback`.
+### Configuration
 
-It also supports an optional error callback to check for errors in the
-environment outside of the normal client or server errors. For example, Sinatra
-sets `sinatra.error` on the `env` in the event of an error, so we'll probably
-want to rollback.  We can check for this by specifying the `:error` setting.
+By default, `Rack::Transaction` will wrap all requests except for request of
+methods GET, HEAD, & OPTION. It also provides away to include or exclude
+certain requests from participating in the transaction. This is done by passing
+in a block to `include` or `exclude` to the configuration. The block can expect
+a `Rack::Request` instance to be used to determine whether or not to include or
+exclude said request. For example, you may want to wrap a GET request in a
+transaction, because the action it routes to is handling the final leg of
+OAauth authorization and saving the refresh token as well as other business
+logic.
 
 ```ruby
-use Rack::Transaction,
-  provider: Sequel.connect('sqlite:///')
-  rollback: Sequel::Rollback
-  error: ->(env){ env['sinatra.error'] }
+use Rack::Transaction do
+  // other config stuff
+
+  include { |request| request.path =~ %r{/oauth/callback$}i }
+  exclude { |request| request.path =~ %r{/search$}i }
+end
 ```
 
+Do note that includes take priority over any excludes specified.
+
 ## Contributing
 
 1. Fork it

data/lib/rack/transaction.rb

@@ -1,40 +1,46 @@
+require 'rack/transaction/version'
+require 'rack/transaction/configuration'
+
 module Rack
   class Transaction
-    VERSION = "0.1.0".freeze
+    attr_reader :config
 
-    def initialize(inner, settings)
+    def initialize(inner, configuration=nil, &block)
       @inner = inner
-      @provider = settings.fetch(:provider)
-      @rollback = settings.fetch(:rollback)
-      @error = settings[:error]
+      @config = configuration || Configuration.new
+
+      config.setup(&block)
     end
 
     def call(env)
+      config.validate!
+
       return @inner.call(env) unless use_transaction?(env)
 
       result = nil
-      @provider.transaction do
+      config.provider.transaction do
         result = @inner.call(env)
-        rollback if has_error?(env, *result)
+        rollback unless successful?(env, *result)
       end
       result
     end
 
     private
 
-    def has_error?(env, status, headers, body)
+    def use_transaction?(env)
+      request = Request.new env
+      config.accepts?(request)
+    end
+
+    def successful?(env, status, headers, body)
       response = Response.new body, status, headers
-      response.client_error? || response.server_error? || (@error.respond_to?(:call) && @error.call(env))
+      config.successful?(response, env)
     end
 
     def rollback
-      klass = @rollback.is_a?(String) ? Object.const_get(@rollback) : @rollback
+      error = config.rollback_error
+      klass = error.is_a?(String) ? Object.const_get(error) : error
       raise klass
     end
-
-    def use_transaction?(env)
-      request = Request.new env
-      !(request.get? || request.head? || request.options?)
-    end
   end
 end

data/lib/rack/transaction/configuration.rb

@@ -0,0 +1,76 @@
+module Rack
+  class Transaction
+    class Configuration
+      class Invalid < StandardError; end
+      class InvalidProvider < StandardError; end
+      class InvalidRollbackError < StandardError; end
+      class InvalidResponseValidation < StandardError; end
+
+      attr_reader :provider, :rollback_error, :success_validation
+
+      def initialize(&block)
+        @includers = []
+        @excluders = []
+        with_defaults
+        setup(&block)
+      end
+
+      def setup(&block)
+        instance_eval(&block) if block_given?
+      end
+
+      def provided_by(value)
+        raise InvalidProvider, 'Provider must respond to transaction' unless value.respond_to?(:transaction)
+        @provider = value
+        self
+      end
+
+      def rollback_with(value)
+        unless (value.is_a?(Class) && (value <= StandardError)) || value.is_a?(String)
+          raise InvalidRollbackError, 'Rollback error must be a valid StandardError type'
+        end
+        @rollback_error = value
+        self
+      end
+
+      def ensure_success_with(&validation)
+        raise InvalidResponseValidation, 'Response validation must respond to call' unless validation.respond_to?(:call)
+        @success_validation = validation
+        self
+      end
+
+      def include(&block)
+        @includers << block
+        self
+      end
+
+      def exclude(&block)
+        @excluders << block
+        self
+      end
+
+      def accepts?(request)
+        @excluders.all?{|x| !x.call(request)} || @includers.any?{|x| x.call(request)}
+      end
+
+      def successful?(response, env)
+        !response.client_error? && !response.server_error? && (success_validation.nil? || success_validation.call(response, env))
+      end
+
+      def validate!
+        missing = []
+        missing << 'provider' unless provider
+        missing << 'rollback_error' unless rollback_error
+        raise Invalid, "Missing #{missing.join ' & '}" if missing.any?
+      end
+
+      private
+
+      def with_defaults
+        exclude(&:get?)
+        exclude(&:head?)
+        exclude(&:options?)
+      end
+    end
+  end
+end

data/lib/rack/transaction/version.rb

@@ -0,0 +1,5 @@
+module Rack
+  class Transaction
+    VERSION = "0.2.0".freeze
+  end
+end

data/rack-transaction.gemspec

@@ -1,5 +1,5 @@
 # -*- encoding: utf-8 -*-
-require File.expand_path('../lib/rack/transaction', __FILE__)
+require File.expand_path('../lib/rack/transaction/version', __FILE__)
 
 Gem::Specification.new do |gem|
   gem.author        = 'vyrak.bunleang@gmail.com'

data/spec/rack/transaction/configuration_spec.rb

@@ -0,0 +1,178 @@
+require 'spec_helper'
+
+describe Rack::Transaction::Configuration do
+  let(:env){ {} }
+  subject { Rack::Transaction::Configuration.new }
+
+  describe "#provided_by" do
+    it 'sets provider' do
+      provider = Class.new { def self.transaction; end }
+      result = subject.provided_by provider
+      result.must_equal subject
+      subject.provider.must_equal provider
+    end
+
+    it 'raises when provider does not respond to :transaction' do
+      proc {
+        subject.provided_by Object
+      }.must_raise Rack::Transaction::Configuration::InvalidProvider
+    end
+  end
+
+  describe "#rollback_with" do
+    it 'sets rollback_error StandardError' do
+      rollback_error = StandardError
+      result = subject.rollback_with rollback_error
+      result.must_equal subject
+      subject.rollback_error.must_equal rollback_error
+    end
+
+    it 'sets rollback_error StandardError subclass' do
+      rollback_error = RuntimeError
+      result = subject.rollback_with rollback_error
+      result.must_equal subject
+      subject.rollback_error.must_equal rollback_error
+    end
+
+    it 'sets rollback_error with String' do
+      rollback_error = 'RuntimeError'
+      result = subject.rollback_with rollback_error
+      result.must_equal subject
+      subject.rollback_error.must_equal rollback_error
+    end
+
+    it 'raises when rollback_error not String or StandardError' do
+      proc {
+        subject.rollback_with Object.new
+      }.must_raise Rack::Transaction::Configuration::InvalidRollbackError
+    end
+  end
+
+  describe "#ensure_success_with" do
+    it 'sets success_validation' do
+      callable = nil
+      result = subject.ensure_success_with {|response, env| callable = true}
+      result.must_equal subject
+
+      subject.success_validation.call
+      callable.must_equal true
+    end
+
+    it 'raises when success_validation does not respond to :call' do
+      proc {
+        subject.ensure_success_with
+      }.must_raise Rack::Transaction::Configuration::InvalidResponseValidation
+    end
+  end
+
+  describe '#validate!' do
+    let(:provider){ Rack::Transaction::Configuration }
+    subject { Rack::Transaction::Configuration }
+
+    it 'raises when provider not configured' do
+      config = subject.new do
+        rollback_with(StandardError)
+      end
+      proc { config.validate! }.must_raise Rack::Transaction::Configuration::Invalid
+    end
+
+    it 'raises when rollback_error not configured' do
+      config = subject.new do
+        provided_by(Class.new { def self.transaction; end })
+      end
+      proc { config.validate! }.must_raise Rack::Transaction::Configuration::Invalid
+    end
+
+    it 'wont raise when valid' do
+      config = subject.new do
+        provided_by(Class.new { def self.transaction; end })
+        rollback_with(StandardError)
+      end
+      config.validate!
+    end
+  end
+
+  describe '#successful?' do
+    it 'is unsuccessful for a response with a client error' do
+      response = Rack::Response.new [], 400, {}
+      subject.successful?(response, {}).must_equal false
+    end
+
+    it 'is unsuccessful for a response with a server error' do
+      response = Rack::Response.new [], 500, {}
+      subject.successful?(response, {}).must_equal false
+    end
+
+    it 'is unsuccessful for a validation error' do
+      validation_args = nil
+      env = {}
+      response = Rack::Response.new [], 200, {}
+
+      subject.ensure_success_with { |*args| validation_args = args; false }
+      subject.successful?(response, env).must_equal false
+
+
+      validation_args.length.must_equal 2
+      response_arg, env_arg = validation_args
+      response_arg.must_equal response
+      env_arg.must_equal env
+    end
+
+    it 'is successful' do
+      response = Rack::Response.new [], 200, {}
+      subject.successful?(response, {}).must_equal true
+    end
+  end
+
+  describe 'with defaults' do
+    let(:request){ Rack::Request.new env }
+
+    it 'accepts request' do
+      subject.accepts?(request).must_equal true
+    end
+
+    %w{DELETE POST PUT}.each do |method|
+      it "accepts #{method} request" do
+        env['REQUEST_METHOD'] = method
+        subject.accepts?(request).must_equal true
+      end
+    end
+
+    %w{GET HEAD OPTIONS}.each do |method|
+      it "wont accept #{method} request" do
+        env['REQUEST_METHOD'] = method
+        subject.accepts?(request).must_equal false
+      end
+    end
+  end
+
+  describe 'with inclusion' do
+    let(:env){ {'REQUEST_METHOD' => 'GET'} }
+    let(:request){ Rack::Request.new env }
+
+    it 'returns self' do
+      result = subject.include(&:get?)
+      result.must_equal subject
+    end
+
+    it 'accepts request' do
+      subject.include(&:get?)
+      subject.accepts?(request).must_equal true
+    end
+  end
+
+  describe 'with exclusion' do
+    let(:env){ {'REQUEST_METHOD' => 'POST'} }
+    let(:request){ Rack::Request.new env }
+
+    it 'returns self' do
+      result = subject.exclude(&:post?)
+      result.must_equal subject
+    end
+
+    it 'wont accept excluded request' do
+      subject.exclude(&:post?)
+      subject.accepts?(request).must_equal false
+    end
+  end
+end

data/spec/rack/transaction_spec.rb

@@ -1,15 +1,20 @@
 require 'spec_helper'
-require 'rack/transaction'
 
 describe Rack::Transaction do
   let(:inner){ mock }
   let(:env){ {'field' => 'variable'} }
   let(:table_name){ :rack }
   let(:dataset){ connection[table_name] }
-  let(:rollback){ Sequel::Rollback }
-  let(:settings){ {provider: connection, rollback: rollback} }
+  let(:error){ Sequel::Rollback }
+  let(:config){
+    context = self
+    Rack::Transaction::Configuration.new do
+      provided_by context.connection
+      rollback_with context.error
+    end
+  }
 
-  subject { Rack::Transaction.new inner, settings }
+  subject { Rack::Transaction.new inner, config }
 
   before do
     connection.create_table table_name do
@@ -42,62 +47,26 @@ describe Rack::Transaction do
     dataset.wont_be :empty?
   end
 
-  it 'rolls back on server error' do
-    expect_call 500
-    result = subject.call env
-    result.must_equal [500, {}, []]
-    dataset.must_be :empty?
-  end
-
-  it 'rolls back on client error' do
+  it 'rolls back on error' do
     expect_call 400
     result = subject.call env
     result.must_equal [400, {}, []]
     dataset.must_be :empty?
   end
 
-  it 'rolls back on custom error callback' do
-    args = nil
-    settings[:error] = ->(*a){ args = a; true }
-    expect_call 200
-    result = subject.call env
-    result.must_equal [200, {}, []]
-    dataset.must_be :empty?
-    args.must_equal [env]
-  end
-
   it 'rolls back on string rollback' do
-    settings[:rollback] = "Sequel::Rollback"
     expect_call 400
+    subject.config.rollback_with("Sequel::Rollback")
     result = subject.call env
     result.must_equal [400, {}, []]
     dataset.must_be :empty?
   end
 
-  %w{ GET HEAD OPTIONS }.each do |method|
-    # shouldn't be modifying anything on these types of requests; modifying for assertion purposes
-
-    describe "on #{method} request" do
-      before { env['REQUEST_METHOD'] = method }
-
-      it 'wont rollback on custom error callback' do
-        settings[:error] = ->{ true }
-        expect_call 200
-        subject.call env
-        dataset.wont_be :empty?
-      end
-
-      it 'wont rollback on server error' do
-        expect_call 500
-        subject.call env
-        dataset.wont_be :empty?
-      end
-
-      it 'wont rollback on client error' do
-        expect_call 400
-        subject.call env
-        dataset.wont_be :empty?
-      end
+  it 'ensures valid configuration' do
+    context = self
+    middleware = Rack::Transaction.new inner do
+      provided_by context.connection
     end
+    proc { middleware.call env }.must_raise Rack::Transaction::Configuration::Invalid
   end
 end

data/spec/spec_helper.rb

@@ -4,6 +4,7 @@ Bundler.require :development
 $:.unshift File.expand_path('../../lib', __FILE__)
 require 'minitest/pride'
 require 'minitest/autorun'
+require 'rack/transaction'
 
 class Minitest::Spec
   def mock

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rack-transaction
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - vyrak.bunleang@gmail.com
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-28 00:00:00.000000000 Z
+date: 2015-03-04 00:00:00.000000000 Z
 dependencies: []
 description: Middleware for transactions
 email: 
@@ -23,7 +23,10 @@ files:
 - README.md
 - Rakefile
 - lib/rack/transaction.rb
+- lib/rack/transaction/configuration.rb
+- lib/rack/transaction/version.rb
 - rack-transaction.gemspec
+- spec/rack/transaction/configuration_spec.rb
 - spec/rack/transaction_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/p60/rack-transaction
@@ -50,5 +53,6 @@ signing_key:
 specification_version: 4
 summary: Middleware for transactions
 test_files:
+- spec/rack/transaction/configuration_spec.rb
 - spec/rack/transaction_spec.rb
 - spec/spec_helper.rb