funktional 1.0.0

data/lib/funktional/context/should_block.rb

@@ -0,0 +1,60 @@
+module Funktional
+  class ShouldBlock
+    
+    def self.build(options, context, &blk)
+      return self.new(name = options, context, &blk) if options.is_a? String
+      
+      options = {:render_404 => 'public/404'} if options == :render_404
+      
+      case options.keys.first
+        when :create
+          ShouldCreateBlock.new(options[:create], context)
+        when :delete
+          ShouldDeleteBlock.new(options[:delete], context)
+        else
+          DelegatingShouldBlock.new(options, context, &blk)
+      end
+    end
+    
+    def initialize(should_name, context, &blk)
+      raise 'block required' unless block_given?
+      @should_name, @blk, @context = should_name, blk, context
+    end
+    
+    def to_test
+      context, blk, before = @context, @blk, @before
+      
+      @context.test_unit_class.send(:define_method, build_test_name) do
+        begin
+          context.run_parent_setup_blocks(self)
+          before.bind(self).call if before
+          
+          context.run_current_setup_blocks(self)
+          blk.bind(self).call
+        ensure
+          context.run_all_teardown_blocks(self)
+        end
+      end
+    end
+    
+    protected
+    
+    def test_and_line_no
+      stack_frame = caller.grep(/bind/).last
+      stack_frame.split(':in ').first
+    end
+    
+    def build_test_name
+      test_name = test_name_parts.flatten.join(' ')
+      
+      if @context.test_unit_class.instance_methods.include?(test_name)
+        warn "  * WARNING: '#{test_name}' is already defined"
+      end
+      return test_name.to_sym
+    end
+    
+    def test_name_parts
+      ["test:", @context.full_name, "should", "#{@should_name}."]
+    end
+  end
+end

data/lib/funktional/context/should_create_block.rb

@@ -0,0 +1,17 @@
+module Funktional
+  class ShouldCreateBlock < ShouldBlock
+    
+    def initialize(klass, context)
+      @context = context
+      @should_name = "create a #{klass}"
+      
+      @before = lambda { @before_setup_count = klass.count }
+      where = test_and_line_no
+      
+      @blk = lambda do
+        expected_count = @before_setup_count + 1
+        assert_equal expected_count, klass.count, "New [#{klass}] was not created. #{where}"
+      end
+    end
+  end
+end

data/lib/funktional/context/should_delete_block.rb

@@ -0,0 +1,17 @@
+module Funktional
+  class ShouldDeleteBlock < ShouldBlock
+    
+    def initialize(klass, context)
+      @context = context
+      @should_name = "delete a #{klass}"
+      
+      @before = lambda { @before_setup_count = klass.count }
+      where = test_and_line_no
+      
+      @blk = lambda do
+        expected_count = @before_setup_count - 1 
+        assert_equal expected_count, klass.count, "New [#{klass}] was not deleted. #{where}"
+      end
+    end
+  end
+end

data/lib/funktional/context/should_not_block.rb

@@ -0,0 +1,20 @@
+module Funktional
+  class ShouldNotBlock
+    
+    def self.build(options, context, &blk)
+      
+      if options.is_a? Symbol and options.eql? :send_email
+        return ShouldNotSendEmailBlock.new(context)
+      end
+      
+      case options.keys.first
+        when :create
+          ShouldNotCreateBlock.new(options[:create], context)
+        when :delete
+          ShouldNotDeleteBlock.new(options[:delete], context)
+        else
+          raise "Unknown assertion [should_not #{options.inspect}]"
+      end
+    end
+  end
+end

data/lib/funktional/context/should_not_create_block.rb

@@ -0,0 +1,17 @@
+module Funktional
+  class ShouldNotCreateBlock < ShouldBlock
+    
+    def initialize(klass, context)
+      @context = context
+      @should_name = "not create a #{klass}"
+      
+      @before = lambda { @before_setup_count = klass.count }
+      where = test_and_line_no
+      
+      @blk = lambda do
+        expected_count = @before_setup_count
+        assert_equal expected_count, klass.count, "New [#{klass}] was created. #{where}"
+      end
+    end
+  end
+end

data/lib/funktional/context/should_not_delete_block.rb

@@ -0,0 +1,17 @@
+module Funktional
+  class ShouldNotDeleteBlock < ShouldBlock
+    
+    def initialize(klass, context)
+      @context = context
+      @should_name = "not delete a #{klass}"
+      
+      @before = lambda { @before_setup_count = klass.count }
+      where = test_and_line_no
+      
+      @blk = lambda do
+        expected_count = @before_setup_count
+        assert_equal expected_count, klass.count, "New [#{klass}] was deleted. #{where}"
+      end
+    end
+  end
+end

