fun_with_testing 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MWE5NTczZmFmZGNiM2RlYzVhMjhlYmY5NWViZDZkOWM1M2Y4NjljNg==
+  data.tar.gz: !binary |-
+    NTZhYmJkMjk5ZWQ2ZjBjYzgwMDM5MDk5NzU1ZGM2Y2Y4YWY5YmI3ZA==
+SHA512:
+  metadata.gz: !binary |-
+    ZGYxNzU2NjdiNTI2MTRlNjU1NjkxYWQ5NWIwOWFkMzQzODllYTE2OTBhYTFh
+    OWY2NzhiZjk3Mjk2YzZhZmI1MzA0MzY3MTQxMzE5ZTgzZGU0ZGYyYjZhYzA1
+    M2QzOWFmNDEyN2I0ZWVkNjZhM2E0NzBlNTBiMWRmN2Q4NjY2ZTI=
+  data.tar.gz: !binary |-
+    MjRhYzA3MjRlNTg1NGE5N2FhMDlkNDNmZjhlMTVmY2QxZjcwN2M5MDkwZmI0
+    MjhkZWE1ZjliMDZkNmEwMmYyNWQ5NmQxYzNhZTk3ZWYzZmQ0NWY5NjIwN2Q1
+    NGU5YzhhMDYzOTkwNTdiMDAxMmNmMjU3NjQ3NjFjNTYyMzM5ZTU=

data/Gemfile

@@ -0,0 +1,14 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "shoulda", ">= 3.5"
+  gem "rdoc", "~> 3.12"
+  gem "bundler", "~> 1.0"
+  gem "jeweler", "~> 2.0"
+  # gem "rcov", ">= 0"
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2014 Bryce Anderson
+
+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/README.rdoc

@@ -0,0 +1,41 @@
+= fun_with_testing
+
+A bunch of useful assertions.
+
+Usage:
+
+    # This might go in test/helper.rb, for example
+    class GemTestCase < Test::Unit::TestCase
+      include FunWith::Testing              # includes all custom assertions
+      # include FunWith::Testing::Assertions::Basics        # alternately, just include tests piecemeal
+      # include FunWith::Testing::Assertions::ActiveRecord  # alternately, just include tests piecemeal
+      # include FunWith::Testing::Assertions::FunWithFiles  # alternately, just include tests piecemeal
+    end
+    
+Then in test/test_gem.rb:
+
+    class TestGem < GemTestCase
+      def test_my_thing
+        assert_zero( 0 )
+        assert_not_zero( 1 )
+        assert_has_method( 1, :to_s )
+        # ... and so on down the line
+      end
+    end
+
+
+== Contributing to fun_with_testing
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet.
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it.
+* Fork the project.
+* Start a feature/bugfix branch.
+* Commit and push until you are happy with your contribution.
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2014 Bryce Anderson. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,58 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "fun_with_testing"
+  gem.homepage = "http://github.com/darthschmoo/fun_with_testing"
+  gem.license = "MIT"
+  gem.summary = "A place to stash Test::Unit assertions I've found handy."
+  gem.description = "A place to stash Test::Unit assertions I've found handy. Use at your own risk"
+  gem.email = "keeputahweird@gmail.com"
+  gem.authors = ["Bryce Anderson"]
+  
+  gem.files = Dir.glob( File.join( ".", "lib", "**", "*.rb" ) ) + 
+              Dir.glob( File.join( ".", "test", "**", "*" ) ) +
+              %w( Gemfile Rakefile LICENSE.txt README.rdoc VERSION CHANGELOG.markdown )
+  
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+# require 'rcov/rcovtask'
+# Rcov::RcovTask.new do |test|
+#   test.libs << 'test'
+#   test.pattern = 'test/**/test_*.rb'
+#   test.verbose = true
+#   test.rcov_opts << '--exclude "gems/*"'
+# end
+
+task :default => :test
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "fun_with_testing #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/fun_with/testing/assertions/active_record.rb

