adva 0.0.1

data/test/with-sugar/lib/with-sugar/controller.rb

@@ -0,0 +1,110 @@
+module With
+  @@variable_types = {:headers => :to_s, :flash => nil, :session => nil, :flash_cookie => nil}
+
+  def it_renders(render_method, *args, &block)
+    send("it_renders_#{render_method}", *args, &block)
+  end
+
+  def it_renders_blank(options = {})
+    asserts_status options[:status]
+    assert @response.body.strip.blank?
+  end
+
+  def it_renders_template(template_name, options = {}, &block)
+    template_name = instance_eval &template_name if template_name.is_a?(Proc)
+
+    assert_status options[:status]
+    assert_content_type options[:format]
+    assert_template template_name.to_s
+
+    instance_eval &block if block
+  end
+
+  def it_assigns(*names)
+    names.each do |name|
+      if name.is_a?(Symbol)
+        it_assigns name => name # go forth and recurse!
+      elsif name.is_a?(Hash)
+        name.each do |key, value|
+          if @@variable_types.key?(key) then send("it_assigns_#{key}", value)
+          else it_assigns_example_values(key, value) end
+        end
+      end
+    end
+  end
+
+  def it_assigns_example_values(name, value)
+    case value
+    when :not_nil
+      assert_not_nil assigns(name),
+        "expected @#{name} not to be nil, but it is nil"
+    when :undefined
+      assert !@controller.send(:instance_variables).include?("@#{name}"),
+        "expected @#{name} not to be undefined, but it is defined"
+    when Symbol
+      if (instance_variable = instance_variable_get("@#{value}")).nil?
+        assert_not_nil assigns(name), "expected @#{name} not to be nil, but it is nil"
+      else
+        assert_equal instance_variable, assigns(name),
+          "expected @#{instance_variable} to be equal to #{assigns(name).inspect}, but it is not"
+      end
+    when Class
+      assert value === assigns(name), "expected #{assigns(name).inspect} to be an instance of #{value.inspect}"
+    when Proc
+      assert_equal instance_eval(&value), assigns(name)
+    else
+      assert_equal value, assigns(name)
+    end
+  end
+
+  @@variable_types.each do |collection_type, collection_op|
+    public
+      define_method "it_assigns_#{collection_type}" do |values|
+        values.each do |key, value|
+          send("it_assigns_#{collection_type}_values", key, value)
+        end
+      end
+
+    protected
+      define_method "it_assigns_#{collection_type}_values" do |key, value|
+        key = key.send(collection_op) if collection_op
+        collection = @response.send(collection_type)
+        case value
+          when nil
+            assert_nil collection[key]
+          when :not_nil
+            assert_not_nil collection[key]
+          when :undefined
+            assert !collection.include?(key), "#{collection_type} includes #{key}"
+          when Proc
+            assert_equal instance_eval(&value), collection[key]
+          else
+            assert_equal value, collection[key]
+        end
+      end
+  end
+
+  def it_redirects_to(path = nil, &block)
+    path ||= instance_eval(&block)
+    assert_redirected_to path
+  end
+
+  protected
+
+    def assert_content_type(type = :html)
+      mime = Mime::Type.lookup_by_extension((type || :html).to_s)
+      assert_equal mime, @response.content_type, "Renders with Content-Type of #{@response.content_type}, not #{mime}"
+    end
+
+    def assert_status(status)
+      case status
+      when String, Fixnum
+        assert_equal status.to_s, @response.code, "Renders with status of #{@response.code.inspect}, not #{status}"
+      when Symbol
+        code_value = ActionController::StatusCodes::SYMBOL_TO_STATUS_CODE[status]
+        assert_equal code_value.to_s, @response.code, "Renders with status of #{@response.code.inspect}, not #{code_value.inspect} (#{status.inspect})"
+      else
+        assert_equal "200", @response.code, "Is not successful"
+      end
+    end
+end

data/test/with-sugar/lib/with-sugar/core.rb

@@ -0,0 +1,7 @@
+module With
+  class Context
+    def it_raises(exception = nil)
+      before { @_expected_exception = exception }
+    end
+  end
+end

data/test/with-sugar/lib/with-sugar/model.rb

