Exemple #1
0
def test_replaceNull():
    '''Test the Lucidic public method that attempts to scan the specified dict and replace None, Null, Nil, or Empty String values with a specified default value.'''

    # Copy the origin dict as the find null values public method will, and then set the Lucidic Test Dict Object
    TestDict = getTestDict("null_dict")
    Lucidict = Lucidic(TestDict)

    assert (Lucidict.dict == TestDict)
    '''Test expected method assertion exceptions:'''
    # keyword = str
    with pytest.raises(AssertionError):
        Lucidict.replaceNull(["UnKnown"])

    # Validate the values of Lucidict.dist before running the key replace method
    assert (isinstance(Lucidict.dict, dict))
    assert (Lucidict.dict == TestDict)
    assert (Lucidict.dict.get('FirstTierKey2') == "Null")
    assert (Lucidict.dict.get('FirstTierKey3').get('SecondTierKey2') == "Nil")
    assert (Lucidict.dict.get('FirstTierKey3').get('SecondTierKey3') == "")
    assert (Lucidict.dict.get('FirstTierKey3').get('SecondTierKey4').get(
        'ThirdTierKey1') == "null")
    assert (Lucidict.dict.get('FirstTierKey3').get('SecondTierKey4').get(
        'ThirdTierKey2')[0].get('FourthListTierKey1') == "nil")
    assert (Lucidict.dict.get('FirstTierKey3').get('SecondTierKey4').get(
        'ThirdTierKey2')[1].get('FourthListTierKey2') == "")

    # Assign SanitizedDict as the return target and call the method.
    SanitizedDict = Lucidict.replaceNull("UnKnown")

    # Check Keyword Assignment
    get_keyword = Lucidict._get_keyword()
    assert (isinstance(get_keyword, str))
    assert (get_keyword == "UnKnown")

    # Validate the values of Lucidict.dist after running the key replace method
    assert (isinstance(Lucidict.dict, dict))
    assert (Lucidict.dict == Lucidict.dict)
    assert (Lucidict.dict != TestDict)
    assert (Lucidict.dict.get('FirstTierKey2') == "UnKnown")
    assert (
        Lucidict.dict.get('FirstTierKey3').get('SecondTierKey2') == "UnKnown")
    assert (
        Lucidict.dict.get('FirstTierKey3').get('SecondTierKey3') == "UnKnown")
    assert (Lucidict.dict.get('FirstTierKey3').get('SecondTierKey4').get(
        'ThirdTierKey1') == "UnKnown")
    assert (Lucidict.dict.get('FirstTierKey3').get('SecondTierKey4').get(
        'ThirdTierKey2')[0].get('FourthListTierKey1') == "UnKnown")
    assert (Lucidict.dict.get('FirstTierKey3').get('SecondTierKey4').get(
        'ThirdTierKey2')[1].get('FourthListTierKey2') == "UnKnown")

    # Validate the values of SanitizedDict after running the key replace method (Should be exact copy of Lucidict.dist)
    assert (isinstance(SanitizedDict, dict))
    assert (SanitizedDict == Lucidict.dict)
    assert (SanitizedDict != TestDict)
    '''Clean Up'''
    Lucidict._reset_instance()
    del TestDict
    del SanitizedDict
    del Lucidict
    del get_keyword
Exemple #2
0
def test_init():
    '''Test Lucidic class constructor'''

    # Create a copy of the SimpleTestDict (This will allow us to test no modifications to the instantiation source dict.)
    TestDict = getTestDict("simple_dict")
    TestList = getTestDict("simple_list")
    Lucidict = Lucidic(TestDict)
    '''Test class constructor:'''
    # Test instantiated class instance with dict specified
    assert (Lucidict.dict == TestDict)

    # Test to ensure original source dict is not modified
    Lucidict.dict.clear()
    assert (TestDict == getTestDict("simple_dict"))
    assert (Lucidict.dict != TestDict)
    assert (Lucidict.dict == {})

    # Test instantiated class instance with no dict specified
    EmptyLucidict = Lucidic()
    assert (EmptyLucidict.dict == {})

    # Test instantiated class instance with non dict object
    with pytest.raises(AssertionError):
        LucidictFail = Lucidic(TestList)
    '''Clean Up'''
    Lucidict._reset_instance()
    del TestDict
    del TestList
    del Lucidict
    del EmptyLucidict
