Issue 2982 - Only return notifications that have at least one entry for title and message

sitescripts/notifications/test/notification.py

 # coding: utf-8
 
 # This file is part of the Adblock Plus web scripts,
 # Copyright (C) 2006-2015 Eyeo GmbH
 #
 # Adblock Plus is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License version 3 as
 # published by the Free Software Foundation.
 #
 # Adblock Plus is distributed in the hope that it will be useful,
@@ skipping 13 matching lines @@
 class TestNotification(unittest.TestCase):
   def setUp(self):
     self.load_notifications_patcher = mock.patch("sitescripts.notifications.web.notification.load_notifications")
     self.load_notifications_mock = self.load_notifications_patcher.start()
 
   def tearDown(self):
     self.load_notifications_patcher.stop()
 
   def test_no_group(self):
     self.load_notifications_mock.return_value = [
-      {"id": "1", "title": {}, "message": {}}
+      {"id": "1", "title": {"en-US": ""}, "message": {"en-US": ""}}
     ]
     result = json.loads(notification.notification({}, lambda *args: None))
     self.assertEqual(len(result["notifications"]), 1)
     self.assertEqual(result["notifications"][0]["id"], "1")
     self.assertFalse("-" in result["version"])
 
   def test_not_in_group(self):
     self.load_notifications_mock.return_value = [
-      {"id": "1", "title": {}, "message": {}},
-      {"id": "a", "variants": [{"title": {}, "message": {}}]}
+      {"id": "1", "title": {"en-US": ""}, "message": {"en-US": ""}},
+      {"id": "a", "variants": [
+        {"title": {"en-US": ""}, "message": {"en-US": ""}}
+      ]}
     ]
     result = json.loads(notification.notification({
       "QUERY_STRING": "lastVersion=197001010000-a/0"
     }, lambda *args: None))
     self.assertEqual(len(result["notifications"]), 1)
     self.assertEqual(result["notifications"][0]["id"], "1")
     self.assertRegexpMatches(result["version"], r"-a/0")
 
   def test_in_group(self):
     self.load_notifications_mock.return_value = [
-      {"id": "1", "title": {}, "message": {}},
-      {"id": "a", "variants": [{"title": {}, "message": {}}]}
+      {"id": "1", "title": {"en-US": ""}, "message": {"en-US": ""}},
+      {"id": "a", "variants": [
+        {"title": {"en-US": ""}, "message": {"en-US": ""}}
+      ]}
     ]
     result = json.loads(notification.notification({
       "QUERY_STRING": "lastVersion=197001010000-a/1"
     }, lambda *args: None))
     self.assertEqual(len(result["notifications"]), 1)
     self.assertEqual(result["notifications"][0]["id"], "a")
     self.assertRegexpMatches(result["version"], r"-a/1")
 
   def test_not_in_one_of_many_groups(self):
     self.load_notifications_mock.return_value = [
-      {"id": "1", "title": {}, "message": {}},
-      {"id": "a", "variants": [{"title": {}, "message": {}}]},
-      {"id": "b", "variants": [{"title": {}, "message": {}}]},
-      {"id": "c", "variants": [{"title": {}, "message": {}}]}
+      {"id": "1", "title": {"en-US": ""}, "message": {"en-US": ""}},
+      {"id": "a", "variants": [
+        {"title": {"en-US": ""}, "message": {"en-US": ""}}
+      ]},
+      {"id": "b", "variants": [
+        {"title": {"en-US": ""}, "message": {"en-US": ""}}
+      ]},
+      {"id": "c", "variants": [
+        {"title": {"en-US": ""}, "message": {"en-US": ""}}
+      ]}
     ]
     result = json.loads(notification.notification({
       "QUERY_STRING": "lastVersion=197001010000-a/0-b/0-c/0"
     }, lambda *args: None))
     self.assertEqual(len(result["notifications"]), 1)
     self.assertEqual(result["notifications"][0]["id"], "1")
     self.assertRegexpMatches(result["version"], r"-a/0-b/0-c/0")
 
   def test_in_one_of_many_groups(self):
     self.load_notifications_mock.return_value = [
-      {"id": "1", "title": {}, "message": {}},
-      {"id": "a", "variants": [{"title": {}, "message": {}}]},
-      {"id": "b", "variants": [{"title": {}, "message": {}}]},
-      {"id": "c", "variants": [{"title": {}, "message": {}}]}
+      {"id": "1", "title": {"en-US": ""}, "message": {"en-US": ""}},
+      {"id": "a", "variants": [
+        {"title": {"en-US": ""}, "message": {"en-US": ""}}
+      ]},
+      {"id": "b", "variants": [
+        {"title": {"en-US": ""}, "message": {"en-US": ""}}
+      ]},
+      {"id": "c", "variants": [
+        {"title": {"en-US": ""}, "message": {"en-US": ""}}
+      ]}
     ]
     result = json.loads(notification.notification({
       "QUERY_STRING": "lastVersion=197001010000-a/0-b/1-c/0"
     }, lambda *args: None))
     self.assertEqual(len(result["notifications"]), 1)
     self.assertEqual(result["notifications"][0]["id"], "b")
     self.assertRegexpMatches(result["version"], r"-a/0-b/1-c/0")
 
   def test_not_put_in_group(self):
     self.load_notifications_mock.return_value = [
-      {"id": "1", "title": {}, "message": {}},
-      {"id": "a", "variants": [{"sample": 0, "title": {}, "message": {}}]}
+      {"id": "1", "title": {"en-US": ""}, "message": {"en-US": ""}},
+      {"id": "a", "variants": [
+        {"sample": 0, "title": {"en-US": ""}, "message": {"en-US": ""}}
+      ]}
     ]
     result = json.loads(notification.notification({
       "QUERY_STRING": "lastVersion=197001010000"
     }, lambda *args: None))
     self.assertEqual(len(result["notifications"]), 1)
     self.assertEqual(result["notifications"][0]["id"], "1")
     self.assertRegexpMatches(result["version"], r"-a/0")
 
   def test_put_in_group(self):
     self.load_notifications_mock.return_value = [
-      {"id": "1", "title": {}, "message": {}},
-      {"id": "a", "variants": [{"sample": 1, "title": {}, "message": {}}]}
+      {"id": "1", "title": {"en-US": ""}, "message": {"en-US": ""}},
+      {"id": "a", "variants": [
+        {"sample": 1, "title": {"en-US": ""}, "message": {"en-US": ""}}
+      ]}
     ]
     result = json.loads(notification.notification({
       "QUERY_STRING": "lastVersion=197001010000"
     }, lambda *args: None))
     self.assertEqual(len(result["notifications"]), 1)
     self.assertEqual(result["notifications"][0]["id"], "a")
     self.assertRegexpMatches(result["version"], r"-a/1")
 
   def test_notification_variant_merged(self):
     self.load_notifications_mock.return_value = [
@@ skipping 20 matching lines @@
     ]
     result = json.loads(notification.notification({}, lambda *args: None))
     self.assertEqual(len(result["notifications"]), 0)
 
   @mock.patch("random.random")
   def test_probability_distribution_single_group(self, random_call):
     self.load_notifications_mock.return_value = [
       {
         "id": "a",
         "variants": [
-          {"sample": 0.5, "title": {"en-US": "1"}, "message": {}},
-          {"sample": 0.25, "title": {"en-US": "2"}, "message": {}},
-          {"sample": 0.25, "title": {"en-US": "3"}, "message": {}}
+          {"sample": 0.5, "title": {"en-US": "1"}, "message": {"en-US": ""}},
+          {"sample": 0.25, "title": {"en-US": "2"}, "message": {"en-US": ""}},
+          {"sample": 0.25, "title": {"en-US": "3"}, "message": {"en-US": ""}}
         ]
       }
     ]
     random_call.return_value = 0
     result = json.loads(notification.notification({}, lambda *args: None))
     self.assertEqual(len(result["notifications"]), 1)
     self.assertEqual(result["notifications"][0]["title"]["en-US"], "1")
     self.assertRegexpMatches(result["version"], r"-a/1")
     random_call.return_value = 0.5
     result = json.loads(notification.notification({}, lambda *args: None))
