public async Task PATCH_AccountMaster_Success()
{
string externalIdentifier = "patchAccountMaster01";
AccountMasterTestData testData = new AccountMasterTestData
{
ExternalIdentifier = externalIdentifier
};
//test scenario setup
await TestScenarioSetUp(testData);
//TODO:
//properies to patch
var request = new
{
UpdatedBy = "patch request",
Name = "name patched"
};
HttpResponseExtended <AccountMasterResponse> response = await Client.AccountMasters.PatchEntity(externalIdentifier, request);
//validations
Assert.IsNotNull(response);
Assert.AreEqual(200, response.StatusCode);
Assert.IsTrue(response.Success);
Assert.IsNotNull(response.Result);
//patch specific validations
Assert.AreEqual(request.Name, response.Result.Name);
Assert.AreEqual(request.UpdatedBy, response.Result.UpdatedBy);
//test scenario clean up
await TestScenarioCleanUp(testData);
}
public async Task DELETE_User_Success()
{
string userExtId = "deleteUserSuccess01";
UserTestData testData = new UserTestData
{
ExternalIdentifier = userExtId,
AccountMasterExtId = "deleteUserAccountSuccess01",
ContactExtId = "deleteUserContactSuccess01",
LoginExtId = "deleteUserLoginSuccess01"
};
//test scenario setup
await TestScenarioSetUp(testData);
HttpResponseExtended <UserResponse> response = await Client.Users.Remove(userExtId);
//validations
Assert.IsNotNull(response, "Response object is null");
Assert.AreEqual(200, response.StatusCode);
Assert.IsTrue(response.Success, "Response status is not successful");
//result object has the deleted entity
//Assert.IsNull(response.Result, "result object should be null");
//delete entity dependencies
await TestScenarioCleanUp(testData);
}
//TODO
//pending
//[TestMethod]
public async Task PATCH_PriceLists()
{
string externalIdentifier = "patchPriceList02";
AccountMasterTestData testData = new AccountMasterTestData
{
ExternalIdentifier = externalIdentifier
};
await TestScenarioSetUp(testData);
//TODO:
//precondition
//create priceLists to add
//string item1 = "priceList01";
//string item2 = "priceList02";
//string item3 = "priceList03";
//var request = new { PriceListIds = new List<string> { item3, item1, item2 } };
var request = new { Name = "asdasd" };
HttpResponseExtended <AccountMasterResponse> response = await Client.AccountMasters.PatchEntity(externalIdentifier, request);
//validations
Assert.IsNotNull(response);
Assert.AreEqual(200, response.StatusCode);
Assert.IsTrue(response.Success);
Assert.IsNotNull(response.Result);
//specific validations
//Assert.IsNotNull(response.Result.PriceLists);
//Assert.AreEqual(response.Result.PriceLists.IndexOf(item3), 0);
//Assert.AreEqual(response.Result.PriceLists.IndexOf(item1), 1);
//Assert.AreEqual(response.Result.PriceLists.IndexOf(item2), 2);
//test scenario clean up
await TestScenarioCleanUp(testData);
}
public async Task DELETE_Contact_Success()
{
string externalIdentifier = "deleteContactSuccess01";
ContactTestData testData = new ContactTestData
{
ExternalIdentifier = externalIdentifier,
AccountMasterExtId = "deleteContactAccountMaster01"
};
//test scenario setup
await TestScenarioSetUp(testData);
HttpResponseExtended <ContactResponse> response = await Client.Contacts.Remove(externalIdentifier);
//validations
Assert.IsNotNull(response, "Response object is null");
Assert.AreEqual(200, response.StatusCode);
Assert.IsTrue(response.Success, "Response status is not successful");
//TODO
//review this
//Assert.IsNull(response.Result, "result object should be null");
//test scenario clean up
await TestScenarioCleanUp(testData);
}
public async Task ClearOfferingProduct()
{
string platformIdentifier = PlatformId;
string platformName = ServiceConstants.FMPPlatformName;
IntegrationsWebAppClient integrationsClientV2 = new IntegrationsWebAppClient(ServiceConstants.IntegrationsAPIUrl, platformName);
DeleteProductRequest deleteProductRequest = new DeleteProductRequest
{
ExternalIdentifier = ProductExternalId
};
HttpResponseExtended <ProductResponse> deleteProductResponse = await integrationsClientV2.Products.Remove(deleteProductRequest);
Assert.IsTrue(deleteProductResponse.Success, $"Response on product should be 204, got {deleteProductResponse.StatusCode}");
Assert.IsNull(deleteProductResponse.ErrorMessage, $"{nameof(deleteProductResponse.ErrorMessage)} should be null");
DeleteOfferingRequest deleteOfferingRequest = new DeleteOfferingRequest
{
ExternalIdentifier = OfferingExternalId
};
HttpResponseExtended <OfferingResponse> deleteOfferingResponse = await integrationsClientV2.Offering.Remove(deleteOfferingRequest);
Assert.IsNotNull(deleteOfferingResponse, $"{nameof(deleteOfferingResponse)} should not be null");
Assert.IsTrue(deleteOfferingResponse.Success, $"Status code on offering is: {deleteOfferingResponse.StatusCode}");
}
public async Task PATCH_Category_Success()
{
string externalIdentifier = "patchCategory01";
//test scenario setup
CategoryTestData testData = new CategoryTestData
{
ExternalIdentifier = externalIdentifier,
CatalogExtId = "patchCatalogCategory01"
};
await TestScenarioSetUp(testData);
var request = new
{
UpdatedBy = "successfully patched",
FullName = "full name patched",
ThumbnailImage = "imageurl"
};
HttpResponseExtended <CategoryResponse> response = await Client.Categories.PatchEntity(externalIdentifier, request);
Assert.IsNotNull(response, $"{nameof(response)} should not be null");
Assert.IsTrue(response.Success, $"Status code is: {response.StatusCode}");
//specific validations
Assert.AreEqual(request.FullName, response.Result.FullName);
Assert.AreEqual(request.UpdatedBy, response.Result.UpdatedBy);
Assert.AreEqual(request.ThumbnailImage, response.Result.ThumbnailImage);
//test scenario clean up
await TestScenarioCleanUp(testData);
}
public async Task PUT_PriceList_Success()
{
string externalIdentifier = "putCase01";
//scenario setup
PriceListTestData testData = new PriceListTestData
{
ExternalIdentifier = externalIdentifier
};
await TestScenarioSetUp(testData);
PriceListRequest request = new PriceListRequest
{
Name = "patched name ;)",
UpdatedBy = "put automated request",
Identifier = "identifier_updated"
};
HttpResponseExtended <PriceListResponse> response = await Client.PriceLists.Update(externalIdentifier, request);
//validations
Assert.IsNotNull(response);
Assert.AreEqual(200, response.StatusCode);
Assert.IsTrue(response.Success);
Assert.IsNotNull(response.Result);
//validate that all properties has been updated
Assert.AreEqual(request.Name, response.Result.Name);
Assert.AreEqual(request.UpdatedBy, response.Result.UpdatedBy);
Assert.AreEqual(externalIdentifier, response.Result.ExternalIdentifier);
Assert.AreNotEqual(request.Identifier, response.Result.ExternalIdentifier);
//test scenario clean up
await TestScenarioSetUp(testData);
}
public async Task DELETE_Category_Success()
{
string externalIdentifier = "deleteCategory01";
//test scenario setup
CategoryTestData testData = new CategoryTestData
{
ExternalIdentifier = externalIdentifier,
CatalogExtId = "deleteCategoryCatalog01"
};
await TestScenarioSetUp(testData);
HttpResponseExtended <CategoryResponse> response = await Client.Categories.Remove(externalIdentifier);
Assert.IsNotNull(response, $"{nameof(response)} should not be null");
Assert.IsTrue(response.Success, $"Response status is not successful");
Assert.AreEqual(200, response.StatusCode);
//TODO
//delete specific validations
//test scenario clean up
await TestScenarioCleanUp(testData);
}
public async Task POST_PriceList_Success()
{
string externalIdentifier = "postPricelistCase01";
PriceListTestData testData = new PriceListTestData
{
ExternalIdentifier = externalIdentifier
};
PriceListRequest request = new PriceListRequest
{
Name = "Pricelist name",
Identifier = externalIdentifier,
CreatedBy = "post request"
};
HttpResponseExtended <PriceListResponse> response = await Client.PriceLists.Create(request);
//validations
Assert.IsNotNull(response);
Assert.AreEqual(200, response.StatusCode);
Assert.IsTrue(response.Success);
Assert.IsNotNull(response.Result);
//validate that all props are assigned in the response
Assert.AreEqual(request.Name, response.Result.Name);
Assert.AreEqual(request.CreatedBy, response.Result.CreatedBy);
Assert.AreEqual(request.Identifier, response.Result.ExternalIdentifier);
//scenario clean up
await TestScenarioCleanUp(testData);
}
public async Task PATCH_PriceList_Success()
{
string externalIdentifier = "patchPriceListCase01";
//scenario setup
PriceListTestData testData = new PriceListTestData
{
ExternalIdentifier = externalIdentifier
};
await TestScenarioSetUp(testData);
var request = new
{
Name = "patched q:",
UpdatedBy = "patch request"
};
HttpResponseExtended <PriceListResponse> response = await Client.PriceLists.PatchEntity(externalIdentifier, request);
//validations
Assert.IsNotNull(response);
Assert.AreEqual(200, response.StatusCode);
Assert.IsTrue(response.Success);
Assert.IsNotNull(response.Result);
//check that the prop has been patched
Assert.AreEqual(request.Name, response.Result.Name);
//TODO
//review this property is not patched
//Assert.AreEqual(request.UpdatedBy, response.Result.UpdatedBy);
//test scenario clean up
await TestScenarioCleanUp(testData);
}
public async Task DELETE_Offering_Success()
{
string externalIdentifier = "deleteOffering01";
OfferingTestData testData = new OfferingTestData
{
OfferingExtId = externalIdentifier,
BrandExtId = "deleteOfferingBrand01",
ProductExtId = "deleteOfferingProduct01",
CatalogExtId = "deleteOfferingCatalog01",
CategoryExtId = "deleteOfferingCategory01"
};
//test scenario setup
await TestScenarioSetUp(testData);
HttpResponseExtended <OfferingResponse> response = await Client.Offerings.Remove(externalIdentifier);
Assert.IsNotNull(response, $"{nameof(response)} should not be null");
Assert.AreEqual(204, response.StatusCode);
Assert.IsTrue(response.Success, $"Status code is: {response.StatusCode}");
//delete specific validations
var getResponse = await Client.Offerings.GetSingle(externalIdentifier);
Assert.AreEqual(404, getResponse.StatusCode);
Assert.IsNull(getResponse.Result);
//test data clean up
await TestScenarioCleanUp(testData);
}
public async Task GET_Offering_Success()
{
string externalIdentifier = "getOffering01";
OfferingTestData testData = new OfferingTestData
{
OfferingExtId = externalIdentifier,
CatalogExtId = "getOfferingCatalog01",
BrandExtId = "getOfferingBrand01",
ProductExtId = "getOfferingProduct01",
CategoryExtId = "getOfferingCategory01"
};
//test scenario setup
await TestScenarioSetUp(testData);
HttpResponseExtended <OfferingResponse> response = await Client.Offerings.GetSingle(externalIdentifier);
//validations
Assert.IsNotNull(response, "The response object is null");
Assert.AreEqual(200, response.StatusCode);
Assert.IsNotNull(response.Result, "The result object is null");
Assert.AreEqual(externalIdentifier, response.Result.ExternalIdentifier);
//test data clean up
await TestScenarioCleanUp(testData);
}
public async Task POST_Login_Success()
{
string externalIdentifier = "postLoginSuccess01";
LoginTestData testData = new LoginTestData
{
ExternalIdentifier = externalIdentifier
};
LoginRequest request = new LoginRequest
{
CreatedBy = "post success req",
ExternalIdentifier = externalIdentifier,
IsEnabled = true,
UserName = "******",
Email = "*****@*****.**",
PasswordHash = "", //todo
PasswordSalt = "" //todo
};
HttpResponseExtended <LoginResponse> response = await Client.Logins.Create(request);
//validations
Assert.IsNotNull(response, "Response object should not be null");
Assert.AreEqual(200, response.StatusCode);
Assert.IsNotNull(response.Result, "result object should not be null");
Assert.IsTrue(response.Success, "Repsonse status is not successful");
//clean the entity
await TestScenarioCleanUp(testData);
}
public async Task PATCH_Product_Success()
{
string externalIdentifier = "patchProductExternalId01";
//test scenario setup
ProductTestData testData = new ProductTestData
{
ExternalIdentifier = externalIdentifier,
BrandExtId = "patchProduct01"
};
await TestScenarioSetUp(testData);
var request = new
{
Name = "patched name",
UpdatedBy = "Me ;3",
DisplayProductCode = "patched;3"
};
HttpResponseExtended <ProductResponse> response = await Client.Products.PatchEntity(externalIdentifier, request);
Assert.IsNotNull(response, $"{nameof(response)} is null o:");
Assert.AreEqual(200, response.StatusCode);
Assert.IsTrue(response.Success, $"Current status response: {response.StatusCode}");
Assert.IsNotNull(response.Result, "Result object should not be null");
//patch validations
Assert.AreEqual(request.UpdatedBy, response.Result.UpdatedBy);
Assert.AreEqual(request.Name, response.Result.Name);
Assert.AreEqual(request.DisplayProductCode, response.Result.DisplayProductCode);
//test scenario clean up
await TestScenarioCleanUp(testData);
}
public async Task PUT_AccountMaster_Not_Found()
{
string externalIdentifier = "putAccountMasterCase03";
AccountMasterRequest request = new AccountMasterRequest
{
CreateAccount = true,
UseAccountTermsAsDefaultPayment = true,
TaxIdentifier = "asd",
UpdatedBy = "http test",
ExternalData = "nada",
GroupIdentifier = "asd",
Identifier = externalIdentifier,
IsWebEnabled = true,
Name = "http test",
ProductPriceDiscount = 105,
TermsConfiguration = new AccountMasterTermConfiguration
{
HasPaymentTerms = true,
TermsDescription = "29 days ;)"
}
};
HttpResponseExtended <AccountMasterResponse> response = await Client.AccountMasters.Update(externalIdentifier, request);
//validations
Assert.IsNotNull(response);
Assert.AreEqual(404, response.StatusCode);
Assert.IsFalse(response.Success);
Assert.IsNull(response.Result);
}
public async Task GET_User_Success()
{
string userExtId = "getUserSuccess01";
UserTestData testData = new UserTestData
{
ExternalIdentifier = userExtId,
AccountMasterExtId = "getUserAccountSuccess01",
LoginExtId = "getUserLoginSuccess01",
ContactExtId = "getUserContactSuccess01"
};
//test scenario setup
await TestScenarioSetUp(testData);
HttpResponseExtended <UserResponse> response = await Client.Users.GetSingle(userExtId);
//validations
Assert.IsNotNull(response, "Response is null");
Assert.AreEqual(200, response.StatusCode);
Assert.IsTrue(response.Success, "Response status is not successful");
Assert.IsNotNull(response.Result, "result object should not be null");
//test scenario clean up
await TestScenarioCleanUp(testData);
}
public async Task <HttpResponseExtended <ProductResponse> > Create(PostProductRequest request)
{
string stringPayload = await Task.Run(() => JsonConvert.SerializeObject(request));
HttpResponseExtended <ProductResponse> productResponse = await Post(stringPayload);
return(productResponse);
}
public async Task <HttpResponseExtended <OfferingResponse> > Create(OfferingRequest request)
{
var stringPayload = await Task.Run(() => JsonConvert.SerializeObject(request));
HttpResponseExtended <OfferingResponse> response = await Post(stringPayload);
return(response);
}
public async Task GET_Offering_Not_Found()
{
string externalIdentifier = "getOffering02";
HttpResponseExtended <OfferingResponse> response = await Client.Offerings.GetSingle(externalIdentifier);
Assert.IsNotNull(response);
Assert.AreEqual(404, response.StatusCode);
}
public async Task <HttpResponseExtended <OfferingResponse> > PatchByExternal(string externalId, object requestObject)
{
MethodUrl = $"/{externalId}";
var stringPayload = await Task.Run(() => JsonConvert.SerializeObject(requestObject));
HttpResponseExtended <OfferingResponse> response = await Patch(stringPayload);
return(response);
}
public async Task GET_Product_Not_Found()
{
string externalIdentifier = "getProduct02";
HttpResponseExtended <ProductResponse> response = await Client.Products.GetSingle(externalIdentifier);
Assert.IsNotNull(response, "Response object should not be null");
Assert.AreEqual(404, response.StatusCode);
Assert.IsNull(response.Result);
}
public async Task DELETE_Category_NotFound()
{
string externalIdentifier = "deleteCategory02";
HttpResponseExtended <CategoryResponse> response = await Client.Categories.Remove(externalIdentifier);
Assert.IsNotNull(response);
Assert.AreEqual(404, response.StatusCode);
Assert.IsNull(response.Result, "result object should be null");
Assert.IsFalse(response.Success);
}
public async Task GET_Category_Not_Found()
{
string externalIdentifier = "getCategory02";
HttpResponseExtended <CategoryResponse> response = await Client.Categories.GetSingle(externalIdentifier);
Assert.IsNotNull(response);
Assert.AreEqual(404, response.StatusCode);
Assert.IsFalse(response.Success);
Assert.IsNull(response.Result);
}
//TODO
//pending
//[TestMethod]
public async Task POST_Verify_PriceList_Order()
{
string externalIdentifier = "postAccountMasterCase01";
AccountMasterTestData testData = new AccountMasterTestData
{
ExternalIdentifier = externalIdentifier
};
//TODO:
//review this validation
IDictionary <int, string> priceListItems = new Dictionary <int, string>
{
{ 0, "priceList01" },
{ 1, "priceList04" },
{ 2, "priceList02" },
{ 3, "priceList03" }
};
AccountMasterRequest request = new AccountMasterRequest
{
CreateAccount = true,
UseAccountTermsAsDefaultPayment = true,
TaxIdentifier = "asd",
CreatedBy = "http test",
ExternalData = "nada",
GroupIdentifier = "asd",
Identifier = externalIdentifier,
IsWebEnabled = true,
Name = "http test",
ProductPriceDiscount = 105,
TermsConfiguration = new AccountMasterTermConfiguration
{
HasPaymentTerms = true,
TermsDescription = "29 days ;)"
},
PriceListIds = new List <string>
{
""
}
};
HttpResponseExtended <AccountMasterResponse> response = await Client.AccountMasters.Create(request);
//validations
Assert.IsNotNull(response);
Assert.AreEqual(200, response.StatusCode);
Assert.IsTrue(response.Success);
Assert.IsNotNull(response.Result);
//NOTE
//the result.PriceLists will return a list of external ids
//test scenario clean up
await TestScenarioCleanUp(testData);
}
public async Task GET_AccountMaster_Not_Found()
{
string externalIdentifier = "getAccountMaster02";
HttpResponseExtended <AccountMasterResponse> response = await Client.AccountMasters.GetSingle(externalIdentifier);
//validations
Assert.IsNotNull(response);
Assert.AreEqual(404, response.StatusCode);
Assert.IsFalse(response.Success);
Assert.IsNull(response.Result);
}
public async Task GET_PriceList_Not_Found()
{
string externalIdentifier = "getPricelistCase02";
HttpResponseExtended <PriceListResponse> response = await Client.PriceLists.GetSingle(externalIdentifier);
//validations
Assert.IsNotNull(response);
Assert.AreEqual(404, response.StatusCode);
Assert.IsFalse(response.Success);
Assert.IsNull(response.Result);
}
public async Task PATCH_PriceList_Not_Found()
{
string externalIdentifier = "patchPriceList02";
var request = new { };
HttpResponseExtended <PriceListResponse> response = await Client.PriceLists.PatchEntity(externalIdentifier, request);
//validations
Assert.IsNotNull(response);
Assert.AreEqual(404, response.StatusCode);
Assert.IsFalse(response.Success);
Assert.IsNull(response.Result);
}
public async Task GET_Contact_NotFound()
{
string externalIdentifier = "getContactFailed01";
HttpResponseExtended <ContactResponse> response = await Client.Contacts.GetSingle(externalIdentifier);
//validations
Assert.IsNotNull(response, "Response is null");
Assert.AreEqual(404, response.StatusCode);
Assert.IsFalse(response.Success, "Response status should not be successful");
Assert.IsNull(response.Result, "result object should be null");
}
public async Task DELETE_User_NotFound()
{
string externalIdentifier = "deleteUserFailed01";
HttpResponseExtended <UserResponse> response = await Client.Users.Remove(externalIdentifier);
//validations
Assert.IsNotNull(response, "Response object is null");
Assert.AreEqual(404, response.StatusCode);
Assert.IsFalse(response.Success, "Response status should not be successful");
Assert.IsNull(response.Result, "result object should be null");
}
public async Task PATCH_AccountMaster_NotFound()
{
string externalIdentifier = "patchAccountMaster02";
var request = new { Name = "patched property" };
HttpResponseExtended <AccountMasterResponse> response = await Client.AccountMasters.PatchEntity(externalIdentifier, request);
//validations
Assert.IsNotNull(response);
Assert.AreEqual(404, response.StatusCode);
Assert.IsFalse(response.Success);
Assert.IsNull(response.Result);
}