Exemple #3
0
def filterObjects(obj, keys=[], accepts=[], rejects=[], strict=True):
    """
    Filter a Neseted Object by Keyword

    Args:
        key: (str) - should be a dict key, not value
        rejects: (list) - keys you wish to keep for matches found
        strict: (boolean) - True = exclusive keyword match, False = partial match
    Returns:
        filtered_obj: (list) - list of filtered objects
    """
    total_keys = []
    a_keys = []
    r_keys = []
    queries = []
    results = []

    for key in keys:
        temp_obj = Lucidic({"stuff": obj}) if isinstance(
            obj, list) else Lucidic(obj)
        query = temp_obj.search(key, strict=True)
        queries.append(query)
        total_keys += [x["keypath"][0] for x in query]
        if accepts:
            a_keys += [
                x["keypath"][0] for x in query if x["match"][key] in accepts
            ]
        if rejects:
            r_keys += [
                x["keypath"][0] for x in query if x["match"][key] in rejects
            ]
    if a_keys:
        filtered_keys = sorted((set(total_keys) & set(a_keys)) - set(r_keys))
    else:
        filtered_keys = sorted(set(total_keys) - set(r_keys))
    for f_key in filtered_keys:
        m = re.search(r"(?P<key>.+)\[(?P<index>\d+)\]", f_key).groupdict()
        results.append(temp_obj.dict[m["key"]][int(m["index"])])
    return results
Exemple #4
0
def getInfo(obj, unique_value, desired_keys):
    idx = Lucidic(obj)
    idx_q = idx.search(unique_value, strict=True)
    info = {}
    for key in desired_keys:
        kdx = Lucidic(obj)
        kdx_q = kdx.search(key)
        for k in kdx_q:
            if k['keypath'] == idx_q[0]['keypath']:
                info.update(idx_q[0]['match'])
                info.update(k['match'])
    return info
Exemple #5
0
                "Name": "54321"
            }, {
                "Name": "34512"
            }],
            "TestList": ["Test", "Name", "In", ["Sub", "Test", "Name"]]
        }
    }]
}

# Test Dict Search:
# ==================

# Construct a new object, passing it the dictionary.
print("Test1: Single Tier")
print("------------------")
lucidicTest = Lucidic(TESTDICT)
results = lucidicTest.search("Name")
print("Results Returned: {}".format(len(results)))
for result in results:
    print(result)
print("\n")

print("Test2: Multi-Tier default (strict:false)")
print("----------------------------------------")
lucidicTest2 = Lucidic(TESTDICT2)
results2 = lucidicTest2.search("Name")
print("Results Returned: {}".format(len(results2)))
for result in results2:
    print(result)
print("\n")
Exemple #6
0
def test_search_recursive_dict():
    '''Test the Lucidic method that attempts to recursively search a python dictionary'''

    # Set the Lucidic Test Dict Object
    TestDict = getTestDict("nested_dict")
    TestList = getTestDict("simple_list")
    Lucidict = Lucidic(TestDict)
    '''Test expected method assertion exceptions:'''
    # subdict = dict
    with pytest.raises(AssertionError):
        Lucidict._search_recursive_dict("TestDict", TestList)
    # keypath = list
    with pytest.raises(AssertionError):
        Lucidict._search_recursive_dict(TestDict, "TestList")
    '''Test Lucidic._search_recursive_dict method actions'''
    # Set the keypath and keyword variables manually, this happens as part of the public search method call
    get_results = Lucidict._get_results()
    assert (isinstance(get_results, list))
    assert (len(get_results) == 0)

    Lucidict._set_strict()
    get_strict = Lucidict._get_strict()
    assert (isinstance(get_strict, bool))
    assert (get_strict == True)

    set_keyword = Lucidict._set_keyword("12345")
    get_keyword = Lucidict._get_keyword()
    assert (isinstance(get_keyword, str))
    assert (get_keyword == "12345")

    # Set the search dict method as a mock method so we can validate the recursive call count.
    Lucidict._search_recursive_dict(Lucidict.dict, [])

    # To validate that the search was successful, we can take a look at the results list.
    get_results = Lucidict._get_results()
    assert (len(get_results) == 3)
    assert (get_results[0] == {
        'keypath': ['Customers', 'Address'],
        'match': {
            'ZipCode': '12345'
        }
    })
    assert (get_results[1] == {
        'keypath': ['Business[0]', 'Address'],
        'match': {
            'ZipCode': '12345'
        }
    })
    assert (get_results[2] == {
        'keypath': ['Business[0]', 'Address', 'Passcode[0]'],
        'match': {
            'Name': '12345'
        }
    })
    '''Clean Up'''
    Lucidict._reset_instance()
    del TestDict
    del TestList
    del get_results
    del get_strict
    del get_keyword
    del set_keyword
    del Lucidict
