555 lines
No EOL
22 KiB
C++
555 lines
No EOL
22 KiB
C++
////////////////////////////////////////////////////////////////////////////////
|
|
// (c) Copyright, Ubisoft Entertainment Inc. || Created by Harbour //
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
#include "tests/config.h"
|
|
#if !defined(US_SDK_FULL)
|
|
#error This file shall not be part of the solution
|
|
#endif
|
|
#include "tests/common/helpers.h"
|
|
#include "tests/fixture/memoryCheckFixture.h"
|
|
#include <ubiservices/core/types/dateTimeHelper.h>
|
|
#include <ubiservices/services/secondaryStoreInstantiation/storeAttributeSpace.h>
|
|
#include <ubiservices/services/secondaryStoreInstantiation/storeAttributeTypeConstants.h>
|
|
#include <ubiservices/services/secondaryStoreInstantiation/storeItemInstance.h>
|
|
#include <ubiservices/services/secondaryStoreInstantiation/storeListOfAttributes.h>
|
|
#include <ubiservices/services/secondaryStoreInstantiation/storeRule.h>
|
|
|
|
namespace US_NS {;
|
|
US_DEFINE_TEST(TestSecondaryStoreInstantiation);
|
|
|
|
typedef LeakChecker SECONDARYSTOREINSTANTIATIONUNIT;
|
|
|
|
#if !defined(US_DLL)
|
|
namespace StoreItemInstancePrivate
|
|
{
|
|
bool extractData(const Json& json, StoreItemInstance& target);
|
|
}
|
|
namespace StoreAttributeStaticPrivate
|
|
{
|
|
bool extractData(const Json& json, StoreAttributeStatic& target);
|
|
}
|
|
namespace StoreAttributeIntegerPrivate
|
|
{
|
|
bool extractData(const Json& json, StoreAttributeInteger& target);
|
|
}
|
|
namespace StoreAttributeFloatPrivate
|
|
{
|
|
bool extractData(const Json& json, StoreAttributeFloat& target);
|
|
}
|
|
namespace StoreAttributeBooleanPrivate
|
|
{
|
|
bool extractData(const Json& json, StoreAttributeBoolean& target);
|
|
}
|
|
namespace StoreAttributePickFromListPrivate
|
|
{
|
|
bool extractData(const Json& json, StoreAttributePickFromList& target);
|
|
}
|
|
namespace StoreRulePrivate
|
|
{
|
|
bool extractData(const Json& json, StoreRule& target);
|
|
}
|
|
namespace StoreListOfAttributesPrivate
|
|
{
|
|
bool extractData(const Json& json, StoreListOfAttributes& target);
|
|
}
|
|
#endif
|
|
namespace TestSecondaryStoreInstantiationPrivate
|
|
{
|
|
JsonWriter generateJsonAttributeMandatoryParams()
|
|
{
|
|
JsonWriter writer;
|
|
writer["attributeId"] = "11111111-2222-3333-4444-555566667777";
|
|
writer["attributeName"] = "DummyName";
|
|
return writer;
|
|
};
|
|
|
|
Json generateJsonAttribute(StoreAttributeType type)
|
|
{
|
|
JsonWriter writer;
|
|
|
|
writer["attributeName"] = String::formatText("%s_%d", "DummyName", type);
|
|
JsonWriter valueWriter;
|
|
JsonWriter json1;
|
|
JsonWriter json2;
|
|
|
|
switch (type)
|
|
{
|
|
case StoreAttributeType::Static:
|
|
writer["attributeId"] = "11111111-2222-3333-4444-555566667771";
|
|
valueWriter["key3"] = "value3";
|
|
valueWriter["key4"] = "value4";
|
|
writer["attributeValue"] = valueWriter.getJson();
|
|
break;
|
|
case StoreAttributeType::IntegerRange:
|
|
writer["attributeId"] = "11111111-2222-3333-4444-555566667772";
|
|
valueWriter["min"] = 1;
|
|
valueWriter["max"] = 5;
|
|
writer["attributeValue"] = valueWriter.getJson();
|
|
break;
|
|
case StoreAttributeType::FloatRange:
|
|
writer["attributeId"] = "11111111-2222-3333-4444-555566667773";
|
|
valueWriter["min"] = 1;
|
|
valueWriter["max"] = 5;
|
|
valueWriter["precision"] = 2;
|
|
writer["attributeValue"] = valueWriter.getJson();
|
|
break;
|
|
case StoreAttributeType::PickFromList:
|
|
writer["attributeId"] = "11111111-2222-3333-4444-555566667774";
|
|
json1["key1"] = "value1";
|
|
json2["key2"] = "value2";
|
|
writer["attributeValue"]["possibleValues"].addItemToArray(json1.getJson());
|
|
writer["attributeValue"]["possibleValues"].addItemToArray(json2.getJson());
|
|
writer["attributeValue"]["quantity"] = 7u;
|
|
writer["attributeValue"]["allowDuplicates"] = true;
|
|
break;
|
|
case StoreAttributeType::Boolean:
|
|
writer["attributeId"] = "11111111-2222-3333-4444-555566667775";
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return writer.getJson();
|
|
};
|
|
|
|
Json generateJsonAttributeSpace()
|
|
{
|
|
Json staticJson = generateJsonAttribute(StoreAttributeType::Static);
|
|
Json integerJson = generateJsonAttribute(StoreAttributeType::IntegerRange);
|
|
Json floatJson = generateJsonAttribute(StoreAttributeType::FloatRange);
|
|
Json pickJson = generateJsonAttribute(StoreAttributeType::PickFromList);
|
|
Json boolJson = generateJsonAttribute(StoreAttributeType::Boolean);
|
|
|
|
JsonWriter writer;
|
|
writer["staticAttributes"].addItemToArray(staticJson);
|
|
writer["integerRangeAttributes"].addItemToArray(integerJson);
|
|
writer["floatRangeAttributes"].addItemToArray(floatJson);
|
|
writer["pickFromListAttributes"].addItemToArray(pickJson);
|
|
writer["booleanAttributes"].addItemToArray(boolJson);
|
|
|
|
return writer.getJson();
|
|
};
|
|
|
|
Json generateJsonAttributeSpaceOnlyStaticAvailable()
|
|
{
|
|
Json staticJson = generateJsonAttribute(StoreAttributeType::Static);
|
|
|
|
JsonWriter writer;
|
|
writer["staticAttributes"].addItemToArray(staticJson);
|
|
|
|
return writer.getJson();
|
|
};
|
|
#if !defined(US_DLL)
|
|
template <typename T, bool(*extractData)(const Json&, T&)>
|
|
JsonWriter checkAttributeMissingField()
|
|
{
|
|
JsonWriter writer;
|
|
writer["attributeId"] = "11111111-2222-3333-4444-555566667777";
|
|
writer["attributeName"] = "DummyName";
|
|
{
|
|
T attribute;
|
|
//attributeValue field is missing
|
|
EXPECT_FALSE(extractData(Json(writer.renderContent()), attribute));
|
|
EXPECT_EQ("", attribute.m_id);
|
|
EXPECT_EQ("", attribute.m_name);
|
|
}
|
|
return writer;
|
|
}
|
|
template <typename T, bool(*extractData)(const Json&, T&)>
|
|
void checkAttributeExtraData(JsonWriter writer)
|
|
{
|
|
// add extra data
|
|
writer["Extra"] = 42;
|
|
{
|
|
T attribute;
|
|
EXPECT_TRUE(extractData(Json(writer.renderContent()), attribute));
|
|
}
|
|
}
|
|
void checkListOfAttributesMandatoryFields(const Json& json,
|
|
const char* expectedListId, const char* expectedListName, const Vector<String> expectedAttributeIds)
|
|
{
|
|
|
|
StoreListOfAttributes listOfAttributes;
|
|
EXPECT_TRUE(StoreListOfAttributesPrivate::extractData(json, listOfAttributes));
|
|
|
|
EXPECT_EQ(StoreListOfAttributesId(expectedListId), listOfAttributes.m_listId);
|
|
EXPECT_EQ(expectedListName, listOfAttributes.m_listName);
|
|
|
|
bool foundAll = true;
|
|
for (String expectedAttributeId : expectedAttributeIds)
|
|
{
|
|
bool foundExpected = false;
|
|
for (StoreAttributeId actualAttributeId : listOfAttributes.m_attributeIds)
|
|
{
|
|
if (StoreAttributeId(expectedAttributeId) == actualAttributeId)
|
|
{
|
|
foundExpected = true;
|
|
}
|
|
}
|
|
if (!foundExpected)
|
|
{
|
|
foundAll = false;
|
|
break;
|
|
}
|
|
}
|
|
EXPECT_TRUE(foundAll) << " Not all attribute IDs were found in the list of attirbutes!";
|
|
}
|
|
#endif
|
|
}
|
|
|
|
#if !defined(US_DLL)
|
|
using TestSecondaryStoreInstantiationPrivate::generateJsonAttributeMandatoryParams;
|
|
using TestSecondaryStoreInstantiationPrivate::generateJsonAttribute;
|
|
using TestSecondaryStoreInstantiationPrivate::checkAttributeMissingField;
|
|
using TestSecondaryStoreInstantiationPrivate::checkAttributeExtraData;
|
|
using TestSecondaryStoreInstantiationPrivate::checkListOfAttributesMandatoryFields;
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// StoreItemInstance
|
|
TEST_F(SECONDARYSTOREINSTANTIATIONUNIT, LOCAL_StoreItemInstanceJsonParsing)
|
|
{
|
|
JsonWriter writer;
|
|
writer["instanceId"] = "11111111-2222-3333-4444-555566667777";
|
|
writer["itemId"] = "22222222-3333-4444-5555-666677778888";
|
|
writer["lastModified"] = DateTimeHelper::formatDateISO8601(DateTime(2015, 01, 10, 14, 03, 58));
|
|
writer["expirationDate"] = DateTimeHelper::formatDateISO8601(DateTime(2016, 02, 10, 14, 03, 58));
|
|
JsonWriter objWriter;
|
|
{
|
|
objWriter["key4"] = "value4";
|
|
objWriter["key5"] = "value5";
|
|
}
|
|
writer["obj"] = objWriter.getJson();
|
|
{
|
|
StoreItemInstance storeItemInstance;
|
|
EXPECT_FALSE(StoreItemInstancePrivate::extractData(Json(writer.renderContent()), storeItemInstance));
|
|
}
|
|
|
|
// Add missing data
|
|
JsonWriter attributesWriter;
|
|
attributesWriter["key1"] = "value1";
|
|
attributesWriter["key2"] = "value2";
|
|
attributesWriter["key3"]["subkey1"] = "subvalue1";
|
|
writer["attributes"] = attributesWriter.getJson();
|
|
{
|
|
StoreItemInstance storeItemInstance;
|
|
EXPECT_TRUE(StoreItemInstancePrivate::extractData(Json(writer.renderContent()), storeItemInstance));
|
|
EXPECT_EQ("11111111-2222-3333-4444-555566667777", storeItemInstance.m_instanceId);
|
|
EXPECT_EQ("22222222-3333-4444-5555-666677778888", storeItemInstance.m_itemId);
|
|
EXPECT_EQ(DateTime(2015, 01, 10, 14, 03, 58), storeItemInstance.m_lastModified);
|
|
EXPECT_EQ(DateTime(2016, 02, 10, 14, 03, 58), storeItemInstance.m_expirationDate.value());
|
|
EXPECT_TRUE(storeItemInstance.m_expirationDate.isSpecified());
|
|
EXPECT_EQ(String("value1"), storeItemInstance.m_attributes["key1"].getValueString());
|
|
EXPECT_EQ(String("value2"), storeItemInstance.m_attributes["key2"].getValueString());
|
|
EXPECT_EQ(String("subvalue1"), storeItemInstance.m_attributes["key3"]["subkey1"].getValueString());
|
|
EXPECT_EQ(String("value4"), storeItemInstance.m_obj["key4"].getValueString());
|
|
EXPECT_EQ(String("value5"), storeItemInstance.m_obj["key5"].getValueString());
|
|
}
|
|
|
|
// add extra data
|
|
writer["Extra"] = 42;
|
|
{
|
|
StoreItemInstance storeItemInstance;
|
|
EXPECT_TRUE(StoreItemInstancePrivate::extractData(Json(writer.renderContent()), storeItemInstance));
|
|
}
|
|
|
|
// check when instance does not expire (null is returned in "expirationDate")
|
|
writer["expirationDate"].setToNull();
|
|
{
|
|
StoreItemInstance storeItemInstance;
|
|
EXPECT_TRUE(StoreItemInstancePrivate::extractData(Json(writer.renderContent()), storeItemInstance));
|
|
EXPECT_FALSE(storeItemInstance.m_expirationDate.isSpecified());
|
|
}
|
|
}
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// StoreAttributes
|
|
TEST_F(SECONDARYSTOREINSTANTIATIONUNIT, LOCAL_StoreAttributeStaticJsonParsing)
|
|
{
|
|
// check the attribute when the mandatory field attributeValue is missing
|
|
JsonWriter writer = checkAttributeMissingField<StoreAttributeStatic, StoreAttributeStaticPrivate::extractData>();
|
|
|
|
// Add missing data
|
|
JsonWriter valueWriter;
|
|
valueWriter["key3"] = "value3";
|
|
valueWriter["key4"] = "value4";
|
|
writer["attributeValue"] = valueWriter.getJson();
|
|
{
|
|
StoreAttributeStatic attribute;
|
|
EXPECT_TRUE(StoreAttributeStaticPrivate::extractData(Json(writer.renderContent()), attribute));
|
|
EXPECT_EQ("11111111-2222-3333-4444-555566667777", attribute.m_id);
|
|
EXPECT_EQ("DummyName", attribute.m_name);
|
|
EXPECT_EQ("value3", attribute.m_value["key3"].getValueString());
|
|
EXPECT_EQ("value4", attribute.m_value["key4"].getValueString());
|
|
|
|
}
|
|
|
|
// add extra data
|
|
checkAttributeExtraData<StoreAttributeStatic, StoreAttributeStaticPrivate::extractData>(writer);
|
|
}
|
|
|
|
TEST_F(SECONDARYSTOREINSTANTIATIONUNIT, LOCAL_StoreAttributeIntegerJsonParsing)
|
|
{
|
|
// check the attribute when the mandatory field attributeValue is missing
|
|
JsonWriter writer = checkAttributeMissingField<StoreAttributeInteger, StoreAttributeIntegerPrivate::extractData>();
|
|
|
|
// Add missing data
|
|
JsonWriter valueWriter;
|
|
valueWriter["min"] = 1;
|
|
valueWriter["max"] = 5;
|
|
writer["attributeValue"] = valueWriter.getJson();
|
|
{
|
|
StoreAttributeInteger attribute;
|
|
EXPECT_TRUE(StoreAttributeIntegerPrivate::extractData(Json(writer.renderContent()), attribute));
|
|
EXPECT_EQ("11111111-2222-3333-4444-555566667777", attribute.m_id);
|
|
EXPECT_EQ("DummyName", attribute.m_name);
|
|
EXPECT_EQ(1, attribute.m_value.m_min);
|
|
EXPECT_EQ(5, attribute.m_value.m_max);
|
|
}
|
|
// add extra data
|
|
checkAttributeExtraData<StoreAttributeInteger, StoreAttributeIntegerPrivate::extractData>(writer);
|
|
}
|
|
|
|
TEST_F(SECONDARYSTOREINSTANTIATIONUNIT, LOCAL_StoreAttributeFloatJsonParsing)
|
|
{
|
|
// check the attribute when the mandatory field attributeValue is missing
|
|
JsonWriter writer = checkAttributeMissingField<StoreAttributeFloat, StoreAttributeFloatPrivate::extractData>();
|
|
|
|
// Add missing data
|
|
JsonWriter valueWriter;
|
|
valueWriter["min"] = 1.2;
|
|
valueWriter["max"] = 5.3;
|
|
valueWriter["precision"] = 2;
|
|
writer["attributeValue"] = valueWriter.getJson();
|
|
{
|
|
StoreAttributeFloat attribute;
|
|
EXPECT_TRUE(StoreAttributeFloatPrivate::extractData(Json(writer.renderContent()), attribute));
|
|
EXPECT_EQ("11111111-2222-3333-4444-555566667777", attribute.m_id);
|
|
EXPECT_EQ("DummyName", attribute.m_name);
|
|
EXPECT_EQ(1.2f, attribute.m_value.m_min);
|
|
EXPECT_EQ(5.3f, attribute.m_value.m_max);
|
|
EXPECT_EQ(2u, attribute.m_value.m_precision);
|
|
}
|
|
|
|
// add extra data
|
|
checkAttributeExtraData<StoreAttributeFloat, StoreAttributeFloatPrivate::extractData>(writer);
|
|
}
|
|
TEST_F(SECONDARYSTOREINSTANTIATIONUNIT, LOCAL_StoreAttributePickFromListJsonParsing)
|
|
{
|
|
// check the attribute when the mandatory field attributeValue is missing
|
|
JsonWriter writer = checkAttributeMissingField<StoreAttributePickFromList, StoreAttributePickFromListPrivate::extractData>();
|
|
|
|
// Add missing data
|
|
JsonWriter json1;
|
|
json1["key1"] = "value1";
|
|
JsonWriter json2;
|
|
json2["key2"] = "value2";
|
|
writer["attributeValue"]["possibleValues"].addItemToArray(json1.getJson());
|
|
writer["attributeValue"]["possibleValues"].addItemToArray(json2.getJson());
|
|
writer["attributeValue"]["quantity"] = 7u;
|
|
writer["attributeValue"]["allowDuplicates"] = true;
|
|
{
|
|
StoreAttributePickFromList attribute;
|
|
EXPECT_TRUE(StoreAttributePickFromListPrivate::extractData(Json(writer.renderContent()), attribute));
|
|
EXPECT_EQ("11111111-2222-3333-4444-555566667777", attribute.m_id);
|
|
EXPECT_EQ("DummyName", attribute.m_name);
|
|
EXPECT_EQ(2u, attribute.m_value.m_possibleValues.size());
|
|
if (attribute.m_value.m_possibleValues.size() == 2u)
|
|
{
|
|
EXPECT_EQ("value1", attribute.m_value.m_possibleValues[0]["key1"].getValueString());
|
|
EXPECT_EQ("value2", attribute.m_value.m_possibleValues[1]["key2"].getValueString());
|
|
}
|
|
EXPECT_EQ(7u, attribute.m_value.m_quantity);
|
|
EXPECT_TRUE(attribute.m_value.m_allowDuplicates);
|
|
|
|
}
|
|
|
|
// add extra data
|
|
checkAttributeExtraData<StoreAttributePickFromList, StoreAttributePickFromListPrivate::extractData>(writer);
|
|
}
|
|
TEST_F(SECONDARYSTOREINSTANTIATIONUNIT, LOCAL_StoreAttributeBooleanJsonParsing)
|
|
{
|
|
JsonWriter writer;
|
|
writer["attributeId"] = "11111111-2222-3333-4444-555566667777";
|
|
{
|
|
StoreAttributeBoolean attribute;
|
|
EXPECT_FALSE(StoreAttributeBooleanPrivate::extractData(Json(writer.renderContent()), attribute));
|
|
EXPECT_EQ("", attribute.m_id);
|
|
EXPECT_EQ("", attribute.m_name);
|
|
}
|
|
|
|
// Add missing data
|
|
writer["attributeName"] = "DummyName";
|
|
{
|
|
StoreAttributeBoolean attribute;
|
|
EXPECT_TRUE(StoreAttributeBooleanPrivate::extractData(Json(writer.renderContent()), attribute));
|
|
EXPECT_EQ("11111111-2222-3333-4444-555566667777", attribute.m_id);
|
|
EXPECT_EQ("DummyName", attribute.m_name);
|
|
}
|
|
// add extra data
|
|
writer["Extra"] = 42;
|
|
{
|
|
StoreAttributeBoolean attribute;
|
|
EXPECT_TRUE(StoreAttributeBooleanPrivate::extractData(Json(writer.renderContent()), attribute));
|
|
}
|
|
}
|
|
|
|
TEST_F(SECONDARYSTOREINSTANTIATIONUNIT, LOCAL_StoreAttributePickFromListAttributeValueParamParsing)
|
|
{
|
|
{ // attributeValue has all params
|
|
JsonWriter writer = generateJsonAttributeMandatoryParams();
|
|
JsonWriter json1;
|
|
json1["key1"] = "value1";
|
|
JsonWriter json2;
|
|
json2["key2"] = "value2";
|
|
writer["attributeValue"]["possibleValues"].addItemToArray(json1.getJson());
|
|
writer["attributeValue"]["possibleValues"].addItemToArray(json2.getJson());
|
|
writer["attributeValue"]["quantity"] = 7u;
|
|
writer["attributeValue"]["allowDuplicates"] = true;
|
|
|
|
StoreAttributePickFromList attribute;
|
|
EXPECT_TRUE(StoreAttributePickFromListPrivate::extractData(Json(writer.renderContent()), attribute));
|
|
|
|
EXPECT_EQ(2u, attribute.m_value.m_possibleValues.size());
|
|
if (attribute.m_value.m_possibleValues.size() == 2u)
|
|
{
|
|
EXPECT_EQ("value1", attribute.m_value.m_possibleValues[0]["key1"].getValueString());
|
|
EXPECT_EQ("value2", attribute.m_value.m_possibleValues[1]["key2"].getValueString());
|
|
}
|
|
EXPECT_EQ(7u, attribute.m_value.m_quantity);
|
|
EXPECT_TRUE(attribute.m_value.m_allowDuplicates);
|
|
}
|
|
{ // possibleValues missing
|
|
JsonWriter writer = generateJsonAttributeMandatoryParams();
|
|
writer["attributeValue"]["quantity"] = 7u;
|
|
writer["attributeValue"]["allowDuplicates"] = true;
|
|
|
|
StoreAttributePickFromList attribute;
|
|
EXPECT_FALSE(StoreAttributePickFromListPrivate::extractData(Json(writer.renderContent()), attribute));
|
|
}
|
|
{ // quantity missing
|
|
JsonWriter writer = generateJsonAttributeMandatoryParams();
|
|
JsonWriter json1;
|
|
json1["key1"] = "value1";
|
|
JsonWriter json2;
|
|
json2["key2"] = "value2";
|
|
writer["attributeValue"]["possibleValues"].addItemToArray(json1.getJson());
|
|
writer["attributeValue"]["possibleValues"].addItemToArray(json2.getJson());
|
|
writer["attributeValue"]["allowDuplicates"] = true;
|
|
|
|
StoreAttributePickFromList attribute;
|
|
EXPECT_FALSE(StoreAttributePickFromListPrivate::extractData(Json(writer.renderContent()), attribute));
|
|
}
|
|
{ // allowDuplicates missing
|
|
JsonWriter writer = generateJsonAttributeMandatoryParams();
|
|
JsonWriter json1;
|
|
json1["key1"] = "value1";
|
|
JsonWriter json2;
|
|
json2["key2"] = "value2";
|
|
writer["attributeValue"]["possibleValues"].addItemToArray(json1.getJson());
|
|
writer["attributeValue"]["possibleValues"].addItemToArray(json2.getJson());
|
|
writer["attributeValue"]["quantity"] = 7u;
|
|
|
|
StoreAttributePickFromList attribute;
|
|
EXPECT_FALSE(StoreAttributePickFromListPrivate::extractData(Json(writer.renderContent()), attribute));
|
|
}
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// StoreRules
|
|
TEST_F(SECONDARYSTOREINSTANTIATIONUNIT, LOCAL_StoreRuleJsonParsing)
|
|
{
|
|
const char* const LIST_OF_ATTRIBUTES_ID = "11111111-2222-3333-4444-555566667777";
|
|
const int MAX_QUANTITY = 5;
|
|
const char* const ITEM_ID = "22222222-2222-3333-4444-555566667777";
|
|
const char* const RULE_ID = "33333333-2222-3333-4444-555566667777";
|
|
|
|
JsonWriter writer;
|
|
writer["maxQuantity"] = MAX_QUANTITY;
|
|
writer["itemId"] = ITEM_ID;
|
|
writer["ruleId"] = RULE_ID;
|
|
|
|
// Missing field
|
|
{
|
|
StoreRule storeRule;
|
|
EXPECT_FALSE(StoreRulePrivate::extractData(writer.getJson(), storeRule));
|
|
}
|
|
|
|
// Adding missing field
|
|
writer["listOfAttributesId"] = LIST_OF_ATTRIBUTES_ID;
|
|
{
|
|
StoreRule storeRule;
|
|
EXPECT_TRUE(StoreRulePrivate::extractData(writer.getJson(), storeRule));
|
|
EXPECT_EQ(StoreRuleId(RULE_ID), storeRule.m_ruleId);
|
|
EXPECT_EQ(StoreListOfAttributesId(LIST_OF_ATTRIBUTES_ID), storeRule.m_listOfAttributesId);
|
|
EXPECT_EQ(MAX_QUANTITY, storeRule.m_maxQuantity);
|
|
EXPECT_EQ(ITEM_ID, storeRule.m_itemId);
|
|
}
|
|
|
|
// Adding extra field
|
|
writer["extraField"] = 100;
|
|
{
|
|
StoreRule storeRule;
|
|
EXPECT_TRUE(StoreRulePrivate::extractData(writer.getJson(), storeRule));
|
|
EXPECT_EQ(StoreRuleId(RULE_ID), storeRule.m_ruleId);
|
|
EXPECT_EQ(StoreListOfAttributesId(LIST_OF_ATTRIBUTES_ID), storeRule.m_listOfAttributesId);
|
|
EXPECT_EQ(MAX_QUANTITY, storeRule.m_maxQuantity);
|
|
EXPECT_EQ(ITEM_ID, storeRule.m_itemId);
|
|
}
|
|
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
// StoreListOfAttributes
|
|
TEST_F(SECONDARYSTOREINSTANTIATIONUNIT, LOCAL_StoreListOfAttributesJsonParsing)
|
|
{
|
|
const char* const LIST_ID = "11111111-2222-3333-4444-555566667777";
|
|
const char* const LIST_NAME = "Dummy_List_Name";
|
|
const Vector<String> LIST_ATTRIBUTE_IDS =
|
|
{
|
|
"11111111-1111-1111-1111-111111111111",
|
|
"22222222-2222-2222-2222-222222222222",
|
|
"33333333-3333-3333-3333-333333333333",
|
|
};
|
|
|
|
JsonWriter writer;
|
|
{
|
|
writer["listName"] = LIST_NAME;
|
|
|
|
JsonWriter attributeIds(JsonWriterType::Array);
|
|
{
|
|
for (String attributeId : LIST_ATTRIBUTE_IDS)
|
|
{
|
|
attributeIds.addItemToArray(attributeId);
|
|
}
|
|
}
|
|
writer["attributeIds"] = attributeIds.getJson();
|
|
}
|
|
|
|
// Missing field
|
|
{
|
|
StoreListOfAttributes storeListOfAttributes;
|
|
EXPECT_FALSE(StoreListOfAttributesPrivate::extractData(writer.getJson(), storeListOfAttributes));
|
|
}
|
|
|
|
// Adding missing field
|
|
writer["listId"] = LIST_ID;
|
|
{
|
|
checkListOfAttributesMandatoryFields(writer.getJson(), LIST_ID, LIST_NAME, LIST_ATTRIBUTE_IDS);
|
|
}
|
|
|
|
// Adding extra field
|
|
writer["extraField"] = 100;
|
|
{
|
|
checkListOfAttributesMandatoryFields(writer.getJson(), LIST_ID, LIST_NAME, LIST_ATTRIBUTE_IDS);
|
|
}
|
|
|
|
// Adding invalid entry in the attributeIds list
|
|
writer["attributeIds"].addItemToArray("5");
|
|
{
|
|
checkListOfAttributesMandatoryFields(writer.getJson(), LIST_ID, LIST_NAME, LIST_ATTRIBUTE_IDS);
|
|
}
|
|
}
|
|
|
|
#endif // !defined(US_DLL)
|
|
|
|
}; |