tokyo 0.0.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 69ea25a5800b85ee00d0af3c0129aec353c1fa95
+  data.tar.gz: 9bf8e1ae90ce5094fa1c9bb3a15e736c151fe491
+SHA512:
+  metadata.gz: b03505ddcac1cc3a69ed2eca8dee762d35872d0063dec027214894c06263be54de8a160b9f0c0d36cea1cda2aa51995060f814e0c763daa33eb94ce8f633fbf7
+  data.tar.gz: 8a2971ff0047dcd9ec8a28c62211bc0f39aa327fd11165faf53775e20bcde6b7945538c8667abde0b84debc6f87f12347373d0db400985ccbab79e7d34c62cfb

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+.DS_Store

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.2.2

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in tokyo.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Slee Woo
+
+MIT License
+
+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.md

@@ -0,0 +1,335 @@
+[![Build Status](https://travis-ci.org/sleewoo/tokyo.svg)](https://travis-ci.org/sleewoo/tokyo)
+
+## Tokyo - super-simple testing library for Ruby
+
+Its base API consist of just 10 memorable methods:
+
+- spec, context
+- before, around, after
+- test
+- assert, refute
+- skip, fail
+
+
+Assertions uses native Ruby methods so no need to remember contrived ones.
+
+Forget about repeatedly scanning documentation, just use methods Ruby already provides.
+
+Want to check whether something is nil? Use `nil?` method:
+
+```ruby
+assert(something).nil?
+```
+
+Want to check whether some array contains some value? Use `include?` method:
+
+```ruby
+assert(some_array).include? some_value
+```
+
+Need to check equality? Nothing simpler:
+
+```ruby
+assert(something) == something_else
+```
+
+Perhaps match?
+
+```ruby
+assert(something) =~ something_else
+```
+
+Or any?
+
+```ruby
+assert(some_array).any? {|v| v > 0}
+```
+
+Whatever. Use Ruby rather than contrived APIs.
+
+
+And when you need to cook your own assertions simply use `assert` method to define them:
+
+```ruby
+# defining a custom assertion
+assert :is_a_pizza do |something|
+  something =~ /Cheese/ && something =~ /Olives/
+end
+
+# using it inside tests
+test 'food' do
+  assert(something).is_a_pizza
+end
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'tokyo'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install tokyo
+
+## Usage
+
+Add `require 'tokyo'` to your `Rakefile`.
+
+Then create a task and use `Tokyo.run`:
+
+```ruby
+task :test do
+  Tokyo.run
+end
+```
+
+By default it will load `*_spec.rb` and `*_test.rb` files from `./spec` and `./test` folders.
+
+If you named your test files differently use `Tokyo.run` with your pattern:
+
+```ruby
+# search for test_*.rb files in ./tests folder
+task :test do
+  Tokyo.run 'tests/test_*.rb'
+end
+```
+
+If you want to run tests directly just use `tokyo` in your terminal:
+
+```bash
+tokyo
+```
+
+This will load `*_spec.rb` and `*_test.rb` files from `./spec` and `./test` folders.<br>
+If your tests have different naming conventions call `tokyo` command with a pattern.<br>
+For ex. load `test_*.rb` files in `./tests` folder:
+
+```bash
+tokyo tests/test_*.rb
+```
+
+
+## Specs
+
+Specs are defined by using `spec` method. It requires a single argument - the spec label.<br>
+It can be whatever but `nil`(which is used for another purpose, as shown below).
+
+```ruby
+# defining a spec
+spec Apple do
+
+  # and tests inside it
+  test :color do
+  end
+end
+```
+
+Nested contexts can be used for splitting logic:
+
+```ruby
+spec Greens do
+
+  context Fruits do
+
+    context Apple do
+
+    end
+  end
+end
+```
+
+## Specs are modules
+
+`spec` method returns a module. Specs including that module will inherit all tests:
+
+```ruby
+FruitsTests = spec Fruits do
+  # some tests
+end
+
+spec Apple do
+  # inheriting tests from FruitsTests spec
+  include FruitsTests
+
+  # defining own specs
+end
+```
+
+If you want a module that just holds tests without run them, use `nil` for label:
+
+
+```ruby
+FruitsTests = spec nil do
+  # tests defined here will run only on specs that includes FruitsTests
+end
+```
+
+## Global setups
+
+`spec` method can also be used for defining a superset of instructions that will be run by all specs.
+
+For this to work `spec` method should be called without arguments.<br>
+Then the given block will run equally on all consequent specs.<br>
+Multiple global setups can be defined and they will run inside specs in the order they was defined.
+
+```ruby
+# supposedly in setup.rb
+spec do
+  include SomeModule
+end
+
+# somewhere in test files
+spec Fruits do
+  # this spec will include SomeModule implicitly
+end
+```
+
+## Before, around, after
+
+Run some code before every test:
+
+```ruby
+spec 'Fruits' do
+  before { @fruit = Fruit.new }
+
+  # tests here will have @fruit variable defined
+end
+```
+
+When you need to run some code after every test simply use `after` method same way as `before`.
+
+There is also an `around` method that will wrap each test into a block.<br>
+The difference is you have to call test manually:
+
+```ruby
+spec 'Fruits' do
+  around do |test|
+    # initialization stuff
+    test.call
+    # teardown stuff
+  end
+
+  # tests here will run inside around block
+end
+```
+
+There is no way to run code before/around/after specific tests.<br>
+If you have tests that needs specific initialization/teardown logic put them into a separate `context`.
+
+
+## Skipping tests and specs
+
+When you need to skip a test simply use `skip` method with a reason provided as first argument:
+
+```ruby
+test 'something' do
+  # any code before skip will still run
+  skip 'will test this later'
+  # code here wont run
+end
+```
+
+`skip` also works for entire specs:
+
+```ruby
+spec Fruits do
+
+  skip 'concentrating on Vegetables for now...'
+
+  # tests here wont run
+end
+```
+
+## Explicit failures
+
+When you need to throw a failure with a custom message use `fail` method:
+
+```ruby
+test 'something' do
+  @a > @b || fail("#a should be greater than #b")
+  # code here wont run
+end
+```
+
+## `raise` helper
+
+`raise` allows to check whether some code raises a specific or any exception.
+
+Check the block raises whatever exception:
+
+```ruby
+assert {some code}.raise
+```
+
+Check the block raises a NameError exception:
+
+```ruby
+assert {some code}.raise NameError
+```
+
+Check the block raises a FruitError exception that match /apple/:
+
+```ruby
+assert {some code}.raise FruitError, /apple/
+```
+
+Use a block to check raised exception:
+
+```ruby
+assert {some code}.raise {|e| e.is_a? FruitError}
+```
+
+Also alternative syntax available:
+
+```ruby
+expect {some code}.to_raise ...
+```
+
+
+## `throw` helper
+
+Check the block throws whatever symbol:
+
+```ruby
+assert {some code}.throw
+```
+
+Check the block throws `:ok` symbol:
+
+```ruby
+assert {some code}.throw :ok
+```
+
+Use a block to validate thrown symbol:
+
+```ruby
+assert {some code}.throw {|s| s == :ok}
+```
+
+Also alternative syntax available:
+
+```ruby
+expect {some code}.to_throw ...
+```
+
+## Development
+
+Make sure `bundler` is installed then run `bundle install` to install all dependencies.
+
+Make your changes and run `rake` to check all tests pass.
+
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/tokyo/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,11 @@
+require 'rake'
+require 'rake/testtask'
+require 'bundler/gem_tasks'
+
+root = File.expand_path('..', __FILE__)
+Rake::TestTask.new do |t|
+  t.ruby_opts << '-r "%s/test/setup" -I "%s/lib"' % [root, root]
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+task default: :test

data/bin/tokyo

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+$:.unshift(File.expand_path('../../lib', __FILE__))
+require 'tokyo'
+Tokyo.run(*$*)

data/lib/tokyo/assert.rb

@@ -0,0 +1,148 @@
+module Tokyo
+  class Assert
+
+    def initialize object, action = :assert, caller = nil
+      @object = object
+      @caller = caller
+      @assert = action == :assert
+      @refute = action == :refute
+      @assert || @refute || Kernel.raise(ArgumentError, 'action should be either :assert or :refute')
+    end
+
+    instance_methods.each do |m|
+      # overriding all instance methods so received messages to be passed to tested object.
+      #
+      # @example
+      #   assert(x).frozen?
+      #   # `assert` returns a object that receives `frozen?` message and pass it to x
+      #
+      define_method m do |*a, &b|
+        __assert__(m, a, b)
+      end
+    end
+
+    # forward any missing method to tested object.
+    #
+    # @example
+    #   assert(some_array).include? x
+    #   # object returned by `assert` does not respond to `include?`
+    #   # so `include?` is passed to `some_array`
+    #
+    def method_missing m, *a, &b
+      __assert__(m, a, b)
+    end
+
+    # ensure the given block raises as expected
+    #
+    # @note if block given it will have precedence over arguments
+    #
+    # @example assertion pass if block raises whatever
+    #   assert {some code}.raise
+    #
+    # @example assertion pass if block raises NameError
+    #   assert {some code}.raise NameError
+    #
+    # @example assertion pass if block raises NameError and error message matches /blah/
+    #   assert {some code}.raise NameError, /blah/
+    #
+    # @example assertion pass if block raises whatever error that matches /blah/
+    #   assert {some code}.raise nil, /blah/
+    #
+    # @example assertion pass if validation block returns a positive value
+    #   assert {some code}.raise {|e| e.is_a?(NameError) && e.message =~ /blah/}
+    #
+    #
+    # @example assertion pass if nothing raised
+    #   refute {some code}.raise
+    #   # same
+    #   fail_if {some code}.raise
+    #
+    # @example assertion fails only if block raises a NameError.
+    #   it may raise whatever but NameError. if nothing raised assertion will fail.
+    #
+    #   fail_if {some code}.raise NameError
+    #
+    # @example assertion pass if raised error does not match /blah/
+    #   if nothing raised assertion will fail.
+    #
+    #   fail_if {some code}.raise nil, /blah/
+    #
+    # @example assertion will pass if raised error is not a NameError
+    #   and error message does not match /blah/
+    #   if nothing raised assertion will fail as well.
+    #
+    #   fail_if {some code}.raise NameError, /blah/
+    #
+    def raise type = nil, message = nil, &block
+      failure = Tokyo.__send__(
+        @assert ? :assert_raised_as_expected : :refute_raised_as_expected,
+        @object, type, message, block
+      )
+      Tokyo.fail(failure, caller[0]) if failure
+    end
+    alias to_raise raise
+
+    # ensure given block thrown as expected
+    #
+    # @note if block given it will have precedence over arguments
+    #
+    # @example assertion pass if any symbol thrown
+    #   assert {some code}.throw
+    #
+    # @example assertion pass only if :x symbol thrown
+    #   assert {some code}.throw(:x)
+    #
+    # @example assertion pass only if given block validates thrown symbol
+    #   assert {some code}.throw {|sym| sym == :x}
+    #
+    def throw expected_symbol = nil, &block
+      failure = Tokyo.__send__(
+        @assert ? :assert_thrown_as_expected : :refute_thrown_as_expected,
+        @object, expected_symbol ? expected_symbol.to_sym : nil, block
+      )
+      Tokyo.fail(failure, caller[0]) if failure
+    end
+    alias to_throw throw
+
+    # ensure given mock will receive expected message by the end of test
+    #
+    # @example
+    #   test :auth do
+    #     user = mock(User.new)
+    #     expect(user).to_receive(:password)
+    #     user.authenticate
+    #     # by the end of test user should receive :password message,
+    #     # otherwise the test will fail
+    #   end
+    #
+    # @param Symbol expected message
+    # @return [Expectation]
+    #
+    def receive expected_message
+      Kernel.throw(:__tokyo_status__, @object[:raised]) if @object[:raised]
+      @__expectation__ = Expectation.new(@object[:returned], expected_message.to_sym, @assert, caller[0])
+    end
+    alias to_receive receive
+
+    def __validate_expectations__
+      return unless @__expectation__
+      @__expectation__.validate
+    end
+
+    private
+    def __assert__ message, arguments, block
+      Tokyo.total_assertions << true
+      Kernel.throw(:__tokyo_status__, @object[:raised]) if @object[:raised]
+      result = __send_message__(@object[:returned], message, arguments, block)
+      return true if (@assert && result) || (@refute && !result)
+      Kernel.throw(:__tokyo_status__, AssertionFailure.new(@object[:returned], arguments, @caller))
+    end
+
+    def __send_message__ object, message, arguments, block
+      if assertion = Tokyo.assertions[message.to_sym]
+        return assertion.call(object, *arguments, &block)
+      end
+      object.__send__(message, *arguments, &block)
+    end
+  end
+end

data/lib/tokyo/core_ext.rb

@@ -0,0 +1,103 @@
+module Kernel
+
+  # when called with a no-nil no-false argument it defines, register and returns a spec.
+  # when called with a nil or false argument it defines and returns a spec but does not register it.
+  # when called without arguments it defines a global setup that will run on each new created spec/context.
+  #
+  # @note a Unit Module is a regular Ruby Module that when included will execute the Unit's block on base
+  #
+  # @example define regular specs
+  #   spec :some_spec do
+  #     # ...
+  #   end
+  #
+  # @example define a spec that will run on its own and can also be included into another specs/contexts
+  #   shared = spec :some_shared_spec do
+  #     # ...
+  #   end
+  #   # `shared` is now a spec good for inclusion in another specs/contexts.
+  #
+  # @example define a spec that wont run on itself but can be included into another specs/contexts
+  #   Shared = spec nil do
+  #     # ...
+  #   end
+  #   # `Shared` is now a module good for inclusion in another specs/contexts
+  #   # but because `nil` used as first argument it wont run as a spec itself
+  #
+  # @example define a global setup, i.e. a block that will run inside any new defined spec/context
+  #   spec do
+  #     include Rack::Test # now Rack::Test will be included in any spec/context
+  #   end
+  #
+  def spec label = (noargs=true; nil), &block
+    block || raise(ArgumentError, 'missing block')
+
+    if noargs
+      # no arguments given, defining a global setup and returning
+      Tokyo::GLOBAL_SETUPS.include?(block) || Tokyo::GLOBAL_SETUPS.push(block)
+      return
+    end
+
+    if label
+      # a no-nil no-false argument given, defining a regular spec
+      Tokyo.define_and_register_a_spec(label, block)
+    end
+
+    # defining a shared spec that wont run itself
+    # but can be included in another specs/contexts
+    Tokyo.define_unit_module(block)
+  end
+
+  # when used out of tests it defines a assertion helper.
+  # the block should return a no-false no-nil value for assertion to pass.
+  # the block will receive tested object as first argument
+  # and any arguments passed to assertion as consequent ones.
+  # it will also receive the passed block.
+  #
+  # @example checks whether two arrays has same keys, orderlessly
+  #   assert :has_same_keys_as do |a, b|
+  #     a.keys.sort == b.keys.sort
+  #   end
+  #
+  #   spec :some_spec do
+  #     test :some_test do
+  #       a = [1, 2]
+  #       b = [2, 1]
+  #       assert(a).has_same_keys_as(b) # => true
+  #     end
+  #   end
+  #
+  # @example same assertion by multiple names
+  #   assert :includes, :to_include do |a, b|
+  #     a.keys.sort == b.keys.sort
+  #   end
+  #
+  #   spec :some_spec do
+  #     test :some_test do
+  #       a = [1, 2]
+  #       assert(a).includes(1) # => true
+  #       # same
+  #       expect(a).to_include(1) # => true
+  #     end
+  #   end
+  #
+  # @param [Array] *labels
+  #
+  def assert *labels, &block
+    labels.any? || raise(ArgumentError, 'Wrong number of arguments, 0 for 1+')
+    block || raise(ArgumentError, 'missing block')
+    labels.each {|label| Tokyo.assertions[label.to_sym] = block}
+  end
+
+  # stop executing any code and report a failure
+  #
+  # @example
+  #   x > y || fail('x should be greater than y')
+  #
+  # @param reason
+  #
+  def fail *reason
+    reason.empty? && raise(ArgumentError, 'Wrong number or arguments, 0 for 1+')
+    Tokyo.fail(reason.flatten, caller[0])
+  end
+end

data/lib/tokyo/expectations/raise.rb

@@ -0,0 +1,32 @@
+module Tokyo
+  class Expectation
+
+    # ensure received message raises as expected
+    #
+    # @note if block given it will have precedence over arguments
+    #
+    # @example
+    #   x = mock(X.new)
+    #   expect(x).to_receive(:y).and_raise(NoMethodError)
+    #   # call `x.y` for test to pass
+    #
+    def and_raise type = nil, message = nil, &block
+      @raise = block || [type, message]
+    end
+
+    def assert_message_raised_as_expected
+      return unless @raise
+      if @raise.is_a?(Proc)
+        received_messages.find {|log| @raise.call(log[:raised])} || Tokyo.fail([
+          'Looks like :%s message never raised as expected' % expected_message,
+          'See validation block'
+        ], @caller)
+      else
+        received_messages.each do |log|
+          next unless f = Tokyo.assert_raised_as_expected(log, *@raise)
+          Tokyo.fail(f, log[:caller])
+        end
+      end
+    end
+  end
+end