rotuka-shoulda-gem 0.0.1

data/Manifest.txt

@@ -0,0 +1,7 @@
+Manifest.txt
+README.txt
+Rakefile
+bin/convert_file_to_shoulda
+lib/shoulda.rb
+lib/proc_extensions.rb
+test/test_shoulda.rb

data/README.txt

@@ -0,0 +1,69 @@
+Shoulda
+    by Tammer Saleh, Thoughtbot, Inc.
+    http://thoughtbot.com/projects/shoulda
+
+== DESCRIPTION:
+  
+The Shoulda gem makes it easy to write elegant, understandable, and maintainable tests. Shoulda consists of test macros, assertions, and helpers added on to the Test::Unit framework. It's fully compatible with your existing tests, and requires no retooling to use.  Should also comes with a complimentary Rails plugin, available here - http://thoughtbot.com/projects/shoulda
+
+== FEATURES/PROBLEMS:
+  
+* wrap your tests in nested context blocks to keep them readable and dry
+* write test names in english, not with_a_bunch_of_underscores
+* fully compatible with your existing Test::Unit tests
+* makes writing test macros simple as pie
+
+== SYNOPSIS:
+
+  class UserTest << Test::Unit 
+    context "A User instance" do
+      setup do
+        @user = User.find(:first)
+      end
+
+      should "return its full name" do
+        assert_equal 'John Doe', @user.full_name
+      end
+
+      context "with a profile" do
+        setup do
+          @user.profile = Profile.find(:first)
+        end
+
+        should "return true when sent #has_profile?" do
+          assert @user.has_profile?
+        end
+      end
+    end
+  end
+
+== REQUIREMENTS:
+
+* Test::Unit
+
+== INSTALL:
+
+* sudo gem install shoulda
+
+== LICENSE:
+
+Copyright (c) 2007 Tammer Saleh, Thoughtbot, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,100 @@
+require 'rubygems'
+require 'rake'
+require 'rake/gempackagetask'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rubyforge'
+
+require File.join(File.dirname(__FILE__), 'lib', 'shoulda')
+
+def paragraphs_of(path, *paragraphs)
+  File.read(path).delete("\r").split(/\n\n+/).values_at(*paragraphs)
+end
+
+name              = "Shoulda"
+summary           = 'Testing library built on top of Test::Unit'
+author            = 'Tammer Saleh'
+email             = 'tsaleh@thoughtbot.com'
+version           = Thoughtbot::Shoulda::VERSION
+description       = paragraphs_of('README.txt', 2..5).join("\n\n")
+rubyforge_project = 'shoulda'
+bindir            = "bin"
+
+desc 'Update documentation on website'
+task :sync_docs => 'rdoc' do
+  `rsync -ave ssh doc/ tsaleh@rubyforge.org:/var/www/gforge-projects/#{rubyforge_project}`
+end
+
+desc 'Package and upload the release to rubyforge.'
+task :release => [:test, :sync_docs, :package] do |t|
+  puts "Releasing #{name} v#{version} to Rubyforge"
+  pkg = "pkg/#{name}-#{version}"
+  
+  rf = RubyForge.new
+
+  c = rf.userconfig
+  c["release_notes"]   = description if description
+  # c["release_changes"] = changes if changes
+  c["preformatted"] = true
+  
+  puts "  Logging in..."
+  rf.login
+    
+  files = ["#{pkg}.tgz", "#{pkg}.gem"]
+  
+  puts "  Uploading..."
+  rf.add_release rubyforge_project, name, version, *files
+end
+
+desc 'Default: run tests.'
+task :default => ['test']
+
+Dir['tasks/*.rake'].each do |f|
+  load f
+end
+
+spec = Gem::Specification.new do |s|
+  s.name              = name
+  s.summary           = summary
+  s.author            = author
+  s.email             = email
+  s.version           = version
+  s.rubyforge_project = rubyforge_project
+  s.bindir            = bindir
+  s.description       = description
+  
+  url = paragraphs_of('README.txt', 0).first.split(/\n/)[1..-1]
+  s.homepage = Array(url).first
+  s.files = File.read("Manifest.txt").delete("\r").split(/\n/)
+  s.executables = s.files.grep(/^bin/) { |f| File.basename(f) }
+
+  dirs = Dir['{lib,ext}']
+  s.require_paths = dirs unless dirs.empty?
+
+  s.rdoc_options = ['--main', 'README.txt']
+  s.extra_rdoc_files = s.files.grep(/txt$/)
+  s.has_rdoc = true
+
+  s.test_files = Dir[*['test/**/test_*.rb']]
+end
+
+Rake::GemPackageTask.new spec do |pkg|
+  pkg.need_tar = true
+end
+
+Rake::TestTask.new do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/test_*.rb'
+  t.verbose = false
+end
+
+Rake::RDocTask.new { |rdoc|
+  rdoc.rdoc_dir = 'doc'
+  rdoc.title    = "Shoulda -- Making tests easy on the fingers and eyes"
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.template = "#{ENV['template']}.rb" if ENV['template']
+  rdoc.rdoc_files.include('README.txt', 'lib/**/*.rb')
+}
+
+
+# vim: syntax=Ruby

