mirror of
https://github.com/lloeki/uspec-js.git
synced 2025-12-06 10:34:40 +01:00
111 lines
3.4 KiB
CoffeeScript
111 lines
3.4 KiB
CoffeeScript
minispec = require('./uspec')
|
|
|
|
describe = minispec.describe
|
|
assert = minispec.assert
|
|
assert_throws = minispec.assert_throws
|
|
pending = minispec.pending
|
|
run = minispec.run
|
|
summary = minispec.summary
|
|
|
|
|
|
describe 'AssertionError',
|
|
'should be exported': ->
|
|
assert -> typeof minispec.AssertionError isnt 'undefined'
|
|
'should take a message': ->
|
|
assert -> (new minispec.AssertionError 'foo').message == 'foo'
|
|
'should render as an error string': ->
|
|
str = (new minispec.AssertionError 'foo').toString()
|
|
assert -> str == "AssertionError: foo"
|
|
|
|
|
|
describe 'PendingError',
|
|
'should be exported': ->
|
|
assert -> typeof minispec.PendingError isnt 'undefined'
|
|
'should take a message': ->
|
|
assert -> (new minispec.PendingError 'foo').message == 'foo'
|
|
'should render as an error string': ->
|
|
str = (new minispec.PendingError 'foo').toString()
|
|
assert -> str == "PendingError: foo"
|
|
|
|
|
|
describe 'pending',
|
|
'should be exported': ->
|
|
assert -> typeof minispec.pending isnt 'undefined'
|
|
|
|
'should throw a PendingError containing a blank message': ->
|
|
try
|
|
pending()
|
|
catch e
|
|
assert -> e instanceof minispec.PendingError
|
|
assert -> e.message == ''
|
|
|
|
'should throw a PendingError containing a message': ->
|
|
try
|
|
pending('foo')
|
|
catch e
|
|
assert -> e instanceof minispec.PendingError
|
|
assert -> e.message == 'foo'
|
|
|
|
|
|
describe 'assert',
|
|
'should be exported': ->
|
|
assert -> typeof minispec.assert isnt 'undefined'
|
|
|
|
'should pass without throwing when assertion returns true': ->
|
|
do ->
|
|
minispec.assert -> true
|
|
|
|
'should throw AssertionError when assertion does not return true': ->
|
|
try
|
|
minispec.assert -> false
|
|
catch e
|
|
unless e instanceof minispec.AssertionError
|
|
throw new AssertionError
|
|
|
|
'should rethrow exception when assertion throws an exception': ->
|
|
try
|
|
minispec.assert -> throw new Error 'foo'
|
|
catch e
|
|
unless e instanceof Error
|
|
throw new AssertionError
|
|
unless e.message == 'foo'
|
|
throw new AssertionError
|
|
|
|
|
|
describe 'assert_throws',
|
|
'should be exported': ->
|
|
assert -> typeof minispec.assert_throws isnt 'undefined'
|
|
|
|
'should pass when block throws the expected exception': ->
|
|
class FooError
|
|
do ->
|
|
minispec.assert_throws FooError, -> throw new FooError
|
|
|
|
'should throw AssertionError when block does not throw any exception': ->
|
|
class FooError
|
|
try
|
|
minispec.assert_throws FooError, -> 42
|
|
catch e
|
|
assert -> e instanceof minispec.AssertionError
|
|
|
|
'should rethrow exception when block throws an unexpected exception': ->
|
|
class FooError
|
|
class BarError
|
|
try
|
|
minispec.assert_throws FooError, -> throw new BarError
|
|
catch e
|
|
assert -> e instanceof BarError
|
|
|
|
describe 'describe',
|
|
'should be exported': ->
|
|
assert -> typeof minispec.describe isnt 'undefined'
|
|
|
|
describe 'run',
|
|
'should be exported': ->
|
|
assert -> typeof minispec.run isnt 'undefined'
|
|
|
|
results = run()
|
|
rc = if summary(results) then 0 else 1
|
|
|
|
phantom.exit(rc) unless typeof phantom is 'undefined'
|
|
process.exit(rc) unless typeof process is 'undefined'
|