/// <summary>
/// Initializes a new instance of the <see cref="RhinoInterceptor"/> class.
/// Creates a new <see cref="RhinoInterceptor"/> instance.
/// </summary>
/// <param name="repository">
/// The repository.
/// </param>
/// <param name="proxyInstance">
/// The proxy Instance.
/// </param>
/// <param name="invocation_visitors">
/// The invocation_visitors.
/// </param>
public RhinoInterceptor(MockRepository repository, IMockedObject proxyInstance,
IEnumerable<InvocationVisitor> invocation_visitors)
{
this.repository = repository;
this.proxyInstance = proxyInstance;
this.invocation_visitors = invocation_visitors;
}
public void WillRememberExceptionInsideOrderRecorderEvenIfInsideCatchBlock()
{
MockRepository mockRepository = new MockRepository();
IInterfaceWithThreeMethods interfaceWithThreeMethods = mockRepository.StrictMock<IInterfaceWithThreeMethods>();
using (mockRepository.Ordered())
{
interfaceWithThreeMethods.A();
interfaceWithThreeMethods.C();
}
mockRepository.ReplayAll();
interfaceWithThreeMethods.A();
try
{
interfaceWithThreeMethods.B();
}
catch { /* valid for code under test to catch all */ }
interfaceWithThreeMethods.C();
string expectedMessage="Unordered method call! The expected call is: 'Ordered: { IInterfaceWithThreeMethods.C(); }' but was: 'IInterfaceWithThreeMethods.B();'";
ExpectationViolationException ex = Assert.Throws<ExpectationViolationException>(
() => mockRepository.VerifyAll());
Assert.Equal(expectedMessage, ex.Message);
}
public void Test_View_Events_WiredUp()
{
MockRepository mocks = new MockRepository();
IView view = mocks.StrictMock<IView>();
// expect that the model is set on the view
// NOTE: if I move this Expect.Call above
// the above Expect.Call, Rhino mocks blows up on with an
// "This method has already been set to ArgsEqualExpectation."
// not sure why. Its a side issue.
Expect.Call(view.Model = Arg<Model>.Is.NotNull);
// expect the event ClickButton to be wired up
IEventRaiser clickButtonEvent =
Expect.Call(delegate
{
view.ClickButton += null;
}).IgnoreArguments().GetEventRaiser();
// Q: How do i set an expectation that checks that the controller
// correctly updates the model in the event handler.
// i.e. above we know that the controller executes
// _model.UserName = "******"
// but how can I verify it?
// The following wont work, because Model is null:
// Expect.Call(view.Model.UserName = Arg<String>.Is.Anything);
mocks.ReplayAll();
Controller controller = new Controller(view);
clickButtonEvent.Raise(null, null);
mocks.VerifyAll();
}
public DslFactoryFixture()
{
factory = new DslFactory();
mocks = new MockRepository();
mockedDslEngine = mocks.DynamicMock<DslEngine>();
mockCache = mocks.DynamicMock<IDslEngineCache>();
mockCache.WriteLock(null);
LastCall.Repeat.Any()
.IgnoreArguments()
.Do((Action<CacheAction>) ExecuteCachedAction);
mockCache.ReadLock(null);
LastCall.Repeat.Any()
.IgnoreArguments()
.Do((Action<CacheAction>)ExecuteCachedAction);
IDslEngineStorage mockStorage = mocks.DynamicMock<IDslEngineStorage>();
Assembly assembly = Assembly.GetCallingAssembly();
context = new CompilerContext();
context.GeneratedAssembly = assembly;
mockedDslEngine.Storage = mockStorage;
mockedDslEngine.Cache = mockCache;
SetupResult.For(mockStorage.GetMatchingUrlsIn("", ref testUrl)).Return(new string[] { testUrl });
SetupResult.For(mockStorage.IsUrlIncludeIn(null, null, null))
.IgnoreArguments()
.Return(true);
}
public void The_value_of_a_variable_used_as_an_out_parameter_should_not_be_used_as_a_constraint_on_an_expectation()
{
MockRepository mockRepository = new MockRepository();
ServiceBeingCalled service = mockRepository.StrictMock<ServiceBeingCalled>();
const int theNumberToReturnFromTheServiceOutParameter = 20;
using(mockRepository.Record())
{
int uninitialized;
// Uncommenting the following line will make the test pass, because the expectation constraints will match up with the actual call.
// However, the value of an out parameter cannot be used within a method value before it is set within the method value,
// so the value going in really is irrelevant, and should therefore be ignored when evaluating constraints.
// Even ReSharper will tell you "Value assigned is not used in any execution path" for the following line.
//uninitialized = 42;
// I understand I can do an IgnoreArguments() or Contraints(Is.Equal("key"), Is.Anything()), but I think the framework should take care of that for me
Expect.Call(service.PopulateOutParameter("key", out uninitialized)).Return(null).OutRef(theNumberToReturnFromTheServiceOutParameter);
}
ObjectBeingTested testObject = new ObjectBeingTested(service);
int returnedValue = testObject.MethodUnderTest();
Assert.Equal(theNumberToReturnFromTheServiceOutParameter, returnedValue);
}
public void IsShouldSuportAddANewTask()
{
var task = new Task("Title", "ceva", DateTime.Now, DateTime.Today, "", "home");
var repository = new MockRepository();
repository.AddTask(task);
repository.ShouldNotBeNull();
}
public void Delete_HappyPath()
{
// obtains a valid patient
Firestarter.CreateFakePatients(this.db.Doctors.First(), this.db);
this.db.SaveChanges();
var patientId = this.db.Patients.First().Id;
var formModel = new AnamneseViewModel()
{
PatientId = patientId,
Conclusion = "This is my anamnese",
DiagnosticHypotheses = new List<DiagnosticHypothesisViewModel>() {
new DiagnosticHypothesisViewModel() { Text = "Text", Cid10Code = "Q878" },
new DiagnosticHypothesisViewModel() { Text = "Text2", Cid10Code = "Q879" }
}
};
var mr = new MockRepository(true);
var controller = mr.CreateController<AnamnesesController>();
controller.Create(new[] { formModel });
Assert.IsTrue(controller.ModelState.IsValid);
// get's the newly created anamnese
var newlyCreatedAnamnese = this.db.Anamnese.First();
// tries to delete the anamnese
var result = controller.Delete(newlyCreatedAnamnese.Id);
JsonDeleteMessage deleteMessage = (JsonDeleteMessage)result.Data;
Assert.AreEqual(true, deleteMessage.success);
Assert.AreEqual(0, this.db.Anamnese.Count());
}
public void MockInternalClass()
{
MockRepository mocker = new MockRepository();
InternalClass mockInternalClass = mocker.StrictMock<InternalClass>();
Assert.IsNotNull(mockInternalClass);
}
public void SetupResult_For_writeable_property_on_stub_should_be_ignored()
{
MockRepository mocks = new MockRepository();
TestClass test = mocks.Stub<TestClass>();
SetupResult.For(test.ReadOnly).Return("foo");
SetupResult.For(test.ReadWrite).PropertyBehavior();
}
public void UsesBranchSpecificConfigOverTopLevelDefaults()
{
var config = new Config
{
VersioningMode = VersioningMode.ContinuousDelivery,
Branches =
{
{
"dev(elop)?(ment)?$", new BranchConfig
{
VersioningMode = VersioningMode.ContinuousDeployment,
Tag = "alpha"
}
}
}
};
ConfigurationProvider.ApplyDefaultsTo(config);
var develop = new MockBranch("develop") { new MockCommit { CommitterEx = Constants.SignatureNow() } };
var mockRepository = new MockRepository
{
Branches = new MockBranchCollection
{
new MockBranch("master") { new MockCommit { CommitterEx = Constants.SignatureNow() } },
develop
}
};
var context = new GitVersionContext(mockRepository, develop, config);
context.Configuration.Tag.ShouldBe("alpha");
}
/// <summary>
/// Initializes a new instance of the <see cref="StubRecordMockState"/> class.
/// </summary>
/// <param name="mockedObject">The proxy that generates the method calls</param>
/// <param name="repository">Repository.</param>
/// <param name="isPartial">A flag indicating whether we should behave like a partial stub.</param>
public StubRecordMockState(IMockedObject mockedObject, MockRepository repository, bool isPartial)
: base(mockedObject, repository)
{
this.isPartial = isPartial;
Type[] types = mockedObject.ImplementedTypes;
SetPropertyBehavior(mockedObject, types);
}
public CallbackExpectationTests()
{
mocks = new MockRepository();
demo = (IDemo) mocks.StrictMock(typeof (IDemo));
method = typeof (IDemo).GetMethod("VoidThreeArgs");
callbackCalled = false;
}
public void ShouldIgnoreArgumentsOnGenericCallWhenTypeIsStruct()
{
// setup
MockRepository mocks = new MockRepository();
ISomeService m_SomeServiceMock = mocks.StrictMock<ISomeService>();
SomeClient sut = new SomeClient(m_SomeServiceMock);
using (mocks.Ordered())
{
Expect.Call(delegate
{
m_SomeServiceMock.DoSomething<string>(null, null);
});
LastCall.IgnoreArguments();
Expect.Call(delegate
{
m_SomeServiceMock.DoSomething<DateTime>(null, default(DateTime)); // can't use null here, because it's a value type!
});
LastCall.IgnoreArguments();
}
mocks.ReplayAll();
// test
sut.DoSomething();
// verification
mocks.VerifyAll();
// cleanup
m_SomeServiceMock = null;
sut = null;
}
public void CanUseExpectSyntax_OnMockWithOrderedExpectations(bool shouldSwitchToReplyImmediately)
{
MockRepository mocks = new MockRepository();
var foo54 = mocks.StrictMock<IFoo54>();
if (shouldSwitchToReplyImmediately)
mocks.ReplayAll();
using (mocks.Ordered())
{
foo54
.Expect(x => x.DoSomething())
.Return(0);
foo54
.Expect(x => x.DoSomethingElse());
}
if (!shouldSwitchToReplyImmediately)
mocks.Replay(foo54);
foo54.DoSomething();
foo54.DoSomethingElse();
foo54.VerifyAllExpectations();
}
public void WillMerge_UnorderedRecorder_WhenRecorderHasSingleRecorderInside()
{
MockRepository mocks = new MockRepository();
ICustomer customer = mocks.StrictMock<ICustomer>();
CustomerMapper mapper = new CustomerMapper();
using (mocks.Record())
using (mocks.Ordered())
{
Expect.Call(customer.Id).Return(0);
customer.IsPreferred = true;
}
ExpectationViolationException ex = Assert.Throws<ExpectationViolationException>(() =>
{
using (mocks.Playback())
{
mapper.MarkCustomerAsPreferred(customer);
}
});
Assert.Equal("Unordered method call! The expected call is: 'Ordered: { ICustomer.get_Id(); }' but was: 'ICustomer.set_IsPreferred(True);'", ex.Message);
}
public void CanMockIE()
{
//TODO: Figure out why this does not work.
MockRepository mockRepository = new MockRepository();
IHTMLEventObj2 mock = mockRepository.StrictMock<IHTMLEventObj2>();
Assert.NotNull(mock);
}
public void CantCallOriginalMethodOnInterface()
{
MockRepository mocks = new MockRepository();
IDemo demo = (IDemo)mocks.StrictMock(typeof(IDemo));
var ex = Assert.Throws<InvalidOperationException>(() => SetupResult.For(demo.ReturnIntNoArgs()).CallOriginalMethod(OriginalCallOptions.CreateExpectation));
Assert.Equal("Can't use CallOriginalMethod on method ReturnIntNoArgs because the method is abstract.", ex.Message);
}
public void CantCallOriginalMethodOnAbstractMethod()
{
MockRepository mocks = new MockRepository();
MockingClassesTests.AbstractDemo demo = (MockingClassesTests.AbstractDemo)mocks.StrictMock(typeof(MockingClassesTests.AbstractDemo));
var ex = Assert.Throws<InvalidOperationException>(() => SetupResult.For(demo.Six()).CallOriginalMethod(OriginalCallOptions.CreateExpectation));
Assert.Equal("Can't use CallOriginalMethod on method Six because the method is abstract.", ex.Message);
}
public void MultiThreadedReplay()
{
var mocks = new MockRepository();
var service = mocks.StrictMock<IService>();
using (mocks.Record())
{
for (int i = 0; i < 100; i++)
{
int i1 = i;
Expect.Call(() => service.Do("message" + i1));
}
}
using (mocks.Playback())
{
int counter = 0;
for (int i = 0; i < 100; i++)
{
var i1 = i;
ThreadPool.QueueUserWorkItem(delegate
{
service.Do("message" + i1);
Interlocked.Increment(ref counter);
});
}
while (counter != 100)
Thread.Sleep(100);
}
}
public void EditPost_UserIsOwner_WithInvalidData()
{
PracticeHomeController homeController;
var mr = new MockRepository();
try
{
mr.SetCurrentUser_Andre_CorrectPassword();
mr.SetRouteData_ConsultorioDrHouse_GregoryHouse(typeof(PracticeHomeController), "Edit");
homeController = mr.CreateController<PracticeHomeController>(callOnActionExecuting: false);
}
catch (Exception ex)
{
InconclusiveInit(ex);
return;
}
var viewModel = new PracticeHomeControllerViewModel
{
PracticeName = "", // Cannot set practice name to empty
PracticeTimeZone = 3
};
Mvc3TestHelper.SetModelStateErrors(homeController, viewModel);
// Execute test: owner must have access to this view.
var actionResult = Mvc3TestHelper.RunOnAuthorization(homeController, "Edit", "POST")
?? Mvc3TestHelper.RunOnActionExecuting(homeController, "Edit", "POST")
?? homeController.Edit(viewModel);
// Asserts
Assert.IsInstanceOfType(actionResult, typeof(ViewResult));
Assert.AreEqual(null, ((ViewResult)actionResult).View);
}
public void EditPost_UserIsAdministrator()
{
PracticeHomeController homeController;
var mr = new MockRepository();
try
{
mr.SetCurrentUser_Miguel_CorrectPassword();
mr.SetRouteData_ConsultorioDrHouse_GregoryHouse(typeof(PracticeHomeController), "Edit");
homeController = mr.CreateController<PracticeHomeController>(callOnActionExecuting: false);
}
catch (Exception ex)
{
InconclusiveInit(ex);
return;
}
// Execute test: owner must have access to this view.
var actionResult = Mvc3TestHelper.RunOnAuthorization(homeController, "Edit", "POST")
?? Mvc3TestHelper.RunOnActionExecuting(homeController, "Edit", "POST")
?? homeController.Edit(new PracticeHomeControllerViewModel
{
PracticeName = "My New Practice Name",
PracticeTimeZone = 3
});
// Asserts
Assert.IsInstanceOfType(actionResult, typeof(RedirectToRouteResult));
var redirectResult = (RedirectToRouteResult)actionResult;
Assert.AreEqual(2, redirectResult.RouteValues.Count);
Assert.AreEqual("practicehome", string.Format("{0}", redirectResult.RouteValues["controller"]), ignoreCase: true);
Assert.AreEqual("Index", string.Format("{0}", redirectResult.RouteValues["action"]), ignoreCase: true);
}
public void Ayende_View_On_Mocking()
{
MockRepository mocks = new MockRepository();
ISomeSystem mockSomeSystem = mocks.StrictMock<ISomeSystem>();
using (mocks.Record())
{
Expect.Call(mockSomeSystem.GetFooFor<ExpectedBar>("foo"))
.Return(new List<ExpectedBar>());
}
ExpectationViolationException ex = Assert.Throws<ExpectationViolationException>(
() =>
{
using (mocks.Playback())
{
ExpectedBarPerformer cut = new ExpectedBarPerformer(mockSomeSystem);
cut.DoStuffWithExpectedBar("foo");
}
}
);
Assert.Equal(@"ISomeSystem.GetFooFor<Rhino.Mocks.Tests.FieldsProblem.UnexpectedBar>(""foo""); Expected #1, Actual #1.
ISomeSystem.GetFooFor<Rhino.Mocks.Tests.FieldsProblem.ExpectedBar>(""foo""); Expected #1, Actual #0.", ex.Message);
}
public void Override_using_tag_with_a_prerelease()
{
var commit = new MockCommit
{
CommitterEx = 2.Seconds().Ago().ToSignature()
};
var finder = new MasterVersionFinder();
var mockBranch = new MockBranch("master")
{
commit
};
var mockRepository = new MockRepository
{
Branches = new MockBranchCollection
{
mockBranch
},
Tags = new MockTagCollection
{
new MockTag
{
NameEx = "0.1.0-beta1",
TargetEx = commit
}
}
};
var version = finder.FindVersion(new GitVersionContext(mockRepository, mockBranch, new Config()));
Assert.AreEqual(0, version.Patch, "Should set the patch version to the patch of the latest hotfix merge commit");
ObjectApprover.VerifyWithJson(version, Scrubbers.GuidScrubber);
}
/// <summary>
/// Initializes a new instance of the <see cref="RecorderChanger"/> class.
/// Creates a new <see cref="RecorderChanger"/> instance.
/// </summary>
/// <param name="repository">
/// The repository.
/// </param>
/// <param name="recorder">
/// The recorder.
/// </param>
/// <param name="newRecorder">
/// The new Recorder.
/// </param>
public RecorderChanger(MockRepository repository, IMethodRecorder recorder, IMethodRecorder newRecorder)
{
this.recorder = recorder;
this.repository = repository;
repository.PushRecorder(newRecorder);
this.recorder.AddRecorder(newRecorder);
}
public void Delete_HappyPath()
{
// obtains a valid patient
Firestarter.CreateFakePatients(this.db.Doctors.First(), this.db, 1);
this.db.SaveChanges();
var patientId = this.db.Patients.First().Id;
var formModel = new DiagnosisViewModel
{
PatientId = patientId,
Text = "This is my diagnosis",
Cid10Code = "Q878",
Cid10Name = "Doença X"
};
var mr = new MockRepository(true);
var controller = mr.CreateController<DiagnosisController>();
controller.Create(new[] { formModel });
Assert.IsTrue(controller.ModelState.IsValid);
// get's the newly created diagnosis
var newlyCreatedDiagnosis = this.db.Diagnoses.First();
// tries to delete the anamnese
var result = controller.Delete(newlyCreatedDiagnosis.Id);
var deleteMessage = (JsonDeleteMessage)result.Data;
Assert.AreEqual(true, deleteMessage.success);
Assert.AreEqual(0, this.db.Anamnese.Count());
}
public void CanMockComInterface()
{
MockRepository mocks = new MockRepository();
IServiceProvider serviceProvider = (IServiceProvider)
mocks.StrictMultiMock(typeof(IServiceProvider), typeof(IHTMLDataTransfer));
Assert.NotNull(serviceProvider);
}
public CallbackTests()
{
System.Threading.Thread.CurrentThread.CurrentCulture = System.Globalization.CultureInfo.InvariantCulture;
mocks = new MockRepository();
demo = (IDemo) mocks.StrictMock(typeof (IDemo));
callbackCalled = false;
}
public static PageTypeUpdater Stub(MockRepository fakesRepository)
{
return fakesRepository.Stub<PageTypeUpdater>(
PageTypeDefinitionLocatorFactory.Stub(),
new PageTypeFactory(),
new PageTypeValueExtractor(),
new PageTypeLocator(new PageTypeFactory()));
}
public void CantMoveToReplayStateWithoutclosingLastMethod()
{
MockRepository mocks = new MockRepository();
ProxyInstance proxy = new ProxyInstance(mocks);
RecordMockState recordState = new RecordMockState(proxy, mocks);
recordState.MethodCall(new FakeInvocation(method), method, "");
recordState.Replay();
}
public void ArgsEqualExpectationUsedForMethodsWithNoOutParameters()
{
MockRepository mocks = new MockRepository();
RecordMockState recordState = new RecordMockState(new ProxyInstance(mocks), mocks);
Assert.IsNull(recordState.LastExpectation);
recordState.MethodCall(new FakeInvocation(method), method, "");
Assert.IsInstanceOfType(typeof(ArgsEqualExpectation), recordState.LastExpectation);
}
public ToDoListCqrsTest()
{
this.mockRepository = new MockRepository(MockBehavior.Strict);
this.mediatorMock = this.mockRepository.Create <IMediator>();
this.controller = new ToDoListCqrsController(this.mediatorMock.Object);
}
public PartialMockTests()
{
abs = MockRepository.Partial <AbstractClass>();
abs.SetUnexpectedBehavior(UnexpectedCallBehaviors.BaseOrDefault);
}
public void CantCreatePartialMockFromInterfaces()
{
Assert.Throws <InvalidOperationException>(
() => MockRepository.Partial <IDemo>());
}
public void Setup()
{
m_log = MockRepository.GenerateStub <ILogger>();
m_config = MockRepository.GenerateStub <IConfig>();
}
public override void SetUp()
{
base.SetUp();
detector = MockRepository.GenerateStub <IReleaseDetector>();
mapper = new ReleaseMapper(scmData, detector);
}
public ServiceTest()
{
var uri = Path.Combine(Environment.CurrentDirectory, "testdata.xml");
Mocks = new MockRepository(uri);
}
public new void Setup()
{
_customerSettings = new CustomerSettings();
_stateProvinceService = MockRepository.GenerateMock <IStateProvinceService>();
_validator = new RegisterValidator(_localizationService, _stateProvinceService, _customerSettings);
}
public void TryToMockClassWithProtectedAbstractClass()
{
MockRepository mockRepository = new MockRepository();
mockRepository.StrictMock <SomeClassWithProtectedAbstractClass>();
}
public void Test_AddWrongCodecName()
{
MockRepository mocks = new MockRepository();
Esapi.Encoder.AddCodec(null, mocks.StrictMock <ICodec>());
}
void InitMocks()
{
_mocks = new MockRepository();
_meta = _mocks.StrictMock <IPersistentMap>();
_mocks.ReplayAll();
}
public static void InitialiseServiceLocator()
{
provider = MockRepository.GenerateStub <IServiceLocator>();
ServiceLocator.SetLocatorProvider(() => provider);
}
public EtagSynchronizerTests()
{
storage = MockRepository.GenerateStub <ITransactionalStorage>();
storage.Stub(x => x.Batch(Arg <Action <IStorageActionsAccessor> > .Is.Anything)).WhenCalled(x => numberOfCalls++);
}
public void SetUp()
{
m_repository = new MockRepository(MockBehavior.Strict);
}
public AgenteTests()
{
this.mockRepository = new MockRepository(MockBehavior.Strict);
}
public void SetUp()
{
mocks = new MockRepository();
}
public void Init()
{
_benchmarkService = MockRepository.GenerateStub <IProteinBenchmarkService>();
}
void CreateClass()
{
classKindUpdater = MockRepository.GenerateStub <IClassKindUpdater>();
codeClass = new CodeClass2(helper.ProjectContentHelper.ProjectContent, helper.Class, classKindUpdater);
}
private AssemblyContext CreateAssemblyContext()
{
return(new AssemblyContext(
MockRepository.GenerateStrictMock <IMutableTypeBatchCodeGenerator>(),
MockRepository.GenerateStrictMock <IGeneratedCodeFlusher>()));
}
protected TType CreateDependency <TType>()
where TType : class
{
return(MockRepository.GenerateMock <TType>());
}
public void Init()
{
_mockRepository = new MockRepository();
InternalInit();
}
public MockHelper(MockRepository mockRepository)
{
MockRepository = mockRepository;
}
protected TType CreateStub <TType>() where TType : class
{
return(MockRepository.GenerateStub <TType>());
}
public void SetUpContext()
{
_fakeStepProvider = MockRepository.GenerateStub<IStepProvider>();
_fakeStepDescriber = MockRepository.GenerateStub<IStepDescriber>();
Job = new StorEvilGlossaryJob(_fakeStepProvider, _fakeStepDescriber, new EventBus(), new NoOpGlossaryFormatter());
}
/// <summary>
/// Sets up the mock objects of the derived unit test class
/// </summary>
public override void SetupMockObjectsForPlugin()
{
Plugin.OrganizationServiceContext = MockRepository.GenerateStub <CrmServiceContext>(Plugin.OrganizationService);
Plugin.CrmService = MockRepository.GenerateMock <CrmService>(Plugin.OrganizationServiceContext, Plugin.TracingService);
Plugin.ManageDeleteEntityService = MockRepository.GenerateMock <ManageDeleteEntityService>(Plugin.CrmService, Plugin.OrganizationServiceContext, Plugin.PluginExecutionContext, Plugin.TracingService);
}
public HomeControllerTests()
{
this.mockRepository = new MockRepository(MockBehavior.Strict);
this.mockLogger = this.mockRepository.Create <ILogger <HomeController> >();
}
public void Setup()
{
mr = new MockRepository();
program = new Program();
}
