public void FuncOfTaskOfStringThrowsDifferentExceptionScenarioShouldFail_ExceptionTypePassedIn() { var action = new Func<Task<string>>(() => { throw new RankException(); }); Verify.ShouldFail(() => action.ShouldThrow("Some additional context", typeof(InvalidOperationException)), errorWithSource: @"Task `action` should throw System.InvalidOperationException but threw System.RankException Additional Info: Some additional context", errorWithoutSource: @"Task should throw System.InvalidOperationException but threw System.RankException Additional Info: Some additional context"); }
public void Handle_Throws() { var bus = new Mock<IBusForHandler>(); bus.Setup(x => x.Headers(It.IsAny<object>())).Returns(new Dictionary<string, string> { {HeaderKeys.MessageId, Guid.NewGuid().ToString()} }); var action = new Func<Task>(async () => await this.testee.Handle(new object(), bus.Object)); action.ShouldThrow<InvalidOperationException>(); }
public void DelegateShouldDropSynchronisationContext() { // The await keyword will automatically capture synchronisation context // Because shouldly uses .Wait() we cannot let continuations run on the sync context without a deadlock var synchronizationContext = new SynchronizationContext(); SynchronizationContext.SetSynchronizationContext(synchronizationContext); SynchronizationContext.Current.ShouldNotBe(null); var task = new Func<Task>(() => { SynchronizationContext.Current.ShouldBe(null); throw new InvalidOperationException(); }); task.ShouldThrow<InvalidOperationException>(); }
public void AndSelectorThrowsInfrastructureException_ThenLetsExceptionBubble() { var request = new CreateApprenticeshipRequest { WageType = WageType.CustomWageFixed, FixedWage = _fixture.Create <decimal>(), WageUnit = _fixture.CreateAnyWageUnitOtherThanNotApplicable(), ExpectedStartDate = _fixture.CreateFutureDateTime(), HoursPerWeek = _fixture.Create <double>() }; var context = GetValidationContextForProperty(request, req => req.FixedWage); _mockSelector .Setup(selector => selector.GetApprenticeMinimumWageRate(It.IsAny <DateTime>())) .Throws <InfrastructureException>(); var action = new Func <Task <ValidationResult> >(() => _validator.ValidateAsync(context)); action.ShouldThrow <InfrastructureException>(); }
public void LoadScriptFromFile_PersistenceServiceThrows_ThrowsIOException() { // Arrange var testInputPath = "C:\\TestPath.filter"; var mockPersistenceService = new Mock <IItemFilterPersistenceService>(); mockPersistenceService.Setup(p => p.LoadItemFilterScriptAsync(testInputPath)).Throws <IOException>(); var mockItemFilterScriptViewModelFactory = new Mock <IItemFilterScriptViewModelFactory>(); var repository = CreateItemFilterScriptRepository(itemFilterPersistenceService: mockPersistenceService.Object, itemFilterScriptViewModelFactory: mockItemFilterScriptViewModelFactory.Object); // Act Func <Task <IItemFilterScriptViewModel> > result = async() => await repository.LoadScriptFromFileAsync(testInputPath); // Assert result.ShouldThrow <IOException>(); }
public void SaveEvents_fails_if_versions_not_sequential() { var events = new DomainEvent[] { new FakeUserCreated { Version = 0 }, new FakeUsernameChanged { Version = 1 }, new FakeUsernameChanged { Version = 3 } }; Func <Task> action = () => sut.SaveEvents <FakeUser>(events); action.ShouldThrow <ArgumentException>() .Where(x => x.ParamName == "events"); }
#pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously public async void GetResponseStringAsync_Should_Throw_Exception_When_Stream_Cannot_Seek() #pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously { _testProcessor.Valid = false; var mockStream = Mock.Create <Stream>(); mockStream.Setup(_ => _.CanSeek) .Returns(false); _mockResponse.Setup(_ => _.Body) .Returns(mockStream.Object); Func <Task> throwAction = async() => await _testProcessor.GetResponseStringAsync(_mockResponse.Object); throwAction.ShouldThrow <Exception>() .And .Message .Should() .Be("The body does not support seek. Ensure that the RewindResponseMiddleware is registered earlier in the pipeline"); }
public void WhenGoogleResponseCannotBeSerialized_ThrowsSecurityException() { var requestBuilder = A.Fake <IHttpRequestMessageBuilder>(); A.CallTo(() => _webRequestSender.NewRequest(A <HttpMethod> ._, A <Uri> ._)).Returns(requestBuilder); var httpRequestMessage = new HttpRequestMessage(); A.CallTo(() => requestBuilder.Build()).Returns(httpRequestMessage); var googleUserJson = "{I am the user}"; var httpResponseMessage = new HttpResponseMessage { Content = new StringContent(googleUserJson) }; A.CallTo(() => _webRequestSender.SendRequestAsync(httpRequestMessage)).Returns(httpResponseMessage); A.CallTo(() => _jsonSerializer.Deserialize <GoogleUserDataRecord>(googleUserJson)).Throws(new JsonSerializationException()); Func <Task> act = () => _sut.ActivateGooglePlusUser(_accessToken); act.ShouldThrow <SecurityException>(); }
public void EmitsADeserializationErrorIfTheJsonSerializerThrowsAnException() { const string rawResponse = "It lives"; serializer.Deserialize <string>(Arg.Any <string>()).Returns(_ => throw new Exception()); apiClient.Send(Arg.Any <Request>()).Returns(x => new Response(rawResponse, true, "text/plain", OK)); var credentials = Credentials.WithPassword("*****@*****.**".ToEmail(), "theirobotmoviesucked123"); var endpoint = Endpoint.Get(ApiUrls.ForEnvironment(ApiEnvironment.Staging), ""); var testApi = new TestApi(endpoint, apiClient, serializer, credentials); var observable = testApi.TestCreateObservable <string>(endpoint, Enumerable.Empty <HttpHeader>(), ""); Func <Task> theObservableReturnedWhenTheApiFails = async() => await observable; theObservableReturnedWhenTheApiFails .ShouldThrow <DeserializationException <string> >() .Which.Json.Should().Be(rawResponse); }
public void Throws_Exception_When_User_Does_Not_Exist() { var userDto = _fixture.Build <UserDto>() .With(x => x.Email, "*****@*****.**") .Create(); _userRepo.Exists(Arg.Any <string>()).Returns(false); Func <Task> act = async() => await _underTest.ValidateEntityAsync(userDto); var fluentAssertionException = act.ShouldThrow <FoodsValidationException>(); var foodsException = fluentAssertionException.Subject; foodsException.Should().NotBeNull(); foodsException.Count().Should().Be(1); var foodsErrors = foodsException.First().Errors; foodsErrors.Count.Should().Be(1); foodsErrors.First().ErrorMessage.Should().Be("The user does not exist."); }
public void Given_InvalidHttpStatusCode_GetInsightsResourceAsync_ShouldThrow_Exception(string appInsightsName, string resourceGroup, HttpStatusCode statusCode) { this._appInsights.SetupGet(p => p.Name).Returns(appInsightsName); this._appInsights.SetupGet(p => p.ResourceGroup).Returns(resourceGroup); this._settings.SetupGet(p => p.ApplicationInsight).Returns(this._appInsights.Object); var resourceResult = new ResourceGetResult() { StatusCode = statusCode }; this._resourceOperations.Setup(p => p.GetAsync(It.IsAny <string>(), It.IsAny <ResourceIdentity>(), It.IsAny <CancellationToken>())).ReturnsAsync(resourceResult); this._resourceClient.SetupGet(p => p.Resources).Returns(this._resourceOperations.Object); Func <Task> func = async() => { var result = await this._service.GetInsightsResourceAsync(this._resourceClient.Object).ConfigureAwait(false); }; func.ShouldThrow <HttpResponseException>().And.Response.StatusCode.Should().Be(statusCode); }
public void given_fails_to_commit_SaveProcessManagerAndPublishCommands_does_not_publish_commands() { // Arrange var fixture = new Fixture(); ICommandPublisher publisher = Mock.Of <ICommandPublisher>(); FooProcessManager processManager = fixture.Create <FooProcessManager>(); processManager.SetValidationError("invalid process manager state"); var sut = new SqlProcessManagerDataContext <FooProcessManager>( new FooProcessManagerDbContext(), new JsonMessageSerializer(), publisher); // Act Func <Task> action = () => sut.SaveProcessManagerAndPublishCommands(processManager); // Assert action.ShouldThrow <DbEntityValidationException>(); Mock.Get(publisher).Verify(x => x.FlushCommands(processManager.Id, CancellationToken.None), Times.Never()); }
public void WhenMessageSentWithBodyWhichCannotBeDeserialized_MessageIsDeadlettered() { var stream = new MemoryStream(); var writer = new StreamWriter(stream); writer.Write("{ ; }"); writer.Flush(); stream.Position = 0; var tm = new DeadLetterTransportMessage { MessageType = typeof(Message).AssemblyQualifiedName }; tm.SetBody(stream); Func <Task> action = () => this.receiver.HandOver(tm); action.ShouldThrow <SerializationException>(); tm.DeadLetterHeaders.Should().NotBeEmpty(); }
public void ThrowsExceptionOnLoading_WhenSettingALastActiveStateThatIsNotASubState() { this.testee.DefineHierarchyOn(StateMachine.States.B) .WithHistoryType(HistoryType.Deep) .WithInitialSubState(StateMachine.States.B1) .WithSubState(StateMachine.States.B2); var loader = A.Fake <IAsyncStateMachineLoader <StateMachine.States> >(); A.CallTo(() => loader.LoadHistoryStates()) .Returns(new Dictionary <StateMachine.States, StateMachine.States> { { StateMachine.States.B, StateMachine.States.A } }); Func <Task> action = async() => await this.testee.Load(loader); action.ShouldThrow <InvalidOperationException>() .WithMessage(Machine.ExceptionMessages.CannotSetALastActiveStateThatIsNotASubState); }
public void ThrowExceptionGivenInvalidBufferFileSizeLimitBytes(long?bufferFileSizeLimitBytes) { // Arrange Func <TimeRolledDurableHttpSink> got = () => new TimeRolledDurableHttpSink( requestUri: "https://www.mylogs.com", bufferBaseFileName: "SomeBuffer", bufferRollingInterval: BufferRollingInterval.Day, bufferFileSizeLimitBytes: bufferFileSizeLimitBytes, bufferFileShared: false, retainedBufferFileCountLimit: 31, batchPostingLimit: 1000, batchSizeLimitBytes: ByteSize.MB, period: TimeSpan.FromSeconds(2), textFormatter: new NormalTextFormatter(), batchFormatter: new ArrayBatchFormatter(), httpClient: new HttpClientMock()); // Act & Assert got.ShouldThrow <ArgumentOutOfRangeException>(); }
public void WhenMessageReachesMaximumNumberOfDelayedRetries_MessageIsDeadlettered() { var stream = new MemoryStream(); var writer = new StreamWriter(stream); writer.Write("{ Bar: 1 }"); writer.Flush(); stream.Position = 0; actualDelayedRetryCount = MaxDelayedRetryCount; var tm = new TestTransportMessage(typeof(Message).AssemblyQualifiedName); tm.SetBody(stream); Func <Task> action = () => this.receiver.HandOver(tm); action.ShouldThrow <InvalidOperationException>(); tm.DeadLetterHeaders.Should().NotBeEmpty(); tm.DelayedDeliveryCount.Should().Be(MaxDelayedRetryCount); }
public void Should_ThrowException_When_PasswordIsNullOrEmpty() { var userRepositoryMock = new Mock <IUserRepository>(); userRepositoryMock.Setup(u => u.RegisterAsync(It.IsAny <User>(), It.IsAny <string>())).ThrowsAsync(new ArgumentException("password is empty.")); var roleLookupMock = new Mock <IRoleLookup>(); var mapperMock = new Mock <IMapper>(); mapperMock.Setup(m => m.Map <RegisterUserCommand, User>(It.IsAny <RegisterUserCommand>())).Returns((User)null); var target = new RegisterUserCommandHandler(userRepositoryMock.Object, roleLookupMock.Object, mapperMock.Object); var command = new RegisterUserCommand(); Func <Task> func = async() => await target.HandleAsync(command); func.ShouldThrow <Exception>(); }
public async Task TestPostSendToSevisAsync_UserDoesNotHaveProvidedSevisCredentials() { var model = new SendToSevisBindingModel { ParticipantIds = new List <int> { 1 }, SevisOrgId = "org", SevisUsername = "******" }; var projectId = 10; var user = new User(100); userProvider.Setup(x => x.HasSevisUserAccountAsync(It.IsAny <IWebApiUser>(), It.IsAny <string>(), It.IsAny <string>())).ReturnsAsync(false); participantPersonSevisService.Setup(x => x.SendToSevisAsync(It.IsAny <ParticipantsToBeSentToSevis>())).ReturnsAsync(new int[] { }); Func <Task> f = () => controller.PostSendToSevisAsync(1, projectId, model); f.ShouldThrow <HttpResponseException>().And.Response.StatusCode.Should().Be(HttpStatusCode.Forbidden); }
public async Task DoubleStart() { var session = new RSession(0, () => { }); Func <Task> start = () => session.StartHostAsync(new RHostStartupInfo { Name = _testMethod.Name, RBasePath = RUtilities.FindExistingRBasePath() }, null, 50000); Func <Task> f = () => ParallelTools.InvokeAsync(4, i => start()); f.ShouldThrow <InvalidOperationException>(); await session.HostStarted; session.IsHostRunning.Should().BeTrue(); await session.StopHostAsync(); session.IsHostRunning.Should().BeFalse(); }
public void NotificationService_MarkNotificationAsRead_NotificationNotAssignedToCurrentUser_ShouldThrowUnauthorizedException() { // Arrange const string userId = "TestUser"; const int notificationId = 1; var notification = new Models.Entities.Notification { Id = notificationId, AssignedToUserId = "OtherUser", IsRead = false }; _mockNotificationRepository.Setup(_ => _.GetAsync(It.IsAny <int>())).ReturnsAsync(notification); // Act Func <Task> throwAction = async() => await _notificationService.MarkNotificationAsRead(userId, notificationId); // Assert throwAction.ShouldThrow <UnauthorizedException>(); }
public void ExecuteStep_should_bubble_up_exceptions_in_middleware() { // Arrange var middleware1 = BuildStepMiddleware(1); var middleware2 = BuildStepMiddleware(2); var middleware3 = BuildStepMiddleware(3); Middleware.AddRange(new[] { middleware1, middleware2, middleware3 }); A .CallTo(HandleMethodFor(middleware2)) .Throws(new ApplicationException("Failed")); // Act Func <Task <ExecutionResult> > action = async() => await Runner.ExecuteStep(Context, Body); // Assert action .ShouldThrow <ApplicationException>() .WithMessage("Failed"); }
public void WHEN_RequiredParams_Is_Null_SHOULD_Throw_Argument_Null_Exception(string scope, string baseUrl) { //Arrange var service = _container.CreateInstance <StoreLocatorViewService>(); //Act Func <Task> asyncFunction = async() => { await service.GetStoreLocatorViewModelAsync(new GetStoreLocatorViewModelParam { Scope = scope, BaseUrl = baseUrl, CultureInfo = CultureInfo.CreateSpecificCulture("en-CA") }); }; //Assert asyncFunction.ShouldThrow <ArgumentNullException>(); }
public async Task ReceiveMessageAsync_should_throw_MongoConnectionClosedException_when_connection_has_failed() { using (var stream = Substitute.For <Stream>()) { _streamFactory.CreateStreamAsync(null, CancellationToken.None) .ReturnsForAnyArgs(Task.FromResult <Stream>(stream)); var readTcs = new TaskCompletionSource <int>(); stream.ReadAsync(null, 0, 0, CancellationToken.None) .ReturnsForAnyArgs(readTcs.Task); var writeTcs = new TaskCompletionSource <int>(); stream.WriteAsync(null, 0, 0, CancellationToken.None) .ReturnsForAnyArgs(writeTcs.Task); await _subject.OpenAsync(CancellationToken.None); _capturedEvents.Clear(); var encoderSelector = new ReplyMessageEncoderSelector <BsonDocument>(BsonDocumentSerializer.Instance); var task1 = _subject.ReceiveMessageAsync(1, encoderSelector, _messageEncoderSettings, CancellationToken.None); readTcs.SetException(new SocketException()); Func <Task> act1 = () => task1; act1.ShouldThrow <MongoConnectionException>() .WithInnerException <SocketException>() .And.ConnectionId.Should().Be(_subject.ConnectionId); var task2 = _subject.ReceiveMessageAsync(2, encoderSelector, _messageEncoderSettings, CancellationToken.None); Func <Task> act2 = () => task2; act2.ShouldThrow <MongoConnectionClosedException>() .And.ConnectionId.Should().Be(_subject.ConnectionId); _capturedEvents.Next().Should().BeOfType <ConnectionReceivingMessageEvent>(); _capturedEvents.Next().Should().BeOfType <ConnectionFailedEvent>(); _capturedEvents.Next().Should().BeOfType <ConnectionReceivingMessageFailedEvent>(); _capturedEvents.Any().Should().BeFalse(); } }
public void TestGrantPermission_ResourceDoesNotExist() { var grantor = new Principal { PrincipalId = 1, }; var grantee = new Principal { PrincipalId = 2 }; var permission = new CAM.Data.Permission { PermissionId = CAM.Data.Permission.EditOffice.Id, PermissionName = CAM.Data.Permission.EditOffice.Value }; var resourceType = ResourceType.Program; context.Principals.Add(grantor); context.Principals.Add(grantee); context.Permissions.Add(permission); ForeignResourceCache foreignResourceCache = null; resourceService.Setup(x => x.GetResourceByForeignResourceId(It.IsAny <int>(), It.IsAny <int>())).Returns(foreignResourceCache); resourceService.Setup(x => x.GetResourceByForeignResourceIdAsync(It.IsAny <int>(), It.IsAny <int>())).ReturnsAsync(foreignResourceCache); var grantedPermission = new GrantedPermission(grantee.PrincipalId, permission.PermissionId, 0, resourceType.Value, grantor.PrincipalId); //invoking async Func <Task> grantAction = async() => { await service.GrantPermissionsAsync(grantedPermission); }; service.Invoking(x => x.GrantPermission(grantedPermission)).ShouldThrow <ModelNotFoundException>() .WithMessage(String.Format("The foreign resource with id [{0}] and resource type [{1}] does not exist in CAM.", grantedPermission.ForeignResourceId, grantedPermission.ResourceTypeAsString)); grantAction.ShouldThrow <ModelNotFoundException>() .WithMessage(String.Format("The foreign resource with id [{0}] and resource type [{1}] does not exist in CAM.", grantedPermission.ForeignResourceId, grantedPermission.ResourceTypeAsString)); }
public virtual async Task Verify_that_a_RenameAsync_throws_an_exception_if_the_destination_file_exists_and_FailIfExists_is_specified() { var filename = Helper.CreateUniqueFileName(); var newFilename = Helper.CreateUniqueFileName(); var folder = Filesystem.LocalStorage; var sourceFile = await Helper.GenerateFileAsync(folder, filename); var existingFile = await Helper.GenerateFileAsync(folder, newFilename); Func <Task> act = () => sourceFile.RenameAsync(newFilename, CollisionOption.FailIfExists); act.ShouldThrow <UnifiedIOException>(); (await sourceFile.ExistsAsync()).Should().BeTrue("Expecting the source file to be untouched"); // Cleanup await existingFile.DeleteAsync(); await sourceFile.DeleteAsync(); }
public void WhenMessageHandlerThrowsDeadletterMessageImmediatelyException_MessageIsDeadlettered() { var stream = new MemoryStream(); var writer = new StreamWriter(stream); writer.Write("{ Bar: 1 }"); writer.Flush(); stream.Position = 0; var tm = new DeadLetterTransportMessage { MessageType = typeof(DeadletterImmediatelyMessage).AssemblyQualifiedName }; tm.SetBody(stream); Func <Task> action = () => this.receiver.HandOver(tm); action.ShouldThrow <DeadletterMessageImmediatelyException>(); tm.DeadLetterHeaders.Should().NotBeEmpty(); tm.DelayedDeliveryCount.Should().Be(0); }
public void WHEN_ParamsProperty_Is_Null_SHOULD_Throw_Argument_Exception(string storeNumber, string scope, string baseUrl) { //Arrange var storeViewService = _container.CreateInstance <StoreViewService>(); //Act Func <Task> asyncFunction = async() => { await storeViewService.GetStoreViewModelAsync(new GetStoreByNumberParam { StoreNumber = storeNumber, Scope = scope, BaseUrl = baseUrl, CultureInfo = CultureInfo.CreateSpecificCulture("en-CA") }); }; //Assert asyncFunction.ShouldThrow <ArgumentException>(); }
public void SagaMachineShouldHaveInitialiseStateId() { _sagaMachine .WithMessage <HelloMessage>((proccess, msg) => proccess .InitialiseState(hello => new TestState { SomeStateVariable = hello.Message }) .Execute() ); Func <Task> act = async() => { await _sagaMachine.Handle(new HelloMessage { Message = "Initialised" }).ConfigureAwait(false); }; act.ShouldThrow <SagaException>(); }
public void SaveEvents_fails_if_db_context_does_not_support_transaction() { // Arrange var created = new FakeUserCreated { Version = 1 }; string databaseName = nameof(SaveEvents_fails_if_db_context_does_not_support_transaction); DbContextOptions options = new DbContextOptionsBuilder() .UseInMemoryDatabase(databaseName) .Options; var sut = new SqlEventStore( () => new FakeEventStoreDbContext(options), new JsonMessageSerializer()); // Act Func <Task> action = () => sut.SaveEvents <FakeUser>(new[] { created }); // Assert action.ShouldThrow <InvalidOperationException>(); }
public void ThenShouldThrowExceptionIfAnyOverlapsExist() { var app = _exampleValidRequest.Apprenticeships.First(); _mockMediator.Setup(x => x.SendAsync(It.IsAny <GetOverlappingApprenticeshipsRequest>())) .ReturnsAsync(new GetOverlappingApprenticeshipsResponse { Data = new List <ApprenticeshipResult> { new ApprenticeshipResult { Id = app.Id, AgreementStatus = app.AgreementStatus, ValidationFailReason = ValidationFailReason.OverlappingEndDate } } }); Func <Task> act = async() => await _handler.Handle(_exampleValidRequest); act.ShouldThrow <ValidationException>(); }
public async Task TestDeleteDocuments_ConfigDoesNotExist() { SimpleEntityConfiguration config = null; indexService.Setup(x => x.GetDocumentConfiguration <SimpleEntity>()).Returns(config); var list = new List <object> { 1, 2 }; Action a = () => service.DeleteDocuments(list); Func <Task> f = () => { return(service.DeleteDocumentsAsync(list)); }; var message = String.Format("The document configuration for the type [{0}] was not found.", typeof(SimpleEntity)); a.ShouldThrow <NotSupportedException>().WithMessage(message); f.ShouldThrow <NotSupportedException>().WithMessage(message); notificationService.Verify(x => x.DeleteDocumentsStarted(It.IsAny <string>(), It.IsAny <List <object> >()), Times.Never()); notificationService.Verify(x => x.DeleteDocumentsFinished(It.IsAny <string>(), It.IsAny <List <object> >()), Times.Never()); }
public void When_async_method_throws_expected_exception_it_should_succeed() { //----------------------------------------------------------------------------------------------------------- // Arrange //----------------------------------------------------------------------------------------------------------- var asyncObject = new AsyncClass(); //----------------------------------------------------------------------------------------------------------- // Act //----------------------------------------------------------------------------------------------------------- Action action = () => { Func <Task> asyncFunction = async() => { await asyncObject.ThrowAsync <ArgumentException>(); }; asyncFunction.ShouldThrow <ArgumentException>(); }; //----------------------------------------------------------------------------------------------------------- // Assert //----------------------------------------------------------------------------------------------------------- action.ShouldNotThrow(); }
public void ThenIfTheDataLockDoesNotBelongToTheApprenticeshipThenAnExceptionIsThrown() { //Arrange var request = new GetDataLockRequest { ApprenticeshipId = 1, DataLockEventId = 2 }; _dataLockRepository.Setup(x => x.GetDataLock(It.IsAny <long>())) .ReturnsAsync(new DataLockStatus { DataLockEventId = 2, ApprenticeshipId = 3 }); //Act & Assert Func <Task> act = async() => await _handler.Handle(request); act.ShouldThrow <ValidationException>(); }
public void ShouldPass_ExceptionTypePassedIn() { // ReSharper disable once RedundantDelegateCreation var task = new Func<Task>(() => { throw new InvalidOperationException(); }); task.ShouldThrow(typeof(InvalidOperationException)); }
public void Should_throw_on_response_timeout() { IServiceLocator serviceLocator = TestRig.CreateTestServiceLocator(); var mockTransport = new Mock<IClientTransport>(); serviceLocator.RegisterInstance(CreateMockTransportFactory(mockTransport.Object)); var testAction = new Func<Task>( async () => { using (var connection = serviceLocator.ResolveType<IMTProtoClientConnection>()) { await connection.Connect(); await connection.RequestAsync<TestResponse>(new TestRequest(), MessageSendingFlags.None, TimeSpan.FromSeconds(1)); } }); testAction.ShouldThrow<TaskCanceledException>(); }
public void ShouldPass() { // ReSharper disable once RedundantDelegateCreation var task = new Func<Task>(() => { throw new InvalidOperationException(); }); task.ShouldThrow<InvalidOperationException>(); }
public void CreateUser_should_throw_exception_if_the_role_he_is_allocated_to_does_not_exist() { using (var store = NewDocumentStore()) { using (var session = store.OpenAsyncSession()) { var controller = GetAccountsController(session); // Arrange var model = new CreateUserBindingModel { Username = "******", FirstName = "Jeremy", LastName = "Holt", Email = "*****@*****.**", Password = "******" }; model.Roles.AddRange(new List<string> {"Admin", "Accounts"}); // Act var act = new Func<Task>(() => controller.CreateUser(model)); // Assert act.ShouldThrow<InvalidOperationException>() .WithMessage("Não existem as cargas 'Admin, Accounts' - por favor cria essas cargas antes que tentando de adicionar o usuário."); } } }
public async Task DeleteAsync_should_throw_exception_if_the_role_has_associated_users() { using (var store = NewDocumentStore()) { new ApplicationUsersIndex().Execute(store); using (var session = store.OpenAsyncSession()) { // Arrange var user = new ApplicationUser("jeremyholt") {Roles = {"Admin", "Accounts"}}; await session.StoreAsync(user); await session.SaveChangesAsync(); var role = new ApplicationRole("Admin"); await session.StoreAsync(role); await session.SaveChangesAsync(); var roleStoreService = new RavenRoleStore(session); // Act var act = new Func<Task>(() => roleStoreService.DeleteAsync(role)); // Assert act.ShouldThrow<InvalidOperationException>().WithMessage("Não pode deletar carga 'Admin' porque existem usuários nessa carga"); } } }
public void FindByNameAsync_should_throw_exception_if_no_rolename_provided() { using (var store = NewDocumentStore()) { using (var session = store.OpenAsyncSession()) { var sut = GetRavenRoleStore(session); // Act var act = new Func<Task>(() => sut.FindByNameAsync("")); // Assert act.ShouldThrow<ArgumentNullException>(); } } }
public void FindByNameAsync_should_throw_notfoundexception_if_rolename_is_not_found() { using (var store = NewDocumentStore()) { using (var session = store.OpenAsyncSession()) { var sut = GetRavenRoleStore(session); // Act var act = new Func<Task>(() => sut.FindByNameAsync("XXX")); // Assert act.ShouldThrow<NotFoundException>().WithMessage("Carga 'XXX' não existe!"); } } }