or
IList<ClassA> GetGridData(
string
info) {
IList<ClassA> list = LibraryX.DoSomething(info);
// web request done in here
if
(list.Count == 0)
list =
null
;
return
list;
}
IList<ClassA> GetGridData(
string
info) {
#if Testing
IList<ClassA> list = Mock.Create<IList<ClassA>>(info);
// or....
IList<ClassA> list = Mock.Create<LibraryX.ClassAFactory>().DoSomething(info);
#else
IList<ClassA> list = LibraryX.ClassAFactory.DoSomething(info);
// web request done in here
#endif
if
(list.Count == 0)
list =
null
;
return
list;
}
public
static
class
StaticClassWithPrivateStaticConstructor
{
private
static
string
_text =
"Text"
;
static
StaticClassWithPrivateStaticConstructor()
{
throw
new
Exception();
}
public
static
string
Text
{
get
{
return
_text; }
}
}
[TestMethod]
public
void
MockStaticConstructor()
{
Mock.SetupStatic(
typeof
(StaticClassWithPrivateStaticConstructor));
Assert.AreEqual(
"Text"
, StaticClassWithPrivateStaticConstructor.Text);
}
namespace MyNamespace
{
/// <
summary
>
/// Provides methods to access a database table.
/// </
summary
>
public abstract class BaseClass<
T
> where T : EntityObject
{
#region Properties
/// <
summary
>
/// Is overriden in derived classes.
/// </
summary
>
protected abstract Func<
SomeObjectContext
, T, T> CompiledQueryGetObject { get; }
/// <
summary
>
/// Context for database operations (EntityFramework)
/// </
summary
>
protected SomeObjectContext Context { get; set; }
#endregion Properties
#region Constructors
/// <
summary
>
/// Creates a new instance of type BaseClass.
/// </
summary
>
/// <
param
name
=
"context"
>The current database context.</
param
>
public BaseClass(SomeObjectContext context)
{
this.Context = context;
}
#endregion Constructors
#region Public methods
/// <
summary
>
/// Tries to retrieve the given object from the database by its unique database constraints.
/// </
summary
>
/// <
param
name
=
"importObject"
>Given entity object.</
param
>
/// <
returns
>Object if found, otherwise null</
returns
>
public T TryToGetObject(T importObject)
{
T existingObject = this.CompiledQueryGetObject(this.Context, importObject);
return existingObject;
}
#endregion Public methods
}
}
namespace MyNamespace
{
/// <
summary
>
/// Provides methods to access the SomeEntityType database table.
/// </
summary
>
public class DerivedClass : BaseClass<
SomeEntityType
>
{
#region Compiled queries
/// <
summary
>
/// A compiled query to look for an entity by its unique identifier(s) column(s).
/// </
summary
>
private static readonly Func<
SomeObjectContext
, SomeEntityType, SomeEntityType> m_LocalCompiledQueryGetObject = CompiledQuery.Compile<
SomeObjectContext
, SomeEntityType, SomeEntityType>(
(context, importSomeEntityType) => context.SomeEntityTypes.SingleOrDefault(someEntityInstance => someEntityInstance.ItemId == importSomeEntityType.ItemId));
#endregion Compiled queries
#region Constants
/// <
summary
>
/// The EntitySetName of the processor that is accessed by this class.
/// </
summary
>
private const string LocalEntitySetName = "SomeEntityType";
#endregion Constants
#region Constructor
/// <
summary
>
/// Creates a new instance of type DerivedClass.
/// </
summary
>
/// <
param
name
=
"context"
>The current database context.</
param
>
public DerivedClass(SomeObjectContext context)
: base(context)
{
}
#endregion Constructor
#region Properties
/// <
summary
>
/// Compiled query to get an object by the unique database constraint; Is overriden in derived classes.
/// </
summary
>
protected override Func<
SomeObjectContext
, SomeEntityType, SomeEntityType> CompiledQueryGetObject
{
get
{
return DerivedClass.m_LocalCompiledQueryGetObject;
}
}
#endregion Properties
}
}
namespace TestProject1
{
[TestClass]
public class UnitTest1
{
[TestMethod]
public void TestMethod1()
{
// Arrange
// -------
using (TransactionScope scope = new TransactionScope(TransactionScopeOption.RequiresNew, TimeSpan.FromSeconds(300)))
{
SomeObjectContext mockedContext = Mock.Create<
SomeObjectContext
>(Constructor.Mocked, Behavior.CallOriginal);
SomeEntityType emptyQueryObject = new SomeEntityType();
emptyQueryObject.ItemId = 1;
emptyQueryObject.CountryId = 1;
emptyQueryObject.StyleColorSetId = 1;
SomeEntityType returnThisObject = new SomeEntityType();
returnThisObject.ItemId = 2;
returnThisObject.CountryId = 2;
returnThisObject.StyleColorSetId = 2;
DerivedClass classUnderTest = new DerivedClass(mockedContext);
// System.ArgumentException: Direct null valued argument for non-public member is not supported. Use ArgExpr.IsNull<
T
>() or other members from ArgExpr wrapper class to provide your specification.
Mock.NonPublic.Arrange<
DerivedClass
>(classUnderTest, "m_LocalCompiledQueryGetObject", Arg.IsAny<
SomeObjectContext
>(), Arg.IsAny<
SomeEntityType
>())
.IgnoreArguments()
.Returns(CompiledQuery.Compile<
SomeObjectContext
, SomeEntityType, SomeEntityType>(
(paramContext, importSomeEntityType) => mockedContext.SomeEntityTypes.SingleOrDefault(someEntityInstance => someEntityInstance.ItemId == importSomeEntityType.ItemId)));
//Test method TestProject1.UnitTest1.TestMethod1 threw exception:
//System.ArgumentException: Expression of type 'System.Func`3[MyNamespace.SomeObjectContext,MyNamespace.SomeEntityType,MyNamespace.SomeEntityType]' cannot be used for return type 'MyNamespace.SomeEntityType'
Mock.NonPublic.Arrange<
SomeEntityType
>(classUnderTest, "CompiledQueryGetObject")
.IgnoreArguments()
.Returns(returnThisObject);
// This one is only possible if I set "InternalsVisibleTo" attribute and use the DerivedClass_Accessor instead
//// Test method TestProject1.UnitTest1.TestMethod1 threw exception:
//// System.ArgumentException: Direct null valued argument for non-public member is not supported. Use ArgExpr.IsNull<
T
>() or other members from ArgExpr wrapper class to provide your specification.
Mock.Arrange(() => classUnderTest.CompiledQueryGetObject(Arg.IsAny<
SomeObjectContext
>(), Arg.IsAny<
SomeEntityType
>()))
.IgnoreArguments()
.Returns(returnThisObject);
// Act
// -------
SomeEntityType receivedObject = classUnderTest.TryToGetObject(emptyQueryObject);
// Assert
// ------
Assert.IsNotNull(receivedObject);
// Some more Asserts...
}
}
private SomeEntityType returnEntity()
{
SomeEntityType returnObject = new SomeEntityType();
return returnObject;
}
}
}
Mock.SetupStatic<Assembly>();
Mock.Arrange(() => Assembly.ReflectionOnlyLoadFrom(Arg.AnyString)).Returns(Mock.Create<Assembly>());
var test = Assembly.ReflectionOnlyLoadFrom(
"Some Assembly"
);
//this will throw an exception instead of returning the mock Assembly
Mock.Partial<Assembly>().For<
string
>((s) => Assembly.ReflectionOnlyLoadFrom(s));
Mock.Arrange(() => Assembly.ReflectionOnlyLoadFrom(Arg.AnyString)).Returns(Mock.Create<Assembly>());
var test = Assembly.ReflectionOnlyLoadFrom(
"Some Assembly"
);
//this will throw an exception instead of returning the mock Assembly
[TestMethod]
public void Can_Determine_Todays_File_By_LastWrite()
{
var mockFile = Mock.Create<
FileSystemInfo
>();
Mock.Arrange(() => mockFile.FullName).Returns("c:\\MSGTRK20111001-1.log");
Mock.Arrange(() => mockFile.Name).Returns("MSGTRK20111001-1.log");
Mock.Arrange(() => mockFile.LastWriteTimeUtc).Returns(DateTime.UtcNow);
var result = FileRoutines.IsTodaysFile(mockFile);
Assert.IsTrue(result);
}
var mockFile = Mock.Create<
FileInfo
>("c:\\MSGTRK20111001-1.log");
[TestMethod()]
public void FooSubmitTest()
{
Mock.SetupStatic<
Foo
>();
Foo.Submit();
Mock.Assert(() => Foo.Submit());
}
public class Foo
{
public static void Submit()
{
throw new NotImplementedException();
}
throw new NotImplementedException();