outbacker 0.0.2

data/test/outbacker_test.rb

@@ -0,0 +1,315 @@
+require 'test_helper'
+
+class OutbackerTest < Minitest::Test
+  extend DefineTestNamesWithStrings
+
+  def teardown
+    Outbacker.configure do |c|
+      c.blacklist = Outbacker::DEFAULT_BLACKLIST
+      c.whitelist = Outbacker::DEFAULT_WHITELIST
+    end
+  end
+
+  test "the right callbacks are invoked when callbacks are specified as methods" do
+    outcomes = random_outcome_list
+    input_values = input_list_that_results_in(outcomes)
+    expected_blocks_called = expected_blocks_called_list_for(outcomes)
+    actual_blocks_called = []
+
+    input_values.each do |input_value|
+      outbacked_domain_object.some_domain_method(input_value) do |on|
+        on.outcome_of_outcome_1 do |callback_block_arg|
+          actual_blocks_called << 'outcome 1'
+        end
+
+        on.outcome_of_outcome_2 do |callback_block_arg|
+          actual_blocks_called << 'outcome 2'
+        end
+
+        on.outcome_of_outcome_3 do |callback_block_arg|
+          actual_blocks_called << 'outcome 3'
+        end
+      end
+    end
+
+    assert_equal expected_blocks_called, actual_blocks_called
+  end
+
+  test "the right callbacks are invoked when callbacks are specified with symbols" do
+    outcomes = random_outcome_list
+    input_values = input_list_that_results_in(outcomes)
+    expected_blocks_called = expected_blocks_called_list_for(outcomes)
+    actual_blocks_called = []
+
+    input_values.each do |input_value|
+      outbacked_domain_object.some_domain_method(input_value) do |on_outcome|
+        on_outcome.of(:outcome_1) do |callback_block_arg|
+          actual_blocks_called << 'outcome 1'
+        end
+
+        on_outcome.of(:outcome_2) do |callback_block_arg|
+          actual_blocks_called << 'outcome 2'
+        end
+
+        on_outcome.of(:outcome_3) do |callback_block_arg|
+          actual_blocks_called << 'outcome 3'
+        end
+      end
+    end
+
+    assert_equal expected_blocks_called, actual_blocks_called
+  end
+
+
+  test "callback block arguments are passed in correctly" do
+    actual_block_arguments_passed = []
+
+    outbacked_domain_object.some_domain_method("input that will result in outcome 4") do |on|
+      on.outcome_of_outcome_4 do |callback_block_arg1, callback_block_arg2, callback_block_arg3|
+        actual_block_arguments_passed = [callback_block_arg1, callback_block_arg2, callback_block_arg3]
+      end
+
+      on.outcome_of_outcome_1 do |callback_block_arg|
+        actual_block_arguments_passed << [callback_block_arg]
+      end
+
+      on.outcome_of_outcome_2 do |callback_block_arg|
+        actual_block_arguments_passed << [callback_block_arg]
+      end
+    end
+
+    assert_equal ["outcome 4 block arg1", "outcome 4 block arg2", "outcome 4 block arg3"], actual_block_arguments_passed
+  end
+
+
+  test "callback block arguments are passed in correctly when callbacks are specified with symbols" do
+    actual_block_arguments_passed = []
+
+    result = outbacked_domain_object.some_domain_method("input that will result in outcome 4") do |on_outcome|
+      on_outcome.of(:outcome_4) do |callback_block_arg1, callback_block_arg2, callback_block_arg3|
+        actual_block_arguments_passed = [callback_block_arg1, callback_block_arg2, callback_block_arg3]
+      end
+
+      on_outcome.of(:outcome_1) do |callback_block_arg|
+        actual_block_arguments_passed << [callback_block_arg]
+      end
+
+      on_outcome.of(:outcome_2) do |callback_block_arg|
+        actual_block_arguments_passed << [callback_block_arg]
+      end
+    end
+
+
+    assert_equal ["outcome 4 block arg1", "outcome 4 block arg2", "outcome 4 block arg3"], actual_block_arguments_passed
+  end
+
+
+  test "exception raised when no callback is provided for the actual outcome" do
+    assert_raises(RuntimeError) {
+      outbacked_domain_object.some_domain_method("input that will result in outcome 4") do |on_outcome|
+        on_outcome.of(:outcome_1) do |callback_block_arg|
+        end
+
+        on_outcome.of(:outcome_2) do |callback_block_arg|
+        end
+      end
+    }
+  end
+
+
+  test "exception raised when the actual outcome is handled more than once" do
+    assert_raises(RuntimeError) {
+      outbacked_domain_object.some_domain_method("input that will result in outcome 4") do |on_outcome|
+        on_outcome.of(:outcome_4) do |callback_block_arg|
+        end
+
+        on_outcome.of(:outcome_4) do |callback_block_arg|
+        end
+      end
+    }
+  end
+
+  test "exception raised when no block is provided for a specific outcome and callbacks are specified with symbols" do
+    assert_raises(RuntimeError) {
+      outbacked_domain_object.some_domain_method("input that will result in outcome 1") do |on_outcome|
+        on_outcome.of(:outcome_1)
+      end
+    }
+  end
+
+  test "exception raised when no block is provided for a specific outcome and callbacks are specified with methods" do
+    assert_raises(RuntimeError) {
+      outbacked_domain_object.some_domain_method("input that will result in outcome 1") do |on|
+        on.outcome_of_outcome_1
+      end
+    }
+  end
+
+  test "exception raised when no outcome is triggered" do
+    assert_raises(RuntimeError) {
+      outbacked_domain_object.domain_method_with_no_outcome("input that will result in outcome 1") do |on_outcome|
+        on_outcome.of(:outcome_1) do |callback_block_arg|
+        end
+
+        on_outcome.of(:outcome_2) do |callback_block_arg|
+        end
+      end
+    }
+  end
+
+  test "exception raised when multiple outcomes are triggered" do
+    assert_raises(RuntimeError) {
+      outbacked_domain_object.domain_method_with_multiple_outcomes do |on_outcome|
+        on_outcome.of(:outcome_1) do
+        end
+
+        on_outcome.of(:outcome_2) do
+        end
+      end
+    }
+  end
+
+  test "when no callback block is provided it returns the callback key and any arguments that were to be passed to the callback" do
+    domain_object = outbacked_domain_object
+    outcomes = random_outcome_list
+    input_values = input_list_that_results_in(outcomes)
+    expected_return_values = outcomes.map { |outcome|
+      [:"outcome_#{outcome}", "outcome #{outcome} block argument"]
+    }
+    actual_return_values = []
+
+    input_values.each do |input_value|
+      actual_return_values << domain_object.some_domain_method(input_value)
+    end
+
+    assert_equal expected_return_values, actual_return_values
+  end
+
+
+
+  test "including within a subclass of ActiveRecord raises an exception" do
+    assert_raises(RuntimeError) {
+      class SomeActiveRecordClass < ActiveRecord::Base
+        include Outbacker
+      end
+    }
+  end
+
+
+  test "including within a subclass of ActionController raises an exception" do
+    assert_raises(RuntimeError) {
+      class SomeControllerClass < ActionController::Base
+        include Outbacker
+      end
+    }
+  end
+
+
+  test "including within a class that isn't a subclass of ActiveRecord does not raise an exception" do
+    class SomeNonActiveRecordOrControllerClass
+      include Outbacker
+    end
+
+    assert_respond_to SomeNonActiveRecordOrControllerClass.new, :with
+  end
+
+  test "trying to include a subclass of another blacklisted class raises an exception" do
+    class BlacklistedClass
+    end
+
+    Outbacker.configure do |c|
+      c.blacklist = [BlacklistedClass]
+    end
+
+    assert_raises(RuntimeError) {
+      class MyBlacklistedClass < BlacklistedClass
+        include Outbacker
+      end
+    }
+
+  end
+
+  test "when a whitelist is set, trying to include a subclass of a non-whitelisted class raises an exception" do
+    class WhitelistedClass
+    end
+
+    class NonWhitelistedClass
+    end
+
+    Outbacker.configure do |c|
+      c.whitelist = [WhitelistedClass]
+    end
+
+    assert_raises(RuntimeError) {
+      class MyNonWhitelistedClass < NonWhitelistedClass
+        include Outbacker
+      end
+    }
+
+  end
+
+  test "when a whitelist is set, trying to include a subclass of a whitelisted class doesn't raise an exception" do
+    class WhitelistedClass
+      include Outbacker
+    end
+
+    Outbacker.configure do |c|
+      c.whitelist = [WhitelistedClass]
+    end
+
+    assert_respond_to WhitelistedClass.new, :with
+  end
+
+
+
+  private
+
+  def random_outcome_list
+    [*1..3].shuffle
+  end
+
+  def input_list_that_results_in(outcomes)
+    outcomes.map { |outcome| "input that will result in outcome #{outcome}" }
+  end
+
+  def expected_blocks_called_list_for(outcomes)
+    outcomes.map { |outcome| "outcome #{outcome}" }
+  end
+
+  def outbacked_domain_object
+    SomeDomainObject.new
+  end
+end
+
+
+class SomeDomainObject
+  include Outbacker
+
+  def some_domain_method(arg, &outcome_handlers)
+    with(outcome_handlers) do |outcomes|
+      case arg
+      when 'input that will result in outcome 1'
+        outcomes.handle :outcome_1, "outcome 1 block argument"
+      when 'input that will result in outcome 2'
+        outcomes.handle :outcome_2, "outcome 2 block argument"
+      when 'input that will result in outcome 3'
+        outcomes.handle :outcome_3, "outcome 3 block argument"
+      when 'input that will result in outcome 4'
+        outcomes.handle :outcome_4, "outcome 4 block arg1", "outcome 4 block arg2", "outcome 4 block arg3"
+      end
+
+    end
+  end
+
+  def domain_method_with_no_outcome(arg, &outcome_handlers)
+    with(outcome_handlers) do |outcomes|
+    end
+  end
+
+  def domain_method_with_multiple_outcomes(&outcome_handlers)
+    with(outcome_handlers) do |outcomes|
+      outcomes.handle :outcome_1
+      outcomes.handle :outcome_2
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,64 @@
+require "codeclimate-test-reporter"
+CodeClimate::TestReporter.start
+
+require 'minitest/autorun'
+require 'minitest/pride'
+
+#
+# Stub out ActiveRecord just for testing purposes, so we don't
+# need to load and have a dependency on Rails just to test that
+# the module shouldn't be included directly within an
+# ActiveRecord class.
+#
+module ActiveRecord
+  class Base
+  end
+end
+
+module ActionController
+  class Base
+  end
+end
+
+require 'outbacker'
+require 'test_support/outbacker_stub'
+
+
+#
+# Allow for Rails-style test names, where test names can be defined with
+# strings rather than a Ruby-method name with underscores.
+#
+# Usage:
+#
+#   class
+#     extend DefineTestNamesWithStrings
+#     ...
+#     test "a descriptive test name" do
+#       ...
+#     end
+#   end
+#
+# Note: We could have just pulled this in from ActiveSupport::TestCase,
+# but I wanted to avoid the dependency.
+#
+module DefineTestNamesWithStrings
+
+  # Helper to define a test method using a String. Under the hood, it replaces
+  # spaces with underscores and defines the test method.
+  #
+  #   test "verify something" do
+  #     ...
+  #   end
+  def test(name, &block)
+    test_name = "test_#{name.gsub(/\s+|,/,'_')}".to_sym
+    defined = method_defined? test_name
+    raise "#{test_name} is already defined in #{self}" if defined
+    if block_given?
+      define_method(test_name, &block)
+    else
+      define_method(test_name) do
+        flunk "No implementation provided for #{name}"
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,167 @@
+--- !ruby/object:Gem::Specification
+name: outbacker
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Anthony Garcia
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-07-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '5.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '5.5'
+- !ruby/object:Gem::Dependency
+  name: m
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.1
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: configurations
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.2.0
+- !ruby/object:Gem::Dependency
+  name: codeclimate-test-reporter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |2
+      A micro library to keep conditional logic out of your Rails
+      controllers and help you write more intention-revealing
+      code with both skinny controllers and skinny models.
+email:
+- polypressure@outlook.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- examples/app/controllers/appointments_controller.rb
+- examples/app/domain/appointment_calendar.rb
+- examples/config/initializers/outbacker.rb
+- examples/test/controllers/appointments_controller_test.rb
+- lib/outbacker.rb
+- lib/outbacker/version.rb
+- lib/test_support/outbacker_stub.rb
+- outbacker.gemspec
+- test/outbacker_stub_test.rb
+- test/outbacker_test.rb
+- test/test_helper.rb
+homepage: https://github.com/polypressure/outbacker
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Drive complexity out of your Rails controllers once and for all, while keeping
+  your models fit and trim.
+test_files:
+- test/outbacker_stub_test.rb
+- test/outbacker_test.rb
+- test/test_helper.rb