Exemple #7
0
def test_replaceKey():
    '''Test the Lucidic public method that attempts to scan the specified dict and replace any found keys matching the provided key_search to the value specified.'''

    # Copy the origin dict as the find null values public method will, and then set the Lucidic Test Dict Object
    TestDict = getTestDict("null_dict")
    Lucidict = Lucidic(TestDict)
    assert (Lucidict.dict == TestDict)

    # Set the test condition vars
    key_search = "FourthListTierKey3"
    replace_value = "ChangedKey1"
    '''Test expected method assertion exceptions:'''
    # key_search = str
    with pytest.raises(AssertionError):
        Lucidict.replaceKey([key_search], replace_value)
    # replace_value = str
    with pytest.raises(AssertionError):
        Lucidict.replaceKey(key_search, [replace_value])

    # Validate the values of before running key replace method
    assert (isinstance(Lucidict.dict, dict))
    assert (Lucidict.dict == TestDict)
    assert (Lucidict.dict.get('FirstTierKey2') == "Null")
    assert (Lucidict.dict.get('FirstTierKey3').get('SecondTierKey2') == "Nil")
    assert (Lucidict.dict.get('FirstTierKey3').get('SecondTierKey3') == "")
    assert (Lucidict.dict.get('FirstTierKey3').get('SecondTierKey4').get(
        'ThirdTierKey1') == "null")
    assert (Lucidict.dict.get('FirstTierKey3').get('SecondTierKey4').get(
        'ThirdTierKey2')[0].get('FourthListTierKey1') == "nil")
    assert (Lucidict.dict.get('FirstTierKey3').get('SecondTierKey4').get(
        'ThirdTierKey2')[1].get('FourthListTierKey2') == "")
    assert (key_search in Lucidict.dict.get('FirstTierKey3').get(
        'SecondTierKey4').get('ThirdTierKey2')[2].keys())
    assert (replace_value not in Lucidict.dict.get('FirstTierKey3').get(
        'SecondTierKey4').get('ThirdTierKey2')[2].keys())

    # Assign SanitizedDict as the return target and call the method.
    KeyReplaceDict = Lucidict.replaceKey(key_search, replace_value)

    # Check Keyword Assignment
    get_keyword = Lucidict._get_keyword()
    assert (isinstance(get_keyword, str))
    assert (get_keyword == replace_value)

    # Validate the values of KeyReplaceDict after running the replace method
    assert (isinstance(Lucidict.dict, dict))
    assert (Lucidict.dict != TestDict)
    assert (Lucidict.dict.get('FirstTierKey2') == "Null")
    assert (Lucidict.dict.get('FirstTierKey3').get('SecondTierKey2') == "Nil")
    assert (Lucidict.dict.get('FirstTierKey3').get('SecondTierKey3') == "")
    assert (Lucidict.dict.get('FirstTierKey3').get('SecondTierKey4').get(
        'ThirdTierKey1') == "null")
    assert (Lucidict.dict.get('FirstTierKey3').get('SecondTierKey4').get(
        'ThirdTierKey2')[0].get('FourthListTierKey1') == "nil")
    assert (Lucidict.dict.get('FirstTierKey3').get('SecondTierKey4').get(
        'ThirdTierKey2')[1].get('FourthListTierKey2') == "")
    assert (replace_value in Lucidict.dict.get('FirstTierKey3').get(
        'SecondTierKey4').get('ThirdTierKey2')[2].keys())
    assert (key_search not in Lucidict.dict.get('FirstTierKey3').get(
        'SecondTierKey4').get('ThirdTierKey2')[2].keys())

    # Validate the values of KeyReplaceDict after running the key replace method (Should be exact copy of Lucidict.dist)
    assert (isinstance(KeyReplaceDict, dict))
    assert (KeyReplaceDict == Lucidict.dict)
    assert (KeyReplaceDict != TestDict)
    '''Clean Up'''
    Lucidict._reset_instance()
    del TestDict
    del KeyReplaceDict
    del Lucidict
    del get_keyword
    del key_search
    del replace_value
Exemple #8
0
def test_keyword():
    '''Test the internal class _get_keyword, _set_keyword, _clear_keyword methods'''

    # Set the Lucidic Test Dict Object
    TestDict = getTestDict("simple_dict")
    Lucidict = Lucidic(TestDict)
    '''Test expected method assertion exceptions:'''
    # keyword = str
    with pytest.raises(AssertionError):
        Lucidict._set_keyword(TestDict)
    '''Test Lucidic._set_keyword, Lucidic._get_keyword and Lucidic._clear_keyword method actions'''
    get_keyword = Lucidict._get_keyword()
    assert (isinstance(get_keyword, str))
    assert (get_keyword == "")

    set_keyword = "MyKeywordAwesomes"
    Lucidict._set_keyword(set_keyword)
    get_keyword = Lucidict._get_keyword()
    assert (isinstance(get_keyword, str))
    assert (get_keyword == set_keyword)

    Lucidict._clear_keyword()
    get_keyword = Lucidict._get_keyword()
    assert (isinstance(get_keyword, str))
    assert (get_keyword == "")
    '''Clean Up'''
    Lucidict._reset_instance()
    del TestDict
    del Lucidict
    del get_keyword
    del set_keyword
