def setUp(self):
self.us_units = Unit(is_metric=False,
ratio=.25)
self.us_units.save()
self.metric_units = Unit(is_metric=True,
ratio=4,
equivalent=self.us_units)
self.metric_units.save()
self.us_units.equivalent = self.metric_units
self.us_units.save()
self.credit_user_submission = CreditUserSubmissionFactory()
self.documentation_field = DocumentationFieldFactory()
def test_validate_points_logging(self):
"""Does validate_points log an error when there's an out of range
error?
"""
credit_user_submission = CreditUserSubmissionFactory(
credit=CreditFactory(point_value=10))
with testfixtures.LogCapture('stars') as log:
credit_user_submission.validate_points(points=-1.0, log_error=True)
self.assertEqual(len(log.records), 1)
self.assertEqual(log.records[0].levelname, 'ERROR')
self.assertTrue(
log.records[0].msg.startswith('Points (-1.0) are out of range'))
def test_calculated_field_is_cleared_when_term_goes_invalid(self):
credit = CreditFactory()
term_field = DocumentationFieldFactory(credit=credit,
type='numeric',
identifier='BA')
calculated_field = DocumentationField.objects.create(
credit=credit, type='calculated', formula='value = BA')
credit_submission = CreditUserSubmissionFactory(credit=credit)
term_submission = NumericDocumentationFieldSubmissionFactory(
credit_submission=credit_submission,
documentation_field=term_field,
value=1)
calculated_submission = NumericDocumentationFieldSubmissionFactory(
credit_submission=credit_submission,
documentation_field=calculated_field,
value=100)
term_submission.value = None
term_submission.save()
# We have a dirty read.
calculated_submission = NumericSubmission.objects.get(
pk=calculated_submission.pk)
self.assertEqual(None, calculated_submission.value)
def test_calculated_field_is_calculated_when_term_changes(self):
credit = CreditFactory()
first_term_field = DocumentationFieldFactory(credit=credit,
type='numeric',
identifier='AA')
second_term_field = DocumentationFieldFactory(credit=credit,
type='numeric',
identifier='AB')
calculated_field = DocumentationField.objects.create(
credit=credit,
type='calculated',
formula='value = (AA or 0) + (AB or 0)')
credit_submission = CreditUserSubmissionFactory(credit=credit)
first_term_submission = NumericDocumentationFieldSubmissionFactory(
credit_submission=credit_submission,
documentation_field=first_term_field,
value=1)
NumericDocumentationFieldSubmissionFactory(
credit_submission=credit_submission,
documentation_field=second_term_field,
value=2)
calculated_submission = NumericDocumentationFieldSubmissionFactory(
credit_submission=credit_submission,
documentation_field=calculated_field,
value=None)
first_term_submission.value = 10
first_term_submission.save()
# We have a dirty read.
calculated_submission = NumericSubmission.objects.get(
pk=calculated_submission.pk)
self.assertEqual(12, calculated_submission.value)
def setUp(self):
self.responsible_party = ResponsiblePartyFactory()
self.credit_user_submissions = list()
for _ in xrange(4):
self.credit_user_submissions.append(
CreditUserSubmissionFactory(
responsible_party=self.responsible_party))
def _make_credits_for_responsible_party(self):
"""List some credits for this responsible_party."""
credits = list()
for credit in xrange(4):
credits.append(
CreditUserSubmissionFactory(
responsible_party=self.responsible_party))
def test_is_test_true_for_usery_credit_submission(self):
"""Is is_test False for a CreditSubmission that's not
a CreditUserSubmission but looks like one?
"""
credit_submission = CreditSubmissionFactory()
credit_submission.creditusersubmission = CreditUserSubmissionFactory()
self.assertFalse(credit_submission.is_test())
def setUp(self, *args, **kwargs):
super(CreditSubmissionHistoryViewTest, self).setUp(*args, **kwargs)
category = CategoryFactory(creditset=self.submission.creditset)
category.save()
category_submission = CategorySubmissionFactory(
category=category, submissionset=self.submission)
self.category_abbreviation = category.abbreviation
subcategory = SubcategoryFactory(category=category)
subcategory.save()
subcategory_submission = SubcategorySubmissionFactory(
subcategory=subcategory, category_submission=category_submission)
self.subcategory_slug = subcategory.slug
credit = CreditFactory(subcategory=subcategory)
credit.save()
credit_submission = CreditUserSubmissionFactory(
credit=credit, subcategory_submission=subcategory_submission)
self.credit_identifier = credit.identifier
# Some history to show:
documentation_field = DocumentationFieldFactory(credit=credit)
documentation_field.save()
documentation_field_submission = DocumentationFieldSubmissionFactory(
documentation_field=documentation_field,
credit_submission=credit_submission)
documentation_field_submission.save()
def test_save_recalculates_invalid_credit_user_submissions(self):
"""Does save recalculate submissions when formula goes invalid?"""
credit_submission = CreditUserSubmissionFactory(credit=self.credit)
fields = make_numeric_fields(self.credit, 3)
field_submissions = []
for i in xrange(len(fields)):
field_submissions.append(
NumericDocumentationFieldSubmissionFactory(
documentation_field=fields[i],
credit_submission=credit_submission,
value=i))
calculated_field = DocumentationField.objects.create(
credit=self.credit, type='calculated', formula='value = A + B + C')
calculated_field_submission = (
NumericDocumentationFieldSubmissionFactory(
documentation_field=calculated_field,
credit_submission=credit_submission))
calculated_field_submission.calculate()
self.assertEqual(3, calculated_field_submission.value)
calculated_field.formula = 'value = bo-o-o-o-gus'
calculated_field.save()
# We have a dirty read.
calculated_field_submission = NumericSubmission.objects.get(
pk=calculated_field_submission.pk)
self.assertEqual(None, calculated_field_submission.value)
def setUp(self):
self.credit_user_submission = CreditUserSubmissionFactory()
self.credit = self.credit_user_submission.credit
numeric_field = DocumentationFieldFactory(credit=self.credit,
type="numeric",
identifier="A")
self.calculated_field = DocumentationFieldFactory(credit=self.credit,
type="calculated",
formula="value = A")
self.calculated_submission = (
NumericDocumentationFieldSubmissionFactory(
documentation_field=self.calculated_field,
credit_submission=self.credit_user_submission,
value=999))
self.numeric_submission = NumericDocumentationFieldSubmissionFactory(
documentation_field=numeric_field,
credit_submission=self.credit_user_submission,
value=0)
def test_is_test_false_for_user_submission(self):
"""Is is_test True for a CreditUserSubmission?
"""
user_submission = CreditUserSubmissionFactory()
self.assertFalse(user_submission.is_test())
class CreditSubmissionReviewNotationTest(TestCase):
def setUp(self):
self.credit_user_submission = CreditUserSubmissionFactory()
submissionset = self.credit_user_submission.get_submissionset()
submissionset.is_under_review = True
submissionset.save()
def testRevisionRequestUnlocksSubmission(self):
"""Does a Revision Request notation unlock the submission?
"""
CreditSubmissionReviewNotation.objects.create(
kind=CREDIT_SUBMISSION_REVIEW_NOTATION_KINDS["REVISION_REQUEST"],
credit_user_submission=self.credit_user_submission)
self.assertTrue(self.credit_user_submission.is_unlocked_for_review)
def testSuggestionForImprovementUnlocksSubmission(self):
"""Does a Suggestion For Improvement notation unlock the submission?
"""
CreditSubmissionReviewNotation.objects.create(
kind=CREDIT_SUBMISSION_REVIEW_NOTATION_KINDS[
"SUGGESTION_FOR_IMPROVEMENT"],
credit_user_submission=self.credit_user_submission)
self.assertTrue(self.credit_user_submission.is_unlocked_for_review)
def testBestPracticeDoesNotUnlockSubmission(self):
"""Does a Best Practice notation unlock the submission? (It shouldn't.)
"""
CreditSubmissionReviewNotation.objects.create(
kind=CREDIT_SUBMISSION_REVIEW_NOTATION_KINDS["BEST_PRACTICE"],
credit_user_submission=self.credit_user_submission)
self.assertFalse(self.credit_user_submission.is_unlocked_for_review)
def testDeleteLastRevisionRequestLocksCreditUserSubmission(self):
"""Does deleting the last Revision Request re-lock the submission?
(Assuming there are no other unlocking kinds of notations on the
submission.)
"""
revision_request = CreditSubmissionReviewNotation.objects.create(
kind=CREDIT_SUBMISSION_REVIEW_NOTATION_KINDS["REVISION_REQUEST"],
credit_user_submission=self.credit_user_submission)
suggestion_for_improvement = (
CreditSubmissionReviewNotation.objects.create(
kind=CREDIT_SUBMISSION_REVIEW_NOTATION_KINDS[
"SUGGESTION_FOR_IMPROVEMENT"],
credit_user_submission=self.credit_user_submission))
self.assertTrue(self.credit_user_submission.is_unlocked_for_review)
suggestion_for_improvement.delete()
self.assertTrue(self.credit_user_submission.is_unlocked_for_review)
revision_request.delete()
self.assertFalse(self.credit_user_submission.is_unlocked_for_review)
def testDeleteLastSuggestionForImprovementLocksCreditUserSubmission(self):
"""Does deleting the last Sugg. for Imprvmnt. re-lock the submission?
(Assuming there are no other unlocking kinds of notations on the
submission.)
"""
revision_request = CreditSubmissionReviewNotation.objects.create(
kind=CREDIT_SUBMISSION_REVIEW_NOTATION_KINDS["REVISION_REQUEST"],
credit_user_submission=self.credit_user_submission)
suggestion_for_improvement = (
CreditSubmissionReviewNotation.objects.create(
kind=CREDIT_SUBMISSION_REVIEW_NOTATION_KINDS[
"SUGGESTION_FOR_IMPROVEMENT"],
credit_user_submission=self.credit_user_submission))
self.assertTrue(self.credit_user_submission.is_unlocked_for_review)
revision_request.delete()
self.assertTrue(self.credit_user_submission.is_unlocked_for_review)
suggestion_for_improvement.delete()
self.assertFalse(self.credit_user_submission.is_unlocked_for_review)
def setUp(self):
self.credit_user_submission = CreditUserSubmissionFactory()
submissionset = self.credit_user_submission.get_submissionset()
submissionset.is_under_review = True
submissionset.save()
class NumericSubmissionTest(TestCase):
def setUp(self):
self.us_units = Unit(is_metric=False,
ratio=.25)
self.us_units.save()
self.metric_units = Unit(is_metric=True,
ratio=4,
equivalent=self.us_units)
self.metric_units.save()
self.us_units.equivalent = self.metric_units
self.us_units.save()
self.credit_user_submission = CreditUserSubmissionFactory()
self.documentation_field = DocumentationFieldFactory()
def set_institution_prefers_metric_system(self, what):
institution = self.credit_user_submission.get_institution()
institution.prefers_metric_system = what
institution.save()
def test_save_store_us_value_when_using_metric(self):
"""Does save() store US value when using metric?
"""
self.set_institution_prefers_metric_system(True)
self.documentation_field.units = self.metric_units
self.documentation_field.save()
numeric_submission = NumericSubmission(
documentation_field=self.documentation_field,
credit_submission=self.credit_user_submission,
metric_value=100)
numeric_submission.save()
self.assertEqual(400, numeric_submission.value)
def test_save_store_metric_value_when_not_using_metric(self):
"""Does save() store metric value when not using metric?
"""
self.set_institution_prefers_metric_system(False)
self.documentation_field.units = self.us_units
self.documentation_field.save()
numeric_submission = NumericSubmission(
documentation_field=self.documentation_field,
credit_submission=self.credit_user_submission,
value=100)
numeric_submission.save()
self.assertEqual(25, numeric_submission.metric_value)
def test_save_handle_metric_value_is_none_using_metric(self):
"""Does save() handle it when the metric_value is None?
(Using metric system.)
"""
self.set_institution_prefers_metric_system(True)
self.documentation_field.units = self.metric_units
self.documentation_field.save()
numeric_submission = NumericSubmission(
documentation_field=self.documentation_field,
credit_submission=self.credit_user_submission,
metric_value=None)
numeric_submission.save()
self.assertEqual(None, numeric_submission.metric_value)
def test_save_handle_metric_value_is_none_not_using_metric(self):
"""Does save() handle it when the metric_value is None?
(Not using metric system.)
"""
self.set_institution_prefers_metric_system(False)
self.documentation_field.units = self.us_units
self.documentation_field.save()
numeric_submission = NumericSubmission(
documentation_field=self.documentation_field,
credit_submission=self.credit_user_submission,
metric_value=None)
numeric_submission.save()
self.assertEqual(None, numeric_submission.metric_value)
def test_save_handle_value_is_none_using_metric(self):
"""Does save() handle it when the value is None?
(Using metric system.)
"""
self.set_institution_prefers_metric_system(True)
self.documentation_field.units = self.metric_units
self.documentation_field.save()
numeric_submission = NumericSubmission(
documentation_field=self.documentation_field,
credit_submission=self.credit_user_submission,
value=None)
numeric_submission.save()
self.assertEqual(None, numeric_submission.value)
def test_save_handle_value_is_none_not_using_metric(self):
"""Does save() handle it when the value is None?
(Not using metric system.)
"""
self.set_institution_prefers_metric_system(False)
self.documentation_field.units = self.us_units
self.documentation_field.save()
numeric_submission = NumericSubmission(
documentation_field=self.documentation_field,
credit_submission=self.credit_user_submission,
value=None)
numeric_submission.save()
self.assertEqual(None, numeric_submission.value)
def test_save_without_units_succeeds(self):
"""Is save() ok when the doc field has no units?
"""
self.documentation_field.units = None
self.documentation_field.save()
numeric_submission = NumericSubmission(
documentation_field=self.documentation_field,
credit_submission=self.credit_user_submission,
value=100)
numeric_submission.save()
self.assertEqual(100, numeric_submission.value)
def test_save_without_units_succeeds_using_metric(self):
"""Is save() ok when the doc field has no units and using metric?
"""
self.set_institution_prefers_metric_system(True)
self.documentation_field.units = None
self.documentation_field.save()
numeric_submission = NumericSubmission(
documentation_field=self.documentation_field,
credit_submission=self.credit_user_submission,
metric_value=100)
numeric_submission.save()
self.assertEqual(100, numeric_submission.metric_value)