private SPItemEventProperties CreateMockSpItemEventProperties(string title, string code, DateTime enrollmentDate, DateTime startDate, DateTime endDate, float courseCost)
{
//Create any mock objects we'll need here
SPItemEventProperties spItemEventProperties = RecorderManager.CreateMockedObject <SPItemEventProperties>();
SPWeb web = RecorderManager.CreateMockedObject <SPWeb>();
SPItemEventDataCollection afterProperties = RecorderManager.CreateMockedObject <SPItemEventDataCollection>();
//record our main expectations
using (RecordExpectations recorder = RecorderManager.StartRecording())
{
object obj = spItemEventProperties.AfterProperties;
recorder.Return(afterProperties).RepeatAlways();
afterProperties["Title"] = string.Empty;
afterProperties["TrainingCourseCode"] = string.Empty;
spItemEventProperties.OpenWeb();
recorder.Return(web);
obj = spItemEventProperties.ListItem[new Guid(Fields.TrainingCourseCode)];
recorder.Return("12345678").RepeatAlways();
}
//Record our expectations for our AfterProperties collection
MockHelper.RecordSPItemEventDataCollection(afterProperties, "Title", title);
MockHelper.RecordSPItemEventDataCollection(afterProperties, "TrainingCourseCode", code);
MockHelper.RecordSPItemEventDataCollection(afterProperties, "TrainingCourseEnrollmentDate", enrollmentDate);
MockHelper.RecordSPItemEventDataCollection(afterProperties, "TrainingCourseStartDate", startDate);
MockHelper.RecordSPItemEventDataCollection(afterProperties, "TrainingCourseEndDate", endDate);
MockHelper.RecordSPItemEventDataCollection(afterProperties, "TrainingCourseCost", courseCost);
return(spItemEventProperties);
}
private SPListItem CreateMockSPListItem(SPListItemMockType mockType, string status)
{
SPListItem listItem = RecorderManager.CreateMockedObject <SPListItem>();
switch (mockType)
{
case SPListItemMockType.Populate:
using (RecordExpectations recorder = RecorderManager.StartRecording())
{
recorder.ExpectAndReturn(listItem.ID, 1);
}
break;
case SPListItemMockType.StatusCheck:
using (RecordExpectations recorder = RecorderManager.StartRecording())
{
recorder.ExpectAndReturn(listItem[new Guid(Fields.RegistrationStatus)], status);
}
break;
default:
using (RecordExpectations recorder = RecorderManager.StartRecording())
{
recorder.ExpectAndReturn(listItem.ID, 1);
}
break;
}
return(listItem);
}
private SPWeb GetMockSPWeb(bool userFound)
{
var web = RecorderManager.CreateMockedObject <SPWeb>();
var user = RecorderManager.CreateMockedObject <SPUser>();
if (!userFound)
{
user = null;
}
using (RecordExpectations recorder = RecorderManager.StartRecording())
{
SPUser spUser = web.SiteUsers.GetByID(12345);
recorder.Return(user);
}
if (user != null)
{
using (RecordExpectations recorder = RecorderManager.StartRecording())
{
string userName = user.Name;
recorder.Return("MockUserName").RepeatAlways();
string userEmail = user.LoginName;
recorder.Return("*****@*****.**").RepeatAlways();
}
}
return(web);
}
public void ScenarioPlayTest()
{
using (RecorderManager.NewRecordingSession("test"))
{
// Make a callee, not really used but needed to record a constructor call:
MockingProxy callee = new MockingProxy(typeof(Sample.Account), null, "m1");
// Push some calls in the recorder:
MockableCall lastcall;
CurrentRecorder.RecordCall(lastcall = new MockableCall(callee, typeof(Sample.Account).GetConstructor(new Type[] { typeof(Sample.CurrencyUnit) }), null));
lastcall.SetConstructionResult("acc");
CurrentRecorder.RecordCall(lastcall = new MockableCall(callee, typeof(Sample.Account).GetMethod("Deposit"), null));
lastcall.SetCallResult();
CurrentRecorder.RecordCall(lastcall = new MockableCall(callee, typeof(Sample.Account).GetMethod("Withdraw"), null));
lastcall.SetCallResult();
CurrentRecorder.RecordCall(lastcall = new MockableCall(callee, typeof(Sample.Account).GetProperty("Balance").GetGetMethod(), null));
lastcall.SetCallResult(10m);
}
using (RecorderManager.NewPlayBackSession("test", true))
{
// Register types to mock:
MockService.AddTypeToMock(typeof(Sample.Account));
// Play scenario:
Sample.Account acc = new Sample.Account(Sample.CurrencyUnit.EUR);
acc.Deposit(100m);
acc.Withdraw(25m);
Decimal balance = acc.Balance;
// Checks:
Assert.AreEqual(10m, balance); // Does not match the scenario, but the mocking result !
}
}
public void RecordingBeginEnd00Test()
{
RecorderManager.BeginRecording("test");
Assert.IsTrue(RecorderManager.IsRecording);
RecorderManager.EndRecording();
Assert.IsFalse(RecorderManager.IsRecording);
}
public void Activate <T>(T controller, HandleInfo handleInfo) where T : ViewController
{
View view = controller.View;
MockedEvent controlsCreated = null;
MockedEvent currentObjectChanged = null;
if (handleInfo != null)
{
if (handleInfo.ControlsCreated)
{
using (RecorderManager.StartRecording()) {
view.ControlsCreated += null;
}
controlsCreated = RecorderManager.LastMockedEvent;
}
if (handleInfo.CurrentObjectChanged)
{
using (RecorderManager.StartRecording()) {
view.CurrentObjectChanged += null;
}
currentObjectChanged = RecorderManager.LastMockedEvent;
}
}
controller.Active.Clear();
controller.Active[""] = true;
if (controlsCreated != null)
{
controlsCreatedHandler = (EventHandler)controlsCreated.GetEventHandle();
}
if (currentObjectChanged != null)
{
currentObjectChangedHandler = (EventHandler)currentObjectChanged.GetEventHandle();
}
}
private SPWeb CreateMockSPWeb(bool blank, bool validUser)
{
SPWeb web = RecorderManager.CreateMockedObject <SPWeb>();
if (!blank)
{
SPUserCollection users = RecorderManager.CreateMockedObject <SPUserCollection>();
if (validUser)
{
SPUser user = RecorderManager.CreateMockedObject <SPUser>();
using (RecordExpectations recorder = RecorderManager.StartRecording())
{
recorder.ExpectAndReturn(web.SiteUsers.GetCollection(new string[] { }), users);
recorder.ExpectAndReturn(users.Count, 1);
recorder.ExpectAndReturn(users[0].LoginName, string.Format(@"{0}\{1}", Environment.MachineName, "spgemployee"));
recorder.ExpectAndReturn(users[0], user);
recorder.ExpectAndReturn(user.ID, 1).RepeatAlways();
recorder.ExpectAndReturn(user.Name, "SPG Employee").RepeatAlways();
recorder.ExpectAndReturn(user.LoginName, string.Format(@"{0}\{1}", Environment.MachineName, "spgemployee")).RepeatAlways();
}
}
else
{
using (RecordExpectations recorder = RecorderManager.StartRecording())
{
recorder.ExpectAndReturn(web.SiteUsers.GetCollection(new string[] { }), users);
recorder.ExpectAndReturn(users.Count, 0);
}
}
}
return(web);
}
public void LocalPattern02Test()
{
using (RecorderManager.NewPlayBackSession("test", false))
{
RemotingMockService.AddGlobalMockingUri("*");
}
}
private SPWeb RecordWebForUpdate()
{
SPWeb web = RecorderManager.CreateMockedObject <SPWeb>();
SPList list = RecorderManager.CreateMockedObject <SPList>();
SPListItemCollection itemCollection = RecorderManager.CreateMockedObject <SPListItemCollection>();
SPListItem item = RecorderManager.CreateMockedObject <SPListItem>();
using (RecordExpectations recorder = RecorderManager.StartRecording())
{
recorder.ExpectAndReturn(web.Lists["Registrations"], list).RepeatAlways();
recorder.ExpectAndReturn(list.GetItems(new SPQuery()), itemCollection).RepeatAlways();
recorder.ExpectAndReturn(itemCollection.Count, 1);
recorder.ExpectAndReturn(itemCollection[0], item);
item[new Guid(Fields.CourseId)] = 1;
recorder.CheckArguments();
item[new Guid(Fields.UserId)] = 1;
recorder.CheckArguments();
//recorder.ExpectAndReturn(web.AllowUnsafeUpdates, false);
//web.AllowUnsafeUpdates = true;
item.Update();
//web.AllowUnsafeUpdates = false;
}
return(web);
}
public void MockOutArgsTest()
{
using (RecorderManager.NewRecordingSession("test"))
{
Assert.AreEqual(RecorderState.Recording, RecorderManager.Action);
// Scenario:
Sample.FooBar fb = new Sample.FooBar();
int a = 1, b = 2, c, d = 4;
object result = fb.SomeMethodWithInsAndOuts(a, ref b, out c, d);
// Check results:
Assert.IsNotNull(result);
Assert.AreEqual(3, b);
Assert.AreEqual(7, c);
// Check mocking records:
Assert.IsTrue(CurrentRecorder[0].IsConstructorCall);
Assert.IsFalse(CurrentRecorder[1].IsConstructorCall);
Assert.IsTrue(CurrentRecorder[1].InArgs.Length == 3);
Assert.AreEqual(1, CurrentRecorder[1].InArgs[0]);
Assert.AreEqual(2, CurrentRecorder[1].InArgs[1]);
Assert.AreEqual(4, CurrentRecorder[1].InArgs[2]);
Assert.IsTrue(CurrentRecorder[1].OutArgs.Length == 2);
Assert.AreEqual(3, CurrentRecorder[1].OutArgs[0]);
Assert.AreEqual(7, CurrentRecorder[1].OutArgs[1]);
Assert.AreEqual(result, CurrentRecorder[1].ReturnValue);
Assert.AreEqual(1, CurrentRecorder[1].Args[0]);
Assert.AreEqual(3, CurrentRecorder[1].Args[1]);
Assert.AreEqual(7, CurrentRecorder[1].Args[2]);
Assert.AreEqual(4, CurrentRecorder[1].Args[3]);
}
}
public void GetValidatedString_InValidValue_ThrowException()
{
CourseDifficultyLevelField courseDifficultyLevelField = RecorderManager.CreateMockedObject <CourseDifficultyLevelField>();
object value = "-1";
string returnValue = courseDifficultyLevelField.GetValidatedString(value);
}
/// <summary>
/// Process synchronous messages through the sink chain. Mocking can be applied here.
/// </summary>
public IMessage SyncProcessMessage(IMessage msg)
{
IMethodCallMessage mcm = (IMethodCallMessage)msg;
IMethodReturnMessage result;
if (RecorderManager.IsPlaying && RemotingMockService.IsUriToMock(mcm.Uri))
{
MockingProxy proxy = new MockingProxy(Type.GetType(mcm.TypeName), new RemotingPlayBackMocker(), mcm.Uri);
result = (IMethodReturnMessage)proxy.Invoke(msg);
}
else if (RecorderManager.IsRecording && !RecorderManager.IsInCall && RemotingMockService.IsUriToMock(mcm.Uri))
{
MockingProxy proxy = new MockingProxy(Type.GetType(mcm.TypeName), null, mcm.Uri);
MockableCall call = new MockableCall(proxy, mcm);
using (new RecorderManager.Lock()) {
result = SyncProcessMessageOnServer(mcm);
call.SetResult(result);
RecorderManager.RecordCall(call);
}
}
else
{
result = (IMethodReturnMessage)nextMessageSink.SyncProcessMessage(msg);
}
return(result);
}
public void PlayBackBeginEnd00Test()
{
Assert.IsFalse(RecorderManager.IsPlaying);
RecorderManager.BeginPlayBack("test");
Assert.IsTrue(RecorderManager.IsPlaying);
RecorderManager.EndPlayBack();
Assert.IsFalse(RecorderManager.IsPlaying);
}
/// <summary>
/// RecordSPItemEventDataCollection mocks the Get behavior of the
/// SPItemEventDataCollection collection.
/// </summary>
/// <param name="properties">A mocked instance of an SPItemEventDataCollection object</param>
/// <param name="fieldName">the name of the SPField that will be used as the indexer</param>
/// <param name="value">the mocked value to return</param>
public static void RecordSPItemEventDataCollection(SPItemEventDataCollection properties, string fieldName, object value)
{
using (RecordExpectations recorder = RecorderManager.StartRecording())
{
object val = properties[fieldName];
recorder.Return(value).RepeatAlways().WhenArgumentsMatch();
}
}
public void NoMockingTest()
{
using (RecorderManager.NewPlayBackSession("test", false))
{
Sample.ICurrencyService srv = Sample.CurrencyServiceFactory.NextInstance;
Assert.IsFalse(MockService.IsMock(srv));
}
}
public static void SPContextWeb()
{
using (RecordExpectations rec = new RecordExpectations())
{
SPWeb web = RecorderManager.CreateMockedObject <SPWeb>(Constructor.Mocked);
rec.ExpectAndReturn(SPContext.Current.Web, web).RepeatAlways();
}
}
public void AddTypeToMockTest()
{
using (RecorderManager.NewPlayBackSession("test", false))
{
Assert.IsFalse(MockService.IsTypeToMock(typeof(Sample.CustomizableCurrencyService)));
MockService.AddTypeToMock(typeof(Sample.CustomizableCurrencyService));
Assert.IsTrue(MockService.IsTypeToMock(typeof(Sample.CustomizableCurrencyService)));
}
}
public void MockingTest()
{
using (RecorderManager.NewPlayBackSession("test", false))
{
MockService.AddTypeToMock(typeof(Sample.CustomizableCurrencyService));
Sample.ICurrencyService srv = Sample.CurrencyServiceFactory.NextInstance;
Assert.IsTrue(MockService.IsMock(srv));
}
}
public void GetValidatedString_ValidValue_ReturnValue()
{
CourseDifficultyLevelField courseDifficultyLevelField = RecorderManager.CreateMockedObject <CourseDifficultyLevelField>();
object value = "1";
string returnValue = courseDifficultyLevelField.GetValidatedString(value);
Assert.AreEqual("1", returnValue);
}
public void LocalPattern00Test()
{
Assert.IsFalse(RemotingMockService.IsUriToMock("http://localhost/service.rem"));
using (RecorderManager.NewPlayBackSession("test", false))
{
RemotingMockService.AddMockingUri("*");
Assert.IsTrue(RemotingMockService.IsUriToMock("http://localhost/service.rem"));
}
Assert.IsFalse(RemotingMockService.IsUriToMock("http://localhost/service.rem"));
}
public void UriPatternsTest()
{
using (RecorderManager.NewPlayBackSession("test", false))
{
RemotingMockService.AddMockingUri("http://*/*?id=5");
Assert.IsTrue(RemotingMockService.IsUriToMock("http://localhost/service.rem?id=5"));
Assert.IsFalse(RemotingMockService.IsUriToMock("http://localhost/service.rem?id=6"));
Assert.IsFalse(RemotingMockService.IsUriToMock("tcp://localhost/service.rem?id=5"));
}
}
/// <summary>
/// The RecordFieldInternalName method will mock the Get of the InternalName property
/// of an SPField
/// </summary>
/// <param name="list">a mocked SPList object</param>
/// <param name="id">the unique identifier of the SPField</param>
/// <param name="internalName">the mocked InternalName</param>
internal static void RecordFieldInternalName(SPList list, Guid id, string internalName)
{
using (RecordExpectations recorder = RecorderManager.StartRecording())
{
SPField field = list.Fields[id];
recorder.CheckArguments();
string fieldName = field.InternalName;
recorder.Return(internalName).RepeatAlways();
}
}
public void CustomMockingScenarioTest()
{
using (RecorderManager.NewPlayBackSession("test", false))
{
MockService.AddTypeToMock(typeof(Sample.CustomizableCurrencyService));
Sample.ICurrencyService srv = Sample.CurrencyServiceFactory.NextInstance;
decimal result = srv.ConvertAmount(100, Sample.CurrencyUnit.NULL, Sample.CurrencyUnit.GBP);
Assert.AreEqual(100m, result);
}
}
public void MockNotCreatedTest()
{
// When type not added with AddTypeToMock...
using (RecorderManager.NewRecordingSession("test"))
{
Assert.AreEqual(RecorderState.Recording, RecorderManager.Action);
Sample.Account acc = new Sample.Account(Sample.CurrencyUnit.EUR);
Assert.IsFalse(MockService.IsMock(acc));
}
}
public void MockCreatedTest()
{
using (RecorderManager.NewRecordingSession("test"))
{
Assert.AreEqual(RecorderState.Recording, RecorderManager.Action);
MockService.AddTypeToMock(typeof(Sample.Account));
Sample.Account acc = new Sample.Account(Sample.CurrencyUnit.EUR);
Assert.IsTrue(MockService.IsMock(acc));
}
}
public void DeepCustomMockingTest()
{
using (RecorderManager.NewPlayBackSession("test", false))
{
MockService.AddTypeToMock(typeof(Sample.CustomizableCurrencyService));
Sample.Account acc = new Sample.Account(Sample.CurrencyUnit.EUR);
acc.Deposit(100m);
acc.SwitchCurrency(Sample.CurrencyUnit.USD);
Assert.AreEqual(100m, acc.Balance);
}
}
private SPWeb RecordGetFieldName()
{
SPWeb web = RecorderManager.CreateMockedObject <SPWeb>();
using (RecordExpectations recorder = RecorderManager.StartRecording())
{
recorder.ExpectAndReturn(web.Lists[""].Fields[new Guid()].InternalName, "UnitTestField");
}
return(web);
}
private SPListItem RecordAddSPListItem()
{
SPListItem item = RecorderManager.CreateMockedObject <SPListItem>();
using (RecordExpectations recorder = RecorderManager.StartRecording())
{
recorder.ExpectAndReturn(item[new Guid(Fields.Id)], 1);
}
return(item);
}
public void PlaybackTest()
{
Support.RecorderListener listener = new Support.RecorderListener();
RecorderManager.BeginPlayBack("test");
using (new RecorderManager.Lock())
{
}
RecorderManager.EndPlayBack();
Assert.AreEqual(1, listener.BeginPlaybackCounter);
Assert.AreEqual(1, listener.EndPlaybackCounter);
}
private SPWeb RecordUpdateReturnSPWeb()
{
SPWeb web = RecorderManager.CreateMockedObject <SPWeb>();
SPUser user = RecorderManager.CreateMockedObject <SPUser>();
using (RecordExpectations recorder = RecorderManager.StartRecording())
{
recorder.ExpectAndReturn(web.SiteUsers.GetByID(1), user);
}
return(web);
}
