Fixed issue on database when requesting latest headers. Updated test case.

Author: fcladera

mocha_core/mocha_core/database.py

@@ -171,11 +171,11 @@ def get_ts_dict(self):
                 ts_dict[robot_id] = {}
             for topic in self.db[robot_id]:
                 if topic not in ts_dict[robot_id]:
-                    ts_dict[robot_id][topic] = -np.inf
+                    ts_dict[robot_id][topic] = None
                 for header in self.db[robot_id][topic]:
                     msg = self.db[robot_id][topic][header]
-                    ts_dict[robot_id][topic] = max(ts_dict[robot_id][topic],
-                                                   msg.ts.nanoseconds)
+                    curr_time = ts_dict[robot_id][topic]
+                    ts_dict[robot_id][topic] = max(curr_time, msg.ts) if curr_time is not None else msg.ts
         self.lock.release()
         return ts_dict
 

mocha_core/test/test_database.py

@@ -8,6 +8,7 @@
 import sample_db
 import mocha_core.hash_comm as hc
 import mocha_core.database_utils as du
+import copy
 
 import pprint
 
@@ -76,16 +77,53 @@ def test_get_header_list(self):
     def test_headers_not_in_local(self):
         dbl = sample_db.get_sample_dbl()
         header_list = dbl.get_header_list()
+        # Test with all headers
         extra_header_1 = du.generate_random_header()
         extra_header_2 = du.generate_random_header()
         header_list.append(extra_header_2)
         header_list.append(extra_header_1)
         new_headers = [extra_header_1, extra_header_2]
         new_headers.sort()
+        # Test without newer
         discover_extra_header = dbl.headers_not_in_local(header_list)
         discover_extra_header.sort()
         self.assertListEqual(discover_extra_header,
                              new_headers)
+        # Test with older header, create a copy of one of the existing headers in the
+        # db. Pick one with the msec field that can accomodate both addition and
+        # substraction
+        test_header = None
+        for header in header_list:
+            h = hc.TsHeader.from_header(header)
+            if h.msecs > 0 and h.msecs < 999:
+                test_header = header
+                break
+        self.assertTrue(test_header is not None)
+        # Modify the timestamp to make it before the current msg
+        h = hc.TsHeader.from_header(test_header)
+        h.msecs -= 1
+        extra_header_3 = h.bindigest()
+        header_list.append(extra_header_3)
+        discover_extra_header_latest = dbl.headers_not_in_local(header_list, newer=True)
+        discover_extra_header_latest.sort()
+        discover_extra_header_all = dbl.headers_not_in_local(header_list)
+        discover_extra_header_all.sort()
+        self.assertListEqual(discover_extra_header_latest, new_headers)
+        diff_header = set(discover_extra_header_all) - set(discover_extra_header)
+        self.assertEqual(diff_header.pop(), extra_header_3)
+        # Modify the timestamp to make it after the current msg
+        h = hc.TsHeader.from_header(test_header)
+        h.msecs += 1
+        extra_header_4 = h.bindigest()
+        header_list.append(extra_header_4)
+        discover_extra_header_latest = dbl.headers_not_in_local(header_list, newer=True)
+        new_headers.append(extra_header_4) # The new header should show in the list
+        new_headers.sort()
+        discover_extra_header_latest.sort()
+        self.assertListEqual(new_headers, discover_extra_header_latest)
+        # Finally, getting all the headers should not filter them out
+        discover_extra_header = dbl.headers_not_in_local(header_list)
+        self.assertTrue(len(discover_extra_header) == 4)
 
     def test_find_header(self):
         dbl = sample_db.get_sample_dbl()