예제 #1
0
    def test_search(self):
        self.assertOk(self.client.get(reverse("search")))

        UserFactory.create(password="******", first_name="Ellen")

        self.assertContains(self.client.get(reverse("search"), {'q': 'ell'}),
                            "Ellen")
예제 #2
0
    def test_officer_endpoint(self):
        models.Endpoint.objects.create(name="Officers",
                                       url="officers",
                                       description="Officer endpoint",
                                       example="title=something",
                                       response="[]")

        # Test that we get 404 when there are no officers
        self.assertOk(self.client.get("/api/v1/officers"), 404)

        # Test that we see all officers and not normal user (will require user to have title)
        self.user.title = "President"
        self.user.first_name = "Test"
        self.user.last_name = "User"
        self.user.save()

        officer = Group.objects.create(name="Officer")
        officer.user_set.add(self.user)

        user2 = UserFactory.create(password="******",
                                   first_name="Other",
                                   last_name="Officer")
        UserFactory.create(password="******")
        officer.user_set.add(user2)

        self.assertEqual(
            self.client.get("/api/v1/officers").content.decode('utf-8'),
            '[{"title":"President","name":"Test User"}]')

        user2.title = "Vice President"
        user2.save()

        self.assertEqual(
            self.client.get("/api/v1/officers").content.decode('utf-8'),
            '[{"title":"President","name":"Test User"},{"title":"Vice President","name":"Other Officer"}]'
        )

        # Test that we can get a specific officer's info (based on title)
        self.assertEqual(
            self.client.get("/api/v1/officers?title=president").content.decode(
                'utf-8'), '[{"title":"President","name":"Test User"}]')

        # Test that we can get a specific officer's info (based on name) - If both parameters, results must match both
        self.assertEqual(
            self.client.get("/api/v1/officers?first_name=test&last_name=user"
                            ).content.decode('utf-8'),
            '[{"title":"President","name":"Test User"}]')

        # Test additional custom options
        self.user.class_year = 2020
        self.user.save()

        self.assertEqual(
            self.client.get(
                "/api/v1/officers?title=president&options=class_year").content.
            decode('utf-8'),
            '[{"title":"President","name":"Test User","class_year":2020}]')
예제 #3
0
파일: tests.py 프로젝트: kylemikableh/lnldb
    def test_password_set_view(self):
        self.setup()

        # Change own password (superuser)
        self.assertOk(self.client.get(reverse("accounts:password", args=[1])))

        data = {
            'new_password1': 'Password.1',
            'new_password2': 'Password.1',
            'save': 'Set Password'
        }

        # Should send to login page on success (rendered as view - status should be 200)
        self.assertOk(self.client.post(reverse("accounts:password", args=[1]), data))

        # Change own password (non-superuser)
        self.user.is_superuser = False

        self.assertOk(self.client.get(reverse("accounts:password", args=[1])))

        # Set own password (non-superuser)
        self.user.password = None
        self.assertOk(self.client.get(reverse("accounts:password", args=[1])))

        # Non-superuser should not be allowed to set password for someone else
        another_user = UserFactory.create(password="******")
        self.assertOk(self.client.get(reverse("accounts:password", args=[another_user.pk])), 403)
예제 #4
0
파일: tests.py 프로젝트: Evans-Notch/lnldb
    def test_hour_viewset(self):
        models.Endpoint.objects.create(name="Office Hours", url="office-hours", description="Office Hours Endpoint",
                                       example="officer=president", response="[]")
        self.user.title = "President"
        self.user.save()

        user2 = UserFactory.create(password="******", title="Vice President")

        # Test that no content returns a 204
        self.assertOk(self.client.get("/api/v1/office-hours"), 204)

        # Test that we can get all office hours
        start_time = timezone.now()
        end_time = timezone.now() + timezone.timedelta(hours=1)
        hour1 = OfficeHour.objects.create(officer=self.user, day=1, hour_start=start_time.time(),
                                          hour_end=end_time.time())
        hour2 = OfficeHour.objects.create(officer=user2, day=3, hour_start=start_time.time(), hour_end=end_time.time())

        self.assertEqual(self.client.get("/api/v1/office-hours").content.decode('utf-8'),
                         '[{"officer":"President","day":1,"hour_start":"' + str(start_time.time()) + '","hour_end":"' +
                         str(end_time.time()) + '"},{"officer":"Vice President","day":3,"hour_start":"' +
                         str(start_time.time()) + '","hour_end":"' + str(end_time.time()) + '"}]')

        # Test that we can get office hours for a specific officer
        self.assertEqual(self.client.get("/api/v1/office-hours?officer=president").content.decode('utf-8'),
                         '[{"officer":"President","day":1,"hour_start":"' + str(start_time.time()) +
                         '","hour_end":"' + str(end_time.time()) + '"}]')

        # Test that we can filter office hours by the day
        self.assertEqual(self.client.get("/api/v1/office-hours?day=3").content.decode('utf-8'),
                         '[{"officer":"Vice President","day":3,"hour_start":"' + str(start_time.time()) +
                         '","hour_end":"' + str(end_time.time()) + '"}]')

        # Test that we can get office hours that start at a certain time (exact match)
        start_time = timezone.datetime.strptime('13:30', '%H:%M').replace(tzinfo=pytz.timezone('US/Eastern'))
        end_time = timezone.datetime.strptime('15:30', '%H:%M').replace(tzinfo=pytz.timezone('US/Eastern'))

        # Ensure that only 1 result will appear in the tests below
        hour1.hour_start = start_time + timezone.timedelta(hours=3)
        hour1.hour_end = end_time + timezone.timedelta(hours=2)
        hour2.hour_start = start_time + timezone.timedelta(hours=3)
        hour2.hour_end = end_time + timezone.timedelta(hours=2)
        hour1.save()
        hour2.save()

        OfficeHour.objects.create(officer=self.user, day=4,
                                  hour_start=start_time.time(),
                                  hour_end=end_time.time())

        self.assertEqual(self.client.get("/api/v1/office-hours?start=13:30:00").content.decode('utf-8'),
                         '[{"officer":"President","day":4,"hour_start":"13:30:00","hour_end":"15:30:00"}]')

        # Test that we can get office hours that end at a certain time (exact match)
        self.assertEqual(self.client.get("/api/v1/office-hours?end=15:30:00").content.decode('utf-8'),
                         '[{"officer":"President","day":4,"hour_start":"13:30:00","hour_end":"15:30:00"}]')

        # Test that if both start and end times are provided the result contains entries that overlap with those times
        self.assertEqual(self.client.get("/api/v1/office-hours?start=13:00:00&end=14:00:00").content.decode('utf-8'),
                         '[{"officer":"President","day":4,"hour_start":"13:30:00","hour_end":"15:30:00"}]')
