tokyo 0.0.5

data/test/receive_test.rb

@@ -0,0 +1,71 @@
+describe :receive do
+
+  it 'should pass when a message expected and received' do
+    this = self
+    spec rand do
+      test :test do
+        expect(x = 'x').to_receive(:class)
+        x.class
+      end
+      this.assert_equal :__tokyo_passed__, run(:test)
+    end
+  end
+
+  it 'should fail when a expected message not received' do
+    this = self
+    spec rand do
+      test :test do
+        expect(x = 'x').to_receive(:class)
+      end
+      this.assert_equal Tokyo::GenericFailure, run(:test).class
+    end
+  end
+
+  it 'should pass when no message expected and no message received' do
+    this = self
+    spec rand do
+      test :test do
+        fail_if(x = 'x').receive(:class)
+      end
+      this.assert_equal :__tokyo_passed__, run(:test)
+    end
+  end
+
+  it 'should fail when unexpected message received' do
+    this = self
+    spec rand do
+      test :test do
+        fail_if(x = 'x').receive(:class)
+        x.class
+      end
+      this.assert_equal Tokyo::GenericFailure, run(:test).class
+    end
+  end
+
+  describe 'missing methods' do
+
+    it 'should call method_missing if defined' do
+      this = self
+      x = Class.new {def self.method_missing(m); 'x' + m.to_s; end}
+      spec rand do
+        test :test do
+          assert(x).receive(:y)
+          x.y
+        end
+        this.assert_equal 'xy', x.y
+        this.assert_equal :__tokyo_passed__, run(:test)
+      end
+    end
+
+    it 'should raise NoMethodError if no method_missing defined' do
+      this = self
+      spec rand do
+        test :test do
+          assert(x = 'x').receive(:y).and_raise(NoMethodError)
+          x.y
+        end
+        this.assert_equal :__tokyo_passed__, run(:test)
+      end
+    end
+  end
+end

data/test/receive_with_test.rb

@@ -0,0 +1,57 @@
+describe :receive_with do
+
+  it 'should pass when called with correct arguments' do
+    this = self
+    spec rand do
+      test :test do
+        expect(x = 'x').to_receive(:+).with('y')
+        x + 'y'
+      end
+      this.assert_equal :__tokyo_passed__, run(:test)
+    end
+  end
+
+  it 'should fail when called without arguments' do
+    this = self
+    spec rand do
+      test :test do
+        expect(x = []).to_receive(:join).with('')
+        x.join
+      end
+      this.assert_match /Looks like :join message never was called with expected arguments/, run(:test).reason*' '
+    end
+  end
+
+  it 'should fail when called with wrong arguments' do
+    this = self
+    spec rand do
+      test :test do
+        expect(x = []).to_receive(:join).with('')
+        x.join('/')
+      end
+      this.assert_match /Looks like :join message never was called with expected arguments/, run(:test).reason*' '
+    end
+  end
+
+  it 'should pass when block validates arguments' do
+    this = self
+    spec rand do
+      test :test do
+        expect(x = 'x').to_receive(:+).with {|a| a == ['y']}
+        x + 'y'
+      end
+      this.assert_equal :__tokyo_passed__, run(:test)
+    end
+  end
+
+  it 'should fail when block does not validate arguments' do
+    this = self
+    spec rand do
+      test :test do
+        expect(x = 'x').to_receive(:+).with {false}
+        x + 'y'
+      end
+      this.assert_match /Looks like :\+ message never was called with expected arguments/, run(:test).reason*' '
+    end
+  end
+end

data/test/refute_raise_test.rb

