def test_view_list_default_view_current_conf_exists(self):
'''
/scheduler/view_list/ should return all events in the current
conference, assuming a current conference exists
'''
other_conf = ConferenceFactory(status='completed')
show = ShowFactory(e_conference=self.conf)
generic_event = GenericEventFactory(e_conference=self.conf)
accepted_class = ClassFactory(accepted=3,
e_conference=self.conf,
b_conference=self.conf)
previous_class = ClassFactory(accepted=3,
e_conference=other_conf,
b_conference=other_conf)
rejected_class = ClassFactory(accepted=1,
e_conference=self.conf,
b_conference=self.conf)
url = reverse("event_list", urlconf="gbe.scheduling.urls")
login_as(ProfileFactory(), self)
response = self.client.get(url)
self.assertContains(response, generic_event.e_title)
self.assertContains(response, show.e_title)
self.assertContains(response, accepted_class.e_title)
self.assertNotContains(response, rejected_class.e_title)
self.assertNotContains(response, previous_class.e_title)
def test_get_tickets_for_class(self):
'''get one ticket for everything but master, and one for classes
'''
event = ClassFactory()
ws_bpt_event = BrownPaperEventsFactory(
conference=event.e_conference,
include_most=True,
title="The Whole Shebang 2016")
sch_bpt_event = BrownPaperEventsFactory(
conference=event.e_conference,
include_conference=True,
title="The Scholar 2016")
whole_shebang = TicketItemFactory(
bpt_event=ws_bpt_event,
live=True,
has_coupon=False)
scholar = TicketItemFactory(
bpt_event=sch_bpt_event,
live=True,
has_coupon=False)
tickets = event.get_tickets()
self.assertEqual(len(tickets), 2)
self.assertEqual(
tickets[0],
ws_bpt_event)
self.assertEqual(
tickets[1],
sch_bpt_event)
class TestClassChangestate(TestCase):
'''Tests for act_changestate view'''
view_name = 'class_changestate'
def setUp(self):
self.client = Client()
self.klass = ClassFactory()
self.privileged_user = ProfileFactory().user_object
grant_privilege(self.privileged_user, 'Class Coordinator')
self.data = {'accepted': '3'}
def test_class_changestate_authorized_user(self):
'''The proper coordinator is changing the state, it works'''
url = reverse(self.view_name, args=[self.klass.pk], urlconf='gbe.urls')
login_as(self.privileged_user, self)
response = self.client.post(url, data=self.data)
nt.assert_equal(response.status_code, 302)
def test_class_accepted_displays_on_scheduler(self):
'''check that bid acceptance sets e_title & e_description'''
self.klass.e_title = ''
self.klass.e_description = ''
self.klass.save()
url = reverse(self.view_name, args=[self.klass.pk], urlconf='gbe.urls')
grant_privilege(self.privileged_user, 'Scheduling Mavens')
login_as(self.privileged_user, self)
response = self.client.post(url, data=self.data)
sched_url = reverse('create_class_wizard',
urlconf='gbe.scheduling.urls',
args=[self.klass.b_conference.conference_slug])
response = self.client.post(sched_url)
print response
assert self.klass.b_title in response.content
def test_class_changestate_unauthorized_user(self):
'''A regular user is changing the state, it fails'''
url = reverse(self.view_name, args=[self.klass.pk], urlconf='gbe.urls')
login_as(ProfileFactory(), self)
response = self.client.post(url, data=self.data)
nt.assert_equal(response.status_code, 403)
def test_class_changestate_clear_schedule(self):
'''The proper coordinator is changing the state, it works'''
context = ClassContext()
url = reverse(self.view_name,
args=[context.bid.pk],
urlconf='gbe.urls')
login_as(self.privileged_user, self)
response = self.client.post(url, data={'accepted': '1'})
assert not context.bid.scheduler_events.exists()
def test_class_changestate_bad_data(self):
'''The proper coordinator is changing the state, it works'''
url = reverse(self.view_name, args=[self.klass.pk], urlconf='gbe.urls')
login_as(self.privileged_user, self)
response = self.client.post(url, data={'accepted': '-1'})
assert response.status_code == 200
assert 'Bid Information' in response.content
def setUp(self):
self.client = Client()
self.performer = PersonaFactory()
self.privileged_profile = ProfileFactory()
self.privileged_user = self.privileged_profile.user_object
grant_privilege(self.privileged_user, 'Class Reviewers')
self.conference = current_conference()
ClassFactory.create_batch(4,
b_conference=self.conference,
e_conference=self.conference,
submitted=True)
def test_auth_user_load_panel(self):
panel = ClassFactory(b_conference=self.current_conference,
e_conference=self.current_conference,
type="Panel",
accepted=3,
teacher=self.teacher,
submitted=True)
login_as(self.privileged_user, self)
data = self.get_data()
data['accepted_class'] = panel.pk
response = self.client.post(
self.url,
data=data,
follow=True)
self.assertContains(
response,
'value="%s"' %
panel.b_title)
self.assertContains(response, "Panelist")
self.assertContains(response, "Moderator")
self.assertContains(
response,
'<option value="%d" selected>%s</option>' % (
panel.teacher.pk,
str(panel.teacher)),
html=True)
def test_view_list_only_classes(self):
'''
/scheduler/view_list/ should return all events in the current
conference, assuming a current conference exists
'''
show = ShowFactory(e_conference=self.conf)
generic_event = GenericEventFactory(e_conference=self.conf)
accepted_class = ClassFactory(accepted=3,
e_conference=self.conf,
b_conference=self.conf)
url = reverse("event_list",
urlconf="gbe.scheduling.urls",
args=['Class'])
login_as(ProfileFactory(), self)
response = self.client.get(url)
self.assertNotContains(response, show.e_title)
self.assertNotContains(response, generic_event.e_title)
self.assertContains(response, accepted_class.e_title)
url = reverse("event_list",
urlconf="gbe.scheduling.urls",
args=['class'])
response = self.client.get(url)
self.assertNotContains(response, show.e_title)
self.assertNotContains(response, generic_event.e_title)
self.assertContains(response, accepted_class.e_title)
def post_class_edit_draft(self):
klass = ClassFactory()
url = reverse(self.view_name, args=[klass.pk], urlconf='gbe.urls')
login_as(klass.teacher.performer_profile, self)
data = self.get_form(submit=False)
response = self.client.post(url, data=data, follow=True)
return response, data
def clone_class(self):
bid = ClassFactory(b_conference=self.old_conference,
e_conference=self.old_conference)
bid.b_title = "Factory is broken"
bid.save()
count = Class.objects.filter(
b_title=bid.b_title,
b_conference=self.current_conference).count()
url = reverse(self.view_name,
urlconf="gbe.urls",
kwargs={'bid_type': 'Class',
'bid_id': bid.id})
login_as(bid.teacher.contact, self)
response = self.client.get(url)
return response, count, bid
def __init__(self,
bid=None,
teacher=None,
conference=None,
room=None,
starttime=None):
self.teacher = teacher or PersonaFactory()
self.conference = conference or ConferenceFactory()
if not self.conference.conferenceday_set.exists():
day = ConferenceDayFactory(conference=self.conference)
if starttime:
day.day = starttime.date()
day.save()
self.days = self.conference.conferenceday_set.all()
self.starttime = starttime or noon(self.days[0])
self.bid = bid or ClassFactory(b_conference=self.conference,
e_conference=self.conference,
accepted=3,
teacher=self.teacher,
submitted=True)
self.room = room or RoomFactory()
self.room.conferences.add(self.conference)
self.sched_event = None
self.sched_event = self.schedule_instance(room=self.room,
starttime=starttime)
def test_authorized_user_single_conference(self):
other_class = ClassFactory(accepted=3,
submitted=True)
login_as(self.privileged_user, self)
response = self.client.get(self.url)
self.assertNotContains(response, str(other_class.b_title))
self.assertNotContains(response, str(other_class.teacher))
def test_view_list_given_slug(self):
other_conf = ConferenceFactory()
this_class = ClassFactory.create(accepted=3,
e_conference=self.conf,
b_conference=self.conf)
that_class = ClassFactory.create(accepted=3,
e_conference=other_conf,
b_conference=other_conf)
login_as(ProfileFactory(), self)
url = reverse("event_list",
urlconf="gbe.scheduling.urls",
args=["Class"])
response = self.client.get(
url, data={"conference": self.conf.conference_slug})
self.assertContains(response, this_class.e_title)
self.assertNotContains(response, that_class.e_title)
def test_edit_bid_not_post(self):
'''edit_bid, not post, should take us to edit process'''
klass = ClassFactory()
url = reverse(self.view_name, args=[klass.pk], urlconf='gbe.urls')
login_as(klass.teacher.performer_profile, self)
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertTrue('Submit a Class' in response.content)
def test_edit_bid_verify_avoided_constraints(self):
klass = ClassFactory()
url = reverse(self.view_name, args=[klass.pk], urlconf='gbe.urls')
login_as(klass.teacher.performer_profile, self)
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertTrue('I Would Prefer to Avoid' in response.content)
self.assertTrue('Submit a Class' in response.content)
def test_edit_bid_verify_info_popup_text(self):
klass = ClassFactory()
url = reverse(self.view_name, args=[klass.pk], urlconf='gbe.urls')
login_as(klass.teacher.performer_profile, self)
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertTrue(
'We will do our best to accommodate' in response.content)
def test_review_class_post_form_invalid(self):
klass = ClassFactory()
url = reverse(self.view_name, args=[klass.pk], urlconf='gbe.urls')
login_as(self.privileged_user, self)
response = self.client.post(url, data={'accepted': 1})
self.assertEqual(response.status_code, 200)
self.assertContains(response, 'Bid Information')
def test_unsched_class(self):
bid_class = ClassFactory()
response = self.client.get(
reverse(self.view_name,
urlconf="gbe.scheduling.urls",
args=[bid_class.eventitem_id]))
self.assertEqual(200, response.status_code)
self.assertEqual(1, response.content.count(bid_class.teacher.name))
def setUp(self):
self.room = RoomFactory()
self.teacher = PersonaFactory()
self.current_conference = ConferenceFactory(accepting_bids=True)
self.day = ConferenceDayFactory(conference=self.current_conference)
self.test_class = ClassFactory(b_conference=self.current_conference,
e_conference=self.current_conference,
accepted=3,
teacher=self.teacher,
submitted=True)
self.url = reverse(self.view_name,
args=[self.current_conference.conference_slug],
urlconf='gbe.scheduling.urls')
self.factory = RequestFactory()
self.client = Client()
self.privileged_user = ProfileFactory().user_object
grant_privilege(self.privileged_user, 'Scheduling Mavens')
def test_review_class_w_scheduling(self):
grant_privilege(self.privileged_user, 'Scheduling Mavens')
klass = ClassFactory()
url = reverse(self.view_name, args=[klass.pk], urlconf='gbe.urls')
login_as(self.privileged_user, self)
response = self.client.get(url)
self.assertContains(response, 'name="extra_button"')
def test_view_panels(self):
this_class = ClassFactory.create(accepted=3,
e_conference=self.conf,
b_conference=self.conf,
type="Panel")
that_class = ClassFactory.create(accepted=3,
e_conference=self.conf,
b_conference=self.conf)
login_as(ProfileFactory(), self)
url = reverse("event_list",
urlconf="gbe.scheduling.urls",
args=["Panel"])
response = self.client.get(
url, data={"conference": self.conf.conference_slug})
self.assertContains(response, this_class.e_title)
self.assertNotContains(response, that_class.e_title)
self.assertContains(response, this_class.teacher.name)
def test_view_class(self):
'''view_class view, success
'''
klass = ClassFactory()
url = reverse(self.view_name, args=[klass.pk], urlconf='gbe.urls')
login_as(klass.teacher.performer_profile, self)
response = self.client.get(url)
assert response.status_code == 200
def test_bad_user(self):
klass = ClassFactory()
reviewer = ProfileFactory()
grant_privilege(reviewer, 'Class Reviewers')
login_as(reviewer, self)
url = reverse(self.view_name, args=[klass.pk], urlconf="gbe.urls")
response = self.client.get(url)
assert "Review Bids" in response.content
assert response.status_code == 200
def test_class_edit_post_form_not_valid(self):
'''class_edit, if form not valid, should return to ActEditForm'''
klass = ClassFactory()
url = reverse(self.view_name, args=[klass.pk], urlconf='gbe.urls')
login_as(klass.teacher.performer_profile, self)
data = self.get_form(invalid=True)
response = self.client.post(url, data=data)
self.assertEqual(response.status_code, 200)
self.assertTrue('Submit a Class' in response.content)
def test_review_class_how_heard_is_present(self):
klass = ClassFactory()
klass.teacher.contact.how_heard = "[u'Facebook']"
klass.teacher.contact.save()
url = reverse(self.view_name, args=[klass.pk], urlconf='gbe.urls')
login_as(self.privileged_user, self)
response = self.client.get(url)
self.assertContains(response, 'Facebook')
def test_classes_to_review(self):
staff_profile = ProfileFactory(user_object__is_staff=True)
grant_privilege(staff_profile, "Class Reviewers")
login_as(staff_profile, self)
klass = ClassFactory(submitted=True,
b_conference=self.current_conf,
e_conference=self.current_conf)
url = reverse('home', urlconf='gbe.urls')
response = self.client.get(url)
nt.assert_true(klass.b_title in response.content)
def test_pick_no_post_action(self):
second_class = ClassFactory(accepted=2)
login_as(self.privileged_profile, self)
data = {
'email-select-conference': [self.context.conference.pk],
'email-select-bid_type': self.priv_list,
'email-select-state': [0, 1, 2, 3, 4, 5],
}
response = self.client.post(self.url, data=data, follow=True)
assert_alert_exists(response, 'danger', 'Error', unknown_request)
def test_get_tickets_for_class_three_ways(self):
'''the ticket is linked to the class event three ways - 'most',
'conference', and a direct link. It only should appear once.
'''
event = ClassFactory()
ticketing_event = TicketingEventsFactory(
conference=event.e_conference,
include_most=True,
include_conference=True,
title="The Whole Shebang 2016")
ticketing_event.linked_events.add(event)
ticketing_event.save()
TicketItemFactory(ticketing_event=ticketing_event,
live=True,
has_coupon=False)
tickets = event.get_tickets()
self.assertEqual(len(tickets), 1)
self.assertEqual(tickets[0].title, "The Whole Shebang 2016")
def test_review_class_no_how_heard(self):
klass = ClassFactory()
klass.teacher.contact.how_heard = '[]'
klass.teacher.contact.save()
url = reverse(self.view_name, args=[klass.pk], urlconf='gbe.urls')
login_as(self.privileged_user, self)
response = self.client.get(url)
self.assertNotContains(response, '[]')
self.assertContains(response, "The Presenter")
def test_review_class_all_well(self):
klass = ClassFactory()
url = reverse(self.view_name,
args=[klass.pk],
urlconf='gbe.urls')
login_as(self.privileged_user, self)
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
self.assertTrue('Bid Information' in response.content)
def test_review_class_inactive_user(self):
ClassFactory(teacher__contact__user_object__is_active=False,
b_conference=self.conference,
e_conference=self.conference,
submitted=True)
url = reverse(self.view_name, urlconf="gbe.urls")
login_as(self.privileged_user, self)
response = self.client.get(
url, data={'conf_slug': self.conference.conference_slug})
self.assertContains(response, 'gbe-table-row gbe-table-danger')
def test_get_tickets_nothing_active(self):
'''the ticket is linked to the class and there are two active prices
only the most expensive is shown
'''
event = ClassFactory()
ticketing_event = TicketingEventsFactory(conference=event.e_conference,
include_conference=True)
TicketItemFactory(ticketing_event=ticketing_event,
live=False,
has_coupon=False,
title="The Whole Shebang 2016")
TicketItemFactory(ticketing_event=ticketing_event,
live=True,
has_coupon=True,
cost=299.99,
title="The Whole Shebang 2016 - expensive")
tickets = event.get_tickets()
self.assertEqual(len(tickets), 0)
def test_get_tickets_for_class_three_ways(self):
'''the ticket is linked to the class event three ways - 'most',
'conference', and a direct link. It only should appear once.
'''
event = ClassFactory()
bpt_event = BrownPaperEventsFactory(
conference=event.e_conference,
include_most=True,
include_conference=True,
title="The Whole Shebang 2016")
bpt_event.linked_events.add(event)
bpt_event.save()
TicketItemFactory(bpt_event=bpt_event,
live=True,
has_coupon=False)
tickets = event.get_tickets()
self.assertEqual(len(tickets), 1)
self.assertEqual(
tickets[0].title,
"The Whole Shebang 2016")
def test_get_tickets_nothing_active(self):
'''the ticket is linked to the class and there are two active prices
only the most expensive is shown
'''
event = ClassFactory()
bpt_event = BrownPaperEventsFactory(
conference=event.e_conference,
include_conference=True)
TicketItemFactory(bpt_event=bpt_event,
live=False,
has_coupon=False,
title="The Whole Shebang 2016")
TicketItemFactory(bpt_event=bpt_event,
live=True,
has_coupon=True,
cost=299.99,
title="The Whole Shebang 2016 - expensive")
tickets = event.get_tickets()
self.assertEqual(len(tickets), 0)
def setUp(self):
self.room = RoomFactory()
self.teacher = PersonaFactory()
self.current_conference = ConferenceFactory(accepting_bids=True)
self.day = ConferenceDayFactory(conference=self.current_conference)
self.test_class = ClassFactory(b_conference=self.current_conference,
e_conference=self.current_conference,
accepted=3,
teacher=self.teacher,
submitted=True)
self.url = reverse(
self.view_name,
args=[self.current_conference.conference_slug],
urlconf='gbe.scheduling.urls')
self.factory = RequestFactory()
self.client = Client()
self.privileged_user = ProfileFactory().user_object
grant_privilege(self.privileged_user, 'Scheduling Mavens')
class TestClassWizard(TestCase):
'''Tests for the 2nd and 3rd stage in the class wizard view'''
view_name = 'create_class_wizard'
def setUp(self):
self.room = RoomFactory()
self.teacher = PersonaFactory()
self.current_conference = ConferenceFactory(accepting_bids=True)
self.day = ConferenceDayFactory(conference=self.current_conference)
self.test_class = ClassFactory(b_conference=self.current_conference,
e_conference=self.current_conference,
accepted=3,
teacher=self.teacher,
submitted=True)
self.url = reverse(
self.view_name,
args=[self.current_conference.conference_slug],
urlconf='gbe.scheduling.urls')
self.factory = RequestFactory()
self.client = Client()
self.privileged_user = ProfileFactory().user_object
grant_privilege(self.privileged_user, 'Scheduling Mavens')
def get_data(self):
data = {
'accepted_class': self.test_class.pk,
'pick_class': 'Next'
}
return data
def edit_class(self):
data = {
'accepted': 3,
'submitted': True,
'eventitem_id': self.test_class.eventitem_id,
'type': 'Panel',
'e_title': "Test Class Wizard #%d" % self.test_class.eventitem_id,
'e_description': 'Description',
'maximum_enrollment': 10,
'fee': 0,
'max_volunteer': 0,
'day': self.day.pk,
'time': '11:00:00',
'duration': 2.5,
'location': self.room.pk,
'alloc_0-role': 'Teacher',
'alloc_0-worker': self.teacher.pk,
'alloc_1-role': 'Volunteer',
'alloc_1-worker': "",
'set_class': 'Finish',
}
return data
def test_create_event_unauthorized_user(self):
login_as(ProfileFactory(), self)
response = self.client.get(self.url)
self.assertEqual(403, response.status_code)
def test_authorized_user_can_access(self):
login_as(self.privileged_user, self)
response = self.client.get(self.url)
self.assertEqual(response.status_code, 200)
assert_event_was_picked_in_wizard(response, "conference")
self.assertContains(response, str(self.test_class.b_title))
self.assertContains(response, str(self.test_class.teacher))
def test_authorized_user_single_conference(self):
other_class = ClassFactory(accepted=3,
submitted=True)
login_as(self.privileged_user, self)
response = self.client.get(self.url)
self.assertNotContains(response, str(other_class.b_title))
self.assertNotContains(response, str(other_class.teacher))
def test_auth_user_can_pick_class(self):
login_as(self.privileged_user, self)
data = self.get_data()
response = self.client.post(
self.url,
data=data,
follow=True)
self.assertContains(
response,
'<input checked="checked" id="id_accepted_class_1" ' +
'name="accepted_class" type="radio" value="%d" />' %
self.test_class.pk)
def test_invalid_form(self):
login_as(self.privileged_user, self)
data = self.get_data()
data['accepted_class'] = "boo"
response = self.client.post(
self.url,
data=data)
self.assertContains(
response,
'That choice is not one of the available choices.')
def test_auth_user_pick_new_class(self):
login_as(self.privileged_user, self)
data = self.get_data()
data['accepted_class'] = ""
response = self.client.post(
self.url,
data=data,
follow=True)
self.assertContains(
response,
'<input checked="checked" id="id_accepted_class_0" ' +
'name="accepted_class" type="radio" value="" />')
self.assertContains(
response,
'Make New Class')
self.assertContains(
response,
'type="number" value="1"')
self.assertContains(
response,
'<option value="%d">%s</option>' % (
self.day.pk,
self.day.day.strftime(DATE_FORMAT)
))
self.assertContains(
response,
'<option value="%s" selected="selected">%s</option>' % (
'Teacher',
'Teacher'))
def test_auth_user_load_class(self):
login_as(self.privileged_user, self)
data = self.get_data()
response = self.client.post(
self.url,
data=data,
follow=True)
self.assertContains(
response,
'value="%s"' %
self.test_class.b_title)
self.assertContains(
response,
'type="number" value="1.0"')
self.assertContains(
response,
'<option value="%d">%s</option>' % (
self.day.pk,
self.day.day.strftime(DATE_FORMAT)
))
self.assertContains(
response,
'<option value="%d" selected="selected">%s</option>' % (
self.test_class.teacher.pk,
str(self.test_class.teacher)))
def test_auth_user_load_panel(self):
panel = ClassFactory(b_conference=self.current_conference,
e_conference=self.current_conference,
type="Panel",
accepted=3,
teacher=self.teacher,
submitted=True)
login_as(self.privileged_user, self)
data = self.get_data()
data['accepted_class'] = panel.pk
response = self.client.post(
self.url,
data=data,
follow=True)
self.assertContains(
response,
'value="%s"' %
panel.b_title)
self.assertContains(response, "Panelist")
self.assertContains(response, "Moderator")
self.assertContains(
response,
'<option value="%d" selected="selected">%s</option>' % (
panel.teacher.pk,
str(panel.teacher)))
def test_auth_user_edit_class(self):
login_as(self.privileged_user, self)
data = self.edit_class()
response = self.client.post(
self.url,
data=data,
follow=True)
occurrence = Event.objects.filter(eventitem=self.test_class)
self.assertRedirects(
response,
"%s?%s-day=%d&filter=Filter&new=[%dL]" % (
reverse('manage_event_list',
urlconf='gbe.scheduling.urls',
args=[self.current_conference.conference_slug]),
self.current_conference.conference_slug,
self.day.pk,
occurrence[0].pk))
assert_alert_exists(
response,
'success',
'Success',
'Occurrence has been updated.<br>%s, Start Time: %s 11:00 AM' % (
data['e_title'],
self.day.day.strftime(DATE_FORMAT))
)
self.assertContains(
response,
'<tr class="bid-table success">\n ' +
'<td class="bid-table">%s</td>' % data['e_title'])
def test_auth_user_create_class(self):
login_as(self.privileged_user, self)
data = self.edit_class()
data['eventitem_id'] = ""
response = self.client.post(
self.url,
data=data,
follow=True)
new_class = Class.objects.get(e_title=data['e_title'])
self.assertEqual(new_class.teacher, self.teacher)
occurrence = Event.objects.get(
eventitem__eventitem_id=new_class.eventitem_id)
self.assertRedirects(
response,
"%s?%s-day=%d&filter=Filter&new=[%dL]" % (
reverse('manage_event_list',
urlconf='gbe.scheduling.urls',
args=[self.current_conference.conference_slug]),
self.current_conference.conference_slug,
self.day.pk,
occurrence.pk))
assert_alert_exists(
response,
'success',
'Success',
'Occurrence has been updated.<br>%s, Start Time: %s 11:00 AM' % (
data['e_title'],
self.day.day.strftime(DATE_FORMAT))
)
self.assertContains(
response,
'<tr class="bid-table success">\n ' +
'<td class="bid-table">%s</td>' % data['e_title'])
def test_auth_user_create_class_no_teacher(self):
login_as(self.privileged_user, self)
data = self.edit_class()
data['eventitem_id'] = ""
data['alloc_0-worker'] = ""
response = self.client.post(
self.url,
data=data,
follow=True)
assert_alert_exists(
response,
'danger',
'Error',
"You must select at least one person to run this class."
)
def test_auth_user_bad_user_assign(self):
login_as(self.privileged_user, self)
data = self.edit_class()
data['alloc_0-role'] = "bad role"
response = self.client.post(
self.url,
data=data,
follow=True)
self.assertContains(
response,
"bad role is not one of the available choices.")
def test_auth_user_bad_schedule_assign(self):
login_as(self.privileged_user, self)
data = self.edit_class()
data['location'] = ""
response = self.client.post(
self.url,
data=data,
follow=True)
self.assertContains(response, "This field is required.")
def test_auth_user_bad_class_booking_assign(self):
login_as(self.privileged_user, self)
data = self.edit_class()
data['type'] = "bad type"
response = self.client.post(
self.url,
data=data,
follow=True)
self.assertContains(
response,
"bad type is not one of the available choices.")
def test_get_class_recommendations(self):
self.test_class.schedule_constraints = "[u'1']"
self.test_class.avoided_constraints = "[u'2']"
self.test_class.space_needs = "2"
self.test_class.type = "Panel"
self.test_class.save()
login_as(self.privileged_user, self)
data = self.get_data()
response = self.client.post(
self.url,
data=data,
follow=True)
assert_good_sched_event_form_wizard(response, self.test_class)
def test_get_empty_schedule_info(self):
self.test_class.schedule_constraints = ""
self.test_class.avoided_constraints = ""
self.test_class.space_needs = ""
self.test_class.type = ""
self.test_class.save()
login_as(self.privileged_user, self)
data = self.get_data()
response = self.client.post(
self.url,
data=data,
follow=True)
assert_good_sched_event_form_wizard(response, self.test_class)
def setUp(self):
self.client = Client()
self.klass = ClassFactory()
self.privileged_user = ProfileFactory().user_object
grant_privilege(self.privileged_user, 'Class Coordinator')
self.data = {'accepted': '3'}
class TestClassChangestate(TestCase):
'''Tests for act_changestate view'''
view_name = 'class_changestate'
def setUp(self):
self.client = Client()
self.klass = ClassFactory()
self.privileged_user = ProfileFactory().user_object
grant_privilege(self.privileged_user, 'Class Coordinator')
self.data = {'accepted': '3'}
def test_class_changestate_authorized_user(self):
'''The proper coordinator is changing the state, it works'''
url = reverse(self.view_name,
args=[self.klass.pk],
urlconf='gbe.urls')
login_as(self.privileged_user, self)
response = self.client.post(url, data=self.data)
nt.assert_equal(response.status_code, 302)
def test_class_accepted_displays_on_scheduler(self):
'''check that bid acceptance sets e_title & e_description'''
self.klass.e_title = ''
self.klass.e_description = ''
self.klass.save()
url = reverse(self.view_name,
args=[self.klass.pk],
urlconf='gbe.urls')
grant_privilege(self.privileged_user, 'Scheduling Mavens')
login_as(self.privileged_user, self)
response = self.client.post(url, data=self.data)
sched_url = reverse('create_class_wizard',
urlconf='gbe.scheduling.urls',
args=[self.klass.b_conference.conference_slug])
response = self.client.post(sched_url)
print response
assert self.klass.b_title in response.content
def test_class_changestate_unauthorized_user(self):
'''A regular user is changing the state, it fails'''
url = reverse(self.view_name,
args=[self.klass.pk],
urlconf='gbe.urls')
login_as(ProfileFactory(), self)
response = self.client.post(url, data=self.data)
nt.assert_equal(response.status_code, 403)
def test_class_changestate_clear_schedule(self):
'''The proper coordinator is changing the state, it works'''
context = ClassContext()
url = reverse(self.view_name,
args=[context.bid.pk],
urlconf='gbe.urls')
login_as(self.privileged_user, self)
response = self.client.post(url, data={'accepted': '1'})
assert not context.bid.scheduler_events.exists()
def test_class_changestate_bad_data(self):
'''The proper coordinator is changing the state, it works'''
url = reverse(self.view_name,
args=[self.klass.pk],
urlconf='gbe.urls')
login_as(self.privileged_user, self)
response = self.client.post(url, data={'accepted': '-1'})
assert response.status_code == 200
assert 'Bid Information' in response.content