Exemple #9
0
def test_search():
    '''Test the Lucidic public method that searches through the specified dictionary class instance for a given keyword.'''

    # Copy the origin dict as the find null values public method will, and then set the Lucidic Test Dict Object
    TestDict = getTestDict("nested_dict")
    Lucidict = Lucidic(TestDict)
    '''Test expected method assertion exceptions:'''
    # keyword = str
    with pytest.raises(AssertionError):
        Lucidict.search(["name"], strict=True)
    # strict = bool
    with pytest.raises(AssertionError):
        Lucidict.search(["name"], strict="True")
    '''Test Lucidict.search method actions'''
    # Perform Loose Search and validate the results
    SearchResults = Lucidict.search("name")
    assert (isinstance(SearchResults, list))
    assert (len(SearchResults) == 11)
    assert (SearchResults[0] == {
        'keypath': [],
        'match': {
            'Name': 'TestDictionary2'
        }
    })
    assert (SearchResults[1] == {
        'keypath': ['Customers'],
        'match': {
            'Name': 'John Doe'
        }
    })
    assert (SearchResults[2] == {
        'keypath': ['Customers', 'Address'],
        'match': {
            'Name': 'Home'
        }
    })
    assert (SearchResults[3] == {
        'keypath': ['Customers', 'Address'],
        'match': {
            'AliasName': 'Home'
        }
    })
    assert (SearchResults[4] == {
        'keypath': ['Business[0]'],
        'match': {
            'Name': 'SomeBusiness'
        }
    })
    assert (SearchResults[5] == {
        'keypath': ['Business[0]', 'Address'],
        'match': {
            'Name': 'Primary'
        }
    })
    assert (SearchResults[6] == {
        'keypath': ['Business[0]', 'Address', 'Passcode[0]'],
        'match': {
            'Name': '12345'
        }
    })
    assert (SearchResults[7] == {
        'keypath': ['Business[0]', 'Address', 'Passcode[1]'],
        'match': {
            'Name': '54321'
        }
    })
    assert (SearchResults[8] == {
        'keypath': ['Business[0]', 'Address', 'Passcode[2]'],
        'match': {
            'Name': '34512'
        }
    })
    assert (SearchResults[9] == {
        'keypath': ['Business[0]', 'Address'],
        'match': {
            'TestList[1]': 'Name'
        }
    })
    assert (SearchResults[10] == {
        'keypath': ['Business[0]', 'Address', 'TestList[3]', 'TestList[3][2]'],
        'match': {
            'TestList[3][2][3]': 'Name'
        }
    })

    # Perform Exact Search and validate the results
    SearchResults = Lucidict.search("Name", strict=True)
    assert (isinstance(SearchResults, list))
    assert (len(SearchResults) == 10)
    assert (SearchResults[0] == {
        'keypath': [],
        'match': {
            'Name': 'TestDictionary2'
        }
    })
    assert (SearchResults[1] == {
        'keypath': ['Customers'],
        'match': {
            'Name': 'John Doe'
        }
    })
    assert (SearchResults[2] == {
        'keypath': ['Customers', 'Address'],
        'match': {
            'Name': 'Home'
        }
    })
    assert (SearchResults[3] == {
        'keypath': ['Business[0]'],
        'match': {
            'Name': 'SomeBusiness'
        }
    })
    assert (SearchResults[4] == {
        'keypath': ['Business[0]', 'Address'],
        'match': {
            'Name': 'Primary'
        }
    })
    assert (SearchResults[5] == {
        'keypath': ['Business[0]', 'Address', 'Passcode[0]'],
        'match': {
            'Name': '12345'
        }
    })
    assert (SearchResults[6] == {
        'keypath': ['Business[0]', 'Address', 'Passcode[1]'],
        'match': {
            'Name': '54321'
        }
    })
    assert (SearchResults[7] == {
        'keypath': ['Business[0]', 'Address', 'Passcode[2]'],
        'match': {
            'Name': '34512'
        }
    })
    assert (SearchResults[8] == {
        'keypath': ['Business[0]', 'Address'],
        'match': {
            'TestList[1]': 'Name'
        }
    })
    assert (SearchResults[9] == {
        'keypath': ['Business[0]', 'Address', 'TestList[3]', 'TestList[3][2]'],
        'match': {
            'TestList[3][2][3]': 'Name'
        }
    })

    # Test No Results
    SearchResults = Lucidict.search("bogus")
    assert (isinstance(SearchResults, list))
    assert (len(SearchResults) == 0)
    '''Clean Up'''
    Lucidict._reset_instance()
    del TestDict
    del SearchResults
    del Lucidict