@@ -0,0 +1,151 @@
+module With
+  class Context
+    def it_changes(expressions, message = nil)
+      expressions.each do |expression, difference|
+        before { record_before_state(expression) }
+        assertion "it changes #{expression} by #{difference}" do
+          assert_state_change(expression, difference, message)
+        end
+      end
+    end
+    
+    def it_does_not_change(*expressions)
+      expressions.each do |expression|
+        before { record_before_state(expression) }
+        assertion "it does not change #{expression}" do
+          assert_no_state_change(expression)
+        end
+      end
+    end
+    
+    def it_updates(*names)
+      names.each do |name|
+        before { record_before_state("all_attributes(@#{name})") }
+        assertion "it updates #{name}" do
+          previous = @before_states["all_attributes(@#{name})"]
+          current = all_attributes(assigns(name).reload)
+          assert_not_equal previous, current, "expected #{name} to be updated, but wasn't"
+        end
+      end
+    end
+    
+    def it_does_not_update(*names)
+      names.each do |name|
+        before { record_before_state("@#{name}.attributes") }
+        assertion "it does not update #{name}" do
+          previous = @before_states["@#{name}.attributes"]
+          current = assigns(name).reload.attributes
+          assert_equal previous, current, "expected #{name} not to be updated (was: #{previous.inspect}, now is: #{current.inspect})"
+        end
+      end
+    end
+    
+    def it_destroys(name)
+      assertion "it destroys #{name}" do
+        record = assigns(name) || instance_variable_get("@#{name}")
+        assert_raises ActiveRecord::RecordNotFound do
+          # name.to_s.classify.constantize
+          record.class.find(record.id)
+        end
+      end
+    end
+    
+    def it_versions(*names)
+      names.each do |name|
+        before { record_before_state("@#{name}.version") }
+        assertion "it versions #{name}" do
+          previous = @before_states["@#{name}.version"]
+          current  = assigns(name).reload.version
+          message  = "expected #{name} to be versioned (changed from #{previous} to #{current}), but wasn't"
+          assert_equal previous + 1, current, message
+        end
+      end
+    end
+    
+    def it_does_not_version(*names)
+      names.each do |name|
+        before { record_before_state("@#{name}.version") }
+        assertion "it versions #{name}" do
+          previous = @before_states["@#{name}.version"]
+          current  = assigns(name).reload.version
+          message  = "expected #{name} not to be versioned,  but was (changed from #{previous} to #{current})"
+          assert_equal previous, current, message
+        end
+      end
+    end
+    
+    # test that the assigned record temporarily has been reverted to the given version
+    def it_reverts(name, options)
+      expected = options[:to] or raise "need to pass the target version as an option"
+      assertion "it reverts the #{name} to version #{expected}" do
+        actual  = assigns(name).version
+        message = "expected #{name} to be rolledback to version #{expected}, but was #{actual}"
+        assert_equal expected.to_i, actual.to_i, message
+      end
+    end
+    
+    # test that the assigned record has been reverted to the given version and saved
+    def it_rollsback(name, options)
+      expected = options[:to] or raise "need to pass the target version as an option"
+      assertion "it rollsback the #{name} to version #{expected}" do
+        actual  = assigns(name).reload.version
+        message = "expected #{name} to be rolledback to version #{expected}, but was #{actual}"
+        assert_equal expected.to_i, actual.to_i, message
+      end
+    end
+    
+    def it_does_not_rollback(name)
+      before { record_before_state("@#{name}.version") }
+
+      assertion "it does not rollback the #{name}" do
+        previous = @before_states["@#{name}.version"]
+        current  = assigns(name).reload.version
+        message  = "expected #{name} not to be rolledback from version #{previous}, but was #{current}"
+        assert_equal previous, current, message
+      end
+    end
+  end
+  
+  def it_saves(*names)
+    names.each do |name|
+      assert !assigns(name).new_record?
+    end
+  end
+
+  def it_does_not_save(*names)
+    names.each do |name|
+      assert assigns(name).new_record?
+    end
+  end
+
+  protected
+  
+    def record_before_state(expression)
+      @before_states ||= {}
+      @before_states[expression] = instance_eval(expression)
+    end
+  
+    # merges in translated attributes, if present
+    def all_attributes(model)
+      model.respond_to?(:translated_attributes) ?
+        model.attributes.merge( model.translated_attributes ) :
+        model.attributes
+    end
+    
+    def assert_state_change(expression, difference, message = nil)
+      expected = @before_states[expression] + difference
+      result   = instance_eval(expression)
+      message  = [message, "expected #{expression} to be #{expected} but was #{result}"]
+    
+      assert_equal expected, result, message.compact.join("\n")
+    end
+  
+    def assert_no_state_change(expression)
+      expected = @before_states[expression]
+      result   = instance_eval(expression)
+      message  = "expected #{expression} to not change, but changed from #{expected} to #{result}"
+    
+      assert_equal expected, result, message
+    end
+end
+

