Пример #1
0
    def setup(self):
        self.event1 = Event2019Factory.create(event_name="All set")
        self.event2 = Event2019Factory.create(event_name="Need Chiefs")
        self.event2.datetime_setup_complete = timezone.now(
        ) + timezone.timedelta(days=1)
        self.event2.datetime_start = timezone.now() + timezone.timedelta(
            days=2)
        self.event2.datetime_end = timezone.now() + timezone.timedelta(days=3)
        self.event2.approved = True
        self.event2.save()

        self.lighting = Category.objects.create(name="Lighting")
        self.sound = Category.objects.create(name="Sound")
        self.l1 = Service.objects.create(shortname="L1",
                                         longname="Basic Lighting",
                                         base_cost=10.00,
                                         addtl_cost=5.00,
                                         category=self.lighting)
        self.s1 = Service.objects.create(shortname="S1",
                                         longname="Basic Sound",
                                         base_cost=10.00,
                                         addtl_cost=5.00,
                                         category=self.sound)

        self.service1 = ServiceInstance.objects.create(service=self.l1,
                                                       event=self.event1)
        self.service2 = ServiceInstance.objects.create(service=self.s1,
                                                       event=self.event2)
Пример #2
0
    def test_user_detail_view(self):
        self.setup()
        # Should be allowed to view own profile
        self.assertOk(self.client.get(reverse("accounts:detail", args=[1])))

        # Should not be allowed to view user profile without view_user permission
        self.assertOk(self.client.get(reverse("accounts:detail", args=[self.user2.pk])), 403)

        permission = Permission.objects.get(codename="view_user")
        self.user.user_permissions.add(permission)

        self.assertOk(self.client.get(reverse("accounts:detail", args=[self.user2.pk])))

        # Same permissions currently apply for accessing member profiles
        # (To require view_member permissions for this as well, you would need to update the Mixin)
        self.associate.user_set.add(self.user2)

        # Make sure user has missing CC report
        event = Event2019Factory.create(event_name="Test Event")
        event.datetime_end = timezone.now() + timezone.timedelta(days=-1)
        category = Category.objects.create(name="Lighting")
        service = Service.objects.create(shortname="L1", longname="Lights", base_cost=10.00, addtl_cost=5.00,
                                         category=category)
        building = Building.objects.create(name="Some Building", shortname="Building")
        location = Location.objects.create(name="Some Location", building=building)

        EventCCInstance.objects.create(event=event, crew_chief=self.user2, category=category, service=service,
                                       setup_location=location)

        self.assertOk(self.client.get(reverse("accounts:detail", args=[self.user2.pk])))
Пример #3
0
    def setUp(self):
        self.e = EventFactory.create(event_name="Test Event")
        self.e2 = EventFactory.create(event_name="Other Test Event")
        self.e3 = Event2019Factory.create(event_name="2019 Test Event")
        self.e4 = Event2019Factory.create(event_name="Another 2019 Test Event")
        self.user = UserFactory.create(password='******')
        self.client.login(username=self.user.username, password='******')

        self.category = Category.objects.create(name="Lighting")
        self.category.save()
        sound_cat = Category.objects.create(name="Sound")
        sound_cat.save()

        lighting = Lighting.objects.create(shortname="L1",
                                           longname="Basic Lighting",
                                           base_cost=10.00,
                                           addtl_cost=5.00,
                                           category=self.category)
        lighting.save()
        self.lighting = ServiceInstance.objects.create(service=lighting,
                                                       event=self.e3)
        self.lighting.save()
        self.extra = Extra.objects.create(name="Test Extra",
                                          cost=10.00,
                                          desc="A test extra",
                                          category=self.category)
        self.extra.save()
        self.extra_instance = ExtraInstance.objects.create(event=self.e4,
                                                           extra=self.extra,
                                                           quant=1)
        self.extra_instance.save()

        self.organization = Organization.objects.create(
            name="Test org", phone="1234567890", user_in_charge=self.user)
        self.organization.save()
        self.e4.org.add(self.organization)
        self.multibilling = MultiBilling.objects.create(
            date_billed=timezone.datetime.today(),
            amount=20.00,
            org=self.organization)
        self.multibilling.save()
        self.multibilling.events.add(self.e2)
        self.multibilling.events.add(self.e4)
