def dataset_relationships(test_database):
user = models.User(username="******",
email="*****@*****.**",
password_hash="123")
db.session.add(user)
db.session.commit()
group = models.Group(group_code="local", group_name="local")
group2 = models.Group(group_code="local2", group_name="local2")
family = models.Family(
family_codename="test",
created_by_id=user.user_id,
updated_by_id=user.user_id,
)
participant = models.Participant(
participant_codename="test",
sex=models.Sex.Female,
participant_type=models.ParticipantType.Proband,
institution_id=1,
created_by_id=user.user_id,
updated_by_id=user.user_id,
)
family.participants.append(participant)
sample = models.TissueSample(
tissue_sample_type=models.TissueSampleType.Blood,
created_by_id=user.user_id,
updated_by_id=user.user_id,
)
participant.tissue_samples.append(sample)
dataset_fields = {
"dataset_type": "WES",
"condition": models.DatasetCondition.Somatic,
"created_by_id": user.user_id,
"updated_by_id": user.user_id,
"notes": "test_dataset_counts",
}
dataset_1 = models.Dataset(**dataset_fields)
dataset_2 = models.Dataset(**dataset_fields)
# each dataset has 2 groups -- with a direct join on groups, this will lead to inaccurate result count
# when `limit` is provided
dataset_1.groups.extend([group, group2])
dataset_2.groups.extend([group, group2])
sample.datasets.extend([dataset_1, dataset_2])
db.session.add(dataset_1)
db.session.add(dataset_2)
db.session.commit()
# confirm that there are 2 models in the database meeting these conditions
# `notes` constraint excludes global test datasets from results
assert (models.Dataset.query.filter(
models.Dataset.notes == "test_dataset_counts").count() == 2)
def test_leave_group(self): """ Tests that merged users are removed from all groups """ group = models.Group( assignment=self._assign.key, member=[self.user1.key, self.user2.key, self.user3.key]) group.put() self.merge_users() group = models.Group.query(models.Group.assignment==self._assign.key).get() self.assertEqual(group.member, [self.user1.key, self.user3.key])
def test_remove_group(get_db, add_users):
group = copy.copy(data.groups[0])
group['user_id'] = get_user_id(group['username'])
del group['username']
db.session.add(models.Group(**group))
db.session.commit()
r = app.test_client().delete(
'/rest/groups/1', headers={'X-Api-Key': get_token(data.users[1])})
assert r.status_code == 204
assert not app.test_client().get('/rest/groups').json
def creategroup():
form = CreateGroupForm()
if form.validate_on_submit():
group_hashed_password = bcrypt.generate_password_hash(form.password.data).decode('utf-8')
flash('The group %s has been created.'%(form.groupName.data))
g = models.Group(groupName=form.groupName.data, password=group_hashed_password, date_created=datetime.datetime.utcnow())
db.session.add(g)
g.accs.append(current_user)
db.session.commit()
logging.info('{} created and joined the {} group.'.format(current_user.username, g.groupName))
return redirect('/groups')
return render_template('creategroup.html', title='Squad Journal - Create Group', form=form)
def test_create_group(self):
"""Merging groups keeps the final submission for that group."""
self.submit(self.backups['first'])
self.assertFinalSubmission('student0', self.backups['first'])
self.assertFinalSubmission('student1', None)
members = [self.accounts[s].key for s in ('student0', 'student1')]
models.Group(assignment=self.assign.key, member=members).put()
for member in members:
member.get().update_final_submission(self.assign)
self.assertFinalSubmission('student0', self.backups['first'])
self.assertFinalSubmission('student1', self.backups['first'])
def test_add_rating_fields(get_db, add_users):
group = copy.copy(data.groups[0])
group['user_id'] = get_user_id(group['username'])
del group['username']
db.session.add(models.Group(**group))
db.session.commit()
rf = copy.copy(data.rating_fields[0])
r1 = app.test_client().post(
'/rest/rating_fields',
json=rf,
headers={'X-Api-Key': get_token(data.users[1])})
rf['id'] = 1
assert r1.status_code == 201
assert r1.json == rf
def setUp(self):
self.app = create_app('testing')
self.app_context = self.app.app_context()
self.app_context.push()
db.create_all()
self.client = self.app.test_client()
# Create a user and a group
james = models.User(first_name='james',
last_name='hawkins',
userid='jhawkins')
admin = models.Group(name='admin')
james.add_group(admin)
db.session.add(james)
db.session.add(admin)
db.session.commit()
def addgroup():
form = forms.Group_add()
if form.validate_on_submit():
newbook = models.Group(
id=form.id.data,
room=form.room.data,
id1=form.id1.data,
id2=form.id2.data,
id3=form.id3.data,
id4=form.id4.data,
id5=form.id5.data,
id6=form.id6.data,
)
db.session.add(newbook)
db.session.commit()
flash('操作成功')
return render_template('addgroup.html', form=form)
def test_add_group_student(get_db, add_users):
group = copy.copy(data.groups[0])
group['user_id'] = get_user_id(group['username'])
del group['username']
db.session.add(models.Group(**group))
db.session.commit()
gs = copy.copy(data.groups_students[0])
gs['group_id'] = get_group_id(gs['group_name'])
gs['user_id'] = get_user_id(gs['username'])
del gs['group_name']
del gs['username']
r1 = app.test_client().post(
'/rest/group_student',
json=gs,
headers={'X-Api-Key': get_token(data.users[1])})
assert r1.status_code == 201
def test_get_group(test_database, client, login_as):
# Test invalid group_code
login_as("admin")
assert client.get("/api/groups/hahah").status_code == 404
group_2 = models.Group(group_code="alas", group_name="...")
db.session.add(group_2)
db.session.commit()
# Test wrong permissions
login_as("user")
assert client.get("/api/groups/alas").status_code == 404
# Test and validate success based on user's permissions
response = client.get("/api/groups/ach")
assert response.status_code == 200
assert response.get_json()["group_name"] == "Alberta"
def create_group():
form = NewGroupForm()
if form.validate_on_submit():
group_name = form.name.data
master_key = form.master_key.data
public_keys = form.public_keys.data
challenge = form.answer.data
if models.Group.query.filter_by(name = group_name).first() is None:
#validate challenge
if BoyenScheme.is_signature_valid(data_for('/register_group.html')['challenge'],
challenge,
group_name,
public_keys = public_keys,
master_key = master_key):
#if (verify_boyen(master_key, public_keys,
# data_for('/register_group.html')['challenge'],
# challenge)):
##add group
#as author
db.session.add(models.Author(name = group_name))
db.session.commit()
#as group
gid = models.Author.query.filter_by(name = group_name).first().id
db.session.add(models.Group(id = gid, name = group_name))
db.session.commit()
#save keys
gid = str(gid)
with open(os.path.join(app.config['GROUP_KEYS_FOLDER'],
gid + '.mkey'), 'w') as f:
f.write(master_key)
with open(os.path.join(app.config['GROUP_KEYS_FOLDER'],
gid + '.pkeys'), 'w') as f:
f.write(public_keys)
return redirect('/')
else:
flash('Fallo de validación, verifique que las claves y la firma son correctas')
else:
flash(u'Grupo ya existe con ese nombre')
else:
flash_errors(form)
return render_template('register_group.html', data=data_for('/register_group.html'), form=form)
def test_add_publication_permission_group(get_db, add_users, add_publications):
group = copy.copy(data.groups[0])
group['user_id'] = get_user_id(group['username'])
del group['username']
db.session.add(models.Group(**group))
db.session.commit()
ppg = copy.copy(data.publications_permissions_group[0])
ppg['group_id'] = get_group_id(ppg['group_name'])
ppg['publication_id'] = get_publication_id(ppg['publication_name'])
del ppg['group_name']
del ppg['publication_name']
r1 = app.test_client().post(
'/rest/publications_permissions_groups',
json=ppg,
headers={'X-Api-Key': get_token(data.users[1])})
assert r1.status_code == 201
def test_remove_publication_permission_group(get_db, add_users,
add_publications):
group = copy.copy(data.groups[0])
group['user_id'] = get_user_id(group['username'])
del group['username']
db.session.add(models.Group(**group))
db.session.commit()
ppg = copy.copy(data.publications_permissions_group[0])
ppg['group_id'] = get_group_id(ppg['group_name'])
ppg['publication_id'] = get_publication_id(ppg['publication_name'])
del ppg['group_name']
del ppg['publication_name']
db.session.add(models.PublicationPermissionGroup(**ppg))
db.session.commit()
r1 = app.test_client().delete(
'/rest/publications_permissions_groups/1',
headers={'X-Api-Key': get_token(data.users[1])})
assert r1.status_code == 204
assert not app.test_client().get(
'/rest/publications_permissions_groups').json
def test_leave_group(self):
"""
Tests that merging two users makes the merged user leave groups.
"""
user_obj, user_obj2 = self.get_user_pair()
# Cause groups must have 2 people
user_obj3 = self.get_basic_user()
user_obj3.email = ['*****@*****.**']
user_obj3.put()
user_obj4 = self.get_basic_user()
user_obj4.email = ['*****@*****.**']
user_obj4.put()
group = models.Group(
member=[user_obj2.key, user_obj3.key, user_obj4.key],
assignment=self.assign.key)
group.put()
self.merge_user(user_obj, user_obj2)
group = group.key.get()
self.assertIsNotNone(group)
self.assertNotIn(user_obj2.key, group.member)
def main():
fake = Factory.create('es_ES')
fake.seed(1024)
print(u'Populate the database with sample data')
print(u' - Creating groups')
grupos = [None]
for i in range(1, 4): # 3 Grupos
grp = models.Group.query.get(i)
if not grp:
grp = models.Group(
id_group=i,
name_group=fake.company(),
url=fake.url(),
)
print(u' - {}'.format(grp), end=' ')
db.session.add(grp)
db.session.commit()
print(u'[OK]')
else:
print(u' - {}'.format(grp), end=' ')
print(u'[Skipped]')
grupos.append(grp)
print(u' - Creating users')
users = []
for i in range(1, 24): # Usuarios
usr = models.User.query.get(i)
if not usr:
usr = models.User(
id_user=i,
name=fake.first_name(),
last_name=fake.last_name(),
email=fake.email(),
phone=fake.phone_number(),
address=fake.address(),
rol=random_distribute((95, 5), ('usr', 'adm')),
group=random_distribute((70,10,10,10), grupos),
)
print(u' - {}'.format(usr), end=' ')
db.session.add(usr)
db.session.commit()
print(u'[OK]')
else:
print(u' - {}'.format(usr), end=' ')
print(u'[skipped]')
users.append(usr)
print(u' - Creating devices')
for usr in users: # Usuarios
if not usr.devices:
kind = random_distribute((50, 50), ('nfc', 'mac'))
if kind == 'nfc':
code = fake_nfc_id()
else:
code = fake_mac_address()
dev = models.Device(user=usr, kind=kind, code=code)
print(u' - {}'.format(dev), end=' ')
db.session.add(dev)
db.session.commit()
print(u'[OK]')
else:
dev = usr.devices[0]
print(u' - {}'.format(dev), end=' ')
print(u'[Skipped]')
print(u' - Creating payments for the current month')
today = datetime.date.today()
month, year = today.month, today.year
for usr in users: # Usuarios
pay = models.Payment.query.filter_by(
user=usr,
month=month,
year=year
).first()
if not pay:
pay = models.Payment(
user=usr,
month=month,
year=year,
f_payment=fake.date_time_this_year(),
amount=decimal.Decimal('10.00'),
)
print(u' - {}'.format(pay), end=' ')
db.session.add(pay)
db.session.commit()
print(u'[OK]')
else:
print(u' - {}'.format(pay), end=' ')
print(u'[Skipped]')
def make_invited_group(assign, members):
return models.Group(member=[members[0].key],
invited=[members[1].key],
assignment=assign.key)
def make_group(assign, members):
return models.Group(member=[m.key for m in members],
assignment=assign.key)
def create_group(db: Session, group: schemas.GroupCreate) -> models.Group:
db_group = models.Group(**group.dict())
db.add(db_group)
db.commit()
db.refresh(db_group)
return db_group
def setUp(self): #pylint: disable=invalid-name
super(BaseUnitTest, self).setUp()
self.accounts = self.get_accounts()
for user in self.accounts.values():
user.put()
self.courses = {
"first":
models.Course(institution="UC Awesome a",
instructor=[self.accounts['admin'].key]),
"second":
models.Course(institution="UC Awesome b",
instructor=[self.accounts['admin'].key]),
}
for course in self.courses.values():
course.put()
self.enroll("student0", "first", STUDENT_ROLE)
self.enroll("student1", "first", STUDENT_ROLE)
self.enroll("student2", "second", STUDENT_ROLE)
self.enroll("staff", "first", STAFF_ROLE)
self.assignments = {
"first":
models.Assignment(name="first",
points=3,
creator=self.accounts["admin"].key,
course=self.courses['first'].key,
display_name="first display",
templates="{}",
max_group_size=3,
due_date=datetime.datetime.now()),
"second":
models.Assignment(name="second",
points=3,
creator=self.accounts["admin"].key,
course=self.courses['second'].key,
display_name="second display",
templates="{}",
max_group_size=3,
due_date=datetime.datetime.now()),
"empty":
models.Assignment(name="empty",
points=3,
creator=self.accounts["admin"].key,
course=self.courses['first'].key,
display_name="second display",
templates="{}",
max_group_size=4,
due_date=datetime.datetime.now()),
}
for assign in self.assignments.values():
assign.put()
self.backups = {
"first":
models.Backup(
submitter=self.accounts["student0"].key,
assignment=self.assignments["first"].key,
),
"second":
models.Backup(
submitter=self.accounts["student1"].key,
assignment=self.assignments["first"].key,
),
"third":
models.Backup(
submitter=self.accounts["student2"].key,
assignment=self.assignments["second"].key,
),
}
for backup in self.backups.values():
backup.put()
self.submissions = {
"first": models.Submission(backup=self.backups["first"].key),
"second": models.Submission(backup=self.backups["second"].key),
"third": models.Submission(backup=self.backups["third"].key),
}
for submission in self.submissions.values():
submission.put()
self.groups = {
'group1':
models.Group(member=[
self.accounts['student0'].key, self.accounts['student1'].key
],
assignment=self.assignments['first'].key)
}
self.groups['group1'].put()
group_backup = models.Backup(
submitter=self.accounts['student0'].key,
assignment=self.assignments['first'].key,
)
group_backup.put()
self.backups['group'] = group_backup
group_submission = models.Submission(backup=group_backup.key)
group_submission.put()
self.submissions['group'] = group_submission
self.queues = {
"first":
models.Queue(
assignment=self.assignments["first"].key,
assigned_staff=[self.accounts["staff"].key],
),
}
for queue in self.queues.values():
queue.put()
self.diffs = {"first": models.Diff()}
for diff in self.diffs.values():
diff.put()
self.comments = {
"first":
models.Comment(author=self.accounts['student0'].key,
diff=self.diffs["first"].key,
message="First comment"),
}
for comment in self.comments.values():
comment.put()
self.user = None