totally-osom-tests 0.0.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    OTI5YzFkNjE0MjkyMzVmMGMyYWYwYTViNjc0YzAyYzU1NjJiNmMwYw==
+  data.tar.gz: !binary |-
+    ZDQ1ODhjNTc5NGFiYzJlNTlkMTZlNDg0MmJhN2UyOTVhZThkZTQ2YQ==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    NTQ5NTFlMTQ1Nzc3MDkyMTcyZTliZTY1YjY4NTI1YmZmNjdjMDRiNjRlY2E1
+    ODhiODNiOWUyZmZjOWQwYTI4YjFhNWUzMzI0YjZiNzNkYmMzOWZlODUzODIw
+    NjE0ZGVjYTY3NjBiZmI2NjJjOGU0MDJjNGNiNWJmNDU4OTI1NTc=
+  data.tar.gz: !binary |-
+    ZTgzZTBlZGFmNzZhZjIxNTllNGVmNDY3ZTc5ZjVlZWU5NGZhMDVmZDRlNGI2
+    ZWVmN2Y3MjgzNDRiODc1YTY4MDFlODdlNzFiYzViMWYxMWQ3NzY0NDdhOWNm
+    OTU5NzAxNDczNWM5YjgxZmQ4YWRjODJhYjNmNTExOTczMzhmM2E=

data/README.md

