uspec.js: first public release

uspec_spec.coffee

@@ -0,0 +1,111 @@
+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'