data/test/with-sugar/lib/with-sugar/routing.rb

@@ -0,0 +1,30 @@
+module With
+  @@variable_types = {:headers => :to_s, :flash => nil, :session => nil, :flash_cookie => nil}
+
+  def params_from(path, method = :get)
+    ActionController::Routing::Routes.recognize_path(path, :method => method, :host_with_port => @request.host_with_port)
+  end
+  
+  def it_maps(method, path, params = {})
+    path, format = $1, $2 if path =~ /(.*)\.([\w]+)$/
+    
+    if path_prefix = params.delete(:path_prefix)
+      path = path_prefix + path
+    end
+
+    if path_suffix = params.delete(:path_suffix)
+      path = path + path_suffix
+    end
+    
+    path = '/' if path.empty?
+    path.gsub!('//', '/')
+    path = path + '.' + format if format
+
+    params[:controller] ||= @controller.class.controller_path
+    assert_recognizes params, {:path => path, :method => method }
+  end
+
+  def it_generates(path, params)
+    assert_generates path, params
+  end
+end

data/test/with-sugar/lib/with-sugar/view.rb

@@ -0,0 +1,65 @@
+module With
+  class << self
+    def view(name, options = {}, &block)
+      if block_given?
+        views[name.to_sym] = Call.new(name, &block)
+      else
+        views[name.to_sym] or raise "can not find view #{name.inspect}"
+      end
+    end
+    
+    def views
+      @@views ||= {}
+    end
+  end
+  
+  module ClassMethods
+    def view(name, options = {}, &block)
+      options[:path] ||= controller_class.controller_path if respond_to?(:controller_class)
+      name = "#{options[:path]}/#{name}"
+      With.view name, options, &block
+    end
+  end
+  
+  def it_renders_view(name, options = {}, &block)
+    it_renders_template options.delete(:template) || name
+    shows name, options, &block
+  end
+  
+  def state(name)
+    yield if @_with_view_options[:state] == name
+  end
+  
+  def shows(name, options = {}, &block)
+    name = "#{@controller.class.controller_path}/#{name}"
+    @_with_view_options = options
+    instance_eval &With.view(name, :path => @controller.class.controller_path)
+  end
+  
+  def has_text(pattern)
+    pattern = /#{pattern}/ unless pattern.is_a?(Regexp)
+    assert_match pattern, @response.body
+  end
+  
+  def does_not_have_text(pattern)
+    pattern = /#{pattern}/ unless pattern.is_a?(Regexp)
+    assert @response.body !~ pattern
+  end
+  
+  def has_tag(*args, &block)
+    assert_select *args, &block
+  end
+  
+  def has_form_posting_to(path, &block)
+    path = instance_eval(&path) if path.is_a?(Proc)
+    assert_select "form[method=post][action=#{path}]", &block
+  end
+  
+  def has_form_putting_to(path, &block)
+    path = instance_eval(&path) if path.is_a?(Proc)
+    assert_select "form[method=post][action=#{path}]" do
+      assert_select 'input[name=_method][value=put]'
+      instance_eval &block if block
+    end
+  end
+end

data/test/with-sugar/test/helper.rb

@@ -0,0 +1,19 @@
+$:.push File.expand_path(File.dirname(__FILE__) + '/../../with/lib')
+$:.push File.expand_path(File.dirname(__FILE__) + '/../lib')
+
+# require 'action_pack'
+# require 'action_controller'
+# require 'action_controller/test_process'
+# require 'active_support'
+
+module ActionController
+  class TestCase < Test::Unit::TestCase
+    # Sucky.
+    # Placeholder so test/unit ignores test cases without any tests.
+    def default_test
+    end
+  end
+end
+
+require 'with'
+require 'with-sugar/view'

data/test/with-sugar/test/view_test.rb

@@ -0,0 +1,12 @@
+require File.dirname(__FILE__) + '/helper'
+
+class ViewTest < Test::Unit::TestCase
+  def setup
+    With.views.clear
+  end
+  
+  def test_registers_views_as_call
+    With.view(:foo) {}
+    assert_equal :foo, With.view(:foo).name
+  end
+end

data/test/with/README.textile

