def test_validate_token_false(self, mock_from_json):
token = mtoken.Token()
mock_from_json.return_value = token
validate_func = mock.Mock()
validate_func.side_effect = [False, True, False]
token.is_ip_restricted = True
self.assertFalse(
handlers.common.token.validate_token(
token, "GET", None, validate_func)[0])
token.is_ip_restricted = True
token.ip_address = "127.1.1.1"
self.assertFalse(
handlers.common.token.validate_token(
token, "GET", "127.0.0.1", validate_func)[0])
token.is_ip_restricted = False
self.assertFalse(
handlers.common.token.validate_token(
token, "GET", None, validate_func)[0])
def test_valid_ip_single_ip(self):
token_obj = modt.Token()
token_obj.is_ip_restricted = True
token_obj.ip_address = '127.0.0.1'
self.assertTrue(token_obj.is_valid_ip('127.0.0.1'))
self.assertFalse(token_obj.is_valid_ip('127.0.0.3'))
def test_valid_ip_network(self):
token_obj = modt.Token()
token_obj.is_ip_restricted = True
token_obj.ip_address = '192.0.4.0/25'
self.assertTrue(token_obj.is_valid_ip('192.0.4.125'))
self.assertFalse(token_obj.is_valid_ip('192.0.5.1'))
def test_token_to_dict_is_dict(self):
token_obj = modt.Token()
token_obj.id = "token-id"
token_obj.email = "*****@*****.**"
token_obj.created_on = "now"
token_obj.token = "token"
token_obj.username = "******"
token_obj.version = "1.1"
expected = {
"_id": "token-id",
"created_on": "now",
"email": "*****@*****.**",
"expired": False,
"expires_on": None,
"ip_address": None,
"properties": [0 for _ in range(0, 16)],
"token": "token",
"username": "******",
"version": "1.1",
}
obtained = token_obj.to_dict()
self.assertIsInstance(obtained, types.DictionaryType)
self.assertDictEqual(expected, obtained)
def test_ip_address_check_with_ip_address(self):
addrlist = ['127.0.0.1']
token_obj = modt.Token()
token_obj.ip_address = addrlist
expected = [netaddr.IPAddress('127.0.0.1').ipv6(ipv4_compatible=True)]
self.assertEqual(expected, token_obj.ip_address)
def test_get_lab_name_none(self, mock_find):
mock_find.return_value = {}
token = mtoken.Token()
lab_name = hbtrigger._get_lab_name(token, self.database)
self.assertIsNone(lab_name)
def test_get_lab_name_with_name(self, mock_find):
mock_find.return_value = {"name": "fake_name"}
token = mtoken.Token()
lab_name = hbtrigger._get_lab_name(token, self.database)
self.assertIsNotNone(lab_name)
self.assertEqual("fake_name", lab_name)
def test_validate_token_expired(self, mock_from_json):
token = mtoken.Token()
token.expired = True
mock_from_json.return_value = token
validate_func = mock.Mock()
self.assertFalse(handlers.common.token.validate_token(
token, "GET", None, validate_func)[0])
def test_ip_address_check_with_ip_network(self):
addrlist = ['192.0.4.0/25']
token_obj = modt.Token()
token_obj.ip_address = addrlist
expected = [
netaddr.IPNetwork('192.0.4.0/25').ipv6(ipv4_compatible=True)
]
self.assertEqual(expected, token_obj.ip_address)
def test_token_expiry_correct_double_digits(self):
expire_str = "2014-07-01"
token_obj = modt.Token()
token_obj.expires_on = expire_str
expected = datetime.datetime(2014, 7, 1, 0, 0)
self.assertEqual(expected, token_obj.expires_on)
def test_valid_ip_mix_valid(self):
token_obj = modt.Token()
token_obj.is_ip_restricted = True
token_obj.ip_address = ['10.2.3.4', '192.0.4.0/25']
self.assertTrue(token_obj.is_valid_ip('192.0.4.1'))
self.assertTrue(token_obj.is_valid_ip('10.2.3.4'))
self.assertFalse(token_obj.is_valid_ip('192.1.4.0'))
self.assertFalse(token_obj.is_valid_ip('10.2.3.3'))
self.assertFalse(token_obj.is_valid_ip('127.0.0.1'))
def test_token_properties_setter_wrong_len(self):
token_obj = modt.Token()
expected = [0 for _ in range(0, 16)]
# Make sure the list we have is all 0 and 16 in length.
self.assertListEqual(token_obj.properties, expected)
self.assertRaises(ValueError, setattr, token_obj, "properties",
[0 for _ in range(0, random.randint(0, 15))])
self.assertRaises(ValueError, setattr, token_obj, "properties",
[0 for _ in range(0, random.randint(17, 1024))])
self.assertRaises(ValueError, setattr, token_obj, "properties", [])
def test_token_is_admin(self):
token_obj = modt.Token()
token_obj.is_admin = 1
self.assertEqual(token_obj.is_admin, 1)
self.assertEqual(token_obj.can_create_token, 1)
self.assertEqual(token_obj.is_superuser, 1)
self.assertEqual(token_obj.is_get_token, 1)
self.assertEqual(token_obj.is_delete_token, 1)
self.assertEqual(token_obj.is_post_token, 1)
self.assertEqual(token_obj.is_test_lab_token, 0)
self.assertEqual(token_obj.is_lab_token, 0)
def setUp(self):
# Default Content-Type header returned by Tornado.
self.content_type = "application/json; charset=UTF-8"
self.req_token = mtoken.Token()
self.database = mongomock.MongoClient()["kernel-ci"]
self.redisdb = fakeredis.FakeStrictRedis()
self.dboptions = {
"mongodb_password": "",
"mongodb_user": ""
}
self.mail_options = {
"smtp_port": 465,
"smtp_host": "localhost",
"smtp_user": "******",
"smtp_password": "******",
"smtp_sender": "*****@*****.**",
"smtp_sender_desc": "Me Email"
}
self.settings = {
"dboptions": self.dboptions,
"mailoptions": self.mail_options,
"redis_connection": self.redisdb,
"database": self.database,
"executor": concurrent.futures.ThreadPoolExecutor(max_workers=1),
"default_handler_class": handlers.app.AppHandler,
"debug": False,
"version": "foo",
"master_key": "bar",
"senddelay": 60 * 60
}
super(TestHandlerBase, self).setUp()
patched_find_token = mock.patch(
"handlers.common.token.find_token")
self.find_token = patched_find_token.start()
self.find_token.return_value = self.req_token
patched_validate_token = mock.patch(
"handlers.common.token.validate_token")
self.validate_token = patched_validate_token.start()
self.validate_token.return_value = (True, self.req_token)
self.addCleanup(patched_find_token.stop)
self.addCleanup(patched_validate_token.stop)
self.doc_id = "".join(
[random.choice(string.digits) for x in xrange(24)])
def test_is_lab_token_normal(self, mock_get_lab):
token = mtoken.Token()
token.is_lab_token = True
mock_get_lab.return_value = "fake"
is_lab, is_super, lab_name = hbtrigger._is_lab_token(
token, self.database)
self.assertTrue(is_lab)
self.assertFalse(is_super)
self.assertIsNotNone(lab_name)
token.is_lab_token = False
is_lab, is_super, lab_name = hbtrigger._is_lab_token(
token, self.database)
self.assertFalse(is_lab)
self.assertFalse(is_super)
self.assertIsNone(lab_name)
def test_is_lab_token_admin_super(self):
token = mtoken.Token()
token.is_admin = True
is_lab, is_super, lab_name = hbtrigger._is_lab_token(
token, self.database)
self.assertTrue(is_lab)
self.assertTrue(is_super)
self.assertIsNone(lab_name)
token.is_admin = False
token.is_superuser = True
is_lab, is_super, lab_name = hbtrigger._is_lab_token(
token, self.database)
self.assertTrue(is_lab)
self.assertTrue(is_super)
self.assertIsNone(lab_name)
def _token_update_create(json_obj, token=None, fail=True):
"""Create or update a `Token` object.
If the `token` argument is null, a new one will be created.
:param json_obj: The JSON object with the values to update.
:param token: The `Token` to update. Default to None meaning a new
token will be created.
param fail: If when a mandatory Token field is missing we should fail.
By default True, and it fails when the `email` field is missing.
:return A `Token`.
:raise KeyError, ValueError, TypeError, Exception.
"""
if not token:
token = mtoken.Token()
json_get = json_obj.get
if fail:
token.email = json_obj[models.EMAIL_KEY]
else:
if json_get(models.EMAIL_KEY, None):
token.email = json_get(models.EMAIL_KEY)
if json_get(models.USERNAME_KEY, None):
token.username = json_get(models.USERNAME_KEY)
if json_get(models.EXPIRES_KEY, None):
token.expires_on = json_get(models.EXPIRES_KEY)
if str(json_get(models.EXPIRED_KEY, None)) != "None":
token.expired = json_get(models.EXPIRED_KEY)
if str(json_get(models.GET_KEY, None)) != "None":
token.is_get_token = json_get(models.GET_KEY)
if str(json_get(models.POST_KEY, None)) != "None":
token.is_post_token = json_get(models.POST_KEY)
if str(json_get(models.DELETE_KEY, None)) != "None":
token.is_delete_token = json_get(models.DELETE_KEY)
if str(json_get(models.SUPERUSER_KEY, None)) != "None":
token.is_superuser = json_get(models.SUPERUSER_KEY)
if str(json_get(models.ADMIN_KEY, None)) != "None":
token.is_admin = json_get(models.ADMIN_KEY)
if str(json_get(models.IP_RESTRICTED, None)) != "None":
token.is_ip_restricted = json_get(models.IP_RESTRICTED)
if str(json_get(models.LAB_KEY, None)) != "None":
token.is_lab_token = json_get(models.LAB_KEY)
if str(json_get(models.UPLOAD_KEY, None)) != "None":
token.is_upload_token = json_get(models.UPLOAD_KEY)
if str(json_get(models.TEST_LAB_KEY, None)) != "None":
token.is_test_lab_token = json_get(models.TEST_LAB_KEY)
if (token.is_ip_restricted
and not json_get(models.IP_ADDRESS_KEY, None)):
raise Exception("IP restricted but no IP addresses given")
elif (json_get(models.IP_ADDRESS_KEY, None)
and not token.is_ip_restricted):
raise Exception(
"IP addresses given, but token is not IP restricted")
elif token.is_ip_restricted and json_get(models.IP_ADDRESS_KEY, None):
token.ip_address = json_get(models.IP_ADDRESS_KEY)
return token
def test_token_with_boolean(self):
token_obj = modt.Token()
token_obj.is_admin = True
self.assertTrue(token_obj.is_admin)
self.assertEqual(token_obj.is_admin, 1)
def test_token_creation_date(self):
token_obj = modt.Token()
self.assertIsInstance(token_obj.created_on, datetime.datetime)
def test_token_not_none(self):
token_obj = modt.Token()
self.assertIsNotNone(token_obj.token)
def test_unique_token(self):
token_obj1 = modt.Token()
token_obj2 = modt.Token()
self.assertNotEqual(token_obj1.token, token_obj2.token)
def test_properties_len(self):
token_obj = modt.Token()
self.assertEqual(len(token_obj.properties), 16)
def test_not_expired(self):
token_obj = modt.Token()
self.assertFalse(token_obj.expired)
def test_token_wrong_expiry(self):
token_obj = modt.Token()
self.assertRaises(ValueError, setattr, token_obj, "expires_on",
"2014-06")
def test_token_model_is_base_document(self):
token_obj = modt.Token()
self.assertIsInstance(token_obj, modb.BaseDocument)
def test_token_valid_negative_number(self):
token_obj = modt.Token()
token_obj.is_superuser = -1
self.assertTrue(token_obj.is_superuser)
def test_valid_ip_single_ip_wrong_address(self):
token_obj = modt.Token()
token_obj.is_ip_restricted = True
token_obj.ip_address = '127.0.0.1'
self.assertFalse(token_obj.is_valid_ip("a.b.c"))
def test_token_properties_setter_wrong_type(self):
token_obj = modt.Token()
self.assertRaises(TypeError, setattr, token_obj, "properties", "")
self.assertRaises(TypeError, setattr, token_obj, "properties", ())
self.assertRaises(TypeError, setattr, token_obj, "properties", {})
def test_valid_ip_no_restricted(self):
token_obj = modt.Token()
self.assertTrue(token_obj.is_valid_ip("foo"))
def test_token_negative_number(self):
token_obj = modt.Token()
self.assertRaises(ValueError, setattr, token_obj, "is_admin", -22)