@@ -0,0 +1,108 @@
+module FunWith
+  module Testing
+    module Assertions
+      module ActiveRecord
+        def assert_record_save( record, message = "")
+          result = record.save
+
+          message = "Record #{record} did not save properly.  "
+          message += record.errors.map{ |k,v| "#{k} : #{v}"}.join(", ")
+
+          assert_block message do
+            result
+          end
+        end
+
+        # Usage:  get("index"); assert_response_success( :template => "index" )
+        # 
+        def assert_response_success( opts = {} )
+          assert_block "@response is nil" do
+            !@response.nil?
+          end
+
+          if @response.error?
+            puts @response.body
+          elsif @response.redirect?
+            raise Test::Unit::AssertionFailedError.new( "Expected success, was redirect to #{@response.redirected_to} with flash #{flash}" )
+          end
+
+          assert_response :success
+          assert_template opts[:template] if opts[:template]
+        end
+
+        def assert_response_redirect( opts = {} )
+          assert_block "@response is nil" do
+            !@response.nil?
+          end
+
+          if @response.error? || @response.client_error?
+            puts @response.body
+            puts "Flash:" + @response.flash.map{|k,v| "#{k} : #{v}"}.join(', ')
+            debugger
+            nil
+          elsif @response.success?
+            puts "OOPS: should have redirected. Instead went to #{@response.template.action_name}, flash: #{@response.flash.inspect}"
+          end
+
+          assert_response :redirect
+          assert_redirected_to opts[:to] if opts[:to]
+        end
+
+        def assert_no_errors_on( record, message = "" )
+          record.valid?
+          message = build_message( message,
+                                   "#{record.class.name} record should have no errors.  Errors: ?",
+                                   record.errors.map{ |k,v| "[#{k} : #{v}]"}.join(", ")
+                                   )
+
+          assert_block message do
+            record.valid?
+          end
+        end
+
+        # TODO: Should be able to say which errors should be present
+        def assert_errors_on( record, message = "" )
+          message = build_message( message, "#{record.class.name} record should have errors.")
+
+          assert_block message do
+            !record.valid?
+          end
+        end
+      
+        def assert_an_error_on( record, _field, error_says = nil )
+          message = build_message( "", "<?> should have an error on the <?> field.", record, _field )
+          assert_block message  do
+            !record.errors[_field].blank?
+          end
+        
+          unless error_says.blank?
+            message = build_message( "", "<?> should have an error on the <?> field that says <?>.", record, _field, error_says )
+            assert_block message do
+              # puts "Inside field error block"
+              #             debugger
+              record.errors[_field].include?(error_says)
+            end
+          end
+        end
+
+        def assert_record_destroyed( record, message = "")
+          not_record_message = build_message(message, "<?> is not an ActiveRecord::Base object.", record)
+          new_record_message = build_message(message, "<?> should not be a new record in order to use assert_destroy().", record)
+          full_message = build_message(message, "<?> should have been destroyed.", record)
+
+          assert_block not_record_message do
+            record.is_a?(ActiveRecord::Base)
+          end
+
+          assert_block new_record_message do
+            record.new_record? == false
+          end
+
+          assert_block full_message do
+            record.class.find_by_id(record.id) == nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fun_with/testing/assertions/basics.rb