@@ -0,0 +1,136 @@
+h1. With
+
+*HIGHLY EXPERIMENTAL!*
+
+Heavily inspired by both 
+"context":http://github.com/jeremymcanally/context 
+by "Jeremy McAnally":http://github.com/jeremymcanally and 
+"context_on_crack":http://github.com/technoweenie/context_on_crack
+(as well as "rspec_on_rails_on_crack":http://github.com/technoweenie/rspec_on_rails_on_crack)
+by "Rick Olson":http://github.com/technoweenie.
+
+For some demo code see: runnable "demo controller test":http://github.com/svenfuchs/with/tree/master/demo.rb.
+Style and initial motivation: "http://gist.github.com/30436":http://gist.github.com/30436. 
+
+In short the goal of this library is:
+
+# setup preconditions for tests/assertions in a more flexible and concise way
+# run as many assertions with common preconditions (setup/before) at once as possible
+
+So it allows to write test/unit tests like this:
+
+<pre><code>
+  describe 'POST to :create' do
+    action { post :create, @params }
+  
+    with :login_as_admin do
+      it_assigns :article
+
+      it "succeeds", :with => :valid_article_params do
+        it_redirects_to 'articles/1'
+        # more assertions ...
+      end
+      
+      it "fails", :with => :invalid_article_params do
+        it_assigns_flash :error, :not_nil
+        # more assertions ...
+      end
+    end
+  
+    with [:login_as_user, :no_login] do
+      it_redirects_to '/login'
+    end
+  end
+</code></pre>
+
+This piece of code will generate at least 4 tests:
+
+<pre><code>
+  test_POST_to_create_with_login_as_admin_and_with_valid_article_params
+  test_POST_to_create_with_login_as_admin_and_with_invalid_article_params
+  test_POST_to_create_with_login_as_user
+  test_POST_to_create_with_no_login
+  # TODO test method names should include the assertion block names (e.g. "succeeds")
+</code></pre>
+
+Shared context blocks can be setup like this:
+
+<pre><code>
+  share :login_as_admin do 
+    before { @controller.current_user = Admin.new }
+  end
+  
+  share :valid_article_params do
+    # could also use a tool like FactoryGirl, Mechanist etc.here
+    before { @params = {'title' => 'article title', 'body' => 'article body'} } 
+  end
+</code></pre>
+
+Also, one can map a context name like :invalid_article_params to multiple 
+blocks. <code>With</code> will then expand them and create separate tests for
+them. 
+
+E.g. with a definition like:
+
+<pre><code>
+  # share multiple contexts with the same name:  
+  share :invalid_article_params do
+    before { @params = valid_article_params.except(:title) }
+  end
+  
+  share :invalid_article_params do
+    before { @params = valid_article_params.except(:body) }
+  end
+  
+  # or register them at once:  
+  share :invalid_article_params,
+    lambda { before { @params = valid_article_params.except(:title) } },
+    lambda { before { @params = valid_article_params.except(:body) } }
+</code></pre>
+
+... it would generate two methods and test the actual assertions against both 
+invalid article params that are missing a title and those that are missing a
+body.
+
+Note that the second goal stated above ("run as many assertions with common 
+preconditions at once as possible") also means that this does not follow the
+"one assertion per test":http://blog.jayfields.com/2007/06/testing-one-assertion-per-test.html 
+philosophy any more. 
+
+E.g. some pseudo code for the first generated method above would be:
+
+<pre><code>
+  def test_POST_to_create_with_login_as_admin_and_with_valid_article_params
+    # preconditions
+    @controller.current_user = Admin.new
+    @params = {'title' => 'article title', 'body' => 'article body'}
+    
+    # action
+    post :create, @params
+    
+    # assertions
+    it_assigns :article
+    it_redirects_to 'articles/1'
+  end
+</code></pre>
+
+(You can still use the default test/unit <code>setup</code> method for setting
+up common, expensive scenarios for the whole testcase.)
+
+The reason for this choice is that tests will run much faster when multiple 
+assertions are validated against the result of one actual controller call (that 
+goes through routing, controller setup, filters, ...) instead of running this 
+setup for every single assertion.
+
+With this speed gain it is possible to run controller tests without heavy stubbing
+and still have reasonable test execution times. So basically the tradeoff I 
+had in mind with this was: trade "real model usage" instead of heavy stubbing 
+(which I wanted to get rid of for my controller tests) for multiple assertions
+per test (which I think still works fine for controller tests).
+
+
+
+
+
+
+