def test_check_equal_nested(self):
self.assertTrue(
check_equal(
{'a': [None, 1, 2, {}], 'b': 1},
{'b': 1, 'a': [1, 2, None, {}]},
),
)
self.assertFalse(
check_equal(
{'a': [None, 1, 2, {}], 'b': 1},
{'b': 1, 'a': [1, 2, {}, {}]},
),
)
self.assertTrue(
check_equal(
[{'a': 1, 'b': True, 'c': ['a', 1]}, 1, 2],
[2, 1, {'c': [1, 'a'], 'a': 1, 'b': True}],
),
)
self.assertFalse(
check_equal(
[{'a': 1, 'b': True, 'c': ['a', 1]}, 1, 2],
[2, 1, {'c': [1, 'a'], 'a': 1, 'b': 1}],
),
)
def test_check_equal_null(self):
self.assertTrue(check_equal(0, 0), )
self.assertFalse(check_equal(0, None), )
self.assertFalse(check_equal(None, False), )
self.assertTrue(check_equal(None, None), )
def test_check_equal_dict(self):
self.assertTrue(
check_equal({'a': 0, 'b': 1}, {'b': 1, 'a': 0}),
)
self.assertFalse(
check_equal({'a': 0, 'b': 1}, {'b': 0, 'a': 1}),
)
def test_check_equal_list(self):
self.assertTrue(check_equal(['a', 'b', 0, 1, 2],
[1, 2, 0, 'b', 'a']), )
self.assertFalse(check_equal(['a', 'b', 0, 1, 2], [1, 2, 0, 'b']), )
self.assertFalse(check_equal(['a', 'b', 0, 1, 2],
[1, 2, 0, 'b', 'c']), )
self.assertFalse(check_equal(['a', 'b', 0, 1, 2],
[1, 4, 0, 'a', 'b']), )
def test_check_equal_nested(self):
self.assertTrue(
check_equal(
{
'a': [None, 1, 2, {}],
'b': 1
},
{
'b': 1,
'a': [1, 2, None, {}]
},
), )
self.assertFalse(
check_equal(
{
'a': [None, 1, 2, {}],
'b': 1
},
{
'b': 1,
'a': [1, 2, {}, {}]
},
), )
self.assertTrue(
check_equal(
[{
'a': 1,
'b': True,
'c': ['a', 1]
}, 1, 2],
[2, 1, {
'c': [1, 'a'],
'a': 1,
'b': True
}],
), )
self.assertFalse(
check_equal(
[{
'a': 1,
'b': True,
'c': ['a', 1]
}, 1, 2],
[2, 1, {
'c': [1, 'a'],
'a': 1,
'b': 1
}],
), )
def test_check_equal_null(self):
self.assertTrue(
check_equal(0, 0),
)
self.assertFalse(
check_equal(0, None),
)
self.assertFalse(
check_equal(None, False),
)
self.assertTrue(
check_equal(None, None),
)
def test_check_equal_list(self):
self.assertTrue(
check_equal(['a', 'b', 0, 1, 2], [1, 2, 0, 'b', 'a']),
)
self.assertFalse(
check_equal(['a', 'b', 0, 1, 2], [1, 2, 0, 'b']),
)
self.assertFalse(
check_equal(['a', 'b', 0, 1, 2], [1, 2, 0, 'b', 'c']),
)
self.assertFalse(
check_equal(['a', 'b', 0, 1, 2], [1, 4, 0, 'a', 'b']),
)
def test_inventory_targeting_utils(self):
adunit1_or_adunit2 = TargetingCriterion(
[AdUnit(id='1'), AdUnit(id='2')],
TargetingCriterion.OPERATOR.OR,
)
dfp_adunit1_or_adunit2 = {
'targetedAdUnits': [
{
'includeDescendants': True,
'adUnitId': '1',
},
{
'includeDescendants': True,
'adUnitId': '2',
},
],
}
# Check transform_inventory_targeting_to_dfp
self.assertTrue(check_equal(
dfp_adunit1_or_adunit2,
transform_inventory_targeting_to_dfp(adunit1_or_adunit2),
))
# Check transform_inventory_targeting_from_dfp
self.assertTrue(check_equal(
adunit1_or_adunit2,
transform_inventory_targeting_from_dfp(dfp_adunit1_or_adunit2),
))
not_adunit3 = TargetingCriterion(
[TargetingCriterion([AdUnit(id='3')], TargetingCriterion.OPERATOR.OR)],
TargetingCriterion.OPERATOR.NOT,
)
dfp_not_adunit3 = {
'excludedAdUnits': [
{
'includeDescendants': True,
'adUnitId': '3',
},
],
}
# Check transform_inventory_targeting_to_dfp
self.assertTrue(check_equal(
dfp_not_adunit3,
transform_inventory_targeting_to_dfp(not_adunit3),
))
# Check transform_inventory_targeting_from_dfp
self.assertTrue(check_equal(
not_adunit3,
transform_inventory_targeting_from_dfp(dfp_not_adunit3),
))
adunit1_or_adunit2_and_not_adunit3 = TargetingCriterion(
[adunit1_or_adunit2, not_adunit3],
TargetingCriterion.OPERATOR.AND,
)
dfp_adunit1_or_adunit2_and_not_adunit3 = {
'targetedAdUnits': [
{
'includeDescendants': True,
'adUnitId': '1',
},
{
'includeDescendants': True,
'adUnitId': '2',
},
],
'excludedAdUnits': [
{
'includeDescendants': True,
'adUnitId': '3',
},
],
}
# Check transform_inventory_targeting_to_dfp
self.assertTrue(check_equal(
dfp_adunit1_or_adunit2_and_not_adunit3,
transform_inventory_targeting_to_dfp(adunit1_or_adunit2_and_not_adunit3),
))
# Check transform_inventory_targeting_from_dfp
self.assertTrue(check_equal(
adunit1_or_adunit2_and_not_adunit3,
transform_inventory_targeting_from_dfp(dfp_adunit1_or_adunit2_and_not_adunit3),
))
def test_technology_targeting_utils(self):
tech1 = Technology(
id='1',
type=TechnologyTargetTypes.browser,
name='chrome',
)
tech2 = Technology(
id='2',
type=TechnologyTargetTypes.device_category,
name='mobile',
)
tech3 = Technology(
id='3',
type=TechnologyTargetTypes.device_category,
name='desktop',
)
tech1_target = TargetingCriterion(tech1)
dfp_tech1 = {
'browserTargeting': {
'browsers': [
{
'id': '1',
},
],
'isTargeted': True,
},
}
self.assertTrue(check_equal(
dfp_tech1,
transform_technology_targeting_to_dfp(tech1_target),
))
not_tech1 = ~tech1_target
dfp_not_tech1 = {
'browserTargeting': {
'browsers': [
{
'id': '1',
},
],
'isTargeted': False,
},
}
self.assertTrue(check_equal(
dfp_not_tech1,
transform_technology_targeting_to_dfp(not_tech1),
))
tech2_or_tech3 = TargetingCriterion(
[tech2, tech3],
TargetingCriterion.OPERATOR.OR,
)
dfp_tech1_or_tech2 = {
'deviceCategoryTargeting': {
'targetedDeviceCategories': [
{
'id': '2',
},
{
'id': '3',
},
],
},
}
self.assertTrue(check_equal(
dfp_tech1_or_tech2,
transform_technology_targeting_to_dfp(tech2_or_tech3),
))
tech2_and_not_tech3 = TargetingCriterion(tech2) & ~TargetingCriterion(tech3)
dfp_tech2_and_not_tech3 = {
'deviceCategoryTargeting': {
'targetedDeviceCategories': [
{
'id': '2',
},
],
'excludedDeviceCategories': [
{
'id': '3',
},
],
},
}
self.assertTrue(check_equal(
dfp_tech2_and_not_tech3,
transform_technology_targeting_to_dfp(tech2_and_not_tech3),
))
tech1_and_tech2_and_not_tech3 = TargetingCriterion(tech1) & tech2_and_not_tech3
dfp_tech1_and_tech2_and_not_tech3 = {
'deviceCategoryTargeting': {
'targetedDeviceCategories': [
{
'id': '2',
},
],
'excludedDeviceCategories': [
{
'id': '3',
},
],
},
'browserTargeting': {
'browsers': [
{
'id': '1',
},
],
'isTargeted': True,
},
}
self.assertTrue(check_equal(
dfp_tech1_and_tech2_and_not_tech3,
transform_technology_targeting_to_dfp(tech1_and_tech2_and_not_tech3),
))
# Test reflexivity
self.assertTrue(check_equal(
dfp_tech1_and_tech2_and_not_tech3,
transform_technology_targeting_to_dfp(
transform_technology_targeting_from_dfp(
dfp_tech1_and_tech2_and_not_tech3,
),
),
))
def test_geography_targeting_utils(self):
geo1 = Geography(
id='1',
type='country',
name='France',
)
geo2 = Geography(
id='2',
type='country',
name='Germany',
)
geo3 = Geography(
id='3',
type='country',
name='Greece',
)
geo1_or_geo2 = TargetingCriterion(
[geo1, geo2],
TargetingCriterion.OPERATOR.OR,
)
dfp_geo1_or_geo2 = {
'targetedLocations': [
{
'type': 'country',
'displayName': 'France',
'id': '1',
},
{
'type': 'country',
'displayName': 'Germany',
'id': '2',
},
],
}
# Check transform_inventory_targeting_to_dfp
self.assertTrue(check_equal(
dfp_geo1_or_geo2,
transform_geography_targeting_to_dfp(geo1_or_geo2),
))
# Check transform_inventory_targeting_from_dfp
self.assertTrue(check_equal(
geo1_or_geo2,
transform_geography_targeting_from_dfp(dfp_geo1_or_geo2),
))
not_geo3 = TargetingCriterion(
[TargetingCriterion([geo3], TargetingCriterion.OPERATOR.OR)],
TargetingCriterion.OPERATOR.NOT,
)
dfp_not_geo3 = {
'excludedLocations': [
{
'type': 'country',
'displayName': 'Greece',
'id': '3',
},
],
}
# Check transform_inventory_targeting_to_dfp
self.assertTrue(check_equal(
dfp_not_geo3,
transform_geography_targeting_to_dfp(not_geo3),
))
# Check transform_inventory_targeting_from_dfp
self.assertTrue(check_equal(
not_geo3,
transform_geography_targeting_from_dfp(dfp_not_geo3),
))
geo1_or_geo2_and_not_geo3 = TargetingCriterion(
[geo1_or_geo2, not_geo3],
TargetingCriterion.OPERATOR.AND,
)
dfp_geo1_or_geo2_and_not_geo3 = {
'targetedLocations': [
{
'type': 'country',
'displayName': 'France',
'id': '1',
},
{
'type': 'country',
'displayName': 'Germany',
'id': '2',
},
],
'excludedLocations': [
{
'type': 'country',
'displayName': 'Greece',
'id': '3',
},
],
}
# Check transform_inventory_targeting_to_dfp
self.assertTrue(check_equal(
dfp_geo1_or_geo2_and_not_geo3,
transform_geography_targeting_to_dfp(geo1_or_geo2_and_not_geo3),
))
# Check transform_inventory_targeting_from_dfp
self.assertTrue(check_equal(
geo1_or_geo2_and_not_geo3,
transform_geography_targeting_from_dfp(dfp_geo1_or_geo2_and_not_geo3),
))
def __eq__(self, other):
if not isinstance(other, TargetingCriterion):
return False
return check_equal(self._data, other._data)
def test_check_equal_dict(self):
self.assertTrue(check_equal({'a': 0, 'b': 1}, {'b': 1, 'a': 0}), )
self.assertFalse(check_equal({'a': 0, 'b': 1}, {'b': 0, 'a': 1}), )
