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 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 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 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 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 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 void Setup()
{
basketRepository = MockRepository.GenerateStub<IRepository<Basket>>();
unitOfWorkManager = MockRepository.GenerateStub<IUnitOfWorkManager>();
userService = MockRepository.GenerateStub<IUserService>();
postageService = MockRepository.GenerateStub<IPostageService>();
countryRepository = MockRepository.GenerateStub<IRepository<Country>>();
cardTypeRepository = MockRepository.GenerateStub<IRepository<CardType>>();
orderRepository = MockRepository.GenerateStub<IRepository<Order>>();
subscriptionRepository = MockRepository.GenerateStub<IRepository<MailingListSubscription>>();
emailService = MockRepository.GenerateStub<IEmailService>();
var mocks = new MockRepository(); //TODO: No need to partial mock once email sending is fixed
controller = new CheckoutController(
basketRepository,
userService,
postageService,
countryRepository,
cardTypeRepository,
orderRepository,
unitOfWorkManager,
emailService,
subscriptionRepository
);
mocks.ReplayAll();
userService.Expect(us => us.CurrentUser).Return(new User { UserId = 4, RoleId = Role.AdministratorId });
}
/// <summary>
/// Creates a mocked datareader and loads it with row data ready to replay
/// </summary>
/// <param name="mocks">The mock repository object that all the tests are running with</param>
/// <param name="procedureName">The name of the procedure you want to call</param>
/// <param name="creator">The new DataReaderCreator object</param>
/// <param name="reader">The new DataReader object</param>
/// <param name="testRowData">A list of test row data to load the reader with</param>
static public void CreateMockedDataBaseObjects(MockRepository mocks, string procedureName, out IDnaDataReaderCreator creator, out IDnaDataReader reader, List<TestDatabaseRow> testRowData)
{
reader = CreateMockedIDnaDataReader(mocks, testRowData);
creator = mocks.DynamicMock<IDnaDataReaderCreator>();
creator.Stub(x => x.CreateDnaDataReader(procedureName)).Return(reader);
mocks.ReplayAll();
}
public static void TestCacheInvalidationForPost(string method)
{
const string relatedUrl = "http://api/SomeLocationUrl/";
// setup
var locationUrl = new Uri(relatedUrl);
var mocks = new MockRepository();
var request = new HttpRequestMessage(new HttpMethod(method), TestUrl);
string routePattern = "http://myserver/api/stuffs/*";
var entityTagStore = mocks.StrictMock<IEntityTagStore>();
var cachingHandler = new CachingHandler(new HttpConfiguration(), entityTagStore)
{
};
var entityTagKey = new CacheKey(TestUrl, new string[0], routePattern);
var response = new HttpResponseMessage();
response.Headers.Location = locationUrl;
var invalidateCacheForPost = cachingHandler.PostInvalidationRule(entityTagKey, request, response);
if(method == "POST")
{
entityTagStore.Expect(x => x.RemoveAllByRoutePattern("/SomeLocationUrl/")).Return(1);
}
mocks.ReplayAll();
// run
invalidateCacheForPost();
// verify
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 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 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 TestIndirectBlocks()
{
var repository = new MockRepository();
var mockDiskAccess = repository.DynamicMock<IDirectDiskAccess>();
var mockAllocator = repository.StrictMock<IBlockAllocator>();
const int blocksToAllocate = 2000;
var list = new List<Address>();
for (int i = 0; i < blocksToAllocate; ++i)
{
list.Add(new Address((ulong)i * Constants.BlockSizeBytes));
}
Expect.Call(mockAllocator.AllocateBlocks(blocksToAllocate)).IgnoreArguments().Return(list.ToArray());
Expect.Call(mockAllocator.AllocateBlocks(1)).IgnoreArguments().Return(new[] { new Address(0) }).Repeat.Times(3); // indirect block allocation
Expect.Call(() => mockAllocator.FreeBlocks(null)).IgnoreArguments().Repeat.Any();
var storage = new BlockAddressStorage(mockDiskAccess, mockAllocator, new Address(0), new Address(0));
repository.ReplayAll();
storage.AddBlocks(2000);
storage.GetBlockStartAddress(12);
storage.GetBlockStartAddress(1024);
storage.GetBlockStartAddress(1024 + 12);
storage.GetBlockStartAddress(1999);
Assert.Throws<IndexOutOfRangeException>(() => storage.GetBlockStartAddress(2000));
repository.VerifyAll();
}
public void Initalize_Sets_URL_On_View()
{
MockRepository repo = new MockRepository();
IOptionsView mockOptionsView = repo.StrictMock<IOptionsView>();
ISettingsOriginator mockSettingsOriginator = repo.StrictMock<ISettingsOriginator>();
ISettingsMemento mockSettingsMemento = repo.StrictMock<ISettingsMemento>();
ISetting urlSetting = repo.StrictMock<ISetting>();
ISetting userNameSetting = repo.StrictMock<ISetting>();
ISetting passwordSetting = repo.StrictMock<ISetting>();
string url = "http://www.google.com";
string userName = "******";
string password = "******";
urlSetting.Expect(set => set.Value).Return(url);
userNameSetting.Expect(set => set.Value).Return(userName);
passwordSetting.Expect(set => set.Value).Return(password);
mockSettingsOriginator.Expect(org => org.Get("TrackerURL")).Return(urlSetting);
mockSettingsOriginator.Expect(org => org.Get("UserName")).Return(userNameSetting);
mockSettingsOriginator.Expect(org => org.Get("Password")).Return(passwordSetting);
mockSettingsOriginator.Expect(org => org.GetMemento()).Return(mockSettingsMemento);
mockOptionsView.Expect(view => view.URL).SetPropertyWithArgument(url);
mockOptionsView.Expect(view => view.UserName).SetPropertyWithArgument(userName);
mockOptionsView.Expect(view => view.Password).SetPropertyWithArgument(password);
repo.ReplayAll();
IOptionsPresenter pres = new OptionsPresenter(mockOptionsView, mockSettingsOriginator);
pres.Initalize();
mockOptionsView.VerifyAllExpectations();
mockSettingsOriginator.VerifyAllExpectations();
urlSetting.VerifyAllExpectations();
}
public void HasReached_GenerationNumberLowerThanCondition_False()
{
var repository = new MockRepository();
var ga = repository.StrictMock<IGeneticAlgorithm>();
using (repository.Ordered())
{
ga.Expect(g => g.GenerationsNumber).Return(1);
ga.Expect(g => g.GenerationsNumber).Return(2);
ga.Expect(g => g.GenerationsNumber).Return(3);
ga.Expect(g => g.GenerationsNumber).Return(4);
ga.Expect(g => g.GenerationsNumber).Return(5);
ga.Expect(g => g.GenerationsNumber).Return(6);
ga.Expect(g => g.GenerationsNumber).Return(7);
ga.Expect(g => g.GenerationsNumber).Return(8);
ga.Expect(g => g.GenerationsNumber).Return(0);
}
repository.ReplayAll();
var target = new GenerationNumberTermination(10);
Assert.IsFalse(target.HasReached(ga));
for (int i = 0; i < 8; i++)
{
Assert.IsFalse(target.HasReached(ga));
}
}
public void CorrectlyExecutesScriptIfItHasntAlreadyBeenExecuted()
{
ConnectionSettings settings = getConnectionSettings();
string scriptFile = @"c:\scripts\Update\01_Test.sql";
string fileContents = "file contents...";
MockRepository mocks = new MockRepository();
IScriptExecutionTracker executionTracker = mocks.CreateMock<IScriptExecutionTracker>();
IFileSystem fileSystem = mocks.CreateMock<IFileSystem>();
IQueryExecutor queryExecutor = mocks.CreateMock<IQueryExecutor>();
ITaskObserver taskObserver = mocks.CreateMock<ITaskObserver>();
Expect.Call(executionTracker.ScriptAlreadyExecuted(settings, "01_Test.sql")).Return(false);
taskObserver.Log("Executing: 01_Test.sql");
Expect.Call(fileSystem.ReadTextFile(scriptFile)).Return(fileContents);
queryExecutor.ExecuteNonQuery(settings, fileContents, true);
executionTracker.MarkScriptAsExecuted(settings, "01_Test.sql", taskObserver);
mocks.ReplayAll();
IChangeScriptExecutor executor = new ChangeScriptExecutor(executionTracker, queryExecutor, fileSystem);
executor.Execute(scriptFile, settings, taskObserver);
mocks.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 Initialize()
{
Queue<string> tags = new Queue<string>();
tags.Enqueue("<2cents>");
tags.Enqueue("<ale>");
tags.Enqueue("<yikes>");
tags.Enqueue(";)");
tags.Enqueue("<3");
Queue<string> tagTranslation = new Queue<string>();
tagTranslation.Enqueue("2cents");
tagTranslation.Enqueue("ale");
tagTranslation.Enqueue("yikes");
tagTranslation.Enqueue("winkeye");
tagTranslation.Enqueue("specialheart");
MockRepository mocks = new MockRepository();
IDnaDataReader reader = mocks.DynamicMock<IDnaDataReader>();
reader.Stub(x => x.HasRows).Return(true);
//reader.Stub(x => x.Read()).Return(true).Repeat.Times(4);
reader.Stub(x => x.Read()).Return(true).Repeat.Times(4);
reader.Stub(x => x.GetStringNullAsEmpty("name")).Return("").WhenCalled(x => x.ReturnValue = tagTranslation.Dequeue());
reader.Stub(x => x.GetStringNullAsEmpty("tag")).Return("").WhenCalled(x => x.ReturnValue = tags.Dequeue());
IDnaDataReaderCreator creator = mocks.DynamicMock<IDnaDataReaderCreator>();
creator.Stub(x => x.CreateDnaDataReader("getsmileylist")).Return(reader);
mocks.ReplayAll();
SmileyTranslator.LoadSmileys(creator);
ProfanityFilterTests.InitialiseProfanities();
}
public static void TestCachingContinuation(
string method,
bool existsInStore,
bool addVaryHeader,
bool addLastModifiedHeader,
bool alreadyHasLastModified,
string[] varyByHeader)
{
// setup
var mocks = new MockRepository();
var request = new HttpRequestMessage(new HttpMethod(method), TestUrl);
request.Headers.Add(HttpHeaderNames.Accept, "text/xml");
request.Headers.Add(HttpHeaderNames.AcceptLanguage, "en-GB");
var entityTagStore = mocks.StrictMock<IEntityTagStore>();
var cachingHandler = new CachingHandler(entityTagStore, varyByHeader)
{
AddLastModifiedHeader = addLastModifiedHeader,
AddVaryHeader = addVaryHeader
};
var entityTagHeaderValue = new TimedEntityTagHeaderValue("\"12345678\"");
var entityTagKey = new EntityTagKey(TestUrl, new string[0]);
cachingHandler.EntityTagKeyGenerator = (x, y) => entityTagKey;
cachingHandler.ETagValueGenerator = (x, y) => new EntityTagHeaderValue(entityTagHeaderValue.Tag);
entityTagStore.Expect(x => x.TryGet(Arg<EntityTagKey>.Matches(etg => etg.ResourceUri == TestUrl),
out Arg<TimedEntityTagHeaderValue>.Out(entityTagHeaderValue).Dummy)).Return(existsInStore);
if (!existsInStore || request.Method == HttpMethod.Put || request.Method == HttpMethod.Post)
{
entityTagStore.Expect(
x => x.AddOrUpdate(Arg<EntityTagKey>.Matches(etk => etk == entityTagKey),
Arg<TimedEntityTagHeaderValue>.Matches(ethv => ethv.Tag == entityTagHeaderValue.Tag)));
}
mocks.ReplayAll();
var response = new HttpResponseMessage();
response.Content = new ByteArrayContent(new byte[0]);
if(alreadyHasLastModified)
response.Content.Headers.Add(HttpHeaderNames.LastModified, DateTimeOffset.Now.ToString("r"));
var cachingContinuation = cachingHandler.GetCachingContinuation(request);
var taskCompletionSource = new TaskCompletionSource<HttpResponseMessage>();
taskCompletionSource.SetResult(response);
// run
var httpResponseMessage = cachingContinuation(taskCompletionSource.Task);
// test
if(addLastModifiedHeader)
{
Assert.That(httpResponseMessage.Content.Headers.Any(x=>x.Key == HttpHeaderNames.LastModified),
"LastModified does not exist");
}
if(!addLastModifiedHeader && !alreadyHasLastModified)
{
Assert.That(!httpResponseMessage.Content.Headers.Any(x => x.Key == HttpHeaderNames.LastModified),
"LastModified exists");
}
}
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 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 static HttpContextBase DynamicHttpContextBase()
{
var mocks = new MockRepository();
var context = mocks.DynamicHttpContextBase();
mocks.ReplayAll();
return context;
}
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 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 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 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 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 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 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 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);
}