Exemple #10
0
def test_strict():
    '''Test the internal class get_strict, _set_strict, _unset_strict methods'''

    # Set the Lucidic Test Dict Object
    TestDict = getTestDict("simple_dict")
    Lucidict = Lucidic(TestDict)
    '''Test Lucidic._get_strict, Lucidic._set_strict and Lucidic._unset_strict method actions'''
    get_strict = Lucidict._get_strict()
    assert (isinstance(get_strict, bool))

    Lucidict._set_strict()
    get_strict = Lucidict._get_strict()
    assert (isinstance(get_strict, bool))
    assert (get_strict == True)

    Lucidict._unset_strict()
    get_strict = Lucidict._get_strict()
    assert (isinstance(get_strict, bool))
    assert (get_strict == False)
    '''Clean Up'''
    Lucidict._reset_instance()
    del TestDict
    del Lucidict
    del get_strict
Exemple #11
0
def test_search_recursive_list():
    '''Test the Lucidic method that attempts to recursively search a python list'''

    # Set the Lucidic Test Dict Object
    TestDict = getTestDict("nested_dict")
    TestList = getTestDict("simple_list")
    Lucidict = Lucidic(TestDict)
    '''Test expected method assertion exceptions:'''
    # k = str
    with pytest.raises(AssertionError):
        Lucidict._search_recursive_list(["parentKey"], TestList, TestList)
    # sublist = list
    with pytest.raises(AssertionError):
        Lucidict._search_recursive_list("parentKey", "TestList", TestList)
    # keypath = list
    with pytest.raises(AssertionError):
        Lucidict._search_recursive_list("parentKey", TestList, "TestList")
    '''Test Lucidic._search_recursive_list method actions'''
    # Set the keypath and keyword variables manually, this happens as part of the public search method call
    get_results = Lucidict._get_results()
    assert (isinstance(get_results, list))
    assert (len(get_results) == 0)

    Lucidict._set_strict()
    get_strict = Lucidict._get_strict()
    assert (isinstance(get_strict, bool))
    assert (get_strict == True)

    set_keyword = Lucidict._set_keyword("Unique")
    get_keyword = Lucidict._get_keyword()
    assert (isinstance(get_keyword, str))
    assert (get_keyword == "Unique")

    # Set the search dict method as a mock method so we can validate the recursive call count.
    Lucidict._search_recursive_list("Business", Lucidict.dict.get('Business'),
                                    [])

    # To validate that the search was successful, we can take a look at the results list.
    get_results = Lucidict._get_results()
    assert (len(get_results) == 1)
    assert (get_results[0] == {
        'keypath': ['Business[0]', 'Address', 'TestList[3]', 'TestList[3][2]'],
        'match': {
            'TestList[3][2][2]': 'Unique'
        }
    })
    '''Clean Up'''
    Lucidict._reset_instance()
    del TestDict
    del TestList
    del get_results
    del get_strict
    del get_keyword
    del set_keyword
    del Lucidict
