on-test-spec 0.2.4

data/test/expectations_test.rb

@@ -0,0 +1,459 @@
+require File.expand_path('../test_helper', __FILE__)
+require 'test/spec/rails'
+
+module TestingAssertionsThemselves
+  class << self
+    def setup
+      $TEST_SPEC_TESTCASE = TestingAssertionsThemselves
+      TestingAssertionsThemselves.assertions = []
+    end
+    
+    attr_accessor :assertions
+    
+    def assert(*args)
+      TestingAssertionsThemselves.assertions << [:assert, args]
+    end
+    
+    def assert_equal(*args)
+      TestingAssertionsThemselves.assertions << [:assert_equal, args]
+    end
+    
+    def last_assertion
+      TestingAssertionsThemselves.assertions.last
+    end
+  end
+end
+
+module AssertionAssertions
+  def assert_assert_success(message=nil)
+    assertion = TestingAssertionsThemselves.last_assertion
+    
+    assert_equal :assert, assertion[0]
+    assert assertion[1][0]
+    assert_equal(message, assertion[2][1]) if message
+  end
+  
+  def assert_assert_failure(message=nil)
+    assertion = TestingAssertionsThemselves.last_assertion
+    
+    assert_equal :assert, assertion[0]
+    assert !assertion[1][0]
+    assert_equal(message, assertion[1][1]) if message
+  end
+  
+  def assert_assert_equal_success(message=nil)
+    assertion = TestingAssertionsThemselves.last_assertion
+    
+    assert_equal :assert_equal, assertion[0]
+    assert_equal assertion[1][0], assertion[1][1]
+    assert_equal(message, assertion[1][2]) if message
+  end
+  
+  def assert_assert_equal_failure(message=nil)
+    assertion = TestingAssertionsThemselves.last_assertion
+    
+    assert_equal :assert_equal, assertion[0]
+    assert_not_equal assertion[1][0], assertion[1][1]
+    assert_equal(message, assertion[1][2]) if message
+  end
+end
+
+class Pony
+  class << self
+    attr_accessor :count
+  end
+end
+
+describe "Differ expectations" do
+  include AssertionAssertions
+  attr_accessor :controller
+  
+  before do
+    TestingAssertionsThemselves.setup
+  end
+  
+  it "should succeed when the expected difference occurs on a local variable" do
+    count = 1
+    lambda {
+      count = 2
+    }.should.differ('count')
+    assert_assert_equal_success
+  end
+  
+  it "should succeed when the expected difference occurs on an instance variable in the current scope" do
+    @count = 1
+    lambda {
+      @count = 2
+    }.should.differ('@count')
+    assert_assert_equal_success
+  end
+  
+  it "should succeed when the expected difference occurs on a class in the current scope" do
+    Pony.count = 1
+    lambda {
+      Pony.count = 2
+    }.should.differ('Pony.count')
+    assert_assert_equal_success
+  end
+  
+  it "should succeed when the difference is explicitly stated" do
+    Pony.count = 1
+    lambda {
+      Pony.count = 3
+    }.should.differ('Pony.count', +2)
+    assert_assert_equal_success
+  end
+  
+  it "should fail when the expected difference does not occur" do
+    Pony.count = 1
+    lambda {
+      Pony.count = 3
+    }.should.differ('Pony.count')
+    assert_assert_equal_failure('"Pony.count" didn\'t change by 1')
+  end
+  
+  it "should fail when the explicitly stated difference does not occur" do
+    Pony.count = 1
+    lambda {
+      Pony.count = 3
+    }.should.differ('Pony.count', +5)
+    assert_assert_equal_failure('"Pony.count" didn\'t change by 5')
+  end
+  
+  it "should return the return value of the block" do
+    Pony.count = 3
+    result = lambda {
+      Pony.count += 1
+    }.should.differ('Pony.count', 1)
+    assert_equal 4, result, "differ didn't return the block result"
+  end
+  
+  it "should succeed when multiple expected differences occur" do
+    count = 1
+    Pony.count = 1
+    lambda {
+      count = 2
+      Pony.count = 2
+    }.should.differ('Pony.count', +1, 'count', +1)
+    
+    TestingAssertionsThemselves.assertions.each do |assertion, args|
+      assert_equal :assert_equal, assertion
+      assert_equal args[0], args[1]
+    end
+  end
+  
+  it "should fail when first of the expected differences does not occur" do
+    count = 1
+    Pony.count = 1
+    lambda {
+      count += 4
+    }.should.differ('Pony.count', +2, 'count', +4)
+    
+    assertion, args = TestingAssertionsThemselves.assertions.first
+    assert_equal :assert_equal, assertion
+    assert_not_equal(args[0], args[1])
+    assert_equal '"Pony.count" didn\'t change by 2', args[2]
+    
+    assertion, args = TestingAssertionsThemselves.assertions.second
+    assert_equal :assert_equal, assertion
+    assert_equal(args[0], args[1])
+  end
+  
+  it "should fail when second of the expected differences does not occur" do
+    count = 1
+    Pony.count = 1
+    lambda {
+      Pony.count += 2
+    }.should.differ('Pony.count', +2, 'count', +4)
+    
+    assertion, args = TestingAssertionsThemselves.assertions.first
+    assert_equal :assert_equal, assertion
+    assert_equal(args[0], args[1])
+    
+    assertion, args = TestingAssertionsThemselves.assertions.second
+    assert_equal :assert_equal, assertion
+    assert_not_equal(args[0], args[1])
+    assert_equal '"count" didn\'t change by 4', args[2]
+  end
+end
+
+describe "NotDiffer expectations" do
+  include AssertionAssertions
+  attr_accessor :controller
+  
+  before do
+    TestingAssertionsThemselves.setup
+  end
+  
+  it "should succeed when no difference occurs on a local variable" do
+    count = 1
+    lambda {
+    }.should.not.differ('count')
+    assert_assert_equal_success
+  end
+  
+  it "should succeed when no difference occurs on an instance variable in the current scope" do
+    @count = 1
+    lambda {
+    }.should.not.differ('@count')
+    assert_assert_equal_success
+  end
+  
+  it "should succeed when no difference occurs on a class in the current scope" do
+    Pony.count = 1
+    lambda {
+    }.should.not.differ('Pony.count')
+    assert_assert_equal_success
+  end
+  
+  it "should fail when a difference occurs" do
+    Pony.count = 1
+    lambda {
+      Pony.count = 3
+    }.should.not.differ('Pony.count')
+    assert_assert_equal_failure('"Pony.count" changed by 2, expected no change')
+  end
+  
+  it "should return the return value of the block" do
+    Pony.count = 3
+    result = lambda {
+      Pony.count += 1
+    }.should.not.differ('Pony.count')
+    assert_equal 4, result, "differ didn't return the block result"
+  end
+  
+  it "should succeed when multiple expected differences do not occur" do
+    count = 1
+    Pony.count = 1
+    lambda {
+    }.should.not.differ('Pony.count', 'count')
+    
+    TestingAssertionsThemselves.assertions.each do |assertion, args|
+      assert_equal :assert_equal, assertion
+      assert_equal args[0], args[1]
+    end
+  end
+  
+  it "should fail when first of the expected differences does occur" do
+    count = 1
+    Pony.count = 1
+    lambda {
+      Pony.count += 2
+    }.should.not.differ('Pony.count', 'count')
+    
+    assertion, args = TestingAssertionsThemselves.assertions.first
+    assert_equal :assert_equal, assertion
+    assert_not_equal(args[0], args[1])
+    assert_equal '"Pony.count" changed by 2, expected no change', args[2]
+    
+    assertion, args = TestingAssertionsThemselves.assertions.second
+    assert_equal :assert_equal, assertion
+    assert_equal(args[0], args[1])
+  end
+  
+  it "should fail when second of the expected differences does occur" do
+    count = 1
+    Pony.count = 1
+    lambda {
+      count += 4
+    }.should.not.differ('Pony.count', 'count')
+    
+    assertion, args = TestingAssertionsThemselves.assertions.first
+    assert_equal :assert_equal, assertion
+    assert_equal(args[0], args[1])
+    
+    assertion, args = TestingAssertionsThemselves.assertions.second
+    assert_equal :assert_equal, assertion
+    assert_not_equal(args[0], args[1])
+    assert_equal '"count" changed by 4, expected no change', args[2]
+  end
+end
+
+
+describe "Record expectations" do
+  include AssertionAssertions
+  attr_accessor :controller
+  
+  before do
+    TestingAssertionsThemselves.setup
+  end
+  
+  it "should succeed when equal_set assertions are correct" do
+    [].should.equal_set []
+    assert_assert_success
+    
+    [stub(:id => 1)].should.equal_set [stub(:id => 1)]
+    assert_assert_success
+    
+    [stub(:id => 1), stub(:id => 1)].should.equal_set [stub(:id => 1), stub(:id => 1)]
+    assert_assert_success
+    
+    [stub(:id => 1), stub(:id => 2)].should.equal_set [stub(:id => 1), stub(:id => 2)]
+    assert_assert_success
+    
+    [stub(:id => 2)].should.not.equal_set [stub(:id => 1)]
+    assert_assert_success
+    
+    [stub(:id => 1), stub(:id => 2)].should.not.equal_set [stub(:id => 1)]
+    assert_assert_success
+    
+    [stub(:id => 1)].should.not.equal_set [stub(:id => 1), stub(:id => 2)]
+    assert_assert_success
+
+    # equal_set ignores order
+    [stub(:id => 1), stub(:id => 2)].should.equal_set [stub(:id => 2), stub(:id => 1)]
+    assert_assert_success
+  end
+  
+  it "should fail when equal_set assertions are not correct" do
+    [].should.not.equal_set []
+    assert_assert_failure("[] has the same records as []")
+    
+    [stub(:id => 1), stub(:id => 1)].should.equal_set [stub(:id => 1)]
+    assert_assert_failure("[Mocha::Mock[1], Mocha::Mock[1]] does not have the same records as [Mocha::Mock[1]]")
+    
+    [stub(:id => 1), stub(:id => 2)].should.equal_set [stub(:id => 1), stub(:id => 1), stub(:id => 2)]
+    assert_assert_failure("[Mocha::Mock[1], Mocha::Mock[2]] does not have the same records as [Mocha::Mock[1], Mocha::Mock[1], Mocha::Mock[2]]")
+    
+    [stub(:id => 1), stub(:id => 2), stub(:id => 1)].should.equal_set [stub(:id => 1), stub(:id => 2), stub(:id => 2)]
+    assert_assert_failure("[Mocha::Mock[1], Mocha::Mock[2], Mocha::Mock[1]] does not have the same records as [Mocha::Mock[1], Mocha::Mock[2], Mocha::Mock[2]]")
+    
+    [stub(:id => 1)].should.not.equal_set [stub(:id => 1)]
+    assert_assert_failure("[Mocha::Mock[1]] has the same records as [Mocha::Mock[1]]")
+    
+    [stub(:id => 1), stub(:id => 2)].should.not.equal_set [stub(:id => 1), stub(:id => 2)]
+    assert_assert_failure("[Mocha::Mock[1], Mocha::Mock[2]] has the same records as [Mocha::Mock[1], Mocha::Mock[2]]")
+    
+    [stub(:id => 2)].should.equal_set [stub(:id => 1)]
+    assert_assert_failure("[Mocha::Mock[2]] does not have the same records as [Mocha::Mock[1]]")
+    
+    [stub(:id => 1), stub(:id => 2)].should.equal_set [stub(:id => 1)]
+    assert_assert_failure("[Mocha::Mock[1], Mocha::Mock[2]] does not have the same records as [Mocha::Mock[1]]")
+    
+    [stub(:id => 1)].should.equal_set [stub(:id => 1), stub(:id => 2)]
+    assert_assert_failure("[Mocha::Mock[1]] does not have the same records as [Mocha::Mock[1], Mocha::Mock[2]]")
+  end
+
+  it "should succeed when equal_list assertions are correct" do
+    [].should.equal_list []
+    assert_assert_success
+    
+    [stub(:id => 1)].should.equal_list [stub(:id => 1)]
+    assert_assert_success
+    
+    [stub(:id => 1), stub(:id => 1)].should.equal_list [stub(:id => 1), stub(:id => 1)]
+    assert_assert_success
+    
+    [stub(:id => 1), stub(:id => 2)].should.equal_list [stub(:id => 1), stub(:id => 2)]
+    assert_assert_success
+    
+    [stub(:id => 2)].should.not.equal_list [stub(:id => 1)]
+    assert_assert_success
+    
+    [stub(:id => 1), stub(:id => 2)].should.not.equal_list [stub(:id => 1)]
+    assert_assert_success
+    
+    [stub(:id => 1)].should.not.equal_list [stub(:id => 1), stub(:id => 2)]
+    assert_assert_success
+
+    # equal_list does not ignore order
+    [stub(:id => 1), stub(:id => 2)].should.not.equal_list [stub(:id => 2), stub(:id => 1)]
+    assert_assert_success
+  end
+  
+  it "should fail when equal_list assertions are not correct" do
+    [].should.not.equal_list []
+    assert_assert_failure("[] has the same records as []")
+    
+    [stub(:id => 1), stub(:id => 1)].should.equal_list [stub(:id => 1)]
+    assert_assert_failure("[Mocha::Mock[1], Mocha::Mock[1]] does not have the same records as [Mocha::Mock[1]]")
+    
+    [stub(:id => 1), stub(:id => 2)].should.equal_list [stub(:id => 1), stub(:id => 1), stub(:id => 2)]
+    assert_assert_failure("[Mocha::Mock[1], Mocha::Mock[2]] does not have the same records as [Mocha::Mock[1], Mocha::Mock[1], Mocha::Mock[2]]")
+    
+    [stub(:id => 1), stub(:id => 2), stub(:id => 1)].should.equal_list [stub(:id => 1), stub(:id => 2), stub(:id => 2)]
+    assert_assert_failure("[Mocha::Mock[1], Mocha::Mock[2], Mocha::Mock[1]] does not have the same records as [Mocha::Mock[1], Mocha::Mock[2], Mocha::Mock[2]]")
+    
+    [stub(:id => 1)].should.not.equal_list [stub(:id => 1)]
+    assert_assert_failure("[Mocha::Mock[1]] has the same records as [Mocha::Mock[1]]")
+    
+    [stub(:id => 1), stub(:id => 2)].should.not.equal_list [stub(:id => 1), stub(:id => 2)]
+    assert_assert_failure("[Mocha::Mock[1], Mocha::Mock[2]] has the same records as [Mocha::Mock[1], Mocha::Mock[2]]")
+    
+    [stub(:id => 2)].should.equal_list [stub(:id => 1)]
+    assert_assert_failure("[Mocha::Mock[2]] does not have the same records as [Mocha::Mock[1]]")
+    
+    [stub(:id => 1), stub(:id => 2)].should.equal_list [stub(:id => 1)]
+    assert_assert_failure("[Mocha::Mock[1], Mocha::Mock[2]] does not have the same records as [Mocha::Mock[1]]")
+    
+    [stub(:id => 1)].should.equal_list [stub(:id => 1), stub(:id => 2)]
+    assert_assert_failure("[Mocha::Mock[1]] does not have the same records as [Mocha::Mock[1], Mocha::Mock[2]]")
+    
+    # equal_list does not ignore order
+    [stub(:id => 1), stub(:id => 2)].should.equal_list [stub(:id => 2), stub(:id => 1)]
+    assert_assert_failure("[Mocha::Mock[1], Mocha::Mock[2]] does not have the same records as [Mocha::Mock[2], Mocha::Mock[1]]")
+  end
+end
+
+class TestController
+  def request
+    unless @request
+      @request ||= Object.new
+      def @request.env
+        @env ||= {}
+      end
+    end
+    @request
+  end
+end
+
+describe "Redirection expectations" do
+  include AssertionAssertions
+  attr_accessor :controller
+  
+  before do
+    TestingAssertionsThemselves.setup
+    
+    @controller = TestController.new
+    @controller.stubs(:url_for).returns(@url)
+    
+    @matcher = stub('matcher')
+    self.stubs(:should).returns(@matcher)
+    @matcher.stubs(:redirect_to)
+    
+    @url = 'new_session_url'
+  end
+  
+  it "should set the request env HTTP_REFERER before executing the proc" do
+    @controller.expects(:url_for).with(@url).returns(@url)
+    lambda {}.should.redirect_back_to(@url)
+    assert_equal @url, controller.request.env['HTTP_REFERER']
+  end
+  
+  it "should call the `redirect_to' matcher with the url _after_ executing the proc" do
+    def @matcher.redirect_to(*args)
+      raise "Oh noes, should not be called yet!"
+    end
+    
+    lambda {
+      def @matcher.redirect_to(*args)
+        @called = true
+      end
+    }.should.redirect_back_to(@url)
+    
+    assert @matcher.instance_variable_get(:@called)
+  end
+  
+  it "should work with regular url options as well" do
+    @controller.expects(:url_for).with(:action => :new).returns(@url)
+    @matcher.expects(:redirect_to).with(@url)
+    
+    lambda {}.should.redirect_back_to(:action => :new)
+    assert_equal @url, controller.request.env['HTTP_REFERER']
+  end
+  
+  it "should return the result of calling the block" do
+    result = lambda { "called block" }.should.redirect_back_to(@url)
+    assert_equal "called block", result
+  end
+end