@@ -0,0 +1,178 @@
+module FunWith
+  module Testing
+    module Assertions
+      module Basics
+        def assert_not_zero( actual, message = "" )
+          message = build_message(message, "should not be zero")
+
+          assert_block message do
+            actual != 0
+          end
+        end
+
+        def assert_zero( actual, message = "" )
+          message = build_message(message, "should be zero, not <#{actual}>")
+
+          assert_block message do
+            actual == 0
+          end
+        end
+
+        def assert_one( actual, message = "" )
+          message = build_message(message, "should be 1, not <#{actual}>")
+
+          assert_block message do
+            actual == 1
+          end
+        end
+        
+        def assert_negative( actual, message = "" )
+          message = build_message(message, "should be negative, not <#{actual}>")
+
+          assert_block message do
+            actual < 0
+          end
+        end
+
+        def assert_true( actual, message = "" )
+          message = build_message(message, "should be true, not <#{actual}>")
+          assert_block message do
+            actual == true
+          end
+        end
+
+        def assert_false( actual, message = "" )
+          message = build_message(message, "should be false, not <#{actual}>")
+          assert_block message do
+            actual == false
+          end
+        end
+        
+        
+        def assert_blank( obj, message = "" )
+          if obj.respond_to?(:blank?)
+            full_message = build_message(message, "<?> should be blank.", obj)
+          else
+            full_message = build_message(message, "<?> does not respond to :blank? method.", obj)
+          end 
+          
+          assert_block full_message do
+            obj.respond_to?(:blank?) && obj.blank?
+          end
+        end
+
+        def assert_matches( string, regexp_or_string, message = "")
+          full_message = build_message(message, "<?> should match regex <?>", string, regexp_or_string)
+          assert_block full_message do
+            if regexp_or_string.is_a?(Regexp)
+              string.match(regexp_or_string) ? true : false
+            elsif regexp_or_string.is_a?(String)
+              string.include?(regexp_or_string)
+            end
+          end
+        end
+
+        def assert_doesnt_match( string, regexp, message = "")
+          full_message = build_message(message, "<?> should not match regex <?>", string, regexp)
+          assert_block full_message do
+            string.match(regexp) ? false : true
+          end
+        end
+
+
+        # check that the given variables were assigned non-nil values
+        # by the controller
+
+        # If successful, returns an array of assigned objects.
+        # You can do:
+        # account, phone_number = assert_assigns(:account, :phone_number)
+        # or
+        # order = assert_assigns(:order)
+        def assert_assigns(*args)
+          symbols_assigned = []
+          symbols_not_assigned = []
+
+          for sym in args
+            ((assigns(sym) != nil)? symbols_assigned : symbols_not_assigned) << sym
+          end
+
+          message = build_message("", "The following variables should have been assigned values by the controller: <?>", symbols_not_assigned.map{|s| "@#{s.to_s}"}.join(", "))
+
+          assert_block message do
+            symbols_not_assigned.length == 0
+          end
+
+          if symbols_assigned.length == 1
+            assigns(symbols_assigned.first)
+          else
+            symbols_assigned.map{|s| assigns(s)}
+          end
+        end
+
+        # Ick
+        # read as "assert greater than 5, <test_value>"
+        def assert_greater_than( reference_value, amount, message = "" )
+          message = build_message("", "second argument <?> should be greater than reference value <?>", amount, reference_value)
+
+          assert_block message do
+            amount > reference_value
+          end
+        end
+
+        # read as "assert less than 5, <test value>"
+        def assert_less_than( reference_value, amount, message = "" )
+          message = build_message("", "second argument <?> should be less than reference value <?>", amount, reference_value)
+
+          assert_block message do
+            amount < reference_value
+          end
+        end
+
+        # I think "assert_delta_in_range" already does this
+        def assert_times_are_close( t1, t2, window = 1, message = "")
+          message = build_message(message, "times should be within ? second of each other.", window)
+
+          assert_block message do
+            (t1 - t2).abs < window
+          end
+        end
+
+        def assert_equal_length( expected, actual, message = "" )
+          message = build_message( message, "items should be of equal length: expected: <?>, actual: <?>", expected.length, actual.length )
+          
+          assert_block message do
+            expected.length == actual.length
+          end
+        end
+          
+        def assert_equality_of_methods(*args)
+          expected = args[0]
+          actual = args[1]
+          methods = args[2..-1].flatten
+          message = "The following methods were not equal: "
+
+          unequal = []
+
+          for method in methods
+            exp = expected.send(method.to_sym)
+            act = actual.send(method.to_sym)
+            unless exp == act
+              unequal << method
+              message += "\n\t#{method} (#{exp.inspect},#{act.inspect})"
+            end
+          end
+
+          assert_block message do
+            unequal.blank?
+          end
+        end
+        
+        def assert_has_instance_method( object, instance_method, message = "object #{object} should respond to #{instance_method.inspect}" )
+          assert_block( message ) do
+            object.instance_methods.include?( instance_method )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fun_with/testing/assertions/fun_with_files.rb

