sin/samba-mirror
1
0
Fork 0
mirror of https://github.com/samba-team/samba.git synced 2025-02-08 05:57:51 +03:00
Code

pytest: dns_aging: use assert_timestamps_equal() widely

Browse Source 
Signed-off-by: Douglas Bagnall <douglas.bagnall@catalyst.net.nz>
Reviewed-by: Andrew Bartlett <abartlet@samba.org>
This commit is contained in:
Douglas Bagnall 2021-06-10 23:31:09 +00:00 committed by Andrew Bartlett
parent 559384beb7
commit 0423b0b884
1 changed files with 110 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

220
python/samba/tests/dns_aging.py
View File

@ -494,7 +494,7 @@ class TestDNSAging(DNSTest):
match = r match = r
self.assertEqual(match.rank, rec.rank & 255) self.assertEqual(match.rank, rec.rank & 255)
self.assertEqual(match.dwTtlSeconds, rec.dwTtlSeconds) self.assertEqual(match.dwTtlSeconds, rec.dwTtlSeconds)
self.assertEqual(match.dwTimeStamp, rec.dwTimeStamp) self.assert_timestamps_equal(match.dwTimeStamp, rec.dwTimeStamp)
return match return match
def ldap_delete_record(self, name, data, wtype=dnsp.DNS_TYPE_TXT): def ldap_delete_record(self, name, data, wtype=dnsp.DNS_TYPE_TXT):
@ -530,7 +530,7 @@ class TestDNSAging(DNSTest):
match = r match = r
self.assertEqual(match.rank, rec.rank & 255) self.assertEqual(match.rank, rec.rank & 255)
self.assertEqual(match.dwTtlSeconds, rec.dwTtlSeconds) self.assertEqual(match.dwTtlSeconds, rec.dwTtlSeconds)
self.assertEqual(match.dwTimeStamp, rec.dwTimeStamp) self.assert_timestamps_equal(match.dwTimeStamp, rec.dwTimeStamp)
return match return match
def ldap_modify_timestamps(self, name, delta): def ldap_modify_timestamps(self, name, delta):
@ -680,11 +680,11 @@ class TestDNSAging(DNSTest):
rec = self.ldap_update_record(name2, [name2], rec = self.ldap_update_record(name2, [name2],
dwTimeStamp=eight_days_ago) dwTimeStamp=eight_days_ago)
self.assertEqual(rec.dwTimeStamp, eight_days_ago) self.assert_timestamps_equal(rec.dwTimeStamp, eight_days_ago)
# if aging was on, this would change # if aging was on, this would change
rec = self.dns_update_record(name2, [name2]) rec = self.dns_update_record(name2, [name2])
self.assertEqual(rec.dwTimeStamp, eight_days_ago) self.assert_timestamps_equal(rec.dwTimeStamp, eight_days_ago)
self.set_aging(True) self.set_aging(True)
rec = self.dns_update_record(name2, [name2]) rec = self.dns_update_record(name2, [name2])
@ -762,7 +762,7 @@ class TestDNSAging(DNSTest):
# no change here # no change here
update_timestamp = self.dns_update_record(name, txt1).dwTimeStamp update_timestamp = self.dns_update_record(name, txt1).dwTimeStamp
self.assertEqual(update_timestamp, timestamp) self.assert_timestamps_equal(update_timestamp, timestamp)
# adding a fresh record # adding a fresh record
for timestamp in (current_time, for timestamp in (current_time,
@ -778,7 +778,7 @@ class TestDNSAging(DNSTest):
name, name,
txt1, txt1,
dwTimeStamp=timestamp).dwTimeStamp dwTimeStamp=timestamp).dwTimeStamp
self.assertEqual(timestamp1, timestamp) self.assert_timestamps_equal(timestamp1, timestamp)
self.dns_update_record(name, txt2) self.dns_update_record(name, txt2)
timestamps = self.get_txt_timestamps(name, txt1, txt2) timestamps = self.get_txt_timestamps(name, txt1, txt2)
@ -803,7 +803,7 @@ class TestDNSAging(DNSTest):
# wind back # wind back
self.ldap_update_record(name, txt1, dwTimeStamp=timestamp) self.ldap_update_record(name, txt1, dwTimeStamp=timestamp)
timestamp1 = self.get_unique_txt_record(name, txt1).dwTimeStamp timestamp1 = self.get_unique_txt_record(name, txt1).dwTimeStamp
self.assertEqual(timestamp1, timestamp) self.assert_timestamps_equal(timestamp1, timestamp)
timestamp2 = self.dns_update_record(name, txt2).dwTimeStamp timestamp2 = self.dns_update_record(name, txt2).dwTimeStamp
# txt1 timestamp is now current time # txt1 timestamp is now current time
@ -824,7 +824,7 @@ class TestDNSAging(DNSTest):
self.ldap_update_record(name, txt2, dwTimeStamp=timestamp) self.ldap_update_record(name, txt2, dwTimeStamp=timestamp)
self.ldap_update_record(name, txt3, dwTimeStamp=(timestamp + 30)) self.ldap_update_record(name, txt3, dwTimeStamp=(timestamp + 30))
timestamp3 = self.get_unique_txt_record(name, txt3).dwTimeStamp timestamp3 = self.get_unique_txt_record(name, txt3).dwTimeStamp
self.assertEqual(timestamp3, timestamp + 30) self.assert_timestamps_equal(timestamp3, timestamp + 30)
self.dns_update_record(name, txt2).dwTimeStamp self.dns_update_record(name, txt2).dwTimeStamp
timestamps = self.get_txt_timestamps(name, txt1, txt2, txt3) timestamps = self.get_txt_timestamps(name, txt1, txt2, txt3)
@ -847,7 +847,7 @@ class TestDNSAging(DNSTest):
self.ldap_update_record(name, txt1, dwTimeStamp=0) self.ldap_update_record(name, txt1, dwTimeStamp=0)
self.ldap_update_record(name, txt3, dwTimeStamp=(timestamp - 9)) self.ldap_update_record(name, txt3, dwTimeStamp=(timestamp - 9))
timestamp3 = self.get_unique_txt_record(name, txt3).dwTimeStamp timestamp3 = self.get_unique_txt_record(name, txt3).dwTimeStamp
self.assertEqual(timestamp3, timestamp - 9) self.assert_timestamps_equal(timestamp3, timestamp - 9)
self.dns_update_record(name, txt2) self.dns_update_record(name, txt2)
timestamps = self.get_txt_timestamps(name, txt1, txt2, txt3) timestamps = self.get_txt_timestamps(name, txt1, txt2, txt3)
@ -870,7 +870,7 @@ class TestDNSAging(DNSTest):
self.ldap_update_record(name, txt2, dwTimeStamp=0) self.ldap_update_record(name, txt2, dwTimeStamp=0)
self.ldap_update_record(name, txt3, dwTimeStamp=(timestamp + 30)) self.ldap_update_record(name, txt3, dwTimeStamp=(timestamp + 30))
timestamp3 = self.get_unique_txt_record(name, txt3).dwTimeStamp timestamp3 = self.get_unique_txt_record(name, txt3).dwTimeStamp
self.assertEqual(timestamp3, timestamp + 30) self.assert_timestamps_equal(timestamp3, timestamp + 30)
self.dns_update_record(name, txt2).dwTimeStamp self.dns_update_record(name, txt2).dwTimeStamp
timestamps = self.get_txt_timestamps(name, txt1, txt2, txt3) timestamps = self.get_txt_timestamps(name, txt1, txt2, txt3)
@ -893,7 +893,7 @@ class TestDNSAging(DNSTest):
# wind back # wind back
self.ldap_update_record(name, txt3, dwTimeStamp=(timestamp)) self.ldap_update_record(name, txt3, dwTimeStamp=(timestamp))
timestamp3 = self.get_unique_txt_record(name, txt3).dwTimeStamp timestamp3 = self.get_unique_txt_record(name, txt3).dwTimeStamp
self.assertEqual(timestamp3, timestamp) self.assert_timestamps_equal(timestamp3, timestamp)
self.dns_update_record(name, txt2) self.dns_update_record(name, txt2)
timestamps = self.get_txt_timestamps(name, txt1, txt2, txt3) timestamps = self.get_txt_timestamps(name, txt1, txt2, txt3)
@ -934,7 +934,7 @@ class TestDNSAging(DNSTest):
self.ldap_update_record(name, txt2, dwTimeStamp=888888) self.ldap_update_record(name, txt2, dwTimeStamp=888888)
self.ldap_update_record(name, txt3, dwTimeStamp=(timestamp)) self.ldap_update_record(name, txt3, dwTimeStamp=(timestamp))
timestamp3 = self.get_unique_txt_record(name, txt3).dwTimeStamp timestamp3 = self.get_unique_txt_record(name, txt3).dwTimeStamp
self.assertEqual(timestamp3, timestamp) self.assert_timestamps_equal(timestamp3, timestamp)
self.rpc_update_record(name, txt2) self.rpc_update_record(name, txt2)
time.sleep(2) time.sleep(2)
@ -958,7 +958,7 @@ class TestDNSAging(DNSTest):
# no change when updating this record # no change when updating this record
update_timestamp = self.dns_update_record(name, txt1).dwTimeStamp update_timestamp = self.dns_update_record(name, txt1).dwTimeStamp
self.assertEqual(update_timestamp, n_days_ago) self.assert_timestamps_equal(update_timestamp, n_days_ago)
# add another record, which should have the current timestamp # add another record, which should have the current timestamp
timestamp2 = self.dns_update_record(name, txt2).dwTimeStamp timestamp2 = self.dns_update_record(name, txt2).dwTimeStamp
@ -966,13 +966,13 @@ class TestDNSAging(DNSTest):
# get the original record timestamp. NOW it matches current_time # get the original record timestamp. NOW it matches current_time
timestamp1 = self.get_unique_txt_record(name, txt1).dwTimeStamp timestamp1 = self.get_unique_txt_record(name, txt1).dwTimeStamp
self.assertEqual(timestamp1, timestamp2) self.assert_timestamps_equal(timestamp1, timestamp2)
# let's repeat that, this time with txt2 existing # let's repeat that, this time with txt2 existing
self.ldap_update_record(name, txt1, dwTimeStamp=n_days_ago) self.ldap_update_record(name, txt1, dwTimeStamp=n_days_ago)
timestamp1 = self.dns_update_record(name, txt1).dwTimeStamp timestamp1 = self.dns_update_record(name, txt1).dwTimeStamp
self.assertEqual(timestamp1, n_days_ago) self.assert_timestamps_equal(timestamp1, n_days_ago)
# this update is not an add # this update is not an add
timestamp2 = self.dns_update_record(name, txt2).dwTimeStamp timestamp2 = self.dns_update_record(name, txt2).dwTimeStamp
@ -980,14 +980,14 @@ class TestDNSAging(DNSTest):
# now timestamp1 is not changed # now timestamp1 is not changed
timestamp1 = self.get_unique_txt_record(name, txt1).dwTimeStamp timestamp1 = self.get_unique_txt_record(name, txt1).dwTimeStamp
self.assertEqual(timestamp1, n_days_ago) self.assert_timestamps_equal(timestamp1, n_days_ago)
# delete record2, try again # delete record2, try again
self.ldap_delete_record(name, txt2) self.ldap_delete_record(name, txt2)
self.ldap_update_record(name, txt1, dwTimeStamp=n_days_ago) self.ldap_update_record(name, txt1, dwTimeStamp=n_days_ago)
timestamp1 = self.dns_update_record(name, txt1).dwTimeStamp timestamp1 = self.dns_update_record(name, txt1).dwTimeStamp
self.assertEqual(timestamp1, n_days_ago) self.assert_timestamps_equal(timestamp1, n_days_ago)
# here we are re-adding the deleted record # here we are re-adding the deleted record
timestamp2 = self.dns_update_record(name, txt2).dwTimeStamp timestamp2 = self.dns_update_record(name, txt2).dwTimeStamp
@ -1000,23 +1000,23 @@ class TestDNSAging(DNSTest):
# from the sibling of freshly added record, depending on the # from the sibling of freshly added record, depending on the
# time difference. # time difference.
if n_days <= 7: if n_days <= 7:
self.assertEqual(timestamp1, n_days_ago) self.assert_timestamps_equal(timestamp1, n_days_ago)
else: else:
self.assertEqual(timestamp1, timestamp2) self.assert_timestamps_equal(timestamp1, timestamp2)
# re-timestamp record2, try again # re-timestamp record2, try again
self.ldap_update_record(name, txt2, dwTimeStamp=n_days_ago) self.ldap_update_record(name, txt2, dwTimeStamp=n_days_ago)
self.ldap_update_record(name, txt1, dwTimeStamp=n_days_ago) self.ldap_update_record(name, txt1, dwTimeStamp=n_days_ago)
timestamp1 = self.dns_update_record(name, txt1).dwTimeStamp timestamp1 = self.dns_update_record(name, txt1).dwTimeStamp
self.assertEqual(timestamp1, n_days_ago) self.assert_timestamps_equal(timestamp1, n_days_ago)
# no change # no change
timestamp2 = self.dns_update_record(name, txt2).dwTimeStamp timestamp2 = self.dns_update_record(name, txt2).dwTimeStamp
self.assertEqual(timestamp2, n_days_ago) self.assert_timestamps_equal(timestamp2, n_days_ago)
# also no change # also no change
timestamp1 = self.get_unique_txt_record(name, txt1).dwTimeStamp timestamp1 = self.get_unique_txt_record(name, txt1).dwTimeStamp
self.assertEqual(timestamp1, timestamp2) self.assert_timestamps_equal(timestamp1, timestamp2)
# let's introduce another record # let's introduce another record
txt3 = ['3'] txt3 = ['3']
@ -1030,11 +1030,11 @@ class TestDNSAging(DNSTest):
timestamp2 = self.get_unique_txt_record(name, txt2).dwTimeStamp timestamp2 = self.get_unique_txt_record(name, txt2).dwTimeStamp
if n_days <= 7: if n_days <= 7:
self.assertEqual(timestamp1, n_days_ago) self.assert_timestamps_equal(timestamp1, n_days_ago)
else: else:
self.assertEqual(timestamp1, timestamp3) self.assert_timestamps_equal(timestamp1, timestamp3)
self.assertEqual(timestamp2, timestamp3) self.assert_timestamps_equal(timestamp2, timestamp3)
self.ldap_delete_record(name, txt3) self.ldap_delete_record(name, txt3)
timestamp2 = self.dns_update_record(name, txt3).dwTimeStamp timestamp2 = self.dns_update_record(name, txt3).dwTimeStamp
@ -1043,11 +1043,11 @@ class TestDNSAging(DNSTest):
timestamp2 = self.get_unique_txt_record(name, txt2).dwTimeStamp timestamp2 = self.get_unique_txt_record(name, txt2).dwTimeStamp
if n_days <= 7: if n_days <= 7:
self.assertEqual(timestamp1, n_days_ago) self.assert_timestamps_equal(timestamp1, n_days_ago)
else: else:
self.assertEqual(timestamp1, timestamp3) self.assert_timestamps_equal(timestamp1, timestamp3)
self.assertEqual(timestamp2, timestamp3) self.assert_timestamps_equal(timestamp2, timestamp3)
# and here we'll make txt3 static # and here we'll make txt3 static
txt4 = ['4'] txt4 = ['4']
@ -1062,8 +1062,8 @@ class TestDNSAging(DNSTest):
timestamp4 = self.dns_update_record(name, txt4).dwTimeStamp timestamp4 = self.dns_update_record(name, txt4).dwTimeStamp
self.assertEqual(timestamp1, 0) self.assertEqual(timestamp1, 0)
self.assertEqual(timestamp2, n_days_ago) self.assert_timestamps_equal(timestamp2, n_days_ago)
self.assertEqual(timestamp3, n_days_ago) self.assert_timestamps_equal(timestamp3, n_days_ago)
self.assert_soon_after(timestamp4, current_time) self.assert_soon_after(timestamp4, current_time)
def test_update_aging_disabled_in_no_refresh_window(self): def test_update_aging_disabled_in_no_refresh_window(self):
@ -1126,7 +1126,7 @@ class TestDNSAging(DNSTest):
self.ldap_update_record(name, txt1, dwTimeStamp=0) self.ldap_update_record(name, txt1, dwTimeStamp=0)
# no change when updating this record # no change when updating this record
timestamp2 = self.dns_update_record(name, txt2).dwTimeStamp timestamp2 = self.dns_update_record(name, txt2).dwTimeStamp
self.assertEqual(timestamp2, 1) self.assert_timestamps_equal(timestamp2, 1)
def test_update_aging_disabled(self): def test_update_aging_disabled(self):
# With aging disabled, Windows updates the timestamps of all # With aging disabled, Windows updates the timestamps of all
@ -1146,11 +1146,11 @@ class TestDNSAging(DNSTest):
self.ldap_modify_timestamps(name, minus_6) self.ldap_modify_timestamps(name, minus_6)
after_mod = self.get_unique_txt_record(name, txt1) after_mod = self.get_unique_txt_record(name, txt1)
six_days_ago = after_mod.dwTimeStamp six_days_ago = after_mod.dwTimeStamp
self.assertEqual(six_days_ago, current_time + minus_6) self.assert_timestamps_equal(six_days_ago, current_time + minus_6)
# no change # no change
update_timestamp = self.dns_update_record(name, txt1).dwTimeStamp update_timestamp = self.dns_update_record(name, txt1).dwTimeStamp
self.assertEqual(update_timestamp, six_days_ago) self.assert_timestamps_equal(update_timestamp, six_days_ago)
self.check_query_txt(name, txt1, zone=self.zone) self.check_query_txt(name, txt1, zone=self.zone)
@ -1160,20 +1160,20 @@ class TestDNSAging(DNSTest):
timestamp1 = self.get_unique_txt_record(name, txt1).dwTimeStamp timestamp1 = self.get_unique_txt_record(name, txt1).dwTimeStamp
# without aging, timestamp1 is changed!! # without aging, timestamp1 is changed!!
self.assertEqual(timestamp1, timestamp2) self.assert_timestamps_equal(timestamp1, timestamp2)
# Set both records back to 8 days ago. # Set both records back to 8 days ago.
self.ldap_modify_timestamps(name, minus_8) self.ldap_modify_timestamps(name, minus_8)
eight_days_ago = self.get_unique_txt_record(name, txt1).dwTimeStamp eight_days_ago = self.get_unique_txt_record(name, txt1).dwTimeStamp
self.assertEqual(eight_days_ago, current_time + minus_8) self.assert_timestamps_equal(eight_days_ago, current_time + minus_8)
update2 = self.dns_update_record(name, txt2) update2 = self.dns_update_record(name, txt2)
# Without aging on, an update should not change the timestamps. # Without aging on, an update should not change the timestamps.
self.assertEqual(update2.dwTimeStamp, eight_days_ago) self.assert_timestamps_equal(update2.dwTimeStamp, eight_days_ago)
timestamp1 = self.get_unique_txt_record(name, txt1).dwTimeStamp timestamp1 = self.get_unique_txt_record(name, txt1).dwTimeStamp
self.assertEqual(timestamp1, eight_days_ago) self.assert_timestamps_equal(timestamp1, eight_days_ago)
# Add another txt record. The new record should have the now # Add another txt record. The new record should have the now
# timestamp, and drag the others up with it. # timestamp, and drag the others up with it.
@ -1181,25 +1181,25 @@ class TestDNSAging(DNSTest):
self.assert_soon_after(timestamp3, current_time) self.assert_soon_after(timestamp3, current_time)
timestamp1 = self.get_unique_txt_record(name, txt1).dwTimeStamp timestamp1 = self.get_unique_txt_record(name, txt1).dwTimeStamp
timestamp2 = self.get_unique_txt_record(name, txt2).dwTimeStamp timestamp2 = self.get_unique_txt_record(name, txt2).dwTimeStamp
self.assertEqual(timestamp1, timestamp3) self.assert_timestamps_equal(timestamp1, timestamp3)
self.assertEqual(timestamp2, timestamp3) self.assert_timestamps_equal(timestamp2, timestamp3)
hundred_days_ago = current_time - 100 * 24 hundred_days_ago = current_time - 100 * 24
thousand_days_ago = current_time - 1000 * 24 thousand_days_ago = current_time - 1000 * 24
record = self.ldap_update_record(name, txt1, record = self.ldap_update_record(name, txt1,
dwTimeStamp=hundred_days_ago) dwTimeStamp=hundred_days_ago)
self.assertEqual(record.dwTimeStamp, hundred_days_ago) self.assert_timestamps_equal(record.dwTimeStamp, hundred_days_ago)
record = self.ldap_update_record(name, txt2, record = self.ldap_update_record(name, txt2,
dwTimeStamp=thousand_days_ago) dwTimeStamp=thousand_days_ago)
self.assertEqual(record.dwTimeStamp, thousand_days_ago) self.assert_timestamps_equal(record.dwTimeStamp, thousand_days_ago)
# update 3, will others change (because beyond RefreshInterval)? yes. # update 3, will others change (because beyond RefreshInterval)? yes.
timestamp3 = self.dns_update_record(name, txt3).dwTimeStamp timestamp3 = self.dns_update_record(name, txt3).dwTimeStamp
timestamp1 = self.get_unique_txt_record(name, txt1).dwTimeStamp timestamp1 = self.get_unique_txt_record(name, txt1).dwTimeStamp
timestamp2 = self.get_unique_txt_record(name, txt2).dwTimeStamp timestamp2 = self.get_unique_txt_record(name, txt2).dwTimeStamp
self.assert_soon_after(timestamp3, current_time) self.assert_soon_after(timestamp3, current_time)
self.assertEqual(timestamp1, hundred_days_ago) self.assert_timestamps_equal(timestamp1, hundred_days_ago)
self.assertEqual(timestamp2, thousand_days_ago) self.assert_timestamps_equal(timestamp2, thousand_days_ago)
fifteen_days_ago = current_time - 15 * 24 fifteen_days_ago = current_time - 15 * 24
self.ldap_update_record(name, txt3, dwTimeStamp=fifteen_days_ago) self.ldap_update_record(name, txt3, dwTimeStamp=fifteen_days_ago)
@ -1208,9 +1208,9 @@ class TestDNSAging(DNSTest):
timestamp1 = self.get_unique_txt_record(name, txt1).dwTimeStamp timestamp1 = self.get_unique_txt_record(name, txt1).dwTimeStamp
timestamp3 = self.get_unique_txt_record(name, txt3).dwTimeStamp timestamp3 = self.get_unique_txt_record(name, txt3).dwTimeStamp
# DNS update has no effect because all records are old # DNS update has no effect because all records are old
self.assertEqual(timestamp2, thousand_days_ago) self.assert_timestamps_equal(timestamp2, thousand_days_ago)
self.assertEqual(timestamp1, hundred_days_ago) self.assert_timestamps_equal(timestamp1, hundred_days_ago)
self.assertEqual(timestamp3, fifteen_days_ago) self.assert_timestamps_equal(timestamp3, fifteen_days_ago)
# Does update of old record affect timestamp of refreshable record? No. # Does update of old record affect timestamp of refreshable record? No.
self.ldap_update_record(name, txt3, dwTimeStamp=eight_days_ago) self.ldap_update_record(name, txt3, dwTimeStamp=eight_days_ago)
@ -1218,9 +1218,9 @@ class TestDNSAging(DNSTest):
timestamp1 = self.get_unique_txt_record(name, txt1).dwTimeStamp timestamp1 = self.get_unique_txt_record(name, txt1).dwTimeStamp
timestamp3 = self.get_unique_txt_record(name, txt3).dwTimeStamp timestamp3 = self.get_unique_txt_record(name, txt3).dwTimeStamp
# DNS update has no effect because all records are old # DNS update has no effect because all records are old
self.assertEqual(timestamp2, thousand_days_ago) self.assert_timestamps_equal(timestamp2, thousand_days_ago)
self.assertEqual(timestamp1, hundred_days_ago) self.assert_timestamps_equal(timestamp1, hundred_days_ago)
self.assertEqual(timestamp3, eight_days_ago) self.assert_timestamps_equal(timestamp3, eight_days_ago)
# RPC zeros timestamp, after which updates won't change it. # RPC zeros timestamp, after which updates won't change it.
# BUT it refreshes all others! # BUT it refreshes all others!
@ -1231,7 +1231,7 @@ class TestDNSAging(DNSTest):
timestamp2 = self.get_unique_txt_record(name, txt2).dwTimeStamp timestamp2 = self.get_unique_txt_record(name, txt2).dwTimeStamp
self.assertEqual(timestamp2, 0) self.assertEqual(timestamp2, 0)
self.assert_soon_after(timestamp1, current_time) self.assert_soon_after(timestamp1, current_time)
self.assertEqual(timestamp3, eight_days_ago) self.assert_timestamps_equal(timestamp3, eight_days_ago)
def test_update_aging_enabled(self): def test_update_aging_enabled(self):
name = 'test' name = 'test'
@ -1256,20 +1256,20 @@ class TestDNSAging(DNSTest):
timestamp1 = self.dns_update_record(name, txt1).dwTimeStamp timestamp1 = self.dns_update_record(name, txt1).dwTimeStamp
timestamp2 = self.get_unique_txt_record(name, txt2).dwTimeStamp timestamp2 = self.get_unique_txt_record(name, txt2).dwTimeStamp
self.assertEqual(timestamp1, six_days_ago) self.assert_timestamps_equal(timestamp1, six_days_ago)
self.assert_soon_after(timestamp2, current_time) self.assert_soon_after(timestamp2, current_time)
self.ldap_update_record(name, txt3, dwTimeStamp=eight_days_ago) self.ldap_update_record(name, txt3, dwTimeStamp=eight_days_ago)
timestamp3 = self.get_unique_txt_record(name, txt3).dwTimeStamp timestamp3 = self.get_unique_txt_record(name, txt3).dwTimeStamp
self.assertEqual(timestamp3, eight_days_ago) self.assert_timestamps_equal(timestamp3, eight_days_ago)
# update 1, what happens to 2 and 3? Nothing? # update 1, what happens to 2 and 3? Nothing?
timestamp1 = self.dns_update_record(name, txt1).dwTimeStamp timestamp1 = self.dns_update_record(name, txt1).dwTimeStamp
timestamp2 = self.get_unique_txt_record(name, txt2).dwTimeStamp timestamp2 = self.get_unique_txt_record(name, txt2).dwTimeStamp
timestamp3 = self.get_unique_txt_record(name, txt3).dwTimeStamp timestamp3 = self.get_unique_txt_record(name, txt3).dwTimeStamp
self.assertEqual(timestamp1, six_days_ago) self.assert_timestamps_equal(timestamp1, six_days_ago)
self.assert_soon_after(timestamp2, current_time) self.assert_soon_after(timestamp2, current_time)
self.assertEqual(timestamp3, eight_days_ago) self.assert_timestamps_equal(timestamp3, eight_days_ago)
# now set 1 to 8 days, and we should see changes # now set 1 to 8 days, and we should see changes
self.ldap_update_record(name, txt1, dwTimeStamp=eight_days_ago) self.ldap_update_record(name, txt1, dwTimeStamp=eight_days_ago)
@ -1280,7 +1280,7 @@ class TestDNSAging(DNSTest):
timestamp3 = self.get_unique_txt_record(name, txt3).dwTimeStamp timestamp3 = self.get_unique_txt_record(name, txt3).dwTimeStamp
self.assert_soon_after(timestamp1, current_time) self.assert_soon_after(timestamp1, current_time)
self.assert_soon_after(timestamp2, current_time) self.assert_soon_after(timestamp2, current_time)
self.assertEqual(timestamp3, eight_days_ago) self.assert_timestamps_equal(timestamp3, eight_days_ago)
# next few ones use these numbers # next few ones use these numbers
self.ldap_update_record(name, txt1, dwTimeStamp=fifteen_days_ago) self.ldap_update_record(name, txt1, dwTimeStamp=fifteen_days_ago)
@ -1292,8 +1292,8 @@ class TestDNSAging(DNSTest):
timestamp2 = self.get_unique_txt_record(name, txt2).dwTimeStamp timestamp2 = self.get_unique_txt_record(name, txt2).dwTimeStamp
timestamp3 = self.get_unique_txt_record(name, txt3).dwTimeStamp timestamp3 = self.get_unique_txt_record(name, txt3).dwTimeStamp
self.assert_soon_after(timestamp1, current_time) self.assert_soon_after(timestamp1, current_time)
self.assertEqual(timestamp2, six_days_ago) self.assert_timestamps_equal(timestamp2, six_days_ago)
self.assertEqual(timestamp3, eight_days_ago) self.assert_timestamps_equal(timestamp3, eight_days_ago)
# reset 1 # reset 1
self.ldap_update_record(name, txt1, dwTimeStamp=fifteen_days_ago) self.ldap_update_record(name, txt1, dwTimeStamp=fifteen_days_ago)
@ -1302,16 +1302,16 @@ class TestDNSAging(DNSTest):
timestamp2 = self.dns_update_record(name, txt2).dwTimeStamp timestamp2 = self.dns_update_record(name, txt2).dwTimeStamp
timestamp1 = self.get_unique_txt_record(name, txt1).dwTimeStamp timestamp1 = self.get_unique_txt_record(name, txt1).dwTimeStamp
timestamp3 = self.get_unique_txt_record(name, txt3).dwTimeStamp timestamp3 = self.get_unique_txt_record(name, txt3).dwTimeStamp
self.assertEqual(timestamp1, fifteen_days_ago) self.assert_timestamps_equal(timestamp1, fifteen_days_ago)
self.assertEqual(timestamp2, six_days_ago) self.assert_timestamps_equal(timestamp2, six_days_ago)
self.assertEqual(timestamp3, eight_days_ago) self.assert_timestamps_equal(timestamp3, eight_days_ago)
# 3 changes, others do not # 3 changes, others do not
timestamp3 = self.dns_update_record(name, txt3).dwTimeStamp timestamp3 = self.dns_update_record(name, txt3).dwTimeStamp
timestamp1 = self.get_unique_txt_record(name, txt1).dwTimeStamp timestamp1 = self.get_unique_txt_record(name, txt1).dwTimeStamp
timestamp2 = self.get_unique_txt_record(name, txt2).dwTimeStamp timestamp2 = self.get_unique_txt_record(name, txt2).dwTimeStamp
self.assertEqual(timestamp1, fifteen_days_ago) self.assert_timestamps_equal(timestamp1, fifteen_days_ago)
self.assertEqual(timestamp2, six_days_ago) self.assert_timestamps_equal(timestamp2, six_days_ago)
self.assert_soon_after(timestamp3, current_time) self.assert_soon_after(timestamp3, current_time)
# reset 3 to 100 days # reset 3 to 100 days
@ -1321,8 +1321,8 @@ class TestDNSAging(DNSTest):
timestamp3 = self.dns_update_record(name, txt3).dwTimeStamp timestamp3 = self.dns_update_record(name, txt3).dwTimeStamp
timestamp1 = self.get_unique_txt_record(name, txt1).dwTimeStamp timestamp1 = self.get_unique_txt_record(name, txt1).dwTimeStamp
timestamp2 = self.get_unique_txt_record(name, txt2).dwTimeStamp timestamp2 = self.get_unique_txt_record(name, txt2).dwTimeStamp
self.assertEqual(timestamp1, fifteen_days_ago) self.assert_timestamps_equal(timestamp1, fifteen_days_ago)
self.assertEqual(timestamp2, six_days_ago) self.assert_timestamps_equal(timestamp2, six_days_ago)
self.assert_soon_after(timestamp3, current_time) self.assert_soon_after(timestamp3, current_time)
# reset 1 and 3 to 8 days. does update of 1 affect 3? # reset 1 and 3 to 8 days. does update of 1 affect 3?
@ -1334,16 +1334,16 @@ class TestDNSAging(DNSTest):
timestamp2 = self.get_unique_txt_record(name, txt2).dwTimeStamp timestamp2 = self.get_unique_txt_record(name, txt2).dwTimeStamp
timestamp3 = self.get_unique_txt_record(name, txt3).dwTimeStamp timestamp3 = self.get_unique_txt_record(name, txt3).dwTimeStamp
self.assert_soon_after(timestamp1, current_time) self.assert_soon_after(timestamp1, current_time)
self.assertEqual(timestamp2, six_days_ago) self.assert_timestamps_equal(timestamp2, six_days_ago)
self.assertEqual(timestamp3, eight_days_ago) self.assert_timestamps_equal(timestamp3, eight_days_ago)
# Try an RPC update, zeroing 1 --> what happens to 3? # Try an RPC update, zeroing 1 --> what happens to 3?
timestamp1 = self.rpc_update_record(name, txt1).dwTimeStamp timestamp1 = self.rpc_update_record(name, txt1).dwTimeStamp
timestamp2 = self.get_unique_txt_record(name, txt2).dwTimeStamp timestamp2 = self.get_unique_txt_record(name, txt2).dwTimeStamp
timestamp3 = self.get_unique_txt_record(name, txt3).dwTimeStamp timestamp3 = self.get_unique_txt_record(name, txt3).dwTimeStamp
self.assertEqual(timestamp1, 0) self.assertEqual(timestamp1, 0)
self.assertEqual(timestamp2, six_days_ago) self.assert_timestamps_equal(timestamp2, six_days_ago)
self.assertEqual(timestamp3, eight_days_ago) self.assert_timestamps_equal(timestamp3, eight_days_ago)
# with 2 and 3 at 8 days, does static record change things? # with 2 and 3 at 8 days, does static record change things?
self.ldap_update_record(name, txt2, dwTimeStamp=eight_days_ago) self.ldap_update_record(name, txt2, dwTimeStamp=eight_days_ago)
@ -1351,14 +1351,14 @@ class TestDNSAging(DNSTest):
timestamp2 = self.dns_update_record(name, txt2).dwTimeStamp timestamp2 = self.dns_update_record(name, txt2).dwTimeStamp
timestamp1 = self.get_unique_txt_record(name, txt1).dwTimeStamp timestamp1 = self.get_unique_txt_record(name, txt1).dwTimeStamp
timestamp3 = self.get_unique_txt_record(name, txt3).dwTimeStamp timestamp3 = self.get_unique_txt_record(name, txt3).dwTimeStamp
self.assertEqual(timestamp1, 0) self.assert_timestamps_equal(timestamp1, 0)
self.assertEqual(timestamp2, 0) self.assert_timestamps_equal(timestamp2, 0)
self.assertEqual(timestamp3, eight_days_ago) self.assert_timestamps_equal(timestamp3, eight_days_ago)
self.ldap_update_record(name, txt2, dwTimeStamp=six_days_ago) self.ldap_update_record(name, txt2, dwTimeStamp=six_days_ago)
self.ldap_update_record(name, txt1, dwTimeStamp=3000000) self.ldap_update_record(name, txt1, dwTimeStamp=3000000)
timestamp1 = self.get_unique_txt_record(name, txt1).dwTimeStamp timestamp1 = self.get_unique_txt_record(name, txt1).dwTimeStamp
self.assertEqual(timestamp1, 3000000) self.assert_timestamps_equal(timestamp1, 3000000)
# dns update remembers that node is static, even with no # dns update remembers that node is static, even with no
# static records. # static records.
@ -1372,10 +1372,10 @@ class TestDNSAging(DNSTest):
timestamp1 = self.get_unique_txt_record(name, txt1).dwTimeStamp timestamp1 = self.get_unique_txt_record(name, txt1).dwTimeStamp
timestamp2 = self.get_unique_txt_record(name, txt2).dwTimeStamp timestamp2 = self.get_unique_txt_record(name, txt2).dwTimeStamp
timestamp3 = self.get_unique_txt_record(name, txt3).dwTimeStamp timestamp3 = self.get_unique_txt_record(name, txt3).dwTimeStamp
self.assertEqual(timestamp1, 0) self.assert_timestamps_equal(timestamp1, 0)
self.assertEqual(timestamp2, six_days_ago) self.assert_timestamps_equal(timestamp2, six_days_ago)
self.assertEqual(timestamp3, eight_days_ago) self.assert_timestamps_equal(timestamp3, eight_days_ago)
self.assertEqual(timestamp4, 0) self.assert_timestamps_equal(timestamp4, 0)
def _test_update_aging_enabled_n_days_ago(self, n_days): def _test_update_aging_enabled_n_days_ago(self, n_days):
name = 'test' name = 'test'
@ -1394,7 +1394,7 @@ class TestDNSAging(DNSTest):
# update changes timestamp depending on time. # update changes timestamp depending on time.
timestamp1 = self.dns_update_record(name, txt1).dwTimeStamp timestamp1 = self.dns_update_record(name, txt1).dwTimeStamp
if n_days <= 7: if n_days <= 7:
self.assertEqual(timestamp1, n_days_ago) self.assert_timestamps_equal(timestamp1, n_days_ago)
else: else:
self.assert_soon_after(timestamp1, current_time) self.assert_soon_after(timestamp1, current_time)
@ -1404,13 +1404,13 @@ class TestDNSAging(DNSTest):
# first record should not have changed # first record should not have changed
timestamp1_b = self.get_unique_txt_record(name, txt1).dwTimeStamp timestamp1_b = self.get_unique_txt_record(name, txt1).dwTimeStamp
self.assertEqual(timestamp1, timestamp1_b) self.assert_timestamps_equal(timestamp1, timestamp1_b)
# let's repeat that, this time with txt2 existing # let's repeat that, this time with txt2 existing
self.ldap_update_record(name, txt1, dwTimeStamp=n_days_ago) self.ldap_update_record(name, txt1, dwTimeStamp=n_days_ago)
timestamp1 = self.dns_update_record(name, txt1).dwTimeStamp timestamp1 = self.dns_update_record(name, txt1).dwTimeStamp
self.assertEqual(timestamp1, timestamp1_b) self.assert_timestamps_equal(timestamp1, timestamp1_b)
# this update is not an add. record 2 is already up-to-date # this update is not an add. record 2 is already up-to-date
timestamp2 = self.dns_update_record(name, txt2).dwTimeStamp timestamp2 = self.dns_update_record(name, txt2).dwTimeStamp
@ -1418,7 +1418,7 @@ class TestDNSAging(DNSTest):
# now timestamp1 is not changed # now timestamp1 is not changed
timestamp1 = self.get_unique_txt_record(name, txt1).dwTimeStamp timestamp1 = self.get_unique_txt_record(name, txt1).dwTimeStamp
self.assertEqual(timestamp1, timestamp1_b) self.assert_timestamps_equal(timestamp1, timestamp1_b)
# delete record2, try again # delete record2, try again
self.ldap_delete_record(name, txt2) self.ldap_delete_record(name, txt2)
@ -1426,7 +1426,7 @@ class TestDNSAging(DNSTest):
timestamp1 = self.dns_update_record(name, txt1).dwTimeStamp timestamp1 = self.dns_update_record(name, txt1).dwTimeStamp
if n_days <= 7: if n_days <= 7:
self.assertEqual(timestamp1, n_days_ago) self.assert_timestamps_equal(timestamp1, n_days_ago)
else: else:
self.assert_soon_after(timestamp1, current_time) self.assert_soon_after(timestamp1, current_time)
@ -1441,9 +1441,9 @@ class TestDNSAging(DNSTest):
# from the sibling of freshly added record, depending on the # from the sibling of freshly added record, depending on the
# time difference. # time difference.
if n_days <= 7: if n_days <= 7:
self.assertEqual(timestamp1, n_days_ago) self.assert_timestamps_equal(timestamp1, n_days_ago)
else: else:
self.assertEqual(timestamp1, timestamp2) self.assert_timestamps_equal(timestamp1, timestamp2)
# re-timestamp record2, try again # re-timestamp record2, try again
self.ldap_update_record(name, txt2, dwTimeStamp=n_days_ago) self.ldap_update_record(name, txt2, dwTimeStamp=n_days_ago)
@ -1451,14 +1451,14 @@ class TestDNSAging(DNSTest):
# this should make no difference # this should make no difference
timestamp1_b = self.dns_update_record(name, txt1).dwTimeStamp timestamp1_b = self.dns_update_record(name, txt1).dwTimeStamp
self.assertEqual(timestamp1, timestamp1_b) self.assert_timestamps_equal(timestamp1, timestamp1_b)
# no change # no change
timestamp2 = self.dns_update_record(name, txt2).dwTimeStamp timestamp2 = self.dns_update_record(name, txt2).dwTimeStamp
self.assertEqual(timestamp2, timestamp1) self.assert_timestamps_equal(timestamp2, timestamp1)
# also no change # also no change
timestamp1 = self.get_unique_txt_record(name, txt1).dwTimeStamp timestamp1 = self.get_unique_txt_record(name, txt1).dwTimeStamp
self.assertEqual(timestamp1, timestamp2) self.assert_timestamps_equal(timestamp1, timestamp2)
# let's introduce another record # let's introduce another record
txt3 = ['3'] txt3 = ['3']
@ -1471,8 +1471,8 @@ class TestDNSAging(DNSTest):
timestamp1 = self.get_unique_txt_record(name, txt1).dwTimeStamp timestamp1 = self.get_unique_txt_record(name, txt1).dwTimeStamp
timestamp2 = self.get_unique_txt_record(name, txt2).dwTimeStamp timestamp2 = self.get_unique_txt_record(name, txt2).dwTimeStamp
self.assertEqual(timestamp1, n_days_ago) self.assert_timestamps_equal(timestamp1, n_days_ago)
self.assertEqual(timestamp2, n_days_ago) self.assert_timestamps_equal(timestamp2, n_days_ago)
self.ldap_delete_record(name, txt3) self.ldap_delete_record(name, txt3)
timestamp2 = self.dns_update_record(name, txt3).dwTimeStamp timestamp2 = self.dns_update_record(name, txt3).dwTimeStamp
@ -1480,8 +1480,8 @@ class TestDNSAging(DNSTest):
timestamp1 = self.get_unique_txt_record(name, txt1).dwTimeStamp timestamp1 = self.get_unique_txt_record(name, txt1).dwTimeStamp
timestamp2 = self.get_unique_txt_record(name, txt2).dwTimeStamp timestamp2 = self.get_unique_txt_record(name, txt2).dwTimeStamp
self.assertEqual(timestamp1, n_days_ago) self.assert_timestamps_equal(timestamp1, n_days_ago)
self.assertEqual(timestamp2, n_days_ago) self.assert_timestamps_equal(timestamp2, n_days_ago)
txt4 = ['4'] txt4 = ['4']
@ -1494,10 +1494,10 @@ class TestDNSAging(DNSTest):
timestamp3 = self.get_unique_txt_record(name, txt3).dwTimeStamp timestamp3 = self.get_unique_txt_record(name, txt3).dwTimeStamp
timestamp4 = self.dns_update_record(name, txt4).dwTimeStamp timestamp4 = self.dns_update_record(name, txt4).dwTimeStamp
self.assertEqual(timestamp1, 0) self.assert_timestamps_equal(timestamp1, 0)
self.assertEqual(timestamp2, n_days_ago) self.assert_timestamps_equal(timestamp2, n_days_ago)
self.assertEqual(timestamp3, n_days_ago) self.assert_timestamps_equal(timestamp3, n_days_ago)
self.assertEqual(timestamp4, 0) self.assert_timestamps_equal(timestamp4, 0)
longer_ago = n_days_ago // 2 longer_ago = n_days_ago // 2
@ -1507,7 +1507,7 @@ class TestDNSAging(DNSTest):
self.ldap_update_record(name, txt2, dwTimeStamp=n_days_ago) self.ldap_update_record(name, txt2, dwTimeStamp=n_days_ago)
self.ldap_update_record(name, txt3, dwTimeStamp=n_days_ago) self.ldap_update_record(name, txt3, dwTimeStamp=n_days_ago)
timestamp1 = self.get_unique_txt_record(name, txt1).dwTimeStamp timestamp1 = self.get_unique_txt_record(name, txt1).dwTimeStamp
self.assertEqual(timestamp1, longer_ago) self.assert_timestamps_equal(timestamp1, longer_ago)
timestamp4 = self.dns_update_record(name, txt4).dwTimeStamp timestamp4 = self.dns_update_record(name, txt4).dwTimeStamp
timestamp2 = self.get_unique_txt_record(name, txt2).dwTimeStamp timestamp2 = self.get_unique_txt_record(name, txt2).dwTimeStamp
@ -1516,19 +1516,19 @@ class TestDNSAging(DNSTest):
# Here, although there is no record frm which to get the zero # Here, although there is no record frm which to get the zero
# timestamp, record 4 does it anyway. # timestamp, record 4 does it anyway.
self.assertEqual(timestamp1, longer_ago) self.assert_timestamps_equal(timestamp1, longer_ago)
self.assertEqual(timestamp2, n_days_ago) self.assert_timestamps_equal(timestamp2, n_days_ago)
self.assertEqual(timestamp3, n_days_ago) self.assert_timestamps_equal(timestamp3, n_days_ago)
self.assertEqual(timestamp4, 0) self.assert_timestamps_equal(timestamp4, 0)
# and now record 1 wants to be static. # and now record 1 wants to be static.
self.ldap_update_record(name, txt4, dwTimeStamp=longer_ago) self.ldap_update_record(name, txt4, dwTimeStamp=longer_ago)
timestamp4 = self.get_unique_txt_record(name, txt4).dwTimeStamp timestamp4 = self.get_unique_txt_record(name, txt4).dwTimeStamp
self.assertEqual(timestamp4, longer_ago) self.assert_timestamps_equal(timestamp4, longer_ago)
timestamp1 = self.dns_update_record(name, txt1).dwTimeStamp timestamp1 = self.dns_update_record(name, txt1).dwTimeStamp
timestamp4 = self.get_unique_txt_record(name, txt4).dwTimeStamp timestamp4 = self.get_unique_txt_record(name, txt4).dwTimeStamp
self.assertEqual(timestamp1, 0) self.assert_timestamps_equal(timestamp1, 0)
self.assertEqual(timestamp4, longer_ago) self.assert_timestamps_equal(timestamp4, longer_ago)
def test_update_aging_enabled_in_no_refresh_window(self): def test_update_aging_enabled_in_no_refresh_window(self):
self._test_update_aging_enabled_n_days_ago(4) self._test_update_aging_enabled_n_days_ago(4)
@ -1587,7 +1587,7 @@ class TestDNSAging(DNSTest):
if n_days > 7 and aging: if n_days > 7 and aging:
self.assert_soon_after(time_A, current_time) self.assert_soon_after(time_A, current_time)
else: else:
self.assertEqual(time_A, n_days_ago) self.assert_timestamps_equal(time_A, n_days_ago)
# add another record, which should have the current timestamp # add another record, which should have the current timestamp
time_B = self.dns_update_record(name, B).dwTimeStamp time_B = self.dns_update_record(name, B).dwTimeStamp
@ -1595,7 +1595,7 @@ class TestDNSAging(DNSTest):
time_A = self.get_unique_txt_record(name, A).dwTimeStamp time_A = self.get_unique_txt_record(name, A).dwTimeStamp
if aging and n_days <= 7: if aging and n_days <= 7:
self.assertEqual(time_A, n_days_ago) self.assert_timestamps_equal(time_A, n_days_ago)
else: else:
self.assert_soon_after(time_A, current_time) self.assert_soon_after(time_A, current_time)
@ -1617,24 +1617,24 @@ class TestDNSAging(DNSTest):
self._test_update_timestamp_weirdness(5, False) self._test_update_timestamp_weirdness(5, False)
# the timestamp of the SIBLING of the deleted, re-added record # the timestamp of the SIBLING of the deleted, re-added record
# differs from the sibling of freshly added record. # differs from the sibling of freshly added record.
self.assertEqual(time_A, n_days_ago) self.assert_timestamps_equal(time_A, n_days_ago)
def test_update_timestamp_weirdness_no_refresh_aging(self): def test_update_timestamp_weirdness_no_refresh_aging(self):
n_days_ago, time_A, time_B = \ n_days_ago, time_A, time_B = \
self._test_update_timestamp_weirdness(5, True) self._test_update_timestamp_weirdness(5, True)
# the timestamp of the SIBLING of the deleted, re-added record # the timestamp of the SIBLING of the deleted, re-added record
# differs from the sibling of freshly added record. # differs from the sibling of freshly added record.
self.assertEqual(time_A, n_days_ago) self.assert_timestamps_equal(time_A, n_days_ago)
def test_update_timestamp_weirdness_refresh_no_aging(self): def test_update_timestamp_weirdness_refresh_no_aging(self):
n_days_ago, time_A, time_B = \ n_days_ago, time_A, time_B = \
self._test_update_timestamp_weirdness(9, False) self._test_update_timestamp_weirdness(9, False)
self.assertEqual(time_A, time_B) self.assert_timestamps_equal(time_A, time_B)
def test_update_timestamp_weirdness_refresh_aging(self): def test_update_timestamp_weirdness_refresh_aging(self):
n_days_ago, time_A, time_B = \ n_days_ago, time_A, time_B = \
self._test_update_timestamp_weirdness(9, True) self._test_update_timestamp_weirdness(9, True)
self.assertEqual(time_A, time_B) self.assert_timestamps_equal(time_A, time_B)
def test_aging_refresh(self): def test_aging_refresh(self):
name, txt = 'agingtest', ['test txt'] name, txt = 'agingtest', ['test txt']
@ -1650,8 +1650,8 @@ class TestDNSAging(DNSTest):
# wouldn't be if we had stuck to the default of 84). # wouldn't be if we had stuck to the default of 84).
self.ldap_modify_timestamps(name, -86) self.ldap_modify_timestamps(name, -86)
rec = self.dns_update_record(name, txt) rec = self.dns_update_record(name, txt)
self.assertEqual(rec.dwTimeStamp, self.assert_timestamps_equal(rec.dwTimeStamp,
start_time - 86) start_time - 86)
# back to -102 hours, into the refresh zone # back to -102 hours, into the refresh zone
# the update should reset the timestamp to now. # the update should reset the timestamp to now.