public void CanBindReturnsTrueOnlyIfAllDataSetsCanSatisfyTheBinding()
{
MergedDataSet dataSet = new MergedDataSet();
DataBinding binding = new DataBinding(0, null);
IDataSet dataSetWithTwoColumns = Mocks.StrictMock <IDataSet>();
IDataSet dataSetWithThreeColumns = Mocks.StrictMock <IDataSet>();
using (Mocks.Record())
{
SetupResult.For(dataSetWithTwoColumns.ColumnCount).Return(2);
Expect.Call(dataSetWithTwoColumns.CanBind(binding)).Repeat.Twice().Return(true);
SetupResult.For(dataSetWithThreeColumns.ColumnCount).Return(3);
Expect.Call(dataSetWithThreeColumns.CanBind(binding)).Return(false);
}
using (Mocks.Playback())
{
Assert.IsTrue(dataSet.CanBind(binding), "Can always bind if there are no data sets.");
dataSet.AddDataSet(dataSetWithTwoColumns);
Assert.IsTrue(dataSet.CanBind(binding), "Can bind because only data set can bind.");
dataSet.AddDataSet(dataSetWithThreeColumns);
Assert.IsFalse(dataSet.CanBind(binding), "Cannot bind because one of the data sets cannot bind.");
}
}
public void ProjectSelected()
{
const string oldProject = "old project";
const string newProject = "new project";
SetupResult.For(settingsMock.SelectedProjectId).Return(oldProject);
Project project = MockRepository.Stub <TestProject>();
SetupResult.For(project.Id).Return(newProject);
Expect.Call(() => eventDispatcherMock.ModelChanged += null).IgnoreArguments();
Expect.Call(viewMock.Controller).PropertyBehavior();
Expect.Call(settingsMock.SelectedProjectId).PropertyBehavior().Repeat.Twice();
Expect.Call(settingsMock.StoreSettings);
Expect.Call(dataLayerMock.CurrentProject).PropertyBehavior().IgnoreArguments();
Expect.Call(() => eventDispatcherMock.Notify(controller, new ModelChangedArgs(EventReceiver.WorkitemView, EventContext.WorkitemCacheInvalidated)));
Expect.Call(viewMock.RefreshProperties);
Expect.Call(() => eventDispatcherMock.Notify(null, null)).IgnoreArguments();
MockRepository.ReplayAll();
controller.RegisterView(viewMock);
controller.Prepare();
controller.HandleProjectSelected(project);
MockRepository.VerifyAll();
}
public void AddingDataSetsUpdatesTheColumnCountAndDataSetsCollection()
{
MergedDataSet dataSet = new MergedDataSet();
IDataSet dataSetWithTwoColumns = Mocks.StrictMock <IDataSet>();
IDataSet dataSetWithThreeColumns = Mocks.StrictMock <IDataSet>();
using (Mocks.Record())
{
SetupResult.For(dataSetWithTwoColumns.ColumnCount).Return(2);
SetupResult.For(dataSetWithThreeColumns.ColumnCount).Return(3);
}
using (Mocks.Playback())
{
Assert.AreEqual(0, dataSet.ColumnCount);
Assert.AreElementsEqual(new IDataSet[] { }, dataSet.DataSets);
dataSet.AddDataSet(dataSetWithTwoColumns);
Assert.AreEqual(2, dataSet.ColumnCount);
Assert.AreElementsEqual(new IDataSet[] { dataSetWithTwoColumns }, dataSet.DataSets);
dataSet.AddDataSet(dataSetWithThreeColumns);
Assert.AreEqual(3, dataSet.ColumnCount);
Assert.AreElementsEqual(new IDataSet[] { dataSetWithTwoColumns, dataSetWithThreeColumns }, dataSet.DataSets);
}
}
public void CreateClone_CallsStrategyForReferences_OnlyWhenNotTouched()
{
var strategyMock = _mockRepository.StrictMock <ICloneStrategy> ();
var contextMock = _mockRepository.Stub <CloneContext> (_cloner);
Order clone = Order.NewObject();
OrderItem clone2 = OrderItem.NewObject();
var shallowClonesFake = new Queue <Tuple <DomainObject, DomainObject> > ();
clone.OrderTicket = clone.OrderTicket;
clone.Official = clone.Official;
clone.Customer = clone.Customer;
clone.OrderItems.Add(clone2);
SetupResult.For(contextMock.GetCloneFor(_order1)).Return(clone);
shallowClonesFake.Enqueue(new Tuple <DomainObject, DomainObject> (_order1, clone));
shallowClonesFake.Enqueue(new Tuple <DomainObject, DomainObject> (_order1.OrderItems[0], clone2));
SetupResult.For(contextMock.CloneHulls).Return(shallowClonesFake);
using (_mockRepository.Unordered())
{
// not called: ExpectHandleReference (strategyMock, _order1, clone, "OrderItems", ClientTransaction.Current, ClientTransaction.Current);
// not called: ExpectHandleReference (strategyMock, _order1, clone, "OrderTicket", ClientTransaction.Current, ClientTransaction.Current);
// not called: ExpectHandleReference (strategyMock, _order1, clone, "Official", ClientTransaction.Current, ClientTransaction.Current);
// not called: ExpectHandleReference (strategyMock, _order1, clone, "Customer", ClientTransaction.Current, ClientTransaction.Current);
// not called: ExpectHandleReference (strategyMock, _order1.OrderItems[0], clone2, "Order", ClientTransaction.Current, ClientTransaction.Current);
}
_mockRepository.ReplayAll();
_cloner.CreateClone(_order1, strategyMock, contextMock);
_mockRepository.VerifyAll();
}
public void SetUp()
{
mockery = new MockRepository();
unknownMenu = mockery.DynamicMock <ISubMenu>();
SetupResult.For(unknownMenu.Name()).Return("blah");
}
private void GenerateTimelineMocks(string appPath, string expected, out IFarmService farmService, out IVelocityViewGenerator viewGenerator, out ICruiseUrlBuilder urlBuilder, out ICruiseRequest cruiseRequest)
{
var url = "/somewhere.aspx";
var projectName = "Test Project";
farmService = this.mocks.StrictMock <IFarmService>();
viewGenerator = this.mocks.StrictMock <IVelocityViewGenerator>();
urlBuilder = this.mocks.StrictMock <ICruiseUrlBuilder>();
cruiseRequest = this.mocks.StrictMock <ICruiseRequest>();
var request = this.mocks.StrictMock <IRequest>();
var projectSpec = this.mocks.StrictMock <IProjectSpecifier>();
SetupResult.For(cruiseRequest.Request).Return(request);
SetupResult.For(cruiseRequest.ProjectName).Return(projectName);
SetupResult.For(cruiseRequest.ProjectSpecifier).Return(projectSpec);
SetupResult.For(request.FileNameWithoutExtension).Return(ProjectTimelineAction.TimelineActionName);
SetupResult.For(request.ApplicationPath).Return(appPath);
SetupResult.For(urlBuilder.BuildProjectUrl(ProjectTimelineAction.DataActionName, projectSpec)).Return(url);
Expect.Call(viewGenerator.GenerateView(null, null))
.Callback <string, Hashtable>((n, ht) =>
{
Assert.AreEqual("ProjectTimeline.vm", n);
Assert.IsNotNull(ht);
Assert.IsTrue(ht.ContainsKey("applicationPath"));
Assert.IsTrue(ht.ContainsKey("projectName"));
Assert.IsTrue(ht.ContainsKey("dataUrl"));
Assert.AreEqual(expected, ht["applicationPath"]);
Assert.AreEqual(projectName, ht["projectName"]);
Assert.AreEqual(url, ht["dataUrl"]);
return(true);
})
.Return(new HtmlFragmentResponse("from nVelocity"));
}
public void OrderProduct_Should_Update_ProductRepository_For_Products_Ordered_When_Not_All_Items_Ordered_Are_In_Stock()
{
this.orderService = new OrderService(
this.productRepositoryStub,
this.orderRepositoryMock,
this.calculationServiceStub,
this.confirmationServiceMock);
// Record expectations
using (mockRepository.Record())
{
SetupResult
.For(productRepositoryStub.GetProductByName(this.productSelectedByCustomer))
.Return(this.productStub);
SetupResult
.For(productRepositoryStub.GetNumberOfItemsOfProductOrderedInStock(this.productStub, this.quantity))
.Return(this.quantity - 1);
// Expectation that UpdateNumberOfItemsInStock is called exactly once with right arguments
this.productRepositoryStub.Expect(t => t.UpdateNumberOfItemsInStock(this.productStub, this.quantity - 1))
.Repeat.Times(1);
}
// Verify expectations
using (mockRepository.Playback())
{
this.orderService.OrderProduct(this.customerStub, productSelectedByCustomer, this.quantity);
}
}
public void OrderProduct_Should_Send_Confirmation_To_Customer_For_Items_Placed_In_BackOrder()
{
this.orderService = new OrderService(
this.productRepositoryStub,
this.orderRepositoryMock,
this.calculationServiceStub,
this.confirmationServiceMock);
// Record expectations
using (mockRepository.Record())
{
SetupResult
.For(productRepositoryStub.GetProductByName(this.productSelectedByCustomer))
.Return(this.productStub);
SetupResult
.For(productRepositoryStub.GetNumberOfItemsOfProductOrderedInStock(this.productStub, this.quantity))
.Return(this.quantity - 1);
// Expectation that SendBackOrderConfirmationToCustomer is called exactly once with right arguments
this.confirmationServiceMock.Expect(t => t.SendBackOrderConfirmationToCustomer(this.customerStub, this.productStub, 1))
.Repeat.Times(1);
}
// Verify expectations
using (mockRepository.Playback())
{
this.orderService.OrderProduct(this.customerStub, productSelectedByCustomer, this.quantity);
}
}
public void VerifyExceptionHandlerCanWrapExceptions()
{
var jetApi = this.mocks.Stub <IJetApi>();
Api.Impl = jetApi;
SetupResult.For(
jetApi.JetBeginTransaction(JET_SESID.Nil))
.IgnoreArguments()
.Return((int)JET_err.TransTooDeep);
this.mocks.ReplayAll();
Api.ErrorHandler handler = ex =>
{
throw new InvalidOperationException("test");
};
try
{
Api.HandleError += handler;
Api.JetBeginTransaction(JET_SESID.Nil);
Assert.Fail("Expected an invalid operation exception");
}
catch (InvalidOperationException)
{
}
Api.HandleError -= handler;
}
public void RunFailsIfTaskErrorsButContinueOnFailure()
{
var buildInfo = mocks.DynamicMock <BuildProgressInformation>(string.Empty, string.Empty);
var result = mocks.Stub <IIntegrationResult>();
result.Status = IntegrationStatus.Success;
SetupResult.For(result.Clone()).Return(result);
SetupResult.For(result.BuildProgressInformation).Return(buildInfo);
var logger = mocks.DynamicMock <ILogger>();
var childTask1 = new SleepingTask {
SleepPeriod = 10, Result = IntegrationStatus.Success
};
var childTask2 = new FailingTask();
var childTask3 = new SleepingTask {
SleepPeriod = 10, Result = IntegrationStatus.Success
};
var task = new SynchronisationTask
{
Logger = logger,
Tasks = new ITask[] {
childTask1,
childTask2,
childTask3
},
ContinueOnFailure = true
};
this.mocks.ReplayAll();
task.Run(result);
this.mocks.VerifyAll();
Assert.AreEqual(IntegrationStatus.Failure, result.Status);
Assert.IsNotNull(result.ExceptionResult);
Assert.AreEqual("Task failed!", result.ExceptionResult.Message);
}
public void Should_map_the_data_from_the_view_to_the_dto(long customerId, string userName, string password,
string firstName,
string lastName, string phone, string city)
{
using (mockery.Record( )) {
SetupResult.For(mockRequest.ParsePayloadFor(PayloadKeys.CustomerId)).Return(customerId);
SetupResult.For(mockRequest.ParsePayloadFor(Create("uxUserNameTextBox"))).Return(userName);
SetupResult.For(mockRequest.ParsePayloadFor(Create("uxPasswordTextBox"))).Return(password);
SetupResult.For(mockRequest.ParsePayloadFor(Create("uxFirstNameTextBox"))).Return(firstName);
SetupResult.For(mockRequest.ParsePayloadFor(Create("uxLastNameTextBox"))).Return(lastName);
SetupResult.For(mockRequest.ParsePayloadFor(Create("uxPhoneNumberTextBox"))).Return(phone);
SetupResult.For(mockRequest.ParsePayloadFor(Create("uxCityTextBox"))).Return(city);
}
using (mockery.Playback( )) {
UpdateCustomerRegistrationDTO dto = CreateSUT( ).MapFrom(mockRequest);
Assert.AreEqual(customerId, dto.CustomerId);
Assert.AreEqual(userName, dto.Username);
Assert.AreEqual(password, dto.Password);
Assert.AreEqual(firstName, dto.FirstName);
Assert.AreEqual(lastName, dto.LastName);
Assert.AreEqual(phone, dto.PhoneNumber);
Assert.AreEqual(city, dto.City);
}
}
public void SiteRootActsAsSafePrefix()
{
var mocks = new MockRepository();
var httpContext = mocks.StrictMock <HttpContextBase>();
var httpRequest = mocks.StrictMock <HttpRequestBase>();
SetupResult.For(httpContext.Request).Return(httpRequest);
var controller = mocks.StrictMock <ControllerBase>();
Expect.Call(httpRequest.ApplicationPath).Return("/");
Expect.Call(httpRequest.ApplicationPath).Return("/TestApp");
Expect.Call(httpRequest.ApplicationPath).Return("/TestApp/");
Expect.Call(httpRequest.ApplicationPath).Return("");
Expect.Call(httpRequest.ApplicationPath).Return(null);
Expect.Call(httpRequest.ApplicationPath).Return("TestApp/");
Expect.Call(httpRequest.ApplicationPath).Return("TestApp");
mocks.ReplayAll();
var view = new StubSparkView();
var viewContext = new ViewContext(new ControllerContext(httpContext, new RouteData(), controller), view, new ViewDataDictionary(), new TempDataDictionary(), new StringWriter());
view = new StubSparkView {
ViewContext = viewContext
};
Assert.AreEqual("", view.SiteRoot);
view = new StubSparkView {
ViewContext = viewContext
};
Assert.AreEqual("/TestApp", view.SiteRoot);
view = new StubSparkView {
ViewContext = viewContext
};
Assert.AreEqual("/TestApp", view.SiteRoot);
view = new StubSparkView {
ViewContext = viewContext
};
Assert.AreEqual("", view.SiteRoot);
view = new StubSparkView {
ViewContext = viewContext
};
Assert.AreEqual("", view.SiteRoot);
view = new StubSparkView {
ViewContext = viewContext
};
Assert.AreEqual("/TestApp", view.SiteRoot);
view = new StubSparkView {
ViewContext = viewContext
};
Assert.AreEqual("/TestApp", view.SiteRoot);
mocks.VerifyAll();
}
public void ValidWildCardLoginReturnsSessionToken()
{
IAuthentication wildcardMock = mocks.DynamicMock <IAuthentication>();
SetupResult.For(wildcardMock.Identifier).Return("*doe");
manager.Users = new IAuthentication[] {
wildcardMock
};
LoginRequest credentials = new LoginRequest("johndoe");
Expect.Call(wildcardMock.Authenticate(credentials)).Return(true);
Expect.Call(wildcardMock.GetUserName(credentials)).Return("johndoe");
Expect.Call(wildcardMock.GetDisplayName(credentials)).Return("johndoe");
Expect.Call(sessionMock.AddToCache("johndoe")).Return(testSessionToken);
Expect.Call(delegate { sessionMock.StoreSessionValue(string.Empty, string.Empty, string.Empty); })
.IgnoreArguments();
mocks.ReplayAll();
manager.Initialise();
string sessionToken = manager.Login(credentials);
Assert.AreEqual(testSessionToken, sessionToken);
}
public async Task <SetupResult> Setup()
{
try
{
var masterKeyFile = LocalHost.GetRandomFilename();
var publicKeyFile = LocalHost.GetRandomFilename();
await LocalHost.RunProcessAsync("cpabe-setup", $"-p {publicKeyFile} -m {masterKeyFile}");
var masterKeyBytes = await LocalHost.ReadFileAsync(masterKeyFile);
var publicKeyBytes = await LocalHost.ReadFileAsync(publicKeyFile);
var setupResult = new SetupResult()
{
MasterKey = new MockMasterKey()
{
Value = masterKeyBytes
},
PublicKey = new MockPublicKey()
{
Value = publicKeyBytes
}
};
File.Delete(masterKeyFile);
File.Delete(publicKeyFile);
return(setupResult);
}
catch (Exception exception)
{
throw new ABESchemeException("Error has occured during initialization", exception);
}
}
public override void SetUp()
{
fixture1 = Mocks.StrictMock <ITestDescriptor>();
fixture2 = Mocks.StrictMock <ITestDescriptor>();
fixture3 = Mocks.StrictMock <ITestDescriptor>();
fixture4 = Mocks.StrictMock <ITestDescriptor>();
ICodeElementInfo codeElement1 = Reflector.Wrap(typeof(SimpleTest));
SetupResult.For(fixture1.CodeElement).Return(codeElement1);
fixture1TypeName = codeElement1.Name;
ICodeElementInfo codeElement2 = Reflector.Wrap(typeof(ParameterizedTest));
SetupResult.For(fixture2.CodeElement).Return(codeElement2);
fixture2TypeName = codeElement2.Name;
ICodeElementInfo codeElement3 = Reflector.Wrap(typeof(FixtureInheritanceSample));
SetupResult.For(fixture3.CodeElement).Return(codeElement3);
fixture3TypeName = codeElement3.Name;
ICodeElementInfo codeElement4 = Reflector.Wrap(typeof(DerivedFixture));
SetupResult.For(fixture4.CodeElement).Return(codeElement4);
Mocks.ReplayAll();
}
public void WriteAuditInformations_ForTwoMockedFeatures_IteratesOverTheseFeaturesAndWritesAuditInformations()
{
var selectionSet = _repository.StrictMock <ISelectionSet2>();
var cursorAndIFeatureCursor = _repository.StrictMock <ICursorAndIFeatureCursor>();
ICursor cursor = cursorAndIFeatureCursor;
IFeatureCursor featureCursor = cursorAndIFeatureCursor;
var featureOne = _repository.StrictMock <IFeature>();
var featureTwo = _repository.StrictMock <IFeature>();
var fields = _repository.DynamicMock <IFields>();
SetupResult.For(featureOne.Fields).Return(fields);
SetupResult.For(fields.FindField("Audit")).Return(6);
using (_repository.Record())
{
Expect.Call(() => selectionSet.Search(null, false, out cursor)).OutRef(cursor);
Expect.Call(featureCursor.NextFeature()).Return(featureOne);
Expect.Call(() => featureOne.Value[6] = string.Empty).IgnoreArguments();
Expect.Call(featureOne.Store);
Expect.Call(featureCursor.NextFeature()).Return(featureTwo);
Expect.Call(() => featureTwo.Value[6] = string.Empty).IgnoreArguments();
Expect.Call(featureTwo.Store);
Expect.Call(featureCursor.NextFeature()).Return(null);
}
using (_repository.Playback())
{
selectionSet.GetFeatures(null, RecyclingPolicy.DoNotRecycle).WriteAuditInformations();
}
}
public static UmbracoContext GetMockUmbracoContext(Uri requestUri, HttpCookie mockCookie = null)
{
//var mockHttpContext = MockRepository.GenerateStub<HttpContextBase>();
//var mockHttpRequest = MockRepository.GenerateStub<HttpRequestBase>();
//var mockHttpResponse = MockRepository.GenerateStub<HttpResponseBase>();
//SetupResult.For(mockHttpContext.Request).Return(mockHttpRequest);
//SetupResult.For(mockHttpRequest.Url).Return(requestUri);
//SetupResult.For(mockHttpRequest.Cookies).Return(cookieCollection);
//SetupResult.For(mockHttpContext.Response).Return(mockHttpResponse);
//SetupResult.For(mockHttpResponse.Cookies).ReturncookieCollection);
var umbracoContext = MockRepository.GenerateStrictMock <UmbracoContext>();
var cookieCollection = new HttpCookieCollection();
SetupResult.For(umbracoContext.HttpContext.Request.Cookies).Return(cookieCollection);
if (mockCookie != null)
{
cookieCollection.Add(mockCookie);
umbracoContext.Expect(c => c.HttpContext.Response.Cookies.Add(mockCookie));
}
SetupResult.For(umbracoContext.HttpContext.Request.Url).Return(requestUri);
return(umbracoContext);
}
public void Search_WithoutGroupType_AndWithSecurityProvider()
{
var principalStub = _mocks.Stub <ISecurityPrincipal> ();
SetupResult.For(principalStub.User).Return("group0/user1");
SetupResult.For(_mockPrincipalProvider.GetPrincipal()).Return(principalStub);
SetupResultSecurityProviderGetAccessForPosition(Delegation.Enabled, principalStub, SecurityManagerAccessTypes.AssignRole);
SetupResultSecurityProviderGetAccessForPosition(Delegation.Disabled, principalStub);
Group rootGroup = _expectedRootGroupHandle.GetObject();
_mocks.ReplayAll();
var positions = _searchService.Search(null, _positionProperty, CreateSearchArguments(rootGroup));
_mocks.VerifyAll();
Assert.That(positions.Length, Is.EqualTo(2));
foreach (string positionName in new[] { "Official", "Global" })
{
Assert.IsTrue(
// ReSharper disable AccessToModifiedClosure
Array.Exists(positions, current => positionName == ((Position)current).Name),
// ReSharper restore AccessToModifiedClosure
"Position '{0}' was not found.",
positionName);
}
}
public void GetItemsAppliesIndexAliasTranslation()
{
List <KeyValuePair <string, string> > metadataPairs = new List <KeyValuePair <string, string> >();
metadataPairs.Add(new KeyValuePair <string, string>("Foo", "Bar"));
IDataSet dataSet = Mocks.StrictMock <IDataSet>();
using (Mocks.Record())
{
SetupResult.For(dataSet.ColumnCount).Return(3);
Expect.Call(dataSet.GetItems(null, true)).IgnoreArguments().Do((GetItemsDelegate) delegate(ICollection <DataBinding> bindings,
bool includeDynamicItems)
{
Assert.IsTrue(includeDynamicItems);
List <IDataItem> items = new List <IDataItem>();
items.Add(new ListDataItem <object>(new object[] { "abc", "def", "ghi" }, metadataPairs, true));
List <DataBinding> bindingList = new List <DataBinding>(bindings);
Assert.AreEqual("translatedPath", bindingList[0].Path);
Assert.AreEqual(2, bindingList[0].Index);
Assert.AreEqual("untranslatedPath", bindingList[1].Path);
Assert.AreEqual(1, bindingList[1].Index);
return(items);
});
}
using (Mocks.Playback())
{
DataSource source = new DataSource("theName");
source.AddIndexAlias("translatedPath", 2);
source.AddDataSet(dataSet);
DataBinding[] bindings = new DataBinding[] {
new DataBinding(5, "translatedPath"),
new DataBinding(1, "untranslatedPath")
};
List <IDataItem> items = new List <IDataItem>(source.GetItems(bindings, true));
Assert.Count(1, items);
PropertyBag map = DataItemUtils.GetMetadata(items[0]);
Assert.Count(1, map);
Assert.AreEqual("Bar", map.GetValue("Foo"));
Assert.Throws <ArgumentNullException>(delegate { items[0].GetValue(null); });
Assert.AreEqual("ghi", items[0].GetValue(bindings[0]));
Assert.AreEqual("def", items[0].GetValue(bindings[1]));
// Should throw ArgumentNullException when binding list is null.
Assert.Throws <ArgumentNullException>(delegate
{
items[0].GetValue(null);
});
}
}
public void SendForgottenPasswordLinkShouldReturnLoginMessageView()
{
LoginController loginController = new LoginController();
HttpContextBase httpContext = mocks.FakeHttpContext();
RequestContext requestContext = new RequestContext(httpContext, new RouteData());
ControllerContext controllerContext = new ControllerContext(requestContext, loginController);
loginController.ControllerContext = controllerContext;
loginController.Url = new UrlHelper(requestContext);
Uri uri = new Uri(@"http://www.andromedia.com/");
SetupResult.For(httpContext.Request.Url).Return(uri);
mocks.ReplayAll();
FormCollection formCollection = new FormCollection();
formCollection["TextBoxEMail"] = user.Username;
ViewResult result = loginController.SendForgottenPasswordLink(formCollection) as ViewResult;
Assert.IsNotNull(result);
Assert.AreEqual(loginMessage_ViewName, result.ViewName);
Assert.IsNotNull(result.ViewData["link"]);
Assert.IsNotNull(result.ViewData["title"]);
Assert.IsNotNull(result.ViewData["message"]);
}
public void CanBindAppliesIndexAliasTranslation()
{
IDataSet dataSet = Mocks.StrictMock <IDataSet>();
using (Mocks.Record())
{
SetupResult.For(dataSet.ColumnCount).Return(2);
Expect.Call(dataSet.CanBind(null)).IgnoreArguments().Do((CanBindDelegate) delegate(DataBinding binding)
{
Assert.AreEqual("translatedPath", binding.Path);
Assert.AreEqual(2, binding.Index);
return(true);
});
Expect.Call(dataSet.CanBind(null)).IgnoreArguments().Do((CanBindDelegate) delegate(DataBinding binding)
{
Assert.AreEqual("untranslatedPath", binding.Path);
Assert.AreEqual(5, binding.Index);
return(false);
});
}
using (Mocks.Playback())
{
DataSource source = new DataSource("theName");
source.AddIndexAlias("translatedPath", 2);
source.AddDataSet(dataSet);
Assert.IsTrue(source.CanBind(new DataBinding(5, "translatedPath")));
Assert.IsFalse(source.CanBind(new DataBinding(5, "untranslatedPath")));
}
}
public void VerifyErrorHandlerIsInvokedOnException()
{
var jetApi = this.mocks.Stub <IJetApi>();
Api.Impl = jetApi;
SetupResult.For(
jetApi.JetBeginTransaction(JET_SESID.Nil))
.IgnoreArguments()
.Return((int)JET_err.TransTooDeep);
this.mocks.ReplayAll();
bool eventWasCalled = false;
JET_err error = JET_err.Success;
Api.ErrorHandler handler = errArg =>
{
eventWasCalled = true;
error = errArg;
};
try
{
Api.HandleError += handler;
Api.JetBeginTransaction(JET_SESID.Nil);
}
catch (EsentErrorException)
{
}
Api.HandleError -= handler;
Assert.IsTrue(eventWasCalled);
Assert.AreEqual(JET_err.TransTooDeep, error);
}
public void ExecuteGeneratesXmlOutputForXml()
{
var farmService = this.mocks.StrictMock <IFarmService>();
var cruiseRequest = this.mocks.StrictMock <ICruiseRequest>();
var projectSpec = this.mocks.StrictMock <IProjectSpecifier>();
var request = this.mocks.StrictMock <IRequest>();
var snapshot = this.GenerateSnapshot();
SetupResult.For(cruiseRequest.ProjectSpecifier).Return(projectSpec);
SetupResult.For(cruiseRequest.RetrieveSessionToken()).Return(null);
SetupResult.For(cruiseRequest.Request).Return(request);
SetupResult.For(request.GetText("view")).Return("xml");
SetupResult.For(farmService.TakeStatusSnapshot(projectSpec, null)).Return(snapshot);
this.mocks.ReplayAll();
var plugin = new ProjectStatusAction(farmService);
var response = plugin.Execute(cruiseRequest);
this.mocks.VerifyAll();
Assert.IsInstanceOf <XmlFragmentResponse>(response);
var actual = response as XmlFragmentResponse;
var expected = snapshot.ToString();
Assert.AreEqual(expected, actual.ResponseFragment);
}
public void SetUp()
{
mockery = new MockRepository();
fileMenu = mockery.DynamicMock <ISubMenu>();
SetupResult.For(fileMenu.Name()).Return("&File");
}
public DslFactoryFixture()
{
factory = new DslFactory();
mocks = new MockRepository();
mockedDslEngine = mocks.DynamicMock <DslEngine>();
mockCache = mocks.DynamicMock <IDslEngineCache>();
mockCache.WriteLock(null);
LastCall.Repeat.Any()
.IgnoreArguments()
.Do((Action <CacheAction>)ExecuteCachedAction);
mockCache.ReadLock(null);
LastCall.Repeat.Any()
.IgnoreArguments()
.Do((Action <CacheAction>)ExecuteCachedAction);
IDslEngineStorage mockStorage = mocks.DynamicMock <IDslEngineStorage>();
Assembly assembly = Assembly.GetCallingAssembly();
context = new CompilerContext();
context.GeneratedAssembly = assembly;
mockedDslEngine.Storage = mockStorage;
mockedDslEngine.Cache = mockCache;
SetupResult.For(mockStorage.GetMatchingUrlsIn("", ref testUrl)).Return(new string[] { testUrl });
SetupResult.For(mockStorage.IsUrlIncludeIn(null, null, null))
.IgnoreArguments()
.Return(true);
}
public void RunFailsIfTaskFails()
{
var buildInfo = mocks.DynamicMock <BuildProgressInformation>(string.Empty, string.Empty);
var result = mocks.Stub <IIntegrationResult>();
result.Status = IntegrationStatus.Success;
SetupResult.For(result.Clone()).Return(result);
SetupResult.For(result.BuildProgressInformation).Return(buildInfo);
var logger = mocks.DynamicMock <ILogger>();
var childTask1 = new SleepingTask {
SleepPeriod = 10, Result = IntegrationStatus.Success
};
var childTask2 = new SleepingTask {
SleepPeriod = 10, Result = IntegrationStatus.Failure
};
var task = new SynchronisationTask
{
Logger = logger,
Tasks = new ITask[] {
childTask1,
childTask2
}
};
this.mocks.ReplayAll();
task.Run(result);
this.mocks.VerifyAll();
Assert.AreEqual(IntegrationStatus.Failure, result.Status);
}
public void Handler_should_match_route()
{
var handler = new DebugHttpHandler();
var mocks = new MockRepository();
var context = mocks.DynamicHttpContextBase();
SetupResult.For(context.Request.AppRelativeCurrentExecutionFilePath).Return("~/Home/");
SetupResult.For(context.Request.PathInfo).Return("Index");
var routes = new RouteCollection
{
new Route("{controller}/{action}/{id}", null, new MvcRouteHandler()),
new Route("{controller}/{action}", null, new MvcRouteHandler()),
new Route("{controller}/{action}", new RouteValueDictionary(new Hash(Controller => "Home")),
new MvcRouteHandler())
};
RouteDebugger.RewriteRoutesForTesting(routes);
mocks.ReplayAll();
var routeData = new RouteData(routes[0], new DebugRouteHandler());
routeData.Values.Add("Controller", "Home");
routeData.Values.Add("Action", "Index");
handler.RequestContext = new RequestContext(context, routeData);
handler.ProcessRequest(context, routes);
Assert.That(context.Response.Output.ToString().Contains("<tr><td>Controller</td><td>Home </td></tr>"));
}
public void OrderProduct_Should_Calulate_OrderAmount_For_Product_Selected_For_Quantity_Entered_By_Customer()
{
this.orderService = new OrderService(
this.productRepositoryStub,
this.orderRepositoryMock,
this.orderAmountCalculatorMock,
this.confirmationServiceMock);
// Record expectations
using (mockRepository.Record())
{
// Expectation that stub returns the product based on the Selected ProductName
SetupResult
.For(this.productRepositoryStub.GetProductByName(this.productSelectedByCustomer))
.Return(this.productStub);
// Expectation that Order Amount Calculator is called exactly once with right arguments.
this.orderAmountCalculatorMock.Expect(
t => t.CalculateOrderAmount(
this.customerStub,
this.productStub,
this.quantity))
.WhenCalled(x => x.ReturnValue = this.orderAmount)
.Return(this.orderAmount)
.Repeat.Times(1);
}
// Verify expectations
using (mockRepository.Playback())
{
this.orderService.OrderProduct(this.customerStub, productSelectedByCustomer, this.quantity);
}
}
public void SetUp()
{
mockery = new MockRepository();
menuThatThisItemBelongsTo = mockery.DynamicMock <ISubMenu>();
SetupResult.For(menuThatThisItemBelongsTo.Name()).Return(MenuNames.Help);
}
public void ExecuteWorksForLinkedSite()
{
var farmService = this.mocks.StrictMock <IFarmService>();
var viewGenerator = this.mocks.StrictMock <IVelocityViewGenerator>();
var request = this.mocks.StrictMock <ICruiseRequest>();
var projectSpec = this.mocks.StrictMock <IProjectSpecifier>();
SetupResult.For(request.ProjectSpecifier).Return(projectSpec);
SetupResult.For(request.ProjectName).Return("Test Project");
SetupResult.For(request.RetrieveSessionToken()).Return(null);
SetupResult.For(farmService.GetLinkedSiteId(projectSpec, null, "ohloh")).Return("1234567");
Expect.Call(viewGenerator.GenerateView(null, null))
.Callback <string, Hashtable>((n, ht) => {
Assert.AreEqual("OhlohStats.vm", n);
Assert.IsNotNull(ht);
Assert.IsTrue(ht.ContainsKey("ohloh"));
Assert.IsTrue(ht.ContainsKey("projectName"));
Assert.AreEqual("1234567", ht["ohloh"]);
Assert.AreEqual("Test Project", ht["projectName"]);
return(true);
})
.Return(new HtmlFragmentResponse("from nVelocity"));
this.mocks.ReplayAll();
var plugin = new OhlohProjectPlugin(farmService, viewGenerator);
var response = plugin.Execute(request);
this.mocks.VerifyAll();
Assert.IsInstanceOf <HtmlFragmentResponse>(response);
var actual = response as HtmlFragmentResponse;
Assert.AreEqual("from nVelocity", actual.ResponseFragment);
}
void ConfigureSession ()
{
if (setupResult != SetupResult.Success)
return;
NSError error = null;
Session.BeginConfiguration ();
Session.SessionPreset = AVCaptureSession.PresetPhoto;
// Add video input
AVCaptureDevice vDevice = GetDeviceFrom (AVMediaType.Video, AVCaptureDevicePosition.Back);
AVCaptureDeviceInput vDeviceInput = AVCaptureDeviceInput.FromDevice (vDevice, out error);
if (error != null) {
Console.WriteLine ("Could not create video device input: {0}", error);
setupResult = SetupResult.SessionConfigurationFailed;
Session.CommitConfiguration ();
return;
}
if (Session.CanAddInput (vDeviceInput)) {
Session.AddInput (vDeviceInput);
VideoDeviceInput = vDeviceInput;
VideoDevice = vDeviceInput.Device;
} else {
Console.WriteLine ("Could not add video device input to the session");
setupResult = SetupResult.SessionConfigurationFailed;
Session.CommitConfiguration ();
return;
}
// Add audio input
AVCaptureDevice aDevice = AVCaptureDevice.DefaultDeviceWithMediaType (AVMediaType.Audio);
AVCaptureDeviceInput aDeviceInput = AVCaptureDeviceInput.FromDevice (aDevice, out error);
if (error != null)
Console.WriteLine ("Could not create audio device input: {0}", error);
if (Session.CanAddInput (aDeviceInput))
Session.AddInput (aDeviceInput);
else
Console.WriteLine ("Could not add audio device input to the session");
// Add photo output
var po = new AVCapturePhotoOutput ();
if (Session.CanAddOutput (po)) {
Session.AddOutput (po);
photoOutput = po;
photoOutput.IsHighResolutionCaptureEnabled = true;
} else {
Console.WriteLine ("Could not add photo output to the session");
setupResult = SetupResult.SessionConfigurationFailed;
Session.CommitConfiguration ();
return;
}
// We will not create an AVCaptureMovieFileOutput when configuring the session because the AVCaptureMovieFileOutput does not support movie recording with AVCaptureSessionPresetPhoto
backgroundRecordingID = -1;
Session.CommitConfiguration ();
DispatchQueue.MainQueue.DispatchAsync (ConfigureManualHUD);
}
void CheckDeviceAuthorizationStatus ()
{
var status = AVCaptureDevice.GetAuthorizationStatus (AVMediaType.Video);
switch (status) {
// The user has previously granted access to the camera
case AVAuthorizationStatus.Authorized:
break;
// The user has not yet been presented with the option to grant video access.
// We suspend the session queue to delay session running until the access request has completed.
// Note that audio access will be implicitly requested when we create an AVCaptureDeviceInput for audio during session setup.
case AVAuthorizationStatus.NotDetermined:
sessionQueue.Suspend ();
AVCaptureDevice.RequestAccessForMediaType (AVMediaType.Video, granted => {
if (!granted)
setupResult = SetupResult.CameraNotAuthorized;
sessionQueue.Resume ();
});
break;
default:
// The user has previously denied access
setupResult = SetupResult.CameraNotAuthorized;
break;
}
}
public override void ViewDidLoad ()
{
base.ViewDidLoad ();
// Disable UI until the session starts running
CameraButton.Enabled = false;
RecordButton.Enabled = false;
PhotoButton.Enabled = false;
CaptureModeControl.Enabled = false;
HUDButton.Enabled = false;
ManualHUD.Hidden = true;
ManualHUDPhotoView.Hidden = true;
ManualHUDFocusView.Hidden = true;
ManualHUDExposureView.Hidden = true;
ManualHUDWhiteBalanceView.Hidden = true;
ManualHUDLensStabilizationView.Hidden = true;
// Create the AVCaptureSession
Session = new AVCaptureSession ();
// Set up preview
PreviewView.Session = Session;
sessionQueue = new DispatchQueue ("session queue");
setupResult = SetupResult.Success;
// Check video authorization status. Video access is required and audio access is optional.
// If audio access is denied, audio is not recorded during movie recording.
CheckDeviceAuthorizationStatus ();
// Setup the capture session.
// In general it is not safe to mutate an AVCaptureSession or any of its inputs, outputs, or connections from multiple threads at the same time.
// Why not do all of this on the main queue?
// Because AVCaptureSession.StartRunning is a blocking call which can take a long time. We dispatch session setup to the sessionQueue
// so that the main queue isn't blocked, which keeps the UI responsive.
sessionQueue.DispatchAsync (ConfigureSession);
}