data/bin/convert_file_to_shoulda

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+require 'fileutils'
+
+def usage(msg = nil)
+  puts "Error: #{msg}" if msg
+  puts if msg
+  puts "Usage: #{File.basename(__FILE__)} normal_test_file.rb"
+  puts
+  puts "Will convert an existing test file with names like "
+  puts
+  puts "  def test_should_do_stuff"
+  puts "    ..."
+  puts "  end"
+  puts
+  puts "to one using the new syntax: "
+  puts
+  puts "  should \"be super cool\" do"
+  puts "    ..."
+  puts "  end"
+  puts
+  puts "A copy of the old file will be left under /tmp/ in case this script just seriously screws up"
+  puts
+  exit (msg ? 2 : 0)
+end
+
+usage("Wrong number of arguments.") unless ARGV.size == 1
+usage("This system doesn't have a /tmp directory.  wtf?") unless File.directory?('/tmp')
+
+file = ARGV.shift
+tmpfile = "/tmp/#{File.basename(file)}"
+usage("File '#{file}' doesn't exist") unless File.exists?(file)
+
+FileUtils.cp(file, tmpfile)
+contents = File.read(tmpfile)
+contents.gsub!(/def test_should_(.*)\s*$/, 'should "\1" do')
+contents.gsub!(/def test_(.*)\s*$/, 'should "RENAME ME: test \1" do')
+contents.gsub!(/should ".*" do$/) {|line| line.tr!('_', ' ')}
+File.open(file, 'w') { |f| f.write(contents) }
+
+puts "File '#{file}' has been converted to 'should' syntax.  Old version has been stored in '#{tmpfile}'"

data/lib/proc_extensions.rb

@@ -0,0 +1,14 @@
+# Stolen straight from ActiveSupport
+
+class Proc #:nodoc:
+  def bind(object)
+    block, time = self, Time.now
+    (class << object; self end).class_eval do
+      method_name = "__bind_#{time.to_i}_#{time.usec}"
+      define_method(method_name, &block)
+      method = instance_method(method_name)
+      remove_method(method_name)
+      method
+    end.bind(object)
+  end
+end

data/lib/shoulda.rb

