def test_get_relative_rating_sorting(self):
"""Does get_ralative_rating choose the correct 1 when there are many?
"""
good_rating = RatingFactory(name="Good", publish_score=True)
reporter_rating = RatingFactory(name="Reporter", publish_score=True)
bad_rating = RatingFactory(name="Bad", publish_score=True)
# A Good submission from 5 days ago:
good_submission = SubmissionSetFactory(
rating=good_rating,
date_submitted=datetime.date.today() - datetime.timedelta(5))
# A Bad submission from yesterday:
SubmissionSetFactory(institution=good_submission.institution,
rating=bad_rating,
date_submitted=datetime.date.today() -
datetime.timedelta(1))
# And a Reporter submission from today:
reporter_submission = SubmissionSetFactory(
institution=good_submission.institution,
rating=reporter_rating,
date_submitted=datetime.date.today())
reporter_submission.institution.current_rating = reporter_rating
reporter_submission.institution.save()
relative_rating = good_submission.institution.get_relative_rating()
self.assertEqual(relative_rating, bad_rating)
def test_user_with_many_stars_accounts(self):
"""Do each of the old paths return 200 if user has > 1 StarsAccount?
"""
user = User.objects.create_user(username='******', password='******')
user.save()
institution1 = InstitutionFactory()
institution2 = InstitutionFactory()
StarsAccountFactory(user=user,
institution=institution1,
user_level='admin',
terms_of_service=True)
submission_set1 = SubmissionSetFactory(institution=institution1)
institution1.current_submission = submission_set1
institution1.save()
StarsAccountFactory(user=user,
institution=institution2,
user_level='admin',
terms_of_service=True)
submission_set2 = SubmissionSetFactory(institution=institution1)
institution2.current_submission = submission_set2
institution2.save()
test_client = test.client.Client()
self.assertTrue(
test_client.login(username=user.username, password='******'))
for old_path in OLD_PATHS_TO_PRESERVE:
path = '/' + old_path
response = test_client.get(path, follow=True)
self.assertEqual(response.status_code, 200)
def test_init_credit_submission_with_non_opt_in_credit(self):
"""Does init_credit_submission() handle non-opt-in Credits correctly?
"""
credit = CreditFactory(is_opt_in=False)
submissionset = SubmissionSetFactory(
creditset=credit.subcategory.category.creditset)
submissionset.init_credit_submissions()
creditsubmission = (submissionset.categorysubmission_set.all()
[0].subcategorysubmission_set.all()
[0].creditusersubmission_set.all()[0])
self.assertNotEqual('na', creditsubmission.submission_status)
def setUp(self):
super(MigrateOptionsViewTest, self).setUp()
self.request.user.user_level = 'admin'
self.r_status_submissionsets = list()
self.f_status_submissionsets = list()
for _ in xrange(2):
self.r_status_submissionsets.append(
SubmissionSetFactory(institution=self.institution, status='r'))
for _ in xrange(2):
self.f_status_submissionsets.append(
SubmissionSetFactory(institution=self.institution, status='f'))
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 test_migrated_from_are_included(self):
"""Are migrated_from SubmissionSets included?"""
ss1 = SubmissionSetFactory(institution=self.institution)
ss2 = SubmissionSetFactory(institution=self.institution,
migrated_from=ss1,
date_created=datetime.date.today())
historical_submissionsets = (get_submissionsets_to_include_in_history(
self.institution))
self.assertEqual([
historical_submissionset.submissionset
for historical_submissionset in historical_submissionsets
], [ss1])
def setUp(self):
institution = InstitutionFactory()
self.pending_submission = SubmissionSetFactory(
institution=institution, status=PENDING_SUBMISSION_STATUS)
self.processing_submission = SubmissionSetFactory(
institution=institution, status=PROCESSSING_SUBMISSION_STATUS)
self.finalized_submission = SubmissionSetFactory(
institution=institution, status=FINALIZED_SUBMISSION_STATUS)
self.rated_submission = SubmissionSetFactory(
institution=institution, status=RATED_SUBMISSION_STATUS)
self.submissions_for_scorecards = views.get_submissions_for_scorecards(
institution=institution)
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 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):
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 test_access_level_in_review_mode(self):
"""When a submission is in review mode, is access_level correct?
"""
institution = InstitutionFactory()
self.assertEqual(institution.access_level, Subscription.BASIC_ACCESS)
institution.current_submission = SubmissionSetFactory(
status=REVIEW_SUBMISSION_STATUS)
institution.save()
self.assertEqual(institution.access_level, Subscription.FULL_ACCESS)
def test_get_relative_rating_no_reporter(self):
"""Is get_relative_rating correct when there's no reporter rating?
"""
good_rating = RatingFactory(name="Good", publish_score=True)
submission = SubmissionSetFactory(rating=good_rating)
submission.institution.current_rating = good_rating
submission.institution.save()
relative_rating = submission.institution.get_relative_rating()
self.assertEqual(relative_rating, good_rating)
def test_get_relative_rating_just_reporter(self):
"""Is get_relative_rating correct when there's only a reporter rating?
"""
reporter_rating = RatingFactory(name="Reporter", publish_score=True)
submission = SubmissionSetFactory(rating=reporter_rating)
submission.institution.current_rating = reporter_rating
submission.institution.save()
relative_rating = submission.institution.get_relative_rating()
self.assertEqual(relative_rating, reporter_rating)
def test_is_participant_in_review_mode(self):
"""When a submission is in review mode, is is_particpant True?
"""
institution = InstitutionFactory()
self.assertFalse(institution.is_participant)
institution.current_submission = SubmissionSetFactory(
status=REVIEW_SUBMISSION_STATUS)
institution.save()
self.assertTrue(institution.is_participant)
def test_rated_are_included(self):
"""Are rated SubmissionSets included?"""
ss = SubmissionSetFactory(status=RATED_SUBMISSION_STATUS,
institution=self.institution,
date_submitted=datetime.date.today())
self.assertEqual([
historicalsubmissionset.submissionset for historicalsubmissionset
in get_submissionsets_to_include_in_history(self.institution)
], [ss])
def test_migrate_submission_sets_migrated_from(self):
"""Does migrate_submission() set SubmissionSet.migrated_from?"""
new_submissionset = SubmissionSetFactory(
institution=self.submissionset.institution,
creditset=self.second_creditset)
utils.migrate_submission(old_submissionset=self.submissionset,
new_submissionset=new_submissionset)
self.assertEqual(new_submissionset.migrated_from, self.submissionset)
def test_get_relative_rating_with_reporter(self):
"""Is get_relative_rating correct when there's no reporter rating?
"""
good_rating = RatingFactory(name="Good", publish_score=True)
reporter_rating = RatingFactory(name="Reporter", publish_score=True)
# A Good submission from 5 days ago:
good_submission = SubmissionSetFactory(
rating=good_rating,
date_submitted=datetime.date.today() - datetime.timedelta(5))
# And a Reporter submission from today:
reporter_submission = SubmissionSetFactory(
institution=good_submission.institution,
rating=reporter_rating,
date_submitted=datetime.date.today())
reporter_submission.institution.current_rating = reporter_rating
reporter_submission.institution.save()
relative_rating = good_submission.institution.get_relative_rating()
self.assertEqual(relative_rating, good_rating)
def test_get_ratings_context(self):
"""Does get_ratings_context return a sensible context?
"""
gold_rating = RatingFactory(name='gold')
for factory in range(2):
InstitutionFactory(current_rating=gold_rating,
current_submission=SubmissionSetFactory(),
rating_expires=datetime.date(2020, 1, 1))
ratings_context = Dashboard().get_ratings_context()
self.assertEqual(2, ratings_context['gold'])
def setUp(self):
super(MigrateViewTest, self).setUp()
self.submissionset = SubmissionSetFactory(institution=self.institution,
status='r')
self.institution.current_submission = self.submissionset
self.institution.save()
current_subscription = SubscriptionFactory(
institution=self.institution,
access_level=Subscription.FULL_ACCESS)
current_subscription.save()
self.c = Client()
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_submissionset(self, creditset, metric_preference=False):
submissionset = SubmissionSetFactory(creditset=creditset)
submissionset.institution.prefers_metric_system = metric_preference
submissionset.institution.save()
self.innovations_numeric_submission = NumericSubmission.objects.create(
documentation_field=self.innovations_documentation_field,
credit_submission=CreditUserSubmission.objects.get(
subcategory_submission__subcategory__slug='innovation'),
value=10,
metric_value=5)
self.not_innovations_numeric_submission = (
NumericSubmission.objects.create(
documentation_field=self.not_innovations_documentation_field,
credit_submission=CreditUserSubmission.objects.get(
subcategory_submission__subcategory__slug='not-innovation'
),
value=20))
return submissionset
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 test_unrated_and_not_migrated_to_are_excluded(self):
"""Are unrated and not migrated_to SubmissionSets excluded?"""
_ = SubmissionSetFactory(institution=self.institution)
self.assertEqual(
get_submissionsets_to_include_in_history(self.institution), [])
def setUp(self):
super(SubmissionSetIsNotLockedMixinTest, self).setUp()
self.institution = InstitutionFactory(slug='hey-baby-you-look-lonely')
self.account = StarsAccountFactory(institution=self.institution)
self.request.user = self.account.user
self.submission = SubmissionSetFactory(institution=self.institution)
def setUp(self):
super(SubmissionSummaryViewTest, self).setUp()
self.institution = InstitutionFactory()
self.account = StarsAccountFactory(institution=self.institution)
self.request.user = self.account.user
self.submission = SubmissionSetFactory(institution=self.institution)
def submissionset(self):
if not self._submissionset:
self._submissionset = SubmissionSetFactory(
creditset=self.first_creditset)
return self._submissionset