data/lib/funktional/context/should_not_send_email_block.rb

@@ -0,0 +1,18 @@
+module Funktional
+  class ShouldNotSendEmailBlock < ShouldBlock
+    
+    def initialize(context)
+      @context = context
+      @should_name = "not send an email"
+      
+      @before = lambda { @before_setup_count = ActionMailer::Base.deliveries.size }
+      where = test_and_line_no
+      
+      @blk = lambda do
+        expected_count = @before_setup_count
+        current = ActionMailer::Base.deliveries.size
+        assert_equal expected_count, current, "New [Email] was sent."
+      end
+    end
+  end
+end

data/lib/funktional/context/stack_recorder.rb

@@ -0,0 +1,35 @@
+module Funktional
+  class BlankSlate
+    instance_methods.each { |m| undef_method m unless m =~ /^__/ }
+  end
+  
+  class StackRecorder < BlankSlate
+    attr_reader :__target
+    
+    def initialize(target)
+      @__target = target
+      @__methods = []
+    end
+    
+    def __meth(index)
+      @__methods[index]
+    end
+    
+    def __each_called
+      @__methods.each { |meth| yield [meth[:name], meth[:args], meth[:block]] }
+    end
+    
+    def __last_value
+      @__methods.last[:args].first
+    end
+    
+    def method_missing(method_name, *args, &block)
+      @__methods << {
+        :name => method_name,
+        :args => args,
+        :block => block
+      }
+      return self
+    end
+  end
+end

data/lib/funktional/context.rb

@@ -0,0 +1,126 @@
+# borrowing heavily from shoulda contexts.
+
+module Funktional
+  class Context
+    
+    attr_accessor :name
+    attr_accessor :parent
+    attr_accessor :sub_contexts
+    attr_accessor :setup_blocks
+    attr_accessor :teardown_blocks
+    attr_accessor :should_blocks
+    
+    def initialize(name, parent, &blk)
+      Funktional.add_context(self)
+      self.name = name
+      self.parent = parent
+      self.setup_blocks = []
+      self.teardown_blocks = []
+      self.should_blocks = []
+      self.sub_contexts = []
+      
+      merge_block(&blk)
+      Funktional.remove_context
+    end
+    
+    def merge_block(&blk)
+      blk.bind(self).call
+    end
+    
+    def context(name, &blk)
+      self.sub_contexts << Context.new(name, self, &blk)
+    end
+    
+    def setup(&blk)
+      self.setup_blocks << blk
+    end
+    
+    alias :before :setup
+    
+    def teardown(&blk)
+      self.teardown_blocks << blk
+    end
+    
+    alias :after :teardown
+    
+    def should(options, &blk)
+      self.should_blocks << ShouldBlock.build(options, self, &blk)
+    end
+    
+    def should_not(options, &blk)
+      self.should_blocks << ShouldNotBlock.build(options, self, &blk)
+    end
+    
+    def element(selector)
+      recorder = StackRecorder.new(selector)
+      self.should_blocks << ElementShouldBlock.new(recorder, self)
+      
+      return recorder
+    end
+    
+    def count(selector)
+      recorder = StackRecorder.new(selector)
+      self.should_blocks << CountShouldBlock.new(recorder, self)
+      
+      return recorder
+    end
+    
+    def assigned(target)
+      recorder = StackRecorder.new(target)
+      self.should_blocks << AssignedShouldBlock.new(recorder, self)
+      
+      return recorder
+    end
+    
+    def flashed(kind)
+      recorder = StackRecorder.new(kind)
+      self.should_blocks << FlashedShouldBlock.new(recorder, self)
+      
+      return recorder
+    end
+    
+    def full_name
+      parent_name = parent.full_name if sub_context?
+      return [parent_name, name].join(" ").strip
+    end
+    
+    def sub_context?
+      parent.is_a?(self.class)
+    end
+    
+    def test_unit_class
+      sub_context? ? parent.test_unit_class : parent
+    end
+    
+    def run_all_setup_blocks(binding)
+      run_parent_setup_blocks(binding)
+      run_current_setup_blocks(binding)
+    end
+    
+    def run_parent_setup_blocks(binding)
+      self.parent.run_all_setup_blocks(binding) if sub_context?
+    end
+    
+    def run_current_setup_blocks(binding)
+      setup_blocks.each do |setup_block|
+        setup_block.bind(binding).call
+      end
+    end
+    
+    def run_all_teardown_blocks(binding)
+      teardown_blocks.reverse.each do |teardown_block|
+        teardown_block.bind(binding).call
+      end
+      self.parent.run_all_teardown_blocks(binding) if sub_context?
+    end
+    
+    def build
+      self.should_blocks.map(&:to_test)
+      sub_contexts.each { |context| context.build }
+    end
+    
+    def method_missing(method, *args, &blk)
+      test_unit_class.send(method, *args, &blk)
+    end
+  end
+end

