Scribd Logo
Upload

Welcome to Scribd!

  • 9K views

    Rhino Mocks AAAQuick Reference

    Uploaded by

    svengrand
    The document provides a quick reference to Rhino Mocks AAA syntax for creating and working with mocks and stubs. It covers creating mocks and stubs, setting expectations and verifying calls for methods, properties, events, exceptions, constraints, ordered expectations, and more.

    Copyright:

    Attribution Non-Commercial (BY-NC)
    Download as PDF, TXT or read online from Scribd

    Rhino Mocks AAAQuick Reference

    Uploaded by

    svengrand
    9K views4 pages
    The document provides a quick reference to Rhino Mocks AAA syntax for creating and working with mocks and stubs. It covers creating mocks and stubs, setting expectations and verifying calls for methods, properties, events, exceptions, constraints, ordered expectations, and more.

    Original Title

    RhinoMocksAAAQuickReference

    Copyright

    © Attribution Non-Commercial (BY-NC)

    Available Formats

    PDF, TXT or read online from Scribd

    Did you find this document useful?

    Is this content inappropriate?

    The document provides a quick reference to Rhino Mocks AAA syntax for creating and working with mocks and stubs. It covers creating mocks and stubs, setting expectations and verifying calls for methods, properties, events, exceptions, constraints, ordered expectations, and more.

    Copyright:

    Attribution Non-Commercial (BY-NC)
    Download as PDF, TXT or read online from Scribd
    Download as pdf or txt
    9K views4 pages

    Rhino Mocks AAAQuick Reference

    Uploaded by

    svengrand
    The document provides a quick reference to Rhino Mocks AAA syntax for creating and working with mocks and stubs. It covers creating mocks and stubs, setting expectations and verifying calls for methods, properties, events, exceptions, constraints, ordered expectations, and more.

    Copyright:

    Attribution Non-Commercial (BY-NC)
    Download as PDF, TXT or read online from Scribd
    Download as pdf or txt
    You are on page 1of 4
    At a glance
    Powered by AI
    The document discusses various syntax and features for creating and interacting with mocks and stubs using Rhino Mocks, including setting expectations, verifying calls, and constraining arguments.

    The document shows that mocks and stubs can be created using MockRepository.GenerateMock or MockRepository.GenerateStub and configured to return values or throw exceptions for called methods.

    The document demonstrates common ways of setting expectations like Expect and Stub and verifying calls using AssertWasCalled and VerifyAllExpectations. It also shows how to repeat calls, handle out/ref parameters and set the call order.

    Rhino Mocks AAA Syntax Quick Reference

    Create Mocks / Stubs


    Mock
    IFoo mock = MockRepository. GenerateMock<IFoo>();

    Stub
    IFoo stub = MockRepository. GenerateStub<IFoo>();

    Mock or Stub
    IFoo foo = MockRepository. GenerateMock<IFoo>();

    or
    IFoo foo = MockRepository. GenerateStub<IFoo>();

    Method Call
    Assert
    foo.AssertWasCalled(x=>x.Do());

    Method Call with Return Value


    Arrange Act Assert
    mock.Expect(x => x.Age()).Return(9); mock.VerifyAllExpectations(); foo.Stub(x => x.Age()).Return(9); foo.AssertWasCalled(x=>x.Age());

    Property Getter
    Arrange Act Assert
    mock.Expect(x => x.Name).Return("Bob"); mock.VerifyAllExpectations(); mock.Stub(x => x.Name).Return("Bob"); mock.AssertWasCalled( x => { var ignored = x.Name; });

    Property Setter
    Arrange
    mock.Expect(x => x.Name = "Bob");

    or
    mock.Expect( x => x.Name = Arg.Is("Bob"));

    or
    mock.Expect( x => x.Name = Arg<string>.Is.NotNull);

    Act Assert

    mock.VerifyAllExpectations();

    mock.AssertWasCalled( x => x.Name = "Bob");

    or
    mock.AssertWasCalled( x => x.Name = Arg.Is("Bob"));

    or
    mock.AssertWasCalled( x => x.Name = Arg<string>.Is.NotNull);

    Repetition
    Arrange Act Assert
    mock.Expect(x => x.Do()).Repeat.Once(); mock.VerifyAllExpectations(); foo.AssertWasCalled(x => x.Do(), y => y.Repeat.Once());

    Once At least once Twice Exactly 2 times Between 1 and 3 times

    .Repeat.Once(); .Repeat.AtLeastOnce(); .Repeat.Twice(); .Repeat.Times(2); .Repeat.Times(1,3);

    y => y.Repeat.Once() y => y.Repeat.AtLeastOnce() y => y.Repeat.Twice() y => y.Repeat.Times(2) y => y.Repeat.Times(1,3)

    Never
    Arrange Act Assert
    mock.Expect(x => x.Do()).Repeat.Never(); mock.VerifyAllExpectations(); foo.AssertWasNotCalled(x => x.Do());

    Multiple Different Return Values


    Arrange Act / Assert
    foo.Stub(x => x.Age()).Return(20).Repeat.Once(); foo.Stub(x => x.Age()).Return(25).Repeat.Twice(); Assert.AreEqual(20, foo.Age()); Assert.AreEqual(25, foo.Age()); Assert.AreEqual(25, foo.Age());

    Equal Constraint
    plain short long
    foo.AssertWasCalled(x => x.Do("Bob")); foo.AssertWasCalled(x => x.Do(Arg.Is("Bob"))); foo.AssertWasCalled(x => x.Do(Arg<string>.Is.Equal("Bob")));

    Constraints in Expect() and Stub()


    Arrange
    mock.Expect(x => x.Calc(Arg.Is("Bob"))). Return(1); mock.Expect(x => x.Calc(Arg.Is("Joe"))). Return(2); foo.Stub(x => x.Calc(Arg.Is("Bob"))). Return(1); foo.Stub(x => x.Calc(Arg.Is("Joe"))). Return(2); foo.AssertWasCalled( x => x.Calc(Arg.Is("Bob"))); foo.AssertWasCalled( x => x.Calc(Arg.Is("Joe")));

    Act Assert

    mock.VerifyAllExpectations();

    Constraints
    Is equal? Is not equal? Is same? Is not same? Is null? Is greater than 1? Is greater than or equal 2? Is less than 3? Is less than or equal 2? Is argument of type SpecialPoint? Is Joe element of the collection? Is Sam the third element (index 2) of the collection? Has the collection three elements? Has the collection exactly the elements Bob, Joe and Sam in this order? Contains the collection the elements Joe, Sam and Bob in an arbitrary order?
    Arg<Point>.Is.Equal(new Point(1, 2)) Arg<Point>.Is.NotEqual(new Point(2, 2)) Arg<Point>.Is.Same(point) Arg<Point>.Is.NotSame(new Point(1, 2)) Arg<string>.Is.Null Arg<int>.Is.GreaterThan(1) Arg<int>.Is.GreaterThanOrEqual(2) Arg<int>.Is.LessThan(3) Arg<int>.Is.LessThanOrEqual(2) Arg<SpecialPoint>.Is.TypeOf

    Arg<ICollection<int>>.List.IsIn("Joe")

    Arg<ICollection<int>>.List.Element(2, Is.Equal("Sam"))

    Arg<ICollection<int>>.List.Count(Is.Equal(3))

    Arg<ICollection<int>>.List.Equal(new string[] { "Bob", "Joe", "Sam" })

    Arg<ICollection<int>>.List.ContainsAll(new string[] { "Joe", "Sam", "Bob" })

    Ignore Arguments
    Is.Anything Is.Anything IgnoreArguments() IgnoreArguments()
    mock.Expect( x => x.Do(Arg<string>.Is.Anything, Arg<int>.Is.Anything)); foo.AssertWasCalled( x => x.Do(Arg<string>.Is.Anything, Arg<int>.Is.Anything)); mock.Expect( x => x.Do("bye", 2)).IgnoreArguments(); foo.AssertWasCalled( x => x.Do("bye", 2),y=>y.IgnoreArguments());

    Plain Equal Constraint Limitation


    Two plain constraints are ok Cant mix plain with others Cant mix plain with others
    foo.AssertWasCalled(x => x.Do("hello", 2)); foo.AssertWasCalled( x => x.Do(Arg.Is("hello"), Arg<int>.Is.GreaterThan(1))); foo.AssertWasCalled( x => x.Do(Arg<string>.Is.Anything, Arg.Is(2)));

    Complex Constraints
    Ensure that Do(arg) was called with arg starting with a B or a C
    foo.AssertWasCalled(x => x.Do(Arg<string>.Matches( y => y.StartsWith("B", StringComparison.InvariantCulture) || y.StartsWith("C", StringComparison.InvariantCulture))));

    Throwing Exceptions
    Arrange
    foo.Stub(x => x.Do()).Throw(new IOException());

    Event Registration
    Ensure that some method was registered for the event:
    event Action Done foo.AssertWasCalled(x => x.Done += Arg<Action>.Is.Anything);

    Raise EventHandler Events


    Instruct the mock/stub to raise the event:
    event EventHandler Ready foo.Raise(x => x.Ready += null, foo, EventArgs.Empty);

    Raise Other Events


    Instruct the mock/stub to raise the event:
    event Action<int,int> Finished const int arg1 = 2; const int arg2 = 4; foo.Raise(x => x.Finished += null, arg1, arg2);

    Mock with Property Behavior


    mock.Stub(x => x.Name).PropertyBehavior(); mock.Name = "Bob"; Assert.AreEqual("Bob", mock.Name);

    Mocks/Stubs with Behavior


    foo.Stub(x => x.Transform(Arg<string>.Is.Anything)).Return(null). WhenCalled(x => x.ReturnValue = ((string)(x.Arguments[0])).ToUpper()); Assert.AreEqual("BOB", foo.Transform("Bob"));

    Return Out and Ref Parameters


    Out parameter Ref parameter
    foo.Expect(x => x.Do(out Arg<int>.Out(3).Dummy)); foo.Expect(x => x.DoRef(ref Arg<int>.Ref(Is.Anything(), 3).Dummy));

    Verify Order of Expectations (pre AAA syntax required)


    IFile fileMock = MockRepository.GenerateMock<IFile>(); using (fileMock.GetMockRepository().Ordered()) { // Copy() should be called before Delete() fileMock.Expect(x => x.Copy(Arg.Is("test.txt"), Arg<string>.Is.Anything)); fileMock.Expect(x => x.Delete(Arg.Is("test.txt"))); } using (fileMock.GetMockRepository().Playback()) { // Act }

    You might also like

    pFad - Phonifier reborn

    Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

    Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


    Alternative Proxies:

    Alternative Proxy

    pFad Proxy

    pFad v3 Proxy

    pFad v4 Proxy