def test_Query_remote_mpl4(self):
self._set_remote()
p = 'nsa.z < 0.12 and ifu.name = 19*'
q = Query(searchfilter=p, mode='remote')
r = q.run()
self.assertEqual([], q.joins)
self.assertEqual(163, r.totalcount) # MPL-4 count
class TestResultsBase(MarvinTest):
@classmethod
def setUpClass(cls):
super(TestResultsBase, cls).setUpClass()
@classmethod
def tearDownClass(cls):
pass
def setUp(self):
self._reset_the_config()
self.set_sasurl('local')
self.mode = self.init_mode
config.setMPL('MPL-5')
config.forceDbOn()
self.filter = 'nsa.z < 0.1 and cube.plate==8485'
self.columns = [
'cube.mangaid', 'cube.plate', 'cube.plateifu', 'ifu.name', 'nsa.z'
]
self.remotecols = [u'mangaid', u'plate', u'plateifu', u'name', u'z']
self.coltoparam = OrderedDict([('mangaid', 'cube.mangaid'),
('plate', 'cube.plate'),
('plateifu', 'cube.plateifu'),
('name', 'ifu.name'), ('z', 'nsa.z')])
self.paramtocol = OrderedDict([('cube.mangaid', 'mangaid'),
('cube.plate', 'plate'),
('cube.plateifu', 'plateifu'),
('ifu.name', 'name'), ('nsa.z', 'z')])
self.res = (u'1-209232', 8485, u'8485-1901', u'1901', 0.0407447)
self.resdict = {
'1': (u'1-43148', 8135, u'8135-6101', u'6101', 0.0108501),
'10': (u'1-167079', 8459, u'8459-1901', u'1901', 0.015711),
'11': (u'1-167075', 8459, u'8459-12704', u'12704', 0.0158584),
'21': (u'1-113567', 7815, u'7815-12701', u'12701', 0.0167432),
'31': (u'1-322048', 8552, u'8552-12705', u'12705', 0.0172298),
'36': (u'1-252151', 8335, u'8335-9102', u'9102', 0.0174864),
'41': (u'1-378182', 8134, u'8134-12705', u'12705', 0.0178659),
'46': (u'1-252126', 8335, u'8335-3703', u'3703', 0.0181555)
}
self.q = Query(searchfilter=self.filter, mode=self.mode)
def tearDown(self):
pass
def _set_remote(self, mode='local', limit=100):
self.mode = 'remote'
self.q = Query(searchfilter=self.filter, mode='remote', limit=limit)
def _run_query(self):
r = self.q.run()
r.sort('z', order='desc')
plateifu = r.getListOf('plateifu')
index = plateifu.index(self.plateifu)
newres = r.results[index]
self.assertEqual(self.res, newres)
return r
def test_dap_query_abs_g_r_remote(self):
# This uses MPL-4 (it will return 4 results if MPL-5)
self._set_remote()
p = 'abs_g_r>-1'
q = Query(searchfilter=p, mode=self.mode)
r = q.run()
self.assertEqual(1389, r.totalcount)
def test_quality_queries(self, sf, qual, flags, count):
q = Query(search_filter=sf, quality=qual, release='MPL-5')
sql = q.show()
for flag in flags.split(','):
assert flag.strip() in sql
r = q.run()
assert r.results is not None
assert r.totalcount == count
def _fail_query(self, errmsg, tracemsg, *args, **kwargs):
with self.assertRaises(MarvinError) as cm:
q = Query(**kwargs)
r = q.run()
self.assertIn(errmsg, str(cm.exception))
self.assertIsNotNone(config._traceback)
self.assertIsNotNone(bconfig.traceback)
self.assertIn(tracemsg, config._traceback)
def test_success(self, query, rps):
query = Query(searchfilter=query.searchfilter,
returnparams=rps,
mode=query.mode)
assert 'nsa.z' in query.params
#assert set(rps).issubset(set(query.params))
res = query.run()
assert all([p in res.columns for p in rps]) is True
def test_Query_only_drpver(self):
p = 'cube.plate==8485 and spaxel.x > 5'
q = Query(searchfilter=p)
r = q.run()
self.assertEqual(self.plate, r.getListOf('cube.plate')[0])
self.assertEqual(self.mangaid, r.getListOf('cube.mangaid')[0])
self.assertIn('drpalias', str(q.query.whereclause))
self.assertNotIn('dapalias', str(q.query.whereclause))
def test_sort(self, query, sortparam, order):
data = query.expdata['queries']['nsa.z < 0.1']['sorted']
query = Query(search_filter=query.search_filter, mode=query.mode, sort=sortparam, order=order)
res = query.run()
if order == 'asc':
redshift = data['1'][-1]
else:
redshift = data['last'][-1]
assert res.results['z'][0] == redshift
def test_bad_queries(self, expmode, badquery, errmsg):
if expmode is None:
pytest.skip('cannot use queries in local mode without a db')
with pytest.raises(MarvinError) as cm:
query = Query(searchfilter=badquery, mode=expmode)
res = query.run()
assert cm.type == MarvinError
assert errmsg in str(cm.value)
def test_skipdefault(self, query, rps):
query = Query(searchfilter=query.searchfilter,
returnparams=rps,
mode=query.mode)
assert len(query._returnparams) == len(rps)
assert len(query.params) == 6
res = query.run()
assert len(res.returnparams) == len(rps)
assert len(res.columns) == 6
def test_target_queries(self, sf, targ, flags, count):
q = Query(search_filter=sf, targets=targ, release='MPL-4')
sql = q.show()
for flag in flags.split(','):
ff = flag.strip()
assert (ff in sql or ff.replace('%', '%%') in sql)
r = q.run()
assert r.results is not None
assert r.totalcount == count
def test_results_returntype_cube_limit(self):
config.setMPL('MPL-5')
p = 'haflux > 25'
q = Query(searchfilter=p)
r = q.run()
r.convertToTool('cube', limit=5)
self.assertIsNotNone(r.objects)
self.assertEqual(18, r.count)
self.assertEqual(5, len(r.objects))
self.assertEqual(True, isinstance(r.objects[0], Cube))
def fxnr(mode):
if mode == 'remote':
config.forceDbOff()
q = Query(search_filter='nsa.z < 0.1', release='MPL-4', mode=mode)
r = q.run()
yield r
q = None
r = None
if mode == 'remote':
config.forceDbOn()
def test_Query_drpver_and_dapver(self):
p = 'cube.plate==8485 and emline_gflux_ha_6564>25'
q = Query(searchfilter=p)
r = q.run()
tmp = r.sort('emline_gflux_ha_6564')
self.assertEqual(self.plate, r.getListOf('cube.plate')[0])
self.assertEqual(self.mangaid, r.getListOf('cube.mangaid')[0])
self.assertEqual(26.112, r.getListOf('emline_gflux_ha_6564')[0])
self.assertGreaterEqual(r.count, 6)
self.assertIn('drpalias', str(q.query.whereclause))
self.assertIn('dapalias', str(q.query.whereclause))
def test_get_success(self, query, objtype, tool):
if query.mode == 'remote' and config.db is None:
pytest.skip('skipping weird case where nodb, remote mode tried to load a local file')
if config.release == 'MPL-4' and objtype == 'modelcube':
pytest.skip('no modelcubes in mpl-4')
query = Query(search_filter=query.search_filter, return_type=objtype, mode=query.mode, release=query.release)
res = query.run()
assert res.objects is not None
assert len(res.results) == len(res.objects)
assert isinstance(res.objects[0], tool) is True
def results(query, request):
searchfilter = request.param if hasattr(
request, 'param') else 'nsa.z < 0.1 and cube.plate==8485'
q = Query(searchfilter=searchfilter,
mode=query.mode,
limit=10,
release=query._release)
r = q.run()
r.expdata = query.expdata
yield r
r = None
def test_bad_queries(self, expmode, badquery, errmsg):
if expmode is None:
pytest.skip('cannot use queries in local mode without a db')
set_the_config(config.release)
with pytest.raises((KeyError, MarvinError)) as cm:
query = Query(search_filter=badquery, mode=expmode)
res = query.run()
assert cm.type == KeyError or cm.type == MarvinError
assert errmsg in str(cm.value)
def test_get_list_all(self, results):
q = Query(search_filter=results.search_filter,
mode=results.mode,
limit=1,
release=results.release,
return_params=results.return_params)
r = q.run(start=0, end=1)
assert r.count == 1
mangaids = r.getListOf('mangaid', return_all=True)
assert len(mangaids) == r.totalcount
assert len(mangaids) == results.expdata['queries'][
results.search_filter]['count']
def _set_modes(self, expmode=None):
p = 'nsa.z < 0.1 and cube.plate == 8485'
q = Query(searchfilter=p, mode=self.mode)
r = q.run()
# this part selects 8485-1901
r.sort('z')
r.results = r.results[-4:]
r.convertToTool('cube', limit=1)
self.assertEqual(expmode, q.mode)
self.assertEqual(expmode, r.mode)
self.assertEqual(q.mode, r.mode)
self.assertEqual(expmode, r.objects[0].mode)
def test_badparams(self, query, expmode, rps, errmsg):
# set error type based on query mode
if expmode == 'remote':
error = MarvinError
else:
error = KeyError
with pytest.raises(error) as cm:
query = Query(searchfilter=query.searchfilter,
returnparams=[rps],
mode=query.mode)
res = query.run()
assert cm.type == error
assert errmsg in str(cm.value)
def results(query, request):
searchfilter = request.param if hasattr(request,
'param') else 'nsa.z < 0.1'
q = Query(search_filter=searchfilter,
mode=query.mode,
limit=10,
release=query.release)
if q.mode == 'remote':
pytest.xfail(
'cannot control for DAP spaxel queries on server side; failing all remotes until then'
)
r = q.run()
r.expdata = query.expdata
yield r
r = None
def _query_return_type(self, rt=None, mode='local'):
if rt == 'cube':
tool = Cube
elif rt == 'maps':
tool = Maps
elif rt == 'spaxel':
tool = Spaxel
if mode == 'remote':
self._set_remote()
config.setMPL('MPL-5')
p = 'haflux > 25'
q = Query(searchfilter=p, returntype=rt, mode=mode)
r = q.run()
self.assertIsNotNone(r.objects)
self.assertEqual(18, r.count)
self.assertEqual(len(r.results), len(r.objects))
self.assertEqual(True, isinstance(r.objects[0], tool))
def _dap_query_1(self,
count,
table=None,
name='emline_gflux_ha_6564',
classname='SpaxelProp',
allspax=None):
classname = 'Clean{0}'.format(classname) if not allspax else classname
if table:
key = '{0}.{1}'.format(table, name)
else:
key = '{0}'.format(name)
p = '{0} > 25 and cube.plate == 8485'.format(key)
q = Query(searchfilter=p,
returnparams=['spaxelprop.emline_gflux_hb_4862'],
allspaxels=allspax)
r = q.run()
self.assertEqual(
classname,
q.marvinform._param_form_lookup[key].Meta.model.__name__)
self.assertEqual(count, r.totalcount)
def test_dap_query_2_remote(self):
self._set_remote()
p = 'npergood(spaxelprop.emline_gflux_ha_6564 > 5) >= 20'
q = Query(searchfilter=p, mode=self.mode)
r = q.run()
self.assertEqual(8, r.totalcount)
def test_Query_drp_but_nomaps(self):
p = 'cube.plate < 8400'
q = Query(searchfilter=p)
r = q.run()
self.assertIn('drpalias', str(q.query.whereclause))
self.assertNotIn('dapalias', str(q.query.whereclause))
def test_Query_remote_no_traceback(self):
self._set_remote(mode='local')
p = 'nsa.z < 0.1'
q = Query(searchfilter=p)
r = q.run()
self.assertIsNone(config._traceback)
def test_function_queries(self, sf):
q = Query(search_filter=sf)
r = q.run()
assert r.results is not None
def test_dap_query_2(self):
p = 'npergood(spaxelprop.emline_gflux_ha_6564 > 5) >= 20'
q = Query(searchfilter=p)
r = q.run()
self.assertEqual(8, r.totalcount)
