def test_user_search(self):
"""
Verify that if 'user' is passed in as a parameter, username and realm
are added to the search parameters.
"""
from linotp.lib.audit.iterator import AuditQuery
user = MagicMock(spec=["login", "realm"])
user.login = "******"
user.realm = "myrealm"
audit = MagicMock(spec=["searchQuery"])
audit.searchQuery.return_value = iter([])
audit_query = AuditQuery({
"qtype": "action",
"query": "audit/search"
},
audit,
user=user)
audit_iterator = iter(audit_query.get_query_result())
assert len(list(audit_iterator)) == 0
audit.searchQuery.assert_called_once_with(
{
"action": "audit/search",
"realm": "myrealm",
"user": "******"
},
rp_dict={
# 'rp': '15',
"sortname": None,
"sortorder": "asc",
},
)
return
def test_row2dict_called(self):
"""
Verify that audit.row2dict is called when some element returned by
the searchQuery is no dictionary
"""
from linotp.lib.audit.iterator import AuditQuery
audit = MagicMock(spec=["searchQuery", "row2dict"])
audit.searchQuery.return_value = [None, {'key': 'value'}]
audit_query = AuditQuery({}, audit)
audit_iterator = iter(audit_query.get_query_result())
rows = 0
for row in audit_iterator:
audit_query.get_entry(row)
rows = rows + 1
self.assertEqual(rows, 2)
audit.searchQuery.assert_called_once_with(
{},
rp_dict={
'sortname': None,
'sortorder': None
}
)
audit.row2dict.assert_called_once_with(None)
return
def test_searchQuery_3(self):
"""
Verify searchQuery parameters.
Unicode
"""
from linotp.lib.audit.iterator import AuditQuery
param = {
"rp": "15",
"sortname": "number",
"session": "deadbeef00174df8e77bde249de541d132903568b767"
"706bb84b59b3fa5ad523",
"sortorder": "desc",
"query": "حافظ",
"qtype": "user",
"page": "1",
}
audit = MagicMock(spec=["searchQuery"])
audit_query = AuditQuery(param, audit)
audit_iterator = iter(audit_query.get_query_result())
assert len(list(audit_iterator)) == 0
audit.searchQuery.assert_called_once_with(
{"user": "******"},
rp_dict={
"sortorder": "desc",
"rp": "15",
"page": 1,
"sortname": "number",
},
)
def test_user_search(self):
"""
Verify that if 'user' is passed in as a parameter, username and realm
are added to the search parameters.
"""
user = MagicMock(spec=["login", "realm"])
user.login = "******"
user.realm = "myrealm"
audit = MagicMock(spec=["searchQuery"])
audit.searchQuery.return_value = iter([])
audit_query = AuditQuery(
{
'qtype': 'action',
'query': 'audit/search'
},
audit,
user=user
)
audit_iterator = iter(audit_query.get_query_result())
self.assertEqual(len(list(audit_iterator)), 0)
audit.searchQuery.assert_called_once_with(
{
'action': 'audit/search',
'realm': 'myrealm',
'user': '******'
},
rp_dict={
# 'rp': '15',
'sortname': None,
'sortorder': None
}
)
return
def test_searchQuery_2(self):
"""
Verify searchQuery parameters.
Search in realm, 10 per page, second page
"""
from linotp.lib.audit.iterator import AuditQuery
param = {
"rp": "10",
"sortname": "number",
"session": "deadbeef00174df8e77bde249de541d132903568b767"
"706bb84b59b3fa5ad523",
"sortorder": "desc",
"query": "se_test_auth",
"qtype": "realm",
"page": "2",
}
audit = MagicMock(spec=["searchQuery"])
audit_query = AuditQuery(param, audit)
audit_iterator = iter(audit_query.get_query_result())
assert len(list(audit_iterator)) == 0
audit.searchQuery.assert_called_once_with(
{"realm": "se_test_auth"},
rp_dict={
"sortorder": "desc",
"rp": "10",
"page": 2,
"sortname": "number",
},
)
def test_searchQuery_3(self):
"""
Verify searchQuery parameters.
Unicode
"""
param = {
'rp': u'15',
'sortname': u'number',
'session': u'deadbeef00174df8e77bde249de541d132903568b767'
'706bb84b59b3fa5ad523',
'sortorder': u'desc',
'query': u'حافظ',
'qtype': u'user',
'page': u'1'
}
audit = MagicMock(spec=["searchQuery"])
audit_query = AuditQuery(param, audit)
audit_iterator = iter(audit_query.get_query_result())
self.assertEqual(len(list(audit_iterator)), 0)
audit.searchQuery.assert_called_once_with(
{u'user': u'حافظ'},
rp_dict={
'sortorder': u'desc',
'rp': u'15',
'page': 1,
'sortname': u'number'
}
)
def test_00_searchQuery_1(self):
"""
Simply verifies that the external method searchQuery is invoked with
the right parameters. On a real system the call would most probably
be received by linotp.lib.audit.SQLAudit
"""
from linotp.lib.audit.iterator import AuditQuery
param = {
"rp": "15",
"sortname": "number",
"session": "deadbeef00174df8e77bdf249de"
"541d132903568b763306bb84b59b3fa5ad111",
"sortorder": "desc",
"query": "",
"qtype": "serial",
"page": "1",
}
audit = MagicMock(spec=["searchQuery", "getTotal"])
audit_query = AuditQuery(param, audit)
audit_iterator = iter(audit_query.get_query_result())
assert len(list(audit_iterator)) == 0
audit.searchQuery.assert_called_once_with(
{"serial": ""},
rp_dict={
"sortorder": "desc",
"rp": "15",
"page": 1,
"sortname": "number",
},
)
def test_searchQuery_4(self):
"""
Verify searchQuery parameters.
extended search (extsearch)
"""
from linotp.lib.audit.iterator import AuditQuery
param = {
"rp": "15",
"sortname": "number",
"session":
"deadbeef00174df8e77bde249de541d132903568b767706bb84b59b3fa5ad523",
"sortorder": "desc",
"query": "action=audit/search;success=1;number=730",
"qtype": "extsearch",
"page": "1",
}
audit = MagicMock(spec=["searchQuery"])
audit_query = AuditQuery(param, audit)
audit_iterator = iter(audit_query.get_query_result())
assert len(list(audit_iterator)) == 0
audit.searchQuery.assert_called_once_with(
{
"action": "audit/search",
"number": "730",
"success": "1"
},
rp_dict={
"sortorder": "desc",
"rp": "15",
"page": 1,
"sortname": "number",
},
)
def test_00_searchQuery_1(self):
"""
Simply verifies that the external method searchQuery is invoked with
the right parameters. On a real system the call would most probably
be received by linotp.lib.audit.SQLAudit
"""
from linotp.lib.audit.iterator import AuditQuery
param = {
'rp': u'15',
'sortname': u'number',
'session': u'deadbeef00174df8e77bdf249de'
'541d132903568b763306bb84b59b3fa5ad111',
'sortorder': u'desc',
'query': u'',
'qtype': u'serial',
'page': u'1'
}
audit = MagicMock(spec=["searchQuery", "getTotal"])
audit_query = AuditQuery(param, audit)
audit_iterator = iter(audit_query.get_query_result())
self.assertEqual(len(list(audit_iterator)), 0)
audit.searchQuery.assert_called_once_with({u'serial': u''},
rp_dict={
'sortorder': u'desc',
'rp': u'15',
'page': 1,
'sortname': u'number'
})
def test_user_search(self):
"""
Verify that if 'user' is passed in as a parameter, username and realm
are added to the search parameters.
"""
from linotp.lib.audit.iterator import AuditQuery
user = MagicMock(spec=["login", "realm"])
user.login = "******"
user.realm = "myrealm"
audit = MagicMock(spec=["searchQuery"])
audit.searchQuery.return_value = iter([])
audit_query = AuditQuery({
'qtype': 'action',
'query': 'audit/search'
},
audit,
user=user)
audit_iterator = iter(audit_query.get_query_result())
self.assertEqual(len(list(audit_iterator)), 0)
audit.searchQuery.assert_called_once_with(
{
'action': 'audit/search',
'realm': 'myrealm',
'user': '******'
},
rp_dict={
# 'rp': '15',
'sortname': None,
'sortorder': None
})
return
def test_00_searchQuery_1(self):
"""
Simply verifies that the external method searchQuery is invoked with
the right parameters. On a real system the call would most probably
be received by linotp.lib.audit.SQLAudit
"""
from linotp.lib.audit.iterator import AuditQuery
param = {
'rp': u'15',
'sortname': u'number',
'session': u'deadbeef00174df8e77bdf249de'
'541d132903568b763306bb84b59b3fa5ad111',
'sortorder': u'desc',
'query': u'',
'qtype': u'serial',
'page': u'1'
}
audit = MagicMock(spec=["searchQuery", "getTotal"])
audit_query = AuditQuery(param, audit)
audit_iterator = iter(audit_query.get_query_result())
self.assertEqual(len(list(audit_iterator)), 0)
audit.searchQuery.assert_called_once_with(
{u'serial': u''},
rp_dict={
'sortorder': u'desc',
'rp': u'15',
'page': 1,
'sortname': u'number'
}
)
def test_row2dict_called(self):
"""
Verify that audit.row2dict is called when some element returned by
the searchQuery is no dictionary
"""
from linotp.lib.audit.iterator import AuditQuery
audit = MagicMock(spec=["searchQuery", "row2dict"])
audit.searchQuery.return_value = [None, {'key': 'value'}]
audit_query = AuditQuery({}, audit)
audit_iterator = iter(audit_query.get_query_result())
rows = 0
for row in audit_iterator:
audit_query.get_entry(row)
rows = rows + 1
assert rows == 2
audit.searchQuery.assert_called_once_with(
{},
rp_dict={
'sortname': None,
'sortorder': 'asc'
}
)
audit.row2dict.assert_called_once_with(None)
return
def test_searchQuery_4(self):
"""
Verify searchQuery parameters.
extended search (extsearch)
"""
from linotp.lib.audit.iterator import AuditQuery
param = {
'rp': u'15',
'sortname': u'number',
'session':
u'deadbeef00174df8e77bde249de541d132903568b767706bb84b59b3fa5ad523',
'sortorder': u'desc',
'query': u'action=audit/search;success=1;number=730',
'qtype': u'extsearch',
'page': u'1'
}
audit = MagicMock(spec=["searchQuery"])
audit_query = AuditQuery(param, audit)
audit_iterator = iter(audit_query.get_query_result())
self.assertEqual(len(list(audit_iterator)), 0)
audit.searchQuery.assert_called_once_with(
{
u'action': u'audit/search',
u'number': u'730',
u'success': u'1'
},
rp_dict={
'sortorder': u'desc',
'rp': u'15',
'page': 1,
'sortname': u'number'
})
def test_searchQuery_2(self):
"""
Verify searchQuery parameters.
Search in realm, 10 per page, second page
"""
from linotp.lib.audit.iterator import AuditQuery
param = {
'rp': u'10',
'sortname': u'number',
'session': u'deadbeef00174df8e77bde249de541d132903568b767'
'706bb84b59b3fa5ad523',
'sortorder': u'desc',
'query': u'se_test_auth',
'qtype': u'realm',
'page': u'2'
}
audit = MagicMock(spec=["searchQuery"])
audit_query = AuditQuery(param, audit)
audit_iterator = iter(audit_query.get_query_result())
self.assertEqual(len(list(audit_iterator)), 0)
audit.searchQuery.assert_called_once_with(
{u'realm': u'se_test_auth'},
rp_dict={
'sortorder': u'desc',
'rp': u'10',
'page': 2,
'sortname': u'number'
}
)
def test_searchQuery_3(self):
"""
Verify searchQuery parameters.
Unicode
"""
from linotp.lib.audit.iterator import AuditQuery
param = {
'rp': '15',
'sortname': 'number',
'session': 'deadbeef00174df8e77bde249de541d132903568b767'
'706bb84b59b3fa5ad523',
'sortorder': 'desc',
'query': 'حافظ',
'qtype': 'user',
'page': '1'
}
audit = MagicMock(spec=["searchQuery"])
audit_query = AuditQuery(param, audit)
audit_iterator = iter(audit_query.get_query_result())
assert len(list(audit_iterator)) == 0
audit.searchQuery.assert_called_once_with(
{'user': '******'},
rp_dict={
'sortorder': 'desc',
'rp': '15',
'page': 1,
'sortname': 'number'
}
)
def test_searchQuery_2(self):
"""
Verify searchQuery parameters.
Search in realm, 10 per page, second page
"""
from linotp.lib.audit.iterator import AuditQuery
param = {
'rp': u'10',
'sortname': u'number',
'session': u'deadbeef00174df8e77bde249de541d132903568b767'
'706bb84b59b3fa5ad523',
'sortorder': u'desc',
'query': u'se_test_auth',
'qtype': u'realm',
'page': u'2'
}
audit = MagicMock(spec=["searchQuery"])
audit_query = AuditQuery(param, audit)
audit_iterator = iter(audit_query.get_query_result())
self.assertEqual(len(list(audit_iterator)), 0)
audit.searchQuery.assert_called_once_with({u'realm': u'se_test_auth'},
rp_dict={
'sortorder': u'desc',
'rp': u'10',
'page': 2,
'sortname': u'number'
})
def test_searchQuery_4(self):
"""
Verify searchQuery parameters.
extended search (extsearch)
"""
from linotp.lib.audit.iterator import AuditQuery
param = {
'rp': u'15',
'sortname': u'number',
'session': u'deadbeef00174df8e77bde249de541d132903568b767706bb84b59b3fa5ad523',
'sortorder': u'desc',
'query': u'action=audit/search;success=1;number=730',
'qtype': u'extsearch',
'page': u'1'
}
audit = MagicMock(spec=["searchQuery"])
audit_query = AuditQuery(param, audit)
audit_iterator = iter(audit_query.get_query_result())
self.assertEqual(len(list(audit_iterator)), 0)
audit.searchQuery.assert_called_once_with(
{
u'action': u'audit/search',
u'number': u'730',
u'success': u'1'
},
rp_dict={
'sortorder': u'desc',
'rp': u'15',
'page': 1,
'sortname': u'number'
}
)
def test_CSVAuditIterator(self):
"""
Verify that the the CSVAuditIterator outputs the expected data given
certain input values
"""
from linotp.lib.audit.iterator import (AuditQuery, CSVAuditIterator)
expected_csv = \
u""""number", "date", "sig_check", "missing_line", "action", "success", "serial", "token_type", "user", "realm", "administrator", "action_detail", "info", "linotp_server", "client", "log_level", "clearance_level"
768, "2014-04-25 11:52:54.243084", "OK", null, "validate/check", "1", "LSSP000120D8", "spass", "حافظ", "se_realm1", "", "", "", "oldjoe", "192.168.33.44", "INFO", 0
764, "2014-04-25 11:52:24.937293", "OK", null, "admin/init", "1", "", "", "حافظ", "se_realm1", "admin", "tokennum = 10", "", "oldjoe", "192.168.33.44", "INFO", 0
"""
param = {u'user': u'حافظ', 'headers': ''}
next_1 = {
'info': u'',
'administrator': u'',
'realm': u'se_realm1',
'success': u'1',
'linotp_server': u'oldjoe',
'sig_check': 'OK',
'number': 768L,
'token_type': u'spass',
'action': u'validate/check',
'client': u'192.168.33.44',
'user': u'حافظ',
'clearance_level': 0L,
'action_detail': u'',
'date': '2014-04-25 11:52:54.243084',
'log_level': u'INFO',
'serial': u'LSSP000120D8'
}
next_2 = {
'info': u'',
'administrator': u'admin',
'realm': u'se_realm1',
'success': u'1',
'linotp_server': u'oldjoe',
'sig_check': 'OK',
'number': 764L,
'token_type': u'',
'action': u'admin/init',
'client': u'192.168.33.44',
'user': u'حافظ',
'clearance_level': 0L,
'action_detail': u'tokennum = 10',
'date': '2014-04-25 11:52:24.937293',
'log_level': u'INFO',
'serial': u''
}
audit = MagicMock(spec=["searchQuery", "getTotal"])
audit.searchQuery.return_value = iter([next_1, next_2])
audit.getTotal.return_value = 2
audit_query = AuditQuery(param, audit)
csv_audit_iterator = CSVAuditIterator(audit_query, ',')
result_csv = ""
for value in csv_audit_iterator:
result_csv += value
result_csv = result_csv.decode('utf-8')
self.assertEqual(expected_csv, result_csv,
"%r \n\n%r" % (expected_csv, result_csv))
return
def test_JSONAuditIterator_1(self):
"""
Verify that the the JSONAuditIterator outputs the expected data given
certain input values
"""
from linotp.lib.audit.iterator import (AuditQuery, JSONAuditIterator)
param = {u'user': u'حافظ'}
next_1 = {
'info': u'',
'administrator': u'',
'realm': u'se_realm1',
'success': u'1',
'linotp_server': u'oldjoe',
'sig_check': 'OK',
'number': 768L,
'token_type': u'spass',
'action': u'validate/check',
'client': u'192.168.33.44',
'user': u'حافظ',
'clearance_level': 0L,
'action_detail': u'',
'date': '2014-04-25 11:52:54.243084',
'log_level': u'INFO',
'serial': u'LSSP000120D8'
}
next_2 = {
'info': u'',
'administrator': u'admin',
'realm': u'se_realm1',
'success': u'1',
'linotp_server': u'oldjoe',
'sig_check': 'OK',
'number': 764L,
'token_type': u'',
'action': u'admin/init',
'client': u'192.168.33.44',
'user': u'حافظ',
'clearance_level': 0L,
'action_detail': u'tokennum = 10',
'date': '2014-04-25 11:52:24.937293',
'log_level': u'INFO',
'serial': u''
}
audit = MagicMock(spec=["searchQuery", "getTotal"])
audit.searchQuery.return_value = iter([next_1, next_2])
audit.getTotal.return_value = 2
audit_query = AuditQuery(param, audit)
json_audit_iterator = JSONAuditIterator(audit_query)
result_json = ""
for value in json_audit_iterator:
result_json += value
expected_json = \
u"""{ "page": 1, "rows": [ {
"cell": [
768,
"2014-04-25 11:52:54.243084",
"OK",
null,
"validate/check",
"1",
"LSSP000120D8",
"spass",
"حافظ",
"se_realm1",
"",
"",
"",
"oldjoe",
"192.168.33.44",
"INFO",
0
],
"id": 768
}, {
"cell": [
764,
"2014-04-25 11:52:24.937293",
"OK",
null,
"admin/init",
"1",
"",
"",
"حافظ",
"se_realm1",
"admin",
"tokennum = 10",
"",
"oldjoe",
"192.168.33.44",
"INFO",
0
],
"id": 764
}], "total": 2 }"""
self.assertEqual(json.loads(result_json), json.loads(expected_json))
def test_CSVAuditIterator(self):
"""
Verify that the the CSVAuditIterator outputs the expected data given
certain input values
"""
from linotp.lib.audit.iterator import AuditQuery, CSVAuditIterator
expected_csv = """"number", "date", "sig_check", "missing_line", "action", "success", "serial", "token_type", "user", "realm", "administrator", "action_detail", "info", "linotp_server", "client", "log_level", "clearance_level"
768, "2014-04-25 11:52:54.243084", "OK", null, "validate/check", "1", "LSSP000120D8", "spass", "حافظ", "se_realm1", "", "", "", "oldjoe", "192.168.33.44", "INFO", 0
764, "2014-04-25 11:52:24.937293", "OK", null, "admin/init", "1", "", "", "حافظ", "se_realm1", "admin", "tokennum = 10", "", "oldjoe", "192.168.33.44", "INFO", 0
"""
param = {"user": "******", "headers": ""}
next_1 = {
"info": "",
"administrator": "",
"realm": "se_realm1",
"success": "1",
"linotp_server": "oldjoe",
"sig_check": "OK",
"number": 768,
"token_type": "spass",
"action": "validate/check",
"client": "192.168.33.44",
"user": "******",
"clearance_level": 0,
"action_detail": "",
"date": "2014-04-25 11:52:54.243084",
"log_level": "INFO",
"serial": "LSSP000120D8",
}
next_2 = {
"info": "",
"administrator": "admin",
"realm": "se_realm1",
"success": "1",
"linotp_server": "oldjoe",
"sig_check": "OK",
"number": 764,
"token_type": "",
"action": "admin/init",
"client": "192.168.33.44",
"user": "******",
"clearance_level": 0,
"action_detail": "tokennum = 10",
"date": "2014-04-25 11:52:24.937293",
"log_level": "INFO",
"serial": "",
}
audit = MagicMock(spec=["searchQuery", "getTotal"])
audit.searchQuery.return_value = iter([next_1, next_2])
audit.getTotal.return_value = 2
audit_query = AuditQuery(param, audit)
csv_audit_iterator = CSVAuditIterator(audit_query, ",")
result_csv = ""
for value in csv_audit_iterator:
result_csv += value
assert expected_csv == result_csv, "%r \n\n%r" % (
expected_csv,
result_csv,
)
return
def search(self):
"""
This functions searches within the audit trail
It returns the audit information for the given search pattern
method:
audit/search
arguments:
key, value pairs as search patterns.
* outform - optional: if set to "csv", than the token list will be
given in CSV
or: Usually the key=values will be locally AND concatenated.
it a parameter or=true is passed, the filters will
be OR concatenated.
The Flexigrid provides us the following parameters:
('page', u'1'), ('rp', u'25'),
('sortname', u'number'),
('sortorder', u'asc'),
('query', u''), ('qtype', u'serial')]
returns:
JSON response or csv format
"""
try:
log.debug("[search] params: %r", self.request_params)
checkPolicyPre("audit", "view", {})
# remove the param outform (and other parameters that should not
# be used for search!
search_params = self.request_params.copy()
for key in ["outform", "delimiter"]:
if key in search_params:
del search_params[key]
output_format = (
self.request_params.get("outform", "json") or "json"
)
delimiter = self.request_params.get("delimiter", ",") or ","
audit_obj = current_app.audit_obj
audit_query = AuditQuery(search_params, audit_obj)
# ------------------------------------------------------------- --
# check if we are running with sqlite which does not support
# streaming responses
stream_output = True
db_uri = current_app.config["SQLALCHEMY_BINDS"]["auditdb"]
if db_uri.startswith("sqlite"):
stream_output = False
if output_format == "csv":
audit_iterator = CSVAuditIterator(audit_query, delimiter)
mimetype = "text/csv"
reponse_headers_args = {
"_key": "Content-disposition",
"_value": "attachment",
"filename": "linotp-audit.csv",
}
else:
audit_iterator = JSONAuditIterator(audit_query)
mimetype = "application/json"
reponse_headers_args = {}
if stream_output:
audit_output = stream_with_context(audit_iterator)
else:
audit_output = ""
try:
while True:
audit_output = audit_output + next(audit_iterator)
except StopIteration:
# continue if all data is joined
pass
streamed_response = Response(audit_output, mimetype=mimetype)
if reponse_headers_args:
streamed_response.headers.set(**reponse_headers_args)
g.audit["success"] = True
db.session.commit()
return streamed_response
except PolicyException as pe:
log.error("[getotp] gettoken/getotp policy failedi: %r", pe)
db.session.rollback()
return sendError(response, pe, 1)
except Exception as exx:
log.error("[search] audit/search failed: %r", exx)
db.session.rollback()
return sendError(response, "audit/search failed", 0)
def search(self):
'''
This functions searches within the audit trail
It returns the audit information for the given search pattern
method:
audit/search
arguments:
key, value pairs as search patterns.
* outform - optional: if set to "csv", than the token list will be
given in CSV
or: Usually the key=values will be locally AND concatenated.
it a parameter or=true is passed, the filters will
be OR concatenated.
The Flexigrid provides us the following parameters:
('page', u'1'), ('rp', u'25'),
('sortname', u'number'),
('sortorder', u'asc'),
('query', u''), ('qtype', u'serial')]
returns:
JSON response or csv format
'''
try:
log.debug("[search] params: %s" % self.request_params)
checkPolicyPre('audit', 'view', {})
# remove the param outform (and other parameters that should not
# be used for search!
search_params = self.request_params.copy()
for key in ["outform", 'delimiter']:
if key in search_params:
del search_params[key]
output_format = self.request_params.get("outform",
'json') or 'json'
streamed_response = None
audit_obj = current_app.audit_obj
audit_query = AuditQuery(search_params, audit_obj)
if output_format == "csv":
delimiter = self.request_params.get('delimiter', ',') or ','
streamed_response = Response(stream_with_context(
CSVAuditIterator(audit_query, delimiter)),
mimetype='text/csv')
streamed_response.headers.set('Content-disposition',
'attachment',
filename='linotp-audit.csv')
else:
streamed_response = Response(stream_with_context(
JSONAuditIterator(audit_query)),
mimetype='application/json')
g.audit['success'] = True
db.session.commit()
return streamed_response
except PolicyException as pe:
log.exception("[getotp] gettoken/getotp policy failed: %r" % pe)
db.session.rollback()
return sendError(response, str(pe), 1)
except Exception as e:
log.exception("[search] audit/search failed: %r" % e)
db.session.rollback()
return sendError(response, "audit/search failed", 0)
def search(self):
'''
This functions searches within the audit trail
It returns the audit information for the given search pattern
method:
audit/search
arguments:
key, value pairs as search patterns.
* outform - optional: if set to "csv", than the token list will be
given in CSV
or: Usually the key=values will be locally AND concatenated.
it a parameter or=true is passed, the filters will
be OR concatenated.
The Flexigrid provides us the following parameters:
('page', u'1'), ('rp', u'25'),
('sortname', u'number'),
('sortorder', u'asc'),
('query', u''), ('qtype', u'serial')]
returns:
JSON response or csv format
'''
param = {}
try:
param.update(request.params)
log.debug("[search] params: %s" % param)
checkPolicyPre('audit', 'view', {})
# remove the param outform (and other parameters that should not
# be used for search!
search_params = {}
search_params.update(param)
for key in ["outform", 'delimiter']:
if key in search_params:
del search_params[key]
output_format = param.get("outform", 'json') or 'json'
delimiter = param.get('delimiter', ',') or ','
audit_iterator = None
audit_query = AuditQuery(search_params, audit)
if output_format == "csv":
filename = "linotp-audit.csv"
response.content_type = "application/force-download"
response.headers['Content-disposition'] = (
'attachment; filename=%s' % filename)
audit_iterator = CSVAuditIterator(audit_query, delimiter)
else:
response.content_type = 'application/json'
audit_iterator = JSONAuditIterator(audit_query)
c.audit['success'] = True
Session.commit()
return audit_iterator
except PolicyException as pe:
log.exception("[getotp] gettoken/getotp policy failed: %r" % pe)
Session.rollback()
return sendError(response, unicode(pe), 1)
except Exception as e:
log.exception("[search] audit/search failed: %r" % e)
Session.rollback()
return sendError(response, "audit/search failed", 0)
finally:
Session.close()
def test_JSONAuditIterator_1(self):
"""
Verify that the the JSONAuditIterator outputs the expected data given
certain input values
"""
from linotp.lib.audit.iterator import AuditQuery, JSONAuditIterator
param = {"user": "******"}
next_1 = {
"info": "",
"administrator": "",
"realm": "se_realm1",
"success": "1",
"linotp_server": "oldjoe",
"sig_check": "OK",
"number": 768,
"token_type": "spass",
"action": "validate/check",
"client": "192.168.33.44",
"user": "******",
"clearance_level": 0,
"action_detail": "",
"date": "2014-04-25 11:52:54.243084",
"log_level": "INFO",
"serial": "LSSP000120D8",
}
next_2 = {
"info": "",
"administrator": "admin",
"realm": "se_realm1",
"success": "1",
"linotp_server": "oldjoe",
"sig_check": "OK",
"number": 764,
"token_type": "",
"action": "admin/init",
"client": "192.168.33.44",
"user": "******",
"clearance_level": 0,
"action_detail": "tokennum = 10",
"date": "2014-04-25 11:52:24.937293",
"log_level": "INFO",
"serial": "",
}
audit = MagicMock(spec=["searchQuery", "getTotal"])
audit.searchQuery.return_value = iter([next_1, next_2])
audit.getTotal.return_value = 2
audit_query = AuditQuery(param, audit)
json_audit_iterator = JSONAuditIterator(audit_query)
result_json = ""
for value in json_audit_iterator:
result_json += value
expected_json = """{ "page": 1, "rows": [ {
"cell": [
768,
"2014-04-25 11:52:54.243084",
"OK",
null,
"validate/check",
"1",
"LSSP000120D8",
"spass",
"حافظ",
"se_realm1",
"",
"",
"",
"oldjoe",
"192.168.33.44",
"INFO",
0
],
"id": 768
}, {
"cell": [
764,
"2014-04-25 11:52:24.937293",
"OK",
null,
"admin/init",
"1",
"",
"",
"حافظ",
"se_realm1",
"admin",
"tokennum = 10",
"",
"oldjoe",
"192.168.33.44",
"INFO",
0
],
"id": 764
}], "total": 2 }"""
assert json.loads(result_json) == json.loads(expected_json)