@@ -0,0 +1,108 @@
+module FunWith
+  module Testing
+    module Assertions
+      module FunWithFiles
+        def assert_fwf_filepath( file, message = "" )
+          message = build_message( message, "File <#{file}> should be a FunWith::Files::FilePath")
+          
+          assert_block message do
+            file.is_a?( FunWith::Files::FilePath )
+          end
+        end
+
+        def assert_file( file, message = "" )
+          assert_fwf_filepath( file, message )
+          
+          message = build_message( message, "File should exist at <#{file}>." )
+
+          assert_block message do
+            file.exist?
+          end
+        end
+
+        def assert_no_file( file, message = "" )
+          assert_fwf_filepath( file, message )
+          
+          message = build_message( message, "No file/directory should exist at <#{file}>." )
+
+          assert_block message do
+            ! file.exist?
+          end
+        end
+        
+        def assert_directory( file, message = "" )
+          assert_fwf_filepath( file, message )
+          
+          message = build_message( message, "<#{file}> should be a directory." )
+
+          
+          assert_block message do
+            file.directory?
+          end
+        end
+
+        def assert_not_directory( file, message = "" )
+          assert_fwf_filepath( file, message )
+          
+          message = build_message( message, "<#{file}> shouldn't be a directory." )
+
+          
+          assert_block message do
+            ! file.directory?
+          end
+        end
+        
+        def assert_empty_file( file, message = "" )
+          assert_fwf_filepath( file, message )
+          
+          message = build_message( message, "Empty file should exist at <#{file}>." )
+
+          
+          assert_block message do
+            file.exist? && file.empty?
+          end
+        end
+
+        def assert_empty_directory( file, message = "" )
+          assert_fwf_filepath( file, message )
+          
+          message = build_message( message, "Empty directory should exist at <#{file}>." )
+
+          assert_block message do
+            file.directory? && file.empty?
+          end
+        end
+        
+        def assert_file_has_content( file, message = "" )
+          assert_fwf_filepath( file, message )
+          
+          message = build_message( message, "File should exist at <#{file}>, and have content." )
+
+          assert_block message do
+            file.exist? && !file.empty?
+          end
+        end
+
+        def assert_file_contents( file, content, message = "" )
+          assert_file( file )
+          
+          case content
+          when String
+            # message = build_message( message, "File <#{file}> contents should be #{content[0..99].inspect}#{'...(truncated)' if content.length > 100}" )
+            assert_equal( content, file.read, message )
+          when Regexp
+            assert_match( content, file.read, message)
+          end
+        end
+        
+        # Actually, because  FilePath responds to =~, assert_match may work for this
+        # def assert_file_content_matches( file, regex_or_string, times = nil, message = "" )
+        #   if 
+        #   if times.nil?
+        #     
+        #   end
+        # end
+      end
+    end
+  end
+end

data/lib/fun_with_testing.rb

@@ -0,0 +1,13 @@
+files = Dir.glob( File.join( File.dirname(__FILE__), "fun_with", "testing", "**", "*.rb" ) )
+
+for file in files.map{ |f| f.gsub(/\.rb$/, '') }
+  require file
+end
+
+
+# FunWith::Testing.extend( FunWith::Testing::FwtExtensions )
+# FunWith::Testing.assertion_modules << FunWith::Testing::Assertions::ActiveRecord
+# FunWith::Testing.assertion_modules << FunWith::Testing::Assertions::Basics
+
+FunWith::Testing.send(:include, FunWith::Testing::Assertions::Basics)
+FunWith::Testing.send(:include, FunWith::Testing::Assertions::ActiveRecord)

data/test/helper.rb

