def test_huge_queue(self): self.conn_handler = SQLConnectionHandler() self.conn_handler.create_queue("toy_queue") # add tons of inserts to queue for x in range(120): self.conn_handler.add_to_queue( "toy_queue", "INSERT INTO qiita.qiita_user (email, name, password) VALUES " "(%s, %s, %s)", ['*****@*****.**' % x, 'Toy', 'pass']) # add failing insert as final item in queue self.conn_handler.add_to_queue( "toy_queue", "INSERT INTO qiita.qiita_BADTABLE (email, name, password) VALUES " "(%s, %s, %s)", ['*****@*****.**' % x, 'Toy', 'pass']) self.conn_handler.add_to_queue( "toy_queue", "UPDATE qiita.qiita_user SET user_level_id = 1 " "WHERE email = %s and password = %s", [{0}, {1}]) with self.assertRaises(QiitaDBExecutionError): self.conn_handler.execute_queue("toy_queue") # make sure roll back correctly obs = self.conn_handler.execute_fetchall( "SELECT * from qiita.qiita_user WHERE email LIKE " "'%[email protected]%'") self.assertEqual(obs, [])
def class_modifier(cls): # First, we check that we are not in a production environment conn_handler = SQLConnectionHandler() # It is possible that we are connecting to a production database test_db = conn_handler.execute_fetchone("SELECT test FROM settings")[0] # Or the loaded configuration file belongs to a production environment # or the test database is not qiita_test if not qiita_config.test_environment or not test_db \ or qiita_config.database != 'qiita_test': raise RuntimeError("Working in a production environment. Not " "executing the tests to keep the production " "database safe.") # Now, we decorate the setup and teardown functions class DecoratedClass(cls): def setUp(self): super(DecoratedClass, self).setUp() self.conn_handler = SQLConnectionHandler() @reset_test_database def tearDown(self): super(DecoratedClass, self).tearDown() del self.conn_handler return DecoratedClass
def setUp(self): if self.database: self.conn_handler = SQLConnectionHandler() # Drop the schema self.conn_handler.execute("DROP SCHEMA qiita CASCADE") # Create the schema with open(LAYOUT_FP, 'U') as f: self.conn_handler.execute(f.read()) # Initialize the database with open(INITIALIZE_FP, 'U') as f: self.conn_handler.execute(f.read()) # Populate the database with open(POPULATE_FP, 'U') as f: self.conn_handler.execute(f.read()) super(TestHandlerBase, self).setUp()
class TestHandlerBase(AsyncHTTPTestCase): database = False conn_handler = SQLConnectionHandler() app = Application() def get_app(self): BaseHandler.get_current_user = Mock(return_value=User("*****@*****.**")) return self.app def setUp(self): if self.database: # First, we check that we are not in a production environment # It is possible that we are connecting to a production database test_db = self.conn_handler.execute_fetchone( "SELECT test FROM settings")[0] # Or the loaded config file belongs to a production environment if not qiita_config.test_environment or not test_db: raise RuntimeError("Working in a production environment. Not " "executing the tests to keep the production" " database safe.") # Drop the schema and rebuild the test database drop_and_rebuild_tst_database(self.conn_handler) super(TestHandlerBase, self).setUp() # helpers from http://www.peterbe.com/plog/tricks-asynchttpclient-tornado def get(self, url, data=None, headers=None, doseq=True): if data is not None: if isinstance(data, dict): data = urlencode(data, doseq=doseq) if '?' in url: url += '&%s' % data else: url += '?%s' % data return self._fetch(url, 'GET', headers=headers) def post(self, url, data, headers=None, doseq=True): if data is not None: if isinstance(data, dict): data = urlencode(data, doseq=doseq) return self._fetch(url, 'POST', data, headers) def _fetch(self, url, method, data=None, headers=None): self.http_client.fetch(self.get_url(url), self.stop, method=method, body=data, headers=headers) return self.wait()
def __call__(self, searchstr, user): """Runs a Study query and returns matching studies and samples Parameters ---------- searchstr : str Search string to use user : User object User making the search. Needed for permissions checks. Returns ------- dict Found samples in format {study_id: [[samp_id1, meta1, meta2, ...], [samp_id2, meta1, meta2, ...], ...} list metadata column names searched for Notes ----- Metadata information for each sample is in the same order as the metadata columns list returned Metadata column names and string searches are case-sensitive """ study_sql, sample_sql, meta_headers = \ self._parse_study_search_string(searchstr, True) conn_handler = SQLConnectionHandler() # get all studies containing the metadata headers requested study_ids = {x[0] for x in conn_handler.execute_fetchall(study_sql)} # strip to only studies user has access to if user.level not in {'admin', 'dev', 'superuser'}: study_ids = study_ids.intersection( Study.get_by_status('public') + user.user_studies + user.shared_studies) results = {} # run search on each study to get out the matching samples for sid in study_ids: study_res = conn_handler.execute_fetchall(sample_sql.format(sid)) if study_res: # only add study to results if actually has samples in results results[sid] = study_res return results, meta_headers
def test_queue_fail(self): """Fail if no results data exists for substitution""" self.conn_handler = SQLConnectionHandler() self.conn_handler.create_queue("toy_queue") self.conn_handler.add_to_queue( "toy_queue", "INSERT INTO qiita.qiita_user (email, name, password) VALUES " "(%s, %s, %s)", ['*****@*****.**', 'Toy', 'pass']) self.conn_handler.add_to_queue( "toy_queue", "UPDATE qiita.qiita_user SET user_level_id = 1 " "WHERE email = %s and password = %s", [{0}, {1}]) with self.assertRaises(QiitaDBExecutionError): self.conn_handler.execute_queue("toy_queue") # make sure roll back correctly obs = self.conn_handler.execute_fetchall( "SELECT * from qiita.qiita_user WHERE email = %s", ['*****@*****.**']) self.assertEqual(obs, [])
def reset_test_database(wrapped_fn): """Decorator that drops the qiita schema, rebuilds and repopulates the schema with test data, then executes wrapped_fn """ conn_handler = SQLConnectionHandler() def decorated_wrapped_fn(*args, **kwargs): # Drop the schema conn_handler.execute("DROP SCHEMA qiita CASCADE") # Create the schema with open(LAYOUT_FP, 'U') as f: conn_handler.execute(f.read()) # Initialize the database with open(INITIALIZE_FP, 'U') as f: conn_handler.execute(f.read()) # Populate the database with open(POPULATE_FP, 'U') as f: conn_handler.execute(f.read()) # Execute the wrapped function return wrapped_fn(*args, **kwargs) return decorated_wrapped_fn
# 23 Nov, 2014 # This patch creates all the qiime mapping files for the existing # prep templates from qiita_db.util import get_mountpoint from qiita_db.sql_connection import SQLConnectionHandler from qiita_db.metadata_template import PrepTemplate conn_handler = SQLConnectionHandler() _id, fp_base = get_mountpoint('templates')[0] for prep_template_id in conn_handler.execute_fetchall( "SELECT prep_template_id FROM qiita.prep_template"): prep_template_id = prep_template_id[0] pt = PrepTemplate(prep_template_id) study_id = pt.study_id for _, fpt in pt.get_filepaths(): pt.create_qiime_mapping_file(fpt)
def setUp(self): super(DecoratedClass, self).setUp() self.conn_handler = SQLConnectionHandler()
def postgres_test(**kwargs): """Open a connection and query postgres""" from qiita_db.sql_connection import SQLConnectionHandler c = SQLConnectionHandler() return c.execute_fetchone("SELECT 42")[0]