def test_get_latest_creditset(self):
"""Does Creditset.objects.get_latest() work?
"""
CreditSetFactory(release_date='1970-01-01')
latest_creditset = CreditSetFactory(
release_date='2000-01-01')
CreditSetFactory(release_date='1975-01-01')
self.assertEqual(latest_creditset.id,
CreditSet.objects.get_latest().id)
def setUp(self):
# create an initial creditset and submission
self.cs1 = CreditSetFactory(
version="2.0",
release_date=date.today() - timedelta(days=2))
self.cat1 = CategoryFactory(creditset=self.cs1)
self.sub1 = SubcategoryFactory(category=self.cat1)
self.cred1 = CreditFactory(subcategory=self.sub1)
self.df1 = DocumentationFieldFactory(
credit=self.cred1, type='numeric', title="doc field 1")
self.ss1 = SubmissionSetFactory(creditset=self.cs1)
self.m_unit = UnitFactory(
name="met",
equivalent=self.df1.units,
is_metric=True
)
self.df1.units.name = "imp"
self.df1.units.equivalent = self.m_unit
self.df1.units.save()
# SubmissionSetFactory doesn't seem to create a numeric submission
# self.assertEqual(NumericSubmission.objects.count(), 1) # fails
self.ns1 = NumericSubmissionFactory(
documentation_field=self.df1,
credit_submission=CreditSubmission.objects.all()[0]
)
# Now created a migrated version of both
self.cs2 = migrate_creditset(
self.cs1, '2.1', date.today() - timedelta(days=1))
self.ss2 = create_ss_mirror(
self.ss1, new_creditset=self.cs2)
# create some old one that won't have versions with others
# create an initial creditset and submission
self.cs0 = CreditSetFactory(
version="1.2",
release_date=date.today() - timedelta(days=3))
self.cat0 = CategoryFactory(creditset=self.cs0)
self.sub0 = SubcategoryFactory(category=self.cat0)
self.cred0 = CreditFactory(subcategory=self.sub0)
self.df0 = DocumentationFieldFactory(
credit=self.cred0, type='numeric', title="doc field 1")
self.ss0 = SubmissionSetFactory(creditset=self.cs0)
self.ns0 = NumericSubmissionFactory(
documentation_field=self.df0,
credit_submission=CreditSubmission.objects.all()[2]
)
self.setUpScores()
def test_migrate_creditset(self):
"""Does migrate_creditset make a faithful copy of a Creditset?
"""
# One CreditSet.
cs = CreditSetFactory()
# Three Categories.
first_category = CategoryFactory(creditset=cs)
second_category = CategoryFactory(creditset=cs)
CategoryFactory(creditset=cs)
# Three Subcategories.
first_subcategory = SubcategoryFactory(category=first_category)
second_subcategory = SubcategoryFactory(category=second_category)
SubcategoryFactory(category=second_category)
# Two Credits.
first_credit = CreditFactory(subcategory=first_subcategory)
second_credit = CreditFactory(subcategory=second_subcategory)
# Four Documentation Fields.
DocumentationFieldFactory(credit=first_credit)
DocumentationFieldFactory(credit=first_credit)
DocumentationFieldFactory(credit=second_credit)
DocumentationFieldFactory(credit=second_credit)
new_cs = migrate_creditset(cs, "99.0", date.today())
self.assertEqual(new_cs.category_set.count(),
cs.category_set.count())
self.assertEqual(
Subcategory.objects.filter(category__creditset=new_cs).count(),
Subcategory.objects.filter(category__creditset=cs).count())
self.assertEqual(
Credit.objects.filter(
subcategory__category__creditset=new_cs).count(),
Credit.objects.filter(
subcategory__category__creditset=cs).count())
self.assertEqual(
ApplicabilityReason.objects.filter(
credit__subcategory__category__creditset=new_cs).count(),
ApplicabilityReason.objects.filter(
credit__subcategory__category__creditset=cs).count())
self.assertEqual(
DocumentationField.objects.filter(
credit__subcategory__category__creditset=new_cs).count(),
DocumentationField.objects.filter(
credit__subcategory__category__creditset=cs).count())
self.assertEqual(
Choice.objects.filter(
documentation_field__credit__subcategory__category__creditset=new_cs).count(),
Choice.objects.filter(
documentation_field__credit__subcategory__category__creditset=cs).count())
self.assertEqual(
CreditTestSubmission.objects.filter(
credit__subcategory__category__creditset=new_cs).count(),
CreditTestSubmission.objects.filter(
credit__subcategory__category__creditset=cs).count())
def setUp(self):
super(InstitutionToolMixinTest, self).setUp()
self.institution = InstitutionFactory(slug='on-the-beach-soldier')
self.account = StarsAccountFactory(institution=self.institution)
self.request.user = self.account.user
creditset = CreditSetFactory()
self.submission = SubmissionSetFactory(institution=self.institution,
creditset=creditset)
def setUp(self):
self.user = User.objects.create(username='******',
is_active=True)
self.user.save()
self.inst = Institution.objects.create(
name='Test Institution',
aashe_id=-1,
contact_first_name='Test',
)
self.inst.save()
self.creditset = CreditSetFactory()
def test_get_STARS_score_logging(self):
"""Does get_STARS_score log an error when there's no scoring method?
"""
creditset = CreditSetFactory(scoring_method='bogus_scoring_method')
submissionset = SubmissionSetFactory(creditset=creditset, status='x')
with testfixtures.LogCapture('stars') as log:
submissionset.get_STARS_score()
self.assertEqual(len(log.records), 1)
self.assertEqual(log.records[0].levelname, 'ERROR')
self.assertTrue(log.records[0].msg.startswith('No method'))
def setUp(self):
self.institution_one = InstitutionFactory(name='First One')
self.institution_two = InstitutionFactory(name='Second One')
self.institution_three = InstitutionFactory(name='AASHE Test')
creditset = CreditSetFactory()
self.submission_one = SubmissionSetFactory(
institution=self.institution_one, creditset=creditset)
self.submission_two = SubmissionSetFactory(
institution=self.institution_two, creditset=creditset)
self.submission_three = SubmissionSetFactory(
institution=self.institution_three, creditset=creditset)
self.filter = Filter(key='institution',
title='Name',
item_list=(('Yes', 'True'), ('No', 'False')),
base_qs=SubmissionSet.objects.all())
def setUp(self):
today = datetime.date.today()
td = datetime.timedelta(days=1)
# create 3 rated Institutions
cs = CreditSetFactory()
count = 0
for l in ['a', 'b', 'c', 'd']:
count += 1
r = RatingFactory(minimal_score=count, name=l, creditset=cs)
ss = SubmissionSetFactory(creditset=cs, status='r', rating=r)
i = InstitutionFactory(is_participant=True,
rated_submission=ss,
current_rating=r)
# create 1 non-rated Institutions
for _ in range(1):
i = InstitutionFactory()
s = SubscriptionFactory(end_date=today - td)
i.current_subscription = s
i.save()
def get_creditset(self):
creditset = CreditSetFactory()
self.innovations_category = Category.objects.create(
creditset=creditset, abbreviation="IN")
self.innovations_subcategory = Subcategory.objects.create(
category=self.innovations_category, title="Innovation")
self.innovations_credit = Credit.objects.create(
subcategory=self.innovations_subcategory,
identifier="INNOVATION",
point_value=10)
self.us_unit = Unit(name='imperial units', is_metric=False,
ratio=.5) # 1 us is .5 metric
self.us_unit.save()
# metric value is twice the us unit
self.metric_unit = Unit(
name="metric units",
is_metric=True,
ratio=2, # 1 metric is 2 us
equivalent=self.us_unit)
self.metric_unit.save()
self.us_unit.equivalent = self.metric_unit
self.us_unit.save()
self.innovations_documentation_field = (
DocumentationField.objects.create(credit=self.innovations_credit,
units=self.us_unit,
type="numeric"))
self.not_innovations_subcategory = Subcategory.objects.create(
category=self.innovations_category, title="Not Innovation")
self.not_innovations_credit = Credit.objects.create(
subcategory=self.not_innovations_subcategory,
identifier="NOT-INNOVATION",
point_value=20)
self.not_innovations_documentation_field = (
DocumentationField.objects.create(
credit=self.not_innovations_credit, type="numeric"))
return creditset
class SubmissionValuesTestCase(TestCase):
def setUp(self):
# create an initial creditset and submission
self.cs1 = CreditSetFactory(
version="2.0",
release_date=date.today() - timedelta(days=2))
self.cat1 = CategoryFactory(creditset=self.cs1)
self.sub1 = SubcategoryFactory(category=self.cat1)
self.cred1 = CreditFactory(subcategory=self.sub1)
self.df1 = DocumentationFieldFactory(
credit=self.cred1, type='numeric', title="doc field 1")
self.ss1 = SubmissionSetFactory(creditset=self.cs1)
self.m_unit = UnitFactory(
name="met",
equivalent=self.df1.units,
is_metric=True
)
self.df1.units.name = "imp"
self.df1.units.equivalent = self.m_unit
self.df1.units.save()
# SubmissionSetFactory doesn't seem to create a numeric submission
# self.assertEqual(NumericSubmission.objects.count(), 1) # fails
self.ns1 = NumericSubmissionFactory(
documentation_field=self.df1,
credit_submission=CreditSubmission.objects.all()[0]
)
# Now created a migrated version of both
self.cs2 = migrate_creditset(
self.cs1, '2.1', date.today() - timedelta(days=1))
self.ss2 = create_ss_mirror(
self.ss1, new_creditset=self.cs2)
# create some old one that won't have versions with others
# create an initial creditset and submission
self.cs0 = CreditSetFactory(
version="1.2",
release_date=date.today() - timedelta(days=3))
self.cat0 = CategoryFactory(creditset=self.cs0)
self.sub0 = SubcategoryFactory(category=self.cat0)
self.cred0 = CreditFactory(subcategory=self.sub0)
self.df0 = DocumentationFieldFactory(
credit=self.cred0, type='numeric', title="doc field 1")
self.ss0 = SubmissionSetFactory(creditset=self.cs0)
self.ns0 = NumericSubmissionFactory(
documentation_field=self.df0,
credit_submission=CreditSubmission.objects.all()[2]
)
self.setUpScores()
def tearDown(self):
self.cs1.delete()
self.cs2.delete()
self.cs0.delete()
def setUpScores(self):
# these need to be rated.
self.ss1.status = self.ss2.status = 'r'
self.ss1.save()
self.ss2.rating = self.ss1.rating
self.ss2.save()
self.ss1.institution.rated_submission = self.ss2
self.ss1.institution.save()
# Set up subcategories
self.subsub1 = SubcategorySubmission.objects.all()[0]
self.subsub2 = SubcategorySubmission.objects.all()[1]
self.assertEqual(
self.subsub1.category_submission.submissionset, self.ss1)
self.assertEqual(
self.subsub2.category_submission.submissionset, self.ss2)
self.subsub1.points = 10
self.subsub1.adjusted_available_points = 20
self.subsub1.percentage_score = .5
self.subsub1.save()
self.subsub2.points = 12
self.subsub2.adjusted_available_points = 15
self.subsub2.percentage_score = .8
self.subsub2.save()
# set up credits
self.credsub1 = CreditSubmission.objects.all()[0]
self.credsub2 = CreditSubmission.objects.all()[1]
self.cus1 = self.credsub1.creditusersubmission
self.cus2 = self.credsub2.creditusersubmission
self.assertEqual(self.cus1.get_submissionset(), self.ss1)
self.assertEqual(self.cus2.get_submissionset(), self.ss2)
self.cus1.available_point_cache = 20
self.cus1.assessed_points = 10
self.cus1.save(calculate_points=False)
self.cus2.available_point_cache = 15
self.cus2.assessed_points = 12
self.cus2.save(calculate_points=False)
# finally the documentation fields
self.ns2 = NumericSubmission.objects.all()[1]
self.df2 = self.ns2.documentation_field
self.df2.title = "doc field 2"
self.df2.save()
self.ns2.value = 4
self.ns2.metric_value = 8
self.ns2.save()
self.ns1.value = 5
self.ns1.metric_value = 8
self.ns1.save()
def testCategoryETLObj(self):
# more readable titles
self.cat1.title = "Category 1 v2.0"
self.cat1.save()
self.cat2 = self.cs2.category_set.all()[0]
self.cat2.title = "Category 1 v2.1"
self.cat2.save()
# Test using the latest category and the latest submissionset
etl_obj = get_cat_etl_obj(self.cat2, self.ss2)
f = etl_obj['fields']
self.assertEqual(etl_obj['model'], 'stars_content.submissionvalue')
self.assertEqual(f['data_point_key'], "cat_%d" % self.cat2.id)
self.assertEqual(f['report_version'], self.ss2.creditset.version)
self.assertTrue(self.cat2.title in f['title'])
self.assertEqual(f['imperial_units'], '%')
self.assertEqual(f['metric_units'], '%')
self.assertEqual(f['imperial_value'], 80)
self.assertEqual(f['metric_value'], 80)
self.assertTrue(f['is_current'])
self.assertTrue(f['is_latest'])
# Test using the latest category and an older submissionset
etl_obj = get_cat_etl_obj(self.cat2, self.ss1)
f = etl_obj['fields']
self.assertEqual(etl_obj['model'], 'stars_content.submissionvalue')
self.assertEqual(f['data_point_key'], "cat_%d" % self.cat2.id)
self.assertEqual(f['report_version'], self.ss1.creditset.version)
self.assertTrue(self.cat2.title in f['title'])
self.assertEqual(f['imperial_units'], '%')
self.assertEqual(f['metric_units'], '%')
self.assertEqual(f['imperial_value'], 50)
self.assertEqual(f['metric_value'], 50)
self.assertFalse(f['is_current'])
self.assertFalse(f['is_latest'])
# will it work with an older cat and newer submissionset?
etl_obj = get_cat_etl_obj(self.cat1, self.ss2)
f = etl_obj['fields']
self.assertEqual(etl_obj['model'], 'stars_content.submissionvalue')
self.assertEqual(f['data_point_key'], "cat_%d" % self.cat2.id)
self.assertEqual(f['report_version'], self.ss2.creditset.version)
self.assertTrue(self.cat1.title in f['title'])
self.assertEqual(f['imperial_units'], '%')
self.assertEqual(f['metric_units'], '%')
self.assertEqual(f['imperial_value'], 80)
self.assertEqual(f['metric_value'], 80)
self.assertTrue(f['is_current'])
self.assertTrue(f['is_latest'])
# should be none for unlinked version
etl_obj = get_cat_etl_obj(self.cat2, self.ss0)
self.assertEqual(etl_obj, None)
def testSubcategoryETLObj(self):
# more readable titles
self.sub1.title = "Subategory 1 v2.0"
self.sub1.save()
self.sub2 = Subcategory.objects.all()[1]
self.sub2.title = "Subcategory 1 v2.1"
self.sub2.save()
# Test using the latest subcategory and the latest submissionset
etl_obj = get_sub_etl_obj(self.sub2, self.ss2)
f = etl_obj['fields']
self.assertEqual(etl_obj['model'], 'stars_content.submissionvalue')
self.assertEqual(f['data_point_key'], "sub_%d" % self.sub2.id)
self.assertEqual(f['report_version'], self.ss2.creditset.version)
self.assertTrue(self.sub2.title in f['title'])
self.assertEqual(f['imperial_units'], '%')
self.assertEqual(f['metric_units'], '%')
self.assertEqual(f['imperial_value'], 80)
self.assertEqual(f['metric_value'], 80)
self.assertTrue(f['is_current'])
self.assertTrue(f['is_latest'])
# Test using the latest subcategory and an older submissionset
etl_obj = get_sub_etl_obj(self.sub2, self.ss1)
f = etl_obj['fields']
self.assertEqual(etl_obj['model'], 'stars_content.submissionvalue')
self.assertEqual(f['data_point_key'], "sub_%d" % self.sub2.id)
self.assertEqual(f['report_version'], self.ss1.creditset.version)
self.assertTrue(self.sub2.title in f['title'])
self.assertEqual(f['imperial_units'], '%')
self.assertEqual(f['metric_units'], '%')
self.assertEqual(f['imperial_value'], 50)
self.assertEqual(f['metric_value'], 50)
self.assertFalse(f['is_current'])
self.assertFalse(f['is_latest'])
# will it work with an older subcategory and newer submissionset?
etl_obj = get_sub_etl_obj(self.sub1, self.ss2)
f = etl_obj['fields']
self.assertEqual(etl_obj['model'], 'stars_content.submissionvalue')
self.assertEqual(f['data_point_key'], "sub_%d" % self.sub2.id)
self.assertEqual(f['report_version'], self.ss2.creditset.version)
self.assertTrue(self.sub1.title in f['title'])
self.assertEqual(f['imperial_units'], '%')
self.assertEqual(f['metric_units'], '%')
self.assertEqual(f['imperial_value'], 80)
self.assertEqual(f['metric_value'], 80)
self.assertTrue(f['is_current'])
self.assertTrue(f['is_latest'])
# should be none for unlinked version
etl_obj = get_sub_etl_obj(self.sub2, self.ss0)
self.assertEqual(etl_obj, None)
def testCreditETLObj(self):
cred1 = self.cus1.credit
cred2 = self.cus2.credit
# Test using the latest credit and the latest submissionset
etl_obj = get_cat_etl_obj(cred2, self.ss2)
f = etl_obj['fields']
self.assertEqual(etl_obj['model'], 'stars_content.submissionvalue')
self.assertEqual(f['data_point_key'], "cred_%d" % cred2.id)
self.assertEqual(f['report_version'], self.ss2.creditset.version)
self.assertTrue(cred2.title in f['title'])
self.assertEqual(f['imperial_units'], '%')
self.assertEqual(f['metric_units'], '%')
v = 100 * float(self.cus2.assessed_points) / \
self.cus2.get_available_points(use_cache=True)
self.assertEqual(f['imperial_value'], v)
self.assertEqual(f['metric_value'], v)
self.assertTrue(f['is_current'])
self.assertTrue(f['is_latest'])
# Test using the latest subcategory and an older submissionset
etl_obj = get_cat_etl_obj(cred2, self.ss1)
f = etl_obj['fields']
self.assertEqual(etl_obj['model'], 'stars_content.submissionvalue')
self.assertEqual(f['data_point_key'], "cred_%d" % cred2.id)
self.assertEqual(f['report_version'], self.ss1.creditset.version)
self.assertTrue(cred2.title in f['title'])
self.assertEqual(f['imperial_units'], '%')
self.assertEqual(f['metric_units'], '%')
v = 100 * float(self.cus1.assessed_points) / \
self.cus1.get_available_points(use_cache=True)
self.assertEqual(f['imperial_value'], v)
self.assertEqual(f['metric_value'], v)
self.assertFalse(f['is_current'])
self.assertFalse(f['is_latest'])
# will it work with an older subcategory and newer submissionset?
etl_obj = get_cat_etl_obj(cred1, self.ss2)
f = etl_obj['fields']
self.assertEqual(etl_obj['model'], 'stars_content.submissionvalue')
self.assertEqual(f['data_point_key'], "cred_%d" % cred2.id)
self.assertEqual(f['report_version'], self.ss2.creditset.version)
self.assertTrue(cred1.title in f['title'])
self.assertEqual(f['imperial_units'], '%')
self.assertEqual(f['metric_units'], '%')
v = 100 * float(self.cus2.assessed_points) / \
self.cus2.get_available_points(use_cache=True)
self.assertEqual(f['imperial_value'], v)
self.assertEqual(f['metric_value'], v)
self.assertTrue(f['is_current'])
self.assertTrue(f['is_latest'])
# should be none for unlinked version
etl_obj = get_cat_etl_obj(cred2, self.ss0)
self.assertEqual(etl_obj, None)
def testFieldETLObj(self):
# Test using the latest credit and the latest submissionset
etl_obj = get_df_etl_obj(self.df2, self.ss2)
f = etl_obj['fields']
self.assertEqual(etl_obj['model'], 'stars_content.submissionvalue')
self.assertEqual(f['data_point_key'], "field_%d" % self.df2.id)
self.assertEqual(f['report_version'], self.ss2.creditset.version)
self.assertTrue(self.df2.title in f['title'])
self.assertEqual(f['imperial_units'], 'imp')
self.assertEqual(f['imperial_value'], self.ns2.value)
self.assertEqual(f['metric_units'], 'met')
self.assertEqual(f['metric_value'], self.ns2.metric_value)
self.assertTrue(f['is_current'])
self.assertTrue(f['is_latest'])
# Test using the latest field and an older submissionset
etl_obj = get_df_etl_obj(self.df2, self.ss1)
f = etl_obj['fields']
self.assertEqual(etl_obj['model'], 'stars_content.submissionvalue')
self.assertEqual(f['data_point_key'], "field_%d" % self.df2.id)
self.assertEqual(f['report_version'], self.ss1.creditset.version)
self.assertTrue(self.df2.title in f['title'])
self.assertEqual(f['imperial_units'], 'imp')
self.assertEqual(f['imperial_value'], self.ns1.value)
self.assertEqual(f['metric_units'], 'met')
self.assertEqual(f['metric_value'], self.ns1.metric_value)
self.assertFalse(f['is_current'])
self.assertFalse(f['is_latest'])
# will it work with an older field and newer submissionset?
etl_obj = get_df_etl_obj(self.df1, self.ss2)
f = etl_obj['fields']
self.assertEqual(etl_obj['model'], 'stars_content.submissionvalue')
self.assertEqual(f['data_point_key'], "field_%d" % self.df2.id)
self.assertEqual(f['report_version'], self.ss2.creditset.version)
self.assertTrue(self.df1.title in f['title'])
self.assertEqual(f['imperial_units'], 'imp')
self.assertEqual(f['imperial_value'], self.ns2.value)
self.assertEqual(f['metric_units'], 'met')
self.assertEqual(f['metric_value'], self.ns2.metric_value)
self.assertTrue(f['is_current'])
self.assertTrue(f['is_latest'])
# should be none for unlinked version
etl_obj = get_df_etl_obj(self.df2, self.ss0)
self.assertEqual(etl_obj, None)
def make_two_creditsets():
return (CreditSetFactory(release_date='1970-01-01'),
CreditSetFactory(release_date='1971-10-07'))