~azzar1/unity/add-show-desktop-key
» Revision
1294.2.70
(compared to revision 1099.1.241)
: ivle/database.py
« back to all changes in this revision
Viewing changes to ivle/database.py
- browse files at revision 1294.2.70
- compare with another revision
- download diff
- download tarball
- view history from revision 1294.2.70
- Committer: William Grant
- Date: 2009-07-05 03:18:14 UTC
- mto: (1294.4.2 ui-the-third)
- mto: This revision was merged to the branch mainline in revision 1353.
- Revision ID: grantw@unimelb.edu.au-20090705031814-yn8oymmawsq0da78
Split out ivle.webapp.admin's routes into annotated functions in ivle.webapp.traversal.
- files added:
- bin/ivle-fetchsubmissions
- ivle/webapp/admin/templates
- ivle/webapp/routing
- ivle/webapp/submit
- files removed:
- ivle/webapp/admin/enrol.html
- ivle/webapp/coremedia/jquery.js
- website
- website/images
- files renamed:
- bin/ivle-makeuser => bin/ivle-adduser
- ivle/conf/mimetypes.py => ivle/mimetypes.py
- files modified:
- bin/ivle-addexercise
added
removed
ivle/database.py
17
17
18
18
# Author: Matt Giuca, Will Grant
19
19
20
"""
21
Database Classes and Utilities for Storm ORM
20
"""Database utilities and content classes.
22
21
23
22
This module provides all of the classes which map to database tables.
24
23
It also provides miscellaneous utility functions for database interaction.
25
24
"""
26
25
27
import md5
26
import hashlib
28
27
import datetime
29
28
30
29
from storm.locals import create_database, Store, Int, Unicode, DateTime, \
31
30
Reference, ReferenceSet, Bool, Storm, Desc
32
from storm.exceptions import NotOneError
31
from storm.expr import Select, Max
32
from storm.exceptions import NotOneError, IntegrityError
33
33
34
import ivle.conf
35
34
from ivle.worksheet.rst import rst
36
35
37
36
__all__ = ['get_store',
38
37
'User',
39
38
'Subject', 'Semester', 'Offering', 'Enrolment',
40
39
'ProjectSet', 'Project', 'ProjectGroup', 'ProjectGroupMembership',
40
'Assessed', 'ProjectSubmission', 'ProjectExtension',
41
41
'Exercise', 'Worksheet', 'WorksheetExercise',
42
42
'ExerciseSave', 'ExerciseAttempt',
43
43
'TestCase', 'TestSuite', 'TestSuiteVar'
50
50
% (self.__class__.__name__, k))
51
51
setattr(self, k, v)
52
52
53
def get_conn_string():
54
"""
55
Returns the Storm connection string, generated from the conf file.
53
def get_conn_string(config):
54
"""Create a Storm connection string to the IVLE database
55
56
@param config: The IVLE configuration.
56
57
"""
57
58
58
59
clusterstr = ''
59
if ivle.conf.db_user:
60
clusterstr += ivle.conf.db_user
61
if ivle.conf.db_password:
62
clusterstr += ':' + ivle.conf.db_password
60
if config['database']['username']:
61
clusterstr += config['database']['username']
62
if config['database']['password']:
63
clusterstr += ':' + config['database']['password']
63
64
clusterstr += '@'
64
65
65
host = ivle.conf.db_host or 'localhost'
66
port = ivle.conf.db_port or 5432
66
host = config['database']['host'] or 'localhost'
67
port = config['database']['port'] or 5432
67
68
68
69
clusterstr += '%s:%d' % (host, port)
69
70
70
return "postgres://%s/%s" % (clusterstr, ivle.conf.db_dbname)
71
72
def get_store():
73
"""
74
Open a database connection and transaction. Return a storm.store.Store
75
instance connected to the configured IVLE database.
76
"""
77
return Store(create_database(get_conn_string()))
71
return "postgres://%s/%s" % (clusterstr, config['database']['name'])
72
73
def get_store(config):
74
"""Create a Storm store connected to the IVLE database.
75
76
@param config: The IVLE configuration.
77
"""
78
return Store(create_database(get_conn_string(config)))
78
79
79
80
# USERS #
80
81
81
82
class User(Storm):
82
"""
83
Represents an IVLE user.
84
"""
83
"""An IVLE user account."""
85
84
__storm_table__ = "login"
86
85
87
86
id = Int(primary=True, name="loginid")
117
116
return self.hash_password(password) == self.passhash
118
117
119
118
@property
119
def display_name(self):
120
"""Returns the "nice name" of the user or group."""
121
return self.fullname
122
123
@property
124
def short_name(self):
125
"""Returns the database "identifier" name of the user or group."""
126
return self.login
127
128
@property
120
129
def password_expired(self):
121
130
fieldval = self.pass_exp
122
131
return fieldval is not None and datetime.datetime.now() > fieldval
159
168
160
169
# TODO: Invitations should be listed too?
161
170
def get_groups(self, offering=None):
171
"""Get groups of which this user is a member.
172
173
@param offering: An optional offering to restrict the search to.
174
"""
162
175
preds = [
163
176
ProjectGroupMembership.user_id == self.id,
164
177
ProjectGroup.id == ProjectGroupMembership.project_group_id,
184
197
'''A sanely ordered list of all of the user's enrolments.'''
185
198
return self._get_enrolments(False)
186
199
200
def get_projects(self, offering=None, active_only=True):
201
"""Find projects that the user can submit.
202
203
This will include projects for offerings in which the user is
204
enrolled, as long as the project is not in a project set which has
205
groups (ie. if maximum number of group members is 0).
206
207
@param active_only: Whether to only search active offerings.
208
@param offering: An optional offering to restrict the search to.
209
"""
210
return Store.of(self).find(Project,
211
Project.project_set_id == ProjectSet.id,
212
ProjectSet.max_students_per_group == None,
213
ProjectSet.offering_id == Offering.id,
214
(offering is None) or (Offering.id == offering.id),
215
Semester.id == Offering.semester_id,
216
(not active_only) or (Semester.state == u'current'),
217
Enrolment.offering_id == Offering.id,
218
Enrolment.user_id == self.id)
219
187
220
@staticmethod
188
221
def hash_password(password):
189
return md5.md5(password).hexdigest()
222
"""Hash a password with MD5."""
223
return hashlib.md5(password).hexdigest()
190
224
191
225
@classmethod
192
226
def get_by_login(cls, store, login):
193
"""
194
Get the User from the db associated with a given store and
195
login.
196
"""
227
"""Find a user in a store by login name."""
197
228
return store.find(cls, cls.login == unicode(login)).one()
198
229
199
230
def get_permissions(self, user):
231
"""Determine privileges held by a user over this object.
232
233
If the user requesting privileges is this user or an admin,
234
they may do everything. Otherwise they may do nothing.
235
"""
200
236
if user and user.admin or user is self:
201
return set(['view', 'edit'])
237
return set(['view', 'edit', 'submit_project'])
202
238
else:
203
239
return set()
204
240
205
241
# SUBJECTS AND ENROLMENTS #
206
242
207
243
class Subject(Storm):
244
"""A subject (or course) which is run in some semesters."""
245
208
246
__storm_table__ = "subject"
209
247
210
248
id = Int(primary=True, name="subjectid")
221
259
return "<%s '%s'>" % (type(self).__name__, self.short_name)
222
260
223
261
def get_permissions(self, user):
262
"""Determine privileges held by a user over this object.
263
264
If the user requesting privileges is an admin, they may edit.
265
Otherwise they may only read.
266
"""
224
267
perms = set()
225
268
if user is not None:
226
269
perms.add('view')
228
271
perms.add('edit')
229
272
return perms
230
273
274
def active_offerings(self):
275
"""Find active offerings for this subject.
276
277
Return a sequence of currently active offerings for this subject
278
(offerings whose semester.state is "current"). There should be 0 or 1
279
elements in this sequence, but it's possible there are more.
280
"""
281
return self.offerings.find(Offering.semester_id == Semester.id,
282
Semester.state == u'current')
283
284
def offering_for_semester(self, year, semester):
285
"""Get the offering for the given year/semester, or None.
286
287
@param year: A string representation of the year.
288
@param semester: A string representation of the semester.
289
"""
290
return self.offerings.find(Offering.semester_id == Semester.id,
291
Semester.year == unicode(year),
292
Semester.semester == unicode(semester)).one()
293
231
294
class Semester(Storm):
295
"""A semester in which subjects can be run."""
296
232
297
__storm_table__ = "semester"
233
298
234
299
id = Int(primary=True, name="semesterid")
248
313
return "<%s %s/%s>" % (type(self).__name__, self.year, self.semester)
249
314
250
315
class Offering(Storm):
316
"""An offering of a subject in a particular semester."""
317
251
318
__storm_table__ = "offering"
252
319
253
320
id = Int(primary=True, name="offeringid")
276
343
self.semester)
277
344
278
345
def enrol(self, user, role=u'student'):
279
'''Enrol a user in this offering.'''
346
"""Enrol a user in this offering.
347
348
Enrolments handle both the staff and student cases. The role controls
349
the privileges granted by this enrolment.
350
"""
280
351
enrolment = Store.of(self).find(Enrolment,
281
352
Enrolment.user_id == user.id,
282
353
Enrolment.offering_id == self.id).one()
307
378
return perms
308
379
309
380
def get_enrolment(self, user):
381
"""Find the user's enrolment in this offering."""
310
382
try:
311
383
enrolment = self.enrolments.find(user=user).one()
312
384
except NotOneError:
314
386
315
387
return enrolment
316
388
389
def get_members_by_role(self, role):
390
return Store.of(self).find(User,
391
Enrolment.user_id == User.id,
392
Enrolment.offering_id == self.id,
393
Enrolment.role == role
394
)
395
396
@property
397
def students(self):
398
return self.get_members_by_role(u'student')
399
317
400
class Enrolment(Storm):
401
"""An enrolment of a user in an offering.
402
403
This represents the roles of both staff and students.
404
"""
405
318
406
__storm_table__ = "enrolment"
319
407
__storm_primary__ = "user_id", "offering_id"
320
408
343
431
# PROJECTS #
344
432
345
433
class ProjectSet(Storm):
434
"""A set of projects that share common groups.
435
436
Each student project group is attached to a project set. The group is
437
valid for all projects in the group's set.
438
"""
439
346
440
__storm_table__ = "project_set"
347
441
348
442
id = Int(name="projectsetid", primary=True)
359
453
return "<%s %d in %r>" % (type(self).__name__, self.id,
360
454
self.offering)
361
455
456
def get_permissions(self, user):
457
return self.offering.get_permissions(user)
458
459
@property
460
def assigned(self):
461
"""Get the entities (groups or users) assigned to submit this project.
462
463
This will be a Storm ResultSet.
464
"""
465
#If its a solo project, return everyone in offering
466
if self.max_students_per_group is None:
467
return self.offering.students
468
else:
469
return self.project_groups
470
362
471
class Project(Storm):
472
"""A student project for which submissions can be made."""
473
363
474
__storm_table__ = "project"
364
475
365
476
id = Int(name="projectid", primary=True)
477
name = Unicode()
478
short_name = Unicode()
366
479
synopsis = Unicode()
367
480
url = Unicode()
368
481
project_set_id = Int(name="projectsetid")
369
482
project_set = Reference(project_set_id, ProjectSet.id)
370
483
deadline = DateTime()
371
484
485
assesseds = ReferenceSet(id, 'Assessed.project_id')
486
submissions = ReferenceSet(id,
487
'Assessed.project_id',
488
'Assessed.id',
489
'ProjectSubmission.assessed_id')
490
372
491
__init__ = _kwarg_init
373
492
374
493
def __repr__(self):
375
return "<%s '%s' in %r>" % (type(self).__name__, self.synopsis,
494
return "<%s '%s' in %r>" % (type(self).__name__, self.short_name,
376
495
self.project_set.offering)
377
496
497
def can_submit(self, principal):
498
return (self in principal.get_projects() and
499
self.deadline > datetime.datetime.now())
500
501
def submit(self, principal, path, revision, who):
502
"""Submit a Subversion path and revision to a project.
503
504
@param principal: The owner of the Subversion repository, and the
505
entity on behalf of whom the submission is being made
506
@param path: A path within that repository to submit.
507
@param revision: The revision of that path to submit.
508
@param who: The user who is actually making the submission.
509
"""
510
511
if not self.can_submit(principal):
512
raise Exception('cannot submit')
513
514
a = Assessed.get(Store.of(self), principal, self)
515
ps = ProjectSubmission()
516
ps.path = path
517
ps.revision = revision
518
ps.date_submitted = datetime.datetime.now()
519
ps.assessed = a
520
ps.submitter = who
521
522
return ps
523
524
def get_permissions(self, user):
525
return self.project_set.offering.get_permissions(user)
526
527
@property
528
def latest_submissions(self):
529
"""Return the latest submission for each Assessed."""
530
return Store.of(self).find(ProjectSubmission,
531
Assessed.project_id == self.id,
532
ProjectSubmission.assessed_id == Assessed.id,
533
ProjectSubmission.date_submitted == Select(
534
Max(ProjectSubmission.date_submitted),
535
ProjectSubmission.assessed_id == Assessed.id,
536
tables=ProjectSubmission
537
)
538
)
539
540
378
541
class ProjectGroup(Storm):
542
"""A group of students working together on a project."""
543
379
544
__storm_table__ = "project_group"
380
545
381
546
id = Int(name="groupid", primary=True)
398
563
return "<%s %s in %r>" % (type(self).__name__, self.name,
399
564
self.project_set.offering)
400
565
566
@property
567
def display_name(self):
568
"""Returns the "nice name" of the user or group."""
569
return self.nick
570
571
@property
572
def short_name(self):
573
"""Returns the database "identifier" name of the user or group."""
574
return self.name
575
576
def get_projects(self, offering=None, active_only=True):
577
'''Find projects that the group can submit.
578
579
This will include projects in the project set which owns this group,
580
unless the project set disallows groups (in which case none will be
581
returned).
582
583
@param active_only: Whether to only search active offerings.
584
@param offering: An optional offering to restrict the search to.
585
'''
586
return Store.of(self).find(Project,
587
Project.project_set_id == ProjectSet.id,
588
ProjectSet.id == self.project_set.id,
589
ProjectSet.max_students_per_group != None,
590
ProjectSet.offering_id == Offering.id,
591
(offering is None) or (Offering.id == offering.id),
592
Semester.id == Offering.semester_id,
593
(not active_only) or (Semester.state == u'current'))
594
595
596
def get_permissions(self, user):
597
if user.admin or user in self.members:
598
return set(['submit_project'])
599
else:
600
return set()
601
401
602
class ProjectGroupMembership(Storm):
603
"""A student's membership in a project group."""
604
402
605
__storm_table__ = "group_member"
403
606
__storm_primary__ = "user_id", "project_group_id"
404
607
413
616
return "<%s %r in %r>" % (type(self).__name__, self.user,
414
617
self.project_group)
415
618
619
class Assessed(Storm):
620
"""A composite of a user or group combined with a project.
621
622
Each project submission and extension refers to an Assessed. It is the
623
sole specifier of the repository and project.
624
"""
625
626
__storm_table__ = "assessed"
627
628
id = Int(name="assessedid", primary=True)
629
user_id = Int(name="loginid")
630
user = Reference(user_id, User.id)
631
project_group_id = Int(name="groupid")
632
project_group = Reference(project_group_id, ProjectGroup.id)
633
634
project_id = Int(name="projectid")
635
project = Reference(project_id, Project.id)
636
637
extensions = ReferenceSet(id, 'ProjectExtension.assessed_id')
638
submissions = ReferenceSet(id, 'ProjectSubmission.assessed_id')
639
640
def __repr__(self):
641
return "<%s %r in %r>" % (type(self).__name__,
642
self.user or self.project_group, self.project)
643
644
@property
645
def is_group(self):
646
"""True if the Assessed is a group, False if it is a user."""
647
return self.project_group is not None
648
649
@property
650
def principal(self):
651
return self.project_group or self.user
652
653
@classmethod
654
def get(cls, store, principal, project):
655
"""Find or create an Assessed for the given user or group and project.
656
657
@param principal: The user or group.
658
@param project: The project.
659
"""
660
t = type(principal)
661
if t not in (User, ProjectGroup):
662
raise AssertionError('principal must be User or ProjectGroup')
663
664
a = store.find(cls,
665
(t is User) or (cls.project_group_id == principal.id),
666
(t is ProjectGroup) or (cls.user_id == principal.id),
667
Project.id == project.id).one()
668
669
if a is None:
670
a = cls()
671
if t is User:
672
a.user = principal
673
else:
674
a.project_group = principal
675
a.project = project
676
store.add(a)
677
678
return a
679
680
681
class ProjectExtension(Storm):
682
"""An extension granted to a user or group on a particular project.
683
684
The user or group and project are specified by the Assessed.
685
"""
686
687
__storm_table__ = "project_extension"
688
689
id = Int(name="extensionid", primary=True)
690
assessed_id = Int(name="assessedid")
691
assessed = Reference(assessed_id, Assessed.id)
692
deadline = DateTime()
693
approver_id = Int(name="approver")
694
approver = Reference(approver_id, User.id)
695
notes = Unicode()
696
697
class ProjectSubmission(Storm):
698
"""A submission from a user or group repository to a particular project.
699
700
The content of a submission is a single path and revision inside a
701
repository. The repository is that owned by the submission's user and
702
group, while the path and revision are explicit.
703
704
The user or group and project are specified by the Assessed.
705
"""
706
707
__storm_table__ = "project_submission"
708
709
id = Int(name="submissionid", primary=True)
710
assessed_id = Int(name="assessedid")
711
assessed = Reference(assessed_id, Assessed.id)
712
path = Unicode()
713
revision = Int()
714
submitter_id = Int(name="submitter")
715
submitter = Reference(submitter_id, User.id)
716
date_submitted = DateTime()
717
718
416
719
# WORKSHEETS AND EXERCISES #
417
720
418
721
class Exercise(Storm):
722
"""An exercise for students to complete in a worksheet.
723
724
An exercise may be present in any number of worksheets.
725
"""
726
419
727
__storm_table__ = "exercise"
420
728
id = Unicode(primary=True, name="identifier")
421
729
name = Unicode()
433
741
'WorksheetExercise.worksheet_id',
434
742
'Worksheet.id'
435
743
)
436
744
437
745
test_suites = ReferenceSet(id,
438
746
'TestSuite.exercise_id',
439
747
order_by='seq_no')
450
758
if user.admin:
451
759
perms.add('edit')
452
760
perms.add('view')
453
elif 'lecturer' in set((e.role for e in user.active_enrolments)):
454
perms.add('edit')
455
perms.add('view')
456
761
elif u'lecturer' in set((e.role for e in user.active_enrolments)):
762
perms.add('edit')
763
perms.add('view')
764
elif u'tutor' in set((e.role for e in user.active_enrolments)):
765
perms.add('edit')
766
perms.add('view')
767
457
768
return perms
458
769
459
770
def get_description(self):
771
"""Return the description interpreted as reStructuredText."""
460
772
return rst(self.description)
461
773
462
def delete(self, store):
463
"""Deletes the exercise, providing it has no associated worksheets.
464
465
Returns True if delete successful. Otherwise returns False."""
466
if self.worksheet_exercises.count() > 0:
467
return False
468
774
def delete(self):
775
"""Deletes the exercise, providing it has no associated worksheets."""
776
if (self.worksheet_exercises.count() > 0):
777
raise IntegrityError()
469
778
for suite in self.test_suites:
470
779
suite.delete()
471
store.remove(self)
472
return True
780
Store.of(self).remove(self)
473
781
474
782
class Worksheet(Storm):
783
"""A worksheet with exercises for students to complete.
784
785
Worksheets are owned by offerings.
786
"""
787
475
788
__storm_table__ = "worksheet"
476
789
477
790
id = Int(primary=True, name="worksheetid")
502
815
def __repr__(self):
503
816
return "<%s %s>" % (type(self).__name__, self.name)
504
817
505
# XXX Refactor this - make it an instance method of Subject rather than a
506
# class method of Worksheet. Can't do that now because Subject isn't
507
# linked referentially to the Worksheet.
508
@classmethod
509
def get_by_name(cls, store, subjectname, worksheetname):
510
"""
511
Get the Worksheet from the db associated with a given store, subject
512
name and worksheet name.
513
"""
514
return store.find(cls, cls.subject == unicode(subjectname),
515
cls.name == unicode(worksheetname)).one()
818
def remove_all_exercises(self):
819
"""Remove all exercises from this worksheet.
516
820
517
def remove_all_exercises(self, store):
518
"""
519
Remove all exercises from this worksheet.
520
821
This does not delete the exercises themselves. It just removes them
521
822
from the worksheet.
522
823
"""
824
store = Store.of(self)
825
for ws_ex in self.all_worksheet_exercises:
826
if ws_ex.saves.count() > 0 or ws_ex.attempts.count() > 0:
827
raise IntegrityError()
523
828
store.find(WorksheetExercise,
524
829
WorksheetExercise.worksheet == self).remove()
525
830
526
831
def get_permissions(self, user):
527
832
return self.offering.get_permissions(user)
528
833
529
834
def get_xml(self):
530
835
"""Returns the xml of this worksheet, converts from rst if required."""
531
836
if self.format == u'rst':
533
838
return ws_xml
534
839
else:
535
840
return self.data
536
537
def delete(self, store):
841
842
def delete(self):
538
843
"""Deletes the worksheet, provided it has no attempts on any exercises.
539
844
540
845
Returns True if delete succeeded, or False if this worksheet has
541
846
attempts attached."""
542
847
for ws_ex in self.all_worksheet_exercises:
543
848
if ws_ex.saves.count() > 0 or ws_ex.attempts.count() > 0:
544
return False
545
849
raise IntegrityError()
850
546
851
self.remove_all_exercises()
547
store.remove(self)
548
return True
549
852
Store.of(self).remove(self)
853
550
854
class WorksheetExercise(Storm):
855
"""A link between a worksheet and one of its exercises.
856
857
These may be marked optional, in which case the exercise does not count
858
for marking purposes. The sequence number is used to order the worksheet
859
ToC.
860
"""
861
551
862
__storm_table__ = "worksheet_exercise"
552
863
553
864
id = Int(primary=True, name="ws_ex_id")
554
865
555
866
worksheet_id = Int(name="worksheetid")
559
870
optional = Bool()
560
871
active = Bool()
561
872
seq_no = Int()
562
873
563
874
saves = ReferenceSet(id, "ExerciseSave.ws_ex_id")
564
875
attempts = ReferenceSet(id, "ExerciseAttempt.ws_ex_id")
565
876
571
882
572
883
def get_permissions(self, user):
573
884
return self.worksheet.get_permissions(user)
574
885
575
886
576
887
class ExerciseSave(Storm):
577
"""
578
Represents a potential solution to an exercise that a user has submitted
579
to the server for storage.
580
A basic ExerciseSave is just the current saved text for this exercise for
581
this user (doesn't count towards their attempts).
582
ExerciseSave may be extended with additional semantics (such as
583
ExerciseAttempt).
584
"""
888
"""A potential exercise solution submitted by a user for storage.
889
890
This is not an actual tested attempt at an exercise, it's just a save of
891
the editing session.
892
"""
893
585
894
__storm_table__ = "exercise_save"
586
895
__storm_primary__ = "ws_ex_id", "user_id"
587
896
600
909
self.exercise.name, self.user.login, self.date.strftime("%c"))
601
910
602
911
class ExerciseAttempt(ExerciseSave):
603
"""
604
An ExerciseAttempt is a special case of an ExerciseSave. Like an
605
ExerciseSave, it constitutes exercise solution data that the user has
606
submitted to the server for storage.
607
In addition, it contains additional information about the submission.
608
complete - True if this submission was successful, rendering this exercise
609
complete for this user.
610
active - True if this submission is "active" (usually true). Submissions
611
may be de-activated by privileged users for special reasons, and then
612
they won't count (either as a penalty or success), but will still be
613
stored.
614
"""
912
"""An attempt at solving an exercise.
913
914
This is a special case of ExerciseSave, used when the user submits a
915
candidate solution. Like an ExerciseSave, it constitutes exercise solution
916
data.
917
918
In addition, it contains information about the result of the submission:
919
920
- complete - True if this submission was successful, rendering this
921
exercise complete for this user in this worksheet.
922
- active - True if this submission is "active" (usually true).
923
Submissions may be de-activated by privileged users for
924
special reasons, and then they won't count (either as a
925
penalty or success), but will still be stored.
926
"""
927
615
928
__storm_table__ = "exercise_attempt"
616
929
__storm_primary__ = "ws_ex_id", "user_id", "date"
617
930
620
933
text = Unicode(name="attempt")
621
934
complete = Bool()
622
935
active = Bool()
623
936
624
937
def get_permissions(self, user):
625
938
return set(['view']) if user is self.user else set()
626
939
627
940
class TestSuite(Storm):
628
"""A Testsuite acts as a container for the test cases of an exercise."""
941
"""A container to group an exercise's test cases.
942
943
The test suite contains some information on how to test. The function to
944
test, variables to set and stdin data are stored here.
945
"""
946
629
947
__storm_table__ = "test_suite"
630
948
__storm_primary__ = "exercise_id", "suiteid"
631
949
632
950
suiteid = Int()
633
951
exercise_id = Unicode(name="exerciseid")
634
952
description = Unicode()
638
956
exercise = Reference(exercise_id, Exercise.id)
639
957
test_cases = ReferenceSet(suiteid, 'TestCase.suiteid', order_by="seq_no")
640
958
variables = ReferenceSet(suiteid, 'TestSuiteVar.suiteid', order_by='arg_no')
641
642
def delete(self, store):
959
960
def delete(self):
643
961
"""Delete this suite, without asking questions."""
644
962
for vaariable in self.variables:
645
963
variable.delete()
646
964
for test_case in self.test_cases:
647
965
test_case.delete()
648
store.remove(self)
966
Store.of(self).remove(self)
649
967
650
968
class TestCase(Storm):
651
"""A TestCase is a member of a TestSuite.
652
653
It contains the data necessary to check if an exercise is correct"""
969
"""A container for actual tests (see TestCasePart), inside a test suite.
970
971
It is the lowest level shown to students on their pass/fail status."""
972
654
973
__storm_table__ = "test_case"
655
974
__storm_primary__ = "testid", "suiteid"
656
975
657
976
testid = Int()
658
977
suiteid = Int()
659
978
suite = Reference(suiteid, "TestSuite.suiteid")
661
980
failmsg = Unicode()
662
981
test_default = Unicode()
663
982
seq_no = Int()
664
983
665
984
parts = ReferenceSet(testid, "TestCasePart.testid")
666
985
667
986
__init__ = _kwarg_init
668
669
def delete(self, store):
987
988
def delete(self):
670
989
for part in self.parts:
671
990
part.delete()
672
store.remove(self)
991
Store.of(self).remove(self)
673
992
674
993
class TestSuiteVar(Storm):
675
"""A container for the arguments of a Test Suite"""
994
"""A variable used by an exercise test suite.
995
996
This may represent a function argument or a normal variable.
997
"""
998
676
999
__storm_table__ = "suite_variable"
677
1000
__storm_primary__ = "varid"
678
1001
679
1002
varid = Int()
680
1003
suiteid = Int()
681
1004
var_name = Unicode()
682
1005
var_value = Unicode()
683
1006
var_type = Unicode()
684
1007
arg_no = Int()
685
1008
686
1009
suite = Reference(suiteid, "TestSuite.suiteid")
687
1010
688
1011
__init__ = _kwarg_init
689
690
def delete(self, store):
691
store.remove(self)
692
1012
1013
def delete(self):
1014
Store.of(self).remove(self)
1015
693
1016
class TestCasePart(Storm):
694
"""A container for the test elements of a Test Case"""
1017
"""An actual piece of code to test an exercise solution."""
1018
695
1019
__storm_table__ = "test_case_part"
696
1020
__storm_primary__ = "partid"
697
1021
698
1022
partid = Int()
699
1023
testid = Int()
700
1024
701
1025
part_type = Unicode()
702
1026
test_type = Unicode()
703
1027
data = Unicode()
704
1028
filename = Unicode()
705
1029
706
1030
test = Reference(testid, "TestCase.testid")
707
1031
708
1032
__init__ = _kwarg_init
709
710
def delete(self, store):
711
store.remove(self)
1033
1034
def delete(self):
1035
Store.of(self).remove(self)
Loggerhead is a web-based interface for Breezy
Version: 2.0.1