def provision_public_group():
"""If public group name is set in the config file, create it."""
env, cfg = load_env()
public_group_name = cfg['misc.public_group_name']
pg = Group.query.filter(Group.name == public_group_name).first()
if pg is None:
DBSession().add(Group(name=public_group_name))
DBSession().commit()
def create_token(ACLs, user_id, name):
t = Token(permissions=ACLs, name=name)
u = User.query.get(user_id)
u.tokens.append(t)
t.created_by = u
DBSession().add(u)
DBSession().add(t)
DBSession().commit()
return t.id
def acls(obj, create, extracted, **kwargs):
if not create:
return
if extracted:
for acl in extracted:
obj.acls.append(acl)
DBSession().add(obj)
DBSession().commit()
def roles(obj, create, extracted, **kwargs):
if not create:
return
if extracted:
for role in extracted:
obj.roles.append(role)
DBSession().add(obj)
DBSession().commit()
def teardown(stream_id):
# Fetch fresh instance of stream
stream = (DBSession().execute(
sa.select(Stream).filter(
Stream.id == stream_id)).scalars().first())
if stream is not None:
# If it is, delete it
DBSession().delete(stream)
DBSession().commit()
def streams(obj, create, extracted, **kwargs):
if not create:
return
if extracted:
for stream in extracted:
obj.streams.append(stream)
DBSession().add(obj)
DBSession().commit()
def public_groupuser(public_group, user):
user.groups.append(public_group)
DBSession().commit()
return (
DBSession()
.query(GroupUser)
.filter(GroupUser.group_id == public_group.id, GroupUser.user_id == user.id)
.first()
)
def groups(obj, create, extracted, **kwargs):
if not create:
return
if extracted:
for group in extracted:
obj.groups.append(group)
DBSession().add(obj)
DBSession().commit()
def public_source_two_groups(public_group, public_group2):
obj = ObjFactory(groups=[public_group, public_group2])
sources = []
for group in [public_group, public_group2]:
source = Source(obj_id=obj.id, group_id=group.id)
sources.append(source)
DBSession.add(source)
DBSession.commit()
yield obj
ObjFactory.teardown(obj)
def teardown(invitation):
if is_already_deleted(invitation, Invitation):
return
invited_by = invitation.invited_by.id
DBSession().delete(invitation)
DBSession().commit()
UserFactory.teardown(invited_by)
def teardown(notification):
if is_already_deleted(notification, UserNotification):
return
user = notification.user.id
DBSession().delete(notification)
DBSession().commit()
UserFactory.teardown(user)
def test_public_source_page_null_z(driver, user, public_source, public_group):
public_source.redshift = None
DBSession().add(public_source)
DBSession().commit()
driver.get(f"/become_user/{user.id}") # TODO decorator/context manager?
driver.get(f"/source/{public_source.id}")
driver.wait_for_xpath(f'//div[text()="{public_source.id}"]')
driver.wait_for_xpath('//*[text()="Export Bold Light Curve to CSV"]', 20)
driver.wait_for_xpath('//span[contains(text(), "Fe III")]')
driver.wait_for_xpath(f'//span[text()="{public_group.name}"]')
def test_token_user_post_get_thumbnail(upload_data_token, public_group,
ztf_camera):
obj_id = str(uuid.uuid4())
status, data = api(
'POST',
'sources',
data={
'id': obj_id,
'ra': 234.22,
'dec': -22.33,
'redshift': 3,
'transient': False,
'ra_dis': 2.3,
'group_ids': [public_group.id],
},
token=upload_data_token,
)
assert status == 200
assert data['data']['id'] == obj_id
orig_source_thumbnail_count = len(
DBSession.query(Obj).filter(Obj.id == obj_id).first().thumbnails)
data = base64.b64encode(
open(os.path.abspath('skyportal/tests/data/14gqr_new.png'),
'rb').read())
ttype = 'new'
status, data = api(
'POST',
'thumbnail',
data={
'obj_id': obj_id,
'data': data,
'ttype': ttype
},
token=upload_data_token,
)
assert status == 200
assert data['status'] == 'success'
thumbnail_id = data['data']['id']
assert isinstance(thumbnail_id, int)
status, data = api('GET',
f'thumbnail/{thumbnail_id}',
token=upload_data_token)
assert status == 200
assert data['status'] == 'success'
assert data['data']['type'] == 'new'
assert (DBSession.query(Thumbnail).filter(
Thumbnail.id == thumbnail_id).first().obj.id) == obj_id
assert (len(
DBSession.query(Obj).filter(Obj.id == obj_id).first().thumbnails) ==
orig_source_thumbnail_count + 1)
def create_token(group_id, permissions=[], created_by_id=None, name=None):
group = Group.query.get(group_id)
t = Token(acl_ids=permissions, created_by_id=created_by_id, name=name)
t.groups.append(group)
if created_by_id:
u = User.query.get(created_by_id)
u.tokens.append(t)
DBSession().add(u)
DBSession().add(t)
DBSession().commit()
return t.id
def public_group2_sedm_allocation(sedm, public_group2):
allocation = Allocation(
instrument=sedm,
group=public_group2,
pi=str(uuid.uuid4()),
proposal_id=str(uuid.uuid4()),
hours_allocated=100,
)
DBSession().add(allocation)
DBSession().commit()
return allocation
def public_candidate(public_filter, user):
obj = ObjFactory(groups=[public_filter.group])
candidate = Candidate(
obj=obj,
filter=public_filter,
passed_at=datetime.utcnow() - timedelta(seconds=np.random.randint(0, 100)),
uploader_id=user.id,
)
DBSession.add(candidate)
DBSession.commit()
yield obj
ObjFactory.teardown(obj)
def public_candidate2(public_filter, user):
obj = ObjFactory(groups=[public_filter.group])
DBSession.add(
Candidate(
obj=obj,
filter=public_filter,
passed_at=datetime.utcnow() -
timedelta(seconds=np.random.randint(0, 100)),
uploader_id=user.id,
))
DBSession.commit()
return obj
def teardown(allocation):
if is_already_deleted(allocation, Allocation):
return
instrument = allocation.instrument
group = allocation.group.id
DBSession().delete(allocation)
DBSession().commit()
InstrumentFactory.teardown(instrument)
GroupFactory.teardown(group)
def teardown(notification):
if is_already_deleted(notification, SourceNotification):
return
source = notification.source
sent_by = notification.sent_by.id
DBSession().delete(notification)
DBSession().commit()
ObjFactory.teardown(source)
UserFactory.teardown(sent_by)
def teardown(run):
if is_already_deleted(run, ObservingRun):
return
owner = run.owner.id
instrument = run.instrument
group = run.group.id
DBSession().delete(run)
DBSession().commit()
UserFactory.teardown(owner)
GroupFactory.teardown(group)
InstrumentFactory.teardown(instrument)
def setup_permissions():
"""Create default ACLs/Roles needed by application.
If a given ACL or Role already exists, it will be skipped."""
all_acls = [ACL.create_or_get(a) for a in all_acl_ids]
DBSession().add_all(all_acls)
DBSession().commit()
for r, acl_ids in role_acls.items():
role = Role.create_or_get(r)
role.acls = [ACL.query.get(a) for a in acl_ids]
DBSession().add(role)
DBSession().commit()
def add_super_user(username):
"""Initializes a super user with full permissions."""
setup_permissions() # make sure permissions already exist
super_user = User.query.filter(User.username == username).first()
if super_user is None:
super_user = User(username=username)
social = TornadoStorage.user.create_social_auth(
super_user, super_user.username, 'google-oauth2')
admin_role = Role.query.get('Super admin')
if admin_role not in super_user.roles:
super_user.roles.append(admin_role)
DBSession().add(super_user)
DBSession().commit()
def teardown(spectrum):
if is_already_deleted(spectrum, Spectrum):
return
instrument = spectrum.instrument
reducers = spectrum.reducers
observers = spectrum.observers
for reducer in reducers:
UserFactory.teardown(reducer.id)
for observer in observers:
UserFactory.teardown(observer.id)
DBSession().delete(spectrum)
DBSession().commit()
InstrumentFactory.teardown(instrument)
def group_admin_user(public_group, public_stream):
user = UserFactory(
groups=[public_group],
roles=[models.Role.query.get("Group admin")],
streams=[public_stream],
)
user_id = user.id
group_user = (DBSession().query(GroupUser).filter(
GroupUser.group_id == public_group.id,
GroupUser.user_id == user.id).first())
group_user.admin = True
DBSession().commit()
yield user
UserFactory.teardown(user_id)
def teardown(request):
if is_already_deleted(request, FollowupRequest):
return
requester = request.requester.id
allocation = request.allocation
obj = request.obj
DBSession().delete(request)
DBSession().commit()
UserFactory.teardown(request.last_modified_by.id)
UserFactory.teardown(requester)
AllocationFactory.teardown(allocation)
ObjFactory.teardown(obj)
def teardown(classification):
if is_already_deleted(classification, Classification):
return
author = classification.author.id
obj = classification.obj
taxonomy = classification.taxonomy.id
DBSession().delete(classification)
DBSession().commit()
UserFactory.teardown(author)
ObjFactory.teardown(obj)
TaxonomyFactory.teardown(taxonomy)
def test_observing_run_skycam_component(driver, super_admin_user,
public_source, red_transients_run,
super_admin_token):
driver.get(f"/become_user/{super_admin_user.id}")
status, data = post_assignment(
public_source,
red_transients_run,
priority="3",
comment="Observe please",
token=super_admin_token,
)
assert status == 200
assert data["status"] == "success"
driver.get(f"/run/{red_transients_run.id}")
# 20 second timeout to give the backend time to perform ephemeris calcs
driver.wait_for_xpath('//*[text()="Current Conditions"]', timeout=20)
driver.wait_for_xpath(
f'//img[contains(@src, "{red_transients_run.instrument.telescope.skycam_link}")]'
)
red_transients_run.instrument.telescope.skycam_link = (
'http://this.is.a.bad.link.web.biz')
DBSession().add(red_transients_run.instrument.telescope)
DBSession().commit()
driver.get(f"/run/{red_transients_run.id}")
driver.wait_for_xpath(
f'//b[contains(text(), "{red_transients_run.instrument.name}")]')
driver.wait_for_xpath('//*[text()="Current Conditions"]')
fallback_url = "static/images/static.jpg"
driver.wait_for_xpath(f'//img[contains(@src, "{fallback_url}")]')
red_transients_run.instrument.telescope.skycam_link = None
DBSession().add(red_transients_run.instrument.telescope)
DBSession().commit()
driver.get(f"/run/{red_transients_run.id}")
# 20 second timeout to give the backend time to perform ephemeris calcs
driver.wait_for_xpath(
f'//b[contains(text(), "{red_transients_run.instrument.name}")]',
timeout=20)
driver.wait_for_xpath_to_disappear('//*[text()="Current Conditions"]')
driver.wait_for_xpath_to_disappear(
f'//img[contains(@src, "{red_transients_run.instrument.telescope.skycam_link}")]'
)
def test_javascript_sexagesimal_conversion(public_source, driver, user):
public_source.ra = 342.0708127
public_source.dec = 56.1130711
DBSession().commit()
driver.get(f"/become_user/{user.id}")
driver.get(f"/source/{public_source.id}")
driver.wait_for_xpath('//*[contains(., "22:48:17.00")]')
driver.wait_for_xpath('//*[contains(., "+56:06:47.06")]')
public_source.ra = 75.6377796
public_source.dec = 15.606709
DBSession().commit()
driver.refresh()
driver.wait_for_xpath('//*[contains(., "05:02:33.07")]')
driver.wait_for_xpath('//*[contains(., "+15:36:24.15")]')
def teardown(assignment):
if is_already_deleted(assignment, ClassicalAssignment):
return
requester = assignment.requester.id
run = assignment.run
obj = assignment.obj
last_modified_by = assignment.last_modified_by.id
DBSession().delete(assignment)
DBSession().commit()
ObservingRunFactory.teardown(run)
ObjFactory.teardown(obj)
UserFactory.teardown(last_modified_by)
UserFactory.teardown(requester)
def teardown(obj):
if is_already_deleted(obj, Obj):
return
instruments = obj.instruments
comment_authors = list(map(lambda x: x.author.id, obj.comments))
for author in comment_authors:
UserFactory.teardown(author)
spectra = DBSession().query(Spectrum).filter(Spectrum.obj_id == obj.id).all()
for spectrum in spectra:
SpectrumFactory.teardown(spectrum)
DBSession().delete(obj)
DBSession().commit()
for instrument in instruments:
InstrumentFactory.teardown(instrument)
