public void UpsertPromotion_Successful()
{
if (!VerifyPromoCodeTestsEnabled())
{
Assert.Ignore();
}
var upsertBasketResult = (Basket.Models.Basket)null;
Coupon coupon;
try
{
(upsertBasketResult, coupon) = PrepareUpsertPromotionRequest(
configuration["Basket:TestReferences:0"],
configuration["Basket:ValidPromoCode"]);
var basketDetails = service.UpsertPromotion(upsertBasketResult.Reference, coupon);
Assert.Null(upsertBasketResult.Coupon);
AssertExtension.AreObjectsValuesEqual(coupon, basketDetails.Coupon);
Assert.NotNull(basketDetails.AppliedPromotion);
}
finally
{
service.ClearBasket(upsertBasketResult?.Reference);
}
}
public void UpsertStandardAttributeByTitle_Successful()
{
var sourceAttribute = service.GetStandardAttributes().First();
var updatedAttribute = service.UpsertStandardAttributeByTitle(sourceAttribute);
AssertExtension.AreObjectsValuesEqual(sourceAttribute, updatedAttribute);
}
public void CreateClientWrapperParameters_ReturnsParametersWithInitializedHeaders(ApiContext context, Dictionary <string, string> expected)
{
var builder = new ApiRestClientBuilder();
var actual = builder.CreateClientWrapperParameters(context, It.IsAny <string>(), new ExecuteApiRequestParameters());
AssertExtension.AreObjectsValuesEqual(expected, actual.RequestHeaders);
}
public void CreateClientWrapper_ReturnsExpectedValue(ApiContext context, RestClientWrapper expected)
{
var builder = new ApiRestClientBuilder();
var actual = builder.CreateClientWrapper(context);
AssertExtension.AreObjectsValuesEqual(expected, actual);
}
public void Errors_ReturnsExpectedValue(IRestResponse response, Context context, List <string> expected)
{
var exception = new ApiException(response, It.IsAny <ApiContext>(), context, It.IsAny <Request>());
var actual = exception.Errors;
AssertExtension.AreObjectsValuesEqual(expected, actual);
}
private void AssertUpsertBasketSuccess(
UpsertBasketParameters request,
Basket.Models.Basket result,
int expectedReservationsCount)
{
AssertUpsertBasketSuccessCommon(result, request.Delivery, expectedReservationsCount);
Assert.AreEqual(request.ChannelId, result.ChannelId);
AssertExtension.AreObjectsValuesEqual(request.Coupon, result.Coupon);
}
public void BuildMany_WithoutNullParentKeys_Successful()
{
var item1 = new TreeItem(1, -1);
var item2 = new TreeItem(2, 1);
var result = ReadOnlyTree <int, TreeItem> .BuildAllTrees(new[] { item1, item2 }, item => item.Id, item => item.ParentId.Value).Single();
AssertExtension.AreObjectsValuesEqual(item1, result.Item);
}
public void GetLocations_IfApiResponseSuccessful_ReturnsLocations(
string responseContent,
List <Location> expected)
{
mockers.SetupSuccessfulExecution <ApiResponse <List <Location> > >(responseContent);
var actual = GetLocations();
AssertExtension.AreObjectsValuesEqual(expected, actual);
}
public void GetProductById_IfApiResponseSuccessful_ReturnsProduct(
string responseContent,
Product expected)
{
mockers.SetupSuccessfulExecution <ApiResponse <Product> >(responseContent);
var actual = GetProductById(TestProductValidId);
AssertExtension.AreObjectsValuesEqual(expected, actual);
}
public void Authenticate_DoesNotChangeContext(ApiContext context)
{
var sourceContext = TestHelper.CopyObject(context);
var service = new PredefinedJwtAuthenticationService(context, It.IsAny <string>(), It.IsAny <string>());
var updatedContext = service.Authenticate();
Assert.AreEqual(context, updatedContext);
AssertExtension.AreObjectsValuesEqual(sourceContext, updatedContext);
}
public void DeserializeString_IfJsonCanBeDeserialized_ReturnsCorrectObject <T>(string dateFormat, string json, T expected)
{
var serializer = new DefaultJsonSerializer {
DateFormat = dateFormat
};
var actual = serializer.Deserialize <T>(json);
AssertExtension.AreObjectsValuesEqual(expected, actual);
}
public void TotalAdjustmentInOfficeCurrency_Correct()
{
var reservation = new Reservation {
AdjustmentAmountInOfficeCurrency = DefaultPrice, Quantity = DefaultQuantity
};
var result = reservation.GetTotalAdjustmentAmountInOfficeCurrency();
AssertExtension.AreObjectsValuesEqual(DefaultPrice.MultiplyByNumber(DefaultQuantity), result);
}
public void AddOrGetExisting_IfDataWithKeyWasNotAddedAndLifeSpanIsNull_AddsDataForDefaultTimeAndReturnsData <T>(T data)
{
var cache = new MemoryCache();
var key = GetRandomKey();
var actual = cache.AddOrGetExisting(key, () => data, null);
Assert.True(cache.Contains(key));
AssertExtension.AreObjectsValuesEqual(data, actual);
}
public void TotalSalePriceInShopperCurrency_Correct()
{
var reservation = new Reservation {
SalePriceInShopperCurrency = DefaultPrice, Quantity = DefaultQuantity
};
var result = reservation.GetTotalSalePriceInShopperCurrency();
AssertExtension.AreObjectsValuesEqual(DefaultPrice.MultiplyByNumber(DefaultQuantity), result);
}
public void Checkout_IfApiResponseSuccessful_ReturnsPaymentInfo(
string responseContent,
PaymentInfo expected)
{
mockers.SetupSuccessfulExecution <ApiResponse <PaymentInfo> >(responseContent);
var actual = Checkout(TestValidBookingParameters);
AssertExtension.AreObjectsValuesEqual(expected, actual);
}
public void SaveResponseInfoInApiContext_SetsInfoInApiContext(
ApiContext sourceContext,
RestResponseInformation information,
ApiContext expectedContext)
{
var builder = new ApiRestClientBuilder();
builder.SaveResponseInfoInApiContext(information, sourceContext);
AssertExtension.AreObjectsValuesEqual(expectedContext, sourceContext);
}
public void Get_IfDataWithKeyWasAddedAndTryToGetDataWithSameType_ReturnsData <T>(T data)
{
var cache = new MemoryCache();
var key = GetRandomKey();
cache.Set(key, () => data, null);
var result = cache.Get <T>(key);
AssertExtension.AreObjectsValuesEqual(data, result);
}
public void Serialize_ReturnsCorrectJson <T>(string dateFormat, NamingStrategy enumNamingStrategy, T item, string expected)
{
var serializer = new DefaultJsonSerializer(enumNamingStrategy)
{
DateFormat = dateFormat
};
var actual = serializer.Serialize(item);
AssertExtension.AreObjectsValuesEqual(expected, actual);
}
public void BuildMany_Successful()
{
var testData = CreateTestData();
var result = ReadOnlyTree <int?, TreeItem> .BuildAllTrees(testData.SetupList, item => item.Id, item => item.ParentId).ToList();
Assert.AreEqual(testData.ExpectedParents.Count, result.Count);
for (int i = 0; i < result.Count; i++)
{
AssertExtension.AreObjectsValuesEqual(testData.ExpectedParents[i], result[i].Item);
}
}
public void CreateClientWrapperParameters_IfSerializerIsSet_ReturnsParametersWithInitializedSerializerAndRequestDataFormat(
ExecuteApiRequestParameters parameters,
ISerializer expectedSerializer,
DataFormat expectedDataFormat)
{
var builder = new ApiRestClientBuilder();
var actual = builder.CreateClientWrapperParameters(It.IsAny <ApiContext>(), It.IsAny <string>(), parameters);
AssertExtension.AreObjectsValuesEqual(expectedSerializer, actual.RequestDataSerializer);
Assert.AreEqual(expectedDataFormat, actual.RequestDataFormat);
}
private void TestSuccessfulAction <T>(Func <T> action, T expectedResult)
where T : class
{
var serializedExpectedResult = serializer.Serialize(expectedResult);
var responseContent = string.Format(SuccessfulResponseTemplate, serializedExpectedResult);
mocker.SetupSuccessfulExecution <ApiResponse <T> >(responseContent);
var result = action();
AssertExtension.AreObjectsValuesEqual(expectedResult, result);
}
public void DeserializeRestResponse_IfJsonCanBeDeserialized_ReturnsCorrectObject <T>(string dateFormat, string json, T expected)
{
var response = new RestResponse <T> {
Content = json
};
var serializer = new DefaultJsonSerializer {
DateFormat = dateFormat
};
var actual = serializer.Deserialize <T>(response);
AssertExtension.AreObjectsValuesEqual(expected, actual);
}
public void AddOrGetExisting_IfDataWithKeyWasNotAddedAndLifeSpanIsSet_AddsDataForCertainTimeAndReturnsData <T>(T data)
{
var cache = new MemoryCache();
var key = GetRandomKey();
var lifeTime = new TimeSpan(0, 0, 0, 0, 100);
var actual = cache.AddOrGetExisting(key, () => data, lifeTime);
Assert.True(cache.Contains(key));
AssertExtension.AreObjectsValuesEqual(data, actual);
Thread.Sleep(lifeTime);
Assert.False(cache.Contains(key));
}
public void Traverse_Successful()
{
var testData = CreateTestData();
var trees = ReadOnlyTree <int?, TreeItem> .BuildAllTrees(testData.SetupList, item => item.Id, item => item.ParentId).ToList();
var result = trees.SelectMany(tree => tree.Traverse()).ToList();
Assert.AreEqual(testData.ExpectedTraversalList.Count, result.Count);
for (int i = 0; i < result.Count; i++)
{
AssertExtension.AreObjectsValuesEqual(testData.ExpectedTraversalList[i], result[i]);
}
}
private void AssertUpsertBasketSuccessCommon(
Basket.Models.Basket result,
Delivery sourceDelivery,
int expectedReservationsCount)
{
Assert.AreEqual(sourceDelivery.Method, result.Delivery.Method);
AssertExtension.AreObjectsValuesEqual(sourceDelivery.Charge, result.Delivery.Charge);
Assert.NotNull(result.Reference);
Assert.NotNull(result.Checksum);
Assert.NotNull(result.Reservations);
Assert.AreEqual(expectedReservationsCount, result.Reservations.Count);
if (VerifyPromoCodeTestsEnabled())
{
Assert.NotNull(result.AppliedPromotion);
}
}
public void Prepend_Successful()
{
var item = new { Id = 1, Value = "string1" };
var originalList = new List <object>
{
new { Id = 2, Value = "string2" },
null,
new { Id = 3, Value = "string3" },
};
var result = EnumerableExtension.Prepend(originalList, item).ToList();
Assert.AreEqual(originalList.Count + 1, result.Count);
AssertExtension.AreObjectsValuesEqual(item, result[0]);
for (int i = 0; i < originalList.Count; i++)
{
AssertExtension.AreObjectsValuesEqual(originalList[i], result[i + 1]);
}
}
public void ExcludeEmptyStrings_ReturnsCorrectly(IEnumerable <string> source, IEnumerable <string> expected)
{
var actual = source.ExcludeEmptyStrings();
AssertExtension.AreObjectsValuesEqual(expected, actual);
}
public void NullIfEmptyEnumerable_IfSourceEnumerableIsNotNull_ReturnsCorrectly <T>(IEnumerable <T> source, List <T> expected)
{
var actual = source.NullIfEmptyEnumerable();
AssertExtension.AreObjectsValuesEqual(expected, actual);
}
public void AreObjectsValuesEqual_AssertsCorrectly <T>(T expected, T actual)
{
Assert.DoesNotThrow(() => AssertExtension.AreObjectsValuesEqual(expected, actual));
}
public void AreObjectsValuesEqual_ThrowsAssertionException <T>(T expected, T actual)
{
Assert.Throws <AssertionException>(() => AssertExtension.AreObjectsValuesEqual(expected, actual));
}
