public void Setup()
{
mr = new MockRepository();
frame = mr.DynamicMock<IWindowFrame>();
sc = new ServiceContainer();
sc.AddService(typeof(IWindowFrame), frame);
}
public void Add()
{
var mocks = new MockRepository();
var connection = mocks.StrictMock<ISolrConnection>();
var executer = mocks.StrictMock<ISolrQueryExecuter<TestDocumentWithoutUniqueKey>>();
var headerParser = mocks.StrictMock<ISolrHeaderResponseParser>();
var docSerializer = new SolrDocumentSerializer<TestDocumentWithoutUniqueKey>(new AttributesMappingManager(), new DefaultFieldSerializer());
With.Mocks(mocks)
.Expecting(() => {
Expect.On(connection)
.Call(connection.Post("/update", "<add><doc /></add>"))
.Repeat.Once()
.Return(EmbeddedResource.GetEmbeddedString(GetType(), "Resources.response.xml"));
Expect.On(headerParser)
.Call(headerParser.Parse(null))
.IgnoreArguments()
.Return(new ResponseHeader());
})
.Verify(() => {
var ops = new SolrBasicServer<TestDocumentWithoutUniqueKey>(connection, executer, docSerializer, null, headerParser, null, null, null);
ops.AddWithBoost(new[] {
new KeyValuePair<TestDocumentWithoutUniqueKey, double?>(new TestDocumentWithoutUniqueKey(), null),
}, null);
});
}
public static void RelationsTest()
{
MockRepository rhinoEngine = new MockRepository();
var mockWriter = rhinoEngine.DynamicMock<TextWriter>();
TextWriterFactory.SetTextWriter(mockWriter);
using (rhinoEngine.Record())
{
mockWriter.Write("Nothing");
LastCall.Constraints(new Rhino.Mocks.Constraints.Contains("TestCustomer") &
new Rhino.Mocks.Constraints.Contains("TestMovie") &
new Rhino.Mocks.Constraints.Contains("6 days") &
new Rhino.Mocks.Constraints.Contains(12.ToString("C")));
mockWriter.Flush();
}
Customer customer = new Customer("TestCustomer");
customer.Rental.Add(new Rental(new Movie("TestMovie", 2), 6));
ReportManager.CreateReport("SomePath", customer);
rhinoEngine.VerifyAll();
}
public void ReturnResultsFromMock()
{
MockRepository mocks = new MockRepository();
IGetResults resultGetter = mocks.DynamicMock<IGetResults>();
using (mocks.Record())
{
resultGetter.GetSomeNumber("a");
LastCall.Return(1);
resultGetter.GetSomeNumber("c");
LastCall.Return(2);
resultGetter.GetSomeNumber("b");
LastCall.Return(3);
}
int result;
result = resultGetter.GetSomeNumber("b");
Assert.AreEqual(3, result);
result = resultGetter.GetSomeNumber("a");
Assert.AreEqual(1, result);
result = resultGetter.GetSomeNumber("c");
Assert.AreEqual(2, result);
}
public void OnViewLoadedSetsCategorieIntheView()
{
// Mock the View
MockRepository mocks = new MockRepository();
//Arrange
var service = mocks.DynamicMock<ICategorieService>();
//Act
var controller = mocks.DynamicMock<ICategorieController>();
// Create Presenter With Mock View and Dummy BlogService
CategorieService serviceActual = new MockCategorieService();
var controllerActual = new CategorieController(serviceActual,null,null);
var presenter = new CategorieenPresenter(controllerActual);
var cat = new BeheerContextEntity { DataKeyValue = "added" };
IList<BeheerContextEntity> list= new List<BeheerContextEntity>();
list.Add(cat);
//controller.AddBusinessEntity(cat);
// Set Expectations
controller.Expect(action=>action.AddBusinessEntity(cat));
//presenter.Expect(action => action.OnViewLoaded());
// Tell Rhino Mocks We're Done Setting Expectations
mocks.ReplayAll();
presenter.OnViewLoaded();
mocks.VerifyAll();
}
public void Setup()
{
mr = new MockRepository();
sc = new ServiceContainer();
cfgSvc = mr.Stub<IConfigurationService>();
sc.AddService<IConfigurationService>(cfgSvc);
}
public void BeginTest()
{
repo = new MockRepository();
channelFactory = repo.StrictMock<ICanCreateChannels<IService>>();
communicationObject = repo.StrictMultiMock<ICommunicationObject>(typeof(IService));
manager = new SingleActionChannelManager<IService>(channelFactory);
}
public void ShouldParseAuthenticationStringWhenAuthorizationStringIsAvailable()
{
MockRepository repository = new MockRepository();
DigestHeaderParser headerParser = MockCreator<DigestHeaderParser>.Stub(repository);
MethodExtractor methodExtractor = MockCreator<MethodExtractor>.Stub(repository);
Message testMessage = TestResources.CreateMessage();
AuthorizationStringExtractor extractor;
using (repository.Record())
{
headerParser.Expect(parser => parser.Parse(string.Empty)).IgnoreArguments().Return(TestResources.CreateHeader());
extractor = MockCreator<AuthorizationStringExtractor>.Create(repository);
string authenticationString;
extractor.Expect(extr => extr.TryExtractAuthorizationHeader(testMessage, out authenticationString)).OutRef(TestResources.AuthenticationString).Return(true);
}
var digestHeaderExtractor = new DigestHeaderExtractor(extractor, headerParser, methodExtractor);
using (repository.Playback())
{
DigestHeader digestHeader;
bool result = digestHeaderExtractor.TryExtract(testMessage, out digestHeader);
Assert.That(result, Is.True);
}
}
public void Save_ThrowsExceptionOnSave_SavesLog()
{
var user = new User()
{
Name = "John",
Email = "*****@*****.**"
};
var exception = new Exception("Fail to connect to database");
var emailValidation = MockRepository.GenerateStub <IEmailValidation>();
var userRepository = MockRepository.GenerateStub <IUserRepository>();
var logService = MockRepository.GenerateMock <ILogService>();
emailValidation.Stub(p => p.isValid(It.IsAny <string>())).Return(true);
userRepository.Stub(p => p.Save(It.Is <User>(u => u.Equals(user)))).Throw(exception);
logService.Expect(p => p.LogError(It.Is <Exception>(e => e.Equals(exception))));
var userService = new UserService(userRepository, emailValidation);
userService.LogService = logService;
userService.Save(user);
userRepository.VerifyAllExpectations();
}
public void Setup()
{
repository = new MockRepository();
sc = new ServiceContainer();
arch = new IntelArchitecture(ProcessorMode.Protected32);
dcSvc = repository.StrictMock<IConfigurationService>();
}
public void GetGigsBySiteAfterDate_Calls_GigDAO_Method_GetGigsBySiteAfterDate_Once_And_Returns_Gigs()
{
MockRepository mocks = new MockRepository();
DateTime startDate = DateTime.Now;
int numGigs = 10;
List<Gig> gigs = (List<Gig>)CreateListOfGigs(numGigs, startDate);
Guid siteId = Guid.NewGuid();
IGigDAO gigDAO = mocks.DynamicMock<IGigDAO>();
GigManager gigManager = new GigManager();
gigManager.GigDAO = gigDAO;
Expect.Call(gigDAO.GetGigsBySiteAfterDate(siteId, startDate))
.Constraints(new AbstractConstraint[] { Is.Equal(siteId), Is.Equal(startDate) })
.Repeat.Once()
.Return(gigs);
mocks.ReplayAll();
List<Gig> result = (List<Gig>)gigManager.GetGigsBySiteAfterDate(siteId, startDate);
mocks.VerifyAll();
}
public void FeedbackCreateCallsCommentService(bool isSpam, bool isAdmin)
{
Assert.IsTrue(Config.CreateBlog("", "username", "password", _hostName, string.Empty));
MockRepository mocks = new MockRepository();
IFeedbackSpamService service = (IFeedbackSpamService)mocks.CreateMock(typeof(IFeedbackSpamService));
Config.CurrentBlog.FeedbackSpamService = service;
Config.CurrentBlog.DuplicateCommentsEnabled = true;
Config.CurrentBlog.FeedbackSpamServiceKey = "my-secret-key";
Config.CurrentBlog.ModerationEnabled = false;
FeedbackItem feedback = new FeedbackItem(FeedbackType.Comment);
Expect.Call(service.IsSpam(feedback)).Return(isSpam);
feedback.Title = "blah";
feedback.Body = UnitTestHelper.GenerateRandomString();
mocks.ReplayAll();
Assert.AreEqual(isAdmin, SecurityHelper.IsAdmin);
try
{
FeedbackItem.Create(feedback, new CommentFilter(new Cache()));
}
catch(BaseCommentException)
{
}
Assert.AreEqual(!isSpam, feedback.Approved);
}
public void Do3Classic()
{
var mockRepository = new MockRepository();
var view = mockRepository.StrictMock<IButtonView>();
var model = mockRepository.StrictMock<IToggleModel>();
model.VisibilityStateChanged += null;
IEventRaiser visibilityChanged = LastCall.GetEventRaiser();
view.Clicked += null;
IEventRaiser clicked = LastCall.GetEventRaiser();
var presenter = new ButtonPresenter(model);
presenter.ConnectView(view);
mockRepository.BackToRecordAll();
//mockRepository.Playback();
Expect.Call(model.ToggleVisibility);
Expect.Call(() => model.VisibilityStateChanged += null).IgnoreArguments();
Expect.Call(() => view.SetCheckedState(CheckedState.Checked));
mockRepository.ReplayAll();
clicked.Raise();
visibilityChanged.Raise(VisibilityState.Visible);
mockRepository.VerifyAll();
}
public void Creates_database()
{
var settings = new ConnectionSettings("server", "db", true, null, null);
var taskAttributes = new TaskAttributes(settings, "c:\\scripts");
taskAttributes.RequestedDatabaseAction= RequestedDatabaseAction.Create;
var mocks = new MockRepository();
var queryExecutor = mocks.StrictMock<IQueryExecutor>();
var executor = mocks.StrictMock<IScriptFolderExecutor>();
var taskObserver = mocks.StrictMock<ITaskObserver>();
using (mocks.Record())
{
queryExecutor.ExecuteNonQuery(settings, "create database [db]");
taskObserver.Log(string.Format("Run scripts in Create folder."));
executor.ExecuteScriptsInFolder(taskAttributes, "Create", taskObserver);
}
using (mocks.Playback())
{
IDatabaseActionExecutor creator = new DatabaseCreator(queryExecutor, executor);
creator.Execute(taskAttributes, taskObserver);
}
mocks.VerifyAll();
}
public void Should_enable_load_balancing_when_requested()
{
ApplicationInstance instance = new ApplicationInstance();
instance.AvailableForLoadBalancing = false;
MockRepository mocks = new MockRepository();
IApplicationInstanceContext instanceContext = mocks.CreateMock<IApplicationInstanceContext>();
IWebContext context = mocks.CreateMock<IWebContext>();
ISecureAvailabilityStatusUpdater updater = mocks.CreateMock<ISecureAvailabilityStatusUpdater>();
using (mocks.Record())
{
Expect.Call(instanceContext.GetCurrent()).Return(instance);
Expect.Call(context.GetRequestItem(LoadBalanceStatusManager.ENABLED_PARAM)).Return("True");
Expect.Call(updater.SetStatus(true)).Return("My error message");
}
using (mocks.Playback())
{
ILoadBalanceStatusManager manager = new LoadBalanceStatusManager(instanceContext, context, updater);
string errorMessage = manager.HandleLoadBalanceRequest();
Assert.That(errorMessage, Is.EqualTo("My error message"));
}
}
public void SetUp()
{
mocks = new MockRepository();
instance = mocks.DynamicMock<IUnitOfWork>();
store = new ThreadedUnitOfWorkStore();
}
public virtual void RunOnceBeforeAny()
{
// Initialize NBuilder settings
BuilderSetup.SetDefaultPropertyNamer(new NonDefaultNonRepeatingPropertyNamer(new ReflectionUtil()));
// Create a mock repository for new mocks
mocks = new MockRepository();
EstablishContext();
// Stop recording
mocks.ReplayAll();
try
{
// Allow execution of code just prior to test execution
BeforeExecuteTest();
// Execute the test
ExecuteTest();
}
finally
{
// Allow cleanup surrounding test execution, prior to final cleanup
AfterExecuteTest();
}
}
public void SetUp()
{
mockRepository = new MockRepository();
mainTransport = mockRepository.StrictMultiMock<ITransport>();
mainTransport.Replay();
retryingTransport = new RetryingTransport(new SilentLogger(), mainTransport, retryCount, retryDelay);
}
public void CanCreateWithDefaults()
{
string SESSIONFACTORY_OBJECTNAME = ConfigSectionSessionScopeSettings.DEFAULT_SESSION_FACTORY_OBJECT_NAME;
// setup expected values
MockRepository mocks = new MockRepository();
ISessionFactory expectedSessionFactory = mocks.StrictMock<ISessionFactory>();
IInterceptor expectedEntityInterceptor = null;
bool expectedSingleSession = SessionScopeSettings.SINGLESESSION_DEFAULT;
FlushMode expectedDefaultFlushMode = SessionScopeSettings.FLUSHMODE_DEFAULT;
// create and register context
StaticApplicationContext appCtx = new StaticApplicationContext();
appCtx.Name = AbstractApplicationContext.DefaultRootContextName;
appCtx.ObjectFactory.RegisterSingleton(SESSIONFACTORY_OBJECTNAME, expectedSessionFactory);
ContextRegistry.Clear();
ContextRegistry.RegisterContext(appCtx);
ConfigSectionSessionScopeSettings settings = new ConfigSectionSessionScopeSettings(this.GetType(), (IVariableSource)null);
Assert.AreEqual(expectedSessionFactory, settings.SessionFactory);
Assert.AreEqual(expectedEntityInterceptor, settings.EntityInterceptor);
Assert.AreEqual(expectedSingleSession, settings.SingleSession);
Assert.AreEqual(expectedDefaultFlushMode, settings.DefaultFlushMode);
}
public void ExecuteWithAllOptions()
{
var mocks = new MockRepository();
var conn = mocks.StrictMock<ISolrConnection>();
With.Mocks(mocks).Expecting(() =>
{
conn.Post("/update", "<commit waitSearcher=\"true\" waitFlush=\"true\" expungeDeletes=\"true\" maxSegments=\"2\" />");
LastCall.On(conn).Repeat.Once().Do(new Writer(delegate(string ignored, string s)
{
Console.WriteLine(s);
return null;
}));
}).Verify(() =>
{
var cmd = new CommitCommand
{
MaxSegments = 2,
ExpungeDeletes = true,
WaitFlush = true,
WaitSearcher = true
};
cmd.Execute(conn);
});
}
public void InitializeTest()
{
_mockScheduleRepository = MockRepository.GenerateMock <IScheduleRepository>();
_scheduleController = new ScheduleController(_mockScheduleRepository);
_templateScheduleController = new TemplateScheduleController();
_templateShiftController = new TemplateShiftController(new TemplateShiftRepository());
}
public static void GetMatchNonMatchTest(
string headerName,
string[] values,
bool existsInStore,
bool expectReturnNull,
HttpStatusCode expectedStatus = HttpStatusCode.Unused)
{
// setup
var mocks = new MockRepository();
var entityTagStore = mocks.StrictMock<IEntityTagStore>();
var entityTagHandler = new CachingHandler(entityTagStore);
var request = new HttpRequestMessage(HttpMethod.Get, TestUrl);
request.Headers.Add(headerName, values);
TimedEntityTagHeaderValue entityTagHeaderValue = new TimedEntityTagHeaderValue("\"12345678\"");
if(values.Length>0) // if
entityTagStore.Expect(x => x.TryGetValue(Arg<CacheKey>.Matches(etg => etg.ResourceUri == entityTagHandler.UriTrimmer(new Uri(TestUrl))),
out Arg<TimedEntityTagHeaderValue>.Out(entityTagHeaderValue).Dummy)).Return(existsInStore);
mocks.ReplayAll();
// run
var matchNoneMatch = entityTagHandler.GetIfMatchNoneMatch();
// verify
Task<HttpResponseMessage> resultTask = matchNoneMatch(request);
Assert.That(expectReturnNull ^ resultTask != null, "result was not as expected");
if(resultTask!=null && expectedStatus != HttpStatusCode.Unused)
{
Assert.AreEqual(expectedStatus, resultTask.Result.StatusCode, "Status code");
}
mocks.VerifyAll();
}
public void VerifyInstanceDoesNotCallJetTermWhenCreateInstanceFails()
{
var mocks = new MockRepository();
var mockApi = mocks.StrictMock<IJetApi>();
using (new ApiTestHook(mockApi))
{
Expect.Call(
mockApi.JetCreateInstance2(
out Arg<JET_INSTANCE>.Out(JET_INSTANCE.Nil).Dummy,
Arg<string>.Is.Anything,
Arg<string>.Is.Anything,
Arg<CreateInstanceGrbit>.Is.Anything))
.Return((int) JET_err.InvalidName);
mocks.ReplayAll();
try
{
using (var instance = new Instance("testfail"))
{
Assert.Fail("Expected an EsentErrorException");
}
}
catch (EsentErrorException)
{
// expected
}
mocks.VerifyAll();
}
}
public void TestFixtureSetUp()
{
Mocks = new MockRepository();
Establish_context();
Because();
}
public void Setup()
{
ssaIds = new SsaIdentifierCollection();
mr = new MockRepository();
arch = mr.Stub<IProcessorArchitecture>();
importResolver = mr.Stub<IImportResolver>();
}
public void SetUp()
{
_mocks = new MockRepository();
_output = new StringWriter();
string viewPath = "MvcContrib.ViewEngines.NVelocity.Tests";
IDictionary properties = new Hashtable();
properties["resource.loader"] = "assembly";
properties["assembly.resource.loader.class"] = "NVelocity.Runtime.Resource.Loader.AssemblyResourceLoader, NVelocity";
properties["assembly.resource.loader.assembly"] = new List<string>() {GetType().Assembly.FullName};
properties["master.folder"] = viewPath;
_viewEngine = new NVelocityViewEngine(properties);
var httpContext = _mocks.DynamicMock<HttpContextBase>();
var response = _mocks.DynamicMock<HttpResponseBase>();
SetupResult.For(httpContext.Response).Return(response);
SetupResult.For(response.Output).Return(_output);
var requestContext = new RequestContext(httpContext, new RouteData());
var controller = _mocks.DynamicMock<ControllerBase>();
_mocks.ReplayAll();
_controllerContext = new ControllerContext(requestContext, controller);
_controllerContext.RouteData.Values.Add("controller", viewPath);
}
public void GetById_Calls_GigDAO_Method_GetById_Once_And_Returns_A_Gig()
{
MockRepository mocks = new MockRepository();
Guid gigId = Guid.NewGuid();
Gig gig = new Gig();
gig.ID = gigId;
IGigDAO gigDAO = mocks.DynamicMock<IGigDAO>();
GigManager gigManager = new GigManager();
gigManager.GigDAO = gigDAO;
Expect.Call(gigDAO.GetById(gigId))
.Constraints(Is.Equal(gigId))
.Repeat.Once()
.Return(gig);
mocks.ReplayAll();
Gig result = gigManager.GetByID(gigId);
mocks.VerifyAll();
Assert.AreEqual(gig.ID, result.ID);
}
public CollectionFieldParser CreateCollectionFieldParser()
{
var mocks = new MockRepository();
var vp = mocks.CreateMock<ISolrFieldParser>();
var p = new CollectionFieldParser(vp);
return p;
}
public void Setup()
{
mr = new MockRepository();
mockFactory = new MockFactory(mr);
arch = new PowerPcArchitecture32();
platform = new SysVPlatform(null, arch);
}
public void Do3Fluent()
{
var mockRepository = new MockRepository();
var view = mockRepository.StrictMock<IButtonView>();
var model = mockRepository.StrictMock<IToggleModel>();
var presenter = new ButtonPresenter(model);
presenter.ConnectView(view);
//IEventRaiser clicked = null;
//view.Clicked += null;
//clicked = LastCall.GetEventRaiser();
IEventSubscriber subscriber = mockRepository.StrictMock<IEventSubscriber>();
IWithEvents events = new WithEvents();
// This doesn't create an expectation because no method is called on subscriber!!
events.Blah += subscriber.Handler;
subscriber.Handler(VisibilityState.Visible);
With.Mocks(mockRepository)
.Expecting(delegate
{
Expect.Call(model.ToggleVisibility);
Expect.Call(() => model.VisibilityStateChanged += null).IgnoreArguments();
Expect.Call(() => view.SetCheckedState(CheckedState.Checked));
})
.Verify(delegate
{
events.RaiseEvent(VisibilityState.Visible);
//clicked.Raise();
});
}
public void SetUp()
{
mockery = new MockRepository();
blogPostService = mockery.DynamicMock<IBlogPostService>();
controller = new PostController(blogPostService);
PrepareController(controller, "post");
}
public void SetUp()
{
_mockRepository = new MockRepository();
_tagRepository = _mockRepository.DynamicMock<IRepository<Tag>>();
_tagService = new TagService(_tagRepository);
}
public void IsMockableWithRhino()
{
var paletteHelper = MockRepository.GenerateStub <PaletteHelper>();
paletteHelper.SetLightDark(true);
paletteHelper.AssertWasCalled(ph => ph.SetLightDark(true));
}
public void Setup()
{
_mockRepository = new MockRepository();
_cacheStore = _mockRepository.StrictMock <ICacheStore>();
_messageHandler = new DummyMessageHandler();
_cachingHandler = new CachingHandler(_cacheStore)
{
InnerHandler = _messageHandler
};
_client = new HttpClient(_cachingHandler);
}
public void Rhino_onSpecificDrugsRetrieved_WhenEventRaised_DrugServiceListens()
{
// Arrange
var mockDrugService = MockRepository.GenerateMock <IDrugService>();
_dataAccess.SpecificDrugRetrievedEvent += mockDrugService.OnSpecificDrugsRetrieved;
// Act
_dataAccess.GetSpecificDrugs(_drugIds);
// Assert
mockDrugService.AssertWasCalled(ds => ds.OnSpecificDrugsRetrieved(Arg <object> .Is.Equal(_dataAccess), Arg <SpecificDrugRetrievedArgs> .Matches(a => Equals(a.DrugIds, _drugIds))));
}
public void About()
{
// Arrange
var mockRepo = new Rhino.Mocks.MockRepository();
var mockTwitterService = mockRepo.StrictMock <ITwitterService>();
var controller = new HomeController(new InMemoryRepository(), null, mockTwitterService);
// Act
var result = controller.About() as ViewResult;
// Assert
Assert.IsNotNull(result);
}
public async Task C_F_RhinoMocksDynamicMockDoesntWorkWell()
{
var mocks = new Rhino.Mocks.MockRepository();
var service = mocks.DynamicMock <IService>();
var sut = new Sut
{
Service = service
};
mocks.ReplayAll();
await sut.UseServiceAsync();
mocks.VerifyAll();
}
public void Save_InvalidEmail_ThrowsException()
{
var user = new User()
{
Name = "John",
Email = "email"
};
var emailValidation = MockRepository.GenerateStub <IEmailValidation>();
emailValidation.Stub(p => p.isValid(It.IsAny <string>())).Return(false);
var userService = new UserService(null, emailValidation);
Assert.Throws(typeof(ArgumentException), () => userService.Save(user), "Email is invalid");
}
public async Task C_G_RhinoMocksButIfYouExplicitlyExpectThenOfCourseItWorks()
{
var mocks = new Rhino.Mocks.MockRepository();
var service = mocks.DynamicMock <IService>();
Expect.Call(service.DoSomethingAsync()).Return(Task.CompletedTask);
var sut = new Sut
{
Service = service
};
mocks.ReplayAll();
await sut.UseServiceAsync();
mocks.VerifyAll();
}
public void Rhino_Exception()
{
// Arrange
var mockDataAccess = MockRepository.GenerateMock <IDataAccess>();
mockDataAccess.Stub(da => da.GetSpecificDrugs(Arg <List <int> > .Is.Anything)).Throw(new ArgumentException());
var mockThirdPartyAccess = MockRepository.GenerateMock <IThirdPartyDataAccess>();
var drugService = new DrugService(mockDataAccess, mockThirdPartyAccess);
// Act
Action getSpecificDrugs = () => drugService.GetSpecificDrugs(Arg <List <int> > .Is.Anything);
// Assert
getSpecificDrugs.ShouldThrow <ArgumentException>();
}
public void Rhino_onDrugRetrieved_WhenEventRaised_HaveDrugsBeenReceivedIsSet()
{
// Arrange
var mockDataAccess = MockRepository.GenerateMock <IDataAccess>();
var mockThirdPartyAccess = MockRepository.GenerateMock <IThirdPartyDataAccess>();
var drugService = new DrugService(mockDataAccess, mockThirdPartyAccess);
drugService.HaveDrugsBeenReceived.ShouldBeFalse();
// Act
// Assert
mockThirdPartyAccess.Raise(tpa => tpa.OnDrugsRetrievedEvent += null, mockThirdPartyAccess, new DrugsRetrievedArgs {
HaveDrugsBeenRetrieved = true
});
drugService.HaveDrugsBeenReceived.ShouldBeTrue();
}
public void GetById_ValidId_ReturnsUser()
{
int id = 1;
var user = new User()
{
Id = id
};
var userRepository = MockRepository.GenerateMock <IUserRepository>();
userRepository.Expect(p => p.GetById(id)).Return(user);
var userService = new UserService(userRepository, null);
var r = userService.GetById(id);
Assert.AreEqual(user, r);
userRepository.VerifyAllExpectations();
}
public void Save_ValidUser_Success()
{
var user = new User()
{
Name = "John",
Email = "*****@*****.**"
};
var emailValidation = MockRepository.GenerateStub <IEmailValidation>();
var userRepository = MockRepository.GenerateMock <IUserRepository>();
emailValidation.Stub(p => p.isValid(It.IsAny <string>())).Return(true);
userRepository.Expect(p => p.Save(It.Is <User>(u => u.Equals(user))));
var userService = new UserService(userRepository, emailValidation);
userService.Save(user);
userRepository.VerifyAllExpectations();
}
public void Should_invoke_the_isautheticated_and_roles_functions()
{
// Arrange
var context = MockRepository.GenerateMock <ISecurityContext>();
context.Expect(x => x.CurrenUserAuthenticated()).Return(true).Repeat.Once();
context.Expect(x => x.CurrenUserRoles()).Return(new List <object> {
UserRole.Owner
}.ToArray()).Repeat.Once();
context.Replay();
var policyContainer = new PolicyContainer(TestDataFactory.ValidControllerName, TestDataFactory.ValidActionName, TestDataFactory.CreateValidPolicyAppender());
policyContainer.AddPolicy(new TestPolicy());
// Act
policyContainer.EnforcePolicies(context);
// Assert
context.VerifyAllExpectations();
}
public void Rhino_GetTheDrugs()
{
// Arrange
var mockDataAccess = MockRepository.GenerateMock <IDataAccess>();
mockDataAccess.Expect(da => da.GetAllTheDrugs()).Return(_fakeDrugList);
var mockThirdPartyAccess = MockRepository.GenerateMock <IThirdPartyDataAccess>();
mockThirdPartyAccess.Expect(tpa => tpa.GetThirdPartyDrugInfo(_fakeDrug1)).Return(FakeThirdPartyInfo1);
mockThirdPartyAccess.Expect(tpa => tpa.GetThirdPartyDrugInfo(_fakeDrug2)).Return(FakeThirdPartyInfo2);
mockThirdPartyAccess.Expect(tpa => tpa.GetThirdPartyDrugInfo(_fakeDrug3)).Return(FakeThirdPartyInfo3);
var drugService = new DrugService(mockDataAccess, mockThirdPartyAccess);
// Act
var actualDrugs = drugService.GetTheDrugs();
// Assert
actualDrugs.Count().ShouldBe(3);
mockDataAccess.AssertWasCalled(da => da.GetAllTheDrugs(), options => options.Repeat.Times(1));
mockThirdPartyAccess.AssertWasCalled(da => da.GetThirdPartyDrugInfo(Arg <Drug> .Is.Anything), options => options.Repeat.Times(3));
}
public void TestInitialize()
{
_mockScheduleRepository = MockRepository.GenerateMock <IScheduleShiftRepository>();
_scheduleShiftController = new ScheduleShiftController(_mockScheduleRepository);
}
