def test_11_old_validity_time(self):
old_time_1 = "11/04/17 22:00" # April 4th
old_time_2 = "24/04/17 22:00" # April 24th
db_token = Token.query.filter_by(serial=self.serial1).first()
token = TokenClass(db_token)
token.add_tokeninfo("validity_period_start", old_time_1)
token.add_tokeninfo("validity_period_end", old_time_2)
info = token.get_tokeninfo()
self.assertEqual(info.get("validity_period_start"), old_time_1)
self.assertEqual(info.get("validity_period_end"), old_time_2)
e = token.get_validity_period_end()
self.assertTrue(e.startswith("2017-04-24T22:00"), e)
s = token.get_validity_period_start()
self.assertTrue(s.startswith("2017-04-11T22:00"), s)
# old date format has problems with check_validity_date
start_date = datetime.datetime.now() - datetime.timedelta(days=15)
end_date = datetime.datetime.now() + datetime.timedelta(days=15)
start = start_date.strftime("%d/%m/%Y")
end = end_date.strftime("%d/%m/%Y")
# Need to write the old format to the database
token.add_tokeninfo("validity_period_start", start)
token.add_tokeninfo("validity_period_end", end)
r = token.check_validity_period()
self.assertTrue(r)
def test_11_old_validity_time(self):
old_time_1 = "11/04/17 22:00" # April 4th
old_time_2 = "24/04/17 22:00" # April 24th
db_token = Token.query.filter_by(serial=self.serial1).first()
token = TokenClass(db_token)
token.add_tokeninfo("validity_period_start", old_time_1)
token.add_tokeninfo("validity_period_end", old_time_2)
info = token.get_tokeninfo()
self.assertEqual(info.get("validity_period_start"), old_time_1)
self.assertEqual(info.get("validity_period_end"), old_time_2)
e = token.get_validity_period_end()
self.assertTrue(e.startswith("2017-04-24T22:00"), e)
s = token.get_validity_period_start()
self.assertTrue(s.startswith("2017-04-11T22:00"), s)
# old date format has problems with check_validity_date
start_date = datetime.datetime.now() - datetime.timedelta(days=15)
end_date = datetime.datetime.now() + datetime.timedelta(days=15)
start = start_date.strftime("%d/%m/%Y")
end = end_date.strftime("%d/%m/%Y")
# Need to write the old format to the database
token.add_tokeninfo("validity_period_start", start)
token.add_tokeninfo("validity_period_end", end)
r = token.check_validity_period()
self.assertTrue(r)
def test_11_tokeninfo(self):
db_token = Token.query.filter_by(serial=self.serial1).first()
token = TokenClass(db_token)
token.add_tokeninfo("key1", "value2")
info1 = token.get_tokeninfo()
self.assertTrue("key1" in info1, info1)
token.add_tokeninfo("key2", "value3")
info2 = token.get_tokeninfo()
self.assertTrue("key2" in info2, info2)
token.set_tokeninfo(info1)
info2 = token.get_tokeninfo()
self.assertTrue("key2" not in info2, info2)
self.assertTrue(token.get_tokeninfo("key1") == "value2",
info2)
# auth counter
token.set_count_auth_success_max(200)
token.set_count_auth_max(1000)
token.set_count_auth_success(100)
token.inc_count_auth_success()
token.set_count_auth(200)
token.inc_count_auth()
self.assertTrue(token.get_count_auth_success_max() == 200)
self.assertTrue(token.get_count_auth_success() == 101)
self.assertTrue(token.get_count_auth_max() == 1000)
self.assertTrue(token.get_count_auth() == 201)
self.assertTrue(token.check_auth_counter())
token.set_count_auth_max(10)
self.assertFalse(token.check_auth_counter())
token.set_count_auth_max(1000)
token.set_count_auth_success_max(10)
self.assertFalse(token.check_auth_counter())
# set the max counter to 0 means authentication is allowed
# 0 is unlimited
token.set_count_auth_max(0)
token.set_count_auth_success_max(0)
self.assertEqual(token.check_auth_counter(), True)
# handle validity end date
token.set_validity_period_end("30/12/14 16:00")
end = token.get_validity_period_end()
self.assertTrue(end == "30/12/14 16:00", end)
self.assertRaises(Exception,
token.set_validity_period_end, "wrong date")
# handle validity start date
token.set_validity_period_start("30/12/13 16:00")
start = token.get_validity_period_start()
self.assertTrue(start == "30/12/13 16:00", start)
self.assertRaises(Exception,
token.set_validity_period_start, "wrong date")
self.assertFalse(token.check_validity_period())
# THe token is valid till 2021, this should be enough!
token.set_validity_period_end("30/12/21 16:00")
self.assertTrue(token.check_validity_period())
token.set_validity_period_end("2015-05-22T22:00:00.000Z")
end = token.get_validity_period_end()
self.assertEqual(end, "22/05/15 22:00")
token.set_validity_period_start("2015-05-22T22:00:00.000Z")
start = token.get_validity_period_start()
self.assertEqual(start, "22/05/15 22:00")
# check validity period
# +5 days
end_date = datetime.datetime.now() + datetime.timedelta(5)
end = end_date.strftime(DATE_FORMAT)
token.set_validity_period_end(end)
# - 5 days
start_date = datetime.datetime.now() - datetime.timedelta(5)
start = start_date.strftime(DATE_FORMAT)
token.set_validity_period_start(start)
self.assertTrue(token.check_validity_period())
# check before start date
# +5 days
end_date = datetime.datetime.now() + datetime.timedelta(5)
end = end_date.strftime(DATE_FORMAT)
token.set_validity_period_end(end)
# + 2 days
start_date = datetime.datetime.now() + datetime.timedelta(2)
start = start_date.strftime(DATE_FORMAT)
token.set_validity_period_start(start)
self.assertFalse(token.check_validity_period())
# check after enddate
# -1 day
end_date = datetime.datetime.now() - datetime.timedelta(1)
end = end_date.strftime(DATE_FORMAT)
token.set_validity_period_end(end)
# - 10 days
start_date = datetime.datetime.now() - datetime.timedelta(10)
start = start_date.strftime(DATE_FORMAT)
token.set_validity_period_start(start)
self.assertFalse(token.check_validity_period())
def test_11_tokeninfo(self):
db_token = Token.query.filter_by(serial=self.serial1).first()
token = TokenClass(db_token)
token.add_tokeninfo("key1", "value2")
info1 = token.get_tokeninfo()
self.assertTrue("key1" in info1, info1)
token.add_tokeninfo("key2", "value3")
info2 = token.get_tokeninfo()
self.assertTrue("key2" in info2, info2)
token.set_tokeninfo(info1)
info2 = token.get_tokeninfo()
self.assertTrue("key2" not in info2, info2)
self.assertTrue(token.get_tokeninfo("key1") == "value2", info2)
# auth counter
token.set_count_auth_success_max(200)
token.set_count_auth_max(1000)
token.set_count_auth_success(100)
token.inc_count_auth_success()
token.set_count_auth(200)
token.inc_count_auth()
self.assertTrue(token.get_count_auth_success_max() == 200)
self.assertTrue(token.get_count_auth_success() == 101)
self.assertTrue(token.get_count_auth_max() == 1000)
self.assertTrue(token.get_count_auth() == 201)
self.assertTrue(token.check_auth_counter())
token.set_count_auth_max(10)
self.assertFalse(token.check_auth_counter())
token.set_count_auth_max(1000)
token.set_count_auth_success_max(10)
self.assertFalse(token.check_auth_counter())
# set the max counter to 0 means authentication is allowed
# 0 is unlimited
token.set_count_auth_max(0)
token.set_count_auth_success_max(0)
self.assertEqual(token.check_auth_counter(), True)
# handle validity end date
token.set_validity_period_end("2014-12-30T16:00+0400")
end = token.get_validity_period_end()
self.assertTrue(end == "2014-12-30T16:00+0400", end)
self.assertRaises(TokenAdminError, token.set_validity_period_end,
"wrong date")
# handle validity start date
token.set_validity_period_start("2014-12-30T16:00+0400")
start = token.get_validity_period_start()
self.assertTrue(start == "2014-12-30T16:00+0400", start)
self.assertRaises(TokenAdminError, token.set_validity_period_start,
"wrong date")
self.assertFalse(token.check_validity_period())
# delete the validity period end by passing an empty string
token.set_validity_period_end('')
end = token.get_validity_period_end()
self.assertTrue(end == "", end)
self.assertTrue(token.check_validity_period())
# try the same for the validity period start
start_date_5d = datetime.datetime.now(
tzlocal()) + datetime.timedelta(5)
token.set_validity_period_start(start_date_5d.strftime(DATE_FORMAT))
self.assertFalse(token.check_validity_period())
token.set_validity_period_start('')
self.assertTrue(token.check_validity_period())
token.set_validity_period_end("2015-05-22T22:00:00.000Z")
end = token.get_validity_period_end()
self.assertEqual(end, "2015-05-22T22:00+0000")
token.set_validity_period_start("2015-05-22T22:00:00.000Z")
start = token.get_validity_period_start()
self.assertEqual(start, "2015-05-22T22:00+0000")
# check validity period
# +5 days
end_date = datetime.datetime.now(tzlocal()) + datetime.timedelta(5)
end = end_date.strftime(DATE_FORMAT)
token.set_validity_period_end(end)
# - 5 days
start_date = datetime.datetime.now(tzlocal()) - datetime.timedelta(5)
start = start_date.strftime(DATE_FORMAT)
token.set_validity_period_start(start)
self.assertTrue(token.check_validity_period())
# check before start date
# +5 days
end_date = datetime.datetime.now(tzlocal()) + datetime.timedelta(5)
end = end_date.strftime(DATE_FORMAT)
token.set_validity_period_end(end)
# + 2 days
start_date = datetime.datetime.now(tzlocal()) + datetime.timedelta(2)
start = start_date.strftime(DATE_FORMAT)
token.set_validity_period_start(start)
self.assertFalse(token.check_validity_period())
# check after enddate
# -1 day
end_date = datetime.datetime.now(tzlocal()) - datetime.timedelta(1)
end = end_date.strftime(DATE_FORMAT)
token.set_validity_period_end(end)
# - 10 days
start_date = datetime.datetime.now(tzlocal()) - datetime.timedelta(10)
start = start_date.strftime(DATE_FORMAT)
token.set_validity_period_start(start)
self.assertFalse(token.check_validity_period())
