public OverloadSpec() { Describe("Method with overloads", () => { It("should have all overloads covered by the one spy.", () => { var spy = Jaz.SpyOn(typeof(TestSubject), nameof(TestSubject.PositiveOne)).And.ReturnValues(3, 2, 1); Expect(TestSubject.PositiveOne()).ToBe(3); Expect(TestSubject.PositiveOne(0)).ToBe(2); Expect(TestSubject.PositiveOne(0)).ToBe(1); }); It("should record calls to both overloads.", () => { var spy = Jaz.SpyOn(typeof(TestSubject), nameof(TestSubject.Write)); TestSubject.Write(1, 2, 3); TestSubject.Write(3); TestSubject.Write(2, 3); Expect(spy).ToHaveBeenCalledWith(2, 3); Expect(spy).ToHaveBeenCalledWith(3); Expect(spy).ToHaveBeenCalledWith(1, 2, 3); }); }); }
public AdderSpec() { Describe <Adder>(() => { It("can add a positive number to a negative number", () => { var adder = new Adder(); Expect(adder.Add(-1, 1)).ToEqual(0M); }); }); Describe <Adder>(() => { List <decimal[]> specs = new List <decimal[]> { // n1, n2, expected new[] { -7M, 3M, -4M }, new[] { 0M, 0M, 0M }, new[] { 999999999M, 1M, 1000000000M } }; foreach (var spec in specs) { It($"can add 2 numbers ({spec[0]}, {spec[1]})", () => { var adder = new Adder(); Expect(adder.Add(spec[0], spec[1])).ToEqual(spec[2]); }); } }); Describe <Adder>(() => { It("appends to history", () => { OperationHistory history = new OperationHistory(); Spy historySpy = Jaz.SpyOn(history, nameof(history.Append)); var adder = new Adder(history); adder.Add(-1, 1); Expect(historySpy).ToHaveBeenCalled(); }); }); Describe <Adder>(() => { Describe(nameof(Adder.Add), () => { It("can add a positive number to a negative number", () => { var adder = new Adder(); Expect(adder.Add(-1, 1)).ToEqual(0M); }); }); }); }
public ExternSpec() { Describe("Extern methods", () => { It("should call through by default.", () => { Expect(GetInt()).ToBe(50); }); It("should do nothing if spied on.", () => { Jaz.SpyOn(typeof(ExternSpec), nameof(GetInt)); Expect(GetInt()).ToBeDefault(); }); It("should return the configured value.", () => { Jaz.SpyOn(typeof(ExternSpec), nameof(GetInt)).And.ReturnValue(1); var result = GetInt(); Expect(result).ToBe(1); }); It("should return the configured values in sequence.", () => { Jaz.SpyOn(typeof(ExternSpec), nameof(GetInt)).And.ReturnValues(1, 2, 3, 4); var result = GetInt(); Expect(result).ToBe(1); result = GetInt(); Expect(result).ToBe(2); result = GetInt(); Expect(result).ToBe(3); result = GetInt(); Expect(result).ToBe(4); }); It("should call through as configured.", () => { Jaz.SpyOn(typeof(ExternSpec), nameof(GetInt)).And.CallThrough(); var result = GetInt(); Expect(result).ToBe(50); }); It("should throw an exception as configured.", () => { var exception = new TestException(); Jaz.SpyOn(typeof(ExternSpec), nameof(GetInt)).And.Throw(exception); var thrown = Expect(() => GetInt()).ToThrow <TestException>(); Expect(thrown).ToBe(exception); }); }); }
public InterfaceSpec() { Describe("Interface", () => { Describe("implementations", () => { It("should call spy wrapper on method calls.", () => { var action = (Action)(() => { }); var testSubject = (ITestSubject) new TestSubject(); var actionSpy = Jaz.SpyOn(action, nameof(action.Invoke)); testSubject.Call(action); Expect(actionSpy).ToHaveBeenCalled(); }); }); }); }
public VirtualMethodSpec() { Describe("Virtual Method", () => { Describe("overrides", () => { It("should call spy wrapper on method calls.", () => { var action = (Action)(() => { }); var testSubject = (TestSubjectBase) new TestSubject(); var actionSpy = Jaz.SpyOn(action, nameof(action.Invoke)); testSubject.Call(action); Expect(actionSpy).ToHaveBeenCalled(); }); }); }); }
public YieldReturnSpec() { Describe("Method using yield return", () => { It("should call through by default.", () => { var result = TestSubject.Method().ToList(); Expect(result).ToEqual(new[] { 1, 2, 3, 5, 7 }); }); It("should do nothing if spied on.", () => { Jaz.SpyOn(typeof(TestSubject), nameof(TestSubject.Method)); var result = TestSubject.Method(); Expect(result).ToBeDefault(); }); It("should call through as configured.", () => { Jaz.SpyOn(typeof(TestSubject), nameof(TestSubject.Method)).And.CallThrough(); var result = TestSubject.Method().ToList(); Expect(result).ToEqual(new[] { 1, 2, 3, 5, 7 }); }); It("should throw an exception as configured.", () => { Jaz.SpyOn(typeof(TestSubject), nameof(TestSubject.Method)).And.Throw <TestException>(); Expect(() => TestSubject.Method()).ToThrow <TestException>(); }); It("should return the configured value.", () => { Jaz.SpyOn(typeof(TestSubject), nameof(TestSubject.Method)).And.ReturnValue(new[] { 4, 6, 8, 9 }); var result = TestSubject.Method().ToList(); Expect(result).ToEqual(new[] { 4, 6, 8, 9 }); }); }); }
public CallsSpec() { Describe("Calls", () => { TestSubject testSubject = null; BeforeEach(() => { testSubject = new TestSubject(); }); It("should be empty for a new spy.", () => { var spy = Jaz.SpyOn(testSubject, nameof(testSubject.Action)); Expect(spy.Calls).ToBeEmpty(); }); It("should contain an ordered call log.", () => { var spy = Jaz.SpyOn(testSubject, nameof(testSubject.Action)); testSubject.Action(1, 2.0, "three"); testSubject.Action(2, 1.0, null); Expect(spy.Calls).ToEqual(new[] { new { Arguments = new object[] { 1, 2.0, "three" } }, new { Arguments = new object[] { 2, 1.0, null } } }); }); }); }
public BehaviourSpec() { var testSubject = new TestSubject(); Describe("Behaviour", () => { Describe("of Return Value", () => { It("should return the provided return value.", () => { Jaz.SpyOn(testSubject, nameof(testSubject.Func)).And.ReturnValue("abc"); var result = testSubject.Func(); Expect(result).ToBe("abc"); }); It("should cycle through return values once when using return values.", () => { Jaz.SpyOn(testSubject, nameof(testSubject.Func)).And.ReturnValues("a", "b", "c"); var result = testSubject.Func(); Expect(result).ToBe("a"); result = testSubject.Func(); Expect(result).ToBe("b"); result = testSubject.Func(); Expect(result).ToBe("c"); }); }); Describe("of Call Through", () => { It("should call through to the original implementation.", () => { Jaz.SpyOn(testSubject, nameof(testSubject.Func)).And.CallThrough(); var result = testSubject.Func(); Expect(result).ToBe("xyz"); }); }); Describe("of Default", () => { It("should return the default value of the function.", () => { Jaz.SpyOn(testSubject, nameof(testSubject.Func)); var result = testSubject.Func(); Expect(result).ToBeDefault(); }); It("should have no logic executed for an action.", () => { Jaz.SpyOn(testSubject, nameof(testSubject.Action)); testSubject.Action(); Expect(testSubject.Value).ToBeDefault(); }); }); Describe("of Throw", () => { It("should throw the given exception.", () => { var exception = new System.Exception(); Jaz.SpyOn(testSubject, nameof(testSubject.Action)).And.Throw(exception); try { testSubject.Action(); Fail("Expected an exception to be thrown."); } catch (Exception ex) { if (ex != exception) { throw; } } }); It("should throw an exception of the given type.", () => { Jaz.SpyOn(testSubject, nameof(testSubject.Action)).And.Throw <Exception>(); try { testSubject.Action(); Fail("Expected an exception to be thrown."); } catch (Exception ex) { if (ex.Message != "Exception of type 'System.Exception' was thrown.") { throw; } } }); }); Describe("in sequence", () => { It("should execute forever if added using And.", () => { Jaz.SpyOn(testSubject, nameof(testSubject.Func)).And.ReturnValue("abc"); var result = testSubject.Func(); Expect(result).ToBe("abc"); result = testSubject.Func(); Expect(result).ToBe("abc"); result = testSubject.Func(); Expect(result).ToBe("abc"); result = testSubject.Func(); Expect(result).ToBe("abc"); }); It("should clear existing behaviours if added using And.", () => { var spy = Jaz.SpyOn(testSubject, nameof(testSubject.Func)); spy.And.Throw <Exception>(); spy.And.ReturnValue("abc"); var result = testSubject.Func(); Expect(result).ToBe("abc"); }); It("should execute once if added using Then.", () => { Jaz.SpyOn(testSubject, nameof(testSubject.Func)).And.ReturnValue(null).Then.ReturnValue("abc"); var result = testSubject.Func(); Expect(result).ToBeDefault(); result = testSubject.Func(); Expect(result).ToBe("abc"); try { testSubject.Func(); Fail("Expected spy exception after running out of behaviours."); } catch (JazSpyException) { } }); It("should execute once if Once is specified.", () => { Jaz.SpyOn(testSubject, nameof(testSubject.Func)).And.ReturnValue("abc").Once(); var result = testSubject.Func(); Expect(result).ToBe("abc"); try { testSubject.Func(); Fail("Expected spy exception after running out of behaviours."); } catch (JazSpyException) { } }); It("should excute twice if Twice is specified.", () => { Jaz.SpyOn(testSubject, nameof(testSubject.Func)).And.ReturnValue("abc").Twice(); var result = testSubject.Func(); Expect(result).ToBe("abc"); result = testSubject.Func(); Expect(result).ToBe("abc"); try { testSubject.Func(); Fail("Expected spy exception after running out of behaviours."); } catch (JazSpyException) { } }); It("should execute the number of times specified in Times.", () => { Jaz.SpyOn(testSubject, nameof(testSubject.Func)).And.ReturnValue("abc").Times(3); var result = testSubject.Func(); Expect(result).ToBe("abc"); result = testSubject.Func(); Expect(result).ToBe("abc"); result = testSubject.Func(); Expect(result).ToBe("abc"); try { testSubject.Func(); Fail("Expected spy exception after running out of behaviours."); } catch (JazSpyException) { } }); It("should execute forever if Forever is specified.", () => { Jaz.SpyOn(testSubject, nameof(testSubject.Func)).And.ReturnValue("abc").Forever(); var result = testSubject.Func(); Expect(result).ToBe("abc"); result = testSubject.Func(); Expect(result).ToBe("abc"); result = testSubject.Func(); Expect(result).ToBe("abc"); }); }); }); }
public ValueExpectSpec() { Describe <ValueExpect <object> >(() => { Describe(nameof(ValueExpect <object> .ToBe), () => { It("should fail if value types are not equal.", () => { Expect(() => Expect(5).ToBe(4)).ToThrow <JazExpectationException>(); }); It("should fail if strings are not equal.", () => { Expect(() => Expect("a").ToBe("A")).ToThrow <JazExpectationException>(); }); It("should fail if classes are not same.", () => { Expect(() => Expect(new object()).ToBe(new object())).ToThrow <JazExpectationException>(); }); It("should pass if value types are equal.", () => { Expect(5).ToBe(5); }); It("should pass if strings are equal.", () => { Expect("a").ToBe("a ".Trim()); }); It("should pass if classes are same.", () => { var instance = new object(); Expect(instance).ToBe(instance); }); Describe("with Not", () => { It("should pass if value types are not equal.", () => { Expect(5).Not.ToBe(4); }); It("should pass if strings are not equal.", () => { Expect("a").Not.ToBe("A"); }); It("should pass if classes are not same.", () => { Expect(new object()).Not.ToBe(new object()); }); It("should fail if value types are equal.", () => { Expect(() => Expect(5).ToBe(5)).Not.ToThrow <JazExpectationException>(); }); It("should fail if strings are equal.", () => { Expect(() => Expect("a").ToBe("a ".Trim())).Not.ToThrow <JazExpectationException>(); }); It("should fail if classes are same.", () => { var instance = new object(); Expect(() => Expect(instance).ToBe(instance)).Not.ToThrow <JazExpectationException>(); }); }); }); Describe(nameof(ValueExpect <object> .ToBeBetween), () => { It("should fail if value is too low.", () => { Expect(() => Expect(5).ToBeBetween(6, 9)).ToThrow <JazExpectationException>(); }); It("should fail if value is too high.", () => { Expect(() => Expect(10).ToBeBetween(6, 9)).ToThrow <JazExpectationException>(); }); It("should pass if value is equal to min.", () => { Expect(6).ToBeBetween(6, 9); }); It("should pass if value is equal to max.", () => { Expect(9).ToBeBetween(6, 9); }); It("should pass if value is inside the range.", () => { Expect(7).ToBeBetween(6, 9); }); Describe("with Not", () => { It("should pass if value is too low.", () => { Expect(5).Not.ToBeBetween(6, 9); }); It("should pass if value is too high.", () => { Expect(10).Not.ToBeBetween(6, 9); }); It("should fail if value is equal to min.", () => { Expect(() => Expect(6).Not.ToBeBetween(6, 9)).ToThrow <JazExpectationException>(); }); It("should fail if value is equal to max.", () => { Expect(() => Expect(9).Not.ToBeBetween(6, 9)).ToThrow <JazExpectationException>(); }); It("should fail if value is inside the range.", () => { Expect(() => Expect(7).Not.ToBeBetween(6, 9)).ToThrow <JazExpectationException>(); }); }); }); Describe(nameof(ValueExpect <object> .ToBeDefault), () => { It("should fail on an instance.", () => { Expect(() => Expect(new object()).ToBeDefault()).ToThrow <JazExpectationException>(); }); It("should fail on non-default value.", () => { Expect(() => Expect(1).ToBeDefault()).ToThrow <JazExpectationException>(); }); It("should pass on null.", () => { Expect((object)null).ToBeDefault(); }); It("should pass on zero.", () => { Expect(0).ToBeDefault(); }); Describe("with Not", () => { It("should pass on an instance.", () => { Expect(new object()).Not.ToBeDefault(); }); It("should pass on non-default value.", () => { Expect(1).Not.ToBeDefault(); }); It("should fail on null.", () => { Expect(() => Expect((object)null).Not.ToBeDefault()).ToThrow <JazExpectationException>(); }); It("should pass on zero.", () => { Expect(() => Expect(0).Not.ToBeDefault()).ToThrow <JazExpectationException>(); }); }); }); Describe(nameof(ValueExpect <object> .ToBeEmpty), () => { It("should fail on an array with items.", () => { Expect(() => Expect(new[] { 1 }).ToBeEmpty()).ToThrow <JazExpectationException>(); }); It("should fail on a non-empty string.", () => { Expect(() => Expect("a").ToBeEmpty()).ToThrow <JazExpectationException>(); }); It("should pass on an empty array.", () => { Expect(new int[0]).ToBeEmpty(); }); It("should pass on an empty string.", () => { Expect("").ToBeEmpty(); }); Describe("with Not", () => { It("should pass on an array with items.", () => { Expect(new[] { 1 }).Not.ToBeEmpty(); }); It("should pass on a non-empty string.", () => { Expect("a").Not.ToBeEmpty(); }); It("should fail on an empty array.", () => { Expect(() => Expect(new int[0]).Not.ToBeEmpty()).ToThrow <JazExpectationException>(); }); It("should fail on an empty string.", () => { Expect(() => Expect("").Not.ToBeEmpty()).ToThrow <JazExpectationException>(); }); }); }); Describe(nameof(ValueExpect <object> .ToBeFalse), () => { It("should fail on non-boolean values.", () => { Expect(() => Expect(5).ToBeFalse()).ToThrow <JazExpectationException>(); }); It("should fail on null.", () => { Expect(() => Expect((object)null).ToBeFalse()).ToThrow <JazExpectationException>(); }); It("should fail on true.", () => { Expect(() => Expect(true).ToBeFalse()).ToThrow <JazExpectationException>(); }); It("should pass on false.", () => { Expect(false).ToBeFalse(); }); Describe("with Not", () => { It("should pass on non-boolean values.", () => { Expect(5).Not.ToBeFalse(); }); It("should pass on null.", () => { Expect((object)null).Not.ToBeFalse(); }); It("should pass on true.", () => { Expect(true).Not.ToBeFalse(); }); It("should fail on false.", () => { Expect(() => Expect(false).Not.ToBeFalse()).ToThrow <JazExpectationException>(); }); }); }); Describe(nameof(ValueExpect <object> .ToBeTrue), () => { It("should fail on non-boolean values.", () => { Expect(() => Expect(5).ToBeTrue()).ToThrow <JazExpectationException>(); }); It("should fail on null.", () => { Expect(() => Expect((object)null).ToBeTrue()).ToThrow <JazExpectationException>(); }); It("should fail on false.", () => { Expect(() => Expect(false).ToBeTrue()).ToThrow <JazExpectationException>(); }); It("should pass on true.", () => { Expect(true).ToBeTrue(); }); Describe("with Not", () => { It("should pass on non-boolean values.", () => { Expect(5).Not.ToBeTrue(); }); It("should pass on null.", () => { Expect((object)null).Not.ToBeTrue(); }); It("should pass on false.", () => { Expect(false).Not.ToBeTrue(); }); It("should fail on true.", () => { Expect(() => Expect(true).Not.ToBeTrue()).ToThrow <JazExpectationException>(); }); }); }); Describe(nameof(ValueExpect <object> .ToEqual), () => { It("should fail on mismatching value types.", () => { Expect(() => Expect(1).ToEqual(2)).ToThrow <JazExpectationException>(); }); It("should fail on different list lengths", () => { Expect(() => Expect(new[] { 3 }).ToEqual(new int[0])).ToThrow <JazExpectationException>(); }); It("should fail on different list items.", () => { Expect(() => Expect(new[] { 3 }).ToEqual(new[] { 1 })).ToThrow <JazExpectationException>(); }); It("should fail if expected has extra properties.", () => { Expect(() => Expect(new { }).ToEqual(new { v = 0 })).ToThrow <JazExpectationException>(); }); It("should fail if expected is missing properties.", () => { Expect(() => Expect(new { v = 0 }).ToEqual(new { })).ToThrow <JazExpectationException>(); }); It("should fail when comparing to Jaz.Any<T> of wrong type.", () => { Expect(() => Expect(new { v = 0 }).ToEqual(new { v = Jaz.Any <double>() })).ToThrow <JazExpectationException>(); }); It("should fail when comparing to Jaz.InstanceOf<T> with inheriting value.", () => { Expect(() => Expect(new { v = "" }).ToEqual(new { v = Jaz.InstanceOf <object>() })).ToThrow <JazExpectationException>(); }); It("should fail when comparing null to Jaz.InstanceOf<T> with nullable type.", () => { Expect(() => Expect(new { v = (object)null }).ToEqual(new { v = Jaz.InstanceOf <object>() })).ToThrow <JazExpectationException>(); }); It("should pass on equivalent value types.", () => { Expect(3).ToEqual(3); }); It("should pass on equivalent reference types.", () => { Expect("yes").ToEqual("yes ".Trim()); }); It("should pass on equivalent list lengths.", () => { Expect(new int[0]).ToEqual(new object[0]); }); It("should pass on equivalent list items.", () => { Expect(new[] { "a", "b", "c" }).ToEqual(new[] { " a ".Trim(), " b ".Trim(), " c ".Trim() }); }); It("should pass on objects with the same properies with equivalent values.", () => { Expect(new { v = "a" }).ToEqual(new { v = " a ".Trim() }); }); It("should pass when comparing to Jaz.Any<T>.", () => { Expect(new { v = 1 }).ToEqual(new { v = Jaz.Any <int>() }); }); It("should pass when comparing to Jaz.Any.", () => { Expect(new { v = 1 }).ToEqual(new { v = Jaz.Any() }); }); It("should pass when comparing to Jaz.AnyOrNull<T> when value is null and T is nullable.", () => { Expect(new { v = (object)null }).ToEqual(new { v = Jaz.AnyOrNull <string>() }); }); It("should pass when comparing to Jaz.AnyOrNull when value is null.", () => { Expect(new { v = (int?)null }).ToEqual(new { v = Jaz.AnyOrNull() }); }); Describe("with Not", () => { It("should pass on mismatching value types.", () => { Expect(1).Not.ToEqual(2); }); It("should pass on different list lengths", () => { Expect(new[] { 3 }).Not.ToEqual(new int[0]); }); It("should pass on different list items.", () => { Expect(new[] { 3 }).Not.ToEqual(new[] { 1 }); }); It("should pass if expected has extra properties.", () => { Expect(new { }).Not.ToEqual(new { v = 0 }); }); It("should pass if expected is missing properties.", () => { Expect(new { v = 0 }).Not.ToEqual(new { }); }); It("should pass when comparing to Jaz.Any<T> of wrong type.", () => { Expect(new { v = 0 }).Not.ToEqual(new { v = Jaz.Any <double>() }); }); It("should pass when comparing to Jaz.InstanceOf<T> with inheriting value.", () => { Expect(new { v = "" }).Not.ToEqual(new { v = Jaz.InstanceOf <object>() }); }); It("should pass when comparing null to Jaz.InstanceOf<T> with nullable type.", () => { Expect(new { v = (object)null }).Not.ToEqual(new { v = Jaz.InstanceOf <object>() }); }); It("should fail on equivalent value types.", () => { Expect(() => Expect(3).Not.ToEqual(3)).ToThrow <JazExpectationException>(); }); It("should fail on equivalent reference types.", () => { Expect(() => Expect("yes").Not.ToEqual("yes ".Trim())).ToThrow <JazExpectationException>(); }); It("should fail on equivalent list lengths.", () => { Expect(() => Expect(new int[0]).Not.ToEqual(new object[0])).ToThrow <JazExpectationException>(); }); It("should fail on equivalent list items.", () => { Expect(() => Expect(new[] { "a", "b", "c" }).Not.ToEqual(new[] { " a ".Trim(), " b ".Trim(), " c ".Trim() })).ToThrow <JazExpectationException>(); }); It("should fail on objects with the same properies with equivalent values.", () => { Expect(() => Expect(new { v = "a" }).Not.ToEqual(new { v = " a ".Trim() })).ToThrow <JazExpectationException>(); }); It("should fail when comparing to Jaz.Any<T>.", () => { Expect(() => Expect(new { v = 1 }).Not.ToEqual(new { v = Jaz.Any <int>() })).ToThrow <JazExpectationException>(); }); It("should fail when comparing to Jaz.Any.", () => { Expect(() => Expect(new { v = 1 }).Not.ToEqual(new { v = Jaz.Any() })).ToThrow <JazExpectationException>(); }); It("should fail when comparing to Jaz.AnyOrNull<T> when value is null and T is nullable.", () => { Expect(() => Expect(new { v = (object)null }).Not.ToEqual(new { v = Jaz.AnyOrNull <string>() })).ToThrow <JazExpectationException>(); }); It("should fail when comparing to Jaz.AnyOrNull when value is null.", () => { Expect(() => Expect(new { v = (int?)null }).Not.ToEqual(new { v = Jaz.AnyOrNull() })).ToThrow <JazExpectationException>(); }); }); }); Describe(nameof(ValueExpect <object> .ToBeGreaterThan), () => { It("should fail if value is less than the given value.", () => { Expect(() => Expect(3).ToBeGreaterThan(5)).ToThrow <JazExpectationException>(); }); It("should fail if value is equal to the given value.", () => { Expect(() => Expect(5).ToBeGreaterThan(5)).ToThrow <JazExpectationException>(); }); It("should pass if value is greater than the given value.", () => { Expect(7).ToBeGreaterThan(5); }); Describe("with Not", () => { It("should pass if value is less than the given value.", () => { Expect(3).Not.ToBeGreaterThan(5); }); It("should pass if value is equal to the given value.", () => { Expect(5).Not.ToBeGreaterThan(5); }); It("should fail if value is greater than the given value.", () => { Expect(() => Expect(7).Not.ToBeGreaterThan(5)).ToThrow <JazExpectationException>(); }); }); }); Describe(nameof(ValueExpect <object> .ToBeLessThan), () => { It("should fail if value is less than the given value.", () => { Expect(() => Expect(7).ToBeLessThan(5)).ToThrow <JazExpectationException>(); }); It("should fail if value is equal to the given value.", () => { Expect(() => Expect(5).ToBeLessThan(5)).ToThrow <JazExpectationException>(); }); It("should pass if value is greater than the given value.", () => { Expect(3).ToBeLessThan(5); }); Describe("with Not", () => { It("should pass if value is greater than the given value.", () => { Expect(7).Not.ToBeLessThan(5); }); It("should pass if value is equal to the given value.", () => { Expect(5).Not.ToBeLessThan(5); }); It("should fail if value is less than the given value.", () => { Expect(() => Expect(3).Not.ToBeLessThan(5)).ToThrow <JazExpectationException>(); }); }); }); Describe(nameof(ValueExpect <object> .ToBeGreaterThanOrEqualTo), () => { It("should fail if value is less than the given value.", () => { Expect(() => Expect(3).ToBeGreaterThanOrEqualTo(5)).ToThrow <JazExpectationException>(); }); It("should pass if value is equal to the given value.", () => { Expect(5).ToBeGreaterThanOrEqualTo(5); }); It("should pass if value is greater than the given value.", () => { Expect(7).ToBeGreaterThanOrEqualTo(5); }); Describe("with Not", () => { It("should pass if value is less than the given value.", () => { Expect(3).Not.ToBeGreaterThanOrEqualTo(5); }); It("should fail if value is equal to the given value.", () => { Expect(() => Expect(5).Not.ToBeGreaterThanOrEqualTo(5)).ToThrow <JazExpectationException>(); }); It("should fail if value is greater than the given value.", () => { Expect(() => Expect(7).Not.ToBeGreaterThanOrEqualTo(5)).ToThrow <JazExpectationException>(); }); }); }); Describe(nameof(ValueExpect <object> .ToBeLessThanOrEqualTo), () => { It("should fail if value is less than the given value.", () => { Expect(() => Expect(7).ToBeLessThanOrEqualTo(5)).ToThrow <JazExpectationException>(); }); It("should pass if value is equal to the given value.", () => { Expect(5).ToBeLessThanOrEqualTo(5); }); It("should pass if value is greater than the given value.", () => { Expect(3).ToBeLessThanOrEqualTo(5); }); Describe("with Not", () => { It("should pass if value is greater than the given value.", () => { Expect(7).Not.ToBeLessThanOrEqualTo(5); }); It("should fail if value is equal to the given value.", () => { Expect(() => Expect(5).Not.ToBeLessThanOrEqualTo(5)).ToThrow <JazExpectationException>(); }); It("should fail if value is less than the given value.", () => { Expect(() => Expect(3).Not.ToBeLessThanOrEqualTo(5)).ToThrow <JazExpectationException>(); }); }); }); Describe(nameof(ValueExpect <string> .ToMatch), () => { It("should fail if the value is not a string.", () => { Expect(() => Expect(12).ToMatch("[0-9]+")).ToThrow <JazExpectationException>(); }); It("should fail if the value is not a string.", () => { Expect(() => Expect(12).ToMatch(new Regex("[0-9]+"))).ToThrow <JazExpectationException>(); }); It("should fail if the value does not match the regex.", () => { Expect(() => Expect("abc").ToMatch("[ab]+d")).ToThrow <JazExpectationException>(); }); It("should fail if the value does not match the regex.", () => { Expect(() => Expect("abc").ToMatch(new Regex("[ab]+d"))).ToThrow <JazExpectationException>(); }); It("should pass if the value does matches the regex.", () => { Expect("abc").ToMatch("[ab]+c"); }); It("should pass if the value does matches the regex.", () => { Expect("abc").ToMatch(new Regex("[ab]+c")); }); Describe("with Not", () => { It("should still fail if the value is not a string.", () => { Expect(() => Expect(12).Not.ToMatch("[0-9]+")).ToThrow <JazExpectationException>(); }); It("should still fail if the value is not a string.", () => { Expect(() => Expect(12).Not.ToMatch(new Regex("[0-9]+"))).ToThrow <JazExpectationException>(); }); It("should pass if the value does not match the regex.", () => { Expect("abc").Not.ToMatch("[ab]+d"); }); It("should pass if the value does not match the regex.", () => { Expect("abc").Not.ToMatch(new Regex("[ab]+d")); }); It("should fail if the value does matches the regex.", () => { Expect(() => Expect("abc").Not.ToMatch("[ab]+c")).ToThrow <JazExpectationException>(); }); It("should fail if the value does matches the regex.", () => { Expect(() => Expect("abc").Not.ToMatch(new Regex("[ab]+c"))).ToThrow <JazExpectationException>(); }); }); }); Describe(nameof(ValueExpect <object> .ToContain), () => { It("should fail if value is not string and checking against a string value.", () => { Expect(() => Expect(12).ToContain("12")).ToThrow <JazExpectationException>(); }); It("should fail if value does not contain the string.", () => { Expect(() => Expect("1234").ToContain("14")).ToThrow <JazExpectationException>(); }); It("should fail if value doesn't match given string casing.", () => { Expect(() => Expect("aBcD").ToContain("bc")).ToThrow <JazExpectationException>(); }); It("should fail if list is missing the given value.", () => { Expect(() => Expect(new[] { "a", "b", "c" }).ToContain(new[] { "a", "d" })).ToThrow <JazExpectationException>(); }); It("should fail if object is missing properties.", () => { Expect(() => Expect(new { p1 = "x", p2 = "y" }).ToContain(new { p1 = "x", p3 = "z" })).ToThrow <JazExpectationException>(); }); It("should fail if list in object is missing values.", () => { Expect(() => Expect(new { p1 = new[] { "a", "b", "c" } }).ToContain(new { p1 = new[] { "a", "d" } })).ToThrow <JazExpectationException>(); }); It("should fail if object in list is missing properties.", () => { Expect(() => Expect(new[] { new { p1 = "x", p2 = "y" } }).ToContain(new[] { new { p1 = "x", p3 = "z" } })).ToThrow <JazExpectationException>(); }); It("should fail if duplicate items are expected but missing.", () => { Expect(() => Expect(new[] { "a", "b" }).ToContain(new[] { "b", "b" })).ToThrow <JazExpectationException>(); }); It("should fail if testing similar items in list in unexpected order.", () => { Expect(() => Expect(new object[] { new { p1 = "x", p2 = "y", p3 = "z" }, new { p1 = "x", p2 = "y" } }) .ToContain(new object[] { new { p1 = "x" }, new { p1 = "x", p3 = "z" } })).ToThrow <JazExpectationException>(); }); It("should pass if value contains string.", () => { Expect("1234").ToContain("23"); }); It("should pass if value casing is different but ignore casing is true.", () => { Expect("aBcD").ToContain("bc", true); }); It("should pass if list contains given items.", () => { Expect(new[] { "a", "b", "c" }).ToContain(new[] { "b", "c" }); }); It("should pass if object contains given properties.", () => { Expect(new { p1 = "x", p2 = "y", p3 = "z" }).ToContain(new { p2 = "y", p3 = "z" }); }); It("should pass if list in object contains expect items.", () => { Expect(new { list = new[] { "a", "b", "c" } }).ToContain(new { list = new[] { "b", "c" } }); }); It("should pass if object in list contains expected properties.", () => { Expect(new[] { new { p1 = "x", p2 = "y", p3 = "z" } }).ToContain(new[] { new { p2 = "y", p3 = "z" } }); }); It("should pass if testing similar items in list in correct order.", () => { Expect(new object[] { new { p1 = "x", p2 = "y" }, new { p1 = "x", p2 = "y", p3 = "z" } }) .ToContain(new object[] { new { p1 = "x" }, new { p1 = "x", p3 = "z" } }); }); }); }); }
public PropertySpec() { Describe("Instance Property", () => { TestSubject testSubject = null; BeforeEach(() => { testSubject = new TestSubject(); }); Describe("with get and set", () => { It("should call through by default.", () => { Expect(testSubject.GetSetProp).ToBe("123"); testSubject.GetSetProp = "test."; Expect(testSubject.Value).ToBe("test."); }); It("should do nothing if spied on.", () => { var spy = Jaz.SpyOnProperty(testSubject, nameof(testSubject.GetSetProp)); testSubject.GetSetProp = "test."; Expect(testSubject.GetSetProp).ToBeDefault(); Expect(testSubject.Value).ToBe("123"); }); It("should return the configured value.", () => { var spy = Jaz.SpyOnProperty(testSubject, nameof(testSubject.GetSetProp)).Getter.And.ReturnValue("test."); Expect(testSubject.GetSetProp).ToBe("test."); }); It("should call through as configured.", () => { var propertySpy = Jaz.SpyOnProperty(testSubject, nameof(testSubject.GetSetProp)); propertySpy.Getter.And.CallThrough(); propertySpy.Setter.And.CallThrough(); Expect(testSubject.GetSetProp).ToBe("123"); testSubject.GetSetProp = "test."; Expect(testSubject.Value).ToBe("test."); }); It("should throw an exception as configured.", () => { var propertySpy = Jaz.SpyOnProperty(testSubject, nameof(testSubject.GetSetProp)); propertySpy.Getter.And.Throw <TestException>(); propertySpy.Setter.And.Throw <TestException>(); Expect(() => { var x = testSubject.GetSetProp; }).ToThrow <TestException>(); Expect(() => testSubject.GetSetProp = "test.").ToThrow <TestException>(); }); }); Describe("with only get", () => { It("should call through by default.", () => { Expect(testSubject.GetProp).ToBe("123"); }); It("should do nothing if spied on.", () => { var propertySpy = Jaz.SpyOnProperty(testSubject, nameof(testSubject.GetProp)); Expect((object)propertySpy.Setter).ToBeDefault(); Expect(testSubject.GetProp).ToBeDefault(); }); It("should return the configured value.", () => { var spy = Jaz.SpyOnProperty(testSubject, nameof(testSubject.GetProp)).Getter.And.ReturnValue("test."); Expect(testSubject.GetProp).ToBe("test."); }); It("should call through as configured.", () => { var propertySpy = Jaz.SpyOnProperty(testSubject, nameof(testSubject.GetProp)); propertySpy.Getter.And.CallThrough(); Expect(testSubject.GetProp).ToBe("123"); }); It("should throw an exception as configured.", () => { var propertySpy = Jaz.SpyOnProperty(testSubject, nameof(testSubject.GetProp)); propertySpy.Getter.And.Throw <TestException>(); Expect(() => { var x = testSubject.GetProp; }).ToThrow <TestException>(); }); }); Describe("with only set", () => { It("should call through by default.", () => { testSubject.SetProp = "test."; Expect(testSubject.Value).ToBe("test."); }); It("should do nothing if spied on.", () => { var propertySpy = Jaz.SpyOnProperty(testSubject, nameof(testSubject.SetProp)); testSubject.SetProp = "test."; Expect((object)propertySpy.Getter).ToBeDefault(); Expect(testSubject.Value).ToBe("123"); }); It("should call through as configured.", () => { var propertySpy = Jaz.SpyOnProperty(testSubject, nameof(testSubject.SetProp)); propertySpy.Setter.And.CallThrough(); testSubject.SetProp = "test."; Expect(testSubject.Value).ToBe("test."); }); It("should throw an exception as configured.", () => { var propertySpy = Jaz.SpyOnProperty(testSubject, nameof(testSubject.SetProp)); propertySpy.Setter.And.Throw <TestException>(); Expect(() => testSubject.SetProp = "test.").ToThrow <TestException>(); }); }); }); Describe("Static Property", () => { BeforeEach(() => { TestSubject.StaticValue = "abc"; }); Describe("with get and set", () => { It("should call through by default.", () => { Expect(TestSubject.StaticGetSetProp).ToBe("abc"); TestSubject.StaticGetSetProp = "test."; Expect(TestSubject.StaticValue).ToBe("test."); }); It("should do nothing if spied on.", () => { var spy = Jaz.SpyOnProperty(typeof(TestSubject), nameof(TestSubject.StaticGetSetProp)); TestSubject.StaticGetSetProp = "test."; Expect(TestSubject.StaticGetSetProp).ToBeDefault(); Expect(TestSubject.StaticValue).ToBe("abc"); }); It("should return the configured value.", () => { var spy = Jaz.SpyOnProperty(typeof(TestSubject), nameof(TestSubject.StaticGetSetProp)).Getter.And.ReturnValue("test."); Expect(TestSubject.StaticGetSetProp).ToBe("test."); }); It("should call through as configured.", () => { var propertySpy = Jaz.SpyOnProperty(typeof(TestSubject), nameof(TestSubject.StaticGetSetProp)); propertySpy.Getter.And.CallThrough(); propertySpy.Setter.And.CallThrough(); Expect(TestSubject.StaticGetSetProp).ToBe("abc"); TestSubject.StaticGetSetProp = "test."; Expect(TestSubject.StaticValue).ToBe("test."); }); It("should throw an exception as configured.", () => { var propertySpy = Jaz.SpyOnProperty(typeof(TestSubject), nameof(TestSubject.StaticGetSetProp)); propertySpy.Getter.And.Throw <TestException>(); propertySpy.Setter.And.Throw <TestException>(); Expect(() => { var x = TestSubject.StaticGetSetProp; }).ToThrow <TestException>(); Expect(() => TestSubject.StaticGetSetProp = "test.").ToThrow <TestException>(); }); }); Describe("with only get", () => { It("should call through by default.", () => { Expect(TestSubject.StaticGetProp).ToBe("abc"); }); It("should do nothing if spied on.", () => { var propertySpy = Jaz.SpyOnProperty(typeof(TestSubject), nameof(TestSubject.StaticGetProp)); Expect((object)propertySpy.Setter).ToBeDefault(); Expect(TestSubject.StaticGetProp).ToBeDefault(); }); It("should return the configured value.", () => { var spy = Jaz.SpyOnProperty(typeof(TestSubject), nameof(TestSubject.StaticGetProp)).Getter.And.ReturnValue("test."); Expect(TestSubject.StaticGetProp).ToBe("test."); }); It("should call through as configured.", () => { var propertySpy = Jaz.SpyOnProperty(typeof(TestSubject), nameof(TestSubject.StaticGetProp)); propertySpy.Getter.And.CallThrough(); Expect(TestSubject.StaticGetProp).ToBe("abc"); }); It("should throw an exception as configured.", () => { var propertySpy = Jaz.SpyOnProperty(typeof(TestSubject), nameof(TestSubject.StaticGetProp)); propertySpy.Getter.And.Throw <TestException>(); Expect(() => { var x = TestSubject.StaticGetProp; }).ToThrow <TestException>(); }); }); Describe("with only set", () => { It("should call through by default.", () => { TestSubject.StaticSetProp = "test."; Expect(TestSubject.StaticValue).ToBe("test."); }); It("should do nothing if spied on.", () => { var propertySpy = Jaz.SpyOnProperty(typeof(TestSubject), nameof(TestSubject.StaticSetProp)); TestSubject.StaticSetProp = "test."; Expect((object)propertySpy.Getter).ToBeDefault(); Expect(TestSubject.StaticValue).ToBe("abc"); }); It("should call through as configured.", () => { var propertySpy = Jaz.SpyOnProperty(typeof(TestSubject), nameof(TestSubject.StaticSetProp)); propertySpy.Setter.And.CallThrough(); TestSubject.StaticSetProp = "test."; Expect(TestSubject.StaticValue).ToBe("test."); }); It("should throw an exception as configured.", () => { var propertySpy = Jaz.SpyOnProperty(typeof(TestSubject), nameof(TestSubject.StaticSetProp)); propertySpy.Setter.And.Throw <TestException>(); Expect(() => TestSubject.StaticSetProp = "test.").ToThrow <TestException>(); }); }); }); Describe("Generic Instance Property", () => { TestSubject <string> testSubject = null; BeforeEach(() => { testSubject = new TestSubject <string>(); testSubject.Value = "123"; }); Describe("with get and set", () => { It("should call through by default.", () => { Expect(testSubject.GetSetProp).ToBe("123"); testSubject.GetSetProp = "test."; Expect(testSubject.Value).ToBe("test."); }); It("should do nothing if spied on.", () => { var spy = Jaz.SpyOnProperty(testSubject, nameof(testSubject.GetSetProp)); testSubject.GetSetProp = "test."; Expect(testSubject.GetSetProp).ToBeDefault(); Expect(testSubject.Value).ToBe("123"); }); It("should return the configured value.", () => { var spy = Jaz.SpyOnProperty(testSubject, nameof(testSubject.GetSetProp)).Getter.And.ReturnValue("test."); Expect(testSubject.GetSetProp).ToBe("test."); }); It("should call through as configured.", () => { var propertySpy = Jaz.SpyOnProperty(testSubject, nameof(testSubject.GetSetProp)); propertySpy.Getter.And.CallThrough(); propertySpy.Setter.And.CallThrough(); Expect(testSubject.GetSetProp).ToBe("123"); testSubject.GetSetProp = "test."; Expect(testSubject.Value).ToBe("test."); }); It("should throw an exception as configured.", () => { var propertySpy = Jaz.SpyOnProperty(testSubject, nameof(testSubject.GetSetProp)); propertySpy.Getter.And.Throw <TestException>(); propertySpy.Setter.And.Throw <TestException>(); Expect(() => { var x = testSubject.GetSetProp; }).ToThrow <TestException>(); Expect(() => testSubject.GetSetProp = "test.").ToThrow <TestException>(); }); }); Describe("with only get", () => { It("should call through by default.", () => { Expect(testSubject.GetProp).ToBe("123"); }); It("should do nothing if spied on.", () => { var propertySpy = Jaz.SpyOnProperty(testSubject, nameof(testSubject.GetProp)); Expect((object)propertySpy.Setter).ToBeDefault(); Expect(testSubject.GetProp).ToBeDefault(); }); It("should return the configured value.", () => { var spy = Jaz.SpyOnProperty(testSubject, nameof(testSubject.GetProp)).Getter.And.ReturnValue("test."); Expect(testSubject.GetProp).ToBe("test."); }); It("should call through as configured.", () => { var propertySpy = Jaz.SpyOnProperty(testSubject, nameof(testSubject.GetProp)); propertySpy.Getter.And.CallThrough(); Expect(testSubject.GetProp).ToBe("123"); }); It("should throw an exception as configured.", () => { var propertySpy = Jaz.SpyOnProperty(testSubject, nameof(testSubject.GetProp)); propertySpy.Getter.And.Throw <TestException>(); Expect(() => { var x = testSubject.GetProp; }).ToThrow <TestException>(); }); }); Describe("with only set", () => { It("should call through by default.", () => { testSubject.SetProp = "test."; Expect(testSubject.Value).ToBe("test."); }); It("should do nothing if spied on.", () => { var propertySpy = Jaz.SpyOnProperty(testSubject, nameof(testSubject.SetProp)); testSubject.SetProp = "test."; Expect((object)propertySpy.Getter).ToBeDefault(); Expect(testSubject.Value).ToBe("123"); }); It("should call through as configured.", () => { var propertySpy = Jaz.SpyOnProperty(testSubject, nameof(testSubject.SetProp)); propertySpy.Setter.And.CallThrough(); testSubject.SetProp = "test."; Expect(testSubject.Value).ToBe("test."); }); It("should throw an exception as configured.", () => { var propertySpy = Jaz.SpyOnProperty(testSubject, nameof(testSubject.SetProp)); propertySpy.Setter.And.Throw <TestException>(); Expect(() => testSubject.SetProp = "test.").ToThrow <TestException>(); }); }); }); Describe("Generic Static Property", () => { BeforeEach(() => { TestSubject <string> .StaticValue = "abc"; }); Describe("with get and set", () => { It("should call through by default.", () => { Expect(TestSubject <string> .StaticGetSetProp).ToBe("abc"); TestSubject <string> .StaticGetSetProp = "test."; Expect(TestSubject <string> .StaticValue).ToBe("test."); }); It("should do nothing if spied on.", () => { var spy = Jaz.SpyOnProperty(typeof(TestSubject <string>), nameof(TestSubject <string> .StaticGetSetProp)); TestSubject.StaticGetSetProp = "test."; Expect(TestSubject <string> .StaticGetSetProp).ToBeDefault(); Expect(TestSubject <string> .StaticValue).ToBe("abc"); }); It("should return the configured value.", () => { var spy = Jaz.SpyOnProperty(typeof(TestSubject <string>), nameof(TestSubject <string> .StaticGetSetProp)).Getter.And.ReturnValue("test."); Expect(TestSubject <string> .StaticGetSetProp).ToBe("test."); }); It("should call through as configured.", () => { var propertySpy = Jaz.SpyOnProperty(typeof(TestSubject <string>), nameof(TestSubject <string> .StaticGetSetProp)); propertySpy.Getter.And.CallThrough(); propertySpy.Setter.And.CallThrough(); Expect(TestSubject <string> .StaticGetSetProp).ToBe("abc"); TestSubject <string> .StaticGetSetProp = "test."; Expect(TestSubject <string> .StaticValue).ToBe("test."); }); It("should throw an exception as configured.", () => { var propertySpy = Jaz.SpyOnProperty(typeof(TestSubject <string>), nameof(TestSubject <string> .StaticGetSetProp)); propertySpy.Getter.And.Throw <TestException>(); propertySpy.Setter.And.Throw <TestException>(); Expect(() => { var x = TestSubject <string> .StaticGetSetProp; }).ToThrow <TestException>(); Expect(() => TestSubject <string> .StaticGetSetProp = "test.").ToThrow <TestException>(); }); }); Describe("with only get", () => { It("should call through by default.", () => { Expect(TestSubject <string> .StaticGetProp).ToBe("abc"); }); It("should do nothing if spied on.", () => { var propertySpy = Jaz.SpyOnProperty(typeof(TestSubject <string>), nameof(TestSubject <string> .StaticGetProp)); Expect((object)propertySpy.Setter).ToBeDefault(); Expect(TestSubject <string> .StaticGetProp).ToBeDefault(); }); It("should return the configured value.", () => { var spy = Jaz.SpyOnProperty(typeof(TestSubject <string>), nameof(TestSubject <string> .StaticGetProp)).Getter.And.ReturnValue("test."); Expect(TestSubject <string> .StaticGetProp).ToBe("test."); }); It("should call through as configured.", () => { var propertySpy = Jaz.SpyOnProperty(typeof(TestSubject <string>), nameof(TestSubject <string> .StaticGetProp)); propertySpy.Getter.And.CallThrough(); Expect(TestSubject <string> .StaticGetProp).ToBe("abc"); }); It("should throw an exception as configured.", () => { var propertySpy = Jaz.SpyOnProperty(typeof(TestSubject <string>), nameof(TestSubject <string> .StaticGetProp)); propertySpy.Getter.And.Throw <TestException>(); Expect(() => { var x = TestSubject <string> .StaticGetProp; }).ToThrow <TestException>(); }); }); Describe("with only set", () => { It("should call through by default.", () => { TestSubject <string> .StaticSetProp = "test."; Expect(TestSubject <string> .StaticValue).ToBe("test."); }); It("should do nothing if spied on.", () => { var propertySpy = Jaz.SpyOnProperty(typeof(TestSubject <string>), nameof(TestSubject <string> .StaticSetProp)); TestSubject <string> .StaticSetProp = "test."; Expect((object)propertySpy.Getter).ToBeDefault(); Expect(TestSubject <string> .StaticValue).ToBe("abc"); }); It("should call through as configured.", () => { var propertySpy = Jaz.SpyOnProperty(typeof(TestSubject <string>), nameof(TestSubject <string> .StaticSetProp)); propertySpy.Setter.And.CallThrough(); TestSubject <string> .StaticSetProp = "test."; Expect(TestSubject <string> .StaticValue).ToBe("test."); }); It("should throw an exception as configured.", () => { var propertySpy = Jaz.SpyOnProperty(typeof(TestSubject <string>), nameof(TestSubject <string> .StaticSetProp)); propertySpy.Setter.And.Throw <TestException>(); Expect(() => TestSubject <string> .StaticSetProp = "test.").ToThrow <TestException>(); }); }); }); }
public ByRefSpec() { TestSubject testSubject = null; Describe("Action with by ref parameter", () => { float testValue = default; BeforeEach(() => { testSubject = new TestSubject(); testValue = 85.5f; }); It("should call through by default.", () => { testSubject.PercentToDecimal(ref testValue); Expect(testValue).ToBe(0.855f); }); It("should do nothing if spied on.", () => { Jaz.SpyOn(testSubject, nameof(testSubject.PercentToDecimal)); testSubject.PercentToDecimal(ref testValue); Expect(testValue).ToBe(85.5f); }); It("should call through as configured.", () => { Jaz.SpyOn(testSubject, nameof(testSubject.PercentToDecimal)).And.CallThrough(); testSubject.PercentToDecimal(ref testValue); Expect(testValue).ToBe(0.855f); }); It("should throw an exception as configured.", () => { Jaz.SpyOn(testSubject, nameof(testSubject.PercentToDecimal)).And.Throw <TestException>(); Expect(() => testSubject.PercentToDecimal(ref testValue)).ToThrow <TestException>(); }); It("should change the ref parameter as configured.", () => { Jaz.SpyOn(testSubject, nameof(testSubject.PercentToDecimal)).And.DoNothing().ThenChangeParameter("value", 1.0f); testSubject.PercentToDecimal(ref testValue); Expect(testValue).ToBe(1.0f); }); }); Describe("Action with out parameter", () => { float testValue = default; BeforeEach(() => { testSubject = new TestSubject(); testValue = 85.5f; }); It("should call through by default.", () => { testSubject.PercentToDecimalPreserve(testValue, out var output); Expect(output).ToBe(0.855f); }); It("should do nothing if spied on.", () => { Jaz.SpyOn(testSubject, nameof(testSubject.PercentToDecimalPreserve)); testSubject.PercentToDecimalPreserve(testValue, out var output); Expect(output).ToBeDefault(); }); It("should call through as configured.", () => { Jaz.SpyOn(testSubject, nameof(testSubject.PercentToDecimalPreserve)).And.CallThrough(); testSubject.PercentToDecimalPreserve(testValue, out var output); Expect(output).ToBe(0.855f); }); It("should throw an exception as configured.", () => { Jaz.SpyOn(testSubject, nameof(testSubject.PercentToDecimalPreserve)).And.Throw <TestException>(); Expect(() => testSubject.PercentToDecimalPreserve(testValue, out var output)).ToThrow <TestException>(); }); It("should change the ref parameter as configured.", () => { Jaz.SpyOn(testSubject, nameof(testSubject.PercentToDecimalPreserve)).And.DoNothing().ThenChangeParameter("decimal", 1.0f); testSubject.PercentToDecimalPreserve(testValue, out var output); Expect(output).ToBe(1.0f); }); });
public StaticMethodSpec() { Describe("A static action", () => { BeforeEach(() => { TestSubject.Value = 0; }); It("should call through by default.", () => { TestSubject.Iterate(3); Expect(TestSubject.Value).ToBe(3); }); It("should do nothing if spied on.", () => { Jaz.SpyOn(typeof(TestSubject), nameof(TestSubject.Iterate)); TestSubject.Iterate(3); Expect(TestSubject.Value).ToBeDefault(); }); It("should call through as configured.", () => { Jaz.SpyOn(typeof(TestSubject), nameof(TestSubject.Iterate)).And.CallThrough(); TestSubject.Iterate(3); Expect(TestSubject.Value).ToBe(3); }); It("should throw an exception as configured.", () => { var exception = new TestException(); Jaz.SpyOn(typeof(TestSubject), nameof(TestSubject.Iterate)).And.Throw(exception); var thrown = Expect(() => TestSubject.Iterate(3)).ToThrow <TestException>(); Expect(thrown).ToBe(exception); }); // the only non-generic spy entry point Describe("with no parameters", () => { It("should call through by default.", () => { TestSubject.Increment(); Expect(TestSubject.Value).ToBe(1); }); It("should do nothing if spied on.", () => { Jaz.SpyOn(typeof(TestSubject), nameof(TestSubject.Increment)); TestSubject.Increment(); Expect(TestSubject.Value).ToBeDefault(); }); It("should call through as configured.", () => { Jaz.SpyOn(typeof(TestSubject), nameof(TestSubject.Increment)).And.CallThrough(); TestSubject.Increment(); Expect(TestSubject.Value).ToBe(1); }); It("should throw an exception as configured.", () => { var exception = new TestException(); Jaz.SpyOn(typeof(TestSubject), nameof(TestSubject.Increment)).And.Throw(exception); var thrown = Expect(() => TestSubject.Increment()).ToThrow <TestException>(); Expect(thrown).ToBe(exception); }); }); }); Describe("A static function", () => { It("should call through by default.", () => { var result = TestSubject.Add5(3); Expect(result).ToBe(8); }); It("should do nothing if spied on.", () => { Jaz.SpyOn(typeof(TestSubject), nameof(TestSubject.Add5)); var result = TestSubject.Add5(3); Expect(result).ToBeDefault(); }); It("should return the configured value.", () => { Jaz.SpyOn(typeof(TestSubject), nameof(TestSubject.Add5)).And.ReturnValue(1); var result = TestSubject.Add5(3); Expect(result).ToBe(1); }); It("should return the configured values in sequence.", () => { Jaz.SpyOn(typeof(TestSubject), nameof(TestSubject.Add5)).And.ReturnValues(1, 2, 3, 4); var result = TestSubject.Add5(3); Expect(result).ToBe(1); result = TestSubject.Add5(3); Expect(result).ToBe(2); result = TestSubject.Add5(3); Expect(result).ToBe(3); result = TestSubject.Add5(3); Expect(result).ToBe(4); }); It("should call through as configured.", () => { Jaz.SpyOn(typeof(TestSubject), nameof(TestSubject.Add5)).And.CallThrough(); var result = TestSubject.Add5(3); Expect(result).ToBe(8); }); It("should throw an exception as configured.", () => { var exception = new TestException(); Jaz.SpyOn(typeof(TestSubject), nameof(TestSubject.Add5)).And.Throw(exception); var thrown = Expect(() => TestSubject.Add5(3)).ToThrow <TestException>(); Expect(thrown).ToBe(exception); }); }); }
public SpyExpectSpec() { Describe <SpyExpect>(() => { TestSubject testSubject = null; Spy spy = null; BeforeEach(() => { testSubject = new TestSubject(); spy = Jaz.SpyOn(testSubject, nameof(testSubject.Action)); }); Describe(nameof(SpyExpect.Not), () => { It("should invert the check.", () => { Expect(spy).Not.ToHaveBeenCalled(); }); }); Describe(nameof(SpyExpect.ToHaveBeenCalled), () => { It("should fail if the spy was not called.", () => { Expect(() => Expect(spy).ToHaveBeenCalled()).ToThrow <JazExpectationException>(); }); It("should pass if the spy was called.", () => { testSubject.Action(1, 2.0, "three"); Expect(spy).ToHaveBeenCalled(); }); Describe("with Not", () => { It("should invert the check.", () => { Expect(spy).Not.ToHaveBeenCalled(); testSubject.Action(1, 2.0, "three"); Expect(() => Expect(spy).Not.ToHaveBeenCalled()).ToThrow <JazExpectationException>(); }); }); }); Describe(nameof(SpyExpect.ToHaveBeenCalledTimes), () => { It("should fail if the spy was called less than the expected number of times.", () => { Expect(() => Expect(spy).ToHaveBeenCalledTimes(1)).ToThrow <JazExpectationException>(); }); It("should pass if the spy was called the expected number of times.", () => { testSubject.Action(1, 2.0, "three"); Expect(spy).ToHaveBeenCalledTimes(1); }); It("should fail if the spy was called more than the expected number of times.", () => { testSubject.Action(1, 2.0, "three"); testSubject.Action(1, 2.0, "three"); Expect(() => Expect(spy).ToHaveBeenCalledTimes(1)).ToThrow <JazExpectationException>(); }); Describe("with Not", () => { It("should invert the check.", () => { Expect(spy).Not.ToHaveBeenCalledTimes(1); testSubject.Action(1, 2.0, "three"); Expect(() => Expect(spy).Not.ToHaveBeenCalledTimes(1)).ToThrow <JazExpectationException>(); testSubject.Action(1, 2.0, "three"); Expect(spy).Not.ToHaveBeenCalledTimes(1); }); }); }); Describe(nameof(SpyExpect.ToHaveBeenCalledWith), () => { It("should fail if the spy was not called.", () => { Expect(() => Expect(spy).ToHaveBeenCalledWith(1, 2.0, "three")).ToThrow <JazExpectationException>(); }); It("should fail if the spy was not called with the expected parameters.", () => { testSubject.Action(1, 2.0, "tree"); Expect(() => Expect(spy).ToHaveBeenCalledWith(1, 2.0, "three")).ToThrow <JazExpectationException>(); }); It("should pass if the spy was called with the expected parameters.", () => { testSubject.Action(1, 2.0, "three"); Expect(spy).ToHaveBeenCalledWith(1, 2.0, "three"); }); Describe("with Not", () => { It("should invert the check.", () => { Expect(spy).Not.ToHaveBeenCalledWith(1, 2.0, "three"); testSubject.Action(1, 2.0, "tree"); Expect(spy).Not.ToHaveBeenCalledWith(1, 2.0, "three"); testSubject.Action(1, 2.0, "three"); Expect(() => Expect(spy).Not.ToHaveBeenCalledWith(1, 2.0, "three")).ToThrow <JazExpectationException>(); }); }); }); }); }
public InstanceMethodSpec() { Describe("An Instance Action", () => { var subject = new TestSubject(); It("should call through by default.", () => { subject.Iterate(3); Expect(subject.Value).ToBe(3); }); It("should do nothing if spied on.", () => { Jaz.SpyOn(subject, nameof(subject.Iterate)); subject.Iterate(3); Expect(subject.Value).ToBeDefault(); }); It("should call through as configured.", () => { Jaz.SpyOn(subject, nameof(subject.Iterate)).And.CallThrough(); subject.Iterate(3); Expect(subject.Value).ToBe(3); }); It("should throw an exception as configured.", () => { var exception = new TestException(); Jaz.SpyOn(subject, nameof(subject.Iterate)).And.Throw(exception); var thrown = Expect(() => subject.Iterate(3)).ToThrow <TestException>(); Expect(thrown).ToBe(exception); }); }); Describe("An Instance Function", () => { var subject = new TestSubject(); It("should call through by default.", () => { var result = subject.Add5(3); Expect(result).ToBe(8); }); It("should do nothing if spied on.", () => { Jaz.SpyOn(subject, nameof(subject.Add5)); var result = subject.Add5(3); Expect(result).ToBeDefault(); }); It("should return the configured value.", () => { Jaz.SpyOn(subject, nameof(subject.Add5)).And.ReturnValue(1); var result = subject.Add5(3); Expect(result).ToBe(1); }); It("should return the configured values in sequence.", () => { Jaz.SpyOn(subject, nameof(subject.Add5)).And.ReturnValues(1, 2, 3, 4); var result = subject.Add5(3); Expect(result).ToBe(1); result = subject.Add5(3); Expect(result).ToBe(2); result = subject.Add5(3); Expect(result).ToBe(3); result = subject.Add5(3); Expect(result).ToBe(4); }); It("should call through as configured.", () => { Jaz.SpyOn(subject, nameof(subject.Add5)).And.CallThrough(); var result = subject.Add5(3); Expect(result).ToBe(8); }); It("should throw an exception as configured.", () => { var exception = new TestException(); Jaz.SpyOn(subject, nameof(subject.Add5)).And.Throw(exception); var thrown = Expect(() => subject.Add5(3)).ToThrow <TestException>(); Expect(thrown).ToBe(exception); }); }); }
public GenericInstanceMethodSpec() { Describe("A generic instance action", () => { var subject = new TestSubject(); It("should call through by default.", () => { subject.Iterate(3); Expect(subject.Value).ToBe(3); }); It("should do nothing if spied on.", () => { Jaz.SpyOn(subject, nameof(subject.Iterate)); subject.Iterate(3); Expect(subject.Value).ToBeDefault(); }); It("should call through as configured.", () => { Jaz.SpyOn(subject, nameof(subject.Iterate)).And.CallThrough(); subject.Iterate(3); Expect(subject.Value).ToBe(3); }); It("should throw an exception as configured.", () => { var exception = new TestException(); Jaz.SpyOn(subject, nameof(subject.Iterate)).And.Throw(exception); var thrown = Expect(() => subject.Iterate(3)).ToThrow <TestException>(); Expect(thrown).ToBe(exception); }); }); Describe("A generic instance function", () => { var subject = new TestSubject(); It("should call through by default.", () => { var result = subject.Add5(3); Expect(result).ToBe(8); }); It("should do nothing if spied on.", () => { Jaz.SpyOn(subject, nameof(subject.Add5)); var result = subject.Add5(3); Expect(result).ToBeDefault(); }); It("should return the configured value.", () => { Jaz.SpyOn(subject, nameof(subject.Add5)).And.ReturnValue(1); var result = subject.Add5(3); Expect(result).ToBe(1); }); It("should return the configured values in sequence.", () => { Jaz.SpyOn(subject, nameof(subject.Add5)).And.ReturnValues(1, 2, 3, 4); var result = subject.Add5(3); Expect(result).ToBe(1); result = subject.Add5(3); Expect(result).ToBe(2); result = subject.Add5(3); Expect(result).ToBe(3); result = subject.Add5(3); Expect(result).ToBe(4); }); It("should call through as configured.", () => { Jaz.SpyOn(subject, nameof(subject.Add5)).And.CallThrough(); var result = subject.Add5(3); Expect(result).ToBe(8); }); It("should throw an exception as configured.", () => { var exception = new TestException(); Jaz.SpyOn(subject, nameof(subject.Add5)).And.Throw(exception); var thrown = Expect(() => subject.Add5(3)).ToThrow <TestException>(); Expect(thrown).ToBe(exception); }); It("should support calling a generic method from a generic method.", () => { var testSubject = new TestSubject(); var result = testSubject.CallFunc(() => 5); Expect(result).ToBe(5); }); It("should support calling a generic method from a generic class.", () => { var testSubject = new TestSubject <int>(); var result = testSubject.CallFunc(() => 5); Expect(result).ToBe(5); }); It("should support calling a generic class from a generic method.", () => { var testSubject = new TestSubject(); var result = testSubject.CallFunc2(() => 5); Expect(result).ToBe(5); }); It("should support calling a method on a nested class in a generic class.", () => { var testSubject = new TestSubject <int> .TestSubjectChild(); var result = testSubject.CallFunc(() => 5); Expect(result).ToBe(5); }); }); }
public AsyncAwaitSpec() { Describe("Async Await methods", () => { Describe("from non-async method", () => { It("should call through by default.", () => { TestSubject.InternalMethod(5).GetAwaiter().GetResult(); }); }); Describe("without a result", () => { It("should call through by default.", async() => { await TestSubject.MethodOne(5); }); // spies may be changed to return Task.CompletedTask in future It("should do nothing if spied on.", () => { Jaz.SpyOn(typeof(TestSubject), nameof(TestSubject.MethodOne)); var task = TestSubject.MethodOne(5); Expect(task).ToBeDefault(); }); It("should call through as configured.", async() => { Jaz.SpyOn(typeof(TestSubject), nameof(TestSubject.MethodOne)).And.CallThrough(); await TestSubject.MethodOne(5); }); It("should throw an exception as configured.", async() => { Jaz.SpyOn(typeof(TestSubject), nameof(TestSubject.MethodOne)).And.Throw <TestException>(); await ExpectAsync(() => TestSubject.MethodOne(5)).ToThrow <TestException>(); }); It("should throw an exception as configured.", async() => { Jaz.SpyOn(typeof(TestSubject), nameof(TestSubject.MethodOne)).And.Throw <TestException>(); await ExpectAsync(async() => await TestSubject.MethodOne(5)).ToThrow <TestException>(); }); }); Describe("with a result", () => { It("should call through by default.", async() => { var result = await TestSubject.MethodTwo(5); Expect(result).ToBe("5"); }); // spies may be changed to return Task.CompletedTask in future It("should do nothing if spied on.", () => { Jaz.SpyOn(typeof(TestSubject), nameof(TestSubject.MethodTwo)); var task = TestSubject.MethodTwo(5); Expect(task).ToBeDefault(); }); It("should call through as configured.", async() => { Jaz.SpyOn(typeof(TestSubject), nameof(TestSubject.MethodTwo)).And.CallThrough(); var result = await TestSubject.MethodTwo(5); Expect(result).ToBe("5"); }); It("should throw an exception as configured.", async() => { Jaz.SpyOn(typeof(TestSubject), nameof(TestSubject.MethodOne)).And.Throw <TestException>(); await ExpectAsync(() => TestSubject.MethodOne(5)).ToThrow <TestException>(); }); It("should throw an exception as configured.", async() => { Jaz.SpyOn(typeof(TestSubject), nameof(TestSubject.MethodOne)).And.Throw <TestException>(); await ExpectAsync(async() => await TestSubject.MethodOne(5)).ToThrow <TestException>(); }); It("should return the configured value.", async() => { Jaz.SpyOn(typeof(TestSubject), nameof(TestSubject.MethodTwo)).And.ReturnValue(Task.FromResult("3")); var result = await TestSubject.MethodTwo(5); Expect(result).ToBe("3"); }); }); }); }