public void GetAdDetails_AdExists_GetAdFromRepoAndReturnAdModel()
{
// Given
Ad ad = new Ad() { Id = 17 };
ad.CreationDate = new DateTime(2012, 02, 18);
ad.CreatedBy = new User { Firstname = "Michel" };
ad.City = new City { Label = "Ville" };
var repoMock = new Moq.Mock<IRepository>();
repoMock.Setup(x => x.Get<BaseAd>(17)).Returns(ad as BaseAd);
var adRepoMock = new Moq.Mock<IAdRepository>();
adRepoMock.Setup(r => r.GetAdType(17)).Returns(AdTypeEnum.Ad);
adRepoMock.Setup(r => r.GetAdById<Ad>(17)).Returns(ad);
var helperMock = new Moq.Mock<IHelperService>();
helperMock.Setup(s => s.GetCurrentDateTime()).Returns(new DateTime(2012, 02, 20));
AdDetailsServices service = new AdDetailsServices(adRepoMock.Object, helperMock.Object);
// When
AdDetailsModel actual = service.GetAdDetails(17);
// Then
Assert.AreEqual(17, actual.AdId);
}
public void TestSimple_2()
{
var facts = new List<NullableFact>();
facts.Add(new NullableFact() { ProductId = null, GeographyId = null, SalesComponentId = null, TimeId = 1, Value = 100 });
var products = new Moq.Mock<IHierarchy>();
var geographies = new Moq.Mock<IHierarchy>();
var causals = new Moq.Mock<IHierarchy>();
var periods = new Moq.Mock<IHierarchy>();
Expression<Func<IHierarchy, IEnumerable<short>>> anyInt = p => p.GetParents(Moq.It.IsAny<short>());
var result = new List<short> { 1 };
products.Setup(anyInt).Returns(result);
geographies.Setup(anyInt).Returns(result);
causals.Setup(anyInt).Returns(result);
periods.Setup(anyInt).Returns(result);
Expression<Func<IHierarchy, bool>> allRelationships = p => p.RelationExists(Moq.It.IsAny<short>(), Moq.It.IsAny<short>());
products.Setup(allRelationships).Returns(true);
geographies.Setup(allRelationships).Returns(true);
causals.Setup(allRelationships).Returns(true);
periods.Setup(allRelationships).Returns(true);
//, Hierarchy products, Hierarchy geographies, Hierarchy causals, Hierarchy periods
var lookup = new FactLookup(facts, products.Object, geographies.Object, causals.Object, periods.Object);
Assert.AreEqual(100, lookup.GetParent(0, 0, 0, 1));
Assert.AreEqual(100, lookup.GetParent(1, 1, 1, 1));
Assert.AreEqual(100, lookup.GetParent(2, 2, 2, 1));
}
ShoppingCart.Web.Mvc.Controllers.CartController CreateCartController()
{
var mock = new Moq.Mock<ControllerContext>();
var cartRepository = new Services.MockCartRepository();
var cartService = new ShoppingCart.Web.Mvc.Services.CartService(cartRepository);
var product = new Moq.Mock<Model.IProduct>();
product.Setup(i => i.Code).Returns("xxx");
product.Setup(i => i.Packaging).Returns(1);
product.Setup(i => i.SaleUnitValue).Returns(1);
product.Setup(i => i.Title).Returns("product 1");
var catalogService = new Moq.Mock<Mvc.Services.ICatalogService>();
catalogService.Setup(i => i.GetProductByCode("xxx")).Returns(product.Object);
catalogService.Setup(i => i.GetPriceByProduct(product.Object)).Returns(new ShoppingCart.Web.Mvc.Model.Price(10.0, 0.196));
var controller = new ShoppingCart.Web.Mvc.Controllers.CartController(
cartService,
catalogService.Object);
controller.ControllerContext = mock.Object;
return controller;
}
public void GetAdPicturesFromModel_2Pictures_FetchThemFromRepoAndSetFirstAsMainImage()
{
// Given
BaseAd ad = new Ad();
String images = "b9da8b1e-aa77-401b-84e0-a1290130b7b7;b9da8b1e-aa77-401b-84e0-a1290130b999;";
AdImage img1 = new AdImage() { Id = Guid.Parse("b9da8b1e-aa77-401b-84e0-a1290130b7b7") };
AdImage img2 = new AdImage() { Id = Guid.Parse("b9da8b1e-aa77-401b-84e0-a1290130b999") };
var repoMock = new Moq.Mock<IRepository>();
repoMock.Setup(x => x.Get<AdImage>(Guid.Parse("b9da8b1e-aa77-401b-84e0-a1290130b7b7"))).Returns(img1);
repoMock.Setup(x => x.Get<AdImage>(Guid.Parse("b9da8b1e-aa77-401b-84e0-a1290130b999"))).Returns(img2);
AdServices service = new AdServices(null, repoMock.Object, null);
// When
BaseAd result = service.GetAdPicturesFromModel(ad, images);
// Then
Assert.AreEqual(ad, result);
Assert.AreEqual(2, ad.Images.Count);
Assert.AreEqual("b9da8b1e-aa77-401b-84e0-a1290130b7b7", ad.Images[0].Id.ToString());
Assert.AreEqual(ad, ad.Images[0].BaseAd);
Assert.IsTrue(ad.Images[0].IsPrimary);
Assert.AreEqual("b9da8b1e-aa77-401b-84e0-a1290130b999", ad.Images[1].Id.ToString());
Assert.AreEqual(ad, ad.Images[1].BaseAd);
Assert.IsFalse(ad.Images[1].IsPrimary);
}
public void ConcreteFactLookup_GlobalFact()
{
var facts = new List<ConcreteFact>();
facts.Add(new ConcreteFact() { ProductId = 2, GeographyId = 2, SalesComponentId = 2, TimeId = 1, Value = 100 });
facts.Add(new ConcreteFact() { ProductId = 3, GeographyId = 3, SalesComponentId = 3, TimeId = 1, Value = 100 });
var products = new Moq.Mock<IHierarchy>();
var geographies = new Moq.Mock<IHierarchy>();
var causals = new Moq.Mock<IHierarchy>();
var periods = new Moq.Mock<IHierarchy>();
Expression<Func<IHierarchy, IEnumerable<short>>> anyInt = p => p.GetChildren(Moq.It.IsAny<short>());
var result = new List<short> { 2, 3 };
products.Setup(anyInt).Returns(result);
geographies.Setup(anyInt).Returns(result);
causals.Setup(anyInt).Returns(result);
periods.Setup(anyInt).Returns(result);
Expression<Func<IHierarchy, bool>> relation = h => h.RelationExists(Moq.It.IsAny<short>(), Moq.It.IsAny<short>());
products.Setup(relation).Returns(true);
geographies.Setup(relation).Returns(true);
causals.Setup(relation).Returns(true);
periods.Setup(relation).Returns(true);
//, Hierarchy products, Hierarchy geographies, Hierarchy causals, Hierarchy periods
var lookup = new ConcreteFactLookup(facts, products.Object, geographies.Object, causals.Object, periods.Object);
Assert.AreEqual(200, lookup.SumChildren(1, 1, 1, 1));
}
public void content_type(string extension, string mimeType)
{
var fileInfo = new Moq.Mock<IFileInfo>();
fileInfo.Setup(x => x.Extension).Returns(extension);
fileInfo.Setup(x => x.OpenRead()).Returns(StreamWith("<this doesn't matter>"));
ResponseFile = fileInfo.Object;
WithResponseFrom("http://localhost:8080", response => {
Verify.That(() => response.ContentType == mimeType);
});
}
public void EmptyImageReturnsEmptyPalette()
{
var image = new Moq.Mock<IImage>();
image.Setup(x => x.Height).Returns(0);
image.Setup(x => x.Width).Returns(0);
var p = new PercentagePaletteInventory
{
Image = image.Object
};
Assert.AreEqual(0,p.Items.Count);
}
public void Init()
{
var lstValid = SearchResultGenerator();
var lstReports = ReportListGenerator();
var lstUsers = UserListGenerator();
var y = new Moq.Mock<IReportHubDataRepository>();
y.Setup(x => x.Search("validsearch")).Returns(lstValid);
y.Setup(x => x.TopReports(5)).Returns(lstReports.AsEnumerable());
y.Setup(x => x.TopUsers(5)).Returns(lstUsers.AsEnumerable());
rhs = new ReportHubService(y.Object);
}
public void ShouldGetAllLogFiles()
{
var fileSystem = new Moq.Mock<IFileSystem>();
var logFiles = new[] { @"C:\Path\backup-1234567890.csv" };
var nonLogFiles = new[] { @"C:\Path\no-match.csv" };
fileSystem.Setup(x => x.GetCommonApplicationDataPath()).Returns(@"C:\Path");
fileSystem.Setup(x => x.GetFiles(@"C:\Path\cache\logs")).Returns(logFiles.Union(nonLogFiles));
var target = new JungleDiskLogFilesProvider(fileSystem.Object, new AutomaticLogFilePath(fileSystem.Object));
var result = target.GetAllLogFiles();
result.Should().Have.SameSequenceAs(logFiles);
}
/// <summary>
/// renaming helper method for mocking IMatrixData
/// </summary>
/// <param name="colnames"></param>
/// <param name="pattern"></param>
/// <param name="replacement"></param>
private static void Rename(List<string> colnames, string pattern, string replacement)
{
var renamer = new RenameColumnsRegexp();
var matrix = new Moq.Mock<IMatrixData>();
matrix.Setup(m => m.ColumnCount).Returns(colnames.Count);
matrix.Setup(m => m.ColumnNames).Returns(colnames);
string err = "";
var param = renamer.GetParameters(matrix.Object, ref err);
param.GetParam<Tuple<Regex, string>>("Regex").Value = Tuple.Create(new Regex(pattern), replacement);
IMatrixData[] supplTables = null;
IDocumentData[] documents = null;
renamer.ProcessData(matrix.Object, param, ref supplTables, ref documents, null);
}
public void content_matches()
{
var message = "Hello World!";
var fileInfo = new Moq.Mock<IFileInfo>();
fileInfo.Setup(x => x.Extension).Returns(".bin");
fileInfo.Setup(x => x.OpenRead()).Returns(StreamWith(message));
ResponseFile = fileInfo.Object;
WithResponseFrom("http://localhost:8080", response => {
Verify.That(() => response.ContentLength == message.Length);
using(var reader = new StreamReader(response.GetResponseStream()))
Verify.That(() => reader.ReadToEnd() == message);
});
}
public void RedImageReturnsRedPalette()
{
var image = new Moq.Mock<IImage>();
image.Setup(x => x.Width).Returns(1);
image.Setup(x => x.Height).Returns(1);
image.Setup(x => x.GetPixel(0,0)).Returns(Color.Red);
var p = new PercentagePaletteInventory
{
Image = image.Object
};
Assert.IsTrue(Math.Abs(p.Items[Color.Red] - 1) < Epsilon);
}
private string GetOutboundUrl(object routeValues)
{
RouteCollection routes = new RouteCollection();
RouteConfig.RegisterRoutes(routes);
var mockHttpContext = new Moq.Mock<HttpContextBase>();
var mockRequest = new Moq.Mock<HttpRequestBase>();
var fakeResponse = new FakeResponse();
mockHttpContext.Setup(x => x.Request).Returns(mockRequest.Object);
mockHttpContext.Setup(x => x.Response).Returns(fakeResponse);
mockRequest.Setup(x => x.ApplicationPath).Returns("/");
var ctx = new RequestContext(mockHttpContext.Object, new RouteData());
return routes.GetVirtualPath(ctx, new RouteValueDictionary(routeValues)).VirtualPath;
}
public ContextMocks(Controller onController)
{
HttpContext = new Moq.Mock<HttpContextBase>();
Request = new Moq.Mock<HttpRequestBase>();
Response = new Moq.Mock<HttpResponseBase>();
HttpContext.Setup(x => x.Request).Returns(Request.Object);
HttpContext.Setup(x => x.Response).Returns(Response.Object);
HttpContext.Setup(x => x.Session).Returns(new FakeSessionState());
Request.Setup(x => x.Cookies).Returns(new HttpCookieCollection());
Response.Setup(x => x.Cookies).Returns(new HttpCookieCollection());
Request.Setup(x => x.QueryString).Returns(new NameValueCollection());
Request.Setup(x => x.Form).Returns(new NameValueCollection());
RequestContext requestContext = new RequestContext(HttpContext.Object, new RouteData());
onController.ControllerContext = new ControllerContext(requestContext, onController);
}
public void AddressTranslatorIsCalledPerEachPeer()
{
var invokedEndPoints = new List <IPEndPoint>();
var translatorMock = new Moq.Mock <IAddressTranslator>(Moq.MockBehavior.Strict);
translatorMock
.Setup(t => t.Translate(Moq.It.IsAny <IPEndPoint>()))
.Callback <IPEndPoint>(invokedEndPoints.Add)
.Returns <IPEndPoint>(e => e);
var testCluster = TestClusterManager.GetNonShareableTestCluster(3);
var cluster = Cluster.Builder()
.AddContactPoint(testCluster.InitialContactPoint)
.WithReconnectionPolicy(new ConstantReconnectionPolicy(int.MaxValue))
.WithAddressTranslator(translatorMock.Object)
.Build();
cluster.Connect();
//2 peers translated
Assert.AreEqual(2, invokedEndPoints.Count);
Assert.True(cluster.AllHosts().All(h => h.IsUp));
testCluster.Stop(3);
//Wait for the C* event to notify the control connection
Thread.Sleep(30000);
//Should be down
Assert.False(cluster.AllHosts().First(h => TestHelper.GetLastAddressByte(h) == 3).IsUp);
//Should have been translated
Assert.AreEqual(3, invokedEndPoints.Count);
//The recently translated should be the host #3
Assert.AreEqual(3, TestHelper.GetLastAddressByte(invokedEndPoints.Last()));
cluster.Dispose();
}
public void Can_Remove_Product_From_Cart()
{
// Подготовка
var mockProductsRepository = new Moq.Mock<IProductsRepository>();
var products = new List<Product>()
{
new Product {ProductID=14, Name="Much Ado About Nothing" },
new Product {ProductID=27, Name="The Comedy of Errors" }
};
mockProductsRepository.Setup(x => x.Products)
.Returns(products.AsQueryable());
var cart = new Cart();
var controller = new CartController(mockProductsRepository.Object, null);
controller.AddToCart(cart, 14, "someReturnUrl");
controller.AddToCart(cart, 27, "someReturnUrl");
Assert.AreEqual(2, cart.Lines.Count);
// Действие
RedirectToRouteResult result =
controller.RemoveFromCart(cart, 14, "someReturnUrl");
// Утверждение
Assert.AreEqual(1, cart.Lines.Count);
Assert.AreEqual(27, cart.Lines[0].Product.ProductID);
Assert.AreEqual("Index", result.RouteValues["action"]);
Assert.AreEqual("someReturnUrl", result.RouteValues["returnUrl"]);
}
public async Task Attaches_Request_Parameters_To_Be_Accessible_Via_ScriptContext()
{
var expectedUri = new Uri("http://127.0.0.1");
var expectedBody = Encoding.UTF8.GetBytes("TestBodyData");
var httpRequest = new Moq.Mock <HttpRequest>();
httpRequest.Setup(h => h.Scheme).Returns(expectedUri.Scheme);
httpRequest.Setup(h => h.Host).Returns(new HostString(expectedUri.Host));
httpRequest.Setup(h => h.Query).Returns(new QueryCollection());
httpRequest.Setup(h => h.Headers).Returns(new HeaderDictionary());
using (var bodyStream = new MemoryStream(expectedBody))
{
httpRequest.Setup(h => h.Body).Returns(bodyStream);
var httpContext = Moq.Mock.Of <HttpContext>(c => c.Request == httpRequest.Object && c.Connection.RemoteIpAddress == IPAddress.Loopback);
var mockacoContext = Moq.Mock.Of <IMockacoContext>(c => c.Errors == new List <Error>());
var scriptContext = new Moq.Mock <IScriptContext>();
scriptContext.Setup(c => c.AttachRequest(httpRequest.Object)).Verifiable();
var mockProvider = new Moq.Mock <IMockProvider>();
mockProvider.Setup(p => p.GetMocks()).Returns(new List <Mock>());
var templateTransformer = Moq.Mock.Of <ITemplateTransformer>();
var requestMatchers = Moq.Mock.Of <IEnumerable <IRequestMatcher> >();
await _middleware.Invoke(httpContext, mockacoContext, scriptContext.Object, mockProvider.Object, templateTransformer, requestMatchers);
Moq.Mock.Verify(scriptContext);
}
}
public void AccountHandler_SendMoney_Succesfull()
{
var accountService = new Moq.Mock <IAccountService>();
var accountHandler = new AccountHandler(accountService.Object);
var transactionId = Guid.NewGuid();
Guid accountId = Guid.NewGuid();
var account = new Models.Account();
var ammount = new Models.Money();
var accountDetail = new Models.AccountDetail()
{
Id = accountId,
Account = account,
Balance = new Money()
{
Total = 1000,
Currency = "BRL"
}
};
accountService
.Setup(a => a.FindAccount(account))
.Returns(accountDetail);
accountHandler.SendMoney(account, ammount, transactionId);
accountService.Verify(a => a.FindAccount(account), Moq.Times.Once);
accountService.Verify(a => a.SendMoney(accountId, ammount, transactionId), Moq.Times.Once);
}
public void Test_CtorWithAd()
{
// Given
SailingBoatAd ad = new SailingBoatAd
{
Title = "title",
SailingBoatType = new Bea.Domain.Reference.SailingBoatType { Label = "type" },
HullType = new Bea.Domain.Reference.SailingBoatHullType { Label = "hull" },
Year = 2012,
Length = 15.75000,
City = new City(),
CreatedBy = new User()
};
var helperMock = new Moq.Mock<IHelperService>();
helperMock.Setup(x => x.GetCulture()).Returns(new System.Globalization.CultureInfo("Fr"));
// When
SailingBoatAdDetailsModel actual = new SailingBoatAdDetailsModel(ad, helperMock.Object);
// Then
Assert.AreEqual(ad.Title, actual.Title);
Assert.AreEqual(ad.SailingBoatType.Label, actual.BoatType);
Assert.AreEqual(ad.HullType.Label, actual.HullType);
Assert.AreEqual(ad.Year, actual.Year);
Assert.AreEqual("15,75 Mtr", actual.Length);
}
public void Produces_Home_Plus_NaLink_Object_For_Each_Distinct_Category()
{
// Подготовка
IQueryable<Product> products = new[] {
new Product { Name="A", Category="Animal" },
new Product { Name="B", Category="Vegetable" },
new Product { Name="C", Category="Mineral" },
new Product { Name="D", Category="Vegetable" },
new Product { Name="E",Category="Animal" }
}.AsQueryable();
var mockProductRepository = new Moq.Mock<IProductsRepository>();
mockProductRepository.Setup(x => x.Products).Returns(products);
var controller = new NavController(mockProductRepository.Object);
// Действие
ViewResult result = controller.Menu(null);
var links = ((IEnumerable<NavLink>)result.ViewData.Model).ToList();
Assert.AreEqual(4, links.Count);
Assert.AreEqual("All", links[0].Text);
Assert.AreEqual("Animal", links[1].Text);
Assert.AreEqual("Mineral", links[2].Text);
Assert.AreEqual("Vegetable", links[3].Text);
foreach(var link in links)
{
Assert.AreEqual("Products", link.RouteValues["controller"]);
Assert.AreEqual("List", link.RouteValues["action"]);
Assert.AreEqual(1, link.RouteValues["page"]);
if (links.IndexOf(link) == 0)
Assert.IsNull(link.RouteValues["category"]);
else
Assert.AreEqual(link.Text, link.RouteValues["category"]);
}
}
public void Setup()
{
_store = new Moq.Mock <IStoreEvents>();
_cache = new Moq.Mock <ICache>();
_pocoStore = new Aggregates.Internal.StorePocos(_store.Object, _cache.Object, false, (a, b, c, d, e) => "test");
var @event = new Moq.Mock <IFullEvent>();
@event.Setup(x => x.Event).Returns(new Poco());
@event.Setup(x => x.Descriptor.Version).Returns(0);
_events = new[]
{
@event.Object
};
}
public ContextMocks(Controller onController, bool IsAjax = false, bool isJson = false)
{
HttpContext = new Moq.Mock <HttpContextBase>();
Request = new Moq.Mock <HttpRequestBase>();
Response = new Moq.Mock <HttpResponseBase>();
HttpContext.Setup(x => x.Request).Returns(Request.Object);
HttpContext.Setup(x => x.Response).Returns(Response.Object);
HttpContext.Setup(x => x.Session).Returns(new FakeSessionState());
Request.Setup(x => x.Cookies).Returns(new HttpCookieCollection());
Response.Setup(x => x.Cookies).Returns(new HttpCookieCollection());
Request.Setup(x => x.QueryString).Returns(new NameValueCollection());
Request.Setup(x => x.Form).Returns(new NameValueCollection());
Request.Setup(x => x.ServerVariables).Returns(new NameValueCollection());
if (IsAjax)
{
Request.Setup(x => x["X-Requested-With"]).Returns("XMLHttpRequest");
}
if (isJson)
{
Request.SetupGet(c => c.AcceptTypes).Returns(new[] { "application/json" }).Verifiable();
}
Request.Setup(x => x.Params).Returns(new NameValueCollection());
Request.SetupAllProperties();
RequestContext rc = new RequestContext(HttpContext.Object, new RouteData());
onController.ControllerContext = new ControllerContext(rc, onController);
}
public void ShouldCallConverterForEachFile()
{
var converter = new Moq.Mock<ICsvToSqlInsertConverter>();
var tableFactory = new Moq.Mock<ICsvTableFactory>();
var table1 = new Moq.Mock<ICsvTable>().Object;
var table2 = new Moq.Mock<ICsvTable>().Object;
tableFactory.Setup(tf => tf.CreateCsvTable("a")).Returns(table1);
tableFactory.Setup(tf => tf.CreateCsvTable("b")).Returns(table2);
converter.Setup(c => c.Convert(table1));
converter.Setup(c => c.Convert(table2));
new CsvFileProcessor(new string[] {"a", "b"}, converter.Object, tableFactory.Object).Process();
tableFactory.VerifyAll();
converter.VerifyAll();
}
public void Setup()
{
_id = Guid.NewGuid();
_builder = new Moq.Mock <IBuilder>();
_store = new Moq.Mock <IStoreEvents>();
_snaps = new Moq.Mock <IStoreSnapshots>();
_stream = new Moq.Mock <IEventStream>();
_eventFactory = new Moq.Mock <IMessageCreator>();
_resolver = new Moq.Mock <IRouteResolver>();
_processor = new Moq.Mock <IProcessor>();
_mapper = new Moq.Mock <IMessageMapper>();
_eventFactory.Setup(x => x.CreateInstance(Moq.It.IsAny <Action <CreatedEvent> >())).Returns <Action <CreatedEvent> >((e) => { var ev = new CreatedEvent(); e(ev); return(ev); });
_eventFactory.Setup(x => x.CreateInstance(Moq.It.IsAny <Action <UpdatedEvent> >())).Returns <Action <UpdatedEvent> >((e) => { var ev = new UpdatedEvent(); e(ev); return(ev); });
_eventFactory.Setup(x => x.CreateInstance(typeof(CreatedEvent))).Returns(new CreatedEvent());
_eventFactory.Setup(x => x.CreateInstance(typeof(UpdatedEvent))).Returns(new UpdatedEvent());
_resolver.Setup(x => x.Resolve(Moq.It.IsAny <_AggregateStub>(), typeof(CreatedEvent))).Returns <_AggregateStub, Type>((agg, type) => (@event) => (agg as _AggregateStub).Handle(@event as CreatedEvent));
_resolver.Setup(x => x.Resolve(Moq.It.IsAny <_AggregateStub>(), typeof(UpdatedEvent))).Returns <_AggregateStub, Type>((agg, type) => (@event) => (agg as _AggregateStub).Handle(@event as UpdatedEvent));
_snaps.Setup(x => x.GetSnapshot(Moq.It.IsAny <String>(), Moq.It.IsAny <String>()));
_store.Setup(x => x.GetStream <_AggregateStub>(Moq.It.IsAny <String>(), Moq.It.IsAny <String>(), Moq.It.IsAny <Int32?>())).Returns(_stream.Object);
_builder.Setup(x => x.CreateChildBuilder()).Returns(_builder.Object);
_builder.Setup(x => x.Build <IRouteResolver>()).Returns(_resolver.Object);
_builder.Setup(x => x.Build <IMessageCreator>()).Returns(_eventFactory.Object);
_builder.Setup(x => x.Build <IStoreEvents>()).Returns(_store.Object);
_builder.Setup(x => x.Build <IStoreSnapshots>()).Returns(_snaps.Object);
_builder.Setup(x => x.Build <IProcessor>()).Returns(_processor.Object);
_stream.Setup(x => x.StreamId).Returns(String.Format("{0}", _id));
_stream.Setup(x => x.StreamVersion).Returns(0);
_stream.Setup(x => x.Events).Returns(new List <IWritableEvent>());
_uow = new Aggregates.Internal.UnitOfWork(new DefaultRepositoryFactory(), _mapper.Object);
_uow.Builder = _builder.Object;
}
public async Task NamespacedPodExecAsync_ActionNull()
{
using (MemoryStream stdIn = new MemoryStream())
using (MemoryStream stdOut = new MemoryStream())
using (MemoryStream stdErr = new MemoryStream())
using (MemoryStream errorStream = new MemoryStream())
{
var muxedStream = new Moq.Mock <IStreamDemuxer>();
muxedStream.Setup(m => m.GetStream(null, ChannelIndex.StdIn)).Returns(stdIn);
muxedStream.Setup(m => m.GetStream(ChannelIndex.StdOut, null)).Returns(stdOut);
muxedStream.Setup(m => m.GetStream(ChannelIndex.StdErr, null)).Returns(stdErr);
muxedStream.Setup(m => m.GetStream(ChannelIndex.Error, null)).Returns(errorStream);
var kubernetesMock = new Moq.Mock <Kubernetes>(
new object[] { Moq.Mock.Of <ServiceClientCredentials>(), new DelegatingHandler[] { } });
var command = new string[] { "/bin/bash", "-c", "echo Hello, World!" };
kubernetesMock.Setup(m => m.MuxedStreamNamespacedPodExecAsync("pod-name", "pod-namespace", command,
"my-container", true, true, true, false, WebSocketProtocol.V4BinaryWebsocketProtocol, null,
CancellationToken.None))
.Returns(Task.FromResult(muxedStream.Object));
using (Kubernetes client = kubernetesMock.Object)
{
await Assert.ThrowsAsync <ArgumentNullException>(() => client.NamespacedPodExecAsync("pod-name",
"pod-namespace", "my-container", command, false, null, CancellationToken.None))
.ConfigureAwait(false);
}
}
}
public void SpamRequestAd_AdExists_SaveSpamRequest()
{
// Given
var adRepoMock = new Moq.Mock<IAdRepository>();
adRepoMock.Setup(x => x.CanDeleteAd(7)).Returns(true);
var repoMock = new Moq.Mock<IRepository>();
repoMock.Setup(x => x.Get<SpamAdType>(3)).Returns(new SpamAdType() { Id = 3 });
var hSMock = new Moq.Mock<IHelperService>();
hSMock.Setup(x => x.GetCurrentDateTime()).Returns(new DateTime(2013, 05, 17, 6, 7, 22));
SpamAdRequestModel model = new SpamAdRequestModel();
model.AdId = 7;
model.Description = "description";
model.RequestorEmail = "*****@*****.**";
model.SelectedSpamAdTypeId = 3;
SpamAdServices service = new SpamAdServices(adRepoMock.Object, repoMock.Object, hSMock.Object);
// When
SpamAdRequestModel result = service.SpamRequestAd(model);
// Then
Assert.IsFalse(result.CanSignal);
Assert.AreEqual("Votre signalement a correctement été transmis. Merci de votre précieuse aide dans la chasse aux mauvaises annonces !", result.InfoMessage);
repoMock.Verify(x => x.Save(Moq.It.Is<SpamAdRequest>(b =>
b.Description == model.Description
&& b.RequestDate == new DateTime(2013, 05, 17, 6, 7, 22)
&& b.RequestorEmailAddress == model.RequestorEmail
&& b.SpamType.Id == 3)));
}
public void Can_Remove_Product_From_Cart()
{
// Arrange: Set up a mock repository with two products
var mockProductsRepos = new Moq.Mock<IProductsRepository>();
var products = new System.Collections.Generic.List<Product> {
new Product { ProductID = 14, Name = "Much Ado About Nothing" },
new Product { ProductID = 27, Name = "The Comedy of Errors" },
};
mockProductsRepos.Setup(x => x.Products)
.Returns(products.AsQueryable());
var cart = new Cart();
cart.AddItem(products[1], 2); // 2x Comedy of Errors
cart.AddItem(products[0], 3); // 3x Much Ado
var controller = new CartController(mockProductsRepos.Object, null);
// Act: Try removing Much Ado
RedirectToRouteResult result =
controller.RemoveFromCart(cart, 14, "someReturnUrl");
// Assert
Assert.AreEqual(1, cart.Lines.Count);
Assert.AreEqual("The Comedy of Errors", cart.Lines[0].Product.Name);
Assert.AreEqual(2, cart.Lines[0].Quantity);
// Check that the visitor was redirected to the cart display screen
Assert.AreEqual("Index", result.RouteValues["action"]);
Assert.AreEqual("someReturnUrl", result.RouteValues["returnUrl"]);
}
private void TestRoute(string url, object expectedValues)
{
// Подготовка
RouteCollection routes = new RouteCollection();
RouteConfig.RegisterRoutes(routes);
var mockHttpContext = new Moq.Mock<HttpContextBase>();
var mockRequest = new Moq.Mock<HttpRequestBase>();
mockHttpContext.Setup(x => x.Request).Returns(mockRequest.Object);
mockRequest.Setup(x => x.AppRelativeCurrentExecutionFilePath).Returns(url);
// Действие
RouteData routeData = routes.GetRouteData(mockHttpContext.Object);
// Утверждение
Assert.IsNotNull(routeData);
var expectedDist = new RouteValueDictionary(expectedValues);
foreach (var expectedVal in expectedDist)
{
if (expectedVal.Value == null)
Assert.IsNull(routeData.Values[expectedVal.Key]);
else
Assert.AreEqual(expectedVal.Value.ToString(),
routeData.Values[expectedVal.Key].ToString());
}
}
private void TestRoute(string url, object expectedValues)
{
// Arrange: Prepare the route collection and a mock request context
RouteCollection routes = new RouteCollection();
MvcApplication.RegisterRoutes(routes);
var mockHttpContext = new Moq.Mock<HttpContextBase>();
var mockRequest = new Moq.Mock<HttpRequestBase>();
mockHttpContext.Setup(x => x.Request).Returns(mockRequest.Object);
mockRequest.Setup(x => x.AppRelativeCurrentExecutionFilePath).Returns(url);
// Act: Get the mapped route
RouteData routeData = routes.GetRouteData(mockHttpContext.Object);
// Assert: Test the route values against expectations
Assert.IsNotNull(routeData);
var expectedDict = new RouteValueDictionary(expectedValues);
foreach (var expectedVal in expectedDict)
{
if (expectedVal.Value == null)
Assert.IsNull(routeData.Values[expectedVal.Key]);
else
Assert.AreEqual(expectedVal.Value.ToString(),
routeData.Values[expectedVal.Key].ToString());
}
}
public static void Initialize()
{
IAccountRepository accRepo = new Moq.Mock<IAccountRepository>().Object;
ISessionRepository sessionRepo = new Moq.Mock<ISessionRepository>().Object;
IPOSSettingRepository posSettingRepo = new Moq.Mock<IPOSSettingRepository>().Object;
Moq.Mock<IProductRepository> productRepo = new Moq.Mock<IProductRepository>();
product_1 = new Product(Guid.NewGuid(), "Product ABC", "001", "001", 2000);
productRepo.Setup(i => i.GetByBarcodeOrCode("001")).Returns(product_1);
Moq.Mock<ICompanyProfileRepository> cpRepo = new Moq.Mock<ICompanyProfileRepository>();
cpRepo.Setup(i => i.Get()).Returns(new CompanyProfile("*****@*****.**", "123", "Toko Dny", "Diamond Palace", null));
AutoNumber autoNumber = new AutoNumber("*****@*****.**", "123", DateTime.Now);
Moq.Mock<IAutoNumberRepository> autoNumberRepo = new Moq.Mock<IAutoNumberRepository>();
autoNumberRepo.Setup(i => i.Get(DateTime.Now)).Returns(autoNumber);
var sessionHolder = new SessionHolder();
ObjectFactory.Initialize(i =>
{
i.For<IAccountRepository>().Use(accRepo);
i.For<ISessionRepository>().Use(sessionRepo);
i.For<ICompanyProfileRepository>().Use(cpRepo.Object);
i.For<SessionService>().Use<SessionService>();
i.For<ShoppingCartService>().Use<ShoppingCartService>();
i.ForSingletonOf<SessionHolder>().Use<SessionHolder>();
i.For<IProductRepository>().Use(productRepo.Object);
i.For<IPOSSettingRepository>().Use(posSettingRepo);
i.ForSingletonOf<SessionHolder>().Use(sessionHolder);
i.ForSingletonOf<IShoppingCartSingleton>().Use(sessionHolder);
i.For<IAutoNumberRepository>().Use(autoNumberRepo.Object);
i.For<AutoNumberGenerator>().Use<AutoNumberGenerator>();
});
}
public void tewwet()
{
var productRepository = new Moq.Mock<IProductRepository>();
productRepository.Setup(x => x.Get())
.Returns(new[]
{
new Product()
{
ID = 1,
Title = "iPad",
Description = "Fruit based tablet",
UnitPrice = 450
},
new Product()
{
ID = 2,
Title = "iPhone",
Description = "Fruit based phone",
UnitPrice = 500
}
});
var homeController = new HomeController(productRepository.Object);
var result = homeController.Index() as ViewResult;
Assert.NotNull(result.Model);
}
public async Task NamespacedPodExecAsync_HttpException_WithStatus()
{
var kubernetesMock = new Moq.Mock <Kubernetes>(
new object[] { Moq.Mock.Of <ServiceClientCredentials>(), new DelegatingHandler[] { } });
var command = new string[] { "/bin/bash", "-c", "echo Hello, World!" };
var handler = new ExecAsyncCallback((stdIn, stdOut, stdError) => Task.CompletedTask);
var status = new V1Status();
kubernetesMock.Setup(m => m.MuxedStreamNamespacedPodExecAsync("pod-name", "pod-namespace", command,
"my-container", true, true, true, false, WebSocketProtocol.V4BinaryWebsocketProtocol, null,
CancellationToken.None))
.Throws(new HttpOperationException()
{
Body = status
});
using (Kubernetes client = kubernetesMock.Object)
{
var ex = await Assert.ThrowsAsync <KubernetesException>(() => client.NamespacedPodExecAsync("pod-name",
"pod-namespace", "my-container", command, false, handler, CancellationToken.None))
.ConfigureAwait(false);
Assert.Same(status, ex.Status);
}
}
public async Task NamespacedPodExecAsyncExitCodeNonZero()
{
var processStatus = new V1Status()
{
Metadata = null,
Status = "Failure",
Message = "command terminated with non-zero exit code: Error executing in Docker Container: 1",
Reason = "NonZeroExitCode",
Details = new V1StatusDetails()
{
Causes = new List <V1StatusCause>()
{
new V1StatusCause()
{
Reason = "ExitCode", Message = "1"
},
},
},
};
var processStatusJson = JsonSerializer.SerializeToUtf8Bytes(processStatus);
var handler = new ExecAsyncCallback((stdIn, stdOut, stdError) => Task.CompletedTask);
using (MemoryStream stdIn = new MemoryStream())
using (MemoryStream stdOut = new MemoryStream())
using (MemoryStream stdErr = new MemoryStream())
using (MemoryStream errorStream = new MemoryStream(processStatusJson))
{
var muxedStream = new Moq.Mock <IStreamDemuxer>();
muxedStream.Setup(m => m.GetStream(null, ChannelIndex.StdIn)).Returns(stdIn);
muxedStream.Setup(m => m.GetStream(ChannelIndex.StdOut, null)).Returns(stdOut);
muxedStream.Setup(m => m.GetStream(ChannelIndex.StdErr, null)).Returns(stdErr);
muxedStream.Setup(m => m.GetStream(ChannelIndex.Error, null)).Returns(errorStream);
var kubernetesMock = new Moq.Mock <Kubernetes>(
new object[] { new KubernetesClientConfiguration()
{
Host = "http://localhost"
}, new DelegatingHandler[] { } })
{
CallBase = true
};
var command = new string[] { "/bin/bash", "-c", "echo Hello, World!" };
var exception = new Exception();
kubernetesMock.Setup(m => m.MuxedStreamNamespacedPodExecAsync("pod-name", "pod-namespace", command,
"my-container", true, true, true, false, WebSocketProtocol.V4BinaryWebsocketProtocol, null,
CancellationToken.None))
.Returns(Task.FromResult(muxedStream.Object));
using (Kubernetes client = kubernetesMock.Object)
{
var exitCode = await client.NamespacedPodExecAsync("pod-name", "pod-namespace", "my-container",
command, false, handler, CancellationToken.None).ConfigureAwait(false);
Assert.Equal(1, exitCode);
}
}
}
/// <summary>
/// Configurations the with invalid filenames.
/// </summary>
/// <param name="invalidFilenames">The invalid filenames.</param>
/// <returns>IConfiguration.</returns>
public static IConfiguration ConfigurationWithInvalidFilenames(IEnumerable <string> invalidFilenames)
{
var configurationMockFactory = new Moq.Mock <IConfiguration>();
configurationMockFactory.Setup(configuration => configuration.InvalidFileNames()).Returns(invalidFilenames);
return(configurationMockFactory.Object);
}
public void GetIssues()
{
issueService.Setup(service => service.GetAllIssuesAsync()).
Returns(Task.FromResult <IEnumerable <Issue> >(new List <Issue>()));
var allissues = controller.GetIssues();
Assert.IsNotNull(allissues);
}
public void MyTestInitialize()
{
mockIntel = new Moq.Mock<IIntelService>();
mockPeer = new Moq.Mock<IPeerRegistration>();
mockServiceHost = new Moq.Mock<IServiceHost>();
mockServiceHost.Setup(mock => mock.PeerRegistration).Returns(mockPeer.Object);
target = new ServicePresenter(mockIntel.Object, mockServiceHost.Object);
}
public void MixedImageReturnsMixedPalette()
{
var image = new Moq.Mock<IImage>();
image.Setup(x => x.Width).Returns(1);
image.Setup(x => x.Height).Returns(2);
image.Setup(x => x.GetPixel(0, 0)).Returns(Color.Red);
image.Setup(x => x.GetPixel(0, 1)).Returns(Color.Blue);
var p = new PercentagePaletteInventory
{
Image = image.Object
};
// TODO: 2 Asserts, smells bad
Assert.IsTrue(Math.Abs(p.Items[Color.Red] - .5) < Epsilon);
Assert.IsTrue(Math.Abs(p.Items[Color.Blue] - .5) < Epsilon);
}
public void Setup()
{
_uow = new Moq.Mock <IUnitOfWork>();
_stream = new Moq.Mock <IEventStream>();
_streamstore = new Moq.Mock <IStoreStreams>();
_builder = new Moq.Mock <IBuilder>();
_creator = new Moq.Mock <IMessageCreator>();
_mapper = new Moq.Mock <IMessageMapper>();
_creator.Setup(x => x.CreateInstance <Test>(Moq.It.IsAny <Action <Test> >())).Returns(new Test());
_resolver = new Aggregates.Internal.DefaultRouteResolver(_mapper.Object);
_builder.Setup(x => x.Build <IUnitOfWork>()).Returns(_uow.Object);
_builder.Setup(x => x.Build <IStoreStreams>()).Returns(_streamstore.Object);
_entity = new FakeEntity(_stream.Object, _builder.Object, _creator.Object, _resolver);
}
public void TestGetOrCreateHomeWithNewHomeShouldCreateANewHome()
{
var mockPersistance = new Moq.Mock<IPersistanceFramework>();
mockPersistance.Setup(m => m.CreateQueryContext<Home>()).Returns(
TestHomes);
var homeToBeCreated = new Home();
mockPersistance.Setup(m => m.Create<Home>()).Returns(homeToBeCreated);
var repository = new HomeRepository(mockPersistance.Object);
var results = repository.GetOrCreateHome("new address", 1, 1);
Assert.AreNotEqual(TestHomes.First().Id, results.Id);
homeToBeCreated.AddressFull = "new address";
mockPersistance.VerifyAll();
}
public void MyTestInitialize()
{
mockIntel = new Moq.Mock <IIntelService>();
mockPeer = new Moq.Mock <IPeerRegistration>();
mockServiceHost = new Moq.Mock <IServiceHost>();
mockServiceHost.Setup(mock => mock.PeerRegistration).Returns(mockPeer.Object);
target = new ServicePresenter(mockIntel.Object, mockServiceHost.Object);
}
/// <summary>
/// Configurations the length of the with maximum filename.
/// </summary>
/// <param name="maxFilenameLength">Maximum length of the filename.</param>
/// <returns>IConfiguration.</returns>
public static IConfiguration ConfigurationWithMaximumFilenameLength(int maxFilenameLength)
{
var configurationMockFactory = new Moq.Mock <IConfiguration>();
configurationMockFactory.Setup(configuration => configuration.MaximumFilenameLength()).Returns(maxFilenameLength);
return(configurationMockFactory.Object);
}
public void Setup()
{
_mapper = new Moq.Mock <IEventMapper>();
_factory = new Moq.Mock <IEventFactory>();
_mapper.Setup(x => x.GetMappedTypeFor(typeof(ISimple))).Returns(typeof(Simple_impl));
_mapper.Setup(x => x.GetMappedTypeFor(typeof(Simple_impl))).Returns(typeof(ISimple));
_mapper.Setup(x => x.GetMappedTypeFor(typeof(IContain))).Returns(typeof(Contain_impl));
_mapper.Setup(x => x.GetMappedTypeFor(typeof(Contain_impl))).Returns(typeof(IContain));
_factory.Setup(x => x.Create(typeof(ISimple))).Returns(new Simple_impl());
_factory.Setup(x => x.Create(typeof(Simple_impl))).Returns(new Simple_impl());
_factory.Setup(x => x.Create(typeof(IContain))).Returns(new Contain_impl());
_factory.Setup(x => x.Create(typeof(Contain_impl))).Returns(new Contain_impl());
_serializer = new JsonMessageSerializer(_mapper.Object, _factory.Object, new Newtonsoft.Json.JsonConverter[] { });
}
public void WithdrawMoney_Failed()
{
Guid from = Guid.NewGuid();
var fromAccount = new Domain.Account(from, new Domain.User(Guid.NewGuid(), "bob", "*****@*****.**"), 120m, 80m, 0m);
Moq.Mock <IAccountRepository> moq = new Moq.Mock <IAccountRepository>();
moq.Setup(x => x.GetAccountById(from)).Returns(fromAccount);
moq.Setup(x => x.Update(fromAccount)).Throws(new Exception("Shouldn't be called."));
IAccountRepository repository = moq.Object;
WithdrawMoney withdrawMoney = new WithdrawMoney(repository);
bool result = withdrawMoney.Execute(from, 130m);
Assert.False(result);
Assert.Equal(120m, fromAccount.Balance);
}
public void TestMethod1()
{
var logger = new Moq.Mock <ILogger <DataAccess> >();
var sp = new Moq.Mock <IServiceProvider>();
var myContext = new Service.Context.XinDBContext(new Microsoft.EntityFrameworkCore.DbContextOptions <Service.Context.XinDBContext>());
sp.Setup((o) => o.GetService(typeof(IEntityContext))).Returns(myContext);
sp.Setup((o) => o.GetService(typeof(IRepository <ResDepartment>)))
.Returns(new GenericEntityRepository <ResDepartment>(logger.Object));
var provider = new UowProvider(logger.Object, sp.Object);
var uow = provider.CreateUnitOfWork();
var repository = uow.GetRepository <ResDepartment>();
var list = repository.GetAll().ToList();
int id = list[0].Id;
}
public void Has_Uri_When_Service_Running()
{
mockPeer.Setup(mock => mock.PeerUri).Returns("localhost");
target.StartService(peerClassifier);
mockServiceHost.Setup(mock => mock.PeerRegistration.PeerUri).Returns("localhost");
mockServiceHost.Raise(mock => mock.Opened += null, new EventArgs());
Assert.AreEqual <string>("localhost", target.Uri);
}
/// <summary>
/// renaming helper method for mocking IMatrixData
/// </summary>
/// <param name="colnames"></param>
/// <param name="pattern"></param>
/// <param name="replacement"></param>
private static void Rename(List <string> colnames, string pattern, string replacement)
{
var renamer = new RenameColumnsRegexp();
var matrix = new Moq.Mock <IMatrixData>();
matrix.Setup(m => m.ColumnCount).Returns(colnames.Count);
matrix.Setup(m => m.ColumnNames).Returns(colnames);
string err = "";
var param = renamer.GetParameters(matrix.Object, ref err);
param.GetParam <string>("Pattern").Value = pattern;
param.GetParam <string>("Replacement").Value = replacement;
IMatrixData[] supplTables = null;
IDocumentData[] documents = null;
renamer.ProcessData(matrix.Object, param, ref supplTables, ref documents, null);
}
static IProductsRepository MockProductsRepository(params Product[] prods)
{
// Generate an implementor of IProductsRepository at runtime using Moq
var mockProductsRepos = new Moq.Mock <IProductsRepository>();
mockProductsRepos.Setup(x => x.Products).Returns(prods.AsQueryable());
return(mockProductsRepos.Object);
}
public async Task ImportBookCommand_Imports_Book()
{
StoreAccess storeAccess = new StoreAccess();
BookShareReference bookShareReference = new BookShareReference();
BookShare bookShare = new BookShare();
_bookShelfService.Setup(s => s.AddSharedBookToBookShelfAndSaveAsync(storeAccess, bookShareReference)).Returns(Task.FromResult(true)).Verifiable();
_bookShareStoreService.Setup(s => s.LoadBookShareAsync(bookShareReference)).Returns(Task.FromResult(bookShare)).Verifiable();
await _viewModel.InitAsync(storeAccess, bookShareReference);
_eventAggregatorMock.Setup(s => s.GetEvent <BookImportedMessage>()).Returns(new BookImportedMessage()).Verifiable();
_viewModel.ImportBookCommand.Execute();
_eventAggregatorMock.Verify();
_bookShareStoreService.Verify();
}
public void SetUp()
{
List<Product> allProducts = new List<Product>();
for (int i = 1; i <= 50; i++)
allProducts.Add(new Product { ProductID = i, Name = "Product " + i });
mockRepository = new Moq.Mock<IProductsRepository>();
mockRepository.Setup(x => x.Products).Returns(allProducts.AsQueryable);
}
public void Create_Creates_NewBookShelf()
{
BookShelf bookShelf = new BookShelf();
bookShelf.OwnerName = "Tim";
_viewModel.OwnerName = bookShelf.OwnerName;
_bookShelfServiceMock.Setup(s => s.CreateAndSaveBookShelfAsync(_storeAccess, _viewModel.OwnerName)).Returns(Task.FromResult(bookShelf)).Verifiable();
_eventAggregator.Setup(s => s.GetEvent <BookShelfCreatedMessage>().Publish(_storeAccess)).Verifiable();
_viewModel.Init(_storeAccess);
_viewModel.CreateBookShelfCommand.Execute();
_bookShelfServiceMock.Verify();
_eventAggregator.Verify();
}
public static void MyClassInitialize(TestContext testContext)
{
var service2Moq = new Moq.Mock <ISupportUseCase2>();
service2Moq.Setup(moq => moq.UseCase2()).Returns(42);
InterfaceDesign.Public.Step4.Locator.Register <ISupportUseCase2>(service2Moq.Object);
}
/// <summary>
/// Configurations the with valid os versions.
/// </summary>
/// <param name="validOsVersions">The valid os versions.</param>
/// <returns>IConfiguration.</returns>
public static IConfiguration ConfigurationWithValidOSVersions(List <string> validOsVersions)
{
var configurationMockFactory = new Moq.Mock <IConfiguration>();
configurationMockFactory.Setup(configuration => configuration.ValidOsVersions()).Returns(validOsVersions);
return(configurationMockFactory.Object);
}
public async Task Refresh_Refreshes_CurrentUploadCount()
{
_uploadQueueService.Setup(s => s.GetOpenUploadCountAsync()).Returns(Task.FromResult(2));
await _viewModel.RefreshAsync();
Assert.AreEqual(2, _viewModel.CurrentQueueCount);
}
public void ExtractsUserHostAddressPlusHeader()
{
var target = new UserHostExtractor();
var httpContext = new Moq.Mock <HttpContextBase>();
var request = new Moq.Mock <HttpRequestBase>();
var headers = new NameValueCollection {
{ "REMOTE_ADDR", "10.0.0.2" }
};
request.Setup(x => x.UserHostAddress).Returns("10.0.0.1");
request.Setup(x => x.Headers).Returns(headers);
httpContext.Setup(x => x.Request).Returns(request.Object);
var result = target.Extract(httpContext.Object);
Assert.AreEqual("10.0.0.1-10.0.0.2-", result);
}
public void Setup()
{
_builder = new Moq.Mock <IBuilder>();
_store = new Moq.Mock <IStoreEvents>();
_stream = new Moq.Mock <IEventStream>();
_builder.Setup(x => x.Build <IStoreEvents>()).Returns(_store.Object);
}
public void AccountHandler_RevertTransaction_Succesfull()
{
var accountService = new Moq.Mock <IAccountService>();
var accountHandler = new AccountHandler(accountService.Object);
var transactionId = Guid.NewGuid();
var ammount = new Models.Money();
var listOperation = new List <Operation>()
{
new Operation()
{
Id = Guid.NewGuid(),
TransactionId = transactionId,
Ammount = ammount,
OperationType = OperationType.Out,
Status = OperationStatus.Waiting
},
new Operation()
{
Id = Guid.NewGuid(),
TransactionId = transactionId,
Ammount = ammount,
OperationType = OperationType.In,
Status = OperationStatus.Waiting
}
};
accountService
.Setup(a => a.FindOperations(transactionId))
.Returns(listOperation);
accountService
.Setup(a => a.RevertOperation(Moq.It.IsAny <Guid>()))
.Returns <Guid>((operationId) =>
{
var operation = listOperation.FirstOrDefault(o => (Guid)o.Id == operationId);
operation.Status = OperationStatus.Reverted;
return(operation);
});
accountHandler.RevertTransaction(transactionId);
accountService.Verify(a => a.FindOperations(transactionId), Moq.Times.Once);
accountService.Verify(a => a.RevertOperation((Guid)listOperation[0].Id), Moq.Times.Once);
accountService.Verify(a => a.RevertOperation((Guid)listOperation[1].Id), Moq.Times.Once);
}
public void Mock_FileSystemWatcher_Succeeds()
{
var fileSystemMock = new Moq.Mock <IFileSystem>();
Assert.DoesNotThrow(() =>
fileSystemMock.Setup(x => x.FileSystemWatcher.ToString()).Returns("")
);
}
public void Mock_DriveInfo_Succeeds()
{
var fileSystemMock = new Moq.Mock <IFileSystem>();
Assert.DoesNotThrow(() =>
fileSystemMock.Setup(x => x.DirectoryInfo.ToString()).Returns("")
);
}
private ControllerContext GenerateControllerContext(ControllerBase controller)
{
var fakeIdentity = new GenericIdentity("Jimmy");
var fakeUser = new GenericPrincipal(fakeIdentity,null);
var httpContext = new Moq.Mock<HttpContextBase>();
httpContext.Setup(x => x.User).Returns(fakeUser);
var reqContext = new RequestContext(httpContext.Object, new RouteData());
return new ControllerContext(reqContext, controller);
}
public void CallOptionsOverloadCanBeMocked()
{
var expected = new SimpleResponse();
var mockClient = new Moq.Mock<TestService.TestServiceClient>();
mockClient.Setup(m => m.UnaryCall(Moq.It.IsAny<SimpleRequest>(), Moq.It.IsAny<CallOptions>())).Returns(expected);
Assert.AreSame(expected, mockClient.Object.UnaryCall(new SimpleRequest(), new CallOptions()));
}
