public void CanReadFromValidStream()
{
string testString = "26/09/2008,1204.47,1215.77,1187.54,1213.27,5383610000,1213.27";
MockRepository mocks = new MockRepository();
TextReader sourceReader = mocks.Stub<TextReader>();
using (mocks.Record())
{
SetupResult
.For(sourceReader.ReadLine())
.Return(testString);
}
IParseIntervals intervalParser = mocks.Stub<IParseIntervals>();
using (mocks.Record())
{
SetupResult
.For(intervalParser.Parse("qwert", 0))
.IgnoreArguments()
.Return(new OHLCVInterval()
{
Close = 1213.27f,
// DataSource="Stub",
DateTime=new DateTime(2008,09,26),
High=1215.77f,
Index=0,
Instrument="StubInstrument",
//Interval="Day",
Exchange="StubExchange",
Low=1187.54f,
Open=1204.47f,
Volume=5383610000,
//Id = Guid.NewGuid()//"StubInstrument" + new DateTime(2008,09,26).Ticks.ToString()
}
);
}
bool hasHeader = false;
OHLCVIntervalReader reader = new OHLCVIntervalReader(sourceReader, intervalParser, hasHeader);
foreach (var interval in reader)
{
Assert.AreEqual(new DateTime(2008, 09, 26), interval.DateTime);
Assert.IsFalse(Math.Abs(1204.47f - interval.Open) > Single.Epsilon);
Assert.IsFalse(Math.Abs(1215.77f - interval.High) > Single.Epsilon);
Assert.IsFalse(Math.Abs(1187.54f - interval.Low) > Single.Epsilon);
Assert.IsFalse(Math.Abs(1213.27f - interval.Close) > Single.Epsilon);
Assert.AreEqual(5383610000, interval.Volume);
Assert.AreEqual(0, interval.Index);
Assert.AreEqual("StubExchange", interval.Exchange);
//Assert.AreEqual("Stub", interval.DataSource);
Assert.AreEqual("StubInstrument", interval.Instrument);
// Assert.AreEqual("StubInstrument" + new DateTime(2008, 09, 26).Ticks.ToString(), interval.Id);
break;
}
}
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 LoadsOnLoad()
{
MockRepository mockRepository = new MockRepository();
IHBaseConnection connection = mockRepository.Stub<IHBaseConnection>();
IHBaseRowData rowData = mockRepository.Stub<IHBaseRowData>();
IHBaseCellData cellData = mockRepository.Stub<IHBaseCellData>();
byte[] tableName = Encoding.UTF8.GetBytes("t");
byte[] rowKey = Encoding.UTF8.GetBytes("r");
byte[] columnName = Encoding.UTF8.GetBytes("c");
using (mockRepository.Record())
{
SetupResult.For(rowData.Key).Return(rowKey);
SetupResult.For(rowData.Columns).Return(new Dictionary<byte[], IList<IHBaseCellData>> { { columnName, new List<IHBaseCellData> { cellData } } });
SetupResult.For(connection.GetRow(tableName, rowKey)).Return(rowData);
}
using (mockRepository.Playback())
{
HBaseDatabase db = new HBaseDatabase(connection);
HBaseRow row = new HBaseRow(Encoding.UTF8.GetBytes("r"), new HBaseTable(Encoding.UTF8.GetBytes("t"), db));
row.Load();
Assert.Equal(1, row.Columns.Keys.Count);
}
}
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 DeleteTimeSeries_IsForwarded()
{
string identity = "mockid", datasetName = "mydataset";
var timeSeries = GetTimeSeries(180);
IForecastingApi api;
var mocks = new MockRepository();
using (mocks.Record())
{
api = mocks.StrictMock<IForecastingApi>();
Expect.Call(api.DeleteTimeSeries(identity, datasetName, null))
.Return(string.Empty)
.IgnoreArguments()
.Repeat.Twice(); // 180 time-series => two requests
}
using (mocks.Playback())
{
var client = new ForecastingClient(identity, api);
client.DeleteTimeSeries(datasetName, timeSeries.Select(d => d.Name).ToArray());
}
}
public void CompleteTest()
{
InstallController target = null;
// Arrange
MockRepository mocks = new MockRepository();
IInstallerService installerService = mocks.StrictMock<IInstallerService>();
ActionResult actual;
using (mocks.Record())
{
}
try
{
target = new InstallController(installerService);
using (mocks.Playback())
{
actual = target.Complete();
}
ControllerTestHelper.TestForEmptyViewAndModel(actual, target);
}
finally
{
if (target != null)
{
target.Dispose();
}
}
}
public void When_application_context_is_started_it_will_initialized_all_the_module_loader()
{
MockRepository mocks = new MockRepository();
IModuleLoader mockLoader1 = mocks.DynamicMock<IModuleLoader>();
IModuleLoader mockLoader2 = mocks.DynamicMock<IModuleLoader>();
IModuleLoader mockLoader3 = mocks.DynamicMock<IModuleLoader>();
IApplicationShell stubShell = mocks.Stub<IApplicationShell>();
DefaultApplicationContext context = mocks.PartialMock<DefaultApplicationContext>(
stubShell,
mocks.DynamicMock<ILayoutRegistry>(),
new IModuleLoader[] { mockLoader1, mockLoader2, mockLoader3 });
//we may have order dependnecies, let us verify
//that it does this in order
using (mocks.Record())
using (mocks.Ordered())
{
mockLoader1.Initialize(context, stubShell);
mockLoader2.Initialize(context, stubShell);
mockLoader3.Initialize(context, stubShell);
}
using (mocks.Playback())
{
context.Start();
}
}
public void FormatPhoneNumber_PhoneNumberInDresdenGermany_ReturnsFormattedNumber(
[Values(DISTANCE_RULE.CANONICAL, DISTANCE_RULE.InternationalRule, DISTANCE_RULE.LongDistanceRule,
DISTANCE_RULE.SameAreaRule)] DISTANCE_RULE distanceRule,
[Values("+49 (351) 1234567", "00493511234567", "03511234567", "1234567")] string expected)
{
MockRepository mocks = new MockRepository();
IPhoneNumberDataXml xmlDataProvider = mocks.Stub<IPhoneNumberDataXml>();
IPhoneNumberDataRegistry registryDataProvider = mocks.Stub<IPhoneNumberDataRegistry>();
string number = "+493511234567";
using (mocks.Record())
{
registryDataProvider.GetUserCountryID();
LastCall.Return("49");
registryDataProvider.GetUserAreaCode();
LastCall.Return("351");
registryDataProvider.GetPhoneFormat(49, DISTANCE_RULE.InternationalRule);
LastCall.Return("00EFG");
registryDataProvider.GetPhoneFormat(49, DISTANCE_RULE.LongDistanceRule);
LastCall.Return("0FG");
registryDataProvider.GetPhoneFormat(49, DISTANCE_RULE.SameAreaRule);
LastCall.Return("G");
xmlDataProvider.GetCountryCode("4935");
LastCall.Return("49");
xmlDataProvider.GetAreaCode("+493511234567");
LastCall.Return("+49351");
}
PhoneNumbers phoneNumberConverter = new PhoneNumbers(xmlDataProvider, registryDataProvider);
string actual = phoneNumberConverter.FormatPhoneNumber(number, distanceRule);
Assert.AreEqual(expected, actual);
}
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 List_getValidNumberAndReferencesOfBeautifulGirls()
{
const int countOfBeautifulGirls= 50;
var girls = Builder<Girl>.CreateListOfSize(2 * countOfBeautifulGirls)
.All()
.With(x => x.Height = 175).With(x => x.Weight = 55).With(x => x.BirthDate = new DateTime(1990, 2, 2))
.TheLast(countOfBeautifulGirls)
.With(x => x.Height = 180).With(x => x.Weight = 105).With(x => x.BirthDate = new DateTime(1990, 2, 2))
.Build();
for (int page = 1; page < 10; page++)
{
Mockery = new MockRepository();
var girlService = Mockery.Stub<IGirlService>();
UnitOfWorkFactory = Mockery.DynamicMock<IUnitOfWorkFactory>();
UnitOfWork = Mockery.DynamicMock<IUnitOfWork>();
using (Mockery.Record())
{
Expect.Call(UnitOfWorkFactory.Create()).Return(UnitOfWork);
Expect.Call(girlService.GetBeautifulGirls()).Return(girls.Take(countOfBeautifulGirls).ToList());
}
IEnumerable<GirlModel> resultGirls;
using (Mockery.Playback())
{
var controller = new GirlsController(girlService, UnitOfWorkFactory);
var result = controller.List(page, true);
resultGirls = (IEnumerable<GirlModel>) result.Data;
}
var girlModels = resultGirls as GirlModel[] ?? resultGirls.ToArray();
Assert.AreEqual(girls.Take(countOfBeautifulGirls).Skip((page - 1) * Constants.GIRLS_PAGER_LINKS_PER_PAGE).
Take(Constants.GIRLS_PAGER_LINKS_PER_PAGE).Count(), girlModels.Count());
if (girlModels.Count() != 0)
Assert.AreEqual(girls.Take(countOfBeautifulGirls).Skip((page - 1) * Constants.GIRLS_PAGER_LINKS_PER_PAGE).
Take(Constants.GIRLS_PAGER_LINKS_PER_PAGE).First().Id, girlModels.First().Id);
}
}
/// <summary>
/// The test window.
/// </summary>
public void TestWindow()
{
var mocks = new MockRepository();
var mockHttpReq = mocks.Stub<IHttpSonarConnector>();
var mockVsHelpers = mocks.Stub<IVsEnvironmentHelper>();
var config = new ConnectionConfiguration("serveraddr", "login", "password");
// set expectations
using (mocks.Record())
{
SetupResult.For(mockHttpReq.HttpSonarGetRequest(config, "/api/issues/search?components=resource"))
.Return(File.ReadAllText("TestData/issuessearchbycomponent.txt"));
SetupResult.For(mockHttpReq.HttpSonarGetRequest(config, "/api/users/search")).Return(File.ReadAllText("TestData/userList.txt"));
}
ISonarRestService service = new SonarRestService(mockHttpReq);
var issues = service.GetIssuesInResource(config, "resource");
var associatedProject = new Resource { Key = "core:Common" };
this.model = new ExtensionDataModel(service, mockVsHelpers, associatedProject);
var t = new Thread(this.Threadprc);
t.SetApartmentState(ApartmentState.STA);
t.Start();
t.Join();
}
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 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 Complete_Doesnt_Save_Task_If_No_Change()
{
var mockery = new MockRepository();
var projectId = 3;
var storyId = 4;
var id = 5;
var completed = true;
var description = "Doin work";
var task = new Task { Description = description, Id = id, ParentStoryId = storyId, ProjectId = projectId, Complete = true };
var storyService = mockery.StrictMock<IStoryService>();
using (mockery.Record())
using (mockery.Ordered()) {
Expect.Call(storyService.GetTask(projectId, storyId, id)).Return(task);
}
using (mockery.Playback()) {
var controller = new TaskController(storyService);
var result = controller.Complete(id, storyId, projectId, completed);
var viewResult = result as PartialViewResult;
Assert.NotNull(viewResult);
Assert.AreEqual("TaskDetails", viewResult.ViewName);
Assert.IsInstanceOf<TaskViewModel>(viewResult.Model);
Assert.AreEqual(task, (viewResult.Model as TaskViewModel).Task);
}
}
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 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 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 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 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 List_getValidNumberAndReferencesOfNews()
{
var news = Builder<News>.CreateListOfSize(100)
.Build();
for (int page = 1; page < 10; page++)
{
Mockery = new MockRepository();
var newsService = Mockery.DynamicMock<INewsService>();
UnitOfWorkFactory = Mockery.DynamicMock<IUnitOfWorkFactory>();
UnitOfWork = Mockery.DynamicMock<IUnitOfWork>();
using (Mockery.Record())
{
Expect.Call(UnitOfWorkFactory.Create()).Return(UnitOfWork);
Expect.Call(newsService.GetAll()).Return(news);
Expect.Call(newsService.Get(Arg<Int32>.Is.Equal((page - 1) * Constants.NEWS_PAGER_LINKS_PER_PAGE), Arg<Int32>.Is.Equal(Constants.NEWS_PAGER_LINKS_PER_PAGE))).
Return(news.Skip((page - 1) * Constants.NEWS_PAGER_LINKS_PER_PAGE).Take(Constants.NEWS_PAGER_LINKS_PER_PAGE).ToList());
}
IEnumerable<News> resultNews;
using (Mockery.Playback())
{
var controller = new NewsController(newsService, UnitOfWorkFactory);
var result = controller.List(page);
resultNews = (IEnumerable<News>)result.Data;
}
var enumerable = resultNews as News[] ?? resultNews.ToArray();
Assert.AreEqual(news.Skip((page - 1) * Constants.GIRLS_PAGER_LINKS_PER_PAGE).
Take(Constants.GIRLS_PAGER_LINKS_PER_PAGE).Count(), enumerable.Count());
if (enumerable.Count() != 0)
Assert.AreEqual(news.Skip((page - 1) * Constants.GIRLS_PAGER_LINKS_PER_PAGE).
Take(Constants.GIRLS_PAGER_LINKS_PER_PAGE).First().Id, enumerable.First().Id);
}
}
public void Select_Finds_FirstToSatisfyAllConstraints()
{
var mockery = new MockRepository();
var constraint1 = mockery.StrictMock<IResidentConstraint>();
var constraint2 = mockery.StrictMock<IResidentConstraint>();
var selector = new ResidentSelector();
selector.Constraints.Clear();
selector.Constraints.Add(constraint1);
selector.Constraints.Add(constraint2);
var residents = new List<Resident> { new Resident(), new Resident(), new Resident() };
var shift = new Shift(DateTime.Today, DateTime.Today, DateTime.Today);
using (mockery.Record()) {
SetupResult.For(constraint1.Assignable(residents.First(), shift)).Return(false);
SetupResult.For(constraint2.Assignable(residents.First(), shift)).Return(true);
SetupResult.For(constraint1.Assignable(residents.Skip(1).First(), shift)).Return(true);
SetupResult.For(constraint2.Assignable(residents.Skip(1).First(), shift)).Return(false);
SetupResult.For(constraint1.Assignable(residents.Skip(2).First(), shift)).Return(true);
SetupResult.For(constraint2.Assignable(residents.Skip(2).First(), shift)).Return(true);
}
using (mockery.Playback()) {
Assert.AreEqual(residents.Skip(2).First(), selector.Select(residents, shift));
}
}
public void Test_CheckIn_Charge_Only_Male()
{
//arrange mock
var customers = new List<Customer>();
//2男1女
var customer1 = new Customer { IsMale = true };
var customer2 = new Customer { IsMale = true };
var customer3 = new Customer { IsMale = false };
customers.Add(customer1);
customers.Add(customer2);
customers.Add(customer3);
MockRepository mock = new MockRepository();
ICheckInFee stubCheckInFee = mock.StrictMock<ICheckInFee>();
using (mock.Record())
{
//期望呼叫ICheckInFee的GetFee()次數為2次
stubCheckInFee.GetFee(customer1);
LastCall
.IgnoreArguments()
.Return((decimal)100)
.Repeat.Times(2);
}
using (mock.Playback())
{
var target = new Pub(stubCheckInFee);
var count = target.CheckInFriday(customers);
}
}
public void SubmitAdRequestsAsync()
{
var mockery = new MockRepository();
var taskFactory = mockery.StrictMock<IVistarTaskFactory>();
var adRequestor = mockery.StrictMock<IAdRequestor>();
var adRequests = new List<AdRequest> {
new AdRequest(),
new AdRequest(),
new AdRequest()
};
var expectedTasks = new List<Task<List<Advertisement>>> {
new Task<List<Advertisement>>(null),
new Task<List<Advertisement>>(null),
new Task<List<Advertisement>>(null)
};
using (mockery.Record()) {
Expect.Call(taskFactory.StartNew(adRequestor.RunSubmitAdRequest, adRequests[0])).Return(expectedTasks[0]);
Expect.Call(taskFactory.StartNew(adRequestor.RunSubmitAdRequest, adRequests[1])).Return(expectedTasks[1]);
Expect.Call(taskFactory.StartNew(adRequestor.RunSubmitAdRequest, adRequests[2])).Return(expectedTasks[2]);
}
using (mockery.Playback()) {
var client = new ApiClientAsync(adRequestor, taskFactory);
var tasks = client.SubmitAdRequestsAsync(adRequests);
Assert.AreEqual(expectedTasks, tasks);
}
}
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 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 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 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 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 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.StrictMock<ITaskObserver>();
var queryExecutor = mocks.StrictMock<IQueryExecutor>();
using (mocks.Record())
{
Expect.Call(() => taskObserver.Log("Running against: SQL Server"));
Expect.Call(queryExecutor.ReadFirstColumnAsStringArray(settings, "select @@version")).Return(new string[] { "SQL Server" });
Expect.Call(() => taskObserver.Log("Dropping database: db\n"));
Expect.Call(() => queryExecutor.ExecuteNonQuery(settings, "ALTER DATABASE [db] SET SINGLE_USER WITH ROLLBACK IMMEDIATE drop database [db]"))
.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 can_start_uow()
{
var factory = _mocks.DynamicMock <IUnitOfWorkFactory>();
var unitOfWork = _mocks.DynamicMock <IUnitOfWork>();
var fieldInfo = typeof(UnitOfWork).GetField("_unitOfWorkFactory",
BindingFlags.Static | BindingFlags.SetField | BindingFlags.NonPublic);
fieldInfo.SetValue(null, factory);
using (_mocks.Record())
{
Expect.Call(factory.Create()).Return(unitOfWork);
}
using (_mocks.Playback())
{
}
}