@@ -0,0 +1,90 @@
+describe :refute_raise do
+
+  it 'should pass if no exception expected and no exception raised' do
+    this = self
+    spec rand do
+      test(:test) {refute {}.raise}
+      this.assert_equal :__tokyo_passed__, run(:test)
+    end
+  end
+
+  it 'should fail if exception raised when not expected' do
+    this = self
+    spec rand do
+      test(:test) {refute {x}.raise}
+      this.assert_equal Tokyo::GenericFailure, run(:test).class
+    end
+  end
+
+  it 'should fail if exception of specific type negated but nothing raised' do
+    this = self
+    spec rand do
+      test(:test) {refute {}.raise NameError}
+      this.assert_equal Tokyo::GenericFailure, run(:test).class
+    end
+  end
+
+  it 'should fail if exception with specific message negated but nothing raised' do
+    this = self
+    spec rand do
+      test(:test) {refute {}.raise nil, /blah/}
+      this.assert_equal Tokyo::GenericFailure, run(:test).class
+    end
+  end
+
+  it 'should pass if it raises a exception type different from negated one' do
+    this = self
+    spec rand do
+      test(:test) {refute {x}.raise(ArgumentError)}
+      this.assert_equal :__tokyo_passed__, run(:test)
+    end
+  end
+
+  it 'should fail if it raises a exception of same type as negated one' do
+    this = self
+    spec rand do
+      test(:test) {refute {x}.raise NameError}
+      this.assert_equal Tokyo::GenericFailure, run(:test).class
+    end
+  end
+
+  it 'should pass if it raises a exception with a message different from negated one' do
+    this = self
+    spec rand do
+      test(:test) {refute {x}.raise nil, /blah/}
+      this.assert_equal :__tokyo_passed__, run(:test)
+    end
+  end
+
+  it 'should fail if it raises a exception with a message matching negated one' do
+    this = self
+    spec rand do
+      test(:test) {refute {x}.raise nil, /undefined local variable/}
+      this.assert_equal Tokyo::GenericFailure, run(:test).class
+    end
+  end
+
+  it 'should pass if raised type is not of negated type and error message does not match negated message' do
+    this = self
+    spec rand do
+      test(:test) {refute {x}.raise ArgumentError, /blah/}
+      this.assert_equal :__tokyo_passed__, run(:test)
+    end
+  end
+
+  it 'should fail if raised type is of negated type' do
+    this = self
+    spec rand do
+      test(:test) {refute {x}.raise NameError, /blah/}
+      this.assert_equal Tokyo::GenericFailure, run(:test).class
+    end
+  end
+
+  it 'should fail if error message matches negated one' do
+    this = self
+    spec rand do
+      test(:test) {refute {x}.raise ArgumentError, /undefined local variable/}
+      this.assert_equal Tokyo::GenericFailure, run(:test).class
+    end
+  end
+end

data/test/refute_throw_test.rb

@@ -0,0 +1,42 @@
+describe :refute_throw do
+
+  it 'should pass when nothing thrown' do
+    this = self
+    spec rand do
+      test(:test) {refute {}.throw}
+      this.assert_equal :__tokyo_passed__, run(:test)
+    end
+  end
+
+  it 'should fail when something thrown' do
+    this = self
+    spec rand do
+      test(:test) {refute {throw :x}.throw}
+      this.assert_equal Tokyo::GenericFailure, run(:test).class
+    end
+  end
+
+  it 'should pass when thrown symbol does not match negated one' do
+    this = self
+    spec rand do
+      test(:test) {refute {throw :x}.throw(:y)}
+      this.assert_equal :__tokyo_passed__, run(:test)
+    end
+  end
+
+  it 'should fail when thrown symbol does match negated one' do
+    this = self
+    spec rand do
+      test(:test) {refute {throw :x}.throw(:x)}
+      this.assert_equal Tokyo::GenericFailure, run(:test).class
+    end
+  end
+
+  it 'should fail when a negated symbol given and nothing thrown' do
+    this = self
+    spec rand do
+      test(:test) {refute {}.throw(:x)}
+      this.assert_equal Tokyo::GenericFailure, run(:test).class
+    end
+  end
+end

data/test/setup.rb

@@ -0,0 +1,25 @@
+require 'json'
+require 'minitest/autorun'
+require 'tokyo'
+
+module Minitest
+  class Mock
+    def respond_to?(sym, include_private = false)
+      retval = __respond_to?(sym, include_private)
+      if @expected_calls.key?(:respond_to?)
+        @actual_calls[:respond_to?] << {retval: retval, args: [sym, include_private]}
+      end
+      retval
+    end
+  end
+end
+
+def proxy obj
+  Tokyo::Assert.new(returned: obj)
+end
+
+def mock meth, *args, &block
+  m = Minitest::Mock.new
+  m.expect(meth, true, args, &block)
+  proxy(m)
+end

data/test/skip_test.rb

@@ -0,0 +1,35 @@
+describe :skip do
+
+  it 'should skip inside spec' do
+    r, w = IO.pipe
+    fork do
+      r.close
+      s = Tokyo.define_spec :skip_spec, proc {
+        test(:a) {}
+        skip
+        test(:b) {}
+      }
+      w.print({skips: Tokyo.skips.size, tests: s.tests.size}.to_json)
+    end
+    w.close
+    data = JSON.parse(r.read)
+    assert_equal 1, data['skips']
+    assert_equal 1, data['tests']
+  end
+
+  it 'should skip inside test' do
+    r, w = IO.pipe
+    fork do
+      r.close
+      Tokyo.define_and_register_a_spec :skip_test, proc {
+        test :x do
+          skip
+          w.print 'bad'
+        end
+      }
+      Tokyo.run
+    end
+    w.close
+    assert_equal '', r.read
+  end
+end

data/test/throw_test.rb

