public void WHEN_Passing_Valid_Parameters_SHOULD_Succeed()
{
//Arrange
_container.Use(OvertureClientFactory.CreateMockWithValue(_dummyCart));
var repository = _container.CreateInstance <CartRepository>();
// Act
var result = repository.AddLineItemAsync(new AddLineItemParam
{
Scope = GetRandom.String(32),
CultureInfo = TestingExtensions.GetRandomCulture(),
CustomerId = GetRandom.Guid(),
CartName = GetRandom.String(32),
ProductId = GetRandom.String(32),
VariantId = GetRandom.String(32),
Quantity = GetRandom.Int(1, 10000)
}).Result;
// Assert
result.Should().NotBeNull("Missing CustomerID or Cart are expected to be created automatically");
}
public void WHEN_Customer_is_Null_SHOULD_throw_ArgumentException()
{
//Arrange
var customerViewService = _container.CreateInstance <CustomerViewService>();
var param = new UpdateAccountParam
{
ReturnUrl = GetRandom.String(32),
Scope = GetRandom.String(32),
CultureInfo = TestingExtensions.GetRandomCulture(),
Email = GetRandom.String(32),
FirstName = GetRandom.String(32),
LastName = GetRandom.String(32),
PreferredLanguage = GetRandom.String(4),
};
//Act
var ex = Assert.ThrowsAsync <ArgumentException>(() => customerViewService.UpdateAccountAsync(param));
//Assert
ex.Message.Should().ContainEquivalentOf("Customer");
}
public void WHEN_Dependencies_Return_NullValues_SHOULD_Succeed()
{
var service = _container.CreateInstance <CartService>();
_container.Use(CartRepositoryFactory.CreateWithNullValues());
// Act
var result = service.GetCartViewModelAsync(new GetCartParam
{
Scope = GetRandom.String(32),
CultureInfo = TestingExtensions.GetRandomCulture(),
CustomerId = GetRandom.Guid(),
CartName = GetRandom.String(32),
ExecuteWorkflow = GetRandom.Boolean(),
WorkflowToExecute = GetRandom.String(32),
BaseUrl = GetRandom.String(32)
}).Result;
// Assert
result.Should().NotBeNull();
}
public void WHEN_CartName_Is_NullOrWhitespace_SHOULD_Throw_ArgumentException(string cartName)
{
var service = _container.CreateInstance <CartService>();
var param = new GetCartParam
{
Scope = GetRandom.String(32),
CultureInfo = TestingExtensions.GetRandomCulture(),
CustomerId = GetRandom.Guid(),
CartName = cartName,
ExecuteWorkflow = GetRandom.Boolean(),
WorkflowToExecute = GetRandom.String(32),
BaseUrl = GetRandom.String(32)
};
// Act
var exception = Assert.ThrowsAsync <ArgumentException>(() => service.GetCartViewModelAsync(param));
//Assert
exception.ParamName.Should().BeSameAs("param");
exception.Message.Should().Contain("param.CartName");
}
public async Task WHEN_bad_request_SHOULD_succeed()
{
//Arrange
var expectedEmail = GetRandom.Email();
var membershipService = _container.CreateInstance <MembershipViewService>();
_container.GetMock <ICustomerRepository>()
.Setup(r => r.SendResetPasswordInstructionsAsync(It.Is <SendResetPasswordInstructionsParam>(p => p.Email == expectedEmail)))
.Throws(new ComposerException(GetRandom.String(2)));
//Act
var result = await membershipService.ForgotPasswordAsync(new ForgotPasswordParam
{
CultureInfo = TestingExtensions.GetRandomCulture(),
Scope = GetRandom.String(32),
Email = expectedEmail
});
//Assert
result.Status.Should().Be(MyAccountStatus.Success.ToString(), "For security, the default implementation does not provide any information on the user's existance");
}
public void WHEN_VariantId_Is_NullOrWhitespace_SHOULD_Succeed(string variantId)
{
//Arrange
_container.Use(OvertureClientFactory.Create());
var repository = _container.CreateInstance <WishListRepository>();
// Act
var result = repository.AddLineItemAsync(new AddLineItemParam
{
Scope = GetRandom.String(32),
CultureInfo = TestingExtensions.GetRandomCulture(),
CustomerId = GetRandom.Guid(),
CartName = GetRandom.String(32),
ProductId = GetRandom.String(32),
VariantId = variantId,
Quantity = 1000
}).Result;
// Assert
result.Should().NotBeNull("Missing CustomerID or WishList are expected to be created automatically");
}
public void WHEN_Scope_Is_NullOrWhitespace_SHOULD_Throw_ArgumentException(string scope)
{
//Arrange
_container.Use(OvertureClientFactory.Create());
var cartRepository = _container.CreateInstance <CartRepository>();
var param = new GetCartsByCustomerIdParam
{
Scope = scope,
CultureInfo = TestingExtensions.GetRandomCulture(),
CustomerId = GetRandom.Guid(),
IncludeChildScopes = GetRandom.Boolean()
};
// Act
Expression <Func <Task <List <CartSummary> > > > expression = () => cartRepository.GetCartsByCustomerIdAsync(param);
var exception = Assert.ThrowsAsync <ArgumentException>(() => expression.Compile().Invoke());
//Assert
exception.ParamName.Should().BeEquivalentTo(GetParamsInfo(expression)[0].Name);
exception.Message.Should().StartWith(GetMessageOfNullWhiteSpace(nameof(param.Scope)));
}
public void WHEN_Passing_Valid_Parameters_SHOULD_Succeed()
{
var service = _container.CreateInstance <CartService>();
// Act
var result = service.UpdateLineItemAsync(new UpdateLineItemParam
{
ScopeId = GetRandom.String(32),
CultureInfo = TestingExtensions.GetRandomCulture(),
CustomerId = GetRandom.Guid(),
CartName = GetRandom.String(32),
LineItemId = GetRandom.Guid(),
GiftMessage = GetRandom.String(32),
GiftWrap = GetRandom.Boolean(),
Quantity = 1000,
BaseUrl = GetRandom.String(32)
}).Result;
// Assert
result.Should().NotBeNull();
}
public void WHEN_Scope_Is_NullOrWhitespace_SHOULD_Throw_ArgumentException(string scope)
{
var service = _container.CreateInstance <CartService>();
var param = new RemoveLineItemParam
{
Scope = scope,
CultureInfo = TestingExtensions.GetRandomCulture(),
CustomerId = GetRandom.Guid(),
CartName = GetRandom.String(32),
LineItemId = GetRandom.Guid(),
BaseUrl = GetRandom.String(32)
};
// Act
Expression <Func <Task <CartViewModel> > > expression = () => service.RemoveLineItemAsync(param);
var exception = Assert.ThrowsAsync <ArgumentException>(() => expression.Compile().Invoke());
//Assert
exception.ParamName.Should().BeEquivalentTo(GetParamsInfo(expression)[0].Name);
exception.Message.Should().StartWith(GetMessageOfNullWhiteSpace(nameof(param.Scope)));
}
public static Mock <IComposerContext> Create(bool authenticated, bool guest)
{
var composerContext = new Mock <IComposerContext>(MockBehavior.Strict);
composerContext.SetupProperty(p => p.CultureInfo)
.Object.CultureInfo = TestingExtensions.GetRandomCulture();
//composerContext.SetupProperty(p => p.Scope)
// .Object.Scope = GetRandom.String(32);
composerContext.SetupProperty(p => p.CustomerId)
.Object.CustomerId = guest ? GetRandom.Guid() : Guid.Empty;
composerContext.SetupProperty(p => p.IsGuest)
.Object.IsGuest = guest;
composerContext.SetupGet(p => p.IsAuthenticated)
.Returns(authenticated);
return(composerContext);
}
public async Task WHEN_valid_request_SHOULD_succeed()
{
//Arrange
var expectedEmail = GetRandom.Email();
var membershipService = _container.CreateInstance <MembershipViewService>();
_container.GetMock <ICustomerRepository>()
.Setup(r => r.SendResetPasswordInstructionsAsync(It.Is <SendResetPasswordInstructionsParam>(p => p.Email == expectedEmail)))
.Returns(Task.FromResult(false));
//Act
var result = await membershipService.ForgotPasswordAsync(new ForgotPasswordParam
{
CultureInfo = TestingExtensions.GetRandomCulture(),
Scope = GetRandom.String(32),
Email = expectedEmail
});
//Assert
result.Status.Should().Be(MyAccountStatus.Success.ToString());
}
public void WHEN_Scope_Is_NullOrWhitespace_SHOULD_Throw_ArgumentException(string scope)
{
//Arrange
_container.Use(OvertureClientFactory.Create());
var cartRepository = _container.CreateInstance <CartRepository>();
var param = new RemoveLineItemParam
{
Scope = scope,
CultureInfo = TestingExtensions.GetRandomCulture(),
CustomerId = GetRandom.Guid(),
CartName = GetRandom.String(32),
LineItemId = GetRandom.Guid()
};
// Act
var exception = Assert.ThrowsAsync <ArgumentException>(() => cartRepository.RemoveLineItemAsync(param));
//Assert
exception.ParamName.Should().BeSameAs("param");
exception.Message.Should().Contain("param.Scope");
}
public void WHEN_CustomerId_is_Empty_SHOULD_throw_ArgumentException()
{
//Arrange
var customerId = Guid.Empty;
var membershipService = _container.CreateInstance <MembershipViewService>();
//Act
var ex = Assert.ThrowsAsync <ArgumentException>(() => membershipService.ChangePasswordAsync(
new ChangePasswordParam
{
CultureInfo = TestingExtensions.GetRandomCulture(),
CustomerId = customerId,
Scope = GetRandom.String(32),
NewPassword = GetRandom.String(32),
OldPassword = GetRandom.String(32)
}
));
//Assert
ex.Message.Should().ContainEquivalentOf("CustomerId");
}
public async Task WHEN_address_does_not_belong_to_the_customer_SHOULD_return_null()
{
//Arrange
var customer = MockCustomerFactory.CreateRandom();
var address = MockAddressFactory.CreateRandom();
customer.AddressIds = new List <Guid>
{
//no address
};
var mockedCustomerRepository = new Mock <ICustomerRepository>();
mockedCustomerRepository.Setup(r => r.GetCustomerByIdAsync(It.IsAny <GetCustomerByIdParam>()))
.ReturnsAsync(customer);
_container.Use(mockedCustomerRepository);
var mockedAddressRepository = new Mock <IAddressRepository>();
mockedAddressRepository.Setup(r => r.GetAddressByIdAsync(It.IsAny <Guid>()))
.ReturnsAsync(address);
_container.Use(mockedAddressRepository);
var customerViewService = _container.CreateInstance <CustomerAddressViewService>();
//Act
var param = new GetEditAddressViewModelAsyncParam
{
Scope = GetRandom.String(32),
CustomerId = Guid.NewGuid(),
CultureInfo = TestingExtensions.GetRandomCulture(),
AddressId = address.Id,
};
var viewModel = await customerViewService.GetEditAddressViewModelAsync(param);
//Assert
viewModel.Should().BeNull();
}
public async Task WHEN_requesting_to_log_in_valid_user_response_but_customer_id_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(MockMembershipUser(
GetRandom.Email(),
Guid.Empty,
GetRandom.Email(),
GetRandom.String(32),
GetRandom.String(32),
GetRandom.Boolean(),
GetRandom.Boolean(),
GetRandom.DateTime(),
GetRandom.DateTime(),
GetRandom.DateTime(),
GetRandom.DateTime(),
GetRandom.DateTime()
));
//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_Scope_Is_NullOrWhitespace_SHOULD_Throw_ArgumentException(string scope)
{
var service = _container.CreateInstance <CartService>();
var param = new AddLineItemParam
{
Scope = scope,
CultureInfo = TestingExtensions.GetRandomCulture(),
CustomerId = GetRandom.Guid(),
CartName = GetRandom.String(32),
ProductId = GetRandom.String(32),
VariantId = GetRandom.String(32),
Quantity = GetRandom.PositiveInt(),
BaseUrl = GetRandom.String(32)
};
// Act
var exception = Assert.ThrowsAsync <ArgumentException>(() => service.AddLineItemAsync(param));
//Assert
exception.ParamName.Should().BeSameAs("param");
exception.Message.Should().Contain("param.Scope");
}
public async Task WHEN_postal_code_matches_regex_SHOULD_result_not_be_null()
{
// Arrange
_container.Use(CountryServiceMock.Create(CanadianPostalCodeRegex));
var service = _container.CreateInstance <CartService>();
// Act
var result = await service.UpdateBillingAddressPostalCodeAsync(new UpdateBillingAddressPostalCodeParam
{
CultureInfo = TestingExtensions.GetRandomCulture(),
CustomerId = Guid.NewGuid(),
CartName = GetRandom.String(32),
BaseUrl = GetRandom.String(32),
Scope = GetRandom.String(32),
PostalCode = "J5R 5Y5",
CountryCode = GetRandom.String(1)
});
// Assert
result.Should().NotBeNull();
}
public void WHEN_Dependencies_Return_NullValues_SHOULD_Succeed()
{
var service = _container.CreateInstance <CartService>();
_container.Use(CartRepositoryFactory.CreateWithNullValues());
// Act
var result = service.AddLineItemAsync(new AddLineItemParam
{
Scope = GetRandom.String(32),
CultureInfo = TestingExtensions.GetRandomCulture(),
CustomerId = GetRandom.Guid(),
CartName = GetRandom.String(32),
ProductId = GetRandom.String(32),
VariantId = GetRandom.String(32),
Quantity = 1000,
BaseUrl = GetRandom.String(32)
}).Result;
// Assert
result.Should().NotBeNull();
}
public void WHEN_WishList_with_Items_SHOULD_setup_TotalQuantity()
{
//Arrange
var wishList = CreateWishListWithLineItems();
MockFixCartService();
_container.Use(WishListRepositoryFactory.CreateWithValues(wishList));
var service = _container.CreateInstance <WishListViewService>();
//Act
var vm = service.GetWishListViewModelAsync(new GetCartParam
{
Scope = "Canada",
BaseUrl = GetRandom.String(128),
CartName = "WishList",
CultureInfo = TestingExtensions.GetRandomCulture(),
CustomerId = Guid.NewGuid()
}).Result;
//Assert
vm.TotalQuantity.Should().Be(2);
}
public void WHEN_Id_Is_Empty_SHOULD_Throw_ArgumentException()
{
//Arrange
_container.Use(OvertureClientFactory.Create());
var cartRepository = _container.CreateInstance <CartRepository>();
var param = new RemoveLineItemParam
{
Scope = GetRandom.String(32),
CultureInfo = TestingExtensions.GetRandomCulture(),
CustomerId = GetRandom.Guid(),
CartName = GetRandom.String(32),
LineItemId = Guid.Empty
};
// Act
Expression <Func <Task <ProcessedCart> > > expression = () => cartRepository.RemoveLineItemAsync(param);
var exception = Assert.ThrowsAsync <ArgumentException>(() => expression.Compile().Invoke());
//Assert
exception.ParamName.Should().BeEquivalentTo(GetParamsInfo(expression)[0].Name);
exception.Message.Should().StartWith(GetMessageOfEmpty(nameof(param.LineItemId)));
}
public void WHEN_passing_empty_Scope_SHOULD_throw_ArgumentException(string scope)
{
//Arrange
var sut = _container.CreateInstance <MembershipViewService>();
sut.Membership = _container.Get <IMembershipProxy>();
var param = new LoginParam()
{
CultureInfo = TestingExtensions.GetRandomCulture(),
Password = GetRandom.String(15),
Username = GetRandom.Email(),
Scope = scope
};
// Act
Expression <Func <Task <LoginViewModel> > > expression = () => sut.LoginAsync(param);
var exception = Assert.ThrowsAsync <ArgumentException>(() => expression.Compile().Invoke());
//Assert
exception.ParamName.Should().BeEquivalentTo(GetParamsInfo(expression)[0].Name);
exception.Message.Should().StartWith(GetMessageOfNullWhiteSpace(nameof(param.Scope)));
}
public void WHEN_CustomerId_Is_Empty_SHOULD_Throw_ArgumentException()
{
var service = _container.CreateInstance <CartService>();
var param = new GetCartParam
{
Scope = GetRandom.String(32),
CultureInfo = TestingExtensions.GetRandomCulture(),
CustomerId = Guid.Empty,
CartName = GetRandom.String(32),
ExecuteWorkflow = GetRandom.Boolean(),
WorkflowToExecute = GetRandom.String(32),
BaseUrl = GetRandom.String(32)
};
// Act
Expression <Func <Task <CartViewModel> > > expression = () => service.GetCartViewModelAsync(param);
var exception = Assert.ThrowsAsync <ArgumentException>(() => expression.Compile().Invoke());
//Assert
exception.ParamName.Should().BeEquivalentTo(GetParamsInfo(expression)[0].Name);
exception.Message.Should().StartWith(GetMessageOfEmpty(nameof(param.CustomerId)));
}
public void WHEN_Dependencies_Return_NullValues_SHOULD_Succeed()
{
//Arrange
_container.Use(OvertureClientFactory.CreateWithNullValues());
var repository = _container.CreateInstance <CartRepository>();
// Act
var result = repository.UpdateLineItemAsync(new UpdateLineItemParam
{
ScopeId = GetRandom.String(32),
CultureInfo = TestingExtensions.GetRandomCulture(),
CustomerId = GetRandom.Guid(),
CartName = GetRandom.String(32),
LineItemId = GetRandom.Guid(),
Quantity = 1000,
GiftMessage = GetRandom.String(32),
GiftWrap = GetRandom.Boolean(),
}).Result;
// Assert
result.Should().NotBeNull();
}
public async Task WHEN_valid_request_SHOULD_return_customer()
{
//Arrange
var expectedCustomer = MockCustomerFactory.CreateRandom();
var expectedScope = GetRandom.String(32);
var expectedCultureInfo = TestingExtensions.GetRandomCulture();
var customerRepository = _container.CreateInstance <CustomerRepository>();
_container.GetMock <IOvertureClient>()
.Setup(r => r.SendAsync(It.Is <GetCustomerRequest>(
param => param.CustomerId == expectedCustomer.Id)))
.ReturnsAsync(expectedCustomer);
//3.8 upgrade
_container.GetMock <ICacheProvider>()
.Setup(provider => provider.GetOrAddAsync(
It.IsNotNull <CacheKey>(),
It.IsNotNull <Func <Task <Customer> > >(),
It.IsAny <Func <Customer, Task> >(),
It.IsAny <CacheKey>()))
.Returns <CacheKey, Func <Task <Customer> >, Func <Customer, Task>, CacheKey>(
(key, func, arg3, arg4) => func())
.Verifiable("This value must be proprelly cached by Id");
//Act
var customer = await customerRepository.GetCustomerByIdAsync(new GetCustomerByIdParam
{
CustomerId = expectedCustomer.Id,
Scope = expectedScope,
CultureInfo = expectedCultureInfo
});
//Assert
customer.Should().NotBeNull();
customer.Id.Should().Be(expectedCustomer.Id);
_container.GetMock <ICacheProvider>().VerifyAll();
}
public async Task WHEN_Membership_Accept_Empty_PasswordAnsnwer_SHOULD_succeed(string passwordAnswer)
{
//Arrange
var membershipService = _container.CreateInstance <MembershipViewService>();
membershipService.Membership = _container.Get <IMembershipProxy>();
_container.GetMock <MembershipProvider>()
.SetupGet(p => p.RequiresQuestionAndAnswer)
.Returns(false);
_container.GetMock <ICustomerRepository>()
.Setup(r => r.GetCustomerByTicketAsync(It.IsAny <string>()))
.ReturnsAsync(MockCustomerFactory.CreateRandom());
_container.GetMock <ICustomerRepository>()
.Setup(r => r.ResetPasswordAsync(
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.Is <string>(pa => pa == passwordAnswer)))
.Returns(Task.FromResult(false));
//Act
var result = await membershipService.ResetPasswordAsync(
new ResetPasswordParam
{
CultureInfo = TestingExtensions.GetRandomCulture(),
Ticket = GetRandom.String(1024),
Scope = GetRandom.String(32),
NewPassword = GetRandom.String(32),
PasswordAnswer = passwordAnswer
}
);
//Assert
result.Status.Should().Be(MyAccountStatus.Success.ToString());
}
public void WHEN_passing_empty_Scope_SHOULD_throw_ArgumentException(string scope)
{
//Arrange
var customerRepository = _container.CreateInstance <CustomerRepository>();
var param = 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 = scope
};
// Act
var exception = Assert.ThrowsAsync <ArgumentException>(() => customerRepository.CreateUserAsync(param));
//Assert
exception.Message.Should().Contain("Scope");
}
public void WHEN_Quantity_Is_Not_Positive_SHOULD_Throw_ArgumentOutOfRangeException(int quantity)
{
var service = _container.CreateInstance <CartService>();
var param = new AddLineItemParam
{
Scope = GetRandom.String(32),
CultureInfo = TestingExtensions.GetRandomCulture(),
CustomerId = GetRandom.Guid(),
CartName = GetRandom.String(32),
ProductId = GetRandom.String(32),
VariantId = GetRandom.String(32),
Quantity = quantity,
BaseUrl = GetRandom.String(32)
};
// Act
Expression <Func <Task <CartViewModel> > > expression = () => service.AddLineItemAsync(param);
var exception = Assert.ThrowsAsync <ArgumentOutOfRangeException>(() => service.AddLineItemAsync(param));
//Assert
exception.ParamName.Should().BeEquivalentTo(GetParamsInfo(expression)[0].Name);
exception.Message.Should().StartWith(GetMessageOfZeroNegative(nameof(param.Quantity)));
}
public async Task WHEN_user_does_not_exists_SHOULD_fail()
{
//Arrange
var expectedCustomerId = GetRandom.Guid();
var membershipService = _container.CreateInstance <MembershipViewService>();
_container.GetMock <ICustomerRepository>()
.Setup(r => r.GetCustomerByIdAsync(It.Is <GetCustomerByIdParam>(param => param.CustomerId == expectedCustomerId)))
.ReturnsAsync(null);
//Act
var result = await membershipService.ChangePasswordAsync(new ChangePasswordParam
{
CultureInfo = TestingExtensions.GetRandomCulture(),
CustomerId = expectedCustomerId,
Scope = GetRandom.String(32),
NewPassword = GetRandom.String(32),
OldPassword = GetRandom.String(32)
});
//Assert
result.Status.Should().Be(MyAccountStatus.Failed.ToString());
}
public async Task WHEN_requesting_to_log_in_invalid_user_response_SHOULD_be_false()
{
//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(false);
//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_Quantity_Is_Not_Positive_SHOULD_Throw_ArgumentException(int quantity)
{
// Arrange
_container.Use(OvertureClientFactory.Create());
var repository = _container.CreateInstance <CartRepository>();
var param = new AddLineItemParam
{
Scope = GetRandom.String(32),
CultureInfo = TestingExtensions.GetRandomCulture(),
CustomerId = GetRandom.Guid(),
CartName = GetRandom.String(32),
ProductId = GetRandom.String(32),
VariantId = GetRandom.String(32),
Quantity = quantity
};
// Act
var exception = Assert.ThrowsAsync <ArgumentException>(() => repository.AddLineItemAsync(param));
//Assert
exception.ParamName.Should().BeSameAs("param");
exception.Message.Should().Contain("param.Quantity");
}
