public async Task WHEN_CustomMethod_Registered_AND_Passing_Valid_Parameters_SHOULD_Update_GuestCustomerInfo()
{
//Arrange
var cart = CreateBasicCart();
cart.Customer.Email = GetRandom.Email();
var service = CreateCheckoutService(cart);
var updatedCustomer = new CustomerSummaryViewModel
{
Email = GetRandom.Email()
};
// Act
var param = new UpdateCheckoutCartParam
{
GetCartParam = CreateGetCartParam(),
UpdateValues = CreateUpdateOperation("GuestCustomerInfo", updatedCustomer),
CurrentStep = GetRandom.Int(),
IsGuest = GetRandom.Boolean()
};
var processedCart = await service.UpdateCheckoutCartAsync(param);
//Assert
processedCart.Should().NotBeNull();
processedCart.Cart.Customer.Email.ShouldBeEquivalentTo(updatedCustomer.Email);
}
public void WHEN_passing_empty_email_SHOULD_throw_ArgumentException(string email)
{
//Arrange
var sut = _container.CreateInstance <MembershipViewService>();
sut.Membership = _container.Get <IMembershipProxy>();
var param = new CreateUserParam
{
Email = email,
FirstName = GetRandom.FirstName(),
LastName = GetRandom.LastName(),
Username = GetRandom.Email(),
Password = GetRandom.String(32),
PasswordQuestion = GetRandom.String(32),
PasswordAnswer = GetRandom.String(32),
CultureInfo = TestingExtensions.GetRandomCulture(),
Scope = GetRandom.String(32)
};
// Act
var exception = Assert.ThrowsAsync <ArgumentException>(() => sut.RegisterAsync(param));
//Assert
exception.Message.Should().Contain("Email");
}
public async Task WHEN_passing_empty_PasswordAnswer_SHOULD_succeed(string passwordAnswer)
{
//Arrange
var expectedCustomer = MockCustomerFactory.CreateRandom();
var customerRepository = _container.CreateInstance <CustomerRepository>();
_container.GetMock <IOvertureClient>()
.Setup(p => p.SendAsync(It.Is <CreateCustomerMembershipRequest>(param => string.IsNullOrWhiteSpace(param.PasswordAnswer))))
.ReturnsAsync(expectedCustomer);
//Act
var result = await customerRepository.CreateUserAsync(new CreateUserParam
{
Email = GetRandom.Email(),
FirstName = GetRandom.FirstName(),
LastName = GetRandom.LastName(),
Username = GetRandom.Email(),
Password = GetRandom.String(32),
PasswordQuestion = GetRandom.String(32),
PasswordAnswer = passwordAnswer,
CultureInfo = TestingExtensions.GetRandomCulture(),
Scope = GetRandom.String(32)
});
//Assert
result.Id.Should().Be(expectedCustomer.Id);
}
public async Task WHEN_passing_empty_username_SHOULD_fallback_to_email_as_username(string username)
{
//Arrange
var sut = _container.CreateInstance <MembershipViewService>();
sut.Membership = _container.Get <IMembershipProxy>();
var expectedEmail = GetRandom.Email();
_container.GetMock <ICustomerRepository>()
.Setup(p => p.CreateUserAsync(It.Is <CreateUserParam>(param => string.IsNullOrWhiteSpace(param.Username))))
.ReturnsAsync(new Customer
{
Email = expectedEmail,
Username = expectedEmail
});
//Act
var result = await sut.RegisterAsync(new CreateUserParam
{
Email = expectedEmail,
FirstName = GetRandom.FirstName(),
LastName = GetRandom.LastName(),
Username = username,
Password = GetRandom.String(32),
PasswordQuestion = GetRandom.String(32),
PasswordAnswer = GetRandom.String(32),
CultureInfo = TestingExtensions.GetRandomCulture(),
Scope = GetRandom.String(32)
});
//Assert
result.Status.Should().Be(MyAccountStatus.Success.ToString());
result.Username.Should().BeEquivalentTo(expectedEmail);
}
public async Task WHEN_passing_empty_PasswordAnswer_SHOULD_succeed(string passwordAnswer)
{
//Arrange
var expectedCustomer = MockCustomerFactory.CreateRandom();
var sut = _container.CreateInstance <MembershipViewService>();
sut.Membership = _container.Get <IMembershipProxy>();
_container.GetMock <ICustomerRepository>()
.Setup(p => p.CreateUserAsync(It.Is <CreateUserParam>(param => string.IsNullOrWhiteSpace(param.PasswordAnswer))))
.ReturnsAsync(expectedCustomer);
//Act
var result = await sut.RegisterAsync(new CreateUserParam
{
Email = GetRandom.Email(),
FirstName = GetRandom.FirstName(),
LastName = GetRandom.LastName(),
Username = GetRandom.Email(),
Password = GetRandom.String(32),
PasswordQuestion = GetRandom.String(32),
PasswordAnswer = passwordAnswer,
CultureInfo = TestingExtensions.GetRandomCulture(),
Scope = GetRandom.String(32)
});
//Assert
result.Status.Should().Be(MyAccountStatus.Success.ToString());
}
public void WHEN_PasswordAnswer_is_Empty_SHOULD_succeed(string passwordAnswer)
{
//Arrange
var expectedUsername = GetRandom.Email();
var expectedScopeId = GetRandom.String(32);
var expectedPassword = GetRandom.String(32);
var customerRepository = _container.CreateInstance <CustomerRepository>();
_container.GetMock <IOvertureClient>()
.Setup(r => r.SendAsync(It.Is <ResetPasswordRequest>(
param => param.Username == expectedUsername &&
param.ScopeId == expectedScopeId &&
param.Password == expectedPassword &&
param.PasswordAnswer == passwordAnswer &&
string.IsNullOrWhiteSpace(param.Email))))
.ReturnsAsync(new ResetPasswordResponse
{
Success = true
});
//Act and Assert
Assert.DoesNotThrowAsync(() =>
customerRepository.ResetPasswordAsync(
expectedUsername,
expectedScopeId,
expectedPassword,
passwordAnswer)
);
}
public void GivenInvalidModelState_ReturnsRegisterView()
{
var model = new Register
{
Username = GetRandom.String(20),
Email = GetRandom.Email(),
Password = "******"
};
Controller.ModelState.AddModelError("Fake error", "error");
var result = Controller.Register(model) as ViewResult;
result.Should().Not.Be.Null();
result.Model.Should().Be.OfType <Register>();
var typedModel = result.Model as Register;
typedModel.Email.Should().Equal(model.Email);
typedModel.Password.Should().Be.NullOrEmpty();
typedModel.ReturnUrl.Should().Equal(model.ReturnUrl);
typedModel.Username.Should().Equal(model.Username);
result.ViewName.Should().Equal("");
var modelState = result.ViewData.ModelState;
modelState.ContainsKey("Fake error").Should().Be.True();
}
public async Task WHEN_requesting_to_log_in_valid_user_response_but_user_is_null_THEN_response_SHOULD_be_unsuccessfull()
{
//Arrange
var sut = _container.CreateInstance <MembershipViewService>();
sut.Membership = _container.Get <IMembershipProxy>();
_container.GetMock <IMembershipProxy>()
.Setup(p => p.LoginUser(It.IsNotNull <string>(), It.IsNotNull <string>()))
.Returns(true);
_container.GetMock <IMembershipProxy>()
.Setup(p => p.GetUser(It.IsNotNull <string>(), It.IsNotNull <bool>()))
.Returns <MembershipUser>(null);
//Act
var result = await sut.LoginAsync(new LoginParam()
{
CultureInfo = TestingExtensions.GetRandomCulture(),
Password = GetRandom.String(15),
Username = GetRandom.Email(),
Scope = GetRandom.String(32)
});
//Assert
result.Status.Should().Be(MyAccountStatus.Failed.ToString());
}
public void WHEN_creating_user_fails_SHOULD_not_attempt_to_merge_cart()
{
//Arrange
var sut = _container.CreateInstance <MembershipViewService>();
_container.GetMock <ICustomerRepository>()
.Setup(p => p.CreateUserAsync(It.IsAny <CreateUserParam>()))
.Throws(new ComposerException(GetRandom.String(3)));
//Act and Assert
Assert.ThrowsAsync <ComposerException>(() => sut.RegisterAsync(new CreateUserParam
{
Email = GetRandom.Email(),
FirstName = GetRandom.FirstName(),
LastName = GetRandom.LastName(),
Username = GetRandom.Email(),
Password = GetRandom.String(32),
PasswordQuestion = GetRandom.String(32),
PasswordAnswer = GetRandom.String(32),
CultureInfo = TestingExtensions.GetRandomCulture(),
Scope = GetRandom.String(32),
}));
_container.GetMock <ICartMergeProvider>().Verify(provider => provider.MergeCartAsync(It.IsAny <CartMergeParam>()), Times.Never);
}
public void WHEN_bad_request_SHOULD_throw_composer_exception()
{
//Arrange
var expectedEmail = GetRandom.Email();
var customerRepository = _container.CreateInstance <CustomerRepository>();
_container.GetMock <IOvertureClient>()
.Setup(r => r.SendAsync(It.Is <ResetPasswordRequest>(
param => string.IsNullOrWhiteSpace(param.Username) &&
string.IsNullOrWhiteSpace(param.Password) &&
string.IsNullOrWhiteSpace(param.PasswordAnswer) &&
param.Email == expectedEmail)))
.ReturnsAsync(new ResetPasswordResponse
{
Success = false
});
//Act and Assert
var sendResetParam = new SendResetPasswordInstructionsParam
{
Email = expectedEmail,
Scope = GetRandom.String(32)
};
Assert.ThrowsAsync <ComposerException>(() => customerRepository.SendResetPasswordInstructionsAsync(sendResetParam));
}
public async Task WHEN_passing_empty_username_SHOULD_fallback_to_email_as_username(string username)
{
//Arrange
var customerRepository = _container.CreateInstance <CustomerRepository>();
var expectedEmail = GetRandom.Email();
_container.GetMock <IOvertureClient>()
.Setup(r => r.SendAsync(It.Is <CreateCustomerMembershipRequest>(param => string.IsNullOrWhiteSpace(param.Username))))
.ReturnsAsync(new Customer
{
Id = GetRandom.Guid(),
Email = expectedEmail,
Username = expectedEmail,
AccountStatus = AccountStatus.Active
});
//Act
var result = await customerRepository.CreateUserAsync(new CreateUserParam
{
Email = expectedEmail,
FirstName = GetRandom.FirstName(),
LastName = GetRandom.LastName(),
Username = username,
Password = GetRandom.String(32),
PasswordQuestion = GetRandom.String(32),
PasswordAnswer = GetRandom.String(32),
CultureInfo = TestingExtensions.GetRandomCulture(),
Scope = GetRandom.String(32)
});
//Assert
result.Email.Should().BeEquivalentTo(expectedEmail);
result.Username.Should().BeEquivalentTo(expectedEmail);
}
private void MockCartPayments(Guid paymentId)
{
var mockedPaymentMethodRepository = _container.GetMock <IPaymentRepository>();
mockedPaymentMethodRepository.Setup(pr => pr.GetCartPaymentsAsync(It.IsNotNull <GetCartPaymentsParam>()))
.ReturnsAsync(new List <Payment>()
{
new Payment
{
Id = paymentId,
Amount = 0.0m,
BillingAddress = new Address()
{
City = GetRandom.String(18),
CountryCode = GetRandom.String(2, true),
FirstName = GetRandom.String(8),
LastName = GetRandom.String(12),
IsPreferredBilling = GetRandom.Boolean(),
IsPreferredShipping = GetRandom.Boolean(),
Email = GetRandom.Email(),
Line1 = GetRandom.Phrase(20),
Line2 = string.Empty,
PhoneNumber = GetRandom.Usa.PhoneNumber(),
PostalCode = GetRandom.String(7, true),
RegionCode = GetRandom.String(5, true)
},
PaymentStatus = PaymentStatus.New,
}
});
}
public void SetUp()
{
//Arrange
_container = new AutoMocker();
_container.Use(ViewModelMapperFactory.Create());
_container.Use(CartViewModelFactoryMock.Create());
var cartRepoMock = _container.GetMock <ICartRepository>();
cartRepoMock.Setup(repo => repo.CompleteCheckoutAsync(It.IsNotNull <CompleteCheckoutParam>()))
.Returns((CompleteCheckoutParam p) =>
{
var order = new Overture.ServiceModel.Orders.Order
{
Cart = new ProcessedCart()
{
Customer = new CustomerSummary()
{
Email = GetRandom.Email()
},
Shipments = new System.Collections.Generic.List <Shipment>()
{
new Shipment
{
Id = GetRandom.Guid(),
LineItems = new System.Collections.Generic.List <LineItem>()
{
new LineItem
{
Id = GetRandom.Guid(),
Sku = GetRandom.String(10),
CatalogId = GetRandom.String(10),
PlacedPrice = GetRandom.Decimal(),
PlacedQuantity = GetRandom.Int(),
Status = GetRandom.String(5),
Total = GetRandom.Decimal(),
KvaValues = new Overture.ServiceModel.PropertyBag(),
KvaDisplayValues = new Overture.ServiceModel.PropertyBag(),
ProductSummary = new CartProductSummary
{
Brand = null,
DisplayName = GetRandom.String(10),
PrimaryParentCategoryId = GetRandom.String(10)
}
}
},
FulfillmentMethod = new FulfillmentMethod
{
FulfillmentMethodType = FulfillmentMethodType.PickUp
}
}
}
},
OrderNumber = GetRandom.String(12)
};
return(Task.FromResult(order));
});
}
public void WHEN_invalid_request_SHOULD_throw_composer_exception()
{
//Arrange
var expectedUsername = GetRandom.Email();
var expectedScope = GetRandom.String(32);
var expectedOldPassword = GetRandom.String(32);
var expectedNewPassword = GetRandom.String(32);
var customerRepository = _container.CreateInstance <CustomerRepository>();
_container.GetMock <IOvertureClient>()
.Setup(r => r.SendAsync(It.Is <ChangePasswordRequest>(
param => param.UserName == expectedUsername &&
param.NewPassword == expectedNewPassword &&
param.OldPassword == expectedOldPassword)))
.ReturnsAsync(new ChangePasswordResponse
{
Success = false
});
//Act and Assert
Assert.ThrowsAsync <ComposerException>(() =>
customerRepository.ChangePasswordAsync(expectedUsername,
expectedScope,
expectedOldPassword,
expectedNewPassword));
}
public async Task RegisterPostTest()
{
Assert.Inconclusive();
async Task validate(object o)
{
var vm = o as RegisterViewModel;
Assert.IsNotNull(vm);
var y = await appDbContext.Users.FirstOrDefaultAsync(x =>
x.Email == vm.Email);
Assert.AreEqual(y.Email, vm.Email);
currentUser = vm;
}
IEnumerable <KeyValuePair <string, string> > createContext(object o)
{
var x = o as RegisterViewModel;
var d = new Dictionary <string, string> {
{ GetMember.Name <RegisterViewModel>(m => m.FirstName), x?.FirstName },
{ GetMember.Name <RegisterViewModel>(m => m.LastName), x?.LastName },
{ GetMember.Name <RegisterViewModel>(m => m.DateOfBirth.ToString()), x?.DateOfBirth.ToString() },
{ GetMember.Name <RegisterViewModel>(m => m.Email), x?.Email },
{ GetMember.Name <RegisterViewModel>(m => m.Password), x?.Password },
{ GetMember.Name <RegisterViewModel>(m => m.ConfirmPassword), x?.ConfirmPassword },
{ GetMember.Name <RegisterViewModel>(m => m.Country), x?.Country },
{ GetMember.Name <RegisterViewModel>(m => m.AddressLine), x?.AddressLine },
{ GetMember.Name <RegisterViewModel>(m => m.ZipCode), x?.ZipCode },
{ GetMember.Name <RegisterViewModel>(m => m.City), x?.City },
{ GetMember.Name <RegisterViewModel>(m => m.County), x?.County }
};
return(d);
}
object createObject()
{
var vm = GetRandom.Object <RegisterViewModel>();
vm.Email = GetRandom.Email();
vm.Password = GetRandom.Password();
vm.ConfirmPassword = vm.Password;
vm.FirstName = GetRandom.String();
vm.LastName = GetRandom.String();
vm.DateOfBirth = GetRandom.DateTime();
vm.Country = GetRandom.Object <Country>().ToString();
vm.AddressLine = GetRandom.String();
vm.ZipCode = GetRandom.String();
vm.City = GetRandom.String();
vm.County = GetRandom.String();
return(vm);
}
await createAllGivenTest <AccountController>(x => x.Register(null),
createObject, createContext, validate);
}
public User SetupUser(Action <User> modifications = null)
{
var item = Builder <User> .CreateNew()
.With(x => x.Id = default(int))
.And(x => x.Username = GetRandom.String(20))
.And(x => x.Password = "******".ToSHAHash())
.And(x => x.Email = GetRandom.Email())
.Build();
return(ApplyModificationsAndSave(item, modifications));
}
public void GivenValidPostRequest_AndNoUserWithEmail_ReturnsView()
{
var model = new ForgotPassword
{
Email = GetRandom.Email()
};
var result = Controller.ForgotPassword(model) as ViewResult;
result.Should().Not.Be.Null();
result.ViewName.Should().Not.Equal("ForgotPasswordConfirmation");
Controller.ModelState.Count.Should().Equal(1);
}
private static User CreateAFakeUser()
{
return(Builder <User>
.CreateNew()
.With(x => x.Id = null)
.With(x => x.FullName = string.Format("{0} {1}", GetRandom.FirstName(), GetRandom.LastName()))
.And(x => x.DisplayName = x.FullName.Replace(' ', '.'))
.And(x => x.Email = GetRandom.Email())
.And(x => x.CreatedOn = GetRandom.DateTime(DateTime.UtcNow.AddMonths(-1), DateTime.UtcNow))
.And(x => x.Reputation = GetRandom.PositiveInt(50000))
.And(x => x.IsActive = GetRandom.Boolean())
.Build());
}
public void CantChangeDataElementsTest()
{
obj = new testClass(GetRandom.Object <UserData>());
var d = obj.Data;
obj.Data.Id = GetRandom.String();
obj.Data.FirstName = GetRandom.String();
obj.Data.LastName = GetRandom.String();
obj.Data.PhoneNumber = GetRandom.String();
obj.Data.Email = GetRandom.Email();
obj.Data.PasswordHash = GetRandom.Password();
arePropertiesEqual(d, obj.Data);
}
public void GivenValidPostRequest_SendsEmail()
{
var model = new Register
{
Username = GetRandom.String(20),
Email = GetRandom.Email(),
Password = "******"
};
Controller.Register(model);
MailController.Verify(x => x.Welcome(It.Is <ViewModels.Mail.Welcome>(m => m.To == model.Email && m.Username == model.Username)), Times.Once());
}
public void GivenExternalReturnUrl_ReturnsConfirmation()
{
var model = new Register
{
Username = GetRandom.String(20),
Email = GetRandom.Email(),
Password = "******",
ReturnUrl = "http://google.com"
};
var result = Controller.Register(model) as ViewResult;
result.Should().Not.Be.Null();
result.ViewName.Should().Equal("RegisterConfirmation");
}
public void GivenReservedUsername_ReturnsRegisterView()
{
var model = new Register
{
Username = "******",
Email = GetRandom.Email(),
Password = "******"
};
var result = Controller.Register(model) as ViewResult;
result.Should().Not.Be.Null();
result.Model.Should().Be.OfType <Register>();
result.ViewName.Should().Equal("");
}
public void WHEN_NewPassword_is_Empty_SHOULD_throw_ArgumentException(string newPassword)
{
//Arrange
var customerRepository = _container.CreateInstance <CustomerRepository>();
//Act
var ex = Assert.ThrowsAsync <ArgumentException>(() => customerRepository.ResetPasswordAsync(
GetRandom.Email(),
GetRandom.String(70),
newPassword,
GetRandom.String(70)
));
//Assert
ex.Message.Should().ContainEquivalentOf("newPassword");
}
public void GivenValidModelState_ReturnsRedirect()
{
var model = new Register
{
Username = GetRandom.String(20),
Email = GetRandom.Email(),
Password = "******",
ReturnUrl = "http://google.com"
};
var result = Controller.Register(model) as RedirectResult;
result.Should().Not.Be.Null();
Controller.TempData[ViewDataConstants.Notification].Should().Not.Be.Null();
result.Url.Should().Equal(Controller.Url.Home().Index());
}
public void WHEN_token_ok_SHOULD_return_encrypted_token()
{
//Arrange
var param = new OrderToken
{
Email = GetRandom.Email(),
OrderNumber = GetRandom.String(6)
};
//Act
var token = GuestOrderTokenizer.GenerateOrderToken(param);
//Assert
token.Should().NotBeNullOrWhiteSpace();
token.Should().NotContainEquivalentOf(param.Email);
token.Should().NotContainEquivalentOf(param.OrderNumber);
}
public void GivenValidModelState_ReturnsConfirmation()
{
var model = new Register
{
Username = GetRandom.String(20),
Email = GetRandom.Email(),
Password = "******"
};
var result = Controller.Register(model) as ViewResult;
result.Should().Not.Be.Null();
result.ViewName.Should().Equal("RegisterConfirmation");
var viewModel = result.Model as Register;
viewModel.Should().Not.Be.Null();
}
public void WHEN_orderNumber_is_invalid_SHOULD_throw_ArgumentNullException(string orderNumber)
{
//Arrange
OrderToken param = new OrderToken
{
Email = GetRandom.Email(),
OrderNumber = orderNumber
};
//Act
var ex = Assert.Throws <ArgumentException>(() => GuestOrderTokenizer.GenerateOrderToken(param));
//Assert
ex.Should().NotBeNull();
ex.ParamName.Should().NotBeNullOrWhiteSpace();
ex.Message.Should().NotBeNullOrWhiteSpace();
}
public async Task WHEN_requesting_to_log_in_valid_user_response_SHOULD_have_correct_user_id()
{
//Arrange
var expectedCustomer = MockCustomerFactory.CreateRandom();
var sut = _container.CreateInstance <MembershipViewService>();
sut.Membership = _container.Get <IMembershipProxy>();
_container.GetMock <IMembershipProxy>()
.Setup(p => p.LoginUser(It.IsNotNull <string>(), It.IsNotNull <string>()))
.Returns(true);
_container.GetMock <IMembershipProxy>()
.Setup(p => p.GetUser(It.IsNotNull <string>(), It.IsNotNull <bool>()))
.Returns(MockMembershipUser(
GetRandom.Email(),
expectedCustomer.Id,
GetRandom.Email(),
GetRandom.String(32),
GetRandom.String(32),
true,
false,
GetRandom.DateTime(),
GetRandom.DateTime(),
GetRandom.DateTime(),
GetRandom.DateTime(),
GetRandom.DateTime()
));
_container.GetMock <ICustomerRepository>()
.Setup(p => p.GetCustomerByIdAsync(It.Is <GetCustomerByIdParam>(param => param.CustomerId == expectedCustomer.Id)))
.ReturnsAsync(expectedCustomer);
//Act
var result = await sut.LoginAsync(new LoginParam()
{
CultureInfo = TestingExtensions.GetRandomCulture(),
Password = GetRandom.String(15),
Username = GetRandom.Email(),
Scope = GetRandom.String(32)
});
//Assert
result.Status.Should().Be(MyAccountStatus.Success.ToString());
}
public void WHEN_CultureInfo_is_Null_SHOULD_throw_ArgumentException(CultureInfo cultureInfo)
{
//Arrange
var membershipService = _container.CreateInstance <MembershipViewService>();
//Act
var ex = Assert.ThrowsAsync <ArgumentException>(() => membershipService.ForgotPasswordAsync(
new ForgotPasswordParam
{
CultureInfo = cultureInfo,
Email = GetRandom.Email(),
Scope = GetRandom.String(32)
}
));
//Assert
ex.Message.Should().ContainEquivalentOf("CultureInfo");
}
public void WHEN_Scope_is_Empty_SHOULD_throw_ArgumentException(string scope)
{
//Arrange
var membershipService = _container.CreateInstance <MembershipViewService>();
//Act
var ex = Assert.ThrowsAsync <ArgumentException>(() => membershipService.ForgotPasswordAsync(
new ForgotPasswordParam
{
CultureInfo = TestingExtensions.GetRandomCulture(),
Email = GetRandom.Email(),
Scope = scope
}
));
//Assert
ex.Message.Should().ContainEquivalentOf("Scope");
}