data/lib/funktional/email_assertion.rb

@@ -0,0 +1,50 @@
+module Funktional
+  class EmailAssertion < Funktional::Assertion
+    def initialize(expectations)
+      if ActionMailer::Base.deliveries.size < 1
+        flunk 'No emails have been sent'
+      end
+      
+      email = ActionMailer::Base.deliveries.last
+      
+      expectations.each_key do |key|
+        case key
+          when :from
+            then check_from(expectations[:from], email.from)
+          when :to
+            then check_to(expectations[:to], email.to)
+          when :subject
+            then assert_equal expectations[:subject], email.subject
+          when :containing
+            then check_containing(expectations[:containing], email.body)
+          else
+            flunk "Assertion key: [#{key}] not recognised"
+        end
+      end
+    end
+    
+    def check_from(expected_from, email_from)
+      if email_from.nil?
+        flunk 'email is missing a [from]'
+      end
+      assert_equal expected_from, email_from[0]
+    end
+    
+    def check_to(expected_to, email_to)
+      if email_to.nil?
+        flunk 'email is missing a [to]'
+      end
+      assert_equal expected_to, email_to[0]
+    end
+    
+    def check_containing(should_contain, body)
+      if should_contain.is_a? Array
+        should_contain.each do |should_i|
+          assert_match /#{Regexp.escape(should_i)}/, body
+        end
+      else
+        assert_match /#{Regexp.escape(should_contain)}/, body
+      end
+    end
+  end
+end

data/lib/funktional/flashed_assertion.rb

@@ -0,0 +1,12 @@
+module Funktional
+  class FlashedAssertion < Funktional::Assertion
+    def initialize(symbol)
+      @symbol = symbol
+    end
+    
+    def should_be(expected_value)
+      assert_not_nil flash[@symbol], "Flash is empty [#{expected_value}] expected."
+      assert_equal expected_value, flash[@symbol]
+    end
+  end
+end

data/lib/funktional/model_assertions.rb

@@ -0,0 +1,108 @@
+module Funktional
+  module ModelAssertions
+    def should_require_a(field, expected_error_message = nil)
+      check_test_instance!
+      must_be_valid_before_test!
+      
+      assign_nil_to(field, expected_error_message) do
+        assert_invalid("'#{self.class.name}' should require a '#{field}'")
+      end
+    end
+    
+    alias :should_require_an :should_require_a
+    
+    def should_not_require_a(field)
+      check_test_instance!
+      
+      assign_nil_to(field) do
+        assert_valid
+      end
+    end
+    
+    alias :should_not_require_an :should_not_require_a
+    
+    def should_have_invalid(field, expected_error_message = nil)
+      check_test_instance!
+      
+      assert_invalid("'#{self.class.name}' should have invalid '#{field}'")
+      assert_message(field, expected_error_message) if expected_error_message
+    end
+    
+    def should_mass_assign(*fields)
+      check_test_instance!
+      fields.each do |field|
+        Funktional.test_instance.assert self.class.accessible_attributes.include?(field.to_s)
+      end
+    end
+    
+    def should_not_mass_assign(*fields)
+      check_test_instance!
+      accessible_attrib = self.class.accessible_attributes.to_a
+      protected_attrib = self.class.protected_attributes.to_a
+      fields = fields.map(&:to_s)
+      
+      if accessible_attrib.any?
+        common_fields = (accessible_attrib & fields)
+        @test.assert((common_fields.size == 0), "#{common_fields.inspect} marked accessible")
+      elsif protected_attrib.any?
+        common_fields = (protected_attrib & fields)
+        difference = (fields - protected_attrib)
+        @test.assert((common_fields.size == fields.size), "#{difference.inspect} not protected")
+      else
+        @test.flunk "#{fields.inspect} not protected"
+      end
+    end
+    
+    def should_protect(*fields)
+      check_test_instance!
+      fields.each do |field|
+        Funktional.test_instance.assert self.class.protected_attributes.include?(field.to_s)
+      end
+    end
+    
+    def should_respond_to(method)
+      Funktional.test_instance.assert_respond_to self, method
+    end
+    
+    private
+    
+    def assign_nil_to(field, expected_error_message = nil)
+      saved_existing_value = self.send field
+      self.send "#{field}=", nil
+      
+      yield
+      
+      assert_message(field, expected_error_message) if expected_error_message
+      self.send "#{field}=", saved_existing_value
+      
+      # clear errors
+      self.valid?
+    end
+    
+    def assert_invalid(message)
+      Funktional.test_instance.assert self.invalid?, message
+    end
+    
+    def assert_valid
+      Funktional.test_instance.assert self.valid?
+    end
+    
+    def assert_message(field, expected_error_message)
+      Funktional.test_instance.assert_equal(expected_error_message, self.errors[field])
+    end
+    
+    def must_be_valid_before_test!
+      if self.invalid?
+        error = "Funktional requires a valid instance of #{self.class.name}"
+        Funktional.test_instance.flunk error
+      end
+    end
+    
+    def check_test_instance!
+      if Funktional.test_instance.nil?
+        raise Funktional::Setup::Error, 'Did you forget to (setup :funktional) in test/test_helper?'
+      end
+      @test = Funktional.test_instance
+    end
+  end
+end

