def setUp(self):
print("")
self.dmg = DataManager(backend_endpoint=backend_address)
print('Data manager', self.dmg)
# Initialize and load ... no reset
assert self.dmg.user_login('admin', 'admin')
result = self.dmg.load()
def setUp(self):
print("")
print("setting up ...")
self.dmg = DataManager(backend_endpoint=backend_address)
print('Data manager', self.dmg)
# Initialize and do not load
assert self.dmg.user_login('admin', 'admin', load=False)
class Test3LoadCreate(unittest2.TestCase):
def setUp(self):
print("")
self.dmg = DataManager(backend_endpoint=backend_address)
print('Data manager', self.dmg)
def tearDown(self):
print("")
def test_3_1_load(self):
print("")
print('test load as admin')
# Initialize and load ... no reset
assert self.dmg.user_login('admin', 'admin')
result = self.dmg.load()
print("Result:", result)
self.assertEqual(result, 0) # No new objects created ...
# Initialize and load ... with reset
result = self.dmg.load(reset=True)
print("Result:", result)
# Must not have loaded any objects ... behavior changed, no more objects loading on login
self.assertEqual(result, 0)
def test_3_3_get_errors(self):
print("")
print('test get errors')
# Initialize and load ... no reset
assert self.dmg.user_login('admin', 'admin')
result = self.dmg.load()
print("Result:", result)
assert result == 0 # No new objects created ...
# Get users error
item = self.dmg.get_user('unknown')
assert not item
item = self.dmg.get_realm('unknown')
assert not item
item = self.dmg.get_host('unknown')
assert not item
item = self.dmg.get_service('unknown')
assert not item
item = self.dmg.get_command('unknown')
assert not item
def setUp(self):
print ""
self.dmg = DataManager(backend_endpoint=backend_address)
print 'Data manager', self.dmg
# Initialize and load ... no reset
assert self.dmg.user_login('admin', 'admin')
result = self.dmg.load()
def test_1_1_find_objects(self):
print('test find_objects - no objects in cache')
# Create new datamanager - do not use default backend address
datamanager = DataManager(backend_endpoint=backend_address)
self.assertIsNotNone(datamanager.backend)
self.assertFalse(datamanager.loaded)
self.assertIsNone(datamanager.get_logged_user())
# Got known managed elements classes
self.assertEqual(len(datamanager.known_classes), 19)
# Login ...
assert datamanager.backend.login('admin', 'admin')
assert datamanager.loaded == False
assert datamanager.backend.connected
print('logged in as admin in the backend')
# Datamanager is not yet aware of the user login !!!
assert datamanager.get_logged_user() is None
# Get current user
# 'name' is not existing!
parameters = {'where': {"name": "admin"}}
items = datamanager.backend.get('user', params=parameters)
print(items)
assert len(items) == 1
assert items[0]["_id"]
admin_id = items[0]["_id"]
users = datamanager.find_object('user', admin_id)
print(users)
assert len(users) == 1
# New user object created in the DM cache ...
self.assertEqual(datamanager.get_objects_count('user', refresh=True),
1)
# Unknown user not found
with assert_raises(ValueError) as cm:
datamanager.find_object('user', 'fake_id')
ex = cm.exception
print(ex)
assert str(
ex
) == """user, search: {'max_results': 50, 'where': '{"_id": "%s"}', 'page': 0} was not found in the backend""" % 'fake_id'
def user_authentication(username, password):
"""
Authenticate a user thanks to his username / password
The authentication is requested near the data manager. This functions uses the data manager
of the current session, else it creates a new one.
Stores the authenticated User object in the session to make it available
"""
logger.info("user_authentication, authenticating: %s", username)
# Session...
session = request.environ['beaker.session']
# Get backend in the server session (if it exists ... else create)
if 'datamanager' not in session:
logger.info(
"user authentication, creating a new data manager in the session..."
)
logger.info(
"backend: %s",
request.app.config.get('alignak_backend', 'http://127.0.0.1:5000'))
session['datamanager'] = DataManager(
request.app.config.get('alignak_backend', 'http://127.0.0.1:5000'))
# Set user for the data manager and try to log-in.
if not session['datamanager'].user_login(
username, password, load=(password is not None)):
session['message'] = session['datamanager'].connection_message
logger.warning("user authentication refused: %s", session['message'])
return False
# Create a new target user in the session
if 'target_user' not in session:
session['target_user'] = User()
session['message'] = session['datamanager'].connection_message
session['current_user'] = session['datamanager'].get_logged_user()
logger.debug("user_authentication, current user authenticated")
return True
class test_5_basic_tests(unittest2.TestCase):
def setUp(self):
print ""
self.dmg = DataManager(backend_endpoint=backend_address)
print 'Data manager', self.dmg
# Initialize and load ... no reset
assert self.dmg.user_login('admin', 'admin')
result = self.dmg.load()
def tearDown(self):
print ""
# Logout
self.dmg.reset(logout=True)
assert not self.dmg.backend.connected
assert self.dmg.get_logged_user() == None
assert self.dmg.loaded == False
def test_5_1_status(self):
print ''
print 'test objects status'
# Get users
items = self.dmg.get_users()
for item in items:
print "Got", item
assert item.get_id()
icon_status = item.get_html_state()
# Get commands
items = self.dmg.get_commands()
for item in items:
print "Got: ", item
assert item.get_id()
icon_status = item.get_html_state()
class test_3_load_create(unittest2.TestCase):
def setUp(self):
print ""
self.dmg = DataManager(backend_endpoint=backend_address)
print 'Data manager', self.dmg
def tearDown(self):
print ""
def test_3_1_load(self):
print ''
print 'test load as admin'
# Initialize and load ... no reset
assert self.dmg.user_login('admin', 'admin')
result = self.dmg.load()
print "Result:", result
assert result == 0 # No new objects created ...
# Initialize and load ... with reset
result = self.dmg.load(reset=True)
print "Result:", result
# Must have loaded some objects ...
assert result != 0
def test_3_3_get_errors(self):
print ''
print 'test get errors'
# Initialize and load ... no reset
assert self.dmg.user_login('admin', 'admin')
result = self.dmg.load()
print "Result:", result
assert result == 0 # No new objects created ...
# Get users error
item = self.dmg.get_user('unknown')
assert not item
def test_1_1_find_objects(self):
print ''
print 'test find_objects - no objects in cache'
# Create new datamanager - do not use default backend address
datamanager = DataManager(backend_endpoint=backend_address)
assert datamanager.backend
assert datamanager.loaded == False
assert datamanager.get_logged_user() is None
# Login ...
assert datamanager.backend.login('admin', 'admin')
assert datamanager.loaded == False
assert datamanager.backend.authenticated
print 'logged in as admin in the backend'
# Datamanager is not yet aware of the user login !!!
assert datamanager.get_logged_user() is None
# Get current user
# 'name' is not existing!
parameters = {'where': '{"name":"admin"}'}
items = datamanager.backend.get('contact', params=parameters)
print items
assert '_items' in items
assert len(items['_items']) == 1
assert items['_items'][0]["_id"]
admin_id = items['_items'][0]["_id"]
users = datamanager.find_object('contact', admin_id)
print users
assert len(users) == 1
# New user object created in the DM cache ...
assert datamanager.get_objects_count('contact') == 1
# Unknown user not found
with assert_raises(ValueError) as cm:
user = datamanager.find_object('contact', 'fake_id')
ex = cm.exception
print ex
assert str(ex) == """contact, {"_id": "%s"} was not found in the cache nor in the backend""" % 'fake_id'
class test_datatable(unittest2.TestCase):
def setUp(self):
print ""
self.dmg = DataManager(backend_endpoint=backend_address)
print 'Data manager', self.dmg
# Initialize and load ... no reset
assert self.dmg.user_login('admin', 'admin')
result = self.dmg.load()
# Test application
self.app = TestApp(
webapp
)
def tearDown(self):
print ""
# Logout
self.dmg.reset(logout=True)
assert not self.dmg.backend.connected
assert self.dmg.get_logged_user() == None
assert self.dmg.loaded == False
def test_01_ccomands(self):
print ''
print 'test commands table'
global items_count
response = self.app.post('/login', {'username': '******', 'password': '******'})
# Redirected twice: /login -> / -> /dashboard !
redirected_response = response.follow()
redirected_response = redirected_response.follow()
print 'get page /commands_table'
response = self.app.get('/commands_table')
response.mustcontain(
'<div id="commands_table">',
"$('#tbl_command').DataTable( {",
'<table id="tbl_command" class="table table-striped" cellspacing="0" width="100%">',
'<th data-name="name" data-type="string">Command name</th>',
'<th data-name="definition_order" data-type="integer">Definition order</th>',
'<th data-name="command_line" data-type="string">Command line</th>',
'<th data-name="module_type" data-type="string">Module type</th>',
'<th data-name="enable_environment_macros" data-type="boolean">Enable environment macros</th>',
'<th data-name="timeout" data-type="integer">Timeout</th>',
'<th data-name="poller_tag" data-type="string">Poller tag</th>',
'<th data-name="reactionner_tag" data-type="string">Reactionner tag</th>'
)
print 'change content with /commands_table_data'
response = self.app.post('/commands_table_data')
response_value = response.json
print response_value
# Temporary ...
items_count = response.json['recordsTotal']
# assert response.json['recordsTotal'] == items_count
# assert response.json['recordsFiltered'] == items_count if items_count < BACKEND_PAGINATION_DEFAULT else BACKEND_PAGINATION_DEFAULT
assert response.json['data']
for x in range(0, items_count):
if x < BACKEND_PAGINATION_DEFAULT:
assert response.json['data'][x]
assert response.json['data'][x]['name']
assert response.json['data'][x]['definition_order']
assert response.json['data'][x]['enable_environment_macros']
assert response.json['data'][x]['command_line']
assert response.json['data'][x]['timeout']
assert response.json['data'][x]['poller_tag']
assert response.json['data'][x]['reactionner_tag']
assert response.json['data'][x]['enable_environment_macros']
assert response.json['data'][x]['ui'] == True
# Rows 5 by 5 ...
for x in range(0, items_count, 5):
response = self.app.post('/commands_table_data', {
'draw': x / 5,
'start': x,
'length': 5
})
response_value = response.json
print response_value
assert response.json['draw'] == x / 5
assert response.json['recordsTotal'] == items_count
assert response.json['recordsFiltered'] == 5
assert response.json['data']
assert len(response.json['data']) == 5
# Out of scope rows ...
response = self.app.post('/commands_table_data', {
'start': items_count+1,
'length': 5
})
response_value = response.json
print response_value
assert response.json['recordsTotal'] == items_count
assert response.json['recordsFiltered'] == items_count
assert not response.json['data']
# Sorting ...
response = self.app.post('/commands_table_data', {
'start': 0,
'length': 5,
'columns': json.dumps([
{"data":"name","name":"name","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
{"data":"definition_order","name":"definition_order","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
{"data":"command_line","name":"command_line","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
{"data":"module_type","name":"module_type","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
{"data":"enable_environment_macros","name":"enable_environment_macros","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
{"data":"timeout","name":"timeout","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
{"data":"poller_tag","name":"poller_tag","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
{"data":"reactionner_tag","name":"reactionner_tag","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
]),
'order': json.dumps([{"column":0,"dir":"asc"}]) # Ascending
})
response_value = response.json
print response_value
assert response.json['recordsTotal'] == items_count
assert response.json['recordsFiltered'] == 5
assert response.json['data']
assert len(response.json['data']) == 5
response = self.app.post('/commands_table_data', {
'start': 0,
'length': 5,
'columns': json.dumps([
{"data":"name","name":"name","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
{"data":"definition_order","name":"definition_order","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
{"data":"command_line","name":"command_line","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
{"data":"module_type","name":"module_type","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
{"data":"enable_environment_macros","name":"enable_environment_macros","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
{"data":"timeout","name":"timeout","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
{"data":"poller_tag","name":"poller_tag","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
{"data":"reactionner_tag","name":"reactionner_tag","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
]),
'order': json.dumps([{"column":0,"dir":"desc"}]) # Descending !
})
response_value = response.json
print response_value
assert response.json['recordsTotal'] == items_count
assert response.json['recordsFiltered'] == 5
assert response.json['data']
assert len(response.json['data']) == 5
# Searching ...
# Global search ...
response = self.app.post('/commands_table_data', {
'start': 0,
'length': 5,
'columns': json.dumps([
{"data":"name","name":"name","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
{"data":"definition_order","name":"definition_order","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
{"data":"command_line","name":"command_line","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
{"data":"module_type","name":"module_type","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
{"data":"enable_environment_macros","name":"enable_environment_macros","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
{"data":"timeout","name":"timeout","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
{"data":"poller_tag","name":"poller_tag","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
{"data":"reactionner_tag","name":"reactionner_tag","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
]),
'order': json.dumps([{"column":0,"dir":"asc"}]),
# Search 'open' in all columns without regex
'search': json.dumps({"value":"check_ping","regex":False})
})
response_value = response.json
print response_value
# Found items_count records and sent 1
assert response.json['recordsTotal'] == items_count
assert response.json['recordsFiltered'] == 1
assert response.json['data']
assert len(response.json['data']) == 1
response = self.app.post('/commands_table_data', {
'start': 0,
'length': 5,
'columns': json.dumps([
{"data":"name","name":"name","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
{"data":"definition_order","name":"definition_order","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
{"data":"command_line","name":"command_line","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
{"data":"module_type","name":"module_type","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
{"data":"enable_environment_macros","name":"enable_environment_macros","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
{"data":"timeout","name":"timeout","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
{"data":"poller_tag","name":"poller_tag","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
{"data":"reactionner_tag","name":"reactionner_tag","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
]),
'order': json.dumps([{"column":0,"dir":"asc"}]),
# Search 'close' in all columns without regex
'search': json.dumps({"value":"check_test","regex":False})
})
response_value = response.json
print response_value
# Not found!
assert response.json['recordsTotal'] == items_count
assert response.json['recordsFiltered'] == 0
assert not response.json['data']
response = self.app.post('/commands_table_data', {
'start': 0,
'length': 5,
'columns': json.dumps([
{"data":"name","name":"name","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
{"data":"definition_order","name":"definition_order","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
{"data":"command_line","name":"command_line","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
{"data":"module_type","name":"module_type","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
{"data":"enable_environment_macros","name":"enable_environment_macros","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
{"data":"timeout","name":"timeout","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
{"data":"poller_tag","name":"poller_tag","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
{"data":"reactionner_tag","name":"reactionner_tag","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
]),
'order': json.dumps([{"column":0,"dir":"asc"}]),
# Search 'open' in all columns with regex
'search': json.dumps({"value":"check","regex":True})
})
response_value = response.json
print response_value
assert response.json['recordsTotal'] == items_count
assert response.json['recordsFiltered'] == items_count
assert response.json['data']
assert len(response.json['data']) == 5
# Searching ...
# Individual search ...
response = self.app.post('/commands_table_data', {
'start': 0,
'length': 5,
'columns': json.dumps([
# Search 'check_ping' in name column ...
{"data":"name","name":"name","searchable":True,"orderable":True,"search":{"value":"check_ping","regex":False}},
{"data":"definition_order","name":"definition_order","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
{"data":"command_line","name":"command_line","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
{"data":"module_type","name":"module_type","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
{"data":"enable_environment_macros","name":"enable_environment_macros","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
{"data":"timeout","name":"timeout","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
{"data":"poller_tag","name":"poller_tag","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
{"data":"reactionner_tag","name":"reactionner_tag","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
]),
'order': json.dumps([{"column":0,"dir":"asc"}]),
})
response_value = response.json
print response_value
assert response.json['recordsTotal'] == items_count
assert response.json['recordsFiltered'] == 1
assert response.json['data']
assert len(response.json['data']) == 1
response = self.app.post('/commands_table_data', {
'start': 0,
'length': 5,
'columns': json.dumps([
# Search 'op' in status column ...
{"data":"name","name":"name","searchable":True,"orderable":True,"search":{"value":"check","regex":False}},
{"data":"definition_order","name":"definition_order","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
{"data":"command_line","name":"command_line","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
{"data":"module_type","name":"module_type","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
{"data":"enable_environment_macros","name":"enable_environment_macros","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
{"data":"timeout","name":"timeout","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
{"data":"poller_tag","name":"poller_tag","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
{"data":"reactionner_tag","name":"reactionner_tag","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
]),
'order': json.dumps([{"column":0,"dir":"asc"}]),
})
response_value = response.json
print response_value
assert response.json['recordsTotal'] == items_count
assert response.json['recordsFiltered'] == 0
assert not response.json['data']
response = self.app.post('/commands_table_data', {
'start': 0,
'length': 5,
'columns': json.dumps([
# Search 'check' in name column ... regex True
{"data":"name","name":"name","searchable":True,"orderable":True,"search":{"value":"check","regex":True}},
{"data":"definition_order","name":"definition_order","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
{"data":"command_line","name":"command_line","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
{"data":"module_type","name":"module_type","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
{"data":"enable_environment_macros","name":"enable_environment_macros","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
{"data":"timeout","name":"timeout","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
{"data":"poller_tag","name":"poller_tag","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
{"data":"reactionner_tag","name":"reactionner_tag","searchable":True,"orderable":True,"search":{"value":"","regex":False}},
]),
'order': json.dumps([{"column":0,"dir":"asc"}]),
})
response_value = response.json
print response_value
assert response.json['recordsTotal'] == items_count
assert response.json['recordsFiltered'] == items_count
assert response.json['data']
assert len(response.json['data']) == 5
def test_02_hosts(self):
print ''
print 'test hosts table'
global items_count
response = self.app.post('/login', {'username': '******', 'password': '******'})
# Redirected twice: /login -> / -> /dashboard !
redirected_response = response.follow()
redirected_response = redirected_response.follow()
print 'get page /sessions_table'
response = self.app.get('/hosts_table')
response.mustcontain(
'<div id="hosts_table">',
"$('#tbl_host').DataTable( {",
'<th data-name="name" data-type="string">Host name</th>',
'<th data-name="definition_order" data-type="integer">Definition order</th>',
'<th data-name="alias" data-type="string">Host alias</th>',
'<th data-name="display_name" data-type="string">Host display name</th>',
'<th data-name="address" data-type="string">Address</th>',
'<th data-name="check_command" data-type="objectid">Check command</th>',
'<th data-name="check_command_args" data-type="string">Check command arguments</th>',
'<th data-name="active_checks_enabled" data-type="boolean">Active checks enabled</th>',
'<th data-name="passive_checks_enabled" data-type="boolean">Passive checks enabled</th>',
'<th data-name="parents" data-type="list">Parents</th>',
'<th data-name="hostgroups" data-type="list">Hosts groups</th>',
'<th data-name="business_impact" data-type="integer">Business impact</th>'
)
response = self.app.post('/hosts_table_data')
response_value = response.json
print response_value
# Temporary
items_count = response.json['recordsTotal']
# assert response.json['recordsTotal'] == items_count
# assert response.json['recordsFiltered'] == items_count if items_count < BACKEND_PAGINATION_DEFAULT else BACKEND_PAGINATION_DEFAULT
assert response.json['data']
for x in range(0, items_count+0):
# Only if lower than default pagination ...
if x < BACKEND_PAGINATION_DEFAULT:
assert response.json['data'][x]
assert response.json['data'][x]['name']
assert response.json['data'][x]['ui'] == True
class Test4NotAdmin(unittest2.TestCase):
def setUp(self):
print("")
self.dmg = DataManager(backend_endpoint=backend_address)
print('Data manager', self.dmg)
def tearDown(self):
print("")
def test_4_1_load(self):
print("")
print('test load not admin user')
# Initialize and load ... no reset
assert self.dmg.user_login('admin', 'admin')
result = self.dmg.load()
print("Result:", result)
assert result == 0 # No new objects created ...
# Get main realm
realm_all = self.dmg.get_realm({'where': {'name': 'All'}})
# Get main TP
tp_all = self.dmg.get_timeperiod({'where': {'name': '24x7'}})
# Create a non admin user ...
# Create a new user
print('create a user')
data = {
"name": "not_admin",
"alias": "Testing user - not administrator",
"min_business_impact": 0,
"email": "*****@*****.**",
"is_admin": False,
"expert": False,
"can_submit_commands": False,
"host_notifications_enabled": True,
"host_notification_period": tp_all.id,
"host_notification_commands": [],
"host_notification_options": ["d", "u", "r"],
"service_notifications_enabled": True,
"service_notification_period": tp_all.id,
"service_notification_commands": [],
"service_notification_options": ["w", "u", "c", "r"],
"note": "Monitoring template : default",
"definition_order": 100,
"address1": "",
"address2": "",
"address3": "",
"address4": "",
"address5": "",
"address6": "",
"pager": "",
"notificationways": [],
"_realm": realm_all.id
}
new_user_id = self.dmg.add_user(data)
print("New user id: %s" % new_user_id)
# Logout
self.dmg.reset(logout=True)
assert not self.dmg.backend.connected
assert self.dmg.get_logged_user() is None
assert self.dmg.loaded == False
# Login as not_admin created user
assert self.dmg.user_login('not_admin', 'NOPASSWORDSET', load=False)
assert self.dmg.backend.connected
assert self.dmg.get_logged_user().get_username() == 'not_admin'
print('logged in as not_admin')
# Initialize and load ...
result = self.dmg.load()
print("Result:", result)
print("Objects count:", self.dmg.get_objects_count())
# assert result == 0 # Only the newly created user, so no new objects loaded
# assert self.dmg.get_objects_count() == 1 # not_admin user
# Initialize and load ... with reset
result = self.dmg.load(reset=True)
print("Result:", result)
print("Objects count:", self.dmg.get_objects_count())
# assert result == 3 # not_admin user + test_service + relation
# assert self.dmg.get_objects_count() == 3 # not_admin user + test_service + relation
# Not admin user can see only its own data, ...
# -------------------------------------------
# Do not check the length because the backend contains more elements than needed ...
# dump_backend(not_admin_user=True, test_service=True)
# Get users
items = self.dmg.get_users()
print("Users:", items)
# assert len(items) == 1
# 1 user only ...
# Get commands
items = self.dmg.get_commands()
print("Commands:", items)
# assert len(items) == 1
# Get realms
items = self.dmg.get_realms()
print("Commands:", items)
# assert len(items) == 1
# Get timeperiods
items = self.dmg.get_timeperiods()
print("Commands:", items)
# assert len(items) == 1
# Get hosts
items = self.dmg.get_hosts()
print("Hosts:", items)
# assert len(items) == 1
# Get services
items = self.dmg.get_services()
print("Services:", items)
# assert len(items) == 1
result = self.dmg.delete_user(new_user_id)
# Cannot delete the current logged-in user
assert not result
# Logout
self.dmg.reset(logout=True)
assert not self.dmg.backend.connected
assert self.dmg.get_logged_user() is None
assert self.dmg.loaded == False
# Login as admin
assert self.dmg.user_login('admin', 'admin', load=False)
assert self.dmg.backend.connected
assert self.dmg.get_logged_user().get_username() == 'admin'
result = self.dmg.delete_user(new_user_id)
# Can delete the former logged-in user
assert result
def setUp(self):
print ""
self.dmg = DataManager(backend_endpoint=backend_address)
print 'Data manager', self.dmg
class test_4_not_admin(unittest2.TestCase):
def setUp(self):
print ""
self.dmg = DataManager(backend_endpoint=backend_address)
print 'Data manager', self.dmg
def tearDown(self):
print ""
def test_4_1_load(self):
print ''
print 'test load not admin user'
# Initialize and load ... no reset
assert self.dmg.user_login('admin', 'admin')
result = self.dmg.load()
print "Result:", result
assert result == 0 # No new objects created ...
# Create a non admin user ...
# TODO
# ***************************************
return
# Logout
self.dmg.reset(logout=True)
assert not self.dmg.backend.connected
assert self.dmg.get_logged_user() == None
assert self.dmg.loaded == False
# Login as not_admin created user
assert self.dmg.user_login('not_admin', 'NOPASSWORDSET', load=False)
assert self.dmg.backend.authenticated
assert self.dmg.get_logged_user().get_username() == 'not_admin'
print 'logged in as not_admin'
# Initialize and load ...
result = self.dmg.load()
print "Result:", result
print "Objects count:", self.dmg.get_objects_count()
assert result == 2 # test_service + relation
assert self.dmg.get_objects_count() == 3 # not_admin user + test_service + relation
# Initialize and load ... with reset
result = self.dmg.load(reset=True)
print "Result:", result
print "Objects count:", self.dmg.get_objects_count()
assert result == 3 # not_admin user + test_service + relation
assert self.dmg.get_objects_count() == 3 # not_admin user + test_service + relation
# Not admin user can see only its own data, ...
# -------------------------------------------
# Do not check the length because the backend contains more elements than needed ...
dump_backend(not_admin_user=True, test_service=True)
# Get users
items = self.dmg.get_users()
assert len(items) == 1
# 1 user only ...
# Get services
items = self.dmg.get_userservices()
assert len(items) == 1
# Get users / services relations
items = self.dmg.get_userservice_users()
assert len(items) == 1
# Get service cdrs
items = self.dmg.get_userservice_cdrs()
assert len(items) == 0
# Get sessions
items = self.dmg.get_sessions()
assert len(items) == 0
def test_2_1_creation_load(self):
print ''
print 'test creation'
datamanager = DataManager()
assert datamanager.backend
assert datamanager.loaded == False
assert datamanager.get_logged_user() == None
print 'Data manager', datamanager
# Initialize and load fail ...
result = datamanager.load()
# Refused because no backend logged-in user
assert not result
# Login error
assert not datamanager.user_login('admin', 'fake')
print datamanager.connection_message
assert datamanager.connection_message == 'Backend is not available'
print datamanager.logged_in_user
assert not datamanager.logged_in_user
# Create new datamanager - do not use default backend address
datamanager = DataManager(backend_endpoint=backend_address)
assert datamanager.backend
assert datamanager.loaded == False
assert datamanager.get_logged_user() == None
print 'Data manager', datamanager
# Initialize and load fail ...
result = datamanager.load()
# Refused because no backend logged-in user
assert not result
# Login error
assert not datamanager.user_login('admin', 'fake')
print datamanager.connection_message
assert datamanager.connection_message == 'Backend connection refused...'
print datamanager.logged_in_user
assert not datamanager.logged_in_user
# User login but do not load yet
assert datamanager.user_login('admin', 'admin', load=False)
assert datamanager.connection_message == 'Connection successful'
print datamanager.logged_in_user
assert datamanager.logged_in_user
assert datamanager.get_logged_user() != None
assert datamanager.get_logged_user().get_username() == 'admin'
assert datamanager.get_logged_user().authenticated
user_token = datamanager.get_logged_user().get_token()
datamanager.reset()
# Still logged-in...
assert datamanager.logged_in_user
assert datamanager.get_logged_user() != None
datamanager.reset(logout=True)
# Logged-out...
assert not datamanager.logged_in_user
assert datamanager.get_logged_user() == None
# User login with an authentication token
assert datamanager.user_login(user_token)
# assert datamanager.connection_message == 'Backend connected'
# When user authentication is made thanks to a token, DM is not loaded ... it is assumed that load already occured!
assert datamanager.user_login('admin', 'admin', load=False)
user_token = datamanager.get_logged_user().get_token()
assert datamanager.user_login(user_token)
assert datamanager.connection_message == 'Backend connected'
assert datamanager.logged_in_user
assert datamanager.get_logged_user() != None
assert datamanager.get_logged_user().get_username() == 'admin'
assert datamanager.get_logged_user().authenticated
def test_2_1_creation_load(self):
print('------------------------------')
print('test creation')
datamanager = DataManager()
assert datamanager.backend
assert datamanager.loaded == False
assert datamanager.get_logged_user() is None
print('Data manager', datamanager)
# Got known managed elements classes
self.assertEqual(len(datamanager.known_classes), 19)
# Initialize and load fail ...
print('DM load failed')
result = datamanager.load()
# Refused because no backend logged-in user
assert not result
# Login error
print('DM logging bad password')
assert not datamanager.user_login('admin', 'fake')
print(datamanager.connection_message)
assert datamanager.connection_message == 'Backend connection refused...'
print(datamanager.logged_in_user)
assert not datamanager.logged_in_user
# Create new datamanager - do not use default backend address
print('DM initialization')
datamanager = DataManager(backend_endpoint=backend_address)
assert datamanager.backend
assert datamanager.loaded == False
assert datamanager.get_logged_user() is None
print('Data manager', datamanager)
# Initialize and load fail ...
print('DM load fail')
result = datamanager.load()
# Refused because no backend logged-in user
assert not result
# Login error
print('DM logging bad password')
assert not datamanager.user_login('admin', 'fake')
print(datamanager.connection_message)
assert datamanager.connection_message == 'Backend connection refused...'
print(datamanager.logged_in_user)
assert not datamanager.logged_in_user
# User login but do not load yet
print('DM login ok')
assert datamanager.user_login('admin', 'admin', load=False)
assert datamanager.connection_message == 'Connection successful'
print("Logged user: %s" % datamanager.logged_in_user)
assert datamanager.logged_in_user
assert datamanager.get_logged_user() is not None
assert datamanager.get_logged_user().id is not None
assert datamanager.get_logged_user().get_username() == 'admin'
assert datamanager.get_logged_user().authenticated
user_token = datamanager.get_logged_user().token
print(User._cache[datamanager.get_logged_user().id].__dict__)
print('DM reset')
datamanager.reset()
# Still logged-in...
assert datamanager.logged_in_user
assert datamanager.get_logged_user() is not None
print('DM reset - logout')
datamanager.reset(logout=True)
# Logged-out...
assert not datamanager.logged_in_user
assert datamanager.get_logged_user() is None
# User login with an authentication token
print('DM login - token')
assert datamanager.user_login(user_token)
# When user authentication is made thanks to a token, DM is not loaded ... it is assumed that load already occured!
print('DM login')
assert datamanager.user_login('admin', 'admin', load=False)
print(datamanager.get_logged_user())
print(datamanager.get_logged_user().token)
user_token = datamanager.get_logged_user().token
assert datamanager.user_login(user_token)
assert datamanager.connection_message == 'Connection successful'
assert datamanager.logged_in_user
assert datamanager.get_logged_user() is not None
assert datamanager.get_logged_user().id is not None
assert datamanager.get_logged_user().get_username() == 'admin'
assert datamanager.get_logged_user().authenticated
class TestLiveState(unittest2.TestCase):
def setUp(self):
print("")
print("setting up ...")
self.dmg = DataManager(backend_endpoint=backend_address)
print('Data manager', self.dmg)
# Initialize and do not load
assert self.dmg.user_login('admin', 'admin', load=False)
def tearDown(self):
print("")
print("tearing down ...")
# Logout
self.dmg.reset(logout=True)
def test_get(self):
print("")
print('test get livestate')
count = 5
# Get livestate
print('Get livestate - 1')
search = {'page': 1, 'max_results': count}
objs = self.dmg.get_livestate(search=search)
self.assertEqual(len(objs), count) # Backend pagination limit ...
for obj in objs:
print("Got: ", obj)
assert obj.id
self.assertIsInstance(obj.host, Host) # Must be an object
self.assertIsInstance(obj.host.check_command, Command)
self.assertIsInstance(obj.host.check_period, TimePeriod)
if obj.type == 'service':
self.assertIsInstance(obj.service,
Service) # Must be an object
self.assertIsInstance(obj.service.check_command, Command)
self.assertIsInstance(obj.service.check_period, TimePeriod)
else:
self.assertEqual(obj.service, "service") # No linked object
livestate = self.dmg.get_livestate({'where': {'_id': obj.id}})
livestate = livestate[0]
print("Got: %s" % livestate)
# Get livestate (bis)
print('Get livestate - 2')
search = {'page': 1, 'max_results': count}
objs = self.dmg.get_livestate(search=search)
self.assertEqual(len(objs), count) # Backend pagination limit ...
lv = LiveState()
for obj in objs:
print("Got: ", obj)
lv = LiveState(obj) # An object from another object
print("Got: %s" % lv)
# Get livestate (ter)
print('Get livestate - 3')
search = {'page': 1, 'max_results': count}
result = self.dmg.backend.get('livestate', search, all_elements=False)
for item in result:
# Create a new object
lv = LiveState(item)
print("Got: %s" % lv)
class Test6Relations(unittest2.TestCase):
def setUp(self):
print("")
print("setting up ...")
self.dmg = DataManager(backend_endpoint=backend_address)
print('Data manager', self.dmg)
# Initialize and do not load
assert self.dmg.user_login('admin', 'admin', load=False)
def tearDown(self):
print("")
print("tearing down ...")
# Logout
self.dmg.reset(logout=True)
def test_01_host_command(self):
print("--- test Item")
# Get main realm
self.dmg.get_realm({'where': {'name': 'All'}})
# Get main TP
self.dmg.get_timeperiod({'where': {'name': '24x7'}})
# Get host
host = self.dmg.get_host({'where': {'name': 'webui'}})
print(host.__dict__)
print(host.check_period)
assert isinstance(host.check_command, Command)
assert host.check_command
def test_02_host_service(self):
print("--- test Item")
# Get main realm
self.dmg.get_realm({'where': {'name': 'All'}})
# Get main TP
self.dmg.get_timeperiod({'where': {'name': '24x7'}})
# Get host
host = self.dmg.get_host({'where': {'name': 'webui'}})
print("Host: ", host.__dict__)
# Get services of this host
service = self.dmg.get_service(
{'where': {
'name': 'Shinken2-broker',
'host_name': host.id
}})
print("Services: ", service)
def setUp(self):
print("")
self.dmg = DataManager(backend_endpoint=backend_address)
print('Data manager', self.dmg)
class Test5Basic(unittest2.TestCase):
def setUp(self):
print("")
self.dmg = DataManager(backend_endpoint=backend_address)
print('Data manager', self.dmg)
# Initialize and load ... no reset
assert self.dmg.user_login('admin', 'admin')
result = self.dmg.load()
def tearDown(self):
print("")
# Logout
self.dmg.reset(logout=True)
assert not self.dmg.backend.connected
assert self.dmg.get_logged_user() is None
assert self.dmg.loaded == False
def test_5_1_get_simple(self):
print("")
print('test objects get simple objects')
# Get realms
items = self.dmg.get_realms()
for item in items:
print("Got: ", item)
assert item.id
item.get_html_state()
self.assertEqual(len(items), 5)
# Get commands
items = self.dmg.get_commands()
for item in items:
print("Got: ", item)
assert item.id
icon_status = item.get_html_state()
self.assertEqual(len(items), 50) # Backend pagination limit ...
# Get timeperiods
items = self.dmg.get_timeperiods()
for item in items:
print("Got: ", item)
assert item.id
item.get_html_state()
self.assertEqual(len(items), 4)
def test_5_1_get_linked(self):
print("")
print('test objects get linked')
# Get hosts
items = self.dmg.get_hosts()
for item in items:
print("Got: ", item)
assert item.id
self.assertIsInstance(item.check_command,
Command) # Must be an object
self.assertIsInstance(item.check_period,
TimePeriod) # Must be an object
self.assertEqual(len(items), 13)
# Get services
items = self.dmg.get_services()
for item in items:
print("Got: ", item)
assert item.id
self.assertIsInstance(item.check_command,
Command) # Must be an object
self.assertIsInstance(item.check_period,
TimePeriod) # Must be an object
self.assertEqual(len(items), 50) # Backend pagination limit ...
# Get livestate
items = self.dmg.get_livestate()
for item in items:
print("Got: ", item)
assert item.id
self.assertIsInstance(item.host, Host) # Must be an object
if item.type == 'service':
self.assertIsInstance(item.service,
Service) # Must be an object
else:
self.assertEqual(item.service, "service") # No linked object
livestate = self.dmg.get_livestate({'where': {'_id': item.id}})
livestate = livestate[0]
print("Got: %s" % livestate)
self.assertEqual(len(items), 50) # Backend pagination limit ...
def test_5_1_get_linked_groups(self):
print("")
print('test objects get self linked')
# Get hostgroups
items = self.dmg.get_hostgroups()
for item in items:
print("Got: ", item)
assert item.id
if item.level != 0:
self.assertIsInstance(item.parent,
HostGroup) # Must be an object
self.assertEqual(len(items), 9)
# Get servicegroups
items = self.dmg.get_servicegroups()
for item in items:
print("Got: ", item)
assert item.id
if item.level != 0:
self.assertIsInstance(item.parent,
ServiceGroup) # Must be an object
self.assertEqual(len(items), 6)
@unittest2.skip("Skipped because not very useful and often change :/")
def test_5_2_total_count(self):
print("")
print('test objects count')
# Get each object type count
self.assertEqual(self.dmg.count_objects('realm'), 5)
self.assertEqual(self.dmg.count_objects('command'), 103)
self.assertEqual(self.dmg.count_objects('timeperiod'), 4)
self.assertEqual(self.dmg.count_objects('user'), 5)
self.assertEqual(self.dmg.count_objects('host'), 13)
self.assertEqual(self.dmg.count_objects('service'), 94)
self.assertEqual(self.dmg.count_objects('livestate'), 13 + 94)
self.assertEqual(self.dmg.count_objects('servicegroup'), 6)
self.assertEqual(self.dmg.count_objects('hostgroup'), 9)
# self.assertEqual(self.dmg.count_objects('livesynthesis'), 1)
# Use global method
self.assertEqual(
self.dmg.get_objects_count(object_type=None,
refresh=True,
log=True), 350)
# No refresh so get current cached objects count
self.assertEqual(self.dmg.get_objects_count('realm'), 5)
self.assertEqual(self.dmg.get_objects_count('command'), 50)
self.assertEqual(self.dmg.get_objects_count('timeperiod'), 4)
self.assertEqual(self.dmg.get_objects_count('user'), 5)
# Not loaded on login in the data manager ... so 0
self.assertEqual(self.dmg.get_objects_count('host'), 0)
self.assertEqual(self.dmg.get_objects_count('service'), 0)
self.assertEqual(self.dmg.get_objects_count('livestate'), 0)
# self.assertEqual(self.dmg.get_objects_count('livesynthesis'), 1) # Not loaded on login ...
# With refresh to get total backend objects count
self.assertEqual(self.dmg.get_objects_count('realm', refresh=True), 5)
self.assertEqual(self.dmg.get_objects_count('command', refresh=True),
103)
self.assertEqual(
self.dmg.get_objects_count('timeperiod', refresh=True), 4)
self.assertEqual(self.dmg.get_objects_count('user', refresh=True), 5)
self.assertEqual(self.dmg.get_objects_count('host', refresh=True), 13)
self.assertEqual(self.dmg.get_objects_count('service', refresh=True),
94)
self.assertEqual(self.dmg.get_objects_count('livestate', refresh=True),
13 + 94)
# self.assertEqual(self.dmg.get_objects_count('livesynthesis', refresh=True), 1)
def test_5_3_livesynthesis(self):
print("")
print('test livesynthesis')
default_ls = {
'hosts_synthesis': {
'nb_elts': 0,
'business_impact': 0,
'warning_threshold': 2.0,
'global_warning_threshold': 2.0,
'critical_threshold': 5.0,
'global_critical_threshold': 5.0,
'nb_up': 0,
'pct_up': 100.0,
'nb_up_hard': 0,
'nb_up_soft': 0,
'nb_down': 0,
'pct_down': 0.0,
'nb_down_hard': 0,
'nb_down_soft': 0,
'nb_unreachable': 0,
'pct_unreachable': 0.0,
'nb_unreachable_hard': 0,
'nb_unreachable_soft': 0,
'nb_problems': 0,
'pct_problems': 0.0,
'nb_flapping': 0,
'pct_flapping': 0.0,
'nb_acknowledged': 0,
'pct_acknowledged': 0.0,
'nb_in_downtime': 0,
'pct_in_downtime': 0.0,
},
'services_synthesis': {
'nb_elts': 0,
'business_impact': 0,
'warning_threshold': 2.0,
'global_warning_threshold': 2.0,
'critical_threshold': 5.0,
'global_critical_threshold': 5.0,
'nb_ok': 0,
'pct_ok': 100.0,
'nb_ok_hard': 0,
'nb_ok_soft': 0,
'nb_warning': 0,
'pct_warning': 0.0,
'nb_warning_hard': 0,
'nb_warning_soft': 0,
'nb_critical': 0,
'pct_critical': 0.0,
'nb_critical_hard': 0,
'nb_critical_soft': 0,
'nb_unknown': 0,
'pct_unknown': 0.0,
'nb_unknown_hard': 0,
'nb_unknown_soft': 0,
'nb_problems': 0,
'pct_problems': 0.0,
'nb_flapping': 0,
'pct_flapping': 0.0,
'nb_acknowledged': 0,
'pct_acknowledged': 0.0,
'nb_in_downtime': 0,
'pct_in_downtime': 0.0
}
}
# Get livesynthesis
self.dmg.get_livesynthesis()