How do you use Moq to mock a simple interface?
Okay, I have a business logic class like this:
Note: For context, Vendor Briefs are simple entities that describe a "download" for a PDF document.
/// <summary>
/// Houses business level functions for dealing with vendor briefs.
/// </summary>
public class VendorBriefController : IVendorBriefController
{
/// <summary>
/// Vendor brief controller requires an instance of IVendorBriefRepository.
/// </summary>
IVendorBriefRepository _vendorBriefRepository;
/// <summary>
/// Initializes an instance of VendorBriefController.
/// </summary>
public VendorBriefController(IVendorBriefRepository vendorBriefRepository)
{
_vendorBriefRepository = vendorBriefRepository;
}
/// <summary>
/// Get a list of string filters for vendor briefs.
/// </summary>
/// <returns>A list of string filters.</returns>
public dynamic GetFilters()
{
List<string> filters = new List<string>
{
"All",
"Active",
"Inactive"
};
return filters;
}
/// <summary>
/// Retrieve vendor brief entity from the repository by its unique ID.
/// </summary>
/// <param name="Id">The unique ID of the vendor brief.</param>
/// <returns>A vendor brief entity.</returns>
public VendorBrief GetVendorBriefForEditing(int Id)
{
var vendorBrief = _vendorBriefRepository开发者_JAVA百科.GetVendorBrief(Id);
return vendorBrief;
}
/// <summary>
/// Get a dynamic list of vendor briefs from the repository based on the supplied filter.
/// </summary>
/// <param name="filter">The filter to be used when retrieving vendor briefs.</param>
/// <returns>A dynamic sorted & filtered list of vendor briefs to be displayed in a grid view.</returns>
public dynamic GetVendorBriefList(string filter)
{
IEnumerable<VendorBrief> results = _vendorBriefRepository.GetVendorBriefs();
switch (filter)
{
default:
results = _vendorBriefRepository.GetVendorBriefs();
break;
case "Active":
results = _vendorBriefRepository.GetVendorBriefs(true);
break;
case "Inactive":
results = _vendorBriefRepository.GetVendorBriefs(false);
break;
}
return from x in results
orderby x.DisplayOrder
select new
{
ID = x.VendorBriefID,
Title = x.Title,
Active = x.IsActive,
DisplayOrder = x.DisplayOrder
};
}
/// <summary>
/// Save changes to the underlying repository in order to persist changes made to self-tracking vendor brief entities.
/// </summary>
/// <param name="vendorBrief"></param>
public void EditVendorBrief(VendorBrief vendorBrief)
{
_vendorBriefRepository.SaveChanges();
}
/// <summary>
/// Remove a vendor brief from the underlying repository.
/// </summary>
/// <param name="vendorBrief">The vendor brief to be removed.</param>
public void DeleteVendorBrief(VendorBrief vendorBrief)
{
_vendorBriefRepository.DeleteVendorBrief(vendorBrief);
_vendorBriefRepository.SaveChanges();
}
/// <summary>
/// Add a vendor brief to the underlying repository.
/// </summary>
/// <param name="vendorBrief">The vendor brief to be added.</param>
public void AddVendorBrief(VendorBrief vendorBrief)
{
_vendorBriefRepository.AddVendorBrief(vendorBrief);
_vendorBriefRepository.SaveChanges();
}
}
I am taking my first steps into unit testing and I'm learning about Moq. I don't want a whole unit test class written for this (unless you feel like it of course :P) but a simple sample will do. I'm assuming I need to "mock" IVendorBriefRepository
so that I can pass it into the constructor when building my controller (not to be confused with mvc controllers), but I'm not sure how to do it. A sample using some of my own code will really help me get started.
Thanks in advance!
Something like this would test DeleteVendorBrief, for example.
Mock<IVendorBriefRepository> mock = new Mock<IVendorBriefRepository>();
VendorBriefController controller = new VendorBriefController(mock.Object);
VendorBrief brief = new VendorBrief();
controller.DeleteVendorBrief(brief);
mock.Verify(f=>f.DeleteVendorBrief(brief));
mock.Verify(f=>f.SaveChanges());
If you don't need to setup any special behavior for your Mocked object and just want a faked object to pass into a simple unit test, you can also use the shorter Mock.Of<T>()
syntax.
The benefit here is that you don't need to remember to pass in the .Object
.
Taking Brook's code as a reference:
Mock<IVendorBriefRepository> mock = Mock.Of<IVendorBriefRepository>();
VendorBriefController controller = new VendorBriefController(mock);
//...
Especially if your code uses Dependency Injection and pass in a lot of dependencies, this syntax makes the code cleaner to read.
精彩评论