def setUp(self):
self.settings = get_appsettings('configs/development.virtuoso.ini',
name='main')
self.request = testing.DummyRequest()
self.request.session['upload_directory'] = os.path.join(
os.path.dirname(__file__), "..", "test-data")
self.temp_directory = tempfile.mkdtemp()
self.it = InterfaceTPS(self.settings, self.request)
self.it.empty()
def setUp(self):
"""Set up the settings and session"""
self.settings = get_appsettings('configs/test.virtuoso.ini',
name='main')
self.request = testing.DummyRequest()
self.request.session['username'] = '******'
self.request.session['group'] = 'base'
self.request.session['admin'] = False
self.request.session['blocked'] = True
self.tps = InterfaceTPS(self.settings, self.request)
class tripleStoreExplorerTests(unittest.TestCase):
def setUp( self ):
self.settings = get_appsettings('configs/development.virtuoso.ini', name='main')
self.request = testing.DummyRequest()
self.request.session['upload_directory'] = os.path.join( os.path.dirname( __file__ ), "..", "test-data")
self.temp_directory = tempfile.mkdtemp()
self.it = InterfaceTPS(self.settings,self.request)
self.it.empty()
def tearDown( self ):
shutil.rmtree( self.temp_directory )
def test_load_data(self):
self.it.load_test1()
def setUp(self):
"""Set up the configuration to access the triplestore
Use the config file test.virtuoso.ini to not interfere with
production data
"""
self.settings = get_appsettings('configs/test.virtuoso.ini', name='main')
self.settings['askomics.upload_user_data_method'] = 'insert'
self.request = testing.DummyRequest()
self.config = testing.setUp(request=self.request)
self.config.add_route('load_data_into_graph', '/load_data_into_graph')
self.config.scan()
self.request.session['username'] = '******'
self.request.session['blocked'] = False
self.request.session['group'] = 'base'
self.request.session['graph'] = 'urn:sparql:test_askomics:jdoe'
self.request.host_url = 'http://localhost:6543'
self.request.json_body = {}
# Create the user dir if not exist
self.temp_directory = self.settings['askomics.files_dir'] + '/upload/' + self.request.session['username']
if not os.path.isdir(self.temp_directory):
os.makedirs(self.temp_directory)
# Set the upload dir
self.request.session['upload_directory'] = self.temp_directory
# Copy files if directory is empty
if not os.listdir(self.temp_directory):
files = ['people.tsv', 'instruments.tsv', 'play_instrument.tsv', 'transcript.tsv', 'qtl.tsv', 'small_data.gff3', 'turtle_data.ttl', 'bed_example.bed']
for file in files:
src = os.path.join(os.path.dirname(__file__), "..", "test-data") + '/' + file
dst = self.request.session['upload_directory'] + '/' + file
copyfile(src, dst)
self.tps = InterfaceTPS(self.settings, self.request)
self.askview = AskView(self.request)
self.askview.settings = self.settings
em = EndpointManager(self.settings, self.request.session)
em.drop()
class tripleStoreExplorerTests(unittest.TestCase):
def setUp(self):
self.settings = get_appsettings('configs/development.virtuoso.ini',
name='main')
self.request = testing.DummyRequest()
self.request.session['upload_directory'] = os.path.join(
os.path.dirname(__file__), "..", "test-data")
self.temp_directory = tempfile.mkdtemp()
self.it = InterfaceTPS(self.settings, self.request)
self.it.empty()
def tearDown(self):
shutil.rmtree(self.temp_directory)
def test_load_data(self):
self.it.load_test1()
def setUp( self ):
self.settings = get_appsettings('configs/development.virtuoso.ini', name='main')
self.request = testing.DummyRequest()
self.request.session['upload_directory'] = os.path.join( os.path.dirname( __file__ ), "..", "test-data")
self.temp_directory = tempfile.mkdtemp()
self.it = InterfaceTPS(self.settings,self.request)
self.it.empty()
self.it.load_test1()
def setUp(self):
self.settings = get_appsettings('configs/development.virtuoso.ini',
name='main')
self.request = testing.DummyRequest()
self.config = testing.setUp(request=self.request)
self.config.add_route('load_data_into_graph', '/load_data_into_graph')
self.config.scan()
self.request.session['upload_directory'] = os.path.join(
os.path.dirname(__file__), "..", "test-data")
self.temp_directory = tempfile.mkdtemp()
self.it = InterfaceTPS(self.settings, self.request)
self.askview = AskView(self.request)
self.askview.settings = self.settings
self.timestamp = str(time.time())
def setUp(self):
"""Set up the settings and session"""
self.settings = get_appsettings('configs/test.virtuoso.ini', name='main')
self.request = testing.DummyRequest()
self.request.session['username'] = '******'
self.request.session['group'] = 'base'
self.request.session['admin'] = False
self.request.session['blocked'] = True
self.tps = InterfaceTPS(self.settings, self.request)
def setUp(self):
self.temp_directory = tempfile.mkdtemp()
self.settings = get_appsettings('configs/development.ini', name='main')
self.request = testing.DummyRequest()
self.request.session['upload_directory'] = os.path.join(
os.path.dirname(__file__), "..", "test-data")
self.temp_directory = tempfile.mkdtemp()
self.it = InterfaceTPS(self.settings, self.request)
self.it.empty()
self.it.load_test1()
variates = ['?Personne1', '?label1', '?Age1', '?ID1', '?Sexe1']
constraintesRelations = [[[
'?URIPersonne1 rdf:type <http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#Personne>',
'?URIPersonne1 rdfs:label ?Personne1',
'?URIPersonne1 <http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#label> ?label1',
'<http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#label> rdfs:domain <http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#Personne>',
'<http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#label> rdfs:range <http://www.w3.org/2001/XMLSchema#string>',
'<http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#label> rdf:type owl:DatatypeProperty',
'?URIPersonne1 <http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#Age> ?Age1',
'<http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#Age> rdfs:domain <http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#Personne>',
'<http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#Age> rdfs:range <http://www.w3.org/2001/XMLSchema#decimal>',
'<http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#Age> rdf:type owl:DatatypeProperty',
'?URIPersonne1 <http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#ID> ?ID1',
'<http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#ID> rdfs:domain <http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#Personne>',
'<http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#ID> rdfs:range <http://www.w3.org/2001/XMLSchema#string>',
'<http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#ID> rdf:type owl:DatatypeProperty',
'?URIPersonne1 <http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#Sexe> ?Sexe1'
], ''], '']
limit = 10
tse = TripleStoreExplorer(self.settings, self.request.session)
self.results, self.query = tse.build_sparql_query_from_json(
variates, constraintesRelations, limit, True)
results, query = tse.build_sparql_query_from_json(
variates, constraintesRelations, limit, False)
assert len(results) == 0
def setUp( self ):
self.settings = get_appsettings('configs/development.virtuoso.ini', name='main')
self.request = testing.DummyRequest()
self.config = testing.setUp(request=self.request)
self.config.add_route('load_data_into_graph', '/load_data_into_graph')
self.config.scan()
self.request.session['upload_directory'] = os.path.join( os.path.dirname( __file__ ), "..", "test-data")
self.temp_directory = tempfile.mkdtemp()
self.it = InterfaceTPS(self.settings,self.request)
self.askview = AskView(self.request)
self.askview.settings = self.settings
self.timestamp = str(time.time())
class SecurityTests(unittest.TestCase):
"""Test for the Security class"""
def setUp(self):
"""Set up the settings and session"""
self.settings = get_appsettings('configs/test.virtuoso.ini',
name='main')
self.request = testing.DummyRequest()
self.request.session['username'] = '******'
self.request.session['group'] = 'base'
self.request.session['admin'] = False
self.request.session['blocked'] = True
self.tps = InterfaceTPS(self.settings, self.request)
def test_get_sha256_pw(self):
"""Test get_sha256_pw"""
security = Security(self.settings, self.request.session, 'jdoe',
'*****@*****.**', 'iamjohndoe', 'iamjohndoe')
assert len(security.get_sha256_pw(
)) == 64 # We cant predict the string cause there is random for salt
def test_check_email(self):
"""Test for check_email"""
# Test if good mail return True
security = Security(self.settings, self.request.session, 'jdoe',
'*****@*****.**', 'iamjohndoe', 'iamjohndoe')
assert security.check_email()
# Test if wrong email return False
security = Security(self.settings, self.request.session, 'jdoe',
'wrong_email', 'iamjohndoe', 'iamjohndoe')
assert not security.check_email()
def test_check_passwords(self):
"""Test for check_passwords"""
# Test if identical passwords return True
security = Security(self.settings, self.request.session, 'jdoe',
'*****@*****.**', 'iamjohndoe', 'iamjohndoe')
assert security.check_passwords()
# Test if different passwords return False
security = Security(self.settings, self.request.session, 'jdoe',
'*****@*****.**', 'iamjohndoe',
'second_wrong_password')
assert not security.check_passwords()
def test_check_password_length(self):
"""Test for check_password_length"""
# Test if long passwords return True
security = Security(self.settings, self.request.session, 'jdoe',
'*****@*****.**', 'iamjohndoe', 'iamjohndoe')
assert security.check_password_length()
# Test if short passwords return False
security = Security(self.settings, self.request.session, 'jdoe',
'*****@*****.**', 'a', 'a')
# assert not security.check_password_length() #FIXME: not working because max lenght is 1
def test_check_username_in_database(self):
"""test check_username_in_database
Insert jdoe and test if jdoe is in database, then test
jsmith is not in database
"""
self.tps.clean_up()
self.tps.add_jdoe_in_users()
security = Security(self.settings, self.request.session, 'jdoe',
'*****@*****.**', 'iamjohndoe', 'iamjohndoe')
# test with same username
assert security.check_username_in_database()
security = Security(self.settings, self.request.session, 'jsmith',
'*****@*****.**', 'iamjohnsmith',
'iamjohnsmith')
# test with a different username
assert not security.check_username_in_database()
def test_check_email_in_database(self):
"""test check_username_in_database
Insert jdoe and test if jdoe is in database, then test
jsmith is not in database
"""
self.tps.clean_up()
self.tps.add_jdoe_in_users()
security = Security(self.settings, self.request.session, 'jdoe',
'*****@*****.**', 'iamjohndoe', 'iamjohndoe')
# test with same username
assert security.check_email_in_database()
security = Security(self.settings, self.request.session, 'jsmith',
'*****@*****.**', 'iamjohnsmith',
'iamjohnsmith')
# test with a different username
assert not security.check_email_in_database()
def test_set_username_by_email(self):
self.tps.clean_up()
self.tps.add_jdoe_in_users()
security = Security(self.settings, self.request.session, 'jdoe',
'*****@*****.**', 'iamjohndoe', 'iamjohndoe')
security.set_username_by_email()
def test_get_owner_of_apikey(self):
self.tps.clean_up()
self.tps.add_jdoe_in_users()
security = Security(self.settings, self.request.session, 'jdoe',
'*****@*****.**', 'iamjohndoe', 'iamjohndoe')
security.get_owner_of_apikey("test")
def test_ckeck_key_belong_user(self):
self.tps.clean_up()
self.tps.add_jdoe_in_users()
security = Security(self.settings, self.request.session, 'jdoe',
'*****@*****.**', 'iamjohndoe', 'iamjohndoe')
security.ckeck_key_belong_user("test")
def test_add_del_apikey(self):
self.tps.clean_up()
self.tps.add_jdoe_in_users()
security = Security(self.settings, self.request.session, 'jdoe',
'*****@*****.**', 'iamjohndoe', 'iamjohndoe')
security.delete_apikey("test")
security.add_apikey("test")
security.delete_apikey("test")
def test_add_del_galaxy(self):
self.tps.clean_up()
self.tps.add_jdoe_in_users()
security = Security(self.settings, self.request.session, 'jdoe',
'*****@*****.**', 'iamjohndoe', 'iamjohndoe')
try:
security.add_galaxy("http://test", "test")
assert False
except Exception as e:
assert True
security.get_galaxy_infos()
security.check_galaxy()
security.delete_galaxy()
def test_check_email_password(self):
"""Test check_email_password
Insert jdoe and check the password
"""
self.tps.clean_up()
self.tps.add_jdoe_in_users()
security = Security(self.settings, self.request.session, 'jdoe',
'*****@*****.**', 'iamjohndoe', 'iamjohndoe')
# try with the good password
assert security.check_email_password()
security = Security(self.settings, self.request.session, 'jdoe',
'*****@*****.**', 'wrong_password',
'wrong_password')
# Try with a wrong password
assert not security.check_email_password()
def test_check_username_password(self):
"""Test check_username_password
Insert jdoe and check the password
"""
self.tps.clean_up()
self.tps.add_jdoe_in_users()
security = Security(self.settings, self.request.session, 'jdoe',
'*****@*****.**', 'iamjohndoe', 'iamjohndoe')
# try with the good password
assert security.check_username_password()
security = Security(self.settings, self.request.session, 'jdoe',
'*****@*****.**', 'wrong_password',
'wrong_password')
# Try with a wrong password
assert not security.check_username_password()
def test_get_number_of_users(self):
"""Test get_number_of_users
test the method with 0, 1 and 2 users
"""
self.tps.clean_up()
security = Security(self.settings, self.request.session, '', '', '',
'')
assert security.get_number_of_users() == 0
self.tps.add_jdoe_in_users()
assert security.get_number_of_users() == 1
self.tps.add_jsmith_in_users()
assert security.get_number_of_users() == 2
def test_persist_user(self):
"""Test persist_user
Insert a user and test if get_number_of_user return 1
"""
self.tps.clean_up()
security = Security(self.settings, self.request.session, 'jdoe',
'*****@*****.**', 'iamjohndoe', 'iamjohndoe')
assert security.get_number_of_users() == 0
security.persist_user('http://localhost')
assert security.get_number_of_users() == 1
#assert security.
security = Security(self.settings, self.request.session, 'jdoe2',
'*****@*****.**', 'iamjohndoe', 'iamjohndoe')
security.persist_user('http://localhost')
assert security.get_number_of_users() == 2
def test_send_mails(self):
"""Test send_mails"""
#TODO: how to test mail ?
pass
def test_create_user_graph(self):
"""Test create_user_graph
create the graph, and then test the presence of the triple
"""
self.tps.clean_up()
security = Security(self.settings, self.request.session, 'jdoe',
'*****@*****.**', 'iamjohndoe', 'iamjohndoe')
security.create_user_graph()
assert self.tps.test_triple_presence(
'urn:sparql:test_askomics',
'<urn:sparql:test_askomics:jdoe> rdfg:subGraphOf <urn:sparql:test_askomics>'
)
assert not self.tps.test_triple_presence(
'urn:sparql:test_askomics',
'<urn:sparql:test_askomics:jsmith> rdfg:subGraphOf <urn:sparql:test_askomics>'
)
def test_get_admins_emails(self):
"""Test get_admins_emails
Test the finction with nobody, 1, 2 non admin users, and with 1 and 2 admins users
"""
self.tps.clean_up()
security = Security(self.settings, self.request.session, '', '', '',
'')
assert security.get_admins_emails() == []
self.tps.add_jdoe_in_users()
assert security.get_admins_emails() == []
self.tps.add_jsmith_in_users()
assert security.get_admins_emails() == []
self.tps.add_admin_in_users()
assert security.get_admins_emails() == ['*****@*****.**']
self.tps.add_another_admin_in_users()
res_emails = security.get_admins_emails()
assert len(res_emails) == 2
assert '*****@*****.**' in res_emails
assert '*****@*****.**' in res_emails
def test_set_admin(self):
"""Test set_admin"""
self.tps.clean_up()
security = Security(self.settings, self.request.session, 'jdoe', '',
'', '')
assert not self.request.session['admin']
security.set_admin(True)
assert self.request.session['admin']
def test_set_galaxy(self):
"""Test set_admin"""
self.tps.clean_up()
security = Security(self.settings, self.request.session, 'jdoe', '',
'', '')
security.set_galaxy(True)
assert self.request.session['galaxy']
def test_set_blocked(self):
"""Test set_blocked"""
self.tps.clean_up()
security = Security(self.settings, self.request.session, 'jdoe', '',
'', '')
assert self.request.session['blocked']
security.set_blocked(False)
assert not self.request.session['blocked']
def test_get_admin_blocked_by_usrnm(self):
"""Test get_admin_blocked_by_username"""
self.tps.clean_up()
self.tps.add_jdoe_in_users()
self.tps.add_admin_in_users()
security = Security(self.settings, self.request.session, 'jdoe',
'*****@*****.**', 'iamjohndoe', 'iamjohndoe')
assert security.get_admin_blocked_by_username() == {
'blocked': False,
'admin': False
}
security = Security(self.settings, self.request.session, 'admin',
'*****@*****.**', 'iamadmin', 'iamadmin')
assert security.get_admin_blocked_by_username() == {
'blocked': False,
'admin': True
}
def test_get_admin_blocked_by_email(self):
"""Test get_admin_blocked_by_email"""
self.tps.clean_up()
self.tps.add_jdoe_in_users()
self.tps.add_admin_in_users()
security = Security(self.settings, self.request.session, 'jdoe',
'*****@*****.**', 'iamjohndoe', 'iamjohndoe')
assert security.get_admin_blocked_by_email() == {
'blocked': False,
'admin': False
}
security = Security(self.settings, self.request.session, 'admin',
'*****@*****.**', 'iamadmin', 'iamadmin')
assert security.get_admin_blocked_by_email() == {
'blocked': False,
'admin': True
}
def test_log_user(self):
"""Test log_user"""
self.tps.clean_up()
security = Security(self.settings, self.request.session, 'testlog',
'*****@*****.**', 'testlog', 'testlog')
security.log_user(self.request)
assert self.request.session['username'] == 'testlog'
assert not self.request.session['admin']
assert self.request.session['blocked']
assert self.request.session[
'graph'] == 'urn:sparql:test_askomics:testlog'
def test_update_email(self):
"""Test update_mail"""
self.tps.clean_up()
self.tps.add_jdoe_in_users()
security = Security(self.settings, self.request.session, 'jdoe',
'*****@*****.**', 'iamjohndoe', 'iamjohndoe')
security.update_email()
graph = 'urn:sparql:test_askomics:users'
triple = ':jdoe foaf:mbox <mailto:[email protected]>'
assert self.tps.test_triple_presence(graph, triple)
triple = ':jdoe foaf:mbox <mailto:[email protected]>'
assert not self.tps.test_triple_presence(graph, triple)
def test_update_passwd(self):
"""Test update_mail"""
self.tps.clean_up()
self.tps.add_jdoe_in_users()
security = Security(self.settings, self.request.session, 'jdoe',
'*****@*****.**', 'newpasswd', 'newpasswd')
security.update_passwd()
graph = 'urn:sparql:test_askomics:users'
triple = ':jdoe :password "' + security.get_sha256_pw() + '"'
assert self.tps.test_triple_presence(graph, triple)
triple = ':jdoe :password "23df582b51c3482b677c8eac54872b8bd0a49bfadc853628b8b8bd4806147b54"'
assert not self.tps.test_triple_presence(graph, triple)
class AskViewTests(unittest.TestCase):
def setUp(self):
self.settings = get_appsettings('configs/development.virtuoso.ini',
name='main')
self.request = testing.DummyRequest()
self.config = testing.setUp(request=self.request)
self.config.add_route('load_data_into_graph', '/load_data_into_graph')
self.config.scan()
self.request.session['upload_directory'] = os.path.join(
os.path.dirname(__file__), "..", "test-data")
self.temp_directory = tempfile.mkdtemp()
self.it = InterfaceTPS(self.settings, self.request)
self.askview = AskView(self.request)
self.askview.settings = self.settings
self.timestamp = str(time.time())
def tearDown(self):
shutil.rmtree(self.temp_directory)
def test_start_points(self):
#load files
self.it.empty()
self.it.load_test2()
data = self.askview.start_points()
resAttendu = {
'http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#Personne':
{
'label':
'Personne',
'uri':
'http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#Personne'
},
'http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#Instrument':
{
'label':
'Instrument',
'uri':
'http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#Instrument'
}
}
for elt in data["nodes"]:
assert data["nodes"][elt] == resAttendu[elt]
assert len(data["nodes"]) == 2
def test_statistics(self):
#load files
self.it.empty()
self.it.load_test2()
ql = QueryLauncher(self.settings, self.request.session)
queryResults = ql.insert_data(':sujet :predicat :objet .', 'test',
'prefix :<test>')
server = queryResults.info()['server']
self.request.json_body = {'namedGraphs': ['test']}
self.askview.delete_graph()
data = self.askview.statistics()
assert data['ntriples'] == 279
assert data['nclasses'] == '6'
assert data['nentities'] == '19'
assert data['ngraphs'] == '5'
assert data['class'] == {
'Personne': {
'count': '7'
},
'Sexe': {
'count': '2'
},
'Instrument': {
'count': '2'
}
}
for key in data['metadata'].keys():
self.assertRegexpMatches(
key,
r'^urn:sparql:(instrument|enseigne|connait|joue|personne)\.tsv_[0-9]+\.[0-9]+$'
)
for key2 in data['metadata'][key]:
self.assertRegexpMatches(
key2, r'^(version|username|filename|loadDate|server)$')
if key2 == 'version':
assert data['metadata'][key][key2] == '2.0'
elif key2 == 'username':
assert data['metadata'][key][key2] == getpass.getuser()
elif key2 == 'filename':
self.assertRegexpMatches(
data['metadata'][key][key2],
r'^(instrument|enseigne|connait|joue|personne)\.tsv$')
elif key2 == 'loadDate':
self.assertRegexpMatches(data['metadata'][key][key2],
r'^[0-9]+\.[0-9]+$')
elif key2 == 'server':
assert data['metadata'][key][key2] == server
def test_empty_database(self):
self.it.empty()
self.it.load_test2()
self.askview.empty_database()
def test_delete_graph(self):
self.it.empty()
self.it.load_test2()
date = self.timestamp
self.request.json_body = {
'namedGraphs': [
'urn:sparql:personne.tsv_' + date,
'urn:sparql:enseigne.tsv_' + date,
'urn:sparql:connait.tsv_' + date,
'urn:sparql:instrument.tsv_' + date,
'urn:sparql:joue.tsv_' + date
]
}
self.askview.delete_graph()
def test_get_list_named_graphs(self):
self.it.empty()
self.it.load_test2()
namedGraphs = self.askview.get_list_named_graphs()
date = self.timestamp
resAttendu = [
'urn:sparql:personne.tsv_' + date,
'urn:sparql:enseigne.tsv_' + date,
'urn:sparql:connait.tsv_' + date,
'urn:sparql:instrument.tsv_' + date, 'urn:sparql:joue.tsv_' + date
]
assert namedGraphs.sort() == resAttendu.sort()
def test_source_files_overview(self):
data = self.askview.source_files_overview()
def test_preview_ttl(self):
self.request.json_body = {
'file_name': 'personne.tsv',
'col_types':
['entity_start', 'text', 'category', 'numeric', 'text'],
'disabled_columns': []
}
data = self.askview.preview_ttl()
def test_check_existing_data(self):
self.request.json_body = {
'file_name': 'personne.tsv',
'col_types':
['entity_start', 'text', 'category', 'numeric', 'text'],
'disabled_columns': []
}
data = self.askview.check_existing_data()
# catch error
self.request.json_body = {
'file_name': 'personneeee.tsv',
'col_types': {},
'disabled_columns': 1
}
data = self.askview.check_existing_data()
def test_load_data_into_graph(self):
self.request.json_body = {
'file_name': 'personne.tsv',
'col_types':
['entity_start', 'text', 'category', 'numeric', 'text'],
'disabled_columns': []
}
data = self.askview.load_data_into_graph()
def test_getUserAbstraction(self):
#load files
self.it.empty()
self.it.load_test1()
data = self.askview.getUserAbstraction()
def test_get_value(self):
#load files
self.it.empty()
self.it.load_test1()
self.request.json_body = {
'variates': ['?Personne1'],
'constraintesRelations': [[
'?URIPersonne1 rdf:type <http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#Personne>',
'?URIPersonne1 rdfs:label ?Personne1'
], ''],
'limit':
30,
'export':
False,
}
data = self.askview.get_value()
self.request.json_body['export'] = True
data = self.askview.get_value()
# manage an error
self.request.json_body = {}
data = self.askview.get_value()
def test_get_valuetxtquery(self):
#load files
self.it.empty()
self.it.load_test1()
self.request.json_body = {
'variates': ['?Personne1'],
'constraintesRelations': [[
'?URIPersonne1 rdf:type <http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#Personne>',
'?URIPersonne1 rdfs:label ?Personne1'
], ''],
'limit':
30,
'export':
False,
}
data = self.askview.getSparqlQueryInTextFormat()
# manage an error
self.request.json_body = {}
data = self.askview.getSparqlQueryInTextFormat()
def test_positionable_attr(self):
self.it.empty()
self.it.load_test3()
self.request.json_body = {
'node':
'http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#transcript',
'second_node':
'http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#qtl',
}
resAttendu = {
'results': {
'position_ref': True,
'position_strand': False,
'position_taxon': True
}
}
data = self.askview.positionable_attr()
assert data == resAttendu
class SecurityTests(unittest.TestCase):
"""Test for the Security class"""
def setUp(self):
"""Set up the settings and session"""
self.settings = get_appsettings('configs/test.virtuoso.ini', name='main')
self.request = testing.DummyRequest()
self.request.session['username'] = '******'
self.request.session['group'] = 'base'
self.request.session['admin'] = False
self.request.session['blocked'] = True
self.tps = InterfaceTPS(self.settings, self.request)
def test_get_sha256_pw(self):
"""Test get_sha256_pw"""
security = Security(self.settings, self.request.session, 'jdoe', '*****@*****.**', 'iamjohndoe', 'iamjohndoe')
assert len(security.get_sha256_pw()) == 64 # We cant predict the string cause there is random for salt
def test_check_email(self):
"""Test for check_email"""
# Test if good mail return True
security = Security(self.settings, self.request.session, 'jdoe', '*****@*****.**', 'iamjohndoe', 'iamjohndoe')
assert security.check_email()
# Test if wrong email return False
security = Security(self.settings, self.request.session, 'jdoe', 'wrong_email', 'iamjohndoe', 'iamjohndoe')
assert not security.check_email()
def test_check_passwords(self):
"""Test for check_passwords"""
# Test if identical passwords return True
security = Security(self.settings, self.request.session, 'jdoe', '*****@*****.**', 'iamjohndoe', 'iamjohndoe')
assert security.check_passwords()
# Test if different passwords return False
security = Security(self.settings, self.request.session, 'jdoe', '*****@*****.**', 'iamjohndoe', 'second_wrong_password')
assert not security.check_passwords()
def test_check_password_length(self):
"""Test for check_password_length"""
# Test if long passwords return True
security = Security(self.settings, self.request.session, 'jdoe', '*****@*****.**', 'iamjohndoe', 'iamjohndoe')
assert security.check_password_length()
# Test if short passwords return False
security = Security(self.settings, self.request.session, 'jdoe', '*****@*****.**', 'a', 'a')
# assert not security.check_password_length() #FIXME: not working because max lenght is 1
def test_check_username_in_database(self):
"""test check_username_in_database
Insert jdoe and test if jdoe is in database, then test
jsmith is not in database
"""
self.tps.clean_up()
self.tps.add_jdoe_in_users()
security = Security(self.settings, self.request.session, 'jdoe', '*****@*****.**', 'iamjohndoe', 'iamjohndoe')
# test with same username
assert security.check_username_in_database()
security = Security(self.settings, self.request.session, 'jsmith', '*****@*****.**', 'iamjohnsmith', 'iamjohnsmith')
# test with a different username
assert not security.check_username_in_database()
def test_check_email_in_database(self):
"""test check_username_in_database
Insert jdoe and test if jdoe is in database, then test
jsmith is not in database
"""
self.tps.clean_up()
self.tps.add_jdoe_in_users()
security = Security(self.settings, self.request.session, 'jdoe', '*****@*****.**', 'iamjohndoe', 'iamjohndoe')
# test with same username
assert security.check_email_in_database()
security = Security(self.settings, self.request.session, 'jsmith', '*****@*****.**', 'iamjohnsmith', 'iamjohnsmith')
# test with a different username
assert not security.check_email_in_database()
def test_set_username_by_email(self):
self.tps.clean_up()
self.tps.add_jdoe_in_users()
security = Security(self.settings, self.request.session, 'jdoe', '*****@*****.**', 'iamjohndoe', 'iamjohndoe')
security.set_username_by_email()
def test_get_owner_of_apikey(self):
self.tps.clean_up()
self.tps.add_jdoe_in_users()
security = Security(self.settings, self.request.session, 'jdoe', '*****@*****.**', 'iamjohndoe', 'iamjohndoe')
security.get_owner_of_apikey("test")
def test_ckeck_key_belong_user(self):
self.tps.clean_up()
self.tps.add_jdoe_in_users()
security = Security(self.settings, self.request.session, 'jdoe', '*****@*****.**', 'iamjohndoe', 'iamjohndoe')
security.ckeck_key_belong_user("test")
def test_add_del_apikey(self):
self.tps.clean_up()
self.tps.add_jdoe_in_users()
security = Security(self.settings, self.request.session, 'jdoe', '*****@*****.**', 'iamjohndoe', 'iamjohndoe')
security.delete_apikey("test")
security.add_apikey("test")
security.delete_apikey("test")
def test_add_del_galaxy(self):
self.tps.clean_up()
self.tps.add_jdoe_in_users()
security = Security(self.settings, self.request.session, 'jdoe', '*****@*****.**', 'iamjohndoe', 'iamjohndoe')
try:
security.add_galaxy("http://test","test")
assert False
except Exception as e:
assert True
security.get_galaxy_infos()
security.check_galaxy()
security.delete_galaxy()
def test_check_email_password(self):
"""Test check_email_password
Insert jdoe and check the password
"""
self.tps.clean_up()
self.tps.add_jdoe_in_users()
security = Security(self.settings, self.request.session, 'jdoe', '*****@*****.**', 'iamjohndoe', 'iamjohndoe')
# try with the good password
assert security.check_email_password()
security = Security(self.settings, self.request.session, 'jdoe', '*****@*****.**', 'wrong_password', 'wrong_password')
# Try with a wrong password
assert not security.check_email_password()
def test_check_username_password(self):
"""Test check_username_password
Insert jdoe and check the password
"""
self.tps.clean_up()
self.tps.add_jdoe_in_users()
security = Security(self.settings, self.request.session, 'jdoe', '*****@*****.**', 'iamjohndoe', 'iamjohndoe')
# try with the good password
assert security.check_username_password()
security = Security(self.settings, self.request.session, 'jdoe', '*****@*****.**', 'wrong_password', 'wrong_password')
# Try with a wrong password
assert not security.check_username_password()
def test_get_number_of_users(self):
"""Test get_number_of_users
test the method with 0, 1 and 2 users
"""
self.tps.clean_up()
security = Security(self.settings, self.request.session, '', '', '', '')
assert security.get_number_of_users() == 0
self.tps.add_jdoe_in_users()
assert security.get_number_of_users() == 1
self.tps.add_jsmith_in_users()
assert security.get_number_of_users() == 2
def test_persist_user(self):
"""Test persist_user
Insert a user and test if get_number_of_user return 1
"""
self.tps.clean_up()
security = Security(self.settings, self.request.session, 'jdoe', '*****@*****.**', 'iamjohndoe', 'iamjohndoe')
assert security.get_number_of_users() == 0
security.persist_user('http://localhost')
assert security.get_number_of_users() == 1
#assert security.
security = Security(self.settings, self.request.session, 'jdoe2', '*****@*****.**', 'iamjohndoe', 'iamjohndoe')
security.persist_user('http://localhost')
assert security.get_number_of_users() == 2
def test_send_mails(self):
"""Test send_mails"""
#TODO: how to test mail ?
pass
def test_create_user_graph(self):
"""Test create_user_graph
create the graph, and then test the presence of the triple
"""
self.tps.clean_up()
security = Security(self.settings, self.request.session, 'jdoe', '*****@*****.**', 'iamjohndoe', 'iamjohndoe')
security.create_user_graph()
assert self.tps.test_triple_presence('urn:sparql:test_askomics', '<urn:sparql:test_askomics:jdoe> rdfg:subGraphOf <urn:sparql:test_askomics>')
assert not self.tps.test_triple_presence('urn:sparql:test_askomics', '<urn:sparql:test_askomics:jsmith> rdfg:subGraphOf <urn:sparql:test_askomics>')
def test_get_admins_emails(self):
"""Test get_admins_emails
Test the finction with nobody, 1, 2 non admin users, and with 1 and 2 admins users
"""
self.tps.clean_up()
security = Security(self.settings, self.request.session, '', '', '', '')
assert security.get_admins_emails() == []
self.tps.add_jdoe_in_users()
assert security.get_admins_emails() == []
self.tps.add_jsmith_in_users()
assert security.get_admins_emails() == []
self.tps.add_admin_in_users()
assert security.get_admins_emails() == ['*****@*****.**']
self.tps.add_another_admin_in_users()
res_emails = security.get_admins_emails()
assert len(res_emails) == 2
assert '*****@*****.**' in res_emails
assert '*****@*****.**' in res_emails
def test_set_admin(self):
"""Test set_admin"""
self.tps.clean_up()
security = Security(self.settings, self.request.session, 'jdoe', '', '', '')
assert not self.request.session['admin']
security.set_admin(True)
assert self.request.session['admin']
def test_set_galaxy(self):
"""Test set_admin"""
self.tps.clean_up()
security = Security(self.settings, self.request.session, 'jdoe', '', '', '')
security.set_galaxy(True)
assert self.request.session['galaxy']
def test_set_blocked(self):
"""Test set_blocked"""
self.tps.clean_up()
security = Security(self.settings, self.request.session, 'jdoe', '', '', '')
assert self.request.session['blocked']
security.set_blocked(False)
assert not self.request.session['blocked']
def test_get_admin_blocked_by_usrnm(self):
"""Test get_admin_blocked_by_username"""
self.tps.clean_up()
self.tps.add_jdoe_in_users()
self.tps.add_admin_in_users()
security = Security(self.settings, self.request.session, 'jdoe', '*****@*****.**', 'iamjohndoe', 'iamjohndoe')
assert security.get_admin_blocked_by_username() == {'blocked': False, 'admin': False}
security = Security(self.settings, self.request.session, 'admin', '*****@*****.**', 'iamadmin', 'iamadmin')
assert security.get_admin_blocked_by_username() == {'blocked': False, 'admin': True}
def test_get_admin_blocked_by_email(self):
"""Test get_admin_blocked_by_email"""
self.tps.clean_up()
self.tps.add_jdoe_in_users()
self.tps.add_admin_in_users()
security = Security(self.settings, self.request.session, 'jdoe', '*****@*****.**', 'iamjohndoe', 'iamjohndoe')
assert security.get_admin_blocked_by_email() == {'blocked': False, 'admin': False}
security = Security(self.settings, self.request.session, 'admin', '*****@*****.**', 'iamadmin', 'iamadmin')
assert security.get_admin_blocked_by_email() == {'blocked': False, 'admin': True}
def test_log_user(self):
"""Test log_user"""
self.tps.clean_up()
security = Security(self.settings, self.request.session, 'testlog', '*****@*****.**', 'testlog', 'testlog')
security.log_user(self.request)
assert self.request.session['username'] == 'testlog'
assert not self.request.session['admin']
assert self.request.session['blocked']
assert self.request.session['graph'] == 'urn:sparql:test_askomics:testlog'
def test_update_email(self):
"""Test update_mail"""
self.tps.clean_up()
self.tps.add_jdoe_in_users()
security = Security(self.settings, self.request.session, 'jdoe', '*****@*****.**', 'iamjohndoe', 'iamjohndoe')
security.update_email()
graph = 'urn:sparql:test_askomics:users'
triple = ':jdoe foaf:mbox <mailto:[email protected]>'
assert self.tps.test_triple_presence(graph, triple)
triple = ':jdoe foaf:mbox <mailto:[email protected]>'
assert not self.tps.test_triple_presence(graph, triple)
def test_update_passwd(self):
"""Test update_mail"""
self.tps.clean_up()
self.tps.add_jdoe_in_users()
security = Security(self.settings, self.request.session, 'jdoe', '*****@*****.**', 'newpasswd', 'newpasswd')
security.update_passwd()
graph = 'urn:sparql:test_askomics:users'
triple = ':jdoe :password "' + security.get_sha256_pw() + '"'
assert self.tps.test_triple_presence(graph, triple)
triple = ':jdoe :password "23df582b51c3482b677c8eac54872b8bd0a49bfadc853628b8b8bd4806147b54"'
assert not self.tps.test_triple_presence(graph, triple)
class AskViewTests(unittest.TestCase):
def setUp( self ):
self.settings = get_appsettings('configs/development.virtuoso.ini', name='main')
self.request = testing.DummyRequest()
self.config = testing.setUp(request=self.request)
self.config.add_route('load_data_into_graph', '/load_data_into_graph')
self.config.scan()
self.request.session['upload_directory'] = os.path.join( os.path.dirname( __file__ ), "..", "test-data")
self.temp_directory = tempfile.mkdtemp()
self.it = InterfaceTPS(self.settings,self.request)
self.askview = AskView(self.request)
self.askview.settings = self.settings
self.timestamp = str(time.time())
def tearDown( self ):
shutil.rmtree( self.temp_directory )
def test_start_points(self):
#load files
self.it.empty()
self.it.load_test2()
data = self.askview.start_points()
resAttendu = {
'http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#Personne': {'label': 'Personne', 'uri': 'http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#Personne'},
'http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#Instrument': {'label': 'Instrument', 'uri': 'http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#Instrument'}
}
for elt in data["nodes"]:
assert data["nodes"][elt] == resAttendu[elt]
assert len(data["nodes"]) == 2
def test_statistics(self):
#load files
self.it.empty()
self.it.load_test2()
ql = QueryLauncher(self.settings, self.request.session)
queryResults = ql.insert_data(':sujet :predicat :objet .', 'test', 'prefix :<test>')
server = queryResults.info()['server']
self.request.json_body = {'namedGraphs': ['test']}
self.askview.delete_graph()
data = self.askview.statistics()
assert data['ntriples'] == 279
assert data['nclasses'] == '6'
assert data['nentities'] == '19'
assert data['ngraphs'] == '5'
assert data['class'] == {
'Personne': {'count': '7'},
'Sexe': {'count': '2'},
'Instrument': {'count': '2'}
}
for key in data['metadata'].keys():
self.assertRegexpMatches(key, r'^urn:sparql:(instrument|enseigne|connait|joue|personne)\.tsv_[0-9]+\.[0-9]+$')
for key2 in data['metadata'][key]:
self.assertRegexpMatches(key2, r'^(version|username|filename|loadDate|server)$')
if key2 == 'version':
assert data['metadata'][key][key2] == '2.0'
elif key2 == 'username':
assert data['metadata'][key][key2] == getpass.getuser()
elif key2 == 'filename':
self.assertRegexpMatches(data['metadata'][key][key2], r'^(instrument|enseigne|connait|joue|personne)\.tsv$')
elif key2 == 'loadDate':
self.assertRegexpMatches(data['metadata'][key][key2], r'^[0-9]+\.[0-9]+$')
elif key2 == 'server':
assert data['metadata'][key][key2] == server
def test_empty_database(self):
self.it.empty()
self.it.load_test2()
self.askview.empty_database()
def test_delete_graph(self):
self.it.empty()
self.it.load_test2()
date = self.timestamp
self.request.json_body = {
'namedGraphs':
[
'urn:sparql:personne.tsv_'+ date,
'urn:sparql:enseigne.tsv_'+ date,
'urn:sparql:connait.tsv_'+ date,
'urn:sparql:instrument.tsv_'+ date,
'urn:sparql:joue.tsv_'+ date
]
}
self.askview.delete_graph()
def test_get_list_named_graphs(self):
self.it.empty()
self.it.load_test2()
namedGraphs = self.askview.get_list_named_graphs()
date = self.timestamp
resAttendu = [
'urn:sparql:personne.tsv_'+ date,
'urn:sparql:enseigne.tsv_'+ date,
'urn:sparql:connait.tsv_'+ date,
'urn:sparql:instrument.tsv_'+ date,
'urn:sparql:joue.tsv_'+ date
]
assert namedGraphs.sort() == resAttendu.sort()
def test_source_files_overview(self):
data = self.askview.source_files_overview()
def test_preview_ttl(self):
self.request.json_body = {
'file_name':'personne.tsv',
'col_types': ['entity_start', 'text', 'category', 'numeric', 'text'],
'disabled_columns':[]
}
data = self.askview.preview_ttl()
def test_check_existing_data(self):
self.request.json_body = {
'file_name':'personne.tsv',
'col_types': ['entity_start', 'text', 'category', 'numeric', 'text'],
'disabled_columns':[]
}
data = self.askview.check_existing_data();
# catch error
self.request.json_body = {
'file_name':'personneeee.tsv',
'col_types': {},
'disabled_columns':1
}
data = self.askview.check_existing_data();
def test_load_data_into_graph(self):
self.request.json_body = {
'file_name':'personne.tsv',
'col_types': ['entity_start', 'text', 'category', 'numeric', 'text'],
'disabled_columns':[]
}
data = self.askview.load_data_into_graph();
def test_getUserAbstraction(self):
#load files
self.it.empty()
self.it.load_test1()
data = self.askview.getUserAbstraction();
def test_get_value(self):
#load files
self.it.empty()
self.it.load_test1()
self.request.json_body = {
'variates':['?Personne1'],
'constraintesRelations': [ ['?URIPersonne1 rdf:type <http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#Personne>','?URIPersonne1 rdfs:label ?Personne1'],''],
'limit': 30,
'export': False,
}
data = self.askview.get_value()
self.request.json_body['export'] = True
data = self.askview.get_value()
# manage an error
self.request.json_body = {
}
data = self.askview.get_value()
def test_get_valuetxtquery(self):
#load files
self.it.empty()
self.it.load_test1()
self.request.json_body = {
'variates':['?Personne1'],
'constraintesRelations': [['?URIPersonne1 rdf:type <http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#Personne>','?URIPersonne1 rdfs:label ?Personne1'],''],
'limit': 30,
'export': False,
}
data = self.askview.getSparqlQueryInTextFormat()
# manage an error
self.request.json_body = {
}
data = self.askview.getSparqlQueryInTextFormat()
def test_positionable_attr(self):
self.it.empty()
self.it.load_test3()
self.request.json_body = {
'node' : 'http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#transcript',
'second_node' : 'http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#qtl',
}
resAttendu = {
'results' : {'position_ref': True, 'position_strand': False, 'position_taxon': True}
}
data = self.askview.positionable_attr()
assert data == resAttendu
class tripleStoreExplorerTests(unittest.TestCase):
def setUp(self):
self.settings = get_appsettings('configs/development.virtuoso.ini',
name='main')
self.request = testing.DummyRequest()
self.request.session['upload_directory'] = os.path.join(
os.path.dirname(__file__), "..", "test-data")
self.temp_directory = tempfile.mkdtemp()
self.it = InterfaceTPS(self.settings, self.request)
self.it.empty()
self.it.load_test1()
def tearDown(self):
shutil.rmtree(self.temp_directory)
self.it.empty()
def test_start_points(self):
tse = TripleStoreExplorer(self.settings, self.request.session)
tse.get_start_points()
def test_build_sparql_query_from_json(self):
variates = ['?Personne1', '?label1', '?Age1', '?ID1', '?Sexe1']
constraintesRelations = [[
'?URIPersonne1 rdf:type <http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#Personne>',
'?URIPersonne1 rdfs:label ?Personne1',
'?URIPersonne1 <http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#label> ?label1',
'<http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#label> rdfs:domain <http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#Personne>',
'<http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#label> rdfs:range <http://www.w3.org/2001/XMLSchema#string>',
'<http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#label> rdf:type owl:DatatypeProperty',
'?URIPersonne1 <http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#Age> ?Age1',
'<http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#Age> rdfs:domain <http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#Personne>',
'<http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#Age> rdfs:range <http://www.w3.org/2001/XMLSchema#decimal>',
'<http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#Age> rdf:type owl:DatatypeProperty',
'?URIPersonne1 <http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#ID> ?ID1',
'<http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#ID> rdfs:domain <http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#Personne>',
'<http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#ID> rdfs:range <http://www.w3.org/2001/XMLSchema#string>',
'<http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#ID> rdf:type owl:DatatypeProperty',
'?URIPersonne1 <http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#Sexe> ?Sexe1'
], '']
limit = 10
tse = TripleStoreExplorer(self.settings, self.request.session)
results, query = tse.build_sparql_query_from_json(
variates, constraintesRelations, limit, True)
a = {
'Age1': '23',
'ID1': 'AZERTY',
'Personne1': 'A',
'Sexe1':
'http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#F',
'label1': 'Alice'
}
b = {
'Age1': '25',
'ID1': 'QSDFG',
'Personne1': 'B',
'Sexe1':
'http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#M',
'label1': 'Bob'
}
c = {
'Age1': '34',
'ID1': 'WXCVB',
'Personne1': 'C',
'Sexe1':
'http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#M',
'label1': 'Charles'
}
d = {
'Age1': '45',
'ID1': 'RTYU',
'Personne1': 'D',
'Sexe1':
'http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#M',
'label1': 'Denis'
}
e = {
'Age1': '55',
'ID1': 'RTYUIO',
'Personne1': 'E',
'Sexe1':
'http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#F',
'label1': 'Elise'
}
f = {
'Age1': '77',
'ID1': 'DFGH',
'Personne1': 'F',
'Sexe1':
'http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#M',
'label1': 'Fred'
}
g = {
'Age1': '99',
'ID1': 'BNHJK',
'Personne1': 'G',
'Sexe1':
'http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#M',
'label1': 'Georges'
}
for elt in results:
self.assertTrue(elt in [a, b, c, d, e, f, g])
assert len(results) == 7
constraintesR1 = copy.deepcopy(constraintesRelations)
constraintesR1[0].append('VALUES ?Sexe1 { :F }')
class tripleStoreExplorerTests(unittest.TestCase):
def setUp( self ):
self.settings = get_appsettings('configs/development.virtuoso.ini', name='main')
self.request = testing.DummyRequest()
self.request.session['upload_directory'] = os.path.join( os.path.dirname( __file__ ), "..", "test-data")
self.temp_directory = tempfile.mkdtemp()
self.it = InterfaceTPS(self.settings,self.request)
self.it.empty()
self.it.load_test1()
def tearDown( self ):
shutil.rmtree( self.temp_directory )
self.it.empty()
def test_start_points(self):
tse = TripleStoreExplorer(self.settings, self.request.session)
tse.get_start_points()
def test_build_sparql_query_from_json(self):
variates = ['?Personne1', '?label1', '?Age1', '?ID1', '?Sexe1']
constraintesRelations = [['?URIPersonne1 rdf:type <http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#Personne>',
'?URIPersonne1 rdfs:label ?Personne1',
'?URIPersonne1 <http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#label> ?label1',
'<http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#label> rdfs:domain <http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#Personne>',
'<http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#label> rdfs:range <http://www.w3.org/2001/XMLSchema#string>',
'<http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#label> rdf:type owl:DatatypeProperty',
'?URIPersonne1 <http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#Age> ?Age1',
'<http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#Age> rdfs:domain <http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#Personne>',
'<http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#Age> rdfs:range <http://www.w3.org/2001/XMLSchema#decimal>',
'<http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#Age> rdf:type owl:DatatypeProperty',
'?URIPersonne1 <http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#ID> ?ID1',
'<http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#ID> rdfs:domain <http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#Personne>',
'<http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#ID> rdfs:range <http://www.w3.org/2001/XMLSchema#string>',
'<http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#ID> rdf:type owl:DatatypeProperty',
'?URIPersonne1 <http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#Sexe> ?Sexe1'],'']
limit = 10
tse = TripleStoreExplorer(self.settings, self.request.session)
results,query = tse.build_sparql_query_from_json(variates,constraintesRelations,limit,True)
a = {'Age1': '23',
'ID1': 'AZERTY',
'Personne1': 'A',
'Sexe1': 'http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#F',
'label1': 'Alice'}
b = {'Age1': '25',
'ID1': 'QSDFG',
'Personne1': 'B',
'Sexe1': 'http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#M',
'label1': 'Bob'}
c = {'Age1': '34',
'ID1': 'WXCVB',
'Personne1': 'C',
'Sexe1': 'http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#M',
'label1': 'Charles'}
d = {'Age1': '45',
'ID1': 'RTYU',
'Personne1': 'D',
'Sexe1': 'http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#M',
'label1': 'Denis'}
e = {'Age1': '55',
'ID1': 'RTYUIO',
'Personne1': 'E',
'Sexe1': 'http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#F','label1': 'Elise'}
f = {'Age1': '77',
'ID1': 'DFGH',
'Personne1': 'F',
'Sexe1': 'http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#M',
'label1': 'Fred'}
g = {'Age1': '99',
'ID1': 'BNHJK',
'Personne1': 'G',
'Sexe1': 'http://www.semanticweb.org/irisa/ontologies/2016/1/igepp-ontology#M',
'label1': 'Georges'}
for elt in results:
self.assertTrue(elt in [a,b,c,d,e,f,g])
assert len(results) == 7
constraintesR1 = copy.deepcopy(constraintesRelations)
constraintesR1[0].append('VALUES ?Sexe1 { :F }')
class AskViewTests(unittest.TestCase):
"""Test for Askview
Contain all the tests for the askView class
"""
def setUp(self):
"""Set up the configuration to access the triplestore
Use the config file test.virtuoso.ini to not interfere with
production data
"""
self.settings = get_appsettings('configs/test.virtuoso.ini', name='main')
self.settings['askomics.upload_user_data_method'] = 'insert'
self.request = testing.DummyRequest()
self.config = testing.setUp(request=self.request)
self.config.add_route('load_data_into_graph', '/load_data_into_graph')
self.config.scan()
self.request.session['username'] = '******'
self.request.session['blocked'] = False
self.request.session['group'] = 'base'
self.request.session['graph'] = 'urn:sparql:test_askomics:jdoe'
self.request.host_url = 'http://*****:*****@example.com',
'password': '******',
'password2': 'iamjohndoe'
}
data = self.askview.signup()
assert data == {'error': [], 'blocked': False, 'admin': True, 'username': '******'}
def test_checkuser(self):
"""Test checkuser method"""
self.tps.clean_up()
data = self.askview.checkuser()
assert data == {'admin': False, 'username': '******', 'blocked': False, 'galaxy': False}
def test_logout(self):
"""Test logout method"""
self.tps.clean_up()
self.askview.logout()
assert self.request.session == {}
def test_login(self):
"""Test login method"""
self.tps.clean_up()
#first, create a user
self.request.json_body = {
'username': '******',
'email': '*****@*****.**',
'password': '******',
'password2': 'iamjohndoe'
}
self.askview.signup()
# then, logout this user
self.askview.logout()
# and then, test login
self.request.json_body = {
'username_email': 'jdoe',
'password': '******'
}
data = self.askview.login()
assert data == {'blocked': False, 'admin': True, 'error': [], 'username': '******'}
def test_get_users_infos(self):
"""Test get_users_infos"""
self.tps.clean_up()
# first test with non admin
try :
data = self.askview.get_users_infos()
assert False
except Exception as e:
assert True
# then, is user is admin
self.request.session['admin'] = True
data = self.askview.get_users_infos()
assert data == {'result': []} #result is empty cause there is no user
#test with user
self.request.json_body = {
'username': '******',
'email': '*****@*****.**',
'password': '******',
'password2': 'iamjohndoe'
}
self.askview.signup()
data = self.askview.get_users_infos()
assert data == {'result': [], 'error': [], 'admin': True, 'blocked': False, 'username': '******'}
def test_lock_user(self):
"""Test lock_user method"""
self.tps.clean_up()
self.request.json_body = {
'username': '******',
'lock': True
}
# first test with non admin
try:
data = self.askview.lock_user()
assert False
except Exception as e:
assert True
# then, is user is admin
self.request.session['admin'] = True
data = self.askview.lock_user()
assert data == 'success'
def test_set_admin(self):
"""Test set_admin_method"""
self.tps.clean_up()
self.request.json_body = {
'username': '******',
'admin': True
}
try:
data = self.askview.set_admin()
except Exception as e:
assert True
# then, is user is admin
self.request.session['admin'] = True
data = self.askview.set_admin()
assert data == 'success'
def test_delete_user(self):
"""Test delete_user method"""
self.tps.clean_up()
# Insert a user
self.request.json_body = {
'username': '******',
'email': '*****@*****.**',
'password': '******',
'password2': 'iamjohndoe'
}
self.askview.signup()
# test the deletion
self.request.json_body = {
'username': '******',
'passwd': 'iamjohndoe',
'passwd_conf': 'iamjohndoe'
}
self.request.session['blocked'] = False
self.request.session['admin'] = False
self.request.session['username'] = '******'
data = self.askview.delete_user()
assert data == 'success'
def test_get_my_infos(self):
"""Test get_my_infos"""
self.tps.clean_up()
# First, insert me
self.request.json_body = {
'username': '******',
'email': '*****@*****.**',
'password': '******',
'password2': 'iamjohndoe'
}
self.askview.signup()
# get my infos
data = self.askview.get_my_infos()
assert data == {'email': '*****@*****.**', 'username': '******', 'apikeys': [], 'blocked': False, 'admin': True}
def test_update_mail(self):
"""Test update_mail"""
self.tps.clean_up()
# First, insert me
self.request.json_body = {
'username': '******',
'email': '*****@*****.**',
'password': '******',
'password2': 'iamjohndoe'
}
self.askview.signup()
# And change my email
self.request.json_body = {
'username': '******',
'email': '*****@*****.**'
}
data = self.askview.update_mail()
assert data == {'username': '******', 'error': [], 'success': 'success', 'blocked': False, 'admin': True}
def test_update_passwd(self):
"""Test update_passwd method"""
self.tps.clean_up()
# First, insert me
self.request.json_body = {
'username': '******',
'email': '*****@*****.**',
'password': '******',
'password2': 'iamjohndoe'
}
self.askview.signup()
# And update my password
self.request.json_body = {
'username': '******',
'current_passwd': 'iamjohndoe',
'passwd': 'mynewpassword',
'passwd2': 'mynewpassword',
}
data = self.askview.update_passwd()
assert data == {'error': [], 'admin': True, 'blocked': False, 'username': '******', 'success': 'success'}
class AskViewTests(unittest.TestCase):
"""Test for Askview
Contain all the tests for the askView class
"""
def setUp(self):
"""Set up the configuration to access the triplestore
Use the config file test.virtuoso.ini to not interfere with
production data
"""
self.settings = get_appsettings('configs/test.virtuoso.ini', name='main')
self.settings['askomics.upload_user_data_method'] = 'insert'
self.request = testing.DummyRequest()
self.config = testing.setUp(request=self.request)
self.config.add_route('load_data_into_graph', '/load_data_into_graph')
self.config.scan()
self.request.session['username'] = '******'
self.request.session['blocked'] = False
self.request.session['group'] = 'base'
self.request.session['graph'] = 'urn:sparql:test_askomics:jdoe'
self.request.host_url = 'http://*****:*****@example.com',
'password': '******',
'password2': 'iamjohndoe'
}
data = self.askview.signup()
assert data == {'error': [], 'blocked': False, 'admin': True, 'username': '******'}
def test_checkuser(self):
"""Test checkuser method"""
self.tps.clean_up()
data = self.askview.checkuser()
assert data == {'admin': False, 'username': '******', 'blocked': False, 'galaxy': False}
def test_logout(self):
"""Test logout method"""
self.tps.clean_up()
self.askview.logout()
assert self.request.session == {}
def test_login(self):
"""Test login method"""
self.tps.clean_up()
#first, create a user
self.request.json_body = {
'username': '******',
'email': '*****@*****.**',
'password': '******',
'password2': 'iamjohndoe'
}
self.askview.signup()
# then, logout this user
self.askview.logout()
# and then, test login
self.request.json_body = {
'username_email': 'jdoe',
'password': '******'
}
data = self.askview.login()
assert data == {'blocked': False, 'admin': True, 'error': [], 'username': '******'}
def test_login_api(self):
"""Test login_api method"""
self.tps.clean_up()
# First, create a user
self.request.json_body = {
'username': '******',
'email': '*****@*****.**',
'password': '******',
'password2': 'iamjohndoe'
}
self.askview.signup()
# Then, create an API key
self.request.json_body = {
'username': '******',
'keyname': 'test'
}
self.askview.api_key()
# then, get infos
infos = self.askview.get_my_infos()
# then, try to log with API key
self.request.json_body = {
'apikey': infos['apikeys'][0]['key']
}
data = self.askview.login_api()
assert data == {'admin': True, 'blocked': False, 'username': '******', 'sucess': 'success', 'error': ''}
def test_login_api_gie(self):
"""Test login_api method"""
self.tps.clean_up()
# First, create a user
self.request.json_body = {
'username': '******',
'email': '*****@*****.**',
'password': '******',
'password2': 'iamjohndoe'
}
self.askview.signup()
# Then, create an API key
self.request.json_body = {
'username': '******',
'keyname': 'test'
}
self.askview.api_key()
# then, get infos
infos = self.askview.get_my_infos()
# then, try to log with API key
self.request.GET['key'] = infos['apikeys'][0]['key']
self.askview.login_api_gie()
def test_get_users_infos(self):
"""Test get_users_infos"""
self.tps.clean_up()
# first test with non admin
try :
data = self.askview.get_users_infos()
assert False
except Exception as e:
assert True
# then, is user is admin
self.request.session['admin'] = True
data = self.askview.get_users_infos()
assert data == {'result': []} #result is empty cause there is no user
#test with user
self.request.json_body = {
'username': '******',
'email': '*****@*****.**',
'password': '******',
'password2': 'iamjohndoe'
}
self.askview.signup()
data = self.askview.get_users_infos()
assert data == {'result': [], 'error': [], 'admin': True, 'blocked': False, 'username': '******'}
def test_lock_user(self):
"""Test lock_user method"""
self.tps.clean_up()
self.request.json_body = {
'username': '******',
'lock': True
}
# first test with non admin
try:
data = self.askview.lock_user()
assert False
except Exception as e:
assert True
# then, is user is admin
self.request.session['admin'] = True
data = self.askview.lock_user()
assert data == 'success'
def test_set_admin(self):
"""Test set_admin_method"""
self.tps.clean_up()
self.request.json_body = {
'username': '******',
'admin': True
}
try:
data = self.askview.set_admin()
except Exception as e:
assert True
# then, is user is admin
self.request.session['admin'] = True
data = self.askview.set_admin()
assert data == 'success'
def test_delete_user(self):
"""Test delete_user method"""
self.tps.clean_up()
# Insert a user
self.request.json_body = {
'username': '******',
'email': '*****@*****.**',
'password': '******',
'password2': 'iamjohndoe'
}
self.askview.signup()
# test the deletion
self.request.json_body = {
'username': '******',
'passwd': 'iamjohndoe',
'passwd_conf': 'iamjohndoe'
}
self.request.session['blocked'] = False
self.request.session['admin'] = False
self.request.session['username'] = '******'
data = self.askview.delete_user()
assert data == 'success'
def test_get_my_infos(self):
"""Test get_my_infos"""
self.tps.clean_up()
# First, insert me
self.request.json_body = {
'username': '******',
'email': '*****@*****.**',
'password': '******',
'password2': 'iamjohndoe'
}
self.askview.signup()
# get my infos
data = self.askview.get_my_infos()
assert data == {'email': '*****@*****.**', 'username': '******', 'apikeys': [], 'blocked': False, 'admin': True}
def test_update_mail(self):
"""Test update_mail"""
self.tps.clean_up()
# First, insert me
self.request.json_body = {
'username': '******',
'email': '*****@*****.**',
'password': '******',
'password2': 'iamjohndoe'
}
self.askview.signup()
# And change my email
self.request.json_body = {
'username': '******',
'email': '*****@*****.**'
}
data = self.askview.update_mail()
assert data == {'username': '******', 'error': [], 'success': 'success', 'blocked': False, 'admin': True}
def test_update_passwd(self):
"""Test update_passwd method"""
self.tps.clean_up()
# First, insert me
self.request.json_body = {
'username': '******',
'email': '*****@*****.**',
'password': '******',
'password2': 'iamjohndoe'
}
self.askview.signup()
# And update my password
self.request.json_body = {
'username': '******',
'current_passwd': 'iamjohndoe',
'passwd': 'mynewpassword',
'passwd2': 'mynewpassword',
}
data = self.askview.update_passwd()
assert data == {'error': [], 'admin': True, 'blocked': False, 'username': '******', 'success': 'success'}