public void BuildReturnsCallableDelegate()
{
var builder = new ApplicationBuilder(null);
var app = builder.Build();
var mockHttpContext = new Moq.Mock<HttpContext>();
var mockHttpResponse = new Moq.Mock<HttpResponse>();
mockHttpContext.SetupGet(x => x.Response).Returns(mockHttpResponse.Object);
mockHttpResponse.SetupProperty(x => x.StatusCode);
app.Invoke(mockHttpContext.Object);
Assert.Equal(mockHttpContext.Object.Response.StatusCode, 404);
}
public void Setup()
{
var library = new Moq.Mock<CollectionSettings>();
library.SetupGet(x => x.IsSourceCollection).Returns(false);
library.SetupGet(x => x.Language2Iso639Code).Returns("en");
library.SetupGet(x => x.Language1Iso639Code).Returns("xyz");
library.SetupGet(x => x.XMatterPackName).Returns("Factory");
ErrorReport.IsOkToInteractWithUser = false;
_fileLocator = new FileLocator(new string[]
{
//FileLocator.GetDirectoryDistributedWithApplication( "factoryCollections"),
BloomFileLocator.GetFactoryBookTemplateDirectory("Basic Book"),
BloomFileLocator.GetFactoryBookTemplateDirectory("Wall Calendar"),
FileLocator.GetDirectoryDistributedWithApplication( BloomFileLocator.BrowserRoot),
BloomFileLocator.GetBrowserDirectory("bookLayout"),
BloomFileLocator.GetBrowserDirectory("bookEdit","css"),
BloomFileLocator.GetInstalledXMatterDirectory()
});
var projectFolder = new TemporaryFolder("BookStarterTests_ProjectCollection");
var collectionSettings = new CollectionSettings(Path.Combine(projectFolder.Path, "test.bloomCollection"));
_starter = new BookStarter(_fileLocator, dir => new BookStorage(dir, _fileLocator, new BookRenamedEvent(), collectionSettings), library.Object);
_shellCollectionFolder = new TemporaryFolder("BookStarterTests_ShellCollection");
_libraryFolder = new TemporaryFolder("BookStarterTests_LibraryCollection");
}
public void Setup()
{
var library = new Moq.Mock <CollectionSettings>();
library.SetupGet(x => x.IsSourceCollection).Returns(false);
library.SetupGet(x => x.Language2Iso639Code).Returns("en");
library.SetupGet(x => x.Language1Iso639Code).Returns("xyz");
library.SetupGet(x => x.XMatterPackName).Returns("Factory");
ErrorReport.IsOkToInteractWithUser = false;
_fileLocator = new FileLocator(new string[]
{
//FileLocationUtilities.GetDirectoryDistributedWithApplication( "factoryCollections"),
BloomFileLocator.GetFactoryBookTemplateDirectory("Basic Book"),
BloomFileLocator.GetFactoryBookTemplateDirectory("Wall Calendar"),
FileLocationUtilities.GetDirectoryDistributedWithApplication(BloomFileLocator.BrowserRoot),
BloomFileLocator.GetBrowserDirectory("bookLayout"),
BloomFileLocator.GetBrowserDirectory("bookEdit", "css"),
BloomFileLocator.GetInstalledXMatterDirectory()
});
var projectFolder = new TemporaryFolder("BookStarterTests_ProjectCollection");
var collectionSettings = new CollectionSettings(Path.Combine(projectFolder.Path, "test.bloomCollection"));
_starter = new BookStarter(_fileLocator, (dir, forSelectedBook) => new BookStorage(dir, _fileLocator, new BookRenamedEvent(), collectionSettings), library.Object);
_shellCollectionFolder = new TemporaryFolder("BookStarterTests_ShellCollection");
_libraryFolder = new TemporaryFolder("BookStarterTests_LibraryCollection");
}
/// <summary>
/// Directories the with given parameters.
/// </summary>
/// <param name="root">The root.</param>
/// <param name="depth">The depth.</param>
/// <param name="numberOfDirectories">The number of directories.</param>
/// <param name="numberOfFilesPerDirectory">The number of files per directory.</param>
/// <param name="totalSize">The total size.</param>
/// <returns>IDirectoryInfo.</returns>
public static IDirectoryInfo DirectoryWithGivenParameters(
string root,
int depth,
int numberOfDirectories,
int numberOfFilesPerDirectory,
long totalSize)
{
var plop = new Moq.Mock <IDirectoryInfo>();
var name = $"root";
var fullname = $"{root}\\{name}";
var sizeForFiles = totalSize >> 1;
var sizeForDirs = totalSize - sizeForFiles;
var hierarchyDirs = DirectoriesWithGivenParametersRecursive(
root: fullname,
level: depth,
numberOfDirectories: numberOfDirectories,
numberOfFilesPerDirectory: numberOfFilesPerDirectory,
totalSize: sizeForDirs);
var hierarchyFiles = CreateFileInfoObjects(
root: fullname,
level: depth,
count: numberOfFilesPerDirectory,
totalSize: sizeForFiles);
plop.SetupGet(obj => obj.Name).Returns(name);
plop.SetupGet(obj => obj.FullName).Returns(fullname);
plop.Setup(obj => obj.EnumerateDirectories()).Returns(hierarchyDirs);
plop.Setup(obj => obj.EnumerateFiles()).Returns(hierarchyFiles);
plop.Setup(obj => obj.Exists()).Returns(true);
return(plop.Object);
}
public void Setup()
{
var library = new Moq.Mock <CollectionSettings>();
library.SetupGet(x => x.IsSourceCollection).Returns(false);
library.SetupGet(x => x.Language2Iso639Code).Returns("en");
library.SetupGet(x => x.Language1Iso639Code).Returns("xyz");
library.SetupGet(x => x.XMatterPackName).Returns("Factory");
ErrorReport.IsOkToInteractWithUser = false;
_fileLocator = new FileLocator(new string[]
{
FileLocator.GetDirectoryDistributedWithApplication("factoryCollections"),
FileLocator.GetDirectoryDistributedWithApplication("factoryCollections", "Templates"),
FileLocator.GetDirectoryDistributedWithApplication("factoryCollections", "Templates", "Basic Book"),
FileLocator.GetDirectoryDistributedWithApplication("BloomBrowserUI"),
FileLocator.GetDirectoryDistributedWithApplication("BloomBrowserui/bookLayout"),
FileLocator.GetDirectoryDistributedWithApplication("xMatter")
});
_starter = new BookStarter(_fileLocator, dir => new BookStorage(dir, _fileLocator, new BookRenamedEvent(), new CollectionSettings()), library.Object);
_shellCollectionFolder = new TemporaryFolder("BookStarterTests_ShellCollection");
_libraryFolder = new TemporaryFolder("BookStarterTests_LibraryCollection");
Browser.SetUpXulRunner();
}
/* can't tell if this storeCollectionList ever existed [Test]
* public void GetStoreBooks_ThereAre2_Returns2CollectionItems()
* {
* var b = CreateBloomServer();
* var transaction = new PretendRequestInfo("http://localhost:8089/bloom/storeCollectionList");
* b.MakeReply(transaction);
* AssertThatXmlIn.String(transaction.ReplyContentsAsXml).HasSpecifiedNumberOfMatchesForXpath("//li//h2[text()='alpha']", 1);
* AssertThatXmlIn.String(transaction.ReplyContentsAsXml).HasSpecifiedNumberOfMatchesForXpath("//li//h2[text()='beta']", 1);
* AssertThatXmlIn.String(transaction.ReplyContentsAsXml).HasSpecifiedNumberOfMatchesForXpath("//li/ul", 2);
* }
*/
private void AddBook(string id, string title)
{
var b = new Moq.Mock <Bloom.Book.BookInfo>();
b.SetupGet(x => x.Id).Returns(id);
b.SetupGet(x => x.QuickTitleUserDisplay).Returns(title);
b.SetupGet(x => x.FolderPath).Returns(Path.GetTempPath); //TODO. this works at the moment, cause we just need some folder which exists
_bookInfoList.Add(b.Object);
}
/// <summary>
/// Namespaces the size of the with path and.
/// </summary>
/// <param name="path">The path.</param>
/// <param name="size">The size.</param>
/// <returns>INamespaceInfo.</returns>
public static INamespaceInfo NamespaceWithPathAndSize(string path, long size)
{
var namespaceInfoMock = new Moq.Mock <INamespaceInfo>();
namespaceInfoMock.SetupGet(namespaceInfo => namespaceInfo.Path).Returns(path);
namespaceInfoMock.SetupGet(namespaceInfo => namespaceInfo.TotalFileSizeInBytes).Returns(size);
return(namespaceInfoMock.Object);
}
public static ScriptDom.SchemaObjectName SchemaObjectName(ScriptDom.Identifier baseIdentifier)
{
var schemaObjectName = new Moq.Mock <ScriptDom.SchemaObjectName>();
schemaObjectName.SetupGet(it => it.BaseIdentifier).Returns(baseIdentifier);
schemaObjectName.SetupGet(it => it.SchemaIdentifier).Returns((ScriptDom.Identifier)null);
return(schemaObjectName.Object);
}
private static WebException CreateThrottledResponse(int throttledStatusCode, string retryAfter)
{
var mockWebResponse = new Moq.Mock <HttpWebResponse>();
var responseHeaders = new WebHeaderCollection();
responseHeaders.Add(HttpResponseHeader.RetryAfter, retryAfter);
mockWebResponse.SetupGet <HttpStatusCode>((webRes) => webRes.StatusCode).Returns((HttpStatusCode)throttledStatusCode);
mockWebResponse.SetupGet <WebHeaderCollection>((webRes) => webRes.Headers).Returns((WebHeaderCollection)responseHeaders);
return(new WebException("Transmitter Error", null, WebExceptionStatus.UnknownError, mockWebResponse.Object));
}
public void TestHeadsetDisconnected()
{
var statusMock = new Moq.Mock<ICicStatusService>();
var deviceManagerMock = new Moq.Mock<IDeviceManager>();
var settingsManagerMock = new Moq.Mock<ISettingsManager>();
settingsManagerMock.SetupGet(s => s.HeadsetDisconnectStatusKey).Returns(STATUS_KEY);
settingsManagerMock.SetupGet(s => s.HeadsetDisconnectChangeStatus).Returns(true);
var target = new StatusChanger(null, statusMock.Object, deviceManagerMock.Object, settingsManagerMock.Object);
deviceManagerMock.Raise(d => d.HeadsetDisconnected += null, new Plantronics.UC.SpokesWrapper.ConnectedStateArgs(true, true));
statusMock.Verify(cic => cic.SetStatus(STATUS_KEY));
}
public async Task Test_Account_Create()
{
// Assemble
var mock = new Moq.Mock <IBankContext>();
mock.Setup(context => context.SaveChangesAsync(Moq.It.IsAny <CancellationToken>())).Returns(Task.FromResult(1));
mock.SetupGet(context => context.Accounts).Returns(new List <Account>().AsQueryable());
AccountsController controller = new AccountsController(mock.Object);
// Act
IActionResult result = await controller.Create(new Account()
{
Name = "Test", SSN = "078-05-1120"
});
// Assert
Assert.True(result is ViewResult, "Assert 1");
var response = (result as ViewResult);
Assert.True(response.Model is Account, "Assert 2");
var responseItem = response.Model as Account;
Assert.True(responseItem.Name == "Test", "Assert 3");
Assert.True(responseItem.SSN == "078-05-1120", "Assert 4");
Assert.True(responseItem.DateCreated != null, "Assert 5");
}
private static WebException CreateException(int statusCode)
{
string content = BackendResponseHelper.CreateBackendResponse(3, 1, new [] { "500" });
var bytes = Encoding.UTF8.GetBytes(content);
var responseStream = new MemoryStream();
responseStream.Write(bytes, 0, bytes.Length);
responseStream.Seek(0, SeekOrigin.Begin);
#if NETCOREAPP1_1
System.Net.Http.HttpResponseMessage responseMessage = new System.Net.Http.HttpResponseMessage((HttpStatusCode)statusCode);
responseMessage.Content = new System.Net.Http.StreamContent(responseStream);
ConstructorInfo ctor = typeof(HttpWebResponse).GetConstructors(BindingFlags.Instance | BindingFlags.NonPublic)[0];
HttpWebResponse webResponse = (HttpWebResponse)ctor.Invoke(new object[] { responseMessage, null, null });
return(new WebException("Transmitter Error", null, WebExceptionStatus.UnknownError, webResponse));
#else
var mockWebResponse = new Moq.Mock <HttpWebResponse>();
mockWebResponse.Setup(c => c.GetResponseStream()).Returns(responseStream);
mockWebResponse.SetupGet <HttpStatusCode>((webRes) => webRes.StatusCode).Returns((HttpStatusCode)statusCode);
return(new WebException("Transmitter Error", null, WebExceptionStatus.UnknownError, mockWebResponse.Object));
#endif
}
public void Homecontrollertest()
{
// Arrange
var mockRepo = new Mock <IGetGridRepository>();
var controller = new HomeController(mockRepo.Object);
var userName = "******";
var controllerContext = new Mock <ControllerContext>();
var principal = new Moq.Mock <System.Security.Principal.IPrincipal>();
principal.Setup(p => p.IsInRole("Administrator")).Returns(true);
principal.SetupGet(x => x.Identity.Name).Returns(userName);
controllerContext.SetupGet(x => x.HttpContext.User).Returns((ClaimsPrincipal)principal.Object);
controller.ControllerContext = controllerContext.Object;
// Act
var result = controller.Index();
// Assert
var viewResult = Assert.IsType <ViewResult>(result);
var model = Assert.IsAssignableFrom <GridViewModel>(
viewResult.ViewData.Model);
//Assert.NotEmpty(model.Items);
Assert.NotEmpty(model.Items);
}
public void WithAutomaticDimensionsFromLayers_ReturnsCorrectValue_WhenCalled(LayerTestCase layerTestsCase)
{
// arrange
var sut = new Psb.Infrastructure.Builders.Implementations.PsdFileBuilder();
var layers = layerTestsCase
.LayersRectangles
.Select(lt =>
{
var layer = new Moq.Mock <Domain.ILayer>();
layer
.SetupGet(l => l.Rectangle)
.Returns(lt);
return(layer.Object);
});
var layerList = new Moq.Mock <Domain.ILayerList>();
layerList
.Setup(ll => ll.GetEnumerator())
.Returns(() => layers.GetEnumerator());
sut.Layers = layerList.Object;
// act
sut.WithAutomaticDimensionsFromLayers();
var result = sut.Build();
// assert
Assert.AreEqual(layerTestsCase.ExpectedWidth, result.Width);
Assert.AreEqual(layerTestsCase.ExpectedHeight, result.Height);
}
public async Task CreateDocumentAsync_PullsDocumentFromCacheWhenOneIsAvailable()
{
var cancellationToken = new CancellationToken();
var logger = new Moq.Mock <ILogger <WopiDiscoveryDocumentFactory> >().Object;
var services = new ServiceCollection();
services.AddMemoryCache();
var serviceProvider = services.BuildServiceProvider();
var memoryCache = serviceProvider.GetRequiredService <IMemoryCache>();
var cachedWopiDiscoveryDocument = new Moq.Mock <IWopiDiscoveryDocument>();
cachedWopiDiscoveryDocument.SetupGet(x => x.IsTainted).Returns(false);
memoryCache.Set(ExtensionMethods.WOPI_DISCOVERY_DOCUMENT_CACHE_KEY, cachedWopiDiscoveryDocument.Object);
var wopiDiscoveryDocumentRepository = new Moq.Mock <IWopiDiscoveryDocumentRepository>().Object;
IWopiDiscoveryDocumentFactory wopiDiscoveryDocumentFactory = new WopiDiscoveryDocumentFactory(memoryCache, wopiDiscoveryDocumentRepository, logger);
var wopiDiscoveryDocument = await wopiDiscoveryDocumentFactory.CreateDocumentAsync(cancellationToken);
Assert.AreSame(cachedWopiDiscoveryDocument.Object, wopiDiscoveryDocument, "Expected the cached document to have been returned");
}
public async Task CreateDocumentAsync_DoesNotPullDocumentFromCacheWhenOneIsAvailableButIsMarkedAsTainted()
{
var cancellationToken = new CancellationToken();
var logger = new Moq.Mock <ILogger <WopiDiscoveryDocumentFactory> >().Object;
var taintedWopiDiscoveryDocument = new Moq.Mock <IWopiDiscoveryDocument>();
taintedWopiDiscoveryDocument.SetupGet(x => x.IsTainted).Returns(true);
var services = new ServiceCollection();
services.AddMemoryCache();
var serviceProvider = services.BuildServiceProvider();
var memoryCache = serviceProvider.GetRequiredService <IMemoryCache>();
memoryCache.Set(ExtensionMethods.WOPI_DISCOVERY_DOCUMENT_CACHE_KEY, taintedWopiDiscoveryDocument.Object);
var untaintedWopiDiscoveryDocument = new Moq.Mock <IWopiDiscoveryDocument>().Object;
var wopiDiscoveryDocumentRepository = new Moq.Mock <IWopiDiscoveryDocumentRepository>();
wopiDiscoveryDocumentRepository.Setup(x => x.GetAsync(Moq.It.IsAny <CancellationToken>())).Returns(Task.FromResult(untaintedWopiDiscoveryDocument));
IWopiDiscoveryDocumentFactory wopiDiscoveryDocumentFactory = new WopiDiscoveryDocumentFactory(memoryCache, wopiDiscoveryDocumentRepository.Object, logger);
var wopiDiscoveryDocument = await wopiDiscoveryDocumentFactory.CreateDocumentAsync(cancellationToken);
Assert.AreNotSame(taintedWopiDiscoveryDocument, wopiDiscoveryDocument, "Expected the tainted document to have been discarded and a new one generated");
Assert.AreSame(untaintedWopiDiscoveryDocument, wopiDiscoveryDocument, "Expected the untainted document to have been returned by the repository");
}
public async Task HandleAsync_ThrowsWhenCancellationTokenCancelled()
{
using var cts = new CancellationTokenSource();
cts.Cancel();
var features = new Features();
var snapshot = new Moq.Mock <IOptionsSnapshot <Features> >();
snapshot.SetupGet(x => x.Value).Returns(features);
IWopiRequestFactory wopiRequestFactory = new WopiRequestFactory(features: snapshot.Object);
var httpContext = new DefaultHttpContext();
var httpRequest = httpContext.Request;
httpRequest.Method = HttpMethods.Get;
httpRequest.Path = "/wopi/files/file-name|file-version";
httpRequest.QueryString = new QueryString("?access_token=<valid-access-token>");
httpRequest.Headers["X-WOPI-ItemVersion"] = "file-version";
var createdOk = wopiRequestFactory.TryCreateRequest(request: httpContext.Request, out var wopiRequest);
Assert.IsTrue(createdOk);
await wopiRequest.HandleAsync(httpContext, cts.Token);
}
public void TestingWithoutSearchClause()
{
var starWarsProvider = new Moq.Mock <IStarWarsProvider>();
starWarsProvider.SetupAllProperties();
var expectedList = new []
{
new Person()
{
Name = "Ziutek", SkinColor = "black"
}
}.AsQueryable();
starWarsProvider.Setup(element => element.GetPeople("Ziu")).Returns(expectedList);
var httpContextAccessor = new Moq.Mock <IHttpContextAccessor>();
httpContextAccessor.SetupAllProperties();
httpContextAccessor.SetupGet(element => element.HttpContext.Request.Query).Returns(new QueryCollection(
new Dictionary <string, StringValues>()
{
{ "search", "Ziu" }
}));
var testee = new PeopleController(starWarsProvider.Object, httpContextAccessor.Object);
var result = testee.Get();
Assert.AreEqual(result.Count(), expectedList.Count());
}
public void On_NonExisting_ImageGetTest(params string[] badImageNames)
{
//Arrange
var serverTiming_mock = new Moq.Mock <Lib.AspNetCore.ServerTiming.IServerTiming>();
serverTiming_mock.SetupGet(m => m.Metrics).Returns(() =>
{
return(new List <Lib.AspNetCore.ServerTiming.Http.Headers.ServerTimingMetric>());
});
WebCamImagesModel wcim = new WebCamImagesModel()
{
PageContext = this.LocalPageContext
};
//Act
foreach (var image_name in badImageNames)
{
var result = wcim.OnGet(base.Configuration, serverTiming_mock.Object, image_name);
//Assert
Assert.NotNull(result);
if (!string.IsNullOrEmpty(Configuration["ImageDirectory"]))
{
Assert.IsType <NotFoundResult>(result);
}
else
{
Assert.IsType <NotFoundObjectResult>(result);
}
}
}
public void TestBindIds()
{
var binder = new TypeDataBinder();
IEnumerable <IBinding> bindings;
IPage page = null;
IRawDependencyGroup dependencies;
binder.Bind(new DataModelMock1(),
a =>
{
page = new Moq.Mock <IPage>().Object;
return(page);
},
(Type t, IAttributeSet a, IGroup p, out int r) =>
{
r = 1;
var ctrlMock = new Moq.Mock <IControl>();
ctrlMock.SetupGet(c => c.Id).Returns(() => a.Id);
return(ctrlMock.Object);
}, out bindings, out dependencies);
Assert.AreEqual(0, bindings.ElementAt(0).Control.Id);
Assert.AreEqual(1, bindings.ElementAt(1).Control.Id);
Assert.AreEqual(2, bindings.ElementAt(2).Control.Id);
}
public void ItReturnsErrorWhenCodePointIsInBoundsOfRange()
{
var configurationMockFactory = new Moq.Mock <IConfiguration>();
List <Configuration.CodePointRange> whitelist = new List <Configuration.CodePointRange> {
new Configuration.CodePointRange {
Start = 0x00,
End = 0x77 // x - 1
},
new Configuration.CodePointRange {
Start = 0x7B, // z + 1
End = 0x10FFFF
},
};
configurationMockFactory.Setup(configuration => configuration.WhitelistOfCodePointRanges()).Returns(whitelist);
configurationMockFactory.Setup(configuration => configuration.BlacklistOfCodePoints()).Returns(new List <int>());
FilenamesCharactersValidation validation = new FilenamesCharactersValidation(configurationMockFactory.Object);
var fileInfoMockFactory = new Moq.Mock <IFileInfo>();
fileInfoMockFactory.SetupGet(fileInfo => fileInfo.Name).Returns("AAAxAAAzAAA");
IValidationResult validationResult = validation.Validate(fileInfoMockFactory.Object);
Assert.StrictEqual <Result>(Result.Fail, validationResult.Result);
Assert.True(validationResult.Positions.Count == 2, $"Unexpected number of error positions");
Assert.True(validationResult.Positions[0] == 4, $"Unexpected position of first error");
Assert.True(validationResult.Positions[1] == 8, $"Unexpected position of second error");
}
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);
}
/// <summary>
/// Files the with path.
/// </summary>
/// <param name="path">The path.</param>
/// <returns>IFileInfo.</returns>
public static IFileInfo FileWithPath(string path)
{
var fileInfoMockFactory = new Moq.Mock <IFileInfo>();
fileInfoMockFactory.SetupGet(fileInfo => fileInfo.FullName).Returns(path);
return(fileInfoMockFactory.Object);
}
/// <summary>
/// Files the name of the with.
/// </summary>
/// <param name="name">The name.</param>
/// <returns>IFileInfo.</returns>
public static IFileInfo FileWithName(string name)
{
var fileInfoMockFactory = new Moq.Mock <IFileInfo>();
fileInfoMockFactory.SetupGet(fileInfo => fileInfo.Name).Returns(name);
return(fileInfoMockFactory.Object);
}
/// <summary>
/// Directories the name of the with.
/// </summary>
/// <param name="name">The name.</param>
/// <returns>IDirectoryInfo.</returns>
public static IDirectoryInfo DirectoryWithName(string name)
{
var directoryInfoMockFactory = new Moq.Mock <IDirectoryInfo>();
directoryInfoMockFactory.SetupGet(directoryInfo => directoryInfo.Name).Returns(name);
return(directoryInfoMockFactory.Object);
}
/// <summary>
/// Files the with size of.
/// </summary>
/// <param name="size">The size.</param>
/// <returns>IFileInfo.</returns>
public static IFileInfo FileWithSizeOf(int size)
{
var fileInfoMockFactory = new Moq.Mock <IFileInfo>();
fileInfoMockFactory.SetupGet(fileInfo => fileInfo.Length).Returns(size);
return(fileInfoMockFactory.Object);
}
/// <summary>
/// Directories the with path.
/// </summary>
/// <param name="path">The path.</param>
/// <returns>IDirectoryInfo.</returns>
internal static IDirectoryInfo DirectoryWithPath(string path)
{
var directoryInfoMockFactory = new Moq.Mock <IDirectoryInfo>();
directoryInfoMockFactory.SetupGet(fileInfo => fileInfo.FullName).Returns(path);
return(directoryInfoMockFactory.Object);
}
private static WebException CreateException(int statusCode)
{
var mockWebResponse = new Moq.Mock <HttpWebResponse>();
mockWebResponse.SetupGet <HttpStatusCode>((webRes) => webRes.StatusCode).Returns((HttpStatusCode)statusCode);
return(new WebException("Transmitter Error", null, WebExceptionStatus.UnknownError, mockWebResponse.Object));
}
public void ActualPriceTestWithoutOffer()
{
CheckOut target = new CheckOut(null);
var product = new Moq.Mock <IProduct>();
product.SetupGet(x => x.Price).Returns(100);
target.Scan(product.Object);
Assert.AreEqual(target.ActualPrice(), 100);
}
public void Ctor_ThrowsIfUserAuthenticationServiceIsNull()
{
var userFileMetadataProvider = new Moq.Mock <IUserFileMetadataProvider>();
var snapshot = new Moq.Mock <IOptionsSnapshot <Features> >();
snapshot.SetupGet(x => x.Value).Returns(new Features());
_ = new WopiRequestHandlerFactory(userAuthenticationService: default, userFileMetadataProvider.Object, features: snapshot.Object);
public CustomTestControllerBuilder()
{
var httpContext = new Moq.Mock<HttpContextBase>();
var request = new Moq.Mock<HttpRequestBase>();
var response = new Moq.Mock<HttpResponseBase>();
var server = new Moq.Mock<HttpServerUtilityBase>();
var _cache = HttpRuntime.Cache;
httpContext.Setup(x=> x.Request).Returns(request.Object);
httpContext.Setup(x => x.Response).Returns(response.Object);
httpContext.Setup(x => x.Session).Returns(Session);
httpContext.Setup(x => x.Server).Returns(server.Object);
httpContext.Setup(x => x.Cache).Returns(_cache);
var items = new Dictionary<object, object>();
httpContext.Setup(x => x.Items).Returns(items);
QueryString = new NameValueCollection();
request.Setup(x => x.QueryString).Returns(QueryString);
Form = new NameValueCollection();
request.Setup(x => x.Form).Returns(Form);
request.Setup(x => x.AcceptTypes).Returns((Func<string[]>)(() => AcceptTypes));
var files = new WriteableHttpFileCollection();
Files = files;
request.Setup(x => x.Files).Returns(files);
Func<NameValueCollection> paramsFunc = () => new NameValueCollection { QueryString, Form };
request.Setup(x => x.Params).Returns(paramsFunc);
request.Setup(x => x.AppRelativeCurrentExecutionFilePath).Returns(
(Func<string>)(() => AppRelativeCurrentExecutionFilePath));
request.Setup(x => x.ApplicationPath).Returns((Func<string>)(() => ApplicationPath));
request.Setup(x => x.PathInfo).Returns((Func<string>)(() => PathInfo));
request.Setup(x => x.RawUrl).Returns((Func<string>)(() => RawUrl));
response.SetupProperty(x => x.Status);
httpContext.SetupProperty(x=>x.User);
var ms = new MemoryStream(65536);
var sw = new StreamWriter(ms);
response.SetupGet(x=>x.Output).Returns(sw);
response.SetupGet(x => x.OutputStream).Returns(ms);
response.Setup(x => x.Write(It.IsAny<string>())).Callback((string s) => { sw.Write(s); });
response.Setup(x => x.Write(It.IsAny<char>())).Callback((char s) => { sw.Write(s); });
response.Setup(x => x.Write(It.IsAny<object>())).Callback((object s) => { sw.Write(s); });
//_mocks.Replay(HttpContext);
//_mocks.Replay(request);
//_mocks.Replay(response);
TempDataDictionary = new TempDataDictionary();
HttpContext = httpContext.Object;
}
public void IsValidFalseTest()
{
FlatDiscountOffer target = new FlatDiscountOffer("Test", "Test", "Testproduct", 2, 100);
var productOrder = new Moq.Mock <IProductOrder>();
var product = new Moq.Mock <IProduct>();
product.SetupGet(x => x.SKU).Returns("DifferentProduct");
productOrder.SetupGet(x => x.Product).Returns(product.Object);
Assert.IsFalse(target.IsValid(productOrder.Object));
}
/// <inheritdoc />
public IEnumerable <ITransaction> FetchTransactions(ITransactionInputFormat format, ITransactionContext context)
{
var transactionMock1 = new Moq.Mock <ITransaction>();
transactionMock1.SetupGet(m => m.Amount).Returns(120);
transactionMock1.SetupGet(m => m.Date).Returns(DateTime.Parse("2018-09-02"));
transactionMock1.SetupGet(m => m.Merchant).Returns(context.Merchants.First(merchant => string.Equals(merchant.Name, "CIRCLE_K")));
var transactionMock2 = new Moq.Mock <ITransaction>();
transactionMock2.SetupGet(m => m.Amount).Returns(200);
transactionMock2.SetupGet(m => m.Date).Returns(DateTime.Parse("2018-09-04"));
transactionMock2.SetupGet(m => m.Merchant).Returns(context.Merchants.First(merchant => string.Equals(merchant.Name, "TELIA")));
var transactionMock3 = new Moq.Mock <ITransaction>();
transactionMock3.SetupGet(m => m.Amount).Returns(300);
transactionMock3.SetupGet(m => m.Date).Returns(DateTime.Parse("2018-10-22"));
transactionMock3.SetupGet(m => m.Merchant).Returns(context.Merchants.First(merchant => string.Equals(merchant.Name, "CIRCLE_K")));
var transactionMock4 = new Moq.Mock <ITransaction>();
transactionMock4.SetupGet(m => m.Amount).Returns(150);
transactionMock4.SetupGet(m => m.Date).Returns(DateTime.Parse("2018-10-29"));
transactionMock4.SetupGet(m => m.Merchant).Returns(context.Merchants.First(merchant => string.Equals(merchant.Name, "CIRCLE_K")));
_transactionFeeResults = new[]
{
"2018-09-02 CIRCLE_K $1.20",
"2018-09-04 TELIA $2.00",
"2018-10-22 CIRCLE_K $3.00",
"2018-10-29 CIRCLE_K $1.50"
};
return(new[]
{
transactionMock1.Object,
transactionMock2.Object,
transactionMock3.Object,
transactionMock4.Object
});;
}
public void IsConnectedTest()
{
var statusMock = new Moq.Mock<IDeviceManager>();
statusMock.SetupGet(s => s.IsDeviceConnected).Returns(false);
StatusViewModel target = new StatusViewModel(statusMock.Object);
Assert.AreEqual(Visibility.Hidden, target.ConnectionVisibility);
Assert.AreEqual(Visibility.Visible, target.ErrorVisibility);
}
public void BuildReturnsCallableDelegate()
{
var builder = new Builder();
var app = builder.Build();
var mockHttpContext = new Moq.Mock<HttpContextBase>();
var mockHttpResponse = new Moq.Mock<HttpResponseBase>();
mockHttpContext.SetupGet(x => x.Response).Returns(mockHttpResponse.Object);
mockHttpResponse.SetupProperty(x => x.StatusCode);
app.Invoke(mockHttpContext.Object);
mockHttpContext.Object.Response.StatusCode.ShouldBe(404);
}
public void ProductNameTest()
{
var statusMock = new Moq.Mock<IDeviceManager>();
statusMock.SetupGet(s => s.ProductName).Returns(TestValue);
StatusViewModel target = new StatusViewModel(statusMock.Object);
string actual = null;
target.PropertyChanged += delegate(object sender, PropertyChangedEventArgs e)
{
actual = e.PropertyName;
};
Assert.AreEqual(TestValue, target.ProductName);
target.ProductName = TestValue2;
Assert.AreEqual(TestValue2, target.ProductName);
Assert.AreEqual("ProductName", actual);
}
private static WebException CreateThrottledResponse(int throttledStatusCode, string retryAfter)
{
var mockWebResponse = new Moq.Mock<HttpWebResponse>();
var responseHeaders = new WebHeaderCollection();
responseHeaders.Add(HttpResponseHeader.RetryAfter, retryAfter);
mockWebResponse.SetupGet<HttpStatusCode>((webRes) => webRes.StatusCode).Returns((HttpStatusCode)throttledStatusCode);
mockWebResponse.SetupGet<WebHeaderCollection>((webRes) => webRes.Headers).Returns((WebHeaderCollection)responseHeaders);
return new WebException("Transmitter Error", null, WebExceptionStatus.UnknownError, mockWebResponse.Object);
}
private static WebException CreateException(int statusCode)
{
var mockWebResponse = new Moq.Mock<HttpWebResponse>();
mockWebResponse.SetupGet<HttpStatusCode>((webRes) => webRes.StatusCode).Returns((HttpStatusCode)statusCode);
return new WebException("Transmitter Error", null, WebExceptionStatus.UnknownError, mockWebResponse.Object);
}
public void VersionNumberTest()
{
var statusMock = new Moq.Mock<IDeviceManager>();
statusMock.SetupGet(s => s.VersionNumber).Returns(0);
StatusViewModel target = new StatusViewModel(statusMock.Object);
string actual = null;
target.PropertyChanged += delegate(object sender, PropertyChangedEventArgs e)
{
actual = e.PropertyName;
};
Assert.AreEqual(0, target.VersionNumber);
target.VersionNumber = 1;
Assert.AreEqual(1, target.VersionNumber);
Assert.AreEqual("VersionNumber", actual);
}
/* can't tell if this storeCollectionList ever existed [Test]
public void GetStoreBooks_ThereAre2_Returns2CollectionItems()
{
var b = CreateBloomServer();
var transaction = new PretendRequestInfo("http://localhost:8089/bloom/storeCollectionList");
b.MakeReply(transaction);
AssertThatXmlIn.String(transaction.ReplyContentsAsXml).HasSpecifiedNumberOfMatchesForXpath("//li//h2[text()='alpha']", 1);
AssertThatXmlIn.String(transaction.ReplyContentsAsXml).HasSpecifiedNumberOfMatchesForXpath("//li//h2[text()='beta']", 1);
AssertThatXmlIn.String(transaction.ReplyContentsAsXml).HasSpecifiedNumberOfMatchesForXpath("//li/ul", 2);
}
*/
private void AddBook(string id, string title)
{
var b = new Moq.Mock<Bloom.Book.BookInfo>();
b.SetupGet(x => x.Id).Returns(id);
b.SetupGet(x => x.QuickTitleUserDisplay).Returns(title);
b.SetupGet(x => x.FolderPath).Returns(Path.GetTempPath);//TODO. this works at the moment, cause we just need some folder which exists
_bookInfoList.Add(b.Object);
}
public void Setup()
{
var library = new Moq.Mock<CollectionSettings>();
library.SetupGet(x => x.IsSourceCollection).Returns(false);
library.SetupGet(x => x.Language2Iso639Code).Returns("en");
library.SetupGet(x => x.Language1Iso639Code).Returns("xyz");
library.SetupGet(x => x.XMatterPackName).Returns("Factory");
ErrorReport.IsOkToInteractWithUser = false;
_fileLocator = new FileLocator(new string[]
{
FileLocator.GetDirectoryDistributedWithApplication( "factoryCollections"),
FileLocator.GetDirectoryDistributedWithApplication( "factoryCollections", "Templates"),
FileLocator.GetDirectoryDistributedWithApplication( "factoryCollections", "Templates", "Basic Book"),
FileLocator.GetDirectoryDistributedWithApplication( "BloomBrowserUI"),
FileLocator.GetDirectoryDistributedWithApplication("BloomBrowserui/bookLayout"),
FileLocator.GetDirectoryDistributedWithApplication( "xMatter")
});
_starter = new BookStarter(_fileLocator, dir => new BookStorage(dir, _fileLocator, new BookRenamedEvent(), new CollectionSettings()), library.Object);
_shellCollectionFolder = new TemporaryFolder("BookStarterTests_ShellCollection");
_libraryFolder = new TemporaryFolder("BookStarterTests_LibraryCollection");
Browser.SetUpXulRunner();
}
