public async Task WHEN_Cart_has_no_valid_fulfillmentLocationId_SHOULD_invoke_UpdateShipment()
{
//Arrange
_container.Use(OvertureClientFactory.Create());
var sut = _container.CreateInstance <FixCartService>();
//Act
await sut.FixCartAsync(new FixCartParam
{
Cart = new ProcessedCart
{
CultureName = "en-US",
Payments = new List <Payment>
{
new Payment()
},
Shipments = new List <Shipment>
{
new Shipment()
}
}
});
//Assert
_container.Verify <ICartRepository>(r => r.UpdateShipmentAsync(It.IsNotNull <UpdateShipmentParam>()));
}
public void WHEN_Scope_Is_NullOrWhitespace_SHOULD_Throw_ArgumentException(string scope)
{
// Arrange
_container.Use(OvertureClientFactory.Create());
var repository = _container.CreateInstance <CartRepository>();
var param = new UpdateLineItemParam
{
ScopeId = null,
CultureInfo = TestingExtensions.GetRandomCulture(),
CustomerId = GetRandom.Guid(),
CartName = GetRandom.String(32),
LineItemId = GetRandom.Guid(),
Quantity = GetRandom.PositiveInt(),
GiftMessage = GetRandom.String(32),
GiftWrap = GetRandom.Boolean(),
};
// Act
Expression <Func <Task <ProcessedCart> > > expression = () => repository.UpdateLineItemAsync(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.ScopeId)));
}
public async Task WHEN_Cart_already_has_fullfillmentLocationId_SHOULD_not_invoke_UpdateShipment()
{
//Arrange
_container.Use(OvertureClientFactory.CreateMockWithValue(_dummyCart));
var sut = _container.CreateInstance <FixCartService>();
//Act
var cart = await sut.FixCartAsync(new FixCartParam
{
Cart = new ProcessedCart
{
Payments = new List <Payment>
{
new Payment()
},
Shipments = new List <Shipment>
{
new Shipment
{
FulfillmentLocationId = Guid.NewGuid()
}
}
}
});
//Assert
cart.Should().NotBeNull();
_container.Verify <ICartRepository>(r => r.UpdateShipmentAsync(It.IsNotNull <UpdateShipmentParam>()), Times.Never());
}
public void WHEN_Param_Is_NullOrWhitespace_SHOULD_Throw_ArgumentException(string scope, string cultureName,
string cartName, string customerId, string productId, int quantity, string paramName)
{
// Arrange
_container.Use(OvertureClientFactory.Create());
var repository = _container.CreateInstance <WishListRepository>();
var param = new AddLineItemParam
{
Scope = scope,
CultureInfo =
string.IsNullOrWhiteSpace(cultureName) ? null : CultureInfo.GetCultureInfo(cultureName),
CustomerId = string.IsNullOrWhiteSpace(customerId) ? Guid.Empty : GetRandom.Guid(),
CartName = cartName,
ProductId = productId,
VariantId = GetRandom.String(10),
Quantity = quantity
};
// Act
var exception = Assert.ThrowsAsync <ArgumentException>(() => repository.AddLineItemAsync(param));
//Assert
exception.ParamName.Should().BeSameAs("param");
exception.Message.Should().Contain(paramName);
}
public void WHEN_Passing_Null_Parameters_SHOULD_Throw_ArgumentNullException()
{
//Arrange
_container.Use(OvertureClientFactory.Create());
var cartRepository = _container.CreateInstance <WishListRepository>();
// Act
Expression <Func <Task <ProcessedCart> > > expression = () => cartRepository.RemoveLineItemAsync(null);
var exception = Assert.ThrowsAsync <ArgumentNullException>(() => expression.Compile().Invoke());
//Assert
exception.ParamName.Should().BeEquivalentTo(GetParamsInfo(expression)[0].Name);
}
public void WHEN_Passing_Null_Parameters_SHOULD_Throw_ArgumentNullException()
{
// Arrange
_container.Use(OvertureClientFactory.Create());
var repository = _container.CreateInstance <CartRepository>();
// Act
var exception = Assert.ThrowsAsync <ArgumentNullException>(() => repository.UpdateLineItemAsync(null));
//Assert
exception.ParamName.Should().BeSameAs("param");
exception.Message.Should().Contain("param");
}
public void WHEN_Dependencies_Return_NullValues_SHOULD_Succeed()
{
// Arrange
_container.Use(OvertureClientFactory.CreateWithNullValues());
// Act
var result = _repository.RetrieveCountry(new RetrieveCountryParam
{
IsoCode = GetRandom.String(32),
CultureInfo = TestingExtensions.GetRandomCulture()
}).Result;
// Assert
result.Should().NotBeNull();
}
public void WHEN_IsoCode_Is_NullOrWhitespace_SHOULD_Throw_ArgumentException(string isoCode)
{
// Arrange
_container.Use(OvertureClientFactory.Create());
var param = new RetrieveCountryParam
{
IsoCode = isoCode,
CultureInfo = TestingExtensions.GetRandomCulture()
};
// Act
var exception = Assert.ThrowsAsync <ArgumentException>(() => _repository.RetrieveCountry(param));
//Assert
exception.ParamName.Should().BeSameAs("param");
exception.Message.Should().Contain("IsoCode");
}
public async Task WHEN_Dependencies_Return_Null_Values_SHOULD_Succeed()
{
//Arrange
Container.Use(OvertureClientFactory.CreateWithNullValues());
var repository = Container.CreateInstance <CartRepository>();
//Act
var result = await repository.CompleteCheckoutAsync(new CompleteCheckoutParam
{
CartName = GetRandom.String(10),
CultureInfo = CultureInfo.CurrentCulture,
CustomerId = GetRandom.Guid(),
Scope = GetRandom.String(10),
});
// Assert
result.Should().NotBeNull();
}
public async Task WHEN_Dependencies_Return_NullValues_SHOULD_Succeed()
{
//Arrange
_container.Use(OvertureClientFactory.CreateWithNullValues());
var cartRepository = _container.CreateInstance <CartRepository>();
// Act
var result = await cartRepository.RemoveLineItemAsync(new RemoveLineItemParam
{
Scope = GetRandom.String(32),
CultureInfo = TestingExtensions.GetRandomCulture(),
CustomerId = GetRandom.Guid(),
CartName = GetRandom.String(32),
LineItemId = GetRandom.Guid()
});
// Assert
result.Should().NotBeNull();
}
public void WHEN_Dependencies_Return_NullValues_SHOULD_Succeed()
{
//Arrange
_container.Use(OvertureClientFactory.CreateWithNullValues());
var cartRepository = _container.CreateInstance <CartRepository>();
// Act
var result = cartRepository.GetCartsByCustomerIdAsync(new GetCartsByCustomerIdParam
{
Scope = GetRandom.String(32),
CultureInfo = TestingExtensions.GetRandomCulture(),
CustomerId = GetRandom.Guid(),
IncludeChildScopes = GetRandom.Boolean()
}).Result;
// Assert
result.Should().NotBeNull();
result.Should().NotBeEmpty();
result.Should().HaveCount(1);
}
public void WHEN_CultureInfo_Is_Null_SHOULD_Throw_ArgumentException()
{
//Arrange
_container.Use(OvertureClientFactory.Create());
var cartRepository = _container.CreateInstance <CartRepository>();
var param = new GetCartsByCustomerIdParam
{
Scope = GetRandom.String(32),
CultureInfo = null,
CustomerId = GetRandom.Guid(),
IncludeChildScopes = GetRandom.Boolean()
};
// Act
var exception = Assert.ThrowsAsync <ArgumentException>(() => cartRepository.GetCartsByCustomerIdAsync(param));
//Assert
exception.ParamName.Should().BeSameAs("param");
exception.Message.Should().Contain("param.CultureInfo");
}
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_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_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_CustomerId_Is_Empty_SHOULD_Throw_ArgumentException()
{
// Arrange
_container.Use(OvertureClientFactory.Create());
var repository = _container.CreateInstance <WishListRepository>();
var param = new GetCartParam
{
Scope = "Canada",
CultureInfo = CultureInfo.GetCultureInfo("en-CA"),
CustomerId = Guid.Empty,
CartName = "WishList"
};
// Act
Expression <Func <Task <ProcessedCart> > > expression = () => repository.GetWishListAsync(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_CultureInfo_Is_Null_SHOULD_Throw_ArgumentException()
{
//Arrange
_container.Use(OvertureClientFactory.Create());
var cartRepository = _container.CreateInstance <CartRepository>();
var param = new GetCartsByCustomerIdParam
{
Scope = GetRandom.String(32),
CultureInfo = null,
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(GetMessageOfNull(nameof(param.CultureInfo)));
}
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 void WHEN_CultureInfo_Is_Null_SHOULD_Throw_ArgumentException()
{
// Arrange
_container.Use(OvertureClientFactory.Create());
var repository = _container.CreateInstance <WishListRepository>();
var param = new RemoveLineItemParam
{
Scope = "Canada",
CultureInfo = null,
CustomerId = Guid.NewGuid(),
CartName = "WishList",
LineItemId = Guid.NewGuid()
};
// Act
Expression <Func <Task <ProcessedCart> > > expression = () => repository.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.CultureInfo)));
}
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_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");
}
public void WHEN_CultureInfo_Is_Null_SHOULD_Throw_ArgumentException()
{
// Arrange
_container.Use(OvertureClientFactory.Create());
var repository = _container.CreateInstance <CartRepository>();
var param = new AddLineItemParam
{
Scope = GetRandom.String(32),
CultureInfo = null,
CustomerId = GetRandom.Guid(),
CartName = GetRandom.String(32),
ProductId = GetRandom.String(32),
VariantId = GetRandom.String(32),
Quantity = GetRandom.Int(1, 100)
};
// Act
var exception = Assert.ThrowsAsync <ArgumentException>(() => repository.AddLineItemAsync(param));
//Assert
exception.ParamName.Should().BeSameAs("param");
exception.Message.Should().Contain("param.CultureInfo");
}
public void WHEN_Scope_Is_NullOrWhitespace_SHOULD_Throw_ArgumentException(string scope)
{
// Arrange
_container.Use(OvertureClientFactory.Create());
var repository = _container.CreateInstance <CartRepository>();
var param = new UpdateLineItemParam
{
ScopeId = null,
CultureInfo = TestingExtensions.GetRandomCulture(),
CustomerId = GetRandom.Guid(),
CartName = GetRandom.String(32),
LineItemId = GetRandom.Guid(),
Quantity = GetRandom.PositiveInt(),
GiftMessage = GetRandom.String(32),
GiftWrap = GetRandom.Boolean(),
};
// Act
var exception = Assert.ThrowsAsync <ArgumentException>(() => repository.UpdateLineItemAsync(param));
//Assert
exception.ParamName.Should().BeSameAs("param");
exception.Message.Should().Contain("param.ScopeId");
}
public void WHEN_Quantity_Is_Not_Positive_SHOULD_Throw_ArgumentOutOfRangeException(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
Expression <Func <Task <ProcessedCart> > > expression = () => repository.AddLineItemAsync(param);
var exception = Assert.ThrowsAsync <ArgumentOutOfRangeException>(() => expression.Compile().Invoke());
//Assert
exception.ParamName.Should().BeEquivalentTo(GetParamsInfo(expression)[0].Name);
exception.Message.Should().StartWith(GetMessageOfZeroNegative(nameof(param.Quantity)));
}
public void WHEN_CultureInfo_Is_Null_SHOULD_Throw_ArgumentException()
{
// Arrange
_container.Use(OvertureClientFactory.Create());
var repository = _container.CreateInstance <CartRepository>();
var param = new AddLineItemParam
{
Scope = GetRandom.String(32),
CultureInfo = null,
CustomerId = GetRandom.Guid(),
CartName = GetRandom.String(32),
ProductId = GetRandom.String(32),
VariantId = GetRandom.String(32),
Quantity = GetRandom.Int(1, 100)
};
// Act
Expression <Func <Task <ProcessedCart> > > expression = () => repository.AddLineItemAsync(param);
var exception = Assert.ThrowsAsync <ArgumentException>(() => expression.Compile().Invoke());
//Assert
exception.ParamName.Should().BeEquivalentTo(GetParamsInfo(expression)[0].Name);
exception.Message.Should().StartWith(GetMessageOfNull(nameof(param.CultureInfo)));
}
public void WHEN_ProductId_Is_NullOrWhitespace_SHOULD_Throw_ArgumentException(string productId)
{
// Arrange
_container.Use(OvertureClientFactory.Create());
var repository = _container.CreateInstance <WishListRepository>();
var param = new AddLineItemParam
{
Scope = "Canada",
CultureInfo = CultureInfo.GetCultureInfo("en-CA"),
CustomerId = Guid.NewGuid(),
CartName = "WishList",
ProductId = productId,
VariantId = "VariantId",
Quantity = 1
};
// Act
Expression <Func <Task <ProcessedCart> > > expression = () => repository.AddLineItemAsync(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.ProductId)));
}