@@ skipping 20 matching lines @@
     self.assertEqual(len(result["notifications"]), 1)
     self.assertEqual(result["notifications"][0]["title"]["en-US"], "3")
     self.assertRegexpMatches(result["version"], r"-a/3")
 
   @mock.patch("random.random")
   def test_probability_distribution_multiple_groups(self, random_call):
     self.load_notifications_mock.return_value = [
       {
         "id": "a",
         "variants": [
-          {"sample": 0.25, "title": {"en-US": "1"}, "message": {}},
-          {"sample": 0.25, "title": {"en-US": "2"}, "message": {}}
+          {"sample": 0.25, "title": {"en-US": "1"}, "message": {"en-US": ""}},
+          {"sample": 0.25, "title": {"en-US": "2"}, "message": {"en-US": ""}}
         ]
       },
       {
         "id": "b",
         "variants": [
-          {"sample": 0.25, "title": {"en-US": "1"}, "message": {}},
-          {"sample": 0.25, "title": {"en-US": "2"}, "message": {}}
+          {"sample": 0.25, "title": {"en-US": "1"}, "message": {"en-US": ""}},
+          {"sample": 0.25, "title": {"en-US": "2"}, "message": {"en-US": ""}}
         ]
       }
     ]
     random_call.return_value = 0
     result = json.loads(notification.notification({}, lambda *args: None))
     self.assertEqual(len(result["notifications"]), 1)
     self.assertEqual(result["notifications"][0]["id"], "a")
     self.assertEqual(result["notifications"][0]["title"]["en-US"], "1")
     self.assertRegexpMatches(result["version"], r"-a/1-b/0")
     random_call.return_value = 0.251