@@ -0,0 +1,239 @@
+require File.join(File.dirname(__FILE__), 'proc_extensions')
+
+module Thoughtbot
+  module Shoulda
+    class << self
+      attr_accessor :current_context
+    end
+
+    VERSION = '1.1.1'
+
+    # = Should statements
+    #
+    # Should statements are just syntactic sugar over normal Test::Unit test methods.  A should block 
+    # contains all the normal code and assertions you're used to seeing, with the added benefit that 
+    # they can be wrapped inside context blocks (see below).
+    #
+    # == Example:
+    #
+    #  class UserTest << Test::Unit::TestCase
+    #    
+    #    def setup
+    #      @user = User.new("John", "Doe")
+    #    end
+    #
+    #    should "return its full name"
+    #      assert_equal 'John Doe', @user.full_name
+    #    end
+    #  
+    #  end
+    #   
+    # ...will produce the following test:
+    # * <tt>"test: User should return its full name. "</tt>
+    #
+    # Note: The part before <tt>should</tt> in the test name is gleamed from the name of the Test::Unit class.
+
+    def should(name, &blk)
+      if Shoulda.current_context
+        Shoulda.current_context.should(name, &blk)
+      else
+        context_name = self.name.gsub(/Test/, "")
+        context = Thoughtbot::Shoulda::Context.new(context_name, self) do
+          should(name, &blk)
+        end
+        context.build
+      end
+    end
+
+    # Just like should, but never runs, and instead prints an 'X' in the Test::Unit output.
+    def should_eventually(name, &blk)
+      context_name = self.name.gsub(/Test/, "")
+      context = Thoughtbot::Shoulda::Context.new(context_name, self) do
+        should_eventually(name, &blk)
+      end
+      context.build
+    end
+
+    # = Contexts
+    # 
+    # A context block groups should statements under a common set of setup/teardown methods.  
+    # Context blocks can be arbitrarily nested, and can do wonders for improving the maintainability
+    # and readability of your test code.
+    #
+    # A context block can contain setup, should, should_eventually, and teardown blocks.
+    #
+    #  class UserTest << Test::Unit::TestCase
+    #    context "A User instance" do
+    #      setup do
+    #        @user = User.find(:first)
+    #      end
+    #    
+    #      should "return its full name"
+    #        assert_equal 'John Doe', @user.full_name
+    #      end
+    #    end
+    #  end
+    #
+    # This code will produce the method <tt>"test: A User instance should return its full name. "</tt>.
+    #
+    # Contexts may be nested.  Nested contexts run their setup blocks from out to in before each 
+    # should statement.  They then run their teardown blocks from in to out after each should statement.
+    #
+    #  class UserTest << Test::Unit::TestCase
+    #    context "A User instance" do
+    #      setup do
+    #        @user = User.find(:first)
+    #      end
+    #    
+    #      should "return its full name"
+    #        assert_equal 'John Doe', @user.full_name
+    #      end
+    #    
+    #      context "with a profile" do
+    #        setup do
+    #          @user.profile = Profile.find(:first)
+    #        end
+    #      
+    #        should "return true when sent :has_profile?"
+    #          assert @user.has_profile?
+    #        end
+    #      end
+    #    end
+    #  end
+    #
+    # This code will produce the following methods 
+    # * <tt>"test: A User instance should return its full name. "</tt>
+    # * <tt>"test: A User instance with a profile should return true when sent :has_profile?. "</tt>
+    #
+    # <b>Just like should statements, a context block can exist next to normal <tt>def test_the_old_way; end</tt> 
+    # tests</b>.  This means you do not have to fully commit to the context/should syntax in a test file.
+
+    def context(name, &blk)
+      if Shoulda.current_context
+        Shoulda.current_context.context(name, &blk)
+      else
+        context = Thoughtbot::Shoulda::Context.new(name, self, &blk)
+        context.build
+      end
+    end
+
+    class Context # :nodoc:
+
+      attr_accessor :name               # my name
+      attr_accessor :parent             # may be another context, or the original test::unit class.
+      attr_accessor :subcontexts        # array of contexts nested under myself
+      attr_accessor :setup_block        # block given via a setup method
+      attr_accessor :teardown_block     # block given via a teardown method
+      attr_accessor :shoulds            # array of hashes representing the should statements
+      attr_accessor :should_eventuallys # array of hashes representing the should eventually statements
+
+      def initialize(name, parent, &blk)
+        Shoulda.current_context = self
+        self.name               = name
+        self.parent             = parent
+        self.setup_block        = nil
+        self.teardown_block     = nil
+        self.shoulds            = []
+        self.should_eventuallys = []
+        self.subcontexts        = []
+
+        blk.bind(self).call
+        Shoulda.current_context = nil
+      end
+
+      def context(name, &blk)
+        subcontexts << Context.new(name, self, &blk)
+        Shoulda.current_context = self
+      end
+
+      def setup(&blk)
+        self.setup_block = blk
+      end
+
+      def teardown(&blk)
+        self.teardown_block = blk
+      end
+
+      def should(name, &blk)
+        self.shoulds << { :name => name, :block => blk }
+      end
+
+      def should_eventually(name, &blk)
+        self.should_eventuallys << { :name => name, :block => blk }
+      end
+
+      def full_name
+        parent_name = parent.full_name if am_subcontext?
+        return [parent_name, name].join(" ").strip
+      end
+
+      def am_subcontext?
+        parent.is_a?(self.class) # my parent is the same class as myself.
+      end
+
+      def test_unit_class
+        am_subcontext? ? parent.test_unit_class : parent
+      end
+
+      def create_test_from_should_hash(should)
+        test_name = ["test:", full_name, "should", "#{should[:name]}. "].flatten.join(' ').to_sym
+
+        if test_unit_class.instance_methods.include?(test_name.to_s)
+          warn "  * WARNING: '#{test_name}' is already defined" 
+        end
+        
+        context = self
+        test_unit_class.send(:define_method, test_name) do |*args|
+          begin
+            context.run_all_setup_blocks(self)
+            should[:block].bind(self).call
+          ensure
+            context.run_all_teardown_blocks(self)
+          end
+        end
+      end
+
+      def run_all_setup_blocks(binding)
+        self.parent.run_all_setup_blocks(binding) if am_subcontext?
+        setup_block.bind(binding).call if setup_block
+      end
+
+      def run_all_teardown_blocks(binding)
+        teardown_block.bind(binding).call if teardown_block
+        self.parent.run_all_teardown_blocks(binding) if am_subcontext?
+      end
+
+      def print_should_eventuallys
+        should_eventuallys.each do |should|
+          test_name = [full_name, "should", "#{should[:name]}. "].flatten.join(' ')
+          puts "  * DEFERRED: " + test_name
+        end
+        subcontexts.each { |context| context.print_should_eventuallys }
+      end
+
+      def build
+        shoulds.each do |should|
+          create_test_from_should_hash(should)
+        end
+
+        subcontexts.each { |context| context.build }
+
+        print_should_eventuallys
+      end
+
+      def method_missing(method, *args, &blk)
+        test_unit_class.send(method, *args, &blk)
+      end
+
+    end
+  end
+end
+
+module Test # :nodoc: all
+  module Unit 
+    class TestCase
+      extend Thoughtbot::Shoulda
+    end
+  end
+end
+

