« back to all changes in this revision
Viewing changes to ivle/database.py
- browse files at revision 1163
- compare with another revision
- download diff
- download tarball
- view history from revision 1163
- Committer: William Grant
- Date: 2009-03-17 07:12:11 UTC
- Revision ID: grantw@unimelb.edu.au-20090317071211-641qkzx7nofnkpgy
Stream files from serveservice, rather than reading the whole file in at once.
- files added:
- ivle/webapp/admin/enrol.html
- website
- website/images
- files removed:
- bin/ivle-fetchsubmissions
- ivle/webapp/admin/templates
- ivle/webapp/submit
- files renamed:
- bin/ivle-adduser => bin/ivle-makeuser
- ivle/mimetypes.py => ivle/conf/mimetypes.py
- files modified:
- bin/ivle-addexercise
added
removed
ivle/database.py
17
17
18
18
# Author: Matt Giuca, Will Grant
19
19
20
"""Database utilities and content classes.
20
"""
21
Database Classes and Utilities for Storm ORM
21
22
22
23
This module provides all of the classes which map to database tables.
23
24
It also provides miscellaneous utility functions for database interaction.
24
25
"""
25
26
26
import hashlib
27
import md5
27
28
import datetime
28
29
29
30
from storm.locals import create_database, Store, Int, Unicode, DateTime, \
30
31
Reference, ReferenceSet, Bool, Storm, Desc
31
from storm.expr import Select, Max
32
32
from storm.exceptions import NotOneError, IntegrityError
33
33
34
import ivle.conf
34
35
from ivle.worksheet.rst import rst
35
36
36
37
__all__ = ['get_store',
37
38
'User',
38
39
'Subject', 'Semester', 'Offering', 'Enrolment',
39
40
'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(config):
54
"""Create a Storm connection string to the IVLE database
55
56
@param config: The IVLE configuration.
53
def get_conn_string():
54
"""
55
Returns the Storm connection string, generated from the conf file.
57
56
"""
58
57
59
58
clusterstr = ''
60
if config['database']['username']:
61
clusterstr += config['database']['username']
62
if config['database']['password']:
63
clusterstr += ':' + config['database']['password']
59
if ivle.conf.db_user:
60
clusterstr += ivle.conf.db_user
61
if ivle.conf.db_password:
62
clusterstr += ':' + ivle.conf.db_password
64
63
clusterstr += '@'
65
64
66
host = config['database']['host'] or 'localhost'
67
port = config['database']['port'] or 5432
65
host = ivle.conf.db_host or 'localhost'
66
port = ivle.conf.db_port or 5432
68
67
69
68
clusterstr += '%s:%d' % (host, port)
70
69
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)))
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()))
79
78
80
79
# USERS #
81
80
82
81
class User(Storm):
83
"""An IVLE user account."""
82
"""
83
Represents an IVLE user.
84
"""
84
85
__storm_table__ = "login"
85
86
86
87
id = Int(primary=True, name="loginid")
116
117
return self.hash_password(password) == self.passhash
117
118
118
119
@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
129
120
def password_expired(self):
130
121
fieldval = self.pass_exp
131
122
return fieldval is not None and datetime.datetime.now() > fieldval
168
159
169
160
# TODO: Invitations should be listed too?
170
161
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
"""
175
162
preds = [
176
163
ProjectGroupMembership.user_id == self.id,
177
164
ProjectGroup.id == ProjectGroupMembership.project_group_id,
197
184
'''A sanely ordered list of all of the user's enrolments.'''
198
185
return self._get_enrolments(False)
199
186
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
220
187
@staticmethod
221
188
def hash_password(password):
222
"""Hash a password with MD5."""
223
return hashlib.md5(password).hexdigest()
189
return md5.md5(password).hexdigest()
224
190
225
191
@classmethod
226
192
def get_by_login(cls, store, login):
227
"""Find a user in a store by login name."""
193
"""
194
Get the User from the db associated with a given store and
195
login.
196
"""
228
197
return store.find(cls, cls.login == unicode(login)).one()
229
198
230
199
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
"""
236
200
if user and user.admin or user is self:
237
return set(['view', 'edit', 'submit_project'])
201
return set(['view', 'edit'])
238
202
else:
239
203
return set()
240
204
241
205
# SUBJECTS AND ENROLMENTS #
242
206
243
207
class Subject(Storm):
244
"""A subject (or course) which is run in some semesters."""
245
246
208
__storm_table__ = "subject"
247
209
248
210
id = Int(primary=True, name="subjectid")
259
221
return "<%s '%s'>" % (type(self).__name__, self.short_name)
260
222
261
223
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
"""
267
224
perms = set()
268
225
if user is not None:
269
226
perms.add('view')
271
228
perms.add('edit')
272
229
return perms
273
230
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
294
231
class Semester(Storm):
295
"""A semester in which subjects can be run."""
296
297
232
__storm_table__ = "semester"
298
233
299
234
id = Int(primary=True, name="semesterid")
313
248
return "<%s %s/%s>" % (type(self).__name__, self.year, self.semester)
314
249
315
250
class Offering(Storm):
316
"""An offering of a subject in a particular semester."""
317
318
251
__storm_table__ = "offering"
319
252
320
253
id = Int(primary=True, name="offeringid")
343
276
self.semester)
344
277
345
278
def enrol(self, user, role=u'student'):
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
"""
279
'''Enrol a user in this offering.'''
351
280
enrolment = Store.of(self).find(Enrolment,
352
281
Enrolment.user_id == user.id,
353
282
Enrolment.offering_id == self.id).one()
378
307
return perms
379
308
380
309
def get_enrolment(self, user):
381
"""Find the user's enrolment in this offering."""
382
310
try:
383
311
enrolment = self.enrolments.find(user=user).one()
384
312
except NotOneError:
386
314
387
315
return enrolment
388
316
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
400
317
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
406
318
__storm_table__ = "enrolment"
407
319
__storm_primary__ = "user_id", "offering_id"
408
320
431
343
# PROJECTS #
432
344
433
345
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
440
346
__storm_table__ = "project_set"
441
347
442
348
id = Int(name="projectsetid", primary=True)
453
359
return "<%s %d in %r>" % (type(self).__name__, self.id,
454
360
self.offering)
455
361
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
471
362
class Project(Storm):
472
"""A student project for which submissions can be made."""
473
474
363
__storm_table__ = "project"
475
364
476
365
id = Int(name="projectid", primary=True)
477
name = Unicode()
478
short_name = Unicode()
479
366
synopsis = Unicode()
480
367
url = Unicode()
481
368
project_set_id = Int(name="projectsetid")
482
369
project_set = Reference(project_set_id, ProjectSet.id)
483
370
deadline = DateTime()
484
371
485
assesseds = ReferenceSet(id, 'Assessed.project_id')
486
submissions = ReferenceSet(id,
487
'Assessed.project_id',
488
'Assessed.id',
489
'ProjectSubmission.assessed_id')
490
491
372
__init__ = _kwarg_init
492
373
493
374
def __repr__(self):
494
return "<%s '%s' in %r>" % (type(self).__name__, self.short_name,
375
return "<%s '%s' in %r>" % (type(self).__name__, self.synopsis,
495
376
self.project_set.offering)
496
377
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
541
378
class ProjectGroup(Storm):
542
"""A group of students working together on a project."""
543
544
379
__storm_table__ = "project_group"
545
380
546
381
id = Int(name="groupid", primary=True)
563
398
return "<%s %s in %r>" % (type(self).__name__, self.name,
564
399
self.project_set.offering)
565
400
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
602
401
class ProjectGroupMembership(Storm):
603
"""A student's membership in a project group."""
604
605
402
__storm_table__ = "group_member"
606
403
__storm_primary__ = "user_id", "project_group_id"
607
404
616
413
return "<%s %r in %r>" % (type(self).__name__, self.user,
617
414
self.project_group)
618
415
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
719
416
# WORKSHEETS AND EXERCISES #
720
417
721
418
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
727
419
__storm_table__ = "exercise"
728
420
id = Unicode(primary=True, name="identifier")
729
421
name = Unicode()
741
433
'WorksheetExercise.worksheet_id',
742
434
'Worksheet.id'
743
435
)
744
436
745
437
test_suites = ReferenceSet(id,
746
438
'TestSuite.exercise_id',
747
439
order_by='seq_no')
758
450
if user.admin:
759
451
perms.add('edit')
760
452
perms.add('view')
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
453
elif 'lecturer' in set((e.role for e in user.active_enrolments)):
454
perms.add('edit')
455
perms.add('view')
456
768
457
return perms
769
458
770
459
def get_description(self):
771
"""Return the description interpreted as reStructuredText."""
772
460
return rst(self.description)
773
461
774
462
def delete(self):
780
468
Store.of(self).remove(self)
781
469
782
470
class Worksheet(Storm):
783
"""A worksheet with exercises for students to complete.
784
785
Worksheets are owned by offerings.
786
"""
787
788
471
__storm_table__ = "worksheet"
789
472
790
473
id = Int(primary=True, name="worksheetid")
815
498
def __repr__(self):
816
499
return "<%s %s>" % (type(self).__name__, self.name)
817
500
501
# XXX Refactor this - make it an instance method of Subject rather than a
502
# class method of Worksheet. Can't do that now because Subject isn't
503
# linked referentially to the Worksheet.
504
@classmethod
505
def get_by_name(cls, store, subjectname, worksheetname):
506
"""
507
Get the Worksheet from the db associated with a given store, subject
508
name and worksheet name.
509
"""
510
return store.find(cls, cls.subject == unicode(subjectname),
511
cls.name == unicode(worksheetname)).one()
512
818
513
def remove_all_exercises(self):
819
"""Remove all exercises from this worksheet.
820
514
"""
515
Remove all exercises from this worksheet.
821
516
This does not delete the exercises themselves. It just removes them
822
517
from the worksheet.
823
518
"""
827
522
raise IntegrityError()
828
523
store.find(WorksheetExercise,
829
524
WorksheetExercise.worksheet == self).remove()
830
525
831
526
def get_permissions(self, user):
832
527
return self.offering.get_permissions(user)
833
528
834
529
def get_xml(self):
835
530
"""Returns the xml of this worksheet, converts from rst if required."""
836
531
if self.format == u'rst':
838
533
return ws_xml
839
534
else:
840
535
return self.data
841
536
842
537
def delete(self):
843
538
"""Deletes the worksheet, provided it has no attempts on any exercises.
844
539
845
540
Returns True if delete succeeded, or False if this worksheet has
846
541
attempts attached."""
847
542
for ws_ex in self.all_worksheet_exercises:
848
543
if ws_ex.saves.count() > 0 or ws_ex.attempts.count() > 0:
849
544
raise IntegrityError()
850
545
851
546
self.remove_all_exercises()
852
547
Store.of(self).remove(self)
853
548
854
549
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
862
550
__storm_table__ = "worksheet_exercise"
863
551
864
552
id = Int(primary=True, name="ws_ex_id")
865
553
866
554
worksheet_id = Int(name="worksheetid")
870
558
optional = Bool()
871
559
active = Bool()
872
560
seq_no = Int()
873
561
874
562
saves = ReferenceSet(id, "ExerciseSave.ws_ex_id")
875
563
attempts = ReferenceSet(id, "ExerciseAttempt.ws_ex_id")
876
564
882
570
883
571
def get_permissions(self, user):
884
572
return self.worksheet.get_permissions(user)
885
573
886
574
887
575
class ExerciseSave(Storm):
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
576
"""
577
Represents a potential solution to an exercise that a user has submitted
578
to the server for storage.
579
A basic ExerciseSave is just the current saved text for this exercise for
580
this user (doesn't count towards their attempts).
581
ExerciseSave may be extended with additional semantics (such as
582
ExerciseAttempt).
583
"""
894
584
__storm_table__ = "exercise_save"
895
585
__storm_primary__ = "ws_ex_id", "user_id"
896
586
909
599
self.exercise.name, self.user.login, self.date.strftime("%c"))
910
600
911
601
class ExerciseAttempt(ExerciseSave):
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
602
"""
603
An ExerciseAttempt is a special case of an ExerciseSave. Like an
604
ExerciseSave, it constitutes exercise solution data that the user has
605
submitted to the server for storage.
606
In addition, it contains additional information about the submission.
607
complete - True if this submission was successful, rendering this exercise
608
complete for this user.
609
active - True if this submission is "active" (usually true). Submissions
610
may be de-activated by privileged users for special reasons, and then
611
they won't count (either as a penalty or success), but will still be
612
stored.
613
"""
928
614
__storm_table__ = "exercise_attempt"
929
615
__storm_primary__ = "ws_ex_id", "user_id", "date"
930
616
933
619
text = Unicode(name="attempt")
934
620
complete = Bool()
935
621
active = Bool()
936
622
937
623
def get_permissions(self, user):
938
624
return set(['view']) if user is self.user else set()
939
625
940
626
class TestSuite(Storm):
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
627
"""A Testsuite acts as a container for the test cases of an exercise."""
947
628
__storm_table__ = "test_suite"
948
629
__storm_primary__ = "exercise_id", "suiteid"
949
630
950
631
suiteid = Int()
951
632
exercise_id = Unicode(name="exerciseid")
952
633
description = Unicode()
956
637
exercise = Reference(exercise_id, Exercise.id)
957
638
test_cases = ReferenceSet(suiteid, 'TestCase.suiteid', order_by="seq_no")
958
639
variables = ReferenceSet(suiteid, 'TestSuiteVar.suiteid', order_by='arg_no')
959
640
960
641
def delete(self):
961
642
"""Delete this suite, without asking questions."""
962
643
for vaariable in self.variables:
966
647
Store.of(self).remove(self)
967
648
968
649
class TestCase(Storm):
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
650
"""A TestCase is a member of a TestSuite.
651
652
It contains the data necessary to check if an exercise is correct"""
973
653
__storm_table__ = "test_case"
974
654
__storm_primary__ = "testid", "suiteid"
975
655
976
656
testid = Int()
977
657
suiteid = Int()
978
658
suite = Reference(suiteid, "TestSuite.suiteid")
980
660
failmsg = Unicode()
981
661
test_default = Unicode()
982
662
seq_no = Int()
983
663
984
664
parts = ReferenceSet(testid, "TestCasePart.testid")
985
665
986
666
__init__ = _kwarg_init
987
667
988
668
def delete(self):
989
669
for part in self.parts:
990
670
part.delete()
991
671
Store.of(self).remove(self)
992
672
993
673
class TestSuiteVar(Storm):
994
"""A variable used by an exercise test suite.
995
996
This may represent a function argument or a normal variable.
997
"""
998
674
"""A container for the arguments of a Test Suite"""
999
675
__storm_table__ = "suite_variable"
1000
676
__storm_primary__ = "varid"
1001
677
1002
678
varid = Int()
1003
679
suiteid = Int()
1004
680
var_name = Unicode()
1005
681
var_value = Unicode()
1006
682
var_type = Unicode()
1007
683
arg_no = Int()
1008
684
1009
685
suite = Reference(suiteid, "TestSuite.suiteid")
1010
686
1011
687
__init__ = _kwarg_init
1012
688
1013
689
def delete(self):
1014
690
Store.of(self).remove(self)
1015
691
1016
692
class TestCasePart(Storm):
1017
"""An actual piece of code to test an exercise solution."""
1018
693
"""A container for the test elements of a Test Case"""
1019
694
__storm_table__ = "test_case_part"
1020
695
__storm_primary__ = "partid"
1021
696
1022
697
partid = Int()
1023
698
testid = Int()
1024
699
1025
700
part_type = Unicode()
1026
701
test_type = Unicode()
1027
702
data = Unicode()
1028
703
filename = Unicode()
1029
704
1030
705
test = Reference(testid, "TestCase.testid")
1031
706
1032
707
__init__ = _kwarg_init
1033
708
1034
709
def delete(self):
1035
710
Store.of(self).remove(self)
Loggerhead is a web-based interface for Breezy
Version: 2.0.1