@@ -0,0 +1,58 @@
+describe :throw do
+
+  it 'should pass when any symbol expected and something thrown' do
+    this = self
+    spec rand do
+      test(:test) {assert {throw :x}.throw}
+      this.assert_equal :__tokyo_passed__, run(:test)
+    end
+  end
+
+  it 'should pass when specific symbol expected and thrown' do
+    this = self
+    spec rand do
+      test(:test) {assert {throw :x}.throw(:x)}
+      this.assert_equal :__tokyo_passed__, run(:test)
+    end
+  end
+
+  it 'should fail when any throw expected but nothing thrown' do
+    this = self
+    spec rand do
+      test(:test) {assert {}.throw}
+      this.assert_equal Tokyo::GenericFailure, run(:test).class
+    end
+  end
+
+  it 'should fail when specific symbol expected but nothing thrown' do
+    this = self
+    spec rand do
+      test(:test) {assert {}.throw(:x)}
+      this.assert_equal Tokyo::GenericFailure, run(:test).class
+    end
+  end
+
+  it 'should fail when wrong symbol thrown' do
+    this = self
+    spec rand do
+      test(:test) {assert {throw :y}.throw(:x)}
+      this.assert_equal Tokyo::GenericFailure, run(:test).class
+    end
+  end
+
+  it 'should pass when given block validates thrown symbol' do
+    this = self
+    spec rand do
+      test(:test) {assert {throw :x}.throw {|s| s == :x}}
+      this.assert_equal :__tokyo_passed__, run(:test)
+    end
+  end
+
+  it 'should fail when given block invalidates thrown symbol' do
+    this = self
+    spec rand do
+      test(:test) {assert {}.throw {false}}
+      this.assert_equal Tokyo::GenericFailure, run(:test).class
+    end
+  end
+end

data/tokyo.gemspec

@@ -0,0 +1,27 @@
+Gem::Specification.new do |spec|
+  spec.name        = 'tokyo'
+  spec.version     = '0.0.5'
+  spec.authors     = ['Slee Woo']
+  spec.email       = ['mail@sleewoo.com']
+  spec.description = 'Super-simple testing library for Ruby'
+  spec.summary     = [spec.name, spec.version]*'-'
+  spec.homepage    = 'https://github.com/sleewoo/' + spec.name
+  spec.license     = 'MIT'
+
+  spec.files = Dir['**/{*,.[a-z]*}'].reject {|e| e =~ /\.(gem|lock|html)\Z/}
+  spec.require_paths = ['lib']
+
+  spec.executables = Dir['bin/*'].map { |f| File.basename(f)}
+
+  spec.required_ruby_version = '>= 2'
+
+  spec.add_runtime_dependency 'tty-progressbar', '~> 0.5'
+  spec.add_runtime_dependency 'tty-screen',      '~> 0.1'
+  spec.add_runtime_dependency 'pastel',          '~> 0.4'
+  spec.add_runtime_dependency 'coderay',         '~> 1'
+  spec.add_runtime_dependency 'json',            '~> 1.8'
+
+  spec.add_development_dependency 'minitest', '~> 5.5'
+  spec.add_development_dependency 'bundler',  '~> 1.8'
+  spec.add_development_dependency 'rake',     '~> 10.4'
+end

metadata

@@ -0,0 +1,195 @@
+--- !ruby/object:Gem::Specification
+name: tokyo
+version: !ruby/object:Gem::Version
+  version: 0.0.5
+platform: ruby
+authors:
+- Slee Woo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-10-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: tty-progressbar
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: tty-screen
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: pastel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+- !ruby/object:Gem::Dependency
+  name: coderay
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.5'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.4'
+description: Super-simple testing library for Ruby
+email:
+- mail@sleewoo.com
+executables:
+- tokyo
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/tokyo
+- lib/tokyo.rb
+- lib/tokyo/assert.rb
+- lib/tokyo/core_ext.rb
+- lib/tokyo/expectations.rb
+- lib/tokyo/expectations/raise.rb
+- lib/tokyo/expectations/return.rb
+- lib/tokyo/expectations/throw.rb
+- lib/tokyo/expectations/with.rb
+- lib/tokyo/pretty_print.rb
+- lib/tokyo/run.rb
+- lib/tokyo/unit.rb
+- lib/tokyo/util.rb
+- lib/tokyo/util/assert_raise.rb
+- lib/tokyo/util/assert_throw.rb
+- lib/tokyo/util/refute_raise.rb
+- lib/tokyo/util/refute_throw.rb
+- test/assert_test.rb
+- test/context_inheritance_test.rb
+- test/hooks_test.rb
+- test/raise_test.rb
+- test/receive_and_raise_test.rb
+- test/receive_and_return_test.rb
+- test/receive_and_throw_test.rb
+- test/receive_test.rb
+- test/receive_with_test.rb
+- test/refute_raise_test.rb
+- test/refute_throw_test.rb
+- test/setup.rb
+- test/skip_test.rb
+- test/throw_test.rb
+- tokyo.gemspec
+homepage: https://github.com/sleewoo/tokyo
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: tokyo-0.0.5
+test_files: []