Exemple #12
0
def test_replace_null_dict_values():
    '''Test the Lucidic method that attempts to scan the specified dict and replace None, Null, Nil, or Empty String values with a specified default value.'''

    # Copy the origin dict as the find null values public method will, and then set the Lucidic Test Dict Object
    TestDict = getTestDict("null_dict")
    Lucidict = Lucidic(TestDict)
    '''Test Lucidic._replace_null_dict_values None, Null, Nil, EmptyString replacement method action'''
    # dictobj = dict
    with pytest.raises(AssertionError):
        Lucidict._replace_null_dict_values("NotaDict")

    # Set the keyword variables and call the method.
    set_keyword = Lucidict._set_keyword("Undefined")
    get_keyword = Lucidict._get_keyword()
    assert (isinstance(get_keyword, str))
    assert (get_keyword == "Undefined")

    # Run the method on the dict
    Lucidict._replace_null_dict_values(Lucidict.dict)

    assert (isinstance(Lucidict.dict, dict))
    assert (Lucidict.dict != TestDict)
    ValidateDict = Lucidict.dict
    assert (ValidateDict.get('FirstTierKey2') == get_keyword)
    assert (
        ValidateDict.get('FirstTierKey3').get('SecondTierKey2') == get_keyword)
    assert (
        ValidateDict.get('FirstTierKey3').get('SecondTierKey3') == get_keyword)
    assert (ValidateDict.get('FirstTierKey3').get('SecondTierKey4').get(
        'ThirdTierKey1') == get_keyword)
    assert (ValidateDict.get('FirstTierKey3').get('SecondTierKey4').get(
        'ThirdTierKey2')[0].get('FourthListTierKey1') == get_keyword)
    assert (ValidateDict.get('FirstTierKey3').get('SecondTierKey4').get(
        'ThirdTierKey2')[1].get('FourthListTierKey2') == get_keyword)

    del ValidateDict
    '''Test Lucidict._replace_null_dict_values replace key method action'''
    # Testing the key replacement of the following dict: {"FourthListTierKey3": "FourthListTierValue3"}

    # key_replace = str
    with pytest.raises(AssertionError):
        Lucidict._replace_null_dict_values(Lucidict.dict,
                                           key_replace=["FourthListTierKey3"])

    # Set the keyword variables and call the method.
    set_keyword = Lucidict._set_keyword("ChangedKey1")
    get_keyword = Lucidict._get_keyword()
    assert (isinstance(get_keyword, str))
    assert (get_keyword == "ChangedKey1")

    # Run the method on the dict
    Lucidict._replace_null_dict_values(Lucidict.dict,
                                       key_replace="FourthListTierKey3")

    # Set a variable to use as a reference to validate that the previously replace values are still in tact.
    confirmVal = "Undefined"
    assert (isinstance(Lucidict.dict, dict))
    assert (Lucidict.dict != TestDict)
    assert (Lucidict.dict.get('FirstTierKey2') == confirmVal)
    assert (
        Lucidict.dict.get('FirstTierKey3').get('SecondTierKey2') == confirmVal)
    assert (
        Lucidict.dict.get('FirstTierKey3').get('SecondTierKey3') == confirmVal)
    assert (Lucidict.dict.get('FirstTierKey3').get('SecondTierKey4').get(
        'ThirdTierKey1') == confirmVal)
    assert (Lucidict.dict.get('FirstTierKey3').get('SecondTierKey4').get(
        'ThirdTierKey2')[0].get('FourthListTierKey1') == confirmVal)
    assert (Lucidict.dict.get('FirstTierKey3').get('SecondTierKey4').get(
        'ThirdTierKey2')[1].get('FourthListTierKey2') == confirmVal)
    assert (Lucidict.dict.get('FirstTierKey3').get('SecondTierKey4').get(
        'ThirdTierKey2')[2].get(get_keyword) == "FourthListTierValue3")
    '''Test Lucidic._replace_null_dict_values replace value method action'''
    # Testing the value replacement of the following dict: {"FourthListTierKey3": "FourthListTierValue3"}

    # value_replace = str
    with pytest.raises(AssertionError):
        Lucidict._replace_null_dict_values(
            Lucidict.dict, value_replace=["FourthListTierKey3"])

    # Set the keyword variables and call the method.
    set_keyword = Lucidict._set_keyword("ChangedValue1")
    get_keyword = Lucidict._get_keyword()
    assert (isinstance(get_keyword, str))
    assert (get_keyword == "ChangedValue1")

    # Run the method on the dict
    Lucidict._replace_null_dict_values(Lucidict.dict,
                                       value_replace="FourthListTierValue3")

    # Set a variable to use as a reference to validate that the previously replace values are still in tact.
    confirmVal = "Undefined"
    assert (isinstance(Lucidict.dict, dict))
    assert (Lucidict.dict != TestDict)
    assert (Lucidict.dict.get('FirstTierKey2') == confirmVal)
    assert (
        Lucidict.dict.get('FirstTierKey3').get('SecondTierKey2') == confirmVal)
    assert (
        Lucidict.dict.get('FirstTierKey3').get('SecondTierKey3') == confirmVal)
    assert (Lucidict.dict.get('FirstTierKey3').get('SecondTierKey4').get(
        'ThirdTierKey1') == confirmVal)
    assert (Lucidict.dict.get('FirstTierKey3').get('SecondTierKey4').get(
        'ThirdTierKey2')[0].get('FourthListTierKey1') == confirmVal)
    assert (Lucidict.dict.get('FirstTierKey3').get('SecondTierKey4').get(
        'ThirdTierKey2')[1].get('FourthListTierKey2') == confirmVal)
    assert (Lucidict.dict.get('FirstTierKey3').get('SecondTierKey4').get(
        'ThirdTierKey2')[2].get('ChangedKey1') == get_keyword)
    '''Clean Up'''
    Lucidict._reset_instance()
    del TestDict
    del get_keyword
    del set_keyword
    del Lucidict
