public void GetFolderContent_NonEmptyFolderGeneral(string vPath) { var currentFolder = SetupFoldersHierarchy(vPath); const int foldersCount = 2; const int filesCount = 3; currentFolder .CreateFolders(foldersCount) .CreateFiles(filesCount); Assert.NotNull(controller); var actionResult = controller.GetFolderContent(vPath); Assert.That(actionResult, Is.AssignableFrom <ObjectResult>()); var result = (ObjectResult)actionResult; Assert.NotNull(result?.Value); Assert.That(result.Value, Is.AssignableFrom <List <FileSystemInfoDto> >()); var list = (List <FileSystemInfoDto>)result.Value; // Check total objects Assert.That(list.Count, Is.EqualTo(foldersCount + filesCount)); Assert.That(list.FindAll(item => !item.IsFile).Count, Is.EqualTo(foldersCount)); Assert.That(list.FindAll(item => item.IsFile).Count, Is.EqualTo(filesCount)); var folders = list.GetRange(0, foldersCount); var files = list.GetRange(foldersCount, filesCount); // Check that folders goes before files Assert.That(folders.Any((item) => item.IsFile), Is.False); Assert.That(files.Any((item) => !item.IsFile), Is.False); // Objects are sorted asc by name Assert.That(files[0], Is.LessThan(files[filesCount - 1])); }
/// <summary> /// A subtest for testing ExecuteAsync when an exception is thrown while sending the request. This is tested /// with and without back-off. If back-off handler is attached to the service's message handler, there should /// be 3 tries (the default value of <seealso cref="ConfigurableMessageHandler.NumTries"/>) before the /// operation fails. /// </summary> /// <param name="backOff">Indicates if back-off handler is attached to the service.</param> private void SubtestExecuteAsync_ThrowException(bool backOff) { var handler = new MockMessageHandler(true); var initializer = new BaseClientService.Initializer() { HttpClientFactory = new MockHttpClientFactory(handler) }; // Configure the back-off behavior by the input. initializer.DefaultExponentialBackOffPolicy = backOff ? ExponentialBackOffPolicy.Exception : ExponentialBackOffPolicy.None; using (var service = new MockClientService(initializer)) { var request = new TestClientServiceRequest(service, "GET", null); var task = request.ExecuteAsync(); try { var result = task.Result; Assert.Fail("Exception should be thrown"); } catch (AggregateException ex) { Assert.That(ex.InnerException, Is.AssignableFrom(typeof(InvalidOperationMockException))); } int calls = backOff ? service.HttpClient.MessageHandler.NumTries : 1; Assert.That(handler.Calls, Is.EqualTo(calls)); } }
public void CreateFile_WhichDoesNotEXists(string vPath) { Assert.NotNull(controller); var currentFolder = SetupFoldersHierarchy(vPath); var newFilename = "newFile.txt"; // File does not exists Assert.False(currentFolder.FileExists(newFilename)); var actionResult = controller.Createfile(vPath, newFilename); Assert.That(actionResult, Is.AssignableFrom <CreatedAtRouteResult>()); var result = (CreatedAtRouteResult)actionResult; // File was created Assert.That(currentFolder.FileExists(newFilename)); // route param is set correctly var expectedRouteParam = string.Format("{0}/{1}", vPath, newFilename); Assert.That(result.RouteValues["targetPath"], Is.EqualTo(expectedRouteParam)); // correct entry returned Assert.That(result.Value, Is.AssignableFrom <FileSystemInfoDto>()); var dto = (FileSystemInfoDto)result.Value; Assert.That(dto.Name, Is.EqualTo(newFilename)); Assert.That(dto.Path, Is.EqualTo(expectedRouteParam)); Assert.That(dto.IsFile); }
public void CreateFile_WichExistsDontOverrideContent(string vPath) { Assert.NotNull(controller); var currentFolder = SetupFoldersHierarchy(vPath); var newFilename = "newFile22.txt"; const string expectedContent = "some initial content"; currentFolder.CreateFileWithContent(newFilename, expectedContent); Assert.That(currentFolder.FileExists(newFilename)); var actionResult = controller.Createfile(vPath, newFilename); Assert.That(actionResult, Is.AssignableFrom <CreatedAtRouteResult>()); var result = (CreatedAtRouteResult)actionResult; //Assert that file was not ovewritten Assert.That(currentFolder.FileExists(newFilename)); var newContent = currentFolder.ReadFile(newFilename); Assert.That(newContent, Is.EqualTo(expectedContent)); // correct entry returned Assert.That(result.Value, Is.AssignableFrom <FileSystemInfoDto>()); var dto = (FileSystemInfoDto)result.Value; Assert.That(dto.Name, Is.EqualTo(newFilename)); Assert.That(dto.Path, Is.EqualTo(string.Format("{0}/{1}", vPath, newFilename))); Assert.That(dto.IsFile); }
public void CreateFolder_ShouldReturnOkForExistingFolder(string vPath) { Assert.NotNull(controller); var currentFolder = SetupFoldersHierarchy(vPath); var newFolderName = "folderNew"; currentFolder.CreateFolder(newFolderName); Assert.That(currentFolder.FolderExists(newFolderName)); var actionResult = controller.CreateFolder(vPath, newFolderName); Assert.That(actionResult, Is.AssignableFrom <CreatedAtRouteResult>()); var result = (CreatedAtRouteResult)actionResult; // route param is set correctly var expectedRouteParam = string.Format("{0}/{1}", vPath, newFolderName); Assert.That(result.RouteValues["targetPath"], Is.EqualTo(expectedRouteParam)); // correct entry returned Assert.That(result.Value, Is.AssignableFrom <FileSystemInfoDto>()); var dto = (FileSystemInfoDto)result.Value; Assert.That(dto.Name, Is.EqualTo(newFolderName)); Assert.That(dto.Path, Is.EqualTo(expectedRouteParam)); Assert.That(dto.IsFile, Is.False); }
public void CreateFolder_FolderDoesNotExists(string vPath) { Assert.NotNull(controller); var currentFolder = SetupFoldersHierarchy(vPath); var newFolderName = "folderNew"; var actionResult = controller.CreateFolder(vPath, newFolderName); Assert.That(actionResult, Is.AssignableFrom <CreatedAtRouteResult>(), "actionResult is not ssignable from <CreatedAtRouteResult>"); var result = (CreatedAtRouteResult)actionResult; // folder has been created Assert.That(currentFolder.FolderExists(newFolderName), "New Folder does not exists"); // route param is set correctly var expectedRouteParam = string.Format("{0}/{1}", vPath, newFolderName); Assert.That(result.RouteValues["targetPath"], Is.EqualTo(expectedRouteParam), "Route path is incorrect"); // correct entry returned Assert.That(result.Value, Is.AssignableFrom <FileSystemInfoDto>(), "value returned is not assignable from <FileSystemInfoDto>"); var dto = (FileSystemInfoDto)result.Value; Assert.That(dto.Name, Is.EqualTo(newFolderName), "dto.Name is not setup corretcly"); Assert.That(dto.Path, Is.EqualTo(expectedRouteParam), "dto.Path is not setup correctly"); Assert.That(dto.IsFile, Is.False, "dto.IsFile should be false"); }
public void GetFolderContent_CorrectEntryValuesReturned(string vPath) { var currentFolder = SetupFoldersHierarchy(vPath); const string foldername = "Myfolder"; const string fileName = "myFile.txt"; currentFolder.CreateFolder(foldername); currentFolder.CreateFile(fileName); Assert.NotNull(controller); var actionResult = controller.GetFolderContent(vPath); Assert.That(actionResult, Is.AssignableFrom <ObjectResult>()); var result = (ObjectResult)actionResult; Assert.NotNull(result?.Value); Assert.That(result.Value, Is.AssignableFrom <List <FileSystemInfoDto> >()); var list = (List <FileSystemInfoDto>)result.Value; Assert.That(list.Count, Is.EqualTo(2)); //Check folder, it should be first var folderDto = list[0]; Assert.That(folderDto.IsFile, Is.False); Assert.That(folderDto.Name, Is.EqualTo(foldername)); Assert.That(folderDto.Path, Is.EqualTo(string.Format("{0}/{1}", vPath, foldername))); //Check file, it should be second var fileDto = list[1]; Assert.That(fileDto.IsFile); Assert.That(fileDto.Name, Is.EqualTo(fileName)); Assert.That(fileDto.Path, Is.EqualTo(string.Format("{0}/{1}", vPath, fileName))); }
public void ShouldReturnTheController() { IController controller = _factory.CreateController(_context, "UnitySimple"); //typeof(SimpleController)); Assert.That(controller, Is.Not.Null); Assert.That(controller, Is.AssignableFrom(typeof(UnitySimpleController))); }
/// <summary> /// A subtest for testing async execute when an exception is thrown during sending the request, with or without /// back-off handler. If back-off handler is attached to the service's message handler, there are going to be /// several retries (up to 2 minutes). /// </summary> /// <param name="backOff">Indicates if back-off handler is attached to the service.</param> private void SubtestExecuteAsync_ThrowException(bool backOff) { var handler = new MockMessageHandler(true); var initializer = new BaseClientService.Initializer() { HttpClientFactory = new MockHttpClientFactory(handler) }; // by default back-off is used, so disable it in case backOff is false if (!backOff) { initializer.DefaultExponentialBackOffPolicy = BaseClientService.ExponentialBackOffPolicy.None; } using (var service = new MockClientService(initializer)) { var request = new TestClientServiceRequest(service, "GET", null); var task = request.ExecuteAsync(); try { var result = task.Result; Assert.Fail("Exception should be thrown"); } catch (AggregateException ex) { Assert.That(ex.InnerException, Is.AssignableFrom(typeof(InvalidOperationMockException))); } // if back-off is enabled, we use 2 minutes maximum wait time for a request, so we should make lg(120) // + 1 calls int calls = backOff ? (int)Math.Ceiling(Math.Log(120, 2) + 1) : 1; Assert.That(handler.Calls, Is.EqualTo(calls)); } }
public void ShouldReturnTheSimpleDependencyAndCastToAnInterface() { var depedency = _dependencyResolver.GetImplementationOf <IDependency>(typeof(SimpleDependency)); Assert.That(depedency, Is.Not.Null); Assert.That(depedency, Is.AssignableFrom(typeof(SimpleDependency))); }
public void Test10() { using (var session = Domain.OpenSession()) using (var tx = session.OpenTransaction()) { var exception = Assert.Throws<QueryTranslationException>( () => session.Query.All<AClassTable>().OfType<IB1>() .OfType<BaseEntity>().Run()); Assert.That(exception.InnerException, Is.AssignableFrom(typeof(NotSupportedException))); } using (var session = Domain.OpenSession()) using (var tx = session.OpenTransaction()) { var exception = Assert.Throws<QueryTranslationException>( () => session.Query.All<AConcreteTable>().OfType<IB1>() .OfType<BaseEntity>().Run()); Assert.That(exception.InnerException, Is.AssignableFrom(typeof(NotSupportedException))); } using (var session = Domain.OpenSession()) using (var tx = session.OpenTransaction()) { var exception = Assert.Throws<QueryTranslationException>( () => session.Query.All<ASingleTable>().OfType<IB1>() .OfType<BaseEntity>().Run()); Assert.That(exception.InnerException, Is.AssignableFrom(typeof(NotSupportedException))); } }
public void Language_DoesProduceCorrectTokens() { string test = null; Grammar.Token[] testit() => new Grammar.Lexer(new StringReader(test)).ToArray(); test = "using namespace @namespace;"; var expected = new[] { Using, Namespace, Identifier, Semicolon, Eof }; var result = testit(); var resultTerminals = result.Select(r => r.Terminal).ToArray(); Assert.That(resultTerminals, Is.EquivalentTo(expected)); Assert.That(result[2], Is.AssignableFrom <IdentifierToken>()); Assert.That((result[2] as IdentifierToken).Name, Is.EqualTo("namespace")); Assert.That(result[2].Lexeme, Is.EqualTo("@namespace")); Assert.That(result.AsLexemes(), Is.EquivalentTo(new[] { "using", "namespace", "@namespace", ";", null })); test = "34.3f"; result = testit(); Assert.That(result[0], Is.TypeOf <NumberToken>()); var number = result[0] as NumberToken; Assert.That(number.GetFloatValue(), Is.EqualTo(34.3f)); Assert.That(number.IsTypeSpecified, Is.True); Assert.That(number.TypeSuffix, Is.EqualTo('f')); }
public async Task DetailsTestAsync() { DepartmentsController controller = new DepartmentsController(_context); var actResult = await controller.Details(null); Assert.IsTrue(typeof(NotFoundResult).IsInstanceOfType(actResult)); Assert.That(actResult, Is.AssignableFrom <NotFoundResult>()); actResult = await controller.Details(2687658); Assert.IsTrue(typeof(NotFoundResult).IsInstanceOfType(actResult)); Assert.That(actResult, Is.AssignableFrom <NotFoundResult>()); actResult = await controller.Details(2); Assert.IsTrue(typeof(ViewResult).IsInstanceOfType(actResult)); Assert.That(actResult, Is.AssignableFrom <ViewResult>()); ViewResult viewResult = actResult as ViewResult; Department department = (Department)viewResult.Model; decimal budget = department.Budget; Assert.That(budget, Is.Not.Null); }
public void Return_statement(string text) { var parser = new Parser(new Lexer(text)); var program = parser.ParseProgram(); Assert.That(program.Statements[0], Is.AssignableFrom <ReturnStatement>()); }
public void CorrectSingleProjectBoostTestDiscovererDispatchingExternalDll() { BoostTestAdapterSettings settings = CreateAdapterSettings(); settings.ExternalTestRunner = CreateExternalRunnerSettings(BoostTestDiscoverer.DllExtension); // source that supports --list-content parameter var source = "ListContentSupport" + BoostTestDiscoverer.ExeExtension; var discoverer = this.DiscovererFactory.GetDiscoverer(source, settings); Assert.That(discoverer, Is.Not.Null); Assert.That(discoverer, Is.AssignableFrom(typeof(ListContentDiscoverer))); // source that NOT supports --list-content parameter source = "ParseSources" + BoostTestDiscoverer.ExeExtension; discoverer = this.DiscovererFactory.GetDiscoverer(source, settings); Assert.That(discoverer, Is.Not.Null); Assert.That(discoverer, Is.AssignableFrom(typeof(SourceCodeDiscoverer))); // source dll project source = "DllProject" + BoostTestDiscoverer.DllExtension; discoverer = this.DiscovererFactory.GetDiscoverer(source, settings); Assert.That(discoverer, Is.Not.Null); Assert.That(discoverer, Is.AssignableFrom(typeof(ExternalDiscoverer))); }
public void ShouldReturnTheSimpleDependency() { IDependency depedency = _dependencyResolver.GetImplementationOf <SimpleDependency>(); Assert.That(depedency, Is.Not.Null); Assert.That(depedency, Is.AssignableFrom(typeof(SimpleDependency))); }
public void TestConstruction() { var obj = new ClassWithLists(); var container = new NodeContainer(); var model = container.GetOrCreateNode(obj); Assert.That(model["IntList"].Retrieve(), Is.SameAs(obj.IntList)); Assert.That(model["IntList"].IsReference, Is.False); Assert.That(model["ClassList"].Retrieve(), Is.SameAs(obj.ClassList)); //Assert.That(model["ClassList"].Reference, Is.AssignableFrom(typeof(ReferenceEnumerable))); Assert.That(model["SimpleStructList"].Retrieve(), Is.SameAs(obj.SimpleStructList)); //Assert.That(model["SimpleStructList"].Reference, Is.AssignableFrom(typeof(ReferenceEnumerable))); Assert.That(model["NestedStructList"].Retrieve(), Is.SameAs(obj.NestedStructList)); //Assert.That(model["NestedStructList"].Reference, Is.AssignableFrom(typeof(ReferenceEnumerable))); Assert.That(model["ListOfSimpleStructLists"].Retrieve(), Is.SameAs(obj.ListOfSimpleStructLists)); //Assert.That(model["ListOfSimpleStructLists"].Reference, Is.AssignableFrom(typeof(ReferenceEnumerable))); foreach (var reference in model["ListOfSimpleStructLists"].Target.ItemReferences) { Assert.That(reference, Is.AssignableFrom(typeof(ObjectReference))); } Assert.That(model["ListOfNestedStructLists"].Retrieve(), Is.SameAs(obj.ListOfNestedStructLists)); //Assert.That(model["ListOfNestedStructLists"].Reference, Is.AssignableFrom(typeof(ReferenceEnumerable))); foreach (var reference in model["ListOfNestedStructLists"].Target.ItemReferences) { Assert.That(reference, Is.AssignableFrom(typeof(ObjectReference))); } Assert.That(container.GetNode(obj.ClassList[0]), !Is.Null); }
public void Handler_Can_Be_Resolved_When_Not_Registered_With_Assembly_Filtering() { //ARRANGE object action; object boolean; object logger = new Mock <IGWLogger <BaseMessageHandler <TestMessage> > >().Object; _mockDependenyResolver.Setup(x => x.TryResolve(typeof(Action), out action)) .Returns(true); _mockDependenyResolver.Setup(x => x.TryResolve(typeof(IGWLogger <BaseMessageHandler <TestMessage> >), out logger)) .Returns(true); _mockDependenyResolver.Setup(x => x.TryResolve(typeof(bool), out boolean)) .Returns(true); _mockHandlerResolverSettings.Setup(x => x.LimitAssembliesTo) .Returns(new List <Assembly> { GetType().Assembly }); _mockHandlerResolverSettings.Setup(x => x.HasCustomAssemblyList).Returns(true); var handlerResolver = new HandlerResolver(_mockDependenyResolver.Object, _mockHandlerResolverSettings.Object); //ACT var handler = handlerResolver.ResolveAllHandlersFor(typeof(TestMessage)); //ASSERT Assert.That(handler.Single(), Is.AssignableFrom(typeof(TestMessageHandler))); }
public void TestPersistCustomFields() { string fieldsetName = "Foo_+ Bar"; string fieldName = "Baz"; string fieldValue = "noop"; var dumbValues = new Dictionary <string, string>(); dumbValues.Add(fieldName, fieldValue); view.CustomFields[fieldsetName] = dumbValues; view.Update(); View fromId = View.FromId(view.id); Expect(fromId.CustomFields, Is.Not.Null, "should have custom fields defined"); Expect(fromId.CustomFields, Is.AssignableFrom(typeof(Dictionary <string, object>))); Expect(fromId.CustomFields[fieldsetName], Is.Not.Null); Expect(fromId.CustomFields[fieldsetName], Is.AssignableFrom(typeof(Dictionary <string, object>))); Expect(fromId.MetadataFieldset(fieldsetName), Is.Not.Null, "should have a metadata fieldset"); Expect((string)fromId.MetadataFieldset(fieldsetName)[fieldName], Is.EqualTo(fieldValue), "value should be what we set it to"); }
public void SetUp() { parseTree = "<assignablefrom System.String>"; staticSyntax = Is.AssignableFrom(typeof(string)); inheritedSyntax = Helper().AssignableFrom(typeof(string)); builderSyntax = Builder().AssignableFrom(typeof(string)); }
public void Should_BeImpossibleTo_FindHiddenElements_WithWrongArguments(ElementsCount count, ElementState state) { const string name = "custom name"; Assert.Throws(Is.AssignableFrom(typeof(TimeoutException)).And.Message.Contains(name), () => FindElements <Label>(HiddenElementsLoc, name, expectedCount: count, state: state), $"Tried to find elements with expected count '{count}' and state '{state}'"); }
public void GetServiceFromContainer() { var service = ServiceContainer.GetService(typeof(ITestInterface)); Assert.That(service, Is.Not.Null); Assert.That(service, Is.AssignableFrom(typeof(MyTestImplementation))); Assert.That(service, Is.AssignableTo(typeof(ITestInterface))); }
public void Test_GetNetworkLink() { var result = testCandidate.GetNetworkLink(Guid.NewGuid()); Assert.IsNotNull(result); Assert.AreEqual(result.LinkGeometry, lineGeometry); Assert.That(result.Id, Is.AssignableFrom(typeof(Guid))); }
public void GetImageSourceForFileSystemEntryShouldReturnOverlayedIconWhenIsExcludedAndIsValid() { ImageSource result = iconProvider.GetImageSourceForFileSystemEntry(testFileName, true, true); Assert.That(result, Is.Not.Null); Assert.That(result, Is.AssignableFrom <DrawingImage>()); Assert.That(result.Width, Is.GreaterThan(0)); }
public void IsAssignableFrom() { int[] array10 = new int[10]; Assert.IsAssignableFrom(typeof(int[]), array10); Assert.That(array10, Is.AssignableFrom(typeof(int[]))); Assert.IsAssignableFrom <int[]>(array10); }
public void Let_expression_parses_as_let_expression(string text) { var parser = new Parser(new Lexer(text)); var program = parser.ParseProgram(); Assert.That(program.Statements[0], Is.AssignableFrom <LetStatement>()); AssertNoErrors(parser); }
public void Test_GetNearestSegment() { var result = testCandidate.GetNearestSegment(dbGeometry); Assert.IsNotNull(result); Assert.AreEqual(result.First().Item1.LinkGeometry, lineGeometry); Assert.That(result.First().Item1.Id, Is.AssignableFrom(typeof(Guid))); }
public void AssignableFromTypeTests() { Assert.IsAssignableFrom(typeof(string), "Hello"); Assert.IsNotAssignableFrom(typeof(string), 5); Assert.That("Hello", Is.AssignableFrom(typeof(string))); Assert.That(5, Is.Not.AssignableFrom(typeof(string))); }
public void CreateFromMemoryUseMemoryStream() { var dataStream = DataStreamFactory.FromMemory(); Assert.That(dataStream.BaseStream, Is.AssignableFrom <RecyclableMemoryStream>()); dataStream.Dispose(); }
public void AssignableFromTypeTests() { // Classic syntax Assert.IsAssignableFrom(typeof(string), "Hello"); Assert.IsNotAssignableFrom(typeof(string), 5); // Constraint Syntax Assert.That("Hello", Is.AssignableFrom(typeof(string))); Assert.That(5, Is.Not.AssignableFrom(typeof(string))); }