data/test/test_shoulda.rb

@@ -0,0 +1,234 @@
+require 'test/unit'
+require File.join(File.dirname(__FILE__), '..', 'lib', 'shoulda')
+require 'rubygems'
+require 'mocha'
+
+class TestShoulda < Test::Unit::TestCase # :nodoc:
+
+  should "be able to define a should statement outside of a context" do
+    assert true
+  end
+  
+  should "see the name of my class as TestShoulda" do
+    assert_equal "TestShoulda", self.class.name
+  end
+  
+  def self.should_see_class_methods
+    should "be able to see class methods" do
+      assert true
+    end
+  end
+
+  def self.should_see_a_context_block_like_a_Test_Unit_class
+    should "see a context block as a Test::Unit class" do
+      assert_equal "TestShoulda", self.class.name
+    end
+  end
+
+  def self.should_see_blah
+    should "see @blah through a macro" do
+      assert @blah 
+    end
+  end
+
+  def self.should_not_see_blah
+    should "not see @blah through a macro" do
+      assert_nil @blah 
+    end
+  end
+
+  def self.should_be_able_to_make_context_macros(prefix = nil)
+    context "a macro" do
+      should "have the tests named correctly" do
+        assert_match(/^test: #{prefix}a macro should have the tests named correctly/, self.to_s)
+      end
+    end
+  end
+  
+  context "Context" do
+
+    should_see_class_methods
+    should_see_a_context_block_like_a_Test_Unit_class
+    should_be_able_to_make_context_macros("Context ")
+
+    should "not define @blah" do
+      assert ! self.instance_variables.include?("@blah")
+    end
+
+    should_not_see_blah
+
+    should "be able to define a should statement" do
+      assert true
+    end
+
+    should "see the name of my class as TestShoulda" do
+      assert_equal "TestShoulda", self.class.name
+    end
+
+    context "with a subcontext" do
+      should_be_able_to_make_context_macros("Context with a subcontext ")
+    end
+  end
+
+  context "Context with setup block" do
+    setup do
+      @blah = "blah"
+    end
+    
+    should "have @blah == 'blah'" do
+      assert_equal "blah", @blah
+    end
+    should_see_blah
+    
+    should "have name set right" do
+      assert_match(/^test: Context with setup block/, self.to_s)
+    end
+
+    context "and a subcontext" do
+      setup do
+        @blah = "#{@blah} twice"
+      end
+      
+      should "be named correctly" do
+        assert_match(/^test: Context with setup block and a subcontext should be named correctly/, self.to_s)
+      end
+      
+      should "run the setup methods in order" do
+        assert_equal @blah, "blah twice"
+      end
+      should_see_blah
+    end
+  end
+
+  context "Another context with setup block" do
+    setup do
+      @blah = "foo"
+    end
+    
+    should "have @blah == 'foo'" do
+      assert_equal "foo", @blah
+    end
+
+    should "have name set right" do
+      assert_match(/^test: Another context with setup block/, self.to_s)
+    end
+    should_see_blah
+  end
+  
+  should_eventually "pass, since it's a should_eventually" do
+    flunk "what?"
+  end
+
+  # Context creation and naming
+
+  def test_should_create_a_new_context
+    assert_nothing_raised do
+      Thoughtbot::Shoulda::Context.new("context name", self) do; end
+    end
+  end
+
+  def test_should_create_a_nested_context
+    assert_nothing_raised do
+      parent = Thoughtbot::Shoulda::Context.new("Parent", self) do; end
+      child  = Thoughtbot::Shoulda::Context.new("Child", parent) do; end
+    end
+  end
+
+  def test_should_name_a_contexts_correctly
+    parent     = Thoughtbot::Shoulda::Context.new("Parent", self) do; end
+    child      = Thoughtbot::Shoulda::Context.new("Child", parent) do; end
+    grandchild = Thoughtbot::Shoulda::Context.new("GrandChild", child) do; end
+
+    assert_equal "Parent", parent.full_name
+    assert_equal "Parent Child", child.full_name
+    assert_equal "Parent Child GrandChild", grandchild.full_name
+  end
+
+  # Should statements
+
+  def test_should_have_should_hashes_when_given_should_statements
+    context = Thoughtbot::Shoulda::Context.new("name", self) do
+      should "be good" do; end
+      should "another" do; end
+    end
+    
+    names = context.shoulds.map {|s| s[:name]}
+    assert_equal ["another", "be good"], names.sort
+  end
+
+  # setup and teardown
+
+  def test_should_capture_setup_and_teardown_blocks
+    context = Thoughtbot::Shoulda::Context.new("name", self) do
+      setup    do; "setup";    end
+      teardown do; "teardown"; end
+    end
+    
+    assert_equal "setup",    context.setup_block.call
+    assert_equal "teardown", context.teardown_block.call
+  end
+
+  # building
+
+  def test_should_create_shoulda_test_for_each_should_on_build
+    context = Thoughtbot::Shoulda::Context.new("name", self) do
+      should "one" do; end
+      should "two" do; end
+    end
+    context.expects(:create_test_from_should_hash).with(has_entry(:name => "one"))
+    context.expects(:create_test_from_should_hash).with(has_entry(:name => "two"))
+    context.build
+  end
+
+  def test_should_create_test_methods_on_build
+    tu_class = Test::Unit::TestCase
+    context = Thoughtbot::Shoulda::Context.new("A Context", tu_class) do
+      should "define the test" do; end
+    end
+
+    tu_class.expects(:define_method).with(:"test: A Context should define the test. ")
+    context.build
+  end
+
+  def test_should_create_test_methods_on_build_when_subcontext
+    tu_class = Test::Unit::TestCase
+    context = Thoughtbot::Shoulda::Context.new("A Context", tu_class) do
+      context "with a child" do
+        should "define the test" do; end
+      end
+    end
+
+    tu_class.expects(:define_method).with(:"test: A Context with a child should define the test. ")
+    context.build
+  end
+
+  # Test::Unit integration
+
+  def test_should_create_a_new_context_and_build_it_on_Test_Unit_context
+    c = mock("context")
+    c.expects(:build)
+    Thoughtbot::Shoulda::Context.expects(:new).with("foo", kind_of(Class)).returns(c)
+    self.class.context "foo" do; end
+  end
+
+  def test_should_create_a_one_off_context_and_build_it_on_Test_Unit_should
+    s = mock("test")
+    Thoughtbot::Shoulda::Context.any_instance.expects(:should).with("rock").returns(s)
+    Thoughtbot::Shoulda::Context.any_instance.expects(:build)
+    self.class.should "rock" do; end
+  end
+
+  def test_should_define_a_test_on_should
+    s = mock("test")
+    Thoughtbot::Shoulda::Context.any_instance.expects(:should).with("rock").returns(s)
+    Thoughtbot::Shoulda::Context.any_instance.expects(:build)
+    self.class.should "rock" do; end
+  end
+
+  def test_should_create_a_one_off_context_and_build_it_on_Test_Unit_should_eventually
+    s = mock("test")
+    Thoughtbot::Shoulda::Context.any_instance.expects(:should_eventually).with("rock").returns(s)
+    Thoughtbot::Shoulda::Context.any_instance.expects(:build)
+    self.class.should_eventually "rock" do; end
+  end
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification 
+name: rotuka-shoulda-gem
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Thoughtbot
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-07-08 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: "The Shoulda Rails plugin makes it easy to write elegant, understandable, and maintainable tests. Shoulda consists of test macros, assertions, and helpers added on to the Test::Unit framework. It\xE2\x80\x99s fully compatible with your existing tests, and requires no retooling to use."
+email: 
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- Manifest.txt
+- README.txt
+files: 
+- .gemspec
+- Manifest.txt
+- Rakefile
+- README.txt
+- bin/convert_file_to_shoulda
+- lib/proc_extensions.rb
+- lib/shoulda.rb
+- test/test_shoulda.rb
+has_rdoc: true
+homepage: http://github.com/thoughtbot/shoulda-gem
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Testing made easier on the fingers and the eyes
+test_files: 
+- test/test_shoulda.rb