def setUp(self):
request = RequestFactory().get('/')
handler = init_handler(ModelHandler(), request)
handler.model = User
self.handler = handler
mommy.make(User, 10)
def test_update_question_order_page(self):
listing_form = ListingTemplate.objects.create(name='l12', description='desc1')
kwargs = {'name': 'survey11', 'description': 'survey description demo12',
'has_sampling': True, 'sample_size': 10,'listing_form_id':listing_form.id}
survey_obj = Survey.objects.create(**kwargs)
batch_obj = Batch.objects.create(name='b1',description='d1', survey=survey_obj)
qset = QuestionSet.get(id=batch_obj.id)
question1 = mommy.make(Question, qset=qset, answer_type=NumericalAnswer.choice_name())
QuestionOption.objects.create(
question=question1,
order=1,
text="q7"
)
question2 = mommy.make(Question, qset=qset, answer_type=NumericalAnswer.choice_name())
QuestionOption.objects.create(
question=question1,
order=4,
text="q4"
)
QuestionFlow.objects.create(
name = 'a1',
desc = 'descq',
question = question2,
question_type = TextAnswer.choice_name(),
next_question = question1,
next_question_type = TextAnswer.choice_name()
)
QuestionLoop.objects.create(
loop_starter = question2,
loop_ender = question1
)
url = reverse('update_question_order_page', kwargs={"batch_id" : batch_obj.id})
response = self.client.post(url,data={"order_information": [batch_obj.id]})
self.assertIn(response.status_code, [200, 302])
def setUp(self):
self.user = User.objects.create_user(username='******', password='******')
self.client.login(username='******', password='******')
self.loja = mommy.make(Loja, dono=self.user)
self.produto = mommy.make(Produto)
self.url = mommy.make(Url)
def test_siguiente_movimiento(self):
tipo_movimiento = mommy.make(TipoMovimiento, codigo= '', incrementa = True)
mov1 = mommy.make(Movimiento, id_movimiento = '', fecha_operacion = datetime.now(), tipo_movimiento = tipo_movimiento)
mov2 = mommy.make(Movimiento, id_movimiento = '', fecha_operacion = datetime.now(), tipo_movimiento = tipo_movimiento)
mov3 = mommy.make(Movimiento, id_movimiento = '', fecha_operacion = datetime.now(), tipo_movimiento = tipo_movimiento)
self.assertEqual(mov2.pk, mov1.siguiente())
self.assertEqual(mov3.pk, mov2.siguiente())
def setUp(self):
self.admin_user = User.objects.create_superuser(
'*****@*****.**', 'example')
self.future_date = timezone.now().date() + timedelta(days=10)
self.job_open = mommy.make(
Job,
review_status=Job.OPEN,
)
self.job_under_review = mommy.make(
Job,
review_status=Job.UNDER_REVIEW,
reviewer=self.admin_user,
)
self.job_ready_to_publish = mommy.make(
Job,
review_status=Job.READY_TO_PUBLISH,
reviewer=self.admin_user,
)
self.job_published = mommy.make(
Job,
review_status=Job.PUBLISHED,
reviewer=self.admin_user,
published_date=timezone.now(),
expiration_date=self.future_date,
)
self.job_rejected = mommy.make(
Job,
review_status=Job.REJECTED,
reviewer=self.admin_user,
)
self.client.login(username=self.admin_user.email, password='******')
def test_allow_create_fkey_related_model(self):
try:
person = mommy.make(Person, dog_set=[mommy.make(Dog), mommy.make(Dog)])
except TypeError:
self.fail('type error raised')
self.assertEqual(person.dog_set.count(), 2)
def test_h1(self):
testuser = mommy.make(settings.AUTH_USER_MODEL)
mommy.make('core.Candidate', relatedstudent__user=testuser)
mockresponse = self.mock_http200_getrequest_htmls(requestuser=testuser)
self.assertEqual(
'Student dashboard',
mockresponse.selector.one('h1').alltext_normalized)
def test_recipient_list_filtering(self):
course = mommy.make(Course)
contributor1 = mommy.make(UserProfile)
contributor2 = mommy.make(UserProfile, delegates=[contributor1])
mommy.make(Contribution, course=course, contributor=contributor1)
mommy.make(Contribution, course=course, contributor=contributor2)
# no-one should get filtered.
recipient_list = EmailTemplate.recipient_list_for_course(course, [EmailTemplate.CONTRIBUTORS], filter_users_in_cc=False)
self.assertCountEqual(recipient_list, [contributor1, contributor2])
# contributor1 is in cc of contributor2 and gets filtered.
recipient_list = EmailTemplate.recipient_list_for_course(course, [EmailTemplate.CONTRIBUTORS], filter_users_in_cc=True)
self.assertCountEqual(recipient_list, [contributor2])
contributor3 = mommy.make(UserProfile, delegates=[contributor2])
mommy.make(Contribution, course=course, contributor=contributor3)
# again, no-one should get filtered.
recipient_list = EmailTemplate.recipient_list_for_course(course, [EmailTemplate.CONTRIBUTORS], filter_users_in_cc=False)
self.assertCountEqual(recipient_list, [contributor1, contributor2, contributor3])
# contributor1 is in cc of contributor2 and gets filtered.
# contributor2 is in cc of contributor3 but is not filtered since contributor1 wouldn't get an email at all then.
recipient_list = EmailTemplate.recipient_list_for_course(course, [EmailTemplate.CONTRIBUTORS], filter_users_in_cc=True)
self.assertCountEqual(recipient_list, [contributor2, contributor3])
def test_results_are_filtered_based_on_queryset(self):
class Car(models.Model):
name = models.CharField(max_length=255)
class CarIndex(Index):
class Meta:
fields = ['name']
model = Car
with connection.schema_editor() as editor:
editor.create_model(Car)
# the signal handler will automatically add these to ES for us
car = make(Car, name="hi", pk=1)
car2 = make(Car, name="hi 2", pk=2)
car3 = make(Car, name="hi 3", pk=3)
class Form(SearchForm):
def get_queryset(self):
# we purposely exclude one of the options, so we can test that
# it isn't in the search results
return super().get_queryset().exclude(pk=1)
form = Form({"q": "hi"}, index=CarIndex)
# the count should be 2 (not 3), since the queryset excluded Car.pk=1
self.assertEqual(form.search().count(), 2)
results = form.results(page=1)
self.assertEqual(set(results), set([car2, car3]))
class Form(BaseSearchForm):
pass
form = Form({"q": "hi"}, index=CarIndex)
self.assertEqual(set(form.results()), set([car, car2, car3]))
def setUp(self):
AL = mommy.make(
State,
fips='01',
abbr='AL',
name='Alabama')
Autauga = mommy.make(
County,
id=2891,
fips='01001',
name='Autauga County',
state=AL,
valid=True)
mommy.make(
CountyMortgageData,
fips='01001',
date=self.start_date,
total=1464,
current=1443,
thirty=10,
sixty=5,
ninety=4,
other=2,
county=Autauga)
def setUpTestData(cls):
cls.semester = mommy.make(Semester)
cls.course = mommy.make(Course, pk=7, state="published", semester=cls.semester)
users = mommy.make(UserProfile, _quantity=3)
cls.course.participants = users
cls.course.voters = users[:2]
def setUp(self):
FL = mommy.make(
State,
fips='12',
abbr='FL',
ap_abbr='Fla.',
counties='["12081"]',
msas='["52081"]',
name='Florida',
non_msa_counties='["12001"]',
non_msa_valid=True)
FL.save()
mommy.make(
County,
fips='12081',
name='Manatee County',
state=FL,
valid=True)
# real values from a base CSV row
self.data_header = 'date,fips,open,current,thirty,sixty,ninety,other\n'
self.data_row = '09/01/16,12081,1952,1905,21,5,10,11\n'
self.data_row_dict = {'date': '09/01/16',
'fips': '12081',
'open': '1952',
'current': '1905',
'thirty': '21',
'sixty': '5',
'ninety': '10',
'other': '11'}
def setUp(self):
self.old_dade_fips = '12025'
self.new_dade_fips = '12086'
mommy.make(
CountyMortgageData,
current=100,
date=datetime.date(2008, 1, 1),
fips=self.old_dade_fips,
ninety=100,
other=100,
sixty=100,
thirty=100,
total=500)
mommy.make(
CountyMortgageData,
current=100,
date=datetime.date(2008, 1, 1),
fips=self.new_dade_fips,
ninety=100,
other=100,
sixty=100,
thirty=100,
total=500)
def test_section_and_triptype_preferences(self):
reg = mommy.make(Registration, trips_year=self.trips_year)
triptype = mommy.make(TripType, pk=1, trips_year=self.trips_year)
section = mommy.make(
Section,
pk=1,
trips_year=self.trips_year,
leaders_arrive=date(2015, 1, 1),
name='A',
)
data = {'triptype_1': 'FIRST CHOICE', 'section_1': 'PREFER'}
data.update(self.REGISTRATION_DATA)
form = RegistrationForm(trips_year=self.trips_year, instance=reg, data=data)
reg = form.save()
self.assertEqual(form.fields['section_1'].label, 'A — Jan 02 to Jan 06')
tts = reg.registrationtriptypechoice_set.all()
self.assertEqual(len(tts), 1)
self.assertEqual(tts[0].triptype, triptype)
self.assertEqual(tts[0].preference, 'FIRST CHOICE')
secs = reg.registrationsectionchoice_set.all()
self.assertEqual(len(secs), 1)
self.assertEqual(secs[0].section, section)
self.assertEqual(secs[0].preference, 'PREFER')
def test_trippee_med_info_is_deleted(self):
trips_year = self.init_trips_year()
trippee = mommy.make(
IncomingStudent,
trips_year=trips_year,
med_info='sparkles',
)
registration = mommy.make(
Registration,
trips_year=trips_year,
medical_conditions='magic',
food_allergies='mangoes',
dietary_restrictions='gluten free',
needs='dinosaurs',
epipen=True
)
forward() # to next year
trippee.refresh_from_db()
registration.refresh_from_db()
self.assertEqual(trippee.med_info, '')
self.assertEqual(registration.medical_conditions, '')
self.assertEqual(registration.food_allergies, '')
self.assertEqual(registration.dietary_restrictions, '')
self.assertEqual(registration.needs, '')
self.assertIsNone(registration.epipen)
def test_registration_connects_to_incoming(self):
t = mommy.make(Timetable)
t.trippee_registrations_open += timedelta(-1)
t.trippee_registrations_close += timedelta(1)
t.save()
mommy.make(Settings, trips_year=self.trips_year)
user = self.make_incoming_student()
student = mommy.make(
IncomingStudent, trips_year=self.trips_year, netid=user.netid
)
reg_data = {
'name': 'test',
'gender': 'hi',
'previous_school': 'nah',
'phone': '134',
'email': '*****@*****.**',
'tshirt_size': 'L',
'regular_exercise': False,
'swimming_ability': 'BEGINNER',
'camping_experience': False,
'hiking_experience': True,
'financial_assistance': True,
'waiver': True,
'doc_membership': False,
'green_fund_donation': 0,
}
url = reverse('incoming:register')
self.app.post(url, params=reg_data, user=user)
registration = Registration.objects.get()
student = IncomingStudent.objects.get()
self.assertEqual(registration.trippee, student)
def test_get_gender_with_registration(self):
""" Pull from registration, if available """
reg = mommy.make(Registration, trips_year=self.trips_year, gender='FEMALE')
incoming = mommy.make(
IncomingStudent, trips_year=self.trips_year, gender='MALE', registration=reg
)
self.assertEqual(incoming.get_gender(), 'female')
def test_non_swimmer_availability_for_trip(self):
trip = mommy.make(
Trip, trips_year=self.trips_year, template__swimtest_required=True
)
available = mommy.make(
IncomingStudent,
trips_year=self.trips_year,
registration__swimming_ability=Registration.BEGINNER,
)
available.registration.set_section_preference(trip.section, PREFER)
available.registration.set_triptype_preference(
trip.template.triptype, AVAILABLE
)
unavailable = mommy.make(
IncomingStudent,
trips_year=self.trips_year,
registration__swimming_ability=Registration.NON_SWIMMER,
)
unavailable.registration.set_section_preference(trip.section, PREFER)
unavailable.registration.set_triptype_preference(
trip.template.triptype, AVAILABLE
)
self.assertQsEqual(
IncomingStudent.objects.available_for_trip(trip), [available]
)
def test_passengers_from_hanover(self):
rte = mommy.make(Route, trips_year=self.trips_year, category=Route.EXTERNAL)
sxn = mommy.make(Section, trips_year=self.trips_year)
psngr1 = mommy.make(
IncomingStudent,
trips_year=self.trips_year,
bus_assignment_round_trip__route=rte,
trip_assignment__section=sxn,
)
psngr2 = mommy.make(
IncomingStudent,
trips_year=self.trips_year,
bus_assignment_from_hanover__route=rte,
trip_assignment__section=sxn,
)
not_psngr = mommy.make(
IncomingStudent,
trips_year=self.trips_year,
bus_assignment_to_hanover__route=rte,
trips_assignment__section=sxn,
)
target = [psngr1, psngr2]
actual = IncomingStudent.objects.passengers_from_hanover(
self.trips_year, rte, sxn
)
self.assertQsEqual(actual, target)
def test_get_city_id_case_insensitive_twice(self):
city = mommy.make(models.City, name="abcd", parent=self.parent)
city2 = mommy.make(models.City, name="ABCD", parent=self.parent)
city_in_other_country = mommy.make(models.City, name="abcd", parent=self.foreign_country)
response = self.client.get(reverse('crm_get_city_id')+"?name="+"ABCD"+"&country=0")
self.assertEqual(200, response.status_code)
self.assertContains(response, "ABCD")
def test_private_course(self):
student = UserProfile.objects.get(username="******")
contributor = UserProfile.objects.get(username="******")
responsible = UserProfile.objects.get(username="******")
test1 = mommy.make(UserProfile, username="******")
test2 = mommy.make(UserProfile, username="******")
mommy.make(UserProfile, username="******")
degree = mommy.make(Degree)
private_course = mommy.make(Course, state='published', is_private=True, semester=self.semester, participants=[student, test1, test2], voters=[test1, test2], degrees=[degree])
mommy.make(Contribution, course=private_course, contributor=responsible, can_edit=True, responsible=True, comment_visibility=Contribution.ALL_COMMENTS)
mommy.make(Contribution, course=private_course, contributor=contributor, can_edit=True)
url = '/results/semester/%s' % (self.semester.id)
page = self.app.get(url, user='******')
self.assertNotIn(private_course.name, page)
page = self.app.get(url, user='******')
self.assertIn(private_course.name, page)
page = self.app.get(url, user='******')
self.assertIn(private_course.name, page)
page = self.app.get(url, user='******')
self.assertIn(private_course.name, page)
page = self.app.get(url, user='******')
self.assertIn(private_course.name, page)
url = '/results/semester/%s/course/%s' % (self.semester.id, private_course.id)
self.get_assert_403(url, "random")
self.get_assert_200(url, "student")
self.get_assert_200(url, "responsible")
self.get_assert_200(url, "contributor")
self.get_assert_200(url, "evap")
def test_post_initial_empty_comment_can_be_edited(self):
testgroup = mommy.make('core.AssignmentGroup', parentnode__parentnode=self.__make_active_period())
testuser = mommy.make(settings.AUTH_USER_MODEL)
self.__make_examiner_for_user(user=testuser, group=testgroup)
testfeedbackset = group_mommy.feedbackset_first_attempt_unpublished(group=testgroup)
groupcomment = mommy.make('devilry_group.GroupComment',
user=testuser,
user_role='examiner',
feedback_set=testfeedbackset)
messagesmock = mock.MagicMock()
self.mock_http302_postrequest(
cradmin_role=testgroup,
requestuser=testuser,
viewkwargs={'pk': groupcomment.id},
requestkwargs={
'data': {
'text': 'edited'
}
},
messagesmock=messagesmock)
db_comment = group_models.GroupComment.objects.get(id=groupcomment.id)
edit_history = group_models.GroupCommentEditHistory.objects.get()
self.assertEqual(group_models.GroupCommentEditHistory.objects.count(), 1)
self.assertEqual('edited', db_comment.text)
self.assertEqual('', edit_history.pre_edit_text)
self.assertEqual('edited', edit_history.post_edit_text)
messagesmock.add.assert_called_once_with(messages.SUCCESS, 'Comment updated!', '')
def test_only_admin_or_coordinator_can_edit_course(client, admin_client):
course = Course.objects.create(slug='dbsql', name='A course', abstract='asdf')
professor = create_user('professor')
client.login(username=professor.username, password='******')
response = client.post('/api/course/{}'.format(str(course.id)),
{'id': course.id,
'slug': course.slug,
'abstract': 'A abstract'},
content_type='application/json;charset=UTF-8')
assert response.status_code == 403
assert course.abstract == 'asdf'
mommy.make('CourseProfessor', user=professor, course=course, role='coordinator')
response = client.post('/api/course/{}'.format(str(course.id)), {'id': str(course.id),
'slug': course.slug,
'abstract': 'A abstract'})
changed_course = Course.objects.get(id=course.id)
assert response.status_code == 200
assert changed_course.abstract == 'A abstract'
response = admin_client.post('/api/course/{}'.format(str(course.id)), {'id': str(course.id),
'slug': course.slug,
'abstract': 'Another abstract'})
changed_course = Course.objects.get(id=course.id)
assert response.status_code == 200
assert changed_course.abstract == 'Another abstract'
def test_publish_latest_offer_publishes_oldest_offer(self):
"""
Test that publish_latest_offer publishes the oldest offer
"""
self.offer.delete()
offers = mommy.make(
Offer,
_quantity=3,
is_ready=True,
is_request=True,
status=Offer.UNPUBLISHED,
provider=self.provider,
creator=self.user
)
# Create some offers who should not be affected since they are invalid
mommy.make(Offer, is_ready=False, is_request=True)
mommy.make(Offer, status=Offer.PUBLISHED)
# Set the oldest to newest
offers[0].readied_at -= timedelta(days=3)
offers[1].readied_at -= timedelta(days=2)
offers[2].readied_at -= timedelta(days=1)
self.assertTrue(publish_latest_offer.delay().successful())
new_offer = Offer.objects.get(pk=offers[0].pk)
self.assertEqual(new_offer.status, Offer.PUBLISHED)
self.assertFalse(new_offer.is_request)
self.assertEqual(Offer.objects.filter(status=Offer.PUBLISHED, is_request=False).count(), 2)
def test_get_courses_user_has_role(client):
course = mommy.make('Course', slug='dbsql', name='A course')
another_course = mommy.make('Course', slug='mysql', name='Another course')
course_whose_professor_coordinate = mommy.make('Course', slug='coordinatedcourse',
name='Course whose professor coordinate')
another_course_whose_professor_coordinate = mommy.make('Course', slug='anothercoordinatedcourse',
name='Another course whose professor coordinate')
professor1 = assign_professor_to_course(course, new_professor_username='******', role='assistant')
assign_professor_to_course(another_course, existing_professor=professor1, role='assistant')
assign_professor_to_course(course_whose_professor_coordinate, existing_professor=professor1, role='coordinator')
assign_professor_to_course(another_course_whose_professor_coordinate, existing_professor=professor1,
role='coordinator')
client.login(username=professor1.username, password='******')
response = client.get('/my-courses/')
assert response.status_code == 200
courses_user_assist = response.context[-1]['courses_user_assist']
assert courses_user_assist
courses_user_coordinate = response.context[-1]['courses_user_coordinate']
assert courses_user_coordinate
def setUp(self):
self.fecha_actual = date.today()
self.fecha_proxima = date(2017,1,1)
self.pe1 = mommy.make(Pedido,codigo = '',fecha = self.fecha_actual)
self.pe2 = mommy.make(Pedido,codigo = '',fecha = self.fecha_actual)
self.pe3 = mommy.make(Pedido,codigo = '',fecha = self.fecha_actual)
self.pe4 = mommy.make(Pedido,codigo = '',fecha = self.fecha_proxima)
def setUp(self):
self.provider = mommy.make(Provider)
self.offer = mommy.make(Offer, provider=self.provider, status=Offer.PUBLISHED)
self.user = User.objects.create_user('user', '*****@*****.**', 'pass')
self.user.user_profile.provider = self.provider
self.user.user_profile.save()
def test_post_comment_private_history_visibility(self):
testgroup = mommy.make('core.AssignmentGroup', parentnode__parentnode=self.__make_active_period())
testuser = mommy.make(settings.AUTH_USER_MODEL)
self.__make_examiner_for_user(user=testuser, group=testgroup)
testfeedbackset = group_mommy.feedbackset_first_attempt_unpublished(group=testgroup)
groupcomment = mommy.make('devilry_group.GroupComment',
user=testuser,
user_role='examiner',
text='unedited',
part_of_grading=True,
visibility=group_models.GroupComment.VISIBILITY_PRIVATE,
feedback_set=testfeedbackset)
messagesmock = mock.MagicMock()
self.mock_http302_postrequest(
cradmin_role=testgroup,
requestuser=testuser,
viewkwargs={'pk': groupcomment.id},
requestkwargs={
'data': {
'text': 'edited'
}
},
messagesmock=messagesmock)
edit_history_entry = group_models.GroupCommentEditHistory.objects.get()
self.assertEqual(edit_history_entry.visibility, group_models.GroupComment.VISIBILITY_PRIVATE)
def test_anterior_movimiento(self):
tipo_movimiento = mommy.make(TipoMovimiento, codigo= '', incrementa = False)
mov1 = mommy.make(Movimiento, id_movimiento = '', fecha_operacion = datetime.now(), tipo_movimiento = tipo_movimiento)
mov2 = mommy.make(Movimiento, id_movimiento = '', fecha_operacion = datetime.now(), tipo_movimiento = tipo_movimiento)
mov3 = mommy.make(Movimiento, id_movimiento = '', fecha_operacion = datetime.now(), tipo_movimiento = tipo_movimiento)
self.assertEqual(mov1.pk, mov2.anterior())
self.assertEqual(mov2.pk, mov3.anterior())
def setUp(self):
self.division = mommy.make(JobCategory)
self.region = mommy.make(JobRegion)
page_clean = patch('jobmanager.models.pages.CFGOVPage.clean')
page_clean.start()
self.addCleanup(page_clean.stop)
def setUp(self):
mommy.make(State,
fips='12',
abbr='FL',
ap_abbr='Fla.',
counties=["12081"],
msas=["52081"],
name='Florida',
non_msa_counties=["12001"],
non_msa_valid=True)
mommy.make(County,
fips='12081',
name='Manatee County',
state=State.objects.get(fips='12'),
valid=True)
mommy.make(MetroArea,
fips='35840',
name='North Port-Sarasota-Bradenton, FL',
states=["12"],
counties=["12081", "12115"],
valid=True)
mommy.make(CountyMortgageData,
current=1250,
date=datetime.date(2008, 1, 1),
county=County.objects.get(fips='12081'),
fips='12081',
id=1,
ninety=100,
other=100,
sixty=100,
thirty=100,
total=1650)
mommy.make(MSAMortgageData,
current=5250,
date=datetime.date(2008, 1, 1),
msa=MetroArea.objects.get(fips='35840'),
fips='35840',
id=1,
ninety=1406,
other=361,
sixty=1275,
thirty=3676,
total=22674)
mommy.make(NonMSAMortgageData,
current=5250,
date=datetime.date(2008, 1, 1),
state=State.objects.get(fips='12'),
fips='12-non',
id=1,
ninety=1406,
other=361,
sixty=1275,
thirty=3676,
total=22674)
mommy.make(StateMortgageData,
current=250081,
date=datetime.date(2008, 1, 1),
state=State.objects.get(fips='12'),
fips='12',
id=1,
ninety=4069,
other=3619,
sixty=2758,
thirty=6766,
total=26748)
mommy.make(NationalMortgageData,
current=2500000,
date=datetime.date(2008, 1, 1),
fips='12',
id=1,
ninety=10000,
other=10000,
sixty=10000,
thirty=10000,
total=2540000)
def setUp(self):
self.cargo = mommy.make('Cargo')
def setUp(self):
self.servico = mommy.make('Servico')
def setUp(self):
from v1.models import HomePage
self.factory = RequestFactory()
self.superuser = User.objects.create_superuser(
username='******', password='******', email='*****@*****.**'
)
self.site = Site.objects.get(is_default_site=True)
self.ROOT_PAGE = HomePage.objects.get(slug='cfgov')
self.landing_page = RegulationLandingPage(
title='Reg Landing', slug='reg-landing')
self.ROOT_PAGE.add_child(instance=self.landing_page)
self.part_1002 = mommy.make(
Part,
part_number='1002',
title='Equal Credit Opportunity Act',
letter_code='B',
chapter='X'
)
self.part_1030 = mommy.make(
Part,
part_number='1030',
title='Truth In Savings',
letter_code='DD', chapter='X'
)
self.effective_version = mommy.make(
EffectiveVersion,
effective_date=datetime.date(2014, 1, 18),
part=self.part_1002
)
self.old_effective_version = mommy.make(
EffectiveVersion,
effective_date=datetime.date(2011, 1, 1),
part=self.part_1002,
)
self.draft_effective_version = mommy.make(
EffectiveVersion,
effective_date=datetime.date(2020, 1, 1),
part=self.part_1002,
draft=True,
)
self.subpart = mommy.make(
Subpart,
label='Subpart General',
title='Subpart A - General',
subpart_type=Subpart.BODY,
version=self.effective_version
)
self.subpart_appendices = mommy.make(
Subpart,
label='Appendices',
title='Appendices',
subpart_type=Subpart.APPENDIX,
version=self.effective_version
)
self.subpart_interps = mommy.make(
Subpart,
label='Official Interpretations',
title='Supplement I to Part 1002',
subpart_type=Subpart.INTERPRETATION,
version=self.effective_version
)
self.subpart_orphan = mommy.make(
Subpart,
label='General Mistake',
title='An orphan subpart with no sections for testing',
version=self.effective_version
)
self.old_subpart = mommy.make(
Subpart,
label='Subpart General',
title='General',
subpart_type=Subpart.BODY,
version=self.old_effective_version
)
self.section_num4 = mommy.make(
Section,
label='4',
title='\xa7\xa01002.4 General rules.',
contents=(
'{a}\n(a) Regdown paragraph a.\n'
'{b}\n(b) Paragraph b\n'
'\nsee(4-b-Interp)\n'
'{c}\n(c) Paragraph c.\n'
'{c-1}\n \n'
'{d}\n(1) General rule. A creditor that provides in writing.\n'
),
subpart=self.subpart,
)
self.graph_to_keep = mommy.make(
SectionParagraph,
section=self.section_num4,
paragraph_id='d',
paragraph=(
'(1) General rule. A creditor that provides in writing.')
)
self.graph_to_delete = mommy.make(
SectionParagraph,
section=self.section_num4,
paragraph_id='x',
paragraph='(x) Non-existent graph that should get deleted.'
)
self.section_num15 = mommy.make(
Section,
label='15',
title='\xa7\xa01002.15 Rules concerning requests for information.',
contents='regdown content.',
subpart=self.subpart,
)
self.section_alpha = mommy.make(
Section,
label='A',
title=('Appendix A to Part 1002-Federal Agencies '
'To Be Listed in Adverse Action Notices'),
contents='regdown content.',
subpart=self.subpart_appendices,
)
self.section_beta = mommy.make(
Section,
label='B',
title=('Appendix B to Part 1002-Errata'),
contents='regdown content.',
subpart=self.subpart_appendices,
)
self.section_interps = mommy.make(
Section,
label='Interp-A',
title=('Official interpretations for Appendix A to Part 1002'),
contents='interp content.',
subpart=self.subpart_interps,
)
self.old_section_num4 = mommy.make(
Section,
label='4',
title='\xa7\xa01002.4 General rules.',
contents='regdown contents',
subpart=self.old_subpart,
)
self.reg_page = RegulationPage(
regulation=self.part_1002,
title='Reg B',
slug='1002')
self.reg_search_page = RegulationsSearchPage(
title="Search regulations",
slug='search-regulations')
self.landing_page.add_child(instance=self.reg_page)
self.landing_page.add_child(instance=self.reg_search_page)
self.reg_page.save()
self.reg_search_page.save()
CACHE_PURGED_URLS[:] = []
def test_altering_workflowjob_job_should_invalidate(self):
self.test_workflowjob.job = mommy.make("rodan.Job")
self.test_workflowjob.save()
# Refetch
wf = Workflow.objects.get(uuid=self.test_workflow.uuid)
self.assertFalse(wf.valid)
def test_creating_workflowjob_should_invalidate(self):
wfj3 = mommy.make("rodan.WorkflowJob", workflow=self.test_workflow)
# Refetch
wf = Workflow.objects.get(uuid=self.test_workflow.uuid)
self.assertFalse(wf.valid)
def setUp(self):
FL = mommy.make(State,
fips='12',
abbr='FL',
ap_abbr='Fla.',
counties='["12081"]',
msas='["52081"]',
name='Florida',
non_msa_counties='["12001"]',
non_msa_valid=True)
FL.save()
manatee = mommy.make(County,
fips='12081',
name='Manatee County',
state=FL,
valid=True)
manatee.save()
mommy.make(MetroArea,
fips='35840',
name='North Port-Sarasota-Bradenton, FL',
counties='["12081"]',
states='["12"]',
valid=True)
mommy.make(CountyMortgageData,
date=datetime.date(2016, 1, 1),
fips='12081',
county=manatee)
mommy.make(MSAMortgageData,
current=5250,
date=datetime.date(2016, 1, 1),
fips='35840',
msa=MetroArea.objects.get(fips='35840'),
id=1,
ninety=1406,
other=361,
sixty=1275,
thirty=3676,
total=22674)
mommy.make(NonMSAMortgageData,
current=250081,
date=datetime.date(2016, 1, 1),
fips='12-non',
state=State.objects.get(fips='12'),
id=1,
ninety=4069,
other=3619,
sixty=2758,
thirty=6766,
total=26748)
mommy.make(StateMortgageData,
current=250081,
date=datetime.date(2016, 1, 1),
state=State.objects.get(fips='12'),
fips='12',
id=1,
ninety=4069,
other=3619,
sixty=2758,
thirty=6766,
total=26748)
def test_group_comment_edit_history_created_on_update_sanity(self):
group_comment = mommy.make('devilry_group.GroupComment')
group_comment.save()
self.assertEqual(GroupCommentEditHistory.objects.count(), 1)
self.assertEqual(CommentEditHistory.objects.count(), 1)
def _setup_user(self):
self.user = mommy.make(settings.AUTH_USER_MODEL,
username='******',
is_active=True)
self.user.set_password('secret')
self.user.save()
def modulos(db):
return [mommy.make(Modulo, titulo=s) for s in 'Antes Depois'.split()]
def setUp(self):
self.top_advert = mommy.make(Advertisement,
ad_type=Advertisement.TOP_AD)
self.side_adverts = mommy.make(Advertisement,
ad_type=Advertisement.SIDE_AD,
_quantity=4)
def test_group_comment_edit_history_not_created_on_create_sanity(self):
mommy.make('devilry_group.GroupComment')
self.assertEqual(GroupCommentEditHistory.objects.count(), 0)
self.assertEqual(CommentEditHistory.objects.count(), 0)
def setUp(self, *args, **kwargs):
self.factory = RequestFactory()
self.tournament = mommy.make(Tournament)
self.pools = mommy.make(Pool, tournament=self.tournament, _quantity=4)
def _setup_fixture(self):
mommy.make('product.Brand', pk=16)
def setUpTestData(cls):
mommy.make(Product, id=1, name="coca", nutriscore="E")
mommy.make(Product, id=30, name="coca light", nutriscore="E")
mommy.make(Product, id=15, name="coca cherry", nutriscore="E")
mommy.make(Product, id=11, name="orangina", nutriscore="E")
def setUp(self):
"""Sets the common objects between the tests."""
self.generator = ValidationTokenGenerator()
self.user = mommy.make(User)
self.user.set_password(self.user.password)
self.user.save()
def test_category_creation(self):
c = mommy.make(Category)
self.assertTrue(isinstance(c, Category))
self.assertEqual(c.__str__(), c.name)
def setUp(self):
self.client = Client()
# create products
c1 = mommy.make(Category, id=1, name="Boissons gazeuses")
c2 = mommy.make(Category, id=2, name="Gateaux")
p1 = mommy.make(Product,
id=1,
name="coca",
nutriscore="E",
category=c1)
p2 = mommy.make(Product,
id=30,
name="Perrier",
nutriscore="A",
category=c1)
p3 = mommy.make(Product,
id=15,
name="Badoit",
nutriscore="A",
category=c1)
p4 = mommy.make(Product,
id=11,
name="orangina",
nutriscore="E",
category=c1)
p5 = mommy.make(Product,
id=55,
name="Biscuit Bio",
nutriscore="A",
category=c2)
p6 = mommy.make(Product,
id=67,
name="Gateau sans gluten",
nutriscore="A",
category=c2)
# create ratings
mommy.make(RatingProduct, product=p1, rating=1)
mommy.make(RatingProduct, product=p2, rating=4)
mommy.make(RatingProduct, product=p3, rating=3)
mommy.make(RatingProduct, product=p4, rating=2)
mommy.make(RatingProduct, product=p5, rating=4)
mommy.make(RatingProduct, product=p6, rating=5)
def test_get_all_messages_percentage(self):
message1 = mommy.make("MotivationMessage",
message="message 1",
frequency_min=65,
frequency_max=65)
message2 = mommy.make("MotivationMessage",
message="message 2",
frequency_min=60)
message3 = mommy.make("MotivationMessage",
message="message 3",
frequency_max=65)
mommy.make("MotivationMessage",
message="message 4",
frequency_min=66,
frequency_max=66)
mommy.make("MotivationMessage",
message="message 5",
frequency_min=64,
frequency_max=64)
mommy.make("MotivationMessage", message="message 6", frequency_min=66)
mommy.make("MotivationMessage", message="message 7", frequency_max=64)
messages = MotivationMessage._get_all_messages(
self.user_attendance).order_by("id")
self.assertQuerysetEqual(messages, [message1, message2, message3],
transform=lambda x: x)
def test_product_creation(self):
new_product = mommy.make('openfoodfacts.Product')
self.assertTrue(isinstance(new_product, Product))
self.assertEqual(new_product.__str__(), new_product.name)
def test_get_random_simple(self):
"""Random enabled message from set with highest priority should be returned"""
message1 = mommy.make("MotivationMessage",
message="message1",
priority=2)
message2 = mommy.make("MotivationMessage",
message="message2",
priority=2)
mommy.make("MotivationMessage", message="message2d", enabled=False)
mommy.make("MotivationMessage", message="message3", priority=1)
mommy.make("MotivationMessage", message="message4", priority=1)
mommy.make("MotivationMessage", message="message5", priority=1)
mommy.make("MotivationMessage", message="message6")
message = MotivationMessage.get_random_message(self.user_attendance)
self.assertTrue(message in (message1, message2))
def setUpTestData(cls):
mommy.make(Product, id=33, name="test")
def test_chu_rating(self):
chu = mommy.make(models.CommunityHealthUnit, name='di chu')
self.check_repr(models.CHURating(chu=chu, rating=4), 'di chu - 4')
def test_get_all_messages_date(self):
message1 = mommy.make(
"MotivationMessage",
message="message 1",
date_from=datetime.date(2010, 11, 20),
date_to=datetime.date(2010, 11, 20),
)
message2 = mommy.make(
"MotivationMessage",
message="message 2",
date_from=datetime.date(2010, 11, 20),
)
message3 = mommy.make(
"MotivationMessage",
message="message 3",
date_to=datetime.date(2010, 11, 20),
)
mommy.make(
"MotivationMessage",
message="message 4",
date_from=datetime.date(2010, 11, 21),
date_to=datetime.date(2010, 11, 21),
)
mommy.make(
"MotivationMessage",
message="message 5",
date_from=datetime.date(2010, 11, 21),
)
mommy.make(
"MotivationMessage",
message="message 6",
date_from=datetime.date(2010, 11, 19),
date_to=datetime.date(2010, 11, 19),
)
mommy.make(
"MotivationMessage",
message="message 7",
date_to=datetime.date(2010, 11, 19),
)
messages = MotivationMessage._get_all_messages(
self.user_attendance).order_by("id")
self.assertQuerysetEqual(messages, (message1, message2, message3),
transform=lambda x: x)
def test_chuservice(self):
x = 'jina'
self.check_repr(mommy.make(models.CHUService, name=x), x)
def test_get_all_messages_rank(self):
message1 = mommy.make("MotivationMessage",
message="message1",
team_rank_from=2,
team_rank_to=2)
message2 = mommy.make("MotivationMessage",
message="message2",
team_rank_from=2)
message3 = mommy.make("MotivationMessage",
message="message3",
team_rank_to=3)
mommy.make("MotivationMessage",
message="message4",
team_rank_from=1,
team_rank_to=1)
mommy.make("MotivationMessage",
message="message5",
team_rank_from=3,
team_rank_to=3)
mommy.make("MotivationMessage", message="message6", team_rank_from=3)
mommy.make("MotivationMessage", message="message7", team_rank_to=1)
messages = MotivationMessage._get_all_messages(
self.user_attendance).order_by("id")
self.assertQuerysetEqual(messages, (message1, message2, message3),
transform=lambda x: x)
def test_cc_report_error_post(self):
mommy.make(EventCCInstance, event=self.e, crew_chief=self.user)
self.assertOk(
self.client.post(reverse("my:report", args=[self.e.pk]), ))
self.assertEqual(
list(self.e.ccreport_set.filter(crew_chief=self.user)), [])
def test_chw(self):
health_unit = mommy.make(models.CommunityHealthUnit, name='jina')
instance = mommy.make(models.CommunityHealthWorker,
first_name="fname",
health_unit=health_unit)
self.check_repr(instance, "fname (jina)")
def test_cc_report_blank(self):
mommy.make(EventCCInstance, event=self.e, crew_chief=self.user)
self.assertOk(self.client.get(reverse("my:report", args=[self.e.pk])))
def test_sendcurrentmatchups(self, mock_notify_players):
"""
Test that we call notify_players for any current matchups
"""
bracket = mommy.make(Bracket)
round_1 = mommy.make(
Round,
bracket=bracket,
start_datetime=timezone.now() - datetime.timedelta(days=8),
end_datetime=timezone.now() - datetime.timedelta(days=1))
round_2 = mommy.make(
Round,
bracket=bracket,
start_datetime=timezone.now() - datetime.timedelta(days=1),
end_datetime=timezone.now() + datetime.timedelta(days=6))
round_3 = mommy.make(
Round,
bracket=bracket,
start_datetime=timezone.now() + datetime.timedelta(days=6),
end_datetime=timezone.now() + datetime.timedelta(days=13))
match_1 = mommy.make(Match,
player_1_init=mommy.make(Player),
player_2_init=mommy.make(Player),
round=round_1)
match_2 = mommy.make(Match,
player_1_init=mommy.make(Player),
player_2_init=mommy.make(Player),
round=round_2)
match_3 = mommy.make(Match,
player_1_init=mommy.make(Player),
player_2_init=mommy.make(Player),
round=round_2)
match_4 = mommy.make(Match,
player_1_init=mommy.make(Player),
player_2_init=mommy.make(Player),
round=round_3)
call_command('sendcurrentmatchups')
self.assertEqual(mock_notify_players.call_count, 2)