data/lib/funktional/random_characters.rb

@@ -0,0 +1,11 @@
+module Funktional
+  module RandomCharacters
+    def random_characters
+      chars = 'abcdefghjkmnpqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23456789'
+      str = ''
+      self.times { str << chars[rand(chars.size)] }
+      
+      return str
+    end
+  end
+end

data/lib/funktional/recursive_assertion.rb

@@ -0,0 +1,23 @@
+module Funktional
+  class RecursiveAssertion < Funktional::Assertion
+    def initialize(assigned, method)
+      @test = Funktional.test_instance
+      @assigned = assigned
+      @method = method
+      
+      @test.assert_respond_to @assigned, @method
+    end
+    
+    def should_be(expected_value)
+      value = @assigned.send @method
+      @test.assert_equal expected_value, value
+    end
+    
+    protected
+    
+    def method_missing(method, *args)
+      @assigned = @assigned.send @method
+      RecursiveAssertion.new(@assigned, method)
+    end
+  end
+end

data/lib/funktional/route_checker.rb

@@ -0,0 +1,49 @@
+module Funktional
+  
+  class RouteChecker
+    instance_methods.each do |method|
+      undef_method(method) unless %w(__send__ __id__ instance_eval).include?(method)
+    end
+    
+    attr_reader :__path_and_method, :__controller_action_etc
+    
+    def self.build(params, &blk)
+      checker = self.new(params)
+      
+      checker.instance_eval(&blk)
+      return checker
+    end
+    
+    def initialize(params)
+      @__path_and_method = __get_path_and_method(params)
+      @__controller_action_etc = {}
+    end
+    
+    def __test_name
+      path = @__path_and_method[:path]
+      method = @__path_and_method[:method]
+      
+      "route '#{path}' :method '#{method}' to #{@__controller_action_etc.inspect}"
+    end
+    
+    def method_missing(method_name, value)
+      @__controller_action_etc[method_name] = value
+    end
+    
+    private
+    
+    def __get_path_and_method(params)
+      if params.is_a? Hash
+        {
+          :path => params[:route],
+          :method => params[:method].to_sym
+        }
+      else
+        {
+          :path => params,
+          :method => :get
+        }
+      end
+    end
+  end
+end

data/lib/funktional/setup.rb

@@ -0,0 +1,11 @@
+module Funktional
+  mattr_accessor :test_instance
+  
+  module Setup
+    def funktional
+      Funktional.test_instance = self
+    end
+    
+    class Error < RuntimeError; end
+  end
+end

data/lib/funktional/test_class_methods.rb

@@ -0,0 +1,28 @@
+module Funktional
+  
+  module TestClassMethods
+    def context(name, &blk)
+      if Funktional.current_context
+        Funktional.current_context.context(name, &blk)
+      else
+        context = Funktional::Context.new(name, self, &blk)
+        context.build
+      end
+    end
+    
+    def should(name, &blk)
+      if Funktional.current_context
+        raise 'block required' unless block_given?
+        Funktional.current_context.should(name, &blk)
+      else
+        context_name = self.name.gsub(/Test/, "")
+        
+        context = Funktional::Context.new(context_name, self) do
+          raise 'block required' unless block_given?
+          should(name, &blk)
+        end
+        context.build
+      end
+    end
+  end
+end