tiramisu 0.0.0 → 0.0.1

data/test/raise_test.rb

@@ -0,0 +1,66 @@
+describe :raise do
+
+  it 'should pass if any exception raised' do
+    this = self
+    spec rand do
+      test(:test) {assert {x}.raise}
+      this.assert_equal :__tiramisu_passed__, run(:test)
+    end
+  end
+
+  it 'should fail if nothing raised' do
+    this = self
+    spec rand do
+      test(:test) {assert {}.raise}
+      this.assert_equal Tiramisu::GenericFailure, run(:test).class
+    end
+  end
+
+  it 'should pass if type matching' do
+    this = self
+    spec rand do
+      test(:test) {assert {x}.raise(NameError)}
+      this.assert_equal :__tiramisu_passed__, run(:test)
+    end
+  end
+
+  it 'should fail if wrong exception raised' do
+    this = self
+    spec rand do
+      test(:test) {assert {}.raise(ArgumentError)}
+      this.assert_equal Tiramisu::GenericFailure, run(:test).class
+    end
+  end
+
+  it 'should pass if both type and message matches' do
+    this = self
+    spec rand do
+      test(:test) {assert {x}.raise NameError, /undefined local variable or method/}
+      this.assert_equal :__tiramisu_passed__, run(:test)
+    end
+  end
+
+  it 'should fail if message does not match' do
+    this = self
+    spec rand do
+      test(:test) {assert {x}.raise(NameError, /blah/)}
+      this.assert_equal Tiramisu::GenericFailure, run(:test).class
+    end
+  end
+
+  it 'should pass if given block validates the raised error' do
+    this = self
+    spec rand do
+      test(:test) {assert {x}.raise {|e| e.class == NameError && e.message =~ /undefined local variable or method/}}
+      this.assert_equal :__tiramisu_passed__, run(:test)
+    end
+  end
+
+  it 'should fail if given block invalidates raised error' do
+    this = self
+    spec rand do
+      test(:test) {assert {x}.raise {false}}
+      this.assert_equal Tiramisu::GenericFailure, run(:test).class
+    end
+  end
+end

data/test/receive_and_raise_test.rb