@@ -0,0 +1,28 @@
+# Totaly Osom Tests
+
+__NOTE__: This is purely an excersize in awesomeness. If you need testing framework
+for a real-life project, please use rspec/test_case/whatever.
+
+## The Goal
+
+1. Zero hassle TDD experiense
+2. Simplified BDD specs syntax
+3. Flexible internal structure
+4. Easily extensible interface
+
+
+## Credits
+
+Most of the parts in this thing are "inspired" by the following projects:
+
+1. [rspec](https://github.com/rspec/rspec)
+2. [minitest](https://github.com/seattlerb/minitest)
+3. [mocha](http://visionmedia.github.com/mocha)
+4. [vows](http://vowsjs.org)
+
+
+## Copyright
+
+All the code in this repo is released under the terms of the MIT license
+
+Copyright (C) 2013 Nikolay Nemshilov

data/bin/tots

@@ -0,0 +1,3 @@
+#! /usr/bin/env ruby
+
+require_relative '../lib/tots/cli'

data/lib/totally-osom-tests.rb

@@ -0,0 +1,6 @@
+#
+# Just a rubygem hook
+#
+# Copyright (C) 2013 Nikolay Nemshilov
+#
+require_relative './tots'

data/lib/tots.rb

@@ -0,0 +1,20 @@
+#
+# The main project's namespace
+#
+# Copyright (C) 2013 Nikolay Nemshilov
+#
+module TOTS
+  VERSION = '0.0.0'
+end
+
+require_relative './tots/asserts'
+require_relative './tots/matcher'
+require_relative './tots/matcher/awesome'
+require_relative './tots/printer'
+require_relative './tots/printer/dots'
+require_relative './tots/printer/emoji'
+require_relative './tots/watcher'
+require_relative './tots/runner'
+require_relative './tots/test'
+require_relative './tots/spec'
+

data/lib/tots/asserts.rb

@@ -0,0 +1,58 @@
+#
+# The standard assertions
+#
+module TOTS::Asserts
+  def assert(smth, msg="No message given")
+    TOTS::Printer.asserting(msg)
+
+    unless smth
+      raise TOTS::Test::Fail, msg
+    end
+  end
+
+  def assert_equal(v1, v2, msg=nil)
+    assert v1 == v2, msg || "#{v1.inspect} supposed to be equal to #{v2.inspect}"
+  end
+
+  def assert_empty(v, msg=nil)
+    assert_respond_to v, :empty?
+    assert v.empty?, msg || "#{v.inspect} supposed to be empty"
+  end
+
+  def assert_respond_to(obj, method, msg=nil)
+    assert obj.respond_to?(method), msg || "#{obj.inspect} supposed to respond to the #{method} method"
+  end
+
+  def assert_nil(v, msg=nil)
+    assert v === nil, msg || "#{v.inspect} supposed to be nil"
+  end
+
+  def assert_includes(list, value, msg=nil)
+    assert_respond_to list, :include?
+    assert list.include?(value), msg || "#{list.inspect} supposed to include #{value.inspect}"
+  end
+
+  def assert_match(obj, re, msg=nil)
+    assert_respond_to re, :=~
+    assert re =~ obj, msg || "#{obj.inspect} supposed to match #{re.inspect}"
+  end
+
+  def assert_instance_of(obj, klass, msg=nil)
+    assert obj.instance_of?(klass), msg || "#{obj.inspect} supposed to be instance of #{klass}"
+  end
+
+  def assert_raises(type, msg=nil, &block)
+    raise ArgumentError, "no block given" if !block_given?
+
+    begin
+      yield
+
+      assert false, msg || "expected to raise #{type}, but nothing was raised"
+
+    rescue Exception => e
+      if type && !(e.is_a?(type))
+        assert false, msg || "expected to raise #{type}, but got #{e.class} instead"
+      end
+    end
+  end
+end

data/lib/tots/autorun.rb

@@ -0,0 +1,16 @@
+#
+# Just an auto-run hook
+#
+# Add this into your tests to be able to run them as plain ruby
+#
+# ```ruby
+# require 'tots/autorun'
+#
+# describe Stuff do
+# end
+# ```
+#
+
+require_relative '../tots' unless defined?(TOTS)
+
+at_exit { TOTS::Runner.start }

data/lib/tots/cli.rb

@@ -0,0 +1,62 @@
+#
+# A simple CLI for the `tots` cmd
+#
+require_relative '../tots/autorun'
+
+args = {}
+dirs = []
+
+dirt = ARGV.dup
+
+while arg = dirt.shift
+  case arg
+  when '-h', '--help'
+    puts <<-EOF.gsub(/(\A|\n)\s+\|/, "\\1")
+    |TOTS Runner Help:
+    |
+    |  tots path[ path ...] [OPTSIONS]
+    |
+    |
+    |OPTIONS:
+    |
+    |  -h      --help              # show this help
+    |  -w      --watch             # watch for changes in specified files/dires
+    |  -r name --reporter name     # specify the reporter
+    |
+    EOF
+    exit
+
+  when '-w', '--watch'
+    args['-w'] = true
+
+  when '-r', '--reporter'
+    args['-r'] = dirt.shift
+
+  else
+    # assuming it's a dir
+    dirs << arg
+  end
+end
+
+# setting the reporter
+TOTS::Printer.set args['-r'] if args['-r']
+
+# figuring the paths
+dirs << 'test' if dirs.empty?
+
+dirs.map! do |name|
+  name = name.slice(0, name.size - 1) if name[name.size-1] == '/'
+  File.exists?(name) && File.directory?(name) ? "#{name}/**/*_test.rb" : name
+end
+
+# including the test files
+$LOAD_PATH << "#{Dir.pwd}/test/" if File.exists?('test') && File.directory?('test')
+
+require "test_helper" if File.exists?("test/test_helper.rb")
+
+Dir[*dirs].each do |name|
+  require "#{Dir.pwd}/#{name}"
+end
+
+# watching for the changes
+TOTS::Watcher.watch(dirs) if args.include?('-w')

data/lib/tots/matcher.rb

@@ -0,0 +1,16 @@
+#
+# The `must` thingy
+#
+class TOTS::Matcher
+  include TOTS::Asserts
+
+  def initialize(object, *args)
+    @object = object
+  end
+end
+
+class Object
+  def must(*args)
+    TOTS::Matcher.new(self)
+  end
+end

data/lib/tots/matcher/awesome.rb

@@ -0,0 +1,42 @@
+#
+# Awesome matchers handler
+#
+# ```ruby
+# describe TOTS::Matcher::Awesome do
+#   it "must provide awesome matchers" do
+#     22.must == 22
+#     22.must >  11
+#     22.must =~ /2/
+#   end
+# end
+# ```
+#
+class TOTS::Matcher
+  def ==(value)
+    assert @object == value, "#{@object.inspect} supposed to be equal #{value.inspect}"
+  end
+
+  def !=(value)
+    assert @object != value, "#{@object.inspect} supposed not to be equal #{value.inspect}"
+  end
+
+  def =~(value)
+    assert value =~ @object, "#{@object.inspect} doesn't match #{value.inspect}"
+  end
+
+  def >(value)
+    assert @object > value, "#{@object.inspect} supposed to be > than #{value.inspect}"
+  end
+
+  def <(value)
+    assert @object < value, "#{@object.inspect} supposed to be < than #{value.inspect}"
+  end
+
+  def >=(value)
+    assert @object >= value, "#{@object.inspect} supposed to be >= than #{value.inspect}"
+  end
+
+  def <=(value)
+    assert @object <= value, "#{@object.inspect} supposed to be <= than #{value.inspect}"
+  end
+end

data/lib/tots/printer.rb

@@ -0,0 +1,126 @@
+# encoding: utf-8
+
+#
+# Generic printer
+#
+class TOTS::Printer
+  RED     = '1'
+  GREEN   = '2'
+  YELLOW  = '3'
+  VIOLET  = '4'
+  MARGETA = '5'
+  BLUE    = '6'
+  GREY    = '7;2'
+
+  def self.set(name)
+    @klass = const_get(name[0].upcase + name.slice(1, name.size - 1))
+  end
+
+  def self.method_missing(*args)
+    @inst ||= (@klass || Dots).new
+
+    @inst.__send__(*args)
+  end
+
+  def initialize
+    @suites_count  = 0
+    @tests_count   = 0
+    @asserts_count = 0
+    @passed_count  = 0
+    @fails_count   = 0
+    @errors_count  = 0
+    @skipped_count = 0
+
+    print "\n"
+  end
+
+  def pass
+    raise "Should be implemented in a subclass"
+  end
+
+  def skip
+    raise "Should be implemented in a subclass"
+  end
+
+  def fail
+    raise "Should be implemented in a subclass"
+  end
+
+  def error
+    raise "Should be implemented in a subclass"
+  end
+
+  def summary
+    {
+      :Asserts => @asserts_count,
+      :Tests   => @tests_count,
+      :Passed  => @passed_count,
+      :Failed  => @fails_count,
+      :Errored => @errors_count,
+      :Skipped => @skipped_count
+
+    }.map do |key, value|
+      "#{value} #{key}"
+    end.join(', ')
+  end
+
+  def waiting
+    raise "Should be implemented in a subclass"
+  end
+
+  def paint(string, color)
+    "\e[3#{color}m#{string}\e[0m"
+  end
+
+  def highlight(string, color)
+    "\e[4#{color}m#{string}\e[0m"
+  end
+
+  def testing(suite)
+    @suite = suite
+
+    @suites_count += 1
+  end
+
+  def running(test)
+    @tests_count += 1
+  end
+
+  def asserting(msg)
+    @asserts_count += 1
+  end
+
+  def passed
+    @passed_count += 1
+    pass
+  end
+
+  def failed(e)
+    @fails_count += 1
+    fail(e)
+  end
+
+  def errored(e)
+    @errors_count += 1
+    error(e)
+  end
+
+  def skipped
+    @skipped_count += 1
+    skip
+  end
+
+  def finish
+    summary
+  end
+
+  def watching(on)
+    if on
+      puts "\n"
+      @waiting = Thread.new { waiting }
+    else
+      @waiting.kill if @waiting
+      puts "\n"
+    end
+  end
+end

data/lib/tots/printer/dots.rb

@@ -0,0 +1,61 @@
+# encoding: utf-8
+
+#
+# Your good old dots printer
+#
+class TOTS::Printer::Dots < TOTS::Printer
+  def pass
+    print paint(".", GREEN)
+  end
+
+  def skip
+    print paint('S', YELLOW)
+  end
+
+  def fail(e)
+    print paint('F', RED)
+  end
+
+  def error(e)
+    print paint('E', RED)
+  end
+
+  def summary
+    puts "\n\n"
+
+    if @fails_count == 0 && @errors_count == 0
+      print paint("✔ Osom! ", GREEN)
+    else
+      print paint("✖ Doh... ", RED)
+    end
+
+    puts paint(super, GREY)
+  end
+
+  CYLON_SIZE = 10
+
+  def waiting
+    puts "\n\n"
+
+    i = 0
+
+    while true
+      inc =  1 if i == 0
+      inc = -1 if i > (CYLON_SIZE - 3)
+
+      dots = Array.new(CYLON_SIZE).map{ |i| ' ' }
+
+      dots[i]           = paint("■", RED)
+      dots[i - inc]     = paint("■", RED + ";2") if i > 0
+      dots[i - 2 * inc] = paint("∙", RED + ";2") if i < CYLON_SIZE - 2 && i > 1
+
+      puts "\u001b[2A\r" + paint('Watching ', GREY) + dots.join('') + "\n\n"
+
+      sleep 0.07
+
+      i += inc
+    end
+  end
+end
+
+

data/lib/tots/printer/emoji.rb

@@ -0,0 +1,55 @@
+# encoding: utf-8
+
+#
+# Emoji printer
+#
+class TOTS::Printer::Emoji < TOTS::Printer
+  GOOD = %w(🌵 🌴 🌲 🌳 🌿 🍀 🎄)
+  WAIT = %w(🌑 🌒 🌓 🌔 🌕 🌖 🌗 🌘)
+
+  def pass
+    print GOOD[rand(GOOD.size)] + " "
+  end
+
+  def skip
+    print '😴 '
+  end
+
+  def fail(e)
+    print '😡 '
+  end
+
+  def error(e)
+    print '💥 '
+  end
+
+  def summary
+    puts "\n\n"
+
+    if @fails_count == 0 && @errors_count == 0
+      print paint("😊  Happy! ", GREEN)
+    else
+      print paint("😱  Oh, no... ", RED)
+    end
+
+    puts paint(super, GREY)
+  end
+
+  CYLON_SIZE = 10
+
+  def waiting
+    puts "\n\n"
+
+    i = 0
+
+    while true
+      i = 0 if i > (WAIT.size - 1)
+
+      puts "\u001b[2A\r" + paint('Waiting ', GREY) + WAIT[i] + "\n\n"
+
+      sleep 0.08
+
+      i += 1
+    end
+  end
+end

data/lib/tots/runner.rb

@@ -0,0 +1,21 @@
+#
+# The runner
+#
+class TOTS::Runner
+
+  def self.<<(spec)
+    specs << spec
+  end
+
+  def self.specs
+    @specs ||= []
+  end
+
+  def self.start
+    specs.each(&:run)
+
+    TOTS::Printer.finish
+
+    TOTS::Watcher.check
+  end
+end

data/lib/tots/spec.rb

@@ -0,0 +1,101 @@
+#
+# The spec unit
+#
+# Copyright (C) 2013 Nikolay Nemshilov
+#
+class TOTS::Spec
+  include TOTS::Asserts
+
+  # the tests stash
+  def self.tests
+    @tests ||= []
+  end
+
+  def self.specs
+    @specs ||= []
+  end
+
+  #
+  # Sub-describe blocks catcher
+  #
+  def self.describe(*args, &block)
+    specs << Class.new(TOTS::Spec, &block)
+  end
+
+  #
+  # alias for `describe`
+  #
+  def self.context(*args, &block)
+    describe(*args, &block)
+  end
+
+  #
+  # The basic `it` thingy
+  #
+  # ```ruby
+  # describe Smth do
+  #   it "must do stuff" do
+  #   end
+  # end
+  # ```
+  #
+  def self.it(*args,&block)
+    if args.size == 0
+      self
+    else
+      tests << TOTS::Test.new(args + [block])
+    end
+  end
+
+  #
+  # Quick, skip marking
+  #
+  # ```ruby
+  # describe Smth do
+  #   it.skip "this test" do
+  #     this_code.will_be(:skipped)
+  #   end
+  # end
+  # ```
+  #
+  def self.skip(*args, &block)
+    it *args # skipping the block
+  end
+
+  #
+  # Runs the spec
+  #
+  def self.run
+    TOTS::Printer.testing self
+
+    suite = new
+
+    tests.each do |test|
+      TOTS::Printer.running test.name
+
+      begin
+        test.run(suite)
+
+        TOTS::Printer.passed
+
+      rescue TOTS::Test::Skip => e
+        TOTS::Printer.skipped
+
+      rescue TOTS::Test::Fail => e
+        TOTS::Printer.failed(e)
+      end
+    end
+
+    specs.each(&:run)
+  end
+
+end
+
+#
+# the top-level describe
+#
+module Kernel
+  def describe(*args, &block)
+    TOTS::Runner << Class.new(TOTS::Spec, &block)
+  end
+end

data/lib/tots/test.rb

@@ -0,0 +1,31 @@
+#
+# A single test case entity
+#
+class TOTS::Test
+  attr_accessor :name, :options, :block
+
+  class Skip < Exception; end
+  class Fail < Exception; end
+
+  def initialize(args)
+    @block   = args.last.is_a?(Proc) ? args.pop : skip
+    @options = args.size > 1 && args.last.is_a?(Hash) ? args.pop : {}
+    @name    = args[0] || 'no name given'
+  end
+
+  def skip
+    @block = Proc.new do
+      raise Skip
+    end
+  end
+
+  def run(context)
+    test = self
+
+    context.instance_eval do
+      @test_options = test.options
+      instance_eval &test.block
+    end
+  end
+
+end

data/lib/tots/watcher.rb

@@ -0,0 +1,33 @@
+#
+# File changes watcher
+#
+class TOTS::Watcher
+
+  def self.watch(paths)
+    @paths = paths
+  end
+
+  def self.check
+    return if ! @paths
+
+    TOTS::Printer.watching(true)
+
+    setup; @watching = true if !@watching
+  end
+
+  def self.setup
+    require 'rb-fsevent'
+
+    fsevent = FSEvent.new
+    fsevent.watch Dir.pwd do |directories|
+      TOTS::Printer.watching(false)
+
+      puts "Detected change inside: #{directories.inspect}\n"
+
+      TOTS::Runner.start
+    end
+
+    fsevent.run
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,11 @@
+require_relative '../lib/tots/autorun'
+
+class TOTS::Spec
+
+  def assert_fails(&block)
+    assert_raises TOTS::Test::Fail do
+      block.yield
+    end
+  end
+
+end

data/test/tots/assert_test.rb

@@ -0,0 +1,113 @@
+require 'test_helper'
+
+describe TOTS::Spec do
+
+  describe "standard assertions" do
+    describe "assert" do
+      it "must pass with trues" do
+        assert true
+      end
+
+      it "must fail with false" do
+        assert_fails { assert(false) }
+      end
+    end
+
+    describe "assert_equal" do
+      it "must pass with equal data" do
+        assert_equal 2, 2
+      end
+
+      it "must fail with different data" do
+        assert_fails { assert_equal(1,2) }
+      end
+    end
+
+    describe "assert_empty" do
+      it "must pass correctly" do
+        assert_empty ''
+      end
+
+      it "must fail with a non-empty objects" do
+        assert_fails { assert_empty(' ') }
+      end
+
+      it "must fail with objects without the :empty? method" do
+        assert_fails { assert_empty(nil) }
+      end
+    end
+
+    describe "assert_respond_to" do
+      it "must pass correctly" do
+        assert_respond_to '', :size
+      end
+
+      it "must fail when method is missing" do
+        assert_fails { assert_respond_to('', :non_existing_method) }
+      end
+    end
+
+    describe "assert_nil" do
+      it "must pass correctly" do
+        assert_nil nil
+      end
+
+      it "must fail with non nils" do
+        assert_fails { assert_nil(false) }
+        assert_fails { assert_nil('') }
+        assert_fails { assert_nil(0) }
+      end
+    end
+
+    describe "assert_includes" do
+      it "must pass correctly" do
+        assert_includes [1,2,3], 2
+      end
+
+      it "must fail correctly" do
+        assert_fails { assert_includes([1,2,3], 4) }
+        assert_fails { assert_includes(nil, 4) }
+      end
+    end
+
+    describe "assert_match" do
+      it "must pass correctly" do
+        assert_match "22", /2/
+      end
+
+      it "must fail correctly" do
+        assert_fails { assert_match("22", /3/) }
+        assert_fails { assert_match("22", nil) }
+      end
+    end
+
+    describe "assert_instance_of" do
+      it "must pass correctly" do
+        assert_instance_of '', String
+      end
+
+      it "must fail correctly" do
+        assert_fails { assert_instance_of('', Integer) }
+      end
+    end
+
+    describe "assert_raises" do
+      it "must pass when something raised" do
+        assert_raises(Exception) { raise Exception }
+      end
+
+      it "must fail when nothing raised" do
+        assert_fails do
+          assert_raises(Exception) { }
+        end
+      end
+
+      it "must fail when raised a different type of exception" do
+        assert_fails do
+          assert_raises(ArgumentError) { raise Exception }
+        end
+      end
+    end
+  end
+
+end

data/test/tots/matcher/awesome_test.rb

@@ -0,0 +1,80 @@
+require 'test_helper'
+
+describe TOTS::Matcher do
+
+  describe "awesome matchers" do
+    describe "==" do
+      it "must assert properly" do
+        22.must == 22
+      end
+
+      it "must fail correctly" do
+        assert_fails { 22.must == 33 }
+      end
+    end
+
+    describe "!=" do
+      it "must assert correctly" do
+        22.must != 33
+      end
+
+      it "must fail correctly" do
+        assert_fails { 22.must != 22 }
+      end
+    end
+
+    describe "=~" do
+      it "must assert correctly" do
+        '22'.must =~ /2/
+      end
+
+      it "must fail correctly" do
+        assert_fails { '22'.must =~ /3/ }
+      end
+    end
+
+    describe ">" do
+      it "must assert properly" do
+        22.must > 11
+      end
+
+      it "must fail correctly" do
+        assert_fails { 22.must > 22 }
+        assert_fails { 22.must > 33 }
+      end
+    end
+
+    describe "<" do
+      it "must assert properly" do
+        22.must < 33
+      end
+
+      it "must fail correctly" do
+        assert_fails { 22.must < 22 }
+        assert_fails { 22.must < 11 }
+      end
+    end
+
+    describe ">=" do
+      it "must assert properly" do
+        22.must >= 11
+        22.must >= 22
+      end
+
+      it "must fail correctly" do
+        assert_fails { 22.must >= 21 }
+      end
+    end
+
+    describe "<=" do
+      it "must assert properly" do
+        22.must <= 22
+        22.must <= 33
+      end
+
+      it "must fail correctly" do
+        assert_fails { 22.must <= 23 }
+      end
+    end
+  end
+end

data/test/tots/matcher_test.rb

@@ -0,0 +1,7 @@
+require 'test_helper'
+
+describe TOTS::Matcher do
+  it "must be accessible" do
+    assert ''.must.class == TOTS::Matcher
+  end
+end

data/test/tots/spec_test.rb

@@ -0,0 +1,18 @@
+require 'test_helper'
+
+describe TOTS::Spec do
+
+  it.skip "must be skipped" do
+    assert false, "this block should not be called"
+  end
+
+  it "must allow to specify options", some: 'options' do
+    assert_equal @test_options, some: 'options'
+  end
+
+  context "sub-block" do
+    it "must be called too" do
+      assert true
+    end
+  end
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: totally-osom-tests
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Nikolay Nemshilov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-12 00:00:00.000000000 Z
+dependencies: []
+description: It's gonna be totally awesome!
+email: nemshilov@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/totally-osom-tests.rb
+- lib/tots/asserts.rb
+- lib/tots/autorun.rb
+- lib/tots/cli.rb
+- lib/tots/matcher/awesome.rb
+- lib/tots/matcher.rb
+- lib/tots/printer/dots.rb
+- lib/tots/printer/emoji.rb
+- lib/tots/printer.rb
+- lib/tots/runner.rb
+- lib/tots/spec.rb
+- lib/tots/test.rb
+- lib/tots/watcher.rb
+- lib/tots.rb
+- test/test_helper.rb
+- test/tots/assert_test.rb
+- test/tots/matcher/awesome_test.rb
+- test/tots/matcher_test.rb
+- test/tots/spec_test.rb
+- bin/tots
+- README.md
+homepage: http://github.com/MadRabbit/totally-osom-tests
+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.0.0
+signing_key: 
+specification_version: 4
+summary: Totally awesome testing framework for ruby
+test_files: []