Exemple #13
0
def test_results():
    '''Test the internal class _get_results, _set_results, _clear_results methods'''

    # Set the Lucidic Test Dict Object
    TestDict = getTestDict("simple_dict")
    Lucidict = Lucidic(TestDict)
    '''Test Lucidic._set_result, Lucidic._get_result and Lucidic._clear_result method actions'''
    get_results = Lucidict._get_results()
    assert (isinstance(get_results, list))
    assert (len(get_results) == 0)
    assert (get_results == [])

    set_results = {"Key": "Value"}
    Lucidict._set_results(set_results)
    get_results = Lucidict._get_results()
    assert (isinstance(get_results, list))
    assert (len(get_results) == 1)
    assert (get_results == [set_results])

    Lucidict._clear_results()
    get_results = Lucidict._get_results()
    assert (isinstance(get_results, list))
    assert (len(get_results) == 0)
    assert (get_results == [])
    '''Clean Up'''
    Lucidict._reset_instance()
    del TestDict
    del Lucidict
    del get_results
    del set_results
Exemple #14
0
def test_search_item_match():
    '''Test the Lucidic method that attempts to match the specified keyword with the current list item, or dict key/value'''

    # Set the Lucidic Test Dict Object
    TestDict = getTestDict("simple_nested_dict")
    TestList = getTestDict("simple_list")
    Lucidict = Lucidic(TestDict)
    '''Test expected method assertion exceptions:'''
    # key = str
    with pytest.raises(AssertionError):
        Lucidict._search_item_match(["Key1"], "Item", TestList)
    # value = !dict
    with pytest.raises(AssertionError):
        Lucidict._search_item_match("Key1", {"Name": "Item"}, TestList)
    # value = !list
    with pytest.raises(AssertionError):
        Lucidict._search_item_match("Key1", ["Item"], TestList)
    # keyPath = list
    with pytest.raises(AssertionError):
        Lucidict._search_item_match("Key1", "Item", "TestList")
    '''Test Lucidic._search_item_match method actions'''
    '''Loose Search Test'''
    # Construct the object test conditions by setting necessary Lucidic attributes.
    get_results = Lucidict._get_results()
    assert (isinstance(get_results, list))
    assert (len(get_results) == 0)

    get_strict = Lucidict._get_strict()
    assert (isinstance(get_strict, bool))
    assert (get_strict == False)

    set_keyword = Lucidict._set_keyword("Name")
    get_keyword = Lucidict._get_keyword()
    assert (isinstance(get_keyword, str))
    assert (get_keyword == "Name")

    # Call the search method and validate the expected results.
    # Because we know the dict is a 2 layer dict, write the test to validate it as such
    for k1, v1 in Lucidict.dict.items():
        if isinstance(v1, dict):
            for k2, v2 in v1.items():
                Lucidict._search_item_match(k2, v2, [k1])
        else:
            Lucidict._search_item_match(k1, v1, [])

    # Check the set result list to ensure that the results match accordingly to the passed dict obj.
    get_results = Lucidict._get_results()
    assert (isinstance(get_results, list))
    assert (len(get_results) == 2)
    assert (isinstance(get_results[0], dict))
    assert (get_results[0] == {
        'keypath': ["Record"],
        'match': {
            "Name": "Test Dictionary"
        }
    })
    assert (isinstance(get_results[1], dict))
    assert (get_results[1] == {
        'keypath': ["Record"],
        'match': {
            "Type": "SomeRecordTypeName"
        }
    })
    '''Exact Search Test'''
    # Reset the _search_results variable to get a fresh result set.
    Lucidict._clear_results()
    # reset the _strict variable to enforce strict match
    Lucidict._set_strict()

    # Call the search method and validate the expected results.
    # Because we know the dict is a 2 layer dict, write the test to validate it as such
    for k1, v1 in Lucidict.dict.items():
        if isinstance(v1, dict):
            for k2, v2 in v1.items():
                Lucidict._search_item_match(k2, v2, [k1])
        else:
            Lucidict._search_item_match(k1, v1, [])

    # Check the set result list to ensure that the results match accordingly to the passed dict obj.
    get_results = Lucidict._get_results()
    assert (isinstance(get_results, list))
    assert (len(get_results) == 1)
    assert (isinstance(get_results[0], dict))
    assert (get_results[0] == {
        'keypath': ["Record"],
        'match': {
            "Name": "Test Dictionary"
        }
    })
    '''Clean Up'''
    Lucidict._reset_instance()
    del TestDict
    del TestList
    del get_results
    del get_strict
    del get_keyword
    del set_keyword
    del Lucidict