예제 #5
0
    def test_hourchange_viewset(self):
        models.Endpoint.objects.create(
            name="Office Hour Updates",
            url="hours/updates",
            description="Office Hour Updates endpoint",
            example="expires=2020-01-01T00:00:00Z",
            response="[]")
        self.user.title = "President"
        self.user.save()

        user2 = UserFactory.create(password="******")
        user2.title = "Treasurer"
        user2.save()

        # Test that we get 204 response if no updates exist
        self.assertOk(self.client.get("/api/v1/hours/updates"), 204)

        post_date = timezone.datetime.strptime(
            "2019-12-01T12:00:00Z",
            "%Y-%m-%dT%H:%M:%SZ").replace(tzinfo=pytz.UTC)
        expires_before = timezone.datetime.strptime("2019-12-31T23:59:00Z", "%Y-%m-%dT%H:%M:%SZ")\
            .replace(tzinfo=pytz.UTC)
        expires_match = timezone.datetime.strptime("2020-01-01T00:00:00Z", "%Y-%m-%dT%H:%M:%SZ")\
            .replace(tzinfo=pytz.UTC)
        expires_after = timezone.datetime.strptime("2020-01-03T00:00:00Z", "%Y-%m-%dT%H:%M:%SZ")\
            .replace(tzinfo=pytz.UTC)
        HourChange.objects.create(officer=self.user,
                                  expires=expires_before,
                                  message="Test Hour Change",
                                  date_posted=post_date)
        HourChange.objects.create(officer=user2,
                                  expires=expires_match,
                                  message="Another test hour change",
                                  date_posted=post_date)
        HourChange.objects.create(officer=self.user,
                                  expires=expires_after,
                                  message="Even more hours will change",
                                  date_posted=post_date)

        # Test that we get all updates
        self.assertEqual(len(self.client.get("/api/v1/hours/updates").data), 3)

        # Test that we can get updates by officer
        resp = self.client.get("/api/v1/hours/updates?officer=treasurer")
        self.assertEqual(len(resp.data), 1)
        self.assertEqual(resp.data[0]["message"], "Another test hour change")

        # Test that we can get updates based on when they expire (on or after specified date)
        resp = self.client.get(
            "/api/v1/hours/updates?expires=2020-01-01T00:00:00Z")
        self.assertEqual(len(resp.data), 2)
        self.assertEqual(resp.data[0]["message"], "Another test hour change")
        self.assertEqual(resp.data[1]["message"],
                         "Even more hours will change")
예제 #6
0
파일: tests.py 프로젝트: kylemikableh/lnldb
 def setUp(self):
     super(TrainingTests, self).setUp()
     self.user2 = UserFactory.create(password="******")
     self.training_type = models.TrainingType.objects.create(
         name="Truss Training", description="It's in the name")
     self.training = models.Training.objects.create(
         training_type=self.training_type,
         date=date.today(),
         trainer=self.user,
         recorded_by=self.user)
     self.trainee = models.Trainee.objects.create(training=self.training,
                                                  person=self.user2)
예제 #7
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)
예제 #8
0
파일: tests.py 프로젝트: kylemikableh/lnldb
 def setup(self):
     self.user2 = UserFactory.create(password="******")
     self.associate = Group.objects.create(name="Associate")
     self.officer = Group.objects.create(name="Officer")
     self.request_factory = RequestFactory()
예제 #9
0
파일: tests.py 프로젝트: kylemikableh/lnldb
 def setUp(self):
     self.user = UserFactory.create(password="******", username="******")
     self.user2 = UserFactory.create(password="******")
     self.org = OrgFactory.create(user_in_charge=self.user, name="LNL")
예제 #10
0
파일: tests.py 프로젝트: alhayden/lnldb
 def setUp(self):
     self.user = UserFactory.create(password="******")
     self.projectionist = models.Projectionist(user=self.user)
     self.projectionist.save()
예제 #11
0
파일: tests.py 프로젝트: Evans-Notch/lnldb
    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)
예제 #12
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='******')
예제 #13
0
파일: test_views.py 프로젝트: WPI-LNL/lnldb
 def setUp(self):
     self.e = EventFactory.create(event_name="Test Event")
     self.e2 = EventFactory.create(event_name="Other Test Event")
     self.user = UserFactory.create(password='******')
     self.client.login(username=self.user.username, password='******')
예제 #14
0
 def setUp(self):
     self.e = EventFactory.create(event_name="Test Event")
     self.e2 = EventFactory.create(event_name="Other Test Event")
     self.user = UserFactory.create(password='******')