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>();
        }
Пример #4
0
        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>();
        }
Пример #5
0
        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>();
        }
Пример #6
0
        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");
        }
Пример #7
0
#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");
        }
Пример #8
0
            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>();
            }
Пример #9
0
            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);
            }
Пример #10
0
        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);
        }
Пример #12
0
        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());
        }
Пример #13
0
        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();
        }
Пример #14
0
        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>();
        }
Пример #16
0
        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);
        }
Пример #19
0
        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();
        }
Пример #20
0
        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>();
        }
Пример #21
0
        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>();
        }
Пример #23
0
        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();
            }
        }
Пример #24
0
        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();
        }
Пример #26
0
        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);
        }
Пример #27
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>();
        }
Пример #28
0
        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>();
        }
Пример #30
0
        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>();
        }
Пример #31
0
        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!");
                }
            }
        }