Exemple #15
0
def test_construct_list_keypath():
    '''Test the Lucidic method that constructs a keypath string that can be appended to the result list from a list item and it's index.'''

    # Set the Lucidic Test Dict Object
    TestDict = getTestDict("simple_dict")
    TestList = getTestDict("simple_list")
    Lucidict = Lucidic(TestDict)
    '''Test expected method assertion exceptions:'''
    # keypath = list
    with pytest.raises(AssertionError):
        Lucidict._construct_list_keypath("TestList", "Key", 0)
    # k = str
    with pytest.raises(AssertionError):
        Lucidict._construct_list_keypath(TestList, ["Key"], 0)
    # list_index = int
    with pytest.raises(AssertionError):
        Lucidict._construct_list_keypath(TestList, "Key", "0")
    '''Test Lucidic._construct_list_keypath method actions'''
    # Test Setting results in the _search_results internal method by calling method with valid parameters.
    list_keypath = Lucidict._construct_list_keypath(TestList, "Key1", 0)
    assert (isinstance(list_keypath, list))
    assert (len(list_keypath) == 3)
    assert (list_keypath[0] == "Name")
    assert (list_keypath[1] == "TestList")
    assert (list_keypath[2] == "Key1[0]")
    '''Clean Up'''
    Lucidict._reset_instance()
    del TestDict
    del TestList
    del list_keypath
    del Lucidict
Exemple #16
0
def test_set_search_result():
    '''Test the Lucidic Update Results Internal Method'''

    # Set the Lucidic Test Dict Object
    TestDict = getTestDict("simple_dict")
    TestList = getTestDict("simple_list")
    Lucidict = Lucidic(TestDict)
    '''Test expected method assertion exceptions:'''
    # keypath = list
    with pytest.raises(AssertionError):
        Lucidict._set_search_result("TestList", TestDict)
    # match = dict
    with pytest.raises(AssertionError):
        Lucidict._set_search_result(TestList, "TestDict")
    '''Test Lucidic._set_search_result method actions'''
    # Ensure the result list object is empty
    get_results = Lucidict._get_results()
    assert (isinstance(get_results, list))
    assert (len(get_results) == 0)
    assert (get_results == [])

    # Call the method and pass it an empty keypath list, and mock K/V Dict
    Lucidict._set_search_result([], {"Key1": "Value1"})
    get_results = Lucidict._get_results()
    assert (isinstance(get_results, list))
    assert (len(get_results) == 1)
    assert (isinstance(get_results[0], dict))
    assert (get_results[0] == {'keypath': [], 'match': {'Key1': 'Value1'}})

    # Call the method again and pass it an 1 item keypath list, and mock K/V Dict
    Lucidict._set_search_result(["Key1"], {"SubKey1": "Value2"})
    get_results = Lucidict._get_results()
    assert (isinstance(get_results, list))
    assert (len(get_results) == 2)
    assert (isinstance(get_results[0], dict))
    assert (get_results[0] == {'keypath': [], 'match': {'Key1': 'Value1'}})
    assert (isinstance(get_results[1], dict))
    assert (get_results[1] == {
        'keypath': ["Key1"],
        'match': {
            'SubKey1': 'Value2'
        }
    })
    '''Clean Up'''
    # Clear the search results, in case we run it later
    Lucidict._reset_instance()
    del TestDict
    del TestList
    del get_results
    del Lucidict
Exemple #17
0
def test_rest_instance():
    '''Test the Lucidic Reset Instance Environment Method'''

    # Set the Lucidic Test Dict Object
    TestDict = getTestDict("simple_dict")
    Lucidict = Lucidic(TestDict)

    # Set and Validate values for results, keyword, and strict
    Lucidict._set_strict()
    get_strict = Lucidict._get_strict()
    assert (isinstance(get_strict, bool))
    assert (get_strict == True)

    Lucidict._set_keyword("TestKeyword")
    get_keyword = Lucidict._get_keyword()
    assert (isinstance(get_keyword, str))
    assert (get_keyword == "TestKeyword")

    set_results = {"Key": "Value"}
    Lucidict._set_results(set_results)
    get_results = Lucidict._get_results()
    assert (isinstance(get_results, list))
    assert (len(get_results) == 1)
    assert (get_results == [set_results])

    # Use the reset
    Lucidict._reset_instance()

    # Validate all previously assigned values were removed.
    get_strict = Lucidict._get_strict()
    assert (isinstance(get_strict, bool))
    assert (get_strict == False)

    get_keyword = Lucidict._get_keyword()
    assert (isinstance(get_keyword, str))
    assert (get_keyword == "")

    get_results = Lucidict._get_results()
    assert (isinstance(get_results, list))
    assert (len(get_results) == 0)
    assert (get_results == [])
    '''Clean Up'''
    Lucidict._reset_instance()
    del TestDict
    del Lucidict
    del get_strict
    del get_keyword
    del set_results
    del get_results