Пример #4
0
    def test_crew_endpoint(self):
        models.Endpoint.objects.create(name="Crew Checkin", url="crew/checkin", description="Checkin to events",
                                       example="user=12345&event=1", response="[]")
        models.Endpoint.objects.create(name="Crew Checkout", url="crew/checkout", description="Checkout from events",
                                       example="user=12345&event=1", response="[]")

        # Get token for authentication
        token, created = Token.objects.get_or_create(user=self.user)
        client = APIClient()
        client.credentials(HTTP_AUTHORIZATION='Token ' + token.key)

        # Test that only POST requests are permitted
        self.assertOk(client.get("/api/v1/crew/checkin"), 405)
        self.assertOk(client.get("/api/v1/crew/checkout"), 405)

        # Test that student ID is required (the next several tests will be the same for both actions)
        self.assertOk(client.post("/api/v1/crew/checkin", {'event': 1}), 400)

        # Test that failure to provide event id results in 400
        self.assertOk(client.post("/api/v1/crew/checkin", {'id': 12345}), 400)

        # Return 404 if user cannot be found with student ID
        self.assertOk(client.post("/api/v1/crew/checkin", {'id': 12345, 'event': 1}), 404)

        self.user.student_id = 12345
        self.user.save()

        # Return error if event cannot be found or is otherwise not eligible for checkin / checkout
        self.assertOk(client.post("/api/v1/crew/checkin", {'id': 12345, 'event': 1}), 404)

        event = Event2019Factory.create(event_name="Test Event")
        event.datetime_end = timezone.now() + timezone.timedelta(hours=1)
        event.max_crew = 1
        event2 = Event2019Factory.create(event_name="Another Event")
        event2.datetime_end = timezone.now() + timezone.timedelta(hours=1)
        event2.approved = True
        event2.max_crew = 1
        event.save()
        event2.save()
        CCInstanceFactory.create(crew_chief=self.user, event=event, setup_start=timezone.now())
        CCInstanceFactory.create(crew_chief=self.user, event=event2, setup_start=timezone.now())

        self.assertOk(client.post("/api/v1/crew/checkin", {'id': 12345, 'event': 1}), 403)

        event.approved = True
        event.save()

        second_user = UserFactory.create(password="******")
        other_checkin = CrewAttendanceRecord.objects.create(event=event, user=second_user, active=True)

        # Should display an error if we have reached maximum crew
        self.assertOk(client.post("/api/v1/crew/checkin", {'id': 12345, 'event': 1}), 403)

        other_checkin.delete()

        # Check response on successful checkin
        resp = client.post("/api/v1/crew/checkin", {'id': 12345, 'event': 1})
        self.assertOk(resp, 201)

        self.assertTrue(CrewAttendanceRecord.objects.filter(user=self.user).exists())

        # Return 409 if checkin record already exists for the user (even if it's for another event)
        self.assertOk(client.post("/api/v1/crew/checkin", {'id': 12345, 'event': 2}), 409)

        # Return 404 if checkin record could not be found during checkout
        self.assertOk(client.post("/api/v1/crew/checkout", {'id': 12345, 'event': 2}), 404)

        # Test with checkout time included
        custom_datetime = timezone.now() + timezone.timedelta(days=-1)
        self.assertOk(client.post("/api/v1/crew/checkout",
                                  {'id': 12345, 'event': 1, 'checkout': custom_datetime}), 201)

        self.assertEqual(CrewAttendanceRecord.objects.get(user=self.user).checkout, custom_datetime)

        # Test with Checkin time included
        self.assertOk(client.post("/api/v1/crew/checkin",
                                  {'id': 12345, 'event': 1, 'checkin': custom_datetime}), 201)

        self.assertEqual(CrewAttendanceRecord.objects.get(user=self.user, active=True).checkin, custom_datetime)
