def test_assignment_not_allowed_on_udm_access(self) -> None:
event = {
'dst_ip': '1.1.1.1',
'dst_port': '2222',
'extra': {
'timestamp': 1,
'array': [1, 2]
}
}
data_model = DataModel({
'versionId':
'version',
'mappings': [{
'name': 'destination_ip',
'path': 'dst_ip'
}, {
'name': 'extra_fields',
'path': 'extra'
}],
'id':
'data_model_id'
})
enriched_event = PantherEvent(event, data_model)
self.assertEqual(ImmutableCaseInsensitiveDict(event['extra']),
enriched_event.udm('extra_fields'))
self.assertIsInstance(enriched_event.udm('extra_fields'),
ImmutableCaseInsensitiveDict)
self.assertIsInstance(
enriched_event.udm('extra_fields')['array'], ImmutableList)
with self.assertRaises(TypeError):
enriched_event.udm('extra_fields')['timestamp'] = 10
def test_equality(self) -> None:
# Equality with dict
self.assertEqual(self.immutable_dict, self.initial_dict)
# Equality with another instance
equal_dict = deepcopy(self.initial_dict)
other_immutable_dict = ImmutableCaseInsensitiveDict(equal_dict)
self.assertEqual(other_immutable_dict, self.immutable_dict)
def test_ensure_immutable(self) -> None:
initial_dict = {
'a': [[1, 2], [3, 4]],
'b': {
'c': {
'd': 1
}
},
't': 10,
'e': {
'f': [{
'g': 90
}]
}
}
immutable_dict = ImmutableCaseInsensitiveDict(initial_dict)
# List of lists with immutable elements
self.assertIsInstance(immutable_dict['a'], ImmutableList)
self.assertIsInstance(immutable_dict['a'][0], ImmutableList)
self.assertEqual(immutable_dict['a'][0][1], 2)
# Two-level nested dictionary
self.assertIsInstance(immutable_dict['b'],
ImmutableCaseInsensitiveDict)
self.assertIsInstance(immutable_dict['b']['c'],
ImmutableCaseInsensitiveDict)
self.assertEqual(immutable_dict['b']['c']['d'], 1)
# Plain immutable object at top-level
self.assertIsInstance(immutable_dict['t'], int)
self.assertEqual(immutable_dict['t'], 10)
# Two-level dictionary with nested list as value
self.assertIsInstance(immutable_dict['e']['f'], ImmutableList)
self.assertIsInstance(immutable_dict['e']['f'][0],
ImmutableCaseInsensitiveDict)
self.assertEqual(immutable_dict['e']['f'][0]['g'], 90)
def test_on_conflict_first_occurrence_returned(self) -> None:
data = {
'X-Forwarded-For': '10.0.0.1, 10.0.0.2',
'X-FORWARDED-FOR': '10.0.0.3, 10.0.0.4'
}
case_insensitive_dict = ImmutableCaseInsensitiveDict(data)
self.assertEqual(case_insensitive_dict['X-FORWARDED-FOR'],
'10.0.0.3, 10.0.0.4')
self.assertEqual(case_insensitive_dict['x-forwarded-for'],
data['X-Forwarded-For'])
def setUp(self) -> None:
self.data = {
'Content-Encoding': 'gzip',
'ACCEPT': '*/*',
'X-Forwarded-For': '10.0.0.1, 10.0.0.2',
'Request': {
'HTTP_version': '1.1',
'query': 'p=1&r=2'
}
}
self.case_insensitive_dict = ImmutableCaseInsensitiveDict(self.data)
def setUp(self) -> None:
self.initial_dict = {
't': 10,
'a': [{
'b': 1,
'c': 2
}],
'd': {
'e': {
'f': True
}
}
}
self.immutable_dict = ImmutableCaseInsensitiveDict(self.initial_dict)
def test_copy(self) -> None:
initial_dict = {
'a': True,
'b': {
'c': {
'e': True,
'd': [{
'g': False
}]
}
}
}
immutable_dict = ImmutableCaseInsensitiveDict(initial_dict)
dict_copy = immutable_dict.copy()
self.assertIsNot(dict_copy, initial_dict)
self.assertIsNot(dict_copy['b'], initial_dict['b'])
self.assertEqual(dict_copy['b'], initial_dict['b'])
self.assertIsInstance(dict_copy['b'], dict)
self.assertIsInstance(dict_copy['b']['c'], dict)
self.assertIsInstance(dict_copy['b']['c']['d'], list)
self.assertIsNot(dict_copy['b']['c']['d'],
initial_dict['b']['c']['d']) # type: ignore
dict_copy['h'] = False
self.assertIs(dict_copy['h'], False)
def test_on_empty_container_raises_key_error(self) -> None:
case_insensitive_dict = ImmutableCaseInsensitiveDict({})
with self.assertRaisesRegex(KeyError, 'non_existing_key'):
_ = case_insensitive_dict['non_existing_key']
def test_immutable_dict(self) -> None:
initial_dict = {'a': [1, 2, 3], 'b': {'c': True}}
immutable_dict = ImmutableCaseInsensitiveDict(initial_dict)
self.assertEqual(json.dumps(initial_dict),
json.dumps(immutable_dict, default=json_encoder))
def setUp(self) -> None:
self.initial_dict = {'a': [1, 2]}
self.immutable_dict = ImmutableCaseInsensitiveDict(self.initial_dict)