@@ -0,0 +1,91 @@
+describe :receive_and_raise do
+
+  it 'should pass when received message raises as expected' do
+    this = self
+    spec rand do
+      test :test do
+        x = mock(:x)
+        expect(x).to_receive(:y).and_raise(NoMethodError)
+        x.y
+      end
+      this.assert_equal :__tiramisu_passed__, run(:test)
+    end
+  end
+
+  it 'should pass when received message raises whatever error' do
+    this = self
+    spec rand do
+      test :test do
+        x = mock(:x)
+        expect(x).to_receive(:y).and_raise
+        x.y
+      end
+      this.assert_equal :__tiramisu_passed__, run(:test)
+    end
+  end
+
+  it 'should fail when received message does not raise' do
+    this = self
+    spec rand do
+      test :test do
+        x = mock(:x)
+        expect(x).to_receive(:to_s).and_raise
+        x.to_s
+      end
+      this.assert_match /Expected a exception to be raised/, run(:test).reason*' '
+    end
+  end
+
+  it 'should fail when received message raises a unexpected error type' do
+    this = self
+    spec rand do
+      test :test do
+        x = mock(:x)
+        expect(x).to_receive(:y).and_raise(NameError)
+        x.y
+      end
+      this.assert_match /Expected a NameError to be raised/, run(:test).reason*' '
+    end
+  end
+
+  it 'should fail when error raised by received message is of expected type but error message does not match' do
+    this = self
+    spec rand do
+      test :test do
+        x = mock(:x)
+        expect(x).to_receive(:y).and_raise(NoMethodError, /blah/)
+        x.y
+      end
+      this.assert_match /to match "blah"/, run(:test).reason*' '
+    end
+  end
+
+  it 'should pass if received message raises a error that match by type and message' do
+    this = self
+    spec rand do
+      test :test do
+        x = mock(:x)
+        expect(x).to_receive(:y).and_raise(NoMethodError, /undefined method `y' for :x:Symbol/)
+        x.y
+      end
+      this.assert_equal :__tiramisu_passed__, run(:test)
+    end
+  end
+
+  it 'should pass if error raised by received message are validated by block' do
+    this, t, m = self, nil, nil
+    spec rand do
+      test :test do
+        x = mock(:x)
+        expect(x).to_receive(:y).and_raise {|e|
+          t, m = e.class, e.message
+          this.assert_match /undefined method .y. for :x:Symbol/, e.message
+        }
+        x.y
+      end
+      run(:test)
+      this.assert_equal NoMethodError, t
+      this.assert_match /undefined method .y. for :x:Symbol/, m
+    end
+  end
+end

data/test/receive_and_return_test.rb

@@ -0,0 +1,74 @@
+describe :receive_and_return do
+
+  it 'should pass when expected message returns expected value' do
+    this = self
+    spec rand do
+      test :test do
+        x = mock(1)
+        expect(x).to_receive(:+).with(1).and_return(2)
+        x + 1
+      end
+      this.assert_equal :__tiramisu_passed__, run(:test)
+    end
+  end
+
+  it 'should fail when expected message returns wrong value' do
+    this = self
+    spec rand do
+      test :test do
+        x = mock(:x)
+        expect(x).to_receive(:to_s).and_return(:y)
+        x.to_s
+      end
+      this.assert_match /Looks like :to_s message never returned expected value/, run(:test).reason*' '
+    end
+  end
+
+  it 'should pass when block validates returned value' do
+    this = self
+    spec rand do
+      test :test do
+        x = mock(1)
+        expect(x).to_receive(:+).with(1).and_return {|v| v == 2}
+        x + 1
+      end
+      this.assert_equal :__tiramisu_passed__, run(:test)
+    end
+  end
+
+  it 'should fail when block does not validate returned value' do
+    this = self
+    spec rand do
+      test :test do
+        x = mock(1)
+        expect(x).to_receive(:+).with(1).and_return {false}
+        x + 1
+      end
+      this.assert_match /Looks like :\+ message never returned expected value/, run(:test).reason*' '
+    end
+  end
+
+  it 'should pass when block validates all returned value' do
+    this = self
+    spec rand do
+      test :test do
+        x = mock(1)
+        expect(x).to_receive(:+).with(1).and_return {|v| v == 2}
+        x + 1
+      end
+      this.assert_equal :__tiramisu_passed__, run(:test)
+    end
+  end
+
+  it 'should fail when block does not validate returned value' do
+    this = self
+    spec rand do
+      test :test do
+        x = mock(1)
+        expect(x).to_receive(:+).with(1).and_return {false}
+        x + 1
+      end
+      this.assert_match /Looks like :\+ message never returned expected value/, run(:test).reason*' '
+    end
+  end
+end

data/test/receive_and_throw_test.rb

@@ -0,0 +1,74 @@
+describe :receive_and_throw do
+
+  it 'should pass when received message throws whatever' do
+    this = self
+    spec rand do
+      test :test do
+        x = mock(Class.new {define_singleton_method(:y) {throw :z}})
+        expect(x).to_receive(:y).and_throw
+        x.y
+      end
+      this.assert_equal :__tiramisu_passed__, run(:test)
+    end
+  end
+
+  it 'should pass when received message throws expected symbol' do
+    this = self
+    spec rand do
+      test :test do
+        x = mock(Class.new {define_singleton_method(:y) {throw :z}})
+        expect(x).to_receive(:y).and_throw(:z)
+        x.y
+      end
+      this.assert_equal :__tiramisu_passed__, run(:test)
+    end
+  end
+
+  it 'should fail when received message throws nothing' do
+    this = self
+    spec rand do
+      test :test do
+        x = mock(Class.new {define_singleton_method(:y) {}})
+        expect(x).to_receive(:y).and_throw
+        x.y
+      end
+      this.assert_match /Expected a symbol to be thrown/, run(:test).reason*' '
+    end
+  end
+
+  it 'should fail when received message throws wrong symbol' do
+    this = self
+    spec rand do
+      test :test do
+        x = mock(Class.new {define_singleton_method(:y) {throw :z}})
+        expect(x).to_receive(:y).and_throw(:a)
+        x.y
+      end
+      this.assert_match /Expected :a to be thrown/, run(:test).reason*' '
+    end
+  end
+
+  it 'should pass when given block validates thrown symbol' do
+    this = self
+    spec rand do
+      test :test do
+        x = mock(Class.new {define_singleton_method(:y) {throw :z}})
+        expect(x).to_receive(:y).and_throw {|s| s == :z}
+        x.y
+      end
+      this.assert_equal :__tiramisu_passed__, run(:test)
+    end
+  end
+
+  it 'should fail when block does not validate thrown symbol' do
+    this = self
+    spec rand do
+      test :test do
+        x = mock(Class.new {define_singleton_method(:y) {throw :z}})
+        expect(x).to_receive(:y).and_throw {false}
+        x.y
+      end
+      this.assert_match /Looks like wrong or no symbol thrown/, run(:test).reason*' '
+    end
+  end
+end

data/test/receive_test.rb

@@ -0,0 +1,48 @@
+describe :receive do
+
+  it 'should pass when a message expected and received' do
+    this = self
+    spec rand do
+      test :test do
+        x = mock(:x)
+        expect(x).to_receive(:class)
+        x.class
+      end
+      this.assert_equal :__tiramisu_passed__, run(:test)
+    end
+  end
+
+  it 'should fail when a expected message not received' do
+    this = self
+    spec rand do
+      test :test do
+        x = mock(:x)
+        expect(x).to_receive(:class)
+      end
+      this.assert_equal Tiramisu::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
+        x = mock(:x)
+        fail_if(x).receive(:class)
+      end
+      this.assert_equal :__tiramisu_passed__, run(:test)
+    end
+  end
+
+  it 'should fail when unexpected message received' do
+    this = self
+    spec rand do
+      test :test do
+        x = mock(:x)
+        fail_if(x).receive(:class)
+        x.class
+      end
+      this.assert_equal Tiramisu::GenericFailure, run(:test).class
+    end
+  end
+end

data/test/receive_with_test.rb

@@ -0,0 +1,62 @@
+describe :receive_with do
+
+  it 'should pass when called with correct arguments' do
+    this = self
+    spec rand do
+      test :test do
+        x = mock(1)
+        expect(x).to_receive(:+).with(1)
+        x + 1
+      end
+      this.assert_equal :__tiramisu_passed__, run(:test)
+    end
+  end
+
+  it 'should fail when called without arguments' do
+    this = self
+    spec rand do
+      test :test do
+        x = mock([])
+        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
+        x = mock([])
+        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
+        x = mock(1)
+        expect(x).to_receive(:+).with {|a| a == [1]}
+        x + 1
+      end
+      this.assert_equal :__tiramisu_passed__, run(:test)
+    end
+  end
+
+  it 'should fail when block does not validate arguments' do
+    this = self
+    spec rand do
+      test :test do
+        x = mock(1)
+        expect(x).to_receive(:+).with {false}
+        x + 1
+      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 :__tiramisu_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 Tiramisu::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 Tiramisu::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 Tiramisu::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 :__tiramisu_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 Tiramisu::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 :__tiramisu_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 Tiramisu::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 :__tiramisu_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 Tiramisu::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 Tiramisu::GenericFailure, run(:test).class
+    end
+  end
+end