def test_sample_data5(self):
self.assertEqual(
1, get_occurrence_of_key(self.sample5, 'total_number_of_cores'))
self.assertEqual(1, get_occurrence_of_key(self.sample5, 'memory'))
# Add key 'memory' and verify
self.sample5['memory'] = 0
self.assertEqual(2, get_occurrence_of_key(self.sample5, 'memory'))
def non_essential_count(base_json):
#base_json = non_essential_json(base_path, cc_id)
return {
"total": get_occurrence_of_key(base_json, key="Touchstatus"),
"essential": get_occurrence_of_value(base_json, value=True),
"non-essential": get_occurrence_of_value(base_json, value=False)
}
def __get(self, b_dict: dict, key: str, prefix: str = ""):
"""Get preference.
Args:
b_dict (dict): Dictionary to search.
key (str): Preference to peek. Can be full path preference.
prefix (:obj:`str`, optional): Prefix defining which sub-config to search.
For example, to access the key ``"visualization/rcParams"``,
this parameter should be ``"visualization"``.
Returns:
The preference value, sub-dictionary to search
"""
p_keys = self._get_prefixes(key)
key = p_keys[-1]
k_prefixes = list(p_keys[:-1])
prefixes = list(self._get_prefixes(prefix))
prefixes.extend(k_prefixes)
subdict = b_dict
for p in prefixes:
subdict = subdict[p]
num_keys = nested_lookup.get_occurrence_of_key(subdict, key)
if num_keys == 0:
raise KeyError("Key not '%s ' found in prefix '%s'" %
(key, prefix))
if num_keys > 1:
raise KeyError(
"Multiple keys '%s 'found in prefix '%s'. Provide a more specific prefix."
% (key, prefix))
return nested_lookup.nested_lookup(key, subdict)[0], subdict
def test_set(self):
a = PreferencesMock()
# Raise error when key doesn't exist.
with self.assertRaises(KeyError):
a.set("sample-key", "bar")
# Raise error when key is not specific.
assert nested_lookup.get_occurrence_of_key(a.config,
"foo") > 1, "%s." % a.config
with self.assertRaises(KeyError):
a.set("foo", 100)
# Raise error when value is not the same
with self.assertRaises(TypeError):
a.set("testing1/foo", "bar")
# Success when using full path or prefix kwarg
a.set("testing1/foo", 50)
assert a.get(
"testing1/foo") == 50, "Value mismatch: got %s, expected %s" % (
a.get("testing1/foo"),
50,
)
a.set("foo", 100, "testing1")
assert a.get(
"testing1/foo") == 100, "Value mismatch: got %s, expected %s" % (
a.get("testing1/foo"),
100,
)
def _verify_key_exists(self, key, lookup_dict):
"""
Return True if the specified key exists in our lookup_dict.
This is a protected method and should not be used outside of the public
convert_it method. This method is responsible for checking to see if we
get a hit on a specified key in a lookup on our dict. This helps us
ensure that during conversion, if any labels annotations or otherwise
will be unaffected by the conversion and thusly not return empty lists.
Parameters
----------
key : str
The key we are looking up in lookup_dict.
lookup_dict : str
The lookup_dict is in our case an alert from an arbitrary alerting
system to be converted to an alert that Alert manager will accept.
Returns
-------
exists : boolean
Simple flag, True or False, to let us know if our search was
successful.
"""
exists = False
if get_occurrence_of_key(lookup_dict, key) > 0:
exists = True
return exists
def test_sample_data4(self):
result = get_occurrence_of_key(self.sample4, "checks")
self.assertEqual(1, result)
result = get_occurrence_of_value(self.sample4, "mziad")
self.assertEqual(1, result)
# Add one more value in key "monitoring_zones" and verify
self.sample4["values"][0]["checks"][0]["monitoring_zones"].append("mziad")
self.assertEqual(2, get_occurrence_of_value(self.sample4, "mziad"))
def non_essential_count(base_json, filter="workspace"):
#base_json = non_essential_json(base_path, cc_id)
return {
"folder": filter,
"total": get_occurrence_of_key(base_json, key="Touchstatus"),
"essential": get_occurrence_of_value(base_json, value=True),
"non-essential": get_occurrence_of_value(base_json, value=False)
}
def test_sample_data4(self):
result = get_occurrence_of_key(self.sample4, 'checks')
self.assertEqual(1, result)
result = get_occurrence_of_value(self.sample4, 'mziad')
self.assertEqual(1, result)
# Add one more value in key "monitoring_zones" and verify
self.sample4['values'][0]['checks'][0]['monitoring_zones'].append(
'mziad')
self.assertEqual(2, get_occurrence_of_value(self.sample4, 'mziad'))
def test_get(self):
a = PreferencesMock()
# Raise error when key doesn't exist.
with self.assertRaises(KeyError):
a.get("sample-key")
# Raise error when key is not specific.
assert nested_lookup.get_occurrence_of_key(a.config, "foo") > 1
with self.assertRaises(KeyError):
a.get("foo")
# No error when lookup is specific.
a.get("testing1/foo")
def filter_line(stat, filter_dict, or_and=True, include_absent=True):
"""
stat - dict which represents JSONL line
filter_dict - simple dict to use for filtering
or_and - True for OR logic else AND
include_absent - if True and filter finds nothing return True
returns True if line has entry from filter_dict
Currently support simple keys and values
"""
found = [filter_dict[k] in nl.nested_lookup(k, stat) for k in filter_dict]
num_exist = [nl.get_occurrence_of_key(stat, k) for k in filter_dict]
return (include_absent and sum(num_exist)
== 0) or (or_and and any(found)) or (not or_and and all(found))
def test_sample_data3(self):
result = get_occurrence_of_key(self.sample3, 'total_number_of_cores')
self.assertEqual(3, result)
result = get_occurrence_of_value(self.sample3, '4')
self.assertEqual(3, result)
def test_sample_data2(self):
result = get_occurrence_of_key(self.sample2, 'core_details')
self.assertEqual(1, result)
result = get_occurrence_of_value(self.sample2, '4')
self.assertEqual(3, result)
def test_sample_data1(self):
result = get_occurrence_of_key(self.sample1, 'build_version')
self.assertEqual(4, result)
result = get_occurrence_of_value(self.sample1, '256 KB')
self.assertEqual(2, result)