@@ skipping 21 matching lines @@
                               lambda *args: None)
     notification.notification({"QUERY_STRING": "lastVersion=-"},
                               lambda *args: None)
     notification.notification({"QUERY_STRING": "lastVersion=-/"},
                               lambda *args: None)
     notification.notification({"QUERY_STRING": "lastVersion=-//"},
                               lambda *args: None)
 
   def test_version_header_present(self):
     self.load_notifications_mock.return_value = [
-      {"id": "1", "title": {}, "message": {}}
+      {"id": "1", "title": {"en-US": ""}, "message": {"en-US": ""}}
     ]
     response_header_map = {}
     def start_response(status, response_headers):
       for name, value in response_headers:
         response_header_map[name] = value
     result = json.loads(notification.notification({}, start_response))
     self.assertEqual(result["version"],
                      response_header_map["ABP-Notification-Version"])
 
   def test_default_group_notification_returned_if_valid(self):
     self.load_notifications_mock.return_value = [
-      {"id": "1", "title": {}, "message": {}},
+      {"id": "1", "title": {"en-US": ""}, "message": {"en-US": ""}},
       {
         "id": "a",
         "title": {"en-US": "0"},
         "message": {"en-US": "0"},
         "variants": [
           {"title": {"en-US": "1"}, "message": {"en-US": "1"}}
         ]
       }
     ]
     result = json.loads(notification.notification({
       "QUERY_STRING": "lastVersion=197001010000-a/0"
     }, lambda *args: None))
     self.assertEqual(len(result["notifications"]), 2)
     self.assertEqual(result["notifications"][0]["id"], "1")
     self.assertEqual(result["notifications"][1]["id"], "a")
     self.assertEqual(result["notifications"][1]["title"]["en-US"], "0")
     self.assertNotIn("variants", result["notifications"][1])
     self.assertRegexpMatches(result["version"], r"-a/0")
 
   def test_default_group_notification_not_returned_if_invalid(self):
     self.load_notifications_mock.return_value = [
-      {"id": "1", "title": {}, "message": {}},
+      {"id": "1", "title": {"en-US": ""}, "message": {"en-US": ""}},
       {
         "id": "a",
         "title": {"en-US": "0"},
         "variants": [
           {"title": {"en-US": "1"}, "message": {"en-US": "1"}}
         ]
       }
     ]
     result = json.loads(notification.notification({
       "QUERY_STRING": "lastVersion=197001010000-a/0"
     }, lambda *args: None))
     self.assertEqual(len(result["notifications"]), 1)
     self.assertEqual(result["notifications"][0]["id"], "1")
     self.assertRegexpMatches(result["version"], r"-a/0")
 
   def test_invalid_notification_not_returned(self):
     self.load_notifications_mock.return_value = [
-      {"id": "1", "title": {}, "message": {}},
-      {"id": "2", "title": {}},
-      {"id": "3", "message": {}}
+      {"id": "1", "title": {"en-US": ""}, "message": {"en-US": ""}},
+      {"id": "2", "title": {"en-US": ""}, "message": {}},
+      {"id": "3", "title": {}, "message": {"en-US": ""}},
+      {"id": "4", "title": {}},
+      {"id": "5", "message": {}},
+      {"id": "6"}
     ]
     result = json.loads(notification.notification({}, lambda *args: None))
     self.assertEqual(len(result["notifications"]), 1)
     self.assertEqual(result["notifications"][0]["id"], "1")
 
   def test_stays_in_group_when_notification_present(self):
     self.load_notifications_mock.return_value = [
       {"id": "a"}
     ]
     result = json.loads(notification.notification({
@@ skipping 15 matching lines @@
       {"id": "a", "inactive": True}
     ]
     result = json.loads(notification.notification({
       "QUERY_STRING": "lastVersion=197001010000-a/0-b/1"
     }, lambda *args: None))
     self.assertEqual(len(result["notifications"]), 0)
     self.assertRegexpMatches(result["version"], r"-a/0")
 
   def test_inactive_notifications_not_returned(self):
     self.load_notifications_mock.return_value = [
-      {"id": "a", "title": {}, "message": {}, "inactive": True},
-      {"id": "b", "title": {}, "message": {}, "inactive": False},
-      {"id": "c", "title": {}, "message": {}}
+      {"id": "a", "title": {"en-US": ""}, "message": {"en-US": ""}, "inactive": True},
+      {"id": "b", "title": {"en-US": ""}, "message": {"en-US": ""}, "inactive": False},
+      {"id": "c", "title": {"en-US": ""}, "message": {"en-US": ""}}
     ]
     result = json.loads(notification.notification({}, lambda *args: None))
     self.assertEqual(len(result["notifications"]), 2)
     self.assertEqual(result["notifications"][0]["id"], "b")
     self.assertEqual(result["notifications"][1]["id"], "c")
 
 if __name__ == '__main__':
   unittest.main()