public void AssemblyAnalisysTest()
{
Assembly assembly = Assembly.Load("Karma.Core.AssemblyAnalyzerSample");
MockRepository repository = new MockRepository();
IClassAnalyzer classAnalyzer = repository.StrictMock<IClassAnalyzer>();
Expect.Call(classAnalyzer.Analyze(null))
.IgnoreArguments()
.Return(new ClassMetadata(typeof(User)))
.Repeat.Twice();
repository.ReplayAll();
AssemblyAnalyzer analyzer = new AssemblyAnalyzer();
analyzer.ClassAnalyzer = classAnalyzer;
AssemblyMetadata metadata = analyzer.Analyze(assembly);
Assert.That(metadata, Is.Not.Null);
Assert.That(metadata.Attributes, Is.Not.Null);
Assert.That(metadata.Attributes, Is.Not.Empty);
Assert.That(metadata.Attributes.Count, Is.EqualTo(1));
Assert.That(metadata.Classes, Is.Not.Null);
Assert.That(metadata.Classes, Is.Not.Empty);
Assert.That(metadata.Classes.Count, Is.EqualTo(2));
repository.VerifyAll();
}
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 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 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 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 ShouldBeAbleToAddNewOrder()
{
// arrange
var mock = new MockRepository();
var repository = mock.DynamicMock<IOrderRepository>();
const string IdentityToken = "*****@*****.**";
const string RetailerUrl = "amazon.com";
Expect.Call(repository.AddOrder(IdentityToken, new Order { Retailer = new Retailer(RetailerUrl) }))
.Return(new Order(OrderStatus.New) { Retailer = new Retailer(RetailerUrl), CreatedDate = DateTime.UtcNow });
var service = new OrderService(repository, new FakeEmailService(), this.logger);
var request = new AddOrderRequest
{
IdentityToken = IdentityToken,
RetailerUrl = RetailerUrl,
CreatedDate = DateTime.UtcNow
};
// act
mock.ReplayAll();
var actual = service.AddOrder(request);
mock.VerifyAll();
// assert
Assert.That(actual, Is.Not.Null);
Assert.That(actual.CreatedDate, Is.EqualTo(request.CreatedDate).Within(1).Minutes);
Assert.That(actual.RetailerUrl, Is.EqualTo(request.RetailerUrl));
}
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 Updates_database()
{
var settings = new ConnectionSettings("server", "db", true, null, null);
var taskAttributes = new TaskAttributes(settings, "c:\\scripts");
taskAttributes.RequestedDatabaseAction = RequestedDatabaseAction.Update;
var mocks = new MockRepository();
var scriptfolderexecutor = mocks.StrictMock<IScriptFolderExecutor>();
var queryexecutor = mocks.StrictMock<IQueryExecutor>();
queryexecutor.Stub(x => x.CheckDatabaseExists(taskAttributes.ConnectionSettings)).Return(true);
var taskObserver = mocks.StrictMock<ITaskObserver>();
using (mocks.Record())
{
taskObserver.Log(string.Format("Run scripts in Update folder."));
scriptfolderexecutor.ExecuteScriptsInFolder(taskAttributes, "Update", taskObserver);
taskObserver.Log(string.Format("Run scripts in Everytime folder."));
scriptfolderexecutor.ExecuteChangedScriptsInFolder(taskAttributes, "Everytime", taskObserver);
taskObserver.Log(string.Format("Run scripts in RunAlways folder."));
scriptfolderexecutor.ExecuteRunAlwaysScriptsInFolder(taskAttributes, "RunAlways", taskObserver);
}
using (mocks.Playback())
{
IDatabaseActionExecutor updater = new DatabaseUpdater(scriptfolderexecutor, queryexecutor);
updater.Execute(taskAttributes, taskObserver);
}
mocks.VerifyAll();
}
public void BidirectionalConverter_Should_Convert_All_Items()
{
var mocks = new MockRepository();
var converter1 = mocks.StrictMock<IBidirectionalConverter<int, string>>();
Expect.Call(converter1.Convert(5)).Return("5");
Expect.Call(converter1.Convert(3)).Return("3");
Expect.Call(converter1.Convert(7)).Return("7");
var converter2 = mocks.StrictMock<IBidirectionalConverter<string, int>>();
Expect.Call(converter2.Convert("5")).Return(5);
Expect.Call(converter2.Convert("3")).Return(3);
Expect.Call(converter2.Convert("7")).Return(7);
mocks.ReplayAll();
// Convert one way
IList<int> input1 = new List<int> { 5, 3, 7 };
var output1 = converter1.ConvertAll(input1);
Assert.IsTrue(output1.Contains("5"));
Assert.IsTrue(output1.Contains("3"));
Assert.IsTrue(output1.Contains("7"));
// Convert the other way
IList<string> input2 = new List<string> { "5", "3", "7" };
var output2 = converter2.ConvertAll(input2);
Assert.IsTrue(output2.Contains(5));
Assert.IsTrue(output2.Contains(3));
Assert.IsTrue(output2.Contains(7));
mocks.VerifyAll();
}
public void Certifies_deployment()
{
var deployment = new Deployment();
var mocks = new MockRepository();
var clock = mocks.CreateMock<ISystemClock>();
var securityContext = mocks.CreateMock<ISecurityContext>();
var repository = mocks.CreateMock<IDeploymentRepository>();
using (mocks.Record())
{
Expect.Call(clock.GetCurrentDateTime()).Return(new DateTime(2007, 4, 15));
Expect.Call(securityContext.GetCurrentUsername()).Return("khurwitz");
repository.Save(deployment);
}
using (mocks.Playback())
{
IVersionCertifier certifier = new VersionCertifier(clock, securityContext, repository);
certifier.Certify(deployment);
Assert.That(deployment.CertifiedBy, Is.EqualTo("khurwitz"));
Assert.That(deployment.CertifiedOn, Is.EqualTo(new DateTime(2007, 4, 15)));
}
mocks.VerifyAll();
}
public void Search()
{
// Basic integration test: search algorithms are already extensively tested with InMemoryIndexBase
MockRepository mocks = new MockRepository();
IIndexConnector conn = mocks.StrictMock<IIndexConnector>();
ScrewTurn.Wiki.SearchEngine.IWordFetcher fetcher = mocks.StrictMock<ScrewTurn.Wiki.SearchEngine.IWordFetcher>();
ScrewTurn.Wiki.SearchEngine.Word dummy = null;
Expect.Call(fetcher.TryGetWord("test", out dummy)).Return(false);
Expect.Call(fetcher.TryGetWord("query", out dummy)).Return(false);
fetcher.Dispose();
LastCall.On(fetcher);
Expect.Call(conn.GetWordFetcher()).Return(fetcher);
mocks.ReplayAll();
SqlIndex index = new SqlIndex(conn);
Assert.AreEqual(0, index.Search(new ScrewTurn.Wiki.SearchEngine.SearchParameters("test query")).Count, "Wrong search result count");
mocks.VerifyAll();
}
public void Should_not_fail_if_datebase_does_not_exist()
{
var settings = new ConnectionSettings("server", "db", true, null, null);
var taskAttributes = new TaskAttributes(settings, null);
var mocks = new MockRepository();
var connectionDropper = mocks.DynamicMock<IDatabaseConnectionDropper>();
var taskObserver = mocks.CreateMock<ITaskObserver>();
var queryExecutor = mocks.CreateMock<IQueryExecutor>();
using (mocks.Record())
{
Expect.Call(() => queryExecutor.ExecuteNonQuery(settings, "ALTER DATABASE [db] SET SINGLE_USER WITH ROLLBACK IMMEDIATE drop database [db]", false))
.Throw(new Exception("foo message"));
Expect.Call(() => taskObserver.Log("Database 'db' could not be dropped."));
}
using (mocks.Playback())
{
IDatabaseActionExecutor dropper = new DatabaseDropper(connectionDropper, queryExecutor);
dropper.Execute(taskAttributes, taskObserver);
}
mocks.VerifyAll();
}
public void GigController_Should_Contain_Index_Method_Which_Accepts_GigID_And_Returns_A_Gig()
{
MockRepository mocks = new MockRepository();
Guid gigId = Guid.NewGuid();
Gig gig = new Gig();
gig.ID = gigId;
//Mock the GigManager
IGigManager gigManager = mocks.DynamicMock<IGigManager>();
GigController gigController = new GigController();
gigController.GigManager = gigManager;
Expect.Call(gigManager.GetByID(gigId))
.Constraints(Is.Equal(gigId))
.Repeat.Once()
.Return(gig);
mocks.ReplayAll();
ViewResult result = (ViewResult)gigController.Index(gigId);
Gig returnedData = (Gig)(result.ViewData.Model);
mocks.VerifyAll();
Assert.IsNotNull(returnedData);
Assert.AreEqual(gig.ID, returnedData.ID);
}
public void Drops_database()
{
var settings = new ConnectionSettings("server", "db", true, null, null);
var taskAttributes = new TaskAttributes(settings, null);
var mocks = new MockRepository();
var connectionDropper = mocks.CreateMock<IDatabaseConnectionDropper>();
var taskObserver = mocks.CreateMock<ITaskObserver>();
var queryExecutor = mocks.CreateMock<IQueryExecutor>();
using (mocks.Record())
{
connectionDropper.Drop(settings, taskObserver);
queryExecutor.ExecuteNonQuery(settings, "ALTER DATABASE [db] SET SINGLE_USER WITH ROLLBACK IMMEDIATE drop database [db]", false);
}
using (mocks.Playback())
{
IDatabaseActionExecutor dropper = new DatabaseDropper(connectionDropper, queryExecutor);
dropper.Execute(taskAttributes, taskObserver);
}
mocks.VerifyAll();
}
public void CanCreateNewSite()
{
Site site = DomainTestHelper.GetTestSite();
Theme theme = MockRepository.GenerateStub<Theme>();
theme.BasePath = "~/themes/default";
theme.Name = "default";
site.Theme = theme;
MockRepository mocks = new MockRepository();
sessionFactory = MockRepository.GenerateMock<Arashi.Core.NHibernate.ISessionFactory>();
session = MockRepository.GenerateMock<ISession>();
Site createdSite;
using (mocks.Record())
{
sessionFactory.Expect(x => x.GetSession()).Return(session /*MockRepository.GenerateStub<ISession>()*/);
session.Expect(x => x.BeginTransaction()).Return(MockRepository.GenerateStub <ITransaction>());
}
using (mocks.Playback())
{
ISiteService siteService = new SiteService( sessionFactory, // this.AutoMockingContainer().Resolve<Arashi.Core.NHibernate.ISessionFactory>(),
this.AutoMockingContainer().Resolve<ILog>(),
this.AutoMockingContainer().Resolve<IUserService>(),
this.AutoMockingContainer().Resolve<IFileService>());
createdSite = siteService.CreateNewSite("Test", "test", "*****@*****.**", "localhost", theme);
}
mocks.VerifyAll();
createdSite.Should().Not.Be.Null();
createdSite.Name.Should().Be.EqualTo(site.Name);
createdSite.Hosts.Count.Should().Be.GreaterThanOrEqualTo(1);
createdSite.Hosts[0].Should().Not.Be.Null();
createdSite.Theme.Should().Be.EqualTo(theme);
//NHibernate.ISession session = mocks.StrictMock<NHibernate.ISession>();
//NHibernate.ITransaction transaction = mocks.Stub<NHibernate.ITransaction>();
//Student expected = new Student();
//Student actual;
//using (mocks.Record())
//{
// Rhino.Mocks.Expect.Call(session.Transaction)
// .Return(transaction)
// .Repeat.Any();
// Rhino.Mocks.Expect.Call(transaction.IsActive)
// .Return(true);
// Rhino.Mocks.Expect.Call(session.Get<Student>(Guid.Empty))
// .Return(expected);
//}
//using (mocks.Playback())
//{
// IReadStudent StudentDao = new StudentDAOImpl(session);
// actual = StudentDao.GetById(Guid.Empty);
//}
//mocks.VerifyAll();
//Assert.IsNotNull(actual);
//Assert.AreSame(expected, actual);
}
public void Executes_all_the_scripts_within_a_folder()
{
var settings = new ConnectionSettings("server", "db", true, null, null);
var sqlFiles = new[] { "c:\\scripts\\Update\\001.sql", "c:\\scripts\\Update\\002_data_.sql", "c:\\scripts\\Update\\003.sql" };
var taskAttributes = new TaskAttributes(settings, "c:\\scripts")
{
RequestedDatabaseAction = RequestedDatabaseAction.Update,
};
var mocks = new MockRepository();
var initializer = mocks.StrictMock<ISchemaInitializer>();
var fileLocator = mocks.StrictMock<ISqlFileLocator>();
var executor = mocks.StrictMock<IChangeScriptExecutor>();
var testdataexecutor = mocks.StrictMock<ITestDataScriptExecutor>();
var versioner = mocks.StrictMock<IDatabaseVersioner>();
var taskObserver = mocks.StrictMock<ITaskObserver>();
using (mocks.Record())
{
initializer.EnsureSchemaCreated(settings);
Expect.Call(fileLocator.GetSqlFilenames("c:\\scripts", "Update")).Return(sqlFiles);
executor.Execute("c:\\scripts\\Update\\001.sql", settings, taskObserver);
executor.Execute("c:\\scripts\\Update\\002_data_.sql", settings, taskObserver);
executor.Execute("c:\\scripts\\Update\\003.sql", settings, taskObserver);
versioner.VersionDatabase(settings, taskObserver);
}
using (mocks.Playback())
{
IScriptFolderExecutor folderExecutor = new ScriptFolderExecutor(initializer, fileLocator, executor, testdataexecutor, versioner);
folderExecutor.ExecuteScriptsInFolder(taskAttributes, "Update", taskObserver);
}
mocks.VerifyAll();
}
public void Simple()
{
var list = GetTestList();
var mockRepository = new MockRepository();
var trackingList = mockRepository.StrictMock<IList<int>>();
// All items should be visited...
trackingList.Add(1);
trackingList.Add(2);
trackingList.Add(3);
trackingList.Add(8);
trackingList.Add(5);
mockRepository.ReplayAll();
var generalVisitor = new GeneralVisitor<int>(
delegate (int value) {
trackingList.Add(value);
return false;
}
);
list.AcceptVisitor(generalVisitor);
mockRepository.VerifyAll();
}
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 PublishDomainEvents()
{
var e = new TestEvent();
var mockRepository = new MockRepository();
IEnumerable<object> handlers;
using (mockRepository.Record())
{
var handler1 = mockRepository.StrictMock<IEventHandler<TestEvent>>();
handler1.Expect(h => h.Handle(e)).Repeat.Once();
var handler2 = mockRepository.StrictMock<IEventHandler<TestEvent>>();
handler2.Expect(h => h.Handle(e)).Repeat.Once();
handlers = new[] { handler1, handler2 };
}
MultiInstanceFactory multiInstanceFactory = t => handlers;
var publisher = new DomainEventsPublisher(multiInstanceFactory);
DomainEvents.Raise(e);
using (mockRepository.Playback())
publisher.Publish();
mockRepository.VerifyAll();
}
public void SetPort_three_locations()
{
var expectedPort = 1234;
var mockRepository = new MockRepository();
// Arrange
var fileManipulation = mockRepository.StrictMock<IFileManipulation>();
var paths = mockRepository.StrictMock<IPaths>();
var neo4JServerConfigSettings = mockRepository.StrictMock<INeo4jServerConfigSettings>();
neo4JServerConfigSettings.Expect(n => n.Port).Return("org.neo4j.server.webserver.port");
neo4JServerConfigSettings.Expect(n => n.WebAdminDataUri).Return("webadmindatauri");
neo4JServerConfigSettings.Expect(n => n.WebAdminManagementUri).Return("webadminmanagementuri");
var neo4JManager = new Neo4jManager(fileManipulation, null);
paths.Expect(p => p.Neo4jServerConfigSettings).Return(neo4JServerConfigSettings);
paths.Expect(p => p.Neo4jAdminDataUri).Return("Neo4jAdminDataUri");
paths.Expect(p => p.Neo4jAdminManagementUri).Return("Neo4jAdminManagementUri");
paths.Expect(p => p.Neo4jServerConfigPath).Return("Neo4jServerConfigPath");
fileManipulation.Expect(fm => fm.ReplaceConfigLine(null, null)).IgnoreArguments();
mockRepository.ReplayAll();
// Act
neo4JManager.SetServerPortAndUrlConfig(paths, expectedPort);
// Assert
mockRepository.VerifyAll();
}
public void Correctly_constructs_action_executors()
{
DatabaseAction[] actions = new DatabaseAction[] { DatabaseAction.Create, DatabaseAction.Update };
MockRepository mocks = new MockRepository();
IDatabaseActionResolver resolver = mocks.StrictMock<IDatabaseActionResolver>();
IDataBaseActionLocator locator = mocks.StrictMock<IDataBaseActionLocator>();
IDatabaseActionExecutor creator = mocks.StrictMock<IDatabaseActionExecutor>();
IDatabaseActionExecutor updater = mocks.StrictMock<IDatabaseActionExecutor>();
using (mocks.Record())
{
Expect.Call(resolver.GetActions(RequestedDatabaseAction.Create)).Return(actions);
Expect.Call(locator.CreateInstance(DatabaseAction.Create)).Return(creator);
Expect.Call(locator.CreateInstance(DatabaseAction.Update)).Return(updater);
}
using (mocks.Playback())
{
IDatabaseActionExecutorFactory factory = new DatabaseActionExecutorFactory(resolver, locator);
IEnumerable<IDatabaseActionExecutor> executors = factory.GetExecutors(RequestedDatabaseAction.Create);
IList<IDatabaseActionExecutor> executorList = new List<IDatabaseActionExecutor>(executors);
Assert.That(executorList, Is.EqualTo(new IDatabaseActionExecutor[]{ creator, updater }));
}
mocks.VerifyAll();
}
public void SetJavaPath()
{
string expectedFileName = "config/wrapper.conf";
string expectedWrapperJavaSetting = "wrapper.java.setting";
string expectedLocalJavaExePath = "c:/localjavapath/java.exe";
var mockRepository = new MockRepository();
// Arrange
var fileManipulation = mockRepository.StrictMock<IFileManipulation>();
var paths = mockRepository.StrictMock<IPaths>();
var neo4JManager = new Neo4jManager(fileManipulation, null);
paths.Expect(p => p.LocalJavaExePath).Return(expectedLocalJavaExePath);
paths.Expect(p => p.Neo4jWrapperSettingJavaCommand).Return(expectedWrapperJavaSetting);
paths.Expect(p => p.Neo4jWrapperConfigPath).Return(expectedFileName);
fileManipulation.Expect(fm => fm.ReplaceConfigLine(null, null)).IgnoreArguments();
mockRepository.ReplayAll();
// Act
neo4JManager.SetJavaPath(paths);
// Assert
mockRepository.VerifyAll();
}
public void Correctly_locates_sql_scripts_and_return_in_asc_order()
{
string scriptFolder = @"c:\scripts";
string[] updateSqlFiles = new string[] { "02_Update.sql", "01_Update.sql" };
MockRepository mocks = new MockRepository();
IFileSystem fileSystem = mocks.CreateMock<IFileSystem>();
using (mocks.Record())
{
Expect.Call(fileSystem.GetAllFilesWithExtensionWithinFolder(@"c:\scripts\Update", "sql")).Return(updateSqlFiles);
}
using (mocks.Playback())
{
ISqlFileLocator fileLocator = new SqlFileLocator(fileSystem);
string[] sqlFilenames = fileLocator.GetSqlFilenames(scriptFolder, "Update");
Assert.AreEqual(2, sqlFilenames.Length);
Assert.AreEqual("01_Update.sql", sqlFilenames[0]);
Assert.AreEqual("02_Update.sql", sqlFilenames[1]);
}
mocks.VerifyAll();
}
public void TestChainOneLink()
{
MockRepository mocks = new MockRepository();
var web = mocks.StrictMock<IWebInteractor>();
var site = new Website("www.whocares.com", "whatever");
var mockFSI = MockRepository.GenerateStub<IFileSystemInteractor>();
CrawlResult testResult = new CrawlResult();
testResult.ReturnCode = 200;
testResult.ReturnStatus = "OK";
testResult.Html = "href=\"/csse.html\"";
var resultTwo = new CrawlResult();
resultTwo.ReturnCode = 200;
resultTwo.ReturnStatus = "OK";
resultTwo.Html = "";
Expect.On(web).Call(web.GetPage("www.test.com")).Return(testResult);
Expect.On(web).Call(web.GetPage("www.test.com/csse.html")).Return(resultTwo);
mocks.ReplayAll();
Bot b = new Bot(new Website("www.test.com","simplepath"),null,null,web,mockFSI);
List<CrawlResult> results = b.CrawlSite(2);
mocks.VerifyAll();
Assert.AreEqual(2,results.Count);
}
public void NavigateTo(bool simulateSuccess)
{
MockRepository mocks = new MockRepository();
IGallioNavigator navigator = mocks.StrictMock<IGallioNavigator>();
using (mocks.Record())
{
Expect.Call(navigator.NavigateTo(
@"C:\Source\MbUnit\v3\src\Gallio\Gallio.Tests\Reflection\Impl\CecilReflectionPolicyTest.cs", 5, 11))
.Return(simulateSuccess);
}
using (mocks.Playback())
{
InstrumentedProgram program = new InstrumentedProgram();
program.Engine = navigator;
int returnCode = program.Run(new string[]
{
@"gallio:navigateTo?path=C:\Source\MbUnit\v3\src\Gallio\Gallio.Tests\Reflection\Impl\CecilReflectionPolicyTest.cs&line=5&column=11"
});
Assert.IsFalse(program.HelpCalled);
Assert.AreEqual(simulateSuccess ? 0 : 1, returnCode);
mocks.VerifyAll();
}
}
public void Manages_database()
{
var settings = new ConnectionSettings("server", "db", true, null, null);
var scriptDirectory = @"c:\scripts";
var taskAttributes = new TaskAttributes(settings, scriptDirectory);
taskAttributes.RequestedDatabaseAction= RequestedDatabaseAction.Create;
var mocks = new MockRepository();
var taskObserver = mocks.StrictMock<ITaskObserver>();
var generator = mocks.StrictMock<ILogMessageGenerator>();
var factory = mocks.StrictMock<IDatabaseActionExecutorFactory>();
var creator = mocks.StrictMock<IDatabaseActionExecutor>();
var updater = mocks.StrictMock<IDatabaseActionExecutor>();
var executors = new IDatabaseActionExecutor[] { creator, updater };
using (mocks.Record())
{
Expect.Call(generator.GetInitialMessage(taskAttributes)).Return("starting...");
taskObserver.Log("starting...");
Expect.Call(factory.GetExecutors(RequestedDatabaseAction.Create)).Return(executors);
creator.Execute(taskAttributes, taskObserver);
updater.Execute(taskAttributes, taskObserver);
}
using (mocks.Playback())
{
ISqlDatabaseManager manager = new SqlDatabaseManager(generator, factory);
manager.Upgrade(taskAttributes, taskObserver);
}
mocks.VerifyAll();
}
public void IsNotInvokedIfServiceObjectThrowsException()
{
MockRepository repository = new MockRepository();
IMethodInvocation mockInvocation = (IMethodInvocation)repository.CreateMock(typeof(IMethodInvocation));
IAfterReturningAdvice mockAdvice = (IAfterReturningAdvice)repository.CreateMock(typeof(IAfterReturningAdvice));
mockAdvice.AfterReturning(null, null, null, null);
LastCall.IgnoreArguments();
LastCall.Throw(new FormatException());
Expect.Call(mockInvocation.Method).Return(ReflectionUtils.GetMethod(typeof(object), "HashCode", new Type[] { }));
Expect.Call(mockInvocation.Arguments).Return(null);
Expect.Call(mockInvocation.This).Return(new object());
Expect.Call(mockInvocation.Proceed()).Return(null);
repository.ReplayAll();
try
{
AfterReturningAdviceInterceptor interceptor = new AfterReturningAdviceInterceptor(mockAdvice);
interceptor.Invoke(mockInvocation);
Assert.Fail("Must have thrown a FormatException by this point.");
}
catch (FormatException)
{
}
repository.VerifyAll();
}
public void Correctly_assigns_current_user_to_role()
{
MockRepository mocks = new MockRepository();
IPrincipal principal = mocks.CreateMock<IPrincipal>();
IIdentity identity = mocks.CreateMock<IIdentity>();
IWebContext context = mocks.CreateMock<IWebContext>();
IPrincipalFactory principalFactory = mocks.CreateMock<IPrincipalFactory>();
using (mocks.Record())
{
Expect.Call(context.GetUserIdentity()).Return(identity);
Expect.Call(principalFactory.CreatePrincipal(identity, "Administrator", "Other Role")).Return(principal);
context.SetUser(principal);
}
mocks.ReplayAll();
using (mocks.Playback())
{
IRoleAssigner assigner = new RoleAssigner(context, principalFactory);
assigner.AssignCurrentUserToRoles("Administrator", "Other Role");
}
mocks.VerifyAll();
}
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 Drops_Azure_database_without_dropping_connections()
{
var settings = new ConnectionSettings("server", "db", true, null, null);
var taskAttributes = new TaskAttributes(settings, null);
var mocks = new MockRepository();
var connectionDropper = mocks.StrictMock<IDatabaseConnectionDropper>();
var taskObserver = mocks.StrictMock<ITaskObserver>();
var queryExecutor = mocks.StrictMock<IQueryExecutor>();
using (mocks.Record())
{
Expect.Call(() => taskObserver.Log("Running against: SQL Azure"));
Expect.Call(queryExecutor.ReadFirstColumnAsStringArray(settings, "select @@version")).Return(new string[] { "SQL Azure" });
queryExecutor.ExecuteNonQuery(settings, "drop database [db]");
Expect.Call(() => taskObserver.Log("Dropping database: db\n"));
}
using (mocks.Playback())
{
IDatabaseActionExecutor dropper = new DatabaseDropper(connectionDropper, queryExecutor);
dropper.Execute(taskAttributes, taskObserver);
}
mocks.VerifyAll();
}
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 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 Get_Must_Revalidate_Etag_NotModified()
{
// setup
var request = new HttpRequestMessage(HttpMethod.Get, DummyUrl);
var responseFromCache = GetOkMessage(true);
responseFromCache.Headers.ETag = new EntityTagHeaderValue(ETagValue);
responseFromCache.Content.Headers.Expires = DateTime.Now.Subtract(TimeSpan.FromSeconds(10));
var responseFromServer = new HttpResponseMessage(HttpStatusCode.NotModified);
_messageHandler.Response = responseFromServer;
_cacheStore.Expect(
x => x.TryGetValue(Arg <CacheKey> .Is.Anything, out Arg <HttpResponseMessage> .Out(responseFromCache).Dummy))
.Return(true);
_cacheStore.Expect(x => x.AddOrUpdate(Arg <CacheKey> .Is.Anything, Arg <HttpResponseMessage> .Is.Anything));
_mockRepository.ReplayAll();
// run
var task = _client.SendAsync(request);
var responseReturned = task.Result;
var header = responseReturned.Headers.Single(x => x.Key == CacheCowHeader.Name);
CacheCowHeader cacheCowHeader = null;
CacheCowHeader.TryParse(header.Value.First(), out cacheCowHeader);
// verify
_mockRepository.VerifyAll();
Assert.IsNotNull(cacheCowHeader);
Assert.AreEqual(ETagValue, request.Headers.IfNoneMatch.First().Tag);
Assert.AreSame(responseFromCache, responseReturned);
Assert.AreEqual(true, cacheCowHeader.CacheValidationApplied);
}
public void Get_OK_But_Not_In_Cache_To_Insert_In_Cache()
{
// setup
var request = new HttpRequestMessage(HttpMethod.Get, DummyUrl);
var response = GetOkMessage();
_messageHandler.Response = response;
_cacheStore.Expect(x => x.TryGetValue(Arg <CacheKey> .Is.Anything,
out Arg <HttpResponseMessage> .Out(null).Dummy)).Return(false);
_cacheStore.Expect(x => x.AddOrUpdate(Arg <CacheKey> .Is.Anything,
Arg <HttpResponseMessage> .Is.Same(response)));
_mockRepository.ReplayAll();
// run
var task = _client.SendAsync(request);
var responseReturned = task.Result;
var header = responseReturned.Headers.Single(x => x.Key == CacheCowHeader.Name);
CacheCowHeader cacheCowHeader = null;
CacheCowHeader.TryParse(header.Value.First(), out cacheCowHeader);
// verify
_mockRepository.VerifyAll();
Assert.IsNotNull(cacheCowHeader);
Assert.AreEqual(true, cacheCowHeader.DidNotExist);
}