data/test/macros/authorization_test.rb

@@ -0,0 +1,102 @@
+require File.expand_path('../../test_helper', __FILE__)
+require 'test/spec/rails/macros'
+
+describe "Authorization::TestGenerator, concerning generation" do
+  before do
+    @test = mock('Test')
+    @generator = Test::Spec::Rails::Macros::Authorization::TestGenerator.new(@test, :access_denied?, true, 'Expected access to be denied')
+  end
+  
+  it "should generate a test description for a GET" do
+    @test.expects(:it).with("should disallow GET on `index'")
+    @generator.get(:index)
+  end
+  
+  it "should generate a test description for a POST with params" do
+    @test.expects(:it).with("should disallow POST on `create\' {:venue=>{:name=>\"Bitterzoet\"}}")
+    @generator.post(:create, :venue => { :name => "Bitterzoet" })
+  end
+  
+  it "should raise a NoMethodError when you disallow an unknown HTTP verb" do
+    lambda {
+      @generator.unknown :index
+    }.should.raise(NoMethodError)
+  end
+end
+
+class Immediate
+  def self.it(description, &block)
+    block.call
+  end
+end
+
+describe "Authorization::TestGenerator, concerning test contents" do
+  before do
+    @generator = Test::Spec::Rails::Macros::Authorization::TestGenerator.new(Immediate, :access_denied?, true, 'Expected access to be denied')
+    @generator.stubs(:send).with(:access_denied?).returns(true)
+  end
+  
+  it "should send the verb and options to the controller" do
+    params = {:venue => {:name => "Bitterzoet"}}
+    @generator.stubs(:immediate_values).with(params).returns(params)
+    @generator.expects(:send).with(:post, :create, params)
+    
+    @generator.post(:create, params)
+  end
+  
+  it "should immediate values in params" do
+    params = {:name => 'bitterzoet'}
+    
+    @generator.expects(:immediate_values).with(params).returns(params)
+    @generator.stubs(:send).returns(true)
+    
+    @generator.post(:create, params)
+  end
+  
+  it "should test the return value of the validation method against the expected method" do
+    @generator.expected = false
+    params = {:name => 'bitterzoet'}
+    
+    @generator.expects(:immediate_values).with(params).returns(params)
+    @generator.stubs(:send).returns(false)
+    
+    @generator.post(:create, params)
+  end
+end
+
+describe "Macros::Authorization" do
+  before do
+    @test_case = mock('TestCase')
+    @proxy = Test::Spec::Rails::Macros::Should.new(@test_case)
+  end
+  
+  it "should return a test generator when a new disallow rule is invoked" do
+    generator = @proxy.disallow
+    
+    generator.should.is_a(Test::Spec::Rails::Macros::Authorization::TestGenerator)
+    generator.test_case.should == @test_case
+    generator.validation_method.should == :access_denied?
+    generator.message.should == 'Expected access to be denied'
+    generator.expected.should == true
+  end
+  
+  it "should return a test generator when a new allow rule is invoked" do
+    generator = @proxy.allow
+    
+    generator.should.is_a(Test::Spec::Rails::Macros::Authorization::TestGenerator)
+    generator.test_case.should == @test_case
+    generator.validation_method.should == :access_denied?
+    generator.message.should == 'Expected access to be allowed'
+    generator.expected.should == false
+  end
+  
+  it "should return a test generator when a new login_required rule is invoked" do
+    generator = @proxy.require_login
+    
+    generator.should.is_a(Test::Spec::Rails::Macros::Authorization::TestGenerator)
+    generator.test_case.should == @test_case
+    generator.validation_method.should == :login_required?
+    generator.message.should == 'Expected login to be required'
+    generator.expected.should == true
+  end
+end

