Natural Mock + Interface

This is very easy to do using expectations that can be verified with Typemock Isolator. Here is a sample:

public interface ISomeInterface
{
  bool BooleanProperty { set; }
}

public class InterfaceConsumer
{
  private ISomeInterface _ctorParam;
  
  public InterfaceConsumer(ISomeInterface ctorParam)
  {
    this._ctorParam = ctorParam;
  }
  
  public void MethodWithParam(ISomeInterface methodParam)
  {
    methodParam.BooleanProperty = true;
  }
  
  public void MethodAllInternal()
  {
    this._ctorParam.BooleanProperty = true;
  }
}

[TestFixture]
[VerifyMocks]
public class MyTestFixture
{
  [Test]
  public void TestMethodWithParam()
  {
    ISomeInterface methodParam = RecorderManager.CreateMockedObject<ISomeInterface>();
    using(RecordExpectations r = RecorderManager.StartRecording())
    {
      methodParam.BooleanProperty = true;
      r.CheckArguments();
    }
    
    InterfaceConsumer consumer = new InterfaceConsumer(null);
    consumer.MethodWithParam(methodParam);
  }

  [Test]
  public void TestMethodAllInternal()
  {
    ISomeInterface ctorParam = RecorderManager.CreateMockedObject<ISomeInterface>();
    using(RecordExpectations r = RecorderManager.StartRecording())
    {
      ctorParam.BooleanProperty = true;
      r.CheckArguments();
    }
    
    InterfaceConsumer consumer = new InterfaceConsumer(ctorParam);
    consumer.MethodAllInternal();
  }
}

In the above examples, you can see how I have an interface with just a setter, and a couple of different ways to get the dependency in there - in one case, a method that takes a parameter; in another case, a constructor that gets it passed in.

In either case, the way you test it is by setting expectations in the recorder block - you'll see that I'm calling "CheckArguments" to verify the value that the property is being set to as soon as the mocks get verified (via the VerifyMocks attribute).

If you have a factory or some other mechanism that's inserting the dependency (maybe you're calling a static method to generate the instance of the interface you're using, etc.) then it just means a couple of additional mocks to set up - you can mock the return value of the static factory method to return your mock interface implementation, for example.

In any case, it's the "CheckArguments" that does the magic.

Thanks for the example Travis, accurate as ever :)

love_luv, may I recommend using the AAA API? We released this with version 5.0 not long ago and it should create more readable tests.

In your case you can use our verification API to verify the property set with the expected value:

// create fake instance of the view implementing the interface
MyView fake = Isolate.Fake.Instance<MyView>(Members.CallOriginal);

// call the method under test 
fake.MethodUnderTest();

// verify the AddProductAllow property was set to be true
Isolate.Verify.WasCalledWithExactArguments(() => fake.AddProductAllow = true);

Go ahead and give it a try.

Thanks,
Doron
Typemock Support Team

:arrow: using the new API and Travis example, the test will be:

[Test,Isolated]
public void TestMethodAllInternal()
{
   ISomeInterface view = Isolate.Fake.Instance<ISomeInterface>(Members.ReturnRecursiveFakes);
   
   InterfaceConsumer consumer = new InterfaceConsumer(view);
   consumer.MethodAllInternal();

   // verify the AddProductAllow property was set to true
   Isolate.Verify.WasCalledWithExactArguments(() => view.AddProductAllow = true); 
} 

Nice. This works, but I have another issue now:

lets say in following method:

public void SomeMethod()
{
// Initialize Bool Property
BooleanProperty = true;

if (Condition X)
BooleanProperty = false;

if (Condition Y)
BooleanProperty = true;
}

Now if I use Check Argument, I will have to perform check twice assuming I am satisfying Condition X or Condition Y. Otherwise Typemock tells me "there is one more expected call".

I don't want to check argument for initialize

I want to check arguments for Condition X or Condition Y.

Thanks,

This is very easy to do using expectations that can be verified with Typemock Isolator. Here is a sample:

public interface ISomeInterface
{
  bool BooleanProperty { set; }
}

public class InterfaceConsumer
{
  private ISomeInterface _ctorParam;
  
  public InterfaceConsumer(ISomeInterface ctorParam)
  {
    this._ctorParam = ctorParam;
  }
  
  public void MethodWithParam(ISomeInterface methodParam)
  {
    methodParam.BooleanProperty = true;
  }
  
  public void MethodAllInternal()
  {
    this._ctorParam.BooleanProperty = true;
  }
}

[TestFixture]
[VerifyMocks]
public class MyTestFixture
{
  [Test]
  public void TestMethodWithParam()
  {
    ISomeInterface methodParam = RecorderManager.CreateMockedObject<ISomeInterface>();
    using(RecordExpectations r = RecorderManager.StartRecording())
    {
      methodParam.BooleanProperty = true;
      r.CheckArguments();
    }
    
    InterfaceConsumer consumer = new InterfaceConsumer(null);
    consumer.MethodWithParam(methodParam);
  }