Пример #5
0
    def test_events_endpoint(self):
        models.Endpoint.objects.create(name="Events", url="events", description="Get your event info here",
                                       example="name=Test Event", response="[]")

        # Test that we get 204 response if no events can be found matching query
        self.assertOk(self.client.get("/api/v1/events"), 204)

        building = Building.objects.create(name="Campus Center", shortname="CC")
        location1 = Location.objects.create(name="CC Office", building=building)
        location2 = Location.objects.create(name="Dunkin Donuts", building=building)
        now = timezone.now().replace(microsecond=0)
        time_past = timezone.now() + timezone.timedelta(hours=-1)
        time_past = time_past.replace(microsecond=0)
        time_future = timezone.now() + timezone.timedelta(hours=1)
        time_future = time_future.replace(microsecond=0)

        Event2019Factory.create(event_name="Test Event", location=location1, datetime_start=now,
                                datetime_end=time_future, description="An event", approved=True)
        Event2019Factory.create(event_name="Another Event", location=location2, datetime_start=time_past,
                                datetime_end=time_future, approved=True)
        Event2019Factory.create(event_name="Past Event", location=location1, datetime_start=time_past,
                                datetime_end=time_past, approved=True)

        now_str = timezone.localtime(now).strftime("%Y-%m-%dT%H:%M:%S%z")
        time_past_str = timezone.localtime(time_past).strftime("%Y-%m-%dT%H:%M:%S%z")
        time_future_str = timezone.localtime(time_future).strftime("%Y-%m-%dT%H:%M:%S%z")

        # Default response should be just upcoming events that are not sensitive, cancelled, or designated as a test
        default_response = '[{"id":1,"event_name":"Test Event","description":"An event","location":"CC Office",' \
                           '"datetime_start":"' + now_str + '","datetime_end":"' + time_future_str + '"},' \
                           '{"id":2,"event_name":"Another Event","description":null,"location":"Dunkin Donuts",' \
                           '"datetime_start":"' + time_past_str + '","datetime_end":"' + time_future_str + '"}]'

        self.assertEqual(self.client.get("/api/v1/events").content.decode('utf-8'), default_response)

        # Test filter by name
        name_response = '[{"id":1,"event_name":"Test Event","description":"An event","location":"CC Office",' \
                        '"datetime_start":"' + now_str + '","datetime_end":"' + time_future_str + '"}]'

        self.assertEqual(self.client.get("/api/v1/events", {"name": "test"}).content.decode('utf-8'), name_response)

        # Test filter by location
        location_response = '[{"id":2,"event_name":"Another Event","description":null,"location":"Dunkin Donuts",' \
                            '"datetime_start":"' + time_past_str + '","datetime_end":"' + time_future_str + '"}]'

        self.assertEqual(self.client.get("/api/v1/events", {"location": "dunkin"}).content.decode('utf-8'),
                         location_response)

        # Test filter by start or end time (match)
        start = now.strftime("%Y-%m-%dT%H:%M:%SZ")
        end = time_future.strftime("%Y-%m-%dT%H:%M:%SZ")

        self.assertEqual(self.client.get("/api/v1/events", {"start": start}).content.decode('utf-8'), name_response)
        self.assertEqual(self.client.get("/api/v1/events", {"end": end}).content.decode('utf-8'), default_response)

        # Test both start and end time
        time_response = '[{"id":2,"event_name":"Another Event","description":null,"location":"Dunkin Donuts",' \
                        '"datetime_start":"' + time_past_str + '","datetime_end":"' + time_future_str + '"},' \
                        '{"id":3,"event_name":"Past Event","description":null,"location":"CC Office",' \
                        '"datetime_start":"' + time_past_str + '","datetime_end":"' + time_past_str + '"}]'

        self.assertEqual(self.client.get("/api/v1/events", {"start": str(time_past + timezone.timedelta(hours=-1)),
                                                            "end": str(now + timezone.timedelta(minutes=-1))}
                                         ).content.decode('utf-8'), time_response)
        self.assertEqual(self.client.get("/api/v1/events",
                                         {"start": str(now), "end": str(time_future + timezone.timedelta(hours=1))}
                                         ).content.decode('utf-8'), default_response)
Пример #6
0
 def setUp(self):
     self.e = EventFactory.create(event_name="Test Event")
     self.e2 = EventFactory.create(event_name="Other Test Event")
     self.e3 = Event2019Factory.create(event_name="2019 Test Event")
     self.user = UserFactory.create(password='******')
Пример #7
0
    def test_find_previous(self):
        self.setup()

        # Test GET request not allowed
        self.assertOk(self.client.get(reverse("wizard-findprevious")), 405)

        # Test missing required fields (in this case location is missing)
        test_data = {
            "org": self.org.pk,
            "event_name": "Test Event #2",
            "start": timezone.now().strftime('%Y-%m-%dT%H:%M:%S.%f%z'),
            "end": timezone.now().strftime('%Y-%m-%dT%H:%M:%S.%f%z'),
            "setup_complete": timezone.now().strftime('%Y-%m-%dT%H:%M:%S.%f%z')
        }

        self.assertOk(
            self.client.post(reverse("wizard-findprevious"),
                             json.dumps(test_data),
                             content_type="application/json"), 422)

        test_data["location"] = self.location.pk

        # Test no match
        self.assertOk(
            self.client.post(reverse("wizard-findprevious"),
                             json.dumps(test_data),
                             content_type="application/json"), 204)

        # Test match but no permission to access unapproved events
        event = Event2019Factory.create(event_name="Test Event",
                                        location=self.location,
                                        datetime_start=timezone.now() -
                                        timezone.timedelta(days=1))
        event.org.add(self.org)
        service = ServiceFactory.create(shortname="S4", enabled_event2019=True)
        ServiceInstance.objects.create(service=service,
                                       event=event,
                                       detail="Tons of wub")

        self.assertOk(
            self.client.post(reverse("wizard-findprevious"),
                             json.dumps(test_data),
                             content_type="application/json"), 204)

        # Test match with valid permissions
        self.org.user_in_charge = self.user
        self.org.save()

        expected_response = {
            "event_name": "Test Event",
            "location": self.location.pk,
            "start": str(event.datetime_start),
            "services": [{
                "id": service.shortname,
                "detail": "Tons of wub"
            }]
        }

        resp = self.client.post(reverse("wizard-findprevious"),
                                json.dumps(test_data),
                                content_type="application/json")
        self.assertOk(resp)
        self.assertEqual(resp.content,
                         json.dumps(expected_response).encode('utf-8'))