public void IsInvalidWhen_MatchesExpiredEntity()
            {
                var confirmation = new EmailConfirmation(EmailConfirmationIntent.CreatePassword)
                {
                    ExpiresOnUtc = DateTime.UtcNow.AddMinutes(-1),
                };
                var command = new RedeemEmailConfirmationCommand
                {
                    Token = confirmation.Token,
                };
                var scenarioOptions = new ScenarioOptions
                {
                    EmailConfirmation = confirmation,
                };
                var validator = CreateValidator(scenarioOptions);

                var results = validator.Validate(command);

                results.IsValid.ShouldBeFalse();
                results.Errors.Count.ShouldBeInRange(1, int.MaxValue);
                var error = results.Errors.SingleOrDefault(e => e.PropertyName == "Token");
                error.ShouldNotBeNull();
                // ReSharper disable PossibleNullReferenceException
                error.ErrorMessage.ShouldEqual(string.Format(
                    ValidateEmailConfirmation.FailedBecauseIsExpired,
                        command.Token, confirmation.ExpiresOnUtc));
                // ReSharper restore PossibleNullReferenceException
            }
            public void IsInvalidWhen_MatchesNoEntity()
            {
                var command = new RedeemEmailConfirmationCommand
                {
                    Token = Guid.NewGuid(),

                };
                var scenarioOptions = new ScenarioOptions
                {
                    EmailConfirmation = new EmailConfirmation(EmailConfirmationIntent.ResetPassword),
                };
                var validator = CreateValidator(scenarioOptions);

                var results = validator.Validate(command);

                results.IsValid.ShouldBeFalse();
                results.Errors.Count.ShouldBeInRange(1, int.MaxValue);
                var error = results.Errors.SingleOrDefault(e => e.PropertyName == "Token");
                error.ShouldNotBeNull();
                // ReSharper disable PossibleNullReferenceException
                error.ErrorMessage.ShouldEqual(string.Format(
                    ValidateEmailConfirmation.FailedBecauseTokenMatchedNoEntity,
                        command.Token));
                // ReSharper restore PossibleNullReferenceException
            }
            public void IsInvalidWhen_IsEmpty()
            {
                var command = new RedeemEmailConfirmationCommand { Token = Guid.Empty };
                var scenarioOptions = new ScenarioOptions();
                var validator = CreateValidator(scenarioOptions);

                var results = validator.Validate(command);

                results.IsValid.ShouldBeFalse();
                results.Errors.Count.ShouldBeInRange(1, int.MaxValue);
                var error = results.Errors.SingleOrDefault(e => e.PropertyName == "Token");
                error.ShouldNotBeNull();
                // ReSharper disable PossibleNullReferenceException
                error.ErrorMessage.ShouldEqual(string.Format(
                    ValidateEmailConfirmation.FailedBecauseTokenWasEmpty,
                        Guid.Empty));
                // ReSharper restore PossibleNullReferenceException
            }
            public void ExecutesUpdate_OnEmailConfirmation_WhenNotRedeeed()
            {
                var confirmation = new EmailConfirmation(EmailConfirmationIntent.CreatePassword)
                {
                    EmailAddress = new EmailAddress(),
                };
                var command = new RedeemEmailConfirmationCommand
                {
                    Token = confirmation.Token,
                };
                var queryProcessor = new Mock<IProcessQueries>(MockBehavior.Strict);
                queryProcessor.Setup(m => m.Execute(It.Is(RandomSecretGeneration(256))))
                    .Returns(null as string);
                var entities = new Mock<ICommandEntities>(MockBehavior.Strict).Initialize();
                entities.Setup(m => m.Get<EmailConfirmation>()).Returns(new[] { confirmation }.AsQueryable);
                entities.Setup(m => m.Update(It.Is(ConfirmationEntity(confirmation))));
                var handler = new RedeemEmailConfirmationHandler(entities.Object);

                handler.Handle(command);

                entities.Verify(m => m.Update(It.Is(ConfirmationEntity(confirmation))),
                    Times.Once());
            }
            public void ExecutesQuery_ForEmailConfirmation()
            {
                var command = new RedeemEmailConfirmationCommand
                {
                    Token = Guid.NewGuid(),
                };
                var entities = new Mock<ICommandEntities>(MockBehavior.Strict).Initialize();
                entities.Setup(m => m.Get<EmailConfirmation>())
                    .Returns(Enumerable.Empty<EmailConfirmation>().AsQueryable);
                var handler = new RedeemEmailConfirmationHandler(entities.Object);
                NullReferenceException exception = null;
                try
                {
                    handler.Handle(command);
                }
                catch (NullReferenceException ex)
                {
                    exception = ex;
                }

                entities.Verify(m => m.Get<EmailConfirmation>(), Times.Once());
                exception.ShouldNotBeNull();
            }
            public void CopiesTicketValue_ToCommandProperty_WhenAlreadyRedeeed()
            {
                var confirmation = new EmailConfirmation(EmailConfirmationIntent.CreatePassword)
                {
                    EmailAddress = new EmailAddress(),
                    RedeemedOnUtc = DateTime.UtcNow.AddSeconds(-5),
                    Ticket = TwoFiftySixLengthString2,
                };
                var command = new RedeemEmailConfirmationCommand
                {
                    Token = confirmation.Token,
                };
                var queryProcessor = new Mock<IProcessQueries>(MockBehavior.Strict);
                queryProcessor.Setup(m => m.Execute(It.Is(RandomSecretGeneration(256))))
                    .Returns(TwoFiftySixLengthString1);
                var entities = new Mock<ICommandEntities>(MockBehavior.Strict).Initialize();
                entities.Setup(m => m.Get<EmailConfirmation>()).Returns(new[] { confirmation }.AsQueryable);
                var handler = new RedeemEmailConfirmationHandler(entities.Object);

                handler.Handle(command);

                command.Ticket.ShouldNotBeNull();
                command.Ticket.Length.ShouldEqual(256);
                command.Ticket.ShouldEqual(confirmation.Ticket);
                command.Ticket.ShouldEqual(TwoFiftySixLengthString2);
            }
            public void SetsConfirmationProperty_Ticket_WhenNotRedeeed()
            {
                var confirmation = new EmailConfirmation(EmailConfirmationIntent.ResetPassword)
                {
                    EmailAddress = new EmailAddress(),
                };
                var command = new RedeemEmailConfirmationCommand
                {
                    Token = confirmation.Token,
                };
                var queryProcessor = new Mock<IProcessQueries>(MockBehavior.Strict);
                queryProcessor.Setup(m => m.Execute(It.Is(RandomSecretGeneration(256))))
                    .Returns(TwoFiftySixLengthString2);
                var entities = new Mock<ICommandEntities>(MockBehavior.Strict).Initialize();
                entities.Setup(m => m.Get<EmailConfirmation>()).Returns(new[] { confirmation }.AsQueryable);
                entities.Setup(m => m.Update(It.Is(ConfirmationEntity(confirmation))));
                var handler = new RedeemEmailConfirmationHandler(entities.Object);

                confirmation.Ticket.ShouldBeNull();
                handler.Handle(command);

                confirmation.Ticket.ShouldNotBeNull();
                confirmation.Ticket.Length.ShouldEqual(256);
            }
            public void SetsNoConfirmationProperty_RedeemedOnUtc_WhenAlreadyRedeeed()
            {
                var redeemedOnUtc = DateTime.UtcNow.AddSeconds(-5);
                var confirmation = new EmailConfirmation(EmailConfirmationIntent.CreatePassword)
                {
                    EmailAddress = new EmailAddress(),
                    RedeemedOnUtc = redeemedOnUtc,
                };
                var command = new RedeemEmailConfirmationCommand
                {
                    Token = confirmation.Token,
                };
                var queryProcessor = new Mock<IProcessQueries>(MockBehavior.Strict);
                queryProcessor.Setup(m => m.Execute(It.Is(RandomSecretGeneration(256))))
                    .Returns(null as string);
                var entities = new Mock<ICommandEntities>(MockBehavior.Strict).Initialize();
                entities.Setup(m => m.Get<EmailConfirmation>()).Returns(new[] { confirmation }.AsQueryable);
                var handler = new RedeemEmailConfirmationHandler(entities.Object);

                handler.Handle(command);

                confirmation.RedeemedOnUtc.HasValue.ShouldBeTrue();
                // ReSharper disable PossibleInvalidOperationException
                confirmation.RedeemedOnUtc.Value.ShouldEqual(redeemedOnUtc);
                // ReSharper restore PossibleInvalidOperationException
            }
            public void SetsNoEmailAddressProperty_IsConfirmed_WhenAlreadyRedeeed()
            {
                var confirmation = new EmailConfirmation(EmailConfirmationIntent.CreatePassword)
                {
                    EmailAddress = new EmailAddress(),
                    RedeemedOnUtc = DateTime.UtcNow.AddSeconds(-5),
                };
                var command = new RedeemEmailConfirmationCommand
                {
                    Token = confirmation.Token,
                };
                var queryProcessor = new Mock<IProcessQueries>(MockBehavior.Strict);
                queryProcessor.Setup(m => m.Execute(It.Is(RandomSecretGeneration(256))))
                    .Returns(null as string);
                var entities = new Mock<ICommandEntities>(MockBehavior.Strict).Initialize();
                entities.Setup(m => m.Get<EmailConfirmation>())
                    .Returns(new[] { confirmation }.AsQueryable);
                var handler = new RedeemEmailConfirmationHandler(entities.Object);

                confirmation.EmailAddress.IsConfirmed.ShouldBeFalse();
                handler.Handle(command);

                confirmation.EmailAddress.IsConfirmed.ShouldBeFalse();
            }
            public void SetsEmailAddressProperty_IsConfirmed_ToTrue_WhenNotRedeemed()
            {
                var confirmation = new EmailConfirmation(EmailConfirmationIntent.ResetPassword)
                {
                    EmailAddress = new EmailAddress(),
                };
                var command = new RedeemEmailConfirmationCommand
                {
                    Token = confirmation.Token,
                };
                var queryProcessor = new Mock<IProcessQueries>(MockBehavior.Strict);
                var entities = new Mock<ICommandEntities>(MockBehavior.Strict).Initialize();
                entities.Setup(m => m.Get<EmailConfirmation>()).Returns(new[] { confirmation }.AsQueryable);
                entities.Setup(m => m.Update(It.Is(ConfirmationEntity(confirmation))));
                queryProcessor.Setup(m => m.Execute(It.Is(RandomSecretGeneration(256))))
                    .Returns(null as string);
                var handler = new RedeemEmailConfirmationHandler(entities.Object);

                confirmation.EmailAddress.IsConfirmed.ShouldBeFalse();
                handler.Handle(command);

                confirmation.EmailAddress.IsConfirmed.ShouldBeTrue();
            }
            public void IsValidWhen_Confirmation_WasNull()
            {
                var command = new RedeemEmailConfirmationCommand();
                var scenarioOptions = new ScenarioOptions();
                var validator = CreateValidator(scenarioOptions);

                var results = validator.Validate(command);

                var error = results.Errors.SingleOrDefault(e => e.PropertyName == "Intent");
                error.ShouldBeNull();
            }
            public void IsValidWhen_IsCorrectMatch()
            {
                var confirmation = new EmailConfirmation(EmailConfirmationIntent.CreatePassword)
                {
                    SecretCode = "tomato",
                };
                var command = new RedeemEmailConfirmationCommand
                {
                    Token = confirmation.Token,
                    SecretCode = "tomato",
                    Intent = EmailConfirmationIntent.CreatePassword,
                };
                var scenarioOptions = new ScenarioOptions
                {
                    EmailConfirmation = confirmation,
                };
                var validator = CreateValidator(scenarioOptions);

                var results = validator.Validate(command);

                var error = results.Errors.SingleOrDefault(e => e.PropertyName == "SecretCode");
                error.ShouldBeNull();
            }
            public void IsValidWhen_IsNotEmpty_AndConfirmationWasNull()
            {
                var command = new RedeemEmailConfirmationCommand
                {
                    SecretCode = "test"
                };
                var scenarioOptions = new ScenarioOptions();
                var validator = CreateValidator(scenarioOptions);

                var results = validator.Validate(command);

                var error = results.Errors.SingleOrDefault(e => e.PropertyName == "SecretCode");
                error.ShouldBeNull();
            }
            public void IsInvalidWhen_IsIncorrectMatch()
            {
                var confirmation = new EmailConfirmation(EmailConfirmationIntent.ResetPassword)
                {
                    SecretCode = "secret1",
                };
                var command = new RedeemEmailConfirmationCommand
                {
                    Token = confirmation.Token,
                    SecretCode = "secret2",
                    Intent = EmailConfirmationIntent.ResetPassword,
                };
                var scenarioOptions = new ScenarioOptions
                {
                    EmailConfirmation = confirmation,
                };
                var validator = CreateValidator(scenarioOptions);

                var results = validator.Validate(command);

                results.IsValid.ShouldBeFalse();
                results.Errors.Count.ShouldBeInRange(1, int.MaxValue);
                var error = results.Errors.SingleOrDefault(e => e.PropertyName == "SecretCode");
                error.ShouldNotBeNull();
                // ReSharper disable PossibleNullReferenceException
                error.ErrorMessage.ShouldEqual(string.Format(
                    ValidateEmailConfirmation.FailedBecauseSecretCodeWasIncorrect,
                        command.SecretCode, confirmation.Token));
                // ReSharper restore PossibleNullReferenceException
            }
            public void IsValidWhen_IsNotEmpty_AndMatchesEntity_Unexpired_UnRedeemed_Unretired()
            {
                var confirmation = new EmailConfirmation(EmailConfirmationIntent.CreatePassword)
                {
                    ExpiresOnUtc = DateTime.UtcNow.AddMinutes(1),
                };
                var command = new RedeemEmailConfirmationCommand
                {
                    Token = confirmation.Token,
                };
                var scenarioOptions = new ScenarioOptions
                {
                    EmailConfirmation = confirmation,
                };
                var validator = CreateValidator(scenarioOptions);

                var results = validator.Validate(command);

                var error = results.Errors.SingleOrDefault(e => e.PropertyName == "Token");
                error.ShouldBeNull();
            }