@@ -0,0 +1,43 @@
+require 'rubygems'
+require 'bundler'
+
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'fun_with_testing'
+
+class Test::Unit::TestCase
+end
+
+# Any subclass of Test::Unit::TestCase seems to automatically hook into the test suite.
+# Therefore, calling a test to see if it returns false makes the suite fail.  Including
+# to this class instead prevents that.  I may need to more closely mimic Test::Unit::TestCase
+# in order to test messages properly.
+class MockUnitTest
+  def build_message( m, m2, obj = nil)
+    "#{m} #{m2} #{obj}"
+  end
+  
+  def assert_block( msg, &block )
+    yield
+  end
+end
+
+class FunWith::Testing::TestCase < Test::Unit::TestCase
+  def extended_test_case( &block )
+    @case_class = Class.new( MockUnitTest )
+    @case_class.send( :include, FunWith::Testing )
+    @case = @case_class.new
+    yield if block_given?
+  end
+end
+

data/test/test_assertions.rb

@@ -0,0 +1,34 @@
+require 'helper'
+
+module FunWith
+  module Testing
+    class TestAssertions < FunWith::Testing::TestCase
+      context "testing :assert_zero()" do
+        setup do
+          extended_test_case
+        end
+        
+        should "proclaim zero is zero" do
+          assert_equal true, @case.assert_zero( 0 )
+        end
+        
+        should "refute the notion that zero is one" do
+          assert_equal false, @case.assert_zero( 1 )
+        end
+        
+        should "demonstrate zero is not a potato" do
+          assert_equal false, @case.assert_zero( :potato )
+        end
+
+        should "prove beyond a shadow of a doubt that zero is not a grue" do
+          assert_equal false, @case.assert_zero( "grue" )
+        end
+        
+        # curious why it doesn't have :to_f
+        should "acknowledge that Integer has instance_variable to :to_s" do
+          assert_equal( true, @case.assert_has_instance_method( Integer, :to_s ) )
+        end
+      end
+    end
+  end
+end

data/test/test_fun_with_testing.rb

@@ -0,0 +1,31 @@
+require 'helper'
+
+
+class TestFunWithTesting < FunWith::Testing::TestCase
+  should "be plumbed properly" do
+    assert defined?( FunWith::Testing::Assertions )
+    assert defined?( FunWith::Testing::Assertions::ActiveRecord )
+    assert defined?( FunWith::Testing::Assertions::Basics )
+    
+    assert_includes( FunWith::Testing::Assertions::Basics.instance_methods, :assert_blank )
+    assert_includes( FunWith::Testing::Assertions::Basics.instance_methods, :assert_blank )
+    assert_includes( FunWith::Testing::Assertions::Basics.instance_methods, :assert_greater_than )
+    assert_includes( FunWith::Testing::Assertions::Basics.instance_methods, :assert_zero )
+    assert_includes( FunWith::Testing::Assertions::ActiveRecord.instance_methods, :assert_no_errors_on )
+  end
+  
+  should "access a listing of assertion modules" do
+    assert_includes( FunWith::Testing.included_modules, FunWith::Testing::Assertions::ActiveRecord )
+    assert_includes( FunWith::Testing.included_modules, FunWith::Testing::Assertions::Basics )
+  end
+  
+  should "successfully get included in a subclass" do
+    klass = Class.new( Test::Unit::TestCase )
+    
+    imethods = klass.instance_methods.select{|sym| sym.to_s =~ /^(assert|refute)_/ }
+    assert_not_include imethods, :assert_zero
+    klass.send( :include, FunWith::Testing )
+    imethods = klass.instance_methods.select{|sym| sym.to_s =~ /^(assert|refute)_/ }
+    assert_include( imethods, :assert_zero )
+  end
+end

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: fun_with_testing
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Bryce Anderson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: shoulda
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.5'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: A place to stash Test::Unit assertions I've found handy. Use at your
+  own risk
+email: keeputahweird@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.rdoc
+files:
+- ./lib/fun_with/testing/assertions/active_record.rb
+- ./lib/fun_with/testing/assertions/basics.rb
+- ./lib/fun_with/testing/assertions/fun_with_files.rb
+- ./lib/fun_with_testing.rb
+- ./test/helper.rb
+- ./test/test_assertions.rb
+- ./test/test_fun_with_testing.rb
+- CHANGELOG.markdown
+- Gemfile
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+homepage: http://github.com/darthschmoo/fun_with_testing
+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: A place to stash Test::Unit assertions I've found handy.
+test_files: []