data/test/macros/base_test.rb

@@ -0,0 +1,78 @@
+require File.expand_path('../../test_helper', __FILE__)
+require 'test/spec/rails/macros'
+
+describe "Macros::Proxy" do
+  it "should store an instance of the test case" do
+    test_case = mock('TestCase')
+    proxy = Test::Spec::Rails::Macros::Proxy.new(test_case)
+    proxy.test_case.should == test_case
+  end
+end
+
+describe "Macros::Should" do
+  it "should store an instance of the test_case" do
+    test_case = mock('TestCase')
+    proxy = Test::Spec::Rails::Macros::Should.new(test_case)
+    proxy.test_case.should == test_case
+  end
+end
+
+class Case
+  extend Test::Spec::Rails::Macros::ClassMethods
+  include Test::Spec::Rails::Macros::InstanceMethods
+  
+  def events(name)
+    "fixture: #{name.inspect}"
+  end
+end
+
+describe "A test case with support for macros" do
+  it "should return a Should instance" do
+    Case.new.should.should.be.kind_of?(Test::Spec::Rails::Macros::Should)
+  end
+  
+  it "should know what are valid fixtures" do
+    Case.stubs(:fixture_table_names).returns(%w(events venues))
+    Case.known_fixture?(:events).should == true
+    Case.known_fixture?(:venues).should == true
+    Case.known_fixture?(:unknown).should == false
+  end
+  
+  it "should know there are no fixtures when there are no fixture_table_names in the test" do
+    Case.stubs(:respond_to?).with(:fixture_table_names).returns(false)
+    Case.known_fixture?(:events).should == false
+    Case.known_fixture?(:venues).should == false
+    Case.known_fixture?(:unknown).should == false
+  end
+  
+  it "should wrap know fixture methods in a lambda so they don't have to be known yet" do    
+    Case.stubs(:fixture_table_names).returns(%w(events venues))
+    Case.events(:bitterzoet).should.be.kind_of?(Test::Spec::Rails::Macros::LazyValue)
+    Case.events(:bitterzoet).value.should == "events(:bitterzoet)"
+  end
+end
+
+describe "A test case instance with support for macros" do
+  before do
+    @case = Case.new
+    Case.stubs(:fixture_table_names).returns(%w(events))
+  end
+  
+  it "should immediate LazyValue values in the context of the current test" do
+    @case.immediate_values(:name => Test::Spec::Rails::Macros::LazyValue.new('events(:bitterzoet)')).should == {
+      :name => 'fixture: :bitterzoet'
+    }
+  end
+  
+  it "should immediate Proc values" do
+    @case.immediate_values(:name => Proc.new { 42 }).should == { :name => 42 }
+  end
+  
+  it "should not change actual values" do
+    @case.immediate_values(:name => 42).should == { :name => 42 }
+  end
+  
+  it "should immediate nested values" do
+    @case.immediate_values(:venue => { :name => Proc.new { 'bitterzoet' } }).should == {:venue => {:name => 'bitterzoet'}}
+  end
+end