  [Test]
  public void TestMethodAllInternal()
  {
    ISomeInterface ctorParam = RecorderManager.CreateMockedObject<ISomeInterface>();
    using(RecordExpectations r = RecorderManager.StartRecording())
    {
      ctorParam.BooleanProperty = true;
      r.CheckArguments();
    }
    
    InterfaceConsumer consumer = new InterfaceConsumer(ctorParam);
    consumer.MethodAllInternal();
  }
}

In the above examples, you can see how I have an interface with just a setter, and a couple of different ways to get the dependency in there - in one case, a method that takes a parameter; in another case, a constructor that gets it passed in.

In either case, the way you test it is by setting expectations in the recorder block - you'll see that I'm calling "CheckArguments" to verify the value that the property is being set to as soon as the mocks get verified (via the VerifyMocks attribute).

If you have a factory or some other mechanism that's inserting the dependency (maybe you're calling a static method to generate the instance of the interface you're using, etc.) then it just means a couple of additional mocks to set up - you can mock the return value of the static factory method to return your mock interface implementation, for example.

In any case, it's the "CheckArguments" that does the magic.

Nice. This works, but I have another issue now:

lets say in following method:

public void SomeMethod()
{
// Initialize Bool Property
BooleanProperty = true;

if (Condition X)
BooleanProperty = false;

if (Condition Y)
BooleanProperty = true;
}

Now if I use Check Argument, I will have to perform check twice assuming I am satisfying Condition X or Condition Y. Otherwise Typemock tells me "there is one more expected call".

I don't want to check argument for initialize

I want to check arguments for Condition X or Condition Y.

Thanks,

This is very easy to do using expectations that can be verified with Typemock Isolator. Here is a sample:

public interface ISomeInterface
{
  bool BooleanProperty { set; }
}

public class InterfaceConsumer
{
  private ISomeInterface _ctorParam;
  
  public InterfaceConsumer(ISomeInterface ctorParam)
  {
    this._ctorParam = ctorParam;
  }
  
  public void MethodWithParam(ISomeInterface methodParam)
  {
    methodParam.BooleanProperty = true;
  }
  
  public void MethodAllInternal()
  {
    this._ctorParam.BooleanProperty = true;
  }
}

[TestFixture]
[VerifyMocks]
public class MyTestFixture
{
  [Test]
  public void TestMethodWithParam()
  {
    ISomeInterface methodParam = RecorderManager.CreateMockedObject<ISomeInterface>();
    using(RecordExpectations r = RecorderManager.StartRecording())
    {
      methodParam.BooleanProperty = true;
      r.CheckArguments();
    }
    
    InterfaceConsumer consumer = new InterfaceConsumer(null);
    consumer.MethodWithParam(methodParam);
  }

  [Test]
  public void TestMethodAllInternal()
  {
    ISomeInterface ctorParam = RecorderManager.CreateMockedObject<ISomeInterface>();
    using(RecordExpectations r = RecorderManager.StartRecording())
    {
      ctorParam.BooleanProperty = true;
      r.CheckArguments();
    }
    
    InterfaceConsumer consumer = new InterfaceConsumer(ctorParam);
    consumer.MethodAllInternal();
  }
}

In the above examples, you can see how I have an interface with just a setter, and a couple of different ways to get the dependency in there - in one case, a method that takes a parameter; in another case, a constructor that gets it passed in.

In either case, the way you test it is by setting expectations in the recorder block - you'll see that I'm calling "CheckArguments" to verify the value that the property is being set to as soon as the mocks get verified (via the VerifyMocks attribute).

If you have a factory or some other mechanism that's inserting the dependency (maybe you're calling a static method to generate the instance of the interface you're using, etc.) then it just means a couple of additional mocks to set up - you can mock the return value of the static factory method to return your mock interface implementation, for example.

In any case, it's the "CheckArguments" that does the magic.

Hi,

I'm not sure i understood you correctly, but according to what I think look at the following example:
Ive added the following method to InterfaceConsumer:

public void SomeComplexMethod()
{
    //init
    _ctorParam.BooleanProperty = true; //this call we dont care about

    if (true)
        _ctorParam.BooleanProperty = false; //this we want to verify
    if (true)
        _ctorParam.BooleanProperty = true; //we also want to verify this
}

as you can see there are 3 calls to the property set and i would like to make sure that only the last 2 have the correct arguments.
here is how the test would be written:

[TestMethod]
public void TestSeveralCallToSet()
{
    ISomeInterface methodParam = RecorderManager.CreateMockedObject<ISomeInterface>();
    using (RecordExpectations r = new RecordExpectations())
    {
        methodParam.BooleanProperty = true;
        methodParam.BooleanProperty = false;
        r.CheckArguments();
        methodParam.BooleanProperty = true;
        r.CheckArguments();
    }
    InterfaceConsumer consumer = new InterfaceConsumer(methodParam);
    consumer.SomeComplexMethod();
}

:!: the key thing to understand here is that the statement: r.CheckArguments(); only apply to the previous recorded expectation. and not to all calls.

I hope this is what you intended if not let me know.