> I found this post which appears to answer my quandary of the day:

> http://groups.google.com/group/RhinoMocks/browse_thread/thread/ac6391...

> To pull a quote from the post:
> "Dynamic Mock will ignore any unknown calls that your make to it.
> Therefor, setting up any Repeat means that you are setting a minimum,
> not a hard limit."

> What I'm wondering is whether or not that is still true. I understand
> the desire to have a DynamicMock and to not want to set up each and
> every call on it. It seems though that once an expectation is stated,
> the "dynamic" component of that call would be lost.

> This code demonstates the issue I'm talking about. I would expect the
> test to fail, but it passes. If I change the DynamicMock to
> CreateMock, the test fails as one would expect.

> public interface IMyTestInterface
> {
>   void MyTestMethod();
> }

> [TestFixture]
> public class RepeatTests
> {
>   [Test]
>   public void Test()
>   {
>      var mockery = new MockRepository();
>      var myMock = mockery.DynamicMock<IMyTestInterface>();

>      using (mockery.Record())
>      {
>         myMock.MyTestMethod();
>         LastCall.Repeat.Once();
>      }
>      using (mockery.Playback())
>      {
>         myMock.MyTestMethod();
>         myMock.MyTestMethod();
>      }
>   }
> }

> I wouldn't argue with the default behavior of a dynamic mock at all.
> That's why we like it so much. The interesting part to me I guess is
> the fact that my stating "LastCall.Repeat.Once()" doesn't undo the
> dynamic behavior of that particular method call on the dynamic mock.
> If that can't happen, I think I would rather get an exception that
> tells me that I can't specify "Once" on a dynamic mock, than just have
> the test pass as if everything is working as expected.

> Not a huge deal by any means. The production code has been updated and
> is working like a champ now.

> On May 17, 2:08 am, "Ayende Rahien" <aye...@ayende.com> wrote:
> > The key difference between dynamic and strict mocks is how they treat
> > unexpected method calls.In your test, the second method call is not
> > expected, and is ignored.

> Repeat.One() is actually the default behavior.

> The way it works is:

>   [Test]
>   public void Test()
>   {
>      var mockery = new MockRepository();
>      var myMock = mockery.DynamicMock<IMyTestInterface>();

>      using (mockery.Record())
>      {
> // create an expectation that this method would be call once
>         myMock.MyTestMethod();

> // doesn't really do anything
>         LastCall.Repeat.Once();
>      }
>      using (mockery.Playback())
>      {
> // match to the first expectation and satisfy it.
>         myMock.MyTestMethod();
> // back to usual behavior
>         myMock.MyTestMethod();
>      }

> What you seem to want is something like this

> On Sun, May 18, 2008 at 10:51 PM, Rob <rten...@gmail.com> wrote:

>> I wouldn't argue with the default behavior of a dynamic mock at all.
>> That's why we like it so much. The interesting part to me I guess is
>> the fact that my stating "LastCall.Repeat.Once()" doesn't undo the
>> dynamic behavior of that particular method call on the dynamic mock.
>> If that can't happen, I think I would rather get an exception that
>> tells me that I can't specify "Once" on a dynamic mock, than just have
>> the test pass as if everything is working as expected.

>> Not a huge deal by any means. The production code has been updated and
>> is working like a champ now.

>> On May 17, 2:08 am, "Ayende Rahien" <aye...@ayende.com> wrote:
>> > The key difference between dynamic and strict mocks is how they treat
>> > unexpected method calls.In your test, the second method call is not
>> > expected, and is ignored.

> MockRepository mocks = new MockRepository();
> IDemo demo = mocks.DynamicMock<IDemo>();
> demo.VoidNoArgs();
> LastCall.Repeat.Once();// doesn't realy matter
> demo.VoidNoArgs();
> LastCall.Repeat.Never();

> mocks.ReplayAll();

> demo.VoidNoArgs();//should work

> demo.VoidNoArgs();// will fail

> On Wed, May 21, 2008 at 9:49 PM, Ayende Rahien <aye...@ayende.com> wrote:
> > The problem here is that we have different models on what is going on.

> > Repeat.One() is actually the default behavior.

> > The way it works is:

> >   [Test]
> >   public void Test()
> >   {
> >      var mockery = new MockRepository();
> >      var myMock = mockery.DynamicMock<IMyTestInterface>();

> >      using (mockery.Record())
> >      {
> > // create an expectation that this method would be call once
> >         myMock.MyTestMethod();

> > // doesn't really do anything
> >         LastCall.Repeat.Once();
> >      }
> >      using (mockery.Playback())
> >      {
> > // match to the first expectation and satisfy it.
> >         myMock.MyTestMethod();
> > // back to usual behavior
> >         myMock.MyTestMethod();
> >      }

> > What you seem to want is something like this

> > On Sun, May 18, 2008 at 10:51 PM, Rob <rten...@gmail.com> wrote:

> >> I wouldn't argue with the default behavior of a dynamic mock at all.
> >> That's why we like it so much. The interesting part to me I guess is
> >> the fact that my stating "LastCall.Repeat.Once()" doesn't undo the
> >> dynamic behavior of that particular method call on the dynamic mock.
> >> If that can't happen, I think I would rather get an exception that
> >> tells me that I can't specify "Once" on a dynamic mock, than just have
> >> the test pass as if everything is working as expected.

> >> Not a huge deal by any means. The production code has been updated and
> >> is working like a champ now.

> >> On May 17, 2:08 am, "Ayende Rahien" <aye...@ayende.com> wrote:
> >> > The key difference between dynamic and strict mocks is how they treat
> >> > unexpected method calls.In your test, the second method call is not
> >> > expected, and is ignored.- Hide quoted text -

> - Show quoted text -

> I just wanted to say that I really appreciate the feedback.  I know
> all of our time is valuable.

> I'm just arguing for the sake of argument at this point. I know how to
> use your framework as intended now and still think it's completely
> excellent to use. So, with that said, one more go at it...

> I think I would still assert that the definition of Once is "Once and
> only once".  This is especially so with the presence of another method
> called "AtLeastOnce".

> Now, given that assertion, if someone creates a dynamic mock that
> ignores unexpected calls, and then turns around and says "Once" on one
> of the methods of that mock, we're left with a contradiction I think.
> For that one method, did the user mean dynamic or did he/she mean
> once? I personally would guess that the user meant "dynamic for
> everything on the mock except the one where I was specific."

> Have an excellent day and thanks again.
> Rob

> On May 21, 1:49 pm, "Ayende Rahien" <aye...@ayende.com> wrote:
> > Like this:

> > MockRepository mocks = new MockRepository();
> > IDemo demo = mocks.DynamicMock<IDemo>();
> > demo.VoidNoArgs();
> > LastCall.Repeat.Once();// doesn't realy matter
> > demo.VoidNoArgs();
> > LastCall.Repeat.Never();

> > mocks.ReplayAll();

> > demo.VoidNoArgs();//should work

> > demo.VoidNoArgs();// will fail

> > On Wed, May 21, 2008 at 9:49 PM, Ayende Rahien <aye...@ayende.com>
> wrote:
> > > The problem here is that we have different models on what is going on.

> > > Repeat.One() is actually the default behavior.

> > > The way it works is:

> > >   [Test]
> > >   public void Test()
> > >   {
> > >      var mockery = new MockRepository();
> > >      var myMock = mockery.DynamicMock<IMyTestInterface>();

> > >      using (mockery.Record())
> > >      {
> > > // create an expectation that this method would be call once
> > >         myMock.MyTestMethod();

> > > // doesn't really do anything
> > >         LastCall.Repeat.Once();
> > >      }
> > >      using (mockery.Playback())
> > >      {
> > > // match to the first expectation and satisfy it.
> > >         myMock.MyTestMethod();
> > > // back to usual behavior
> > >         myMock.MyTestMethod();
> > >      }

> > > What you seem to want is something like this

> > > On Sun, May 18, 2008 at 10:51 PM, Rob <rten...@gmail.com> wrote:

> > >> I wouldn't argue with the default behavior of a dynamic mock at all.
> > >> That's why we like it so much. The interesting part to me I guess is
> > >> the fact that my stating "LastCall.Repeat.Once()" doesn't undo the
> > >> dynamic behavior of that particular method call on the dynamic mock.
> > >> If that can't happen, I think I would rather get an exception that
> > >> tells me that I can't specify "Once" on a dynamic mock, than just have
> > >> the test pass as if everything is working as expected.

> > >> Not a huge deal by any means. The production code has been updated and
> > >> is working like a champ now.

> > >> On May 17, 2:08 am, "Ayende Rahien" <aye...@ayende.com> wrote:
> > >> > The key difference between dynamic and strict mocks is how they
> treat
> > >> > unexpected method calls.In your test, the second method call is not
> > >> > expected, and is ignored.- Hide quoted text -

> > - Show quoted text -