def test_user_event_cardinality_1to1(self): """Tests whether the User-Event relationship is set up correctly.""" email1 = '*****@*****.**' email2 = '*****@*****.**' add_user(email=email1) add_user(email=email2) user1_id = User.query.filter_by(email=email1).first().id user2_id = User.query.filter_by(email=email2).first().id availability1 = create_availability() availability2 = create_availability() add_event(user_id=user1_id, availability=availability1) add_event(url='anEvent', user_id=user2_id, availability=availability2) db.session.commit() query1 = User.query.\ filter_by(email=email1).\ join(Event, Availability).\ all() query2 = User.query.\ filter_by(email=email2).\ join(Event, Availability).\ all() self.assertEqual(len(query1), 1) self.assertEqual(len(query2), 1) self.assertEqual(len(query1[0].events), 1) self.assertEqual(len(query2[0].events), 1)
def test_get_appointments(self): """Tests whether appointments can be successfully requested.""" add_user() db.session.commit() user = User.query.first() add_event(user_id=user.id, availability=create_availability()) db.session.commit() event = Event.query.first() name = 'Jimmy Joe' comments = "OMG I haven't seen you in forever Jimmy how has it been?" start = dt.datetime.now(dt.timezone.utc) add_appointment(event_id=event.id, participants=[create_participant(name=name)], comments=comments, start=start) db.session.commit() auth_token = user.encode_auth_token(user.id) response = self.api.get( f'/users/{user.public_id}/events/{event.url}/' f'appointments', headers={'x-access-token': auth_token}, content_type='application/json') data = json.loads(response.data.decode()) appointment = data[0] participants = appointment['participants'][0] self.assertEqual(response.status_code, 200) self.assertEqual(appointment['comments'], comments) self.assertEqual(participants['name'], name) self.assertEqual(parser.isoparse(appointment['start']), start)
def test_many_participants(self): """Tests whether an appointment can have many participants.""" add_user() db.session.commit() user = User.query.first() availability = create_availability() add_event(user_id=user.id, availability=availability) db.session.commit() event = Event.query.first() name = ['User Jeff', 'Jeff User', 'Reff Usej'] email = ['*****@*****.**', '*****@*****.**', '*****@*****.**'] comments = 'I think this whole Jeff and User thing is getting ' \ 'confusing.' add_appointment(event_id=event.id, participants=[ create_participant(name[i], email[i]) for i in range(2) ], comments=comments) db.session.commit() participants = db.session.query(Participant).\ filter(Appointment.comments == comments) for j in range(2): self.assertEqual(participants[j].name, name[j]) self.assertEqual(participants[j].email, email[j])
def test_bad_params(self): """Tests whether a request with both valid and invalid parameters is accepted and the valid parameters are used.""" add_user() db.session.commit() user = User.query.first() user_public_id = user.public_id add_event(user.id, create_availability()) db.session.commit() event = Event.query.first() event_url = event.url start = dt.datetime.now(dt.timezone.utc) + dt.timedelta(days=30) add_appointment(event_id=event.id, participants=[create_participant()], start=start, status=True) db.session.commit() route = f'/users/{user_public_id}/events/{event_url}/appointments/' \ f'{start.isoformat()}' status = False response = self.api.patch(route, data=json.dumps({ 'status': status, 'potato': 'I love potatoes man.' }), content_type='application/json') self.assertEqual(response.status_code, 200) data = json.loads(response.data.decode()) self.assertEqual(data['message'], 'success')
def test_updating_to_same_value(self): """Tests whether updating a value to its current value is accepted.""" add_user() db.session.commit() user = User.query.first() user_public_id = user.public_id add_event(user.id, create_availability()) db.session.commit() event = Event.query.first() event_url = event.url start = dt.datetime.now(dt.timezone.utc) + dt.timedelta(days=30) add_appointment(event_id=event.id, participants=[create_participant()], start=start, status=True) db.session.commit() route = f'/users/{user_public_id}/events/{event_url}/appointments/' \ f'{start.isoformat()}' status = True response = self.api.patch(route, data=json.dumps({'status': status}), content_type='application/json') self.assertEqual(response.status_code, 200) data = json.loads(response.data.decode()) self.assertEqual(data['message'], 'success') appointment = Appointment.query.first() self.assertEqual(appointment.status, status)
def test_get_appointment(self): """Tests whether an appointment can be successfully requested.""" add_user() db.session.commit() user = User.query.first() user_public_id = user.public_id add_event(user.id, create_availability()) db.session.commit() event = Event.query.first() event_url = event.url name = 'Big Bob' email = '*****@*****.**' comments = 'What is this appointment for again?' start = dt.datetime(year=2020, month=3, day=2, hour=9, tzinfo=dt.timezone.utc) add_appointment( event_id=event.id, participants=[create_participant(name=name, email=email)], start=start, comments=comments) db.session.commit() route = f'/users/{user_public_id}/events/{event_url}/appointments/' \ f'{start.isoformat()}' response = self.api.get(route, content_type='application/json') appointment = json.loads(response.data.decode()) participant = appointment['participants'][0] self.assertEqual(response.status_code, 200) self.assertEqual(appointment['comments'], comments) self.assertEqual(participant['name'], name) self.assertEqual(participant['email'], email)
def test_event_foreign_key(self): """Tests whether the foreign key relationship is working between Event and User.""" name1 = 'timmy' name2 = 'johny' email1 = '*****@*****.**' email2 = '*****@*****.**' add_user(name=name1, email=email1) add_user(name=name2, email=email2) user1_id = User.query.filter_by(email=email1).first().id user2_id = User.query.filter_by(email=email2).first().id start1 = dt.time(6, tzinfo=dt.timezone.utc) start2 = dt.time(8, tzinfo=dt.timezone.utc) availability1 = create_availability(start=start1) availability2 = create_availability(start=start2) url1 = 'aCleverUrl' url2 = 'aNotSoCleverUrl' add_event(url=url1, user_id=user1_id, availability=availability1) add_event(url=url2, user_id=user2_id, availability=availability2) db.session.commit() query1 = User.query.\ filter_by(email=email1).\ join(Event, Availability).\ first() query2 = User.query.\ filter_by(email=email2).\ join(Event, Availability).\ first() self.assertEqual(query1.name, name1) self.assertEqual(query2.name, name2) self.assertEqual(query1.events[0].url, url1) self.assertEqual(query2.events[0].url, url2) self.assertEqual(query1.events[0].availability.start, start1) self.assertEqual(query2.events[0].availability.start, start2)
def test_timezone_conversion(self, _mock_email, _mock_event): """Tests whether non utc timezones are correctly converted to UTC time. """ add_user() db.session.commit() user = User.query.first() user_public_id = user.public_id add_event(user.id, create_availability()) db.session.commit() event = Event.query.first() event_url = event.url start = dt.datetime(year=2020, month=3, day=2, hour=9, tzinfo=dt.timezone(dt.timedelta(hours=-5))) route = f'/users/{user_public_id}/events/{event_url}/appointments' request = create_appointment_json(start=dt.datetime.isoformat(start)) response = self.api.post(route, data=request, content_type='application/json') data = json.loads(response.data.decode()) self.assertEqual(response.status_code, 201) self.assertEqual(data['message'], 'success') appointment = db.session.query(Appointment).\ filter(Event.url == event_url).\ first() self.assertEqual(appointment.start, start.astimezone(dt.timezone.utc))
def test_availability_days(self, _mock_email, _mock_event): """Tests whether a request outside of the available days is rejected with a 400 response.""" add_user() db.session.commit() user = User.query.first() user_public_id = user.public_id add_event(user.id, create_availability()) # Sunday: False db.session.commit() event = Event.query.first() event_url = event.url start = dt.datetime( year=2020, month=3, day=1, # Sunday hour=9, tzinfo=dt.timezone.utc) route = f'/users/{user_public_id}/events/{event_url}/appointments' request = create_appointment_json(start=dt.datetime.isoformat(start)) response = self.api.post(route, data=request, content_type='application/json') data = json.loads(response.data.decode()) self.assertEqual(response.status_code, 400) self.assertEqual(data['status'], 'fail') self.assertEqual( data['message'], 'The provided start time and date is ' 'not allowed please choose a valid ' 'start time and date and resubmit ' 'your request.')
def test_start_after_next_x_days(self, _mock_email, _mock_event): """Tests whether a request made with a start time that is more than NEXT_X_DAYS is rejected with a 400 response.""" add_user() db.session.commit() user = User.query.first() user_public_id = user.public_id add_event(user.id, create_availability()) db.session.commit() event = Event.query.first() event_url = event.url start = dt.datetime.now(dt.timezone.utc) + dt.timedelta(days=91) route = f'/users/{user_public_id}/events/{event_url}/appointments' response = self.api.post( route, data=create_appointment_json(start=start.isoformat()), content_type='application/json') data = json.loads(response.data.decode()) self.assertEqual(response.status_code, 400) self.assertEqual(data['status'], 'fail') self.assertEqual( data['message'], f"You may only schedule an " f"appointment within the next " f"{NEXT_X_DAYS} days in the future.")
def test_appointment_model(self): """Tests whether the appointment model is working correctly.""" add_user() db.session.commit() user = User.query.first() availability = create_availability() add_event(user_id=user.id, availability=availability) db.session.commit() event = Event.query.first() participant = create_participant() start = dt.datetime(year=2020, month=3, day=1, hour=8, tzinfo=dt.timezone.utc) end = start + dt.timedelta(hours=1) created = dt.datetime.now(dt.timezone.utc) add_appointment(event_id=event.id, participants=[participant], start=start, end=end, created=created) db.session.commit() appointment = Appointment.query.filter_by(start=start).first() self.assertEqual(appointment.end, end) self.assertEqual(appointment.created, created)
def test_bad_token(self): """Tests whether a request with an invalid token returns a 403 response.""" add_user(email='*****@*****.**') add_user(email='*****@*****.**') db.session.commit() user1 = User.query.filter_by(email='*****@*****.**').first() user2 = User.query.filter_by(email='*****@*****.**').first() add_event(user1.id, create_availability()) db.session.commit() event1 = Event.query.filter_by(user_id=user1.id).first() add_appointment(event_id=event1.id, participants=[create_participant()]) db.session.commit() auth_token2 = user2.encode_auth_token(user2.id) route = f'/users/{user1.public_id}/events/{event1.url}/appointments' response = self.api.get(route, headers={'x-access-token': auth_token2}, content_type='application/json') data = json.loads(response.data.decode()) self.assertEqual(response.status_code, 403) self.assertEqual(data['message'], "You do not have permission to access this content")
def test_appointment_not_found(self): """Tests whether requesting an appointment that doesn't exist returns a 404 error.""" add_user() db.session.commit() user = User.query.first() user_public_id = user.public_id add_event(user.id, create_availability()) db.session.commit() event = Event.query.first() event_url = event.url start = dt.datetime.now(dt.timezone.utc) + dt.timedelta(days=30) add_appointment(event_id=event.id, participants=[create_participant()], start=start) db.session.commit() route = f'/users/{user_public_id}/events/{event_url}/appointments/' \ f'{(start + dt.timedelta(days=1)).isoformat()}' status = False response = self.api.patch(route, data=json.dumps({'status': status}), content_type='application/json') data = json.loads(response.data.decode()) self.assertEqual(response.status_code, 404) self.assertEqual(data['status'], 'fail') self.assertEqual(data['message'], 'No appointment was found for that ' 'start time.')
def test_bad_value(self): """Tests whether attempting to supply an unsupported value is rejected with a 400 response.""" add_user() db.session.commit() user = User.query.first() user_public_id = user.public_id add_event(user.id, create_availability()) db.session.commit() event = Event.query.first() event_url = event.url start = dt.datetime.now(dt.timezone.utc) + dt.timedelta(days=30) add_appointment(event_id=event.id, participants=[create_participant()], start=start) db.session.commit() route = f'/users/{user_public_id}/events/{event_url}/appointments/' \ f'{start.isoformat()}' status = 'potato' response = self.api.patch(route, data=json.dumps({'status': status}), content_type='application/json') self.assertEqual(response.status_code, 400) data = json.loads(response.data.decode()) self.assertEqual(data['errors']['status'], f"'{status}' is not of type " f"'boolean'") self.assertEqual(data['message'], 'Input payload validation failed')
def test_get_all_appointments(self): """Test Getting all appointments from a User""" add_user() db.session.commit() user = User.query.first() # Create 2 events event1 = add_event(user_id=user.id, availability=create_availability(), name="Frist Event", url="my first url") event2 = add_event(user_id=user.id, availability=create_availability(), name="Frist Second", url="my second url") db.session.commit() start = dt.datetime.now(dt.timezone.utc) # add appointment to event 1 add_appointment(event_id=event1.id, participants=[ create_participant(name="John", email="*****@*****.**") ], comments="comments", start=start) # add appointment to event 2 add_appointment(event_id=event2.id, participants=[ create_participant(name="Bonnie", email="*****@*****.**") ], comments="comments", start=start + dt.timedelta(days=1)) db.session.commit() auth_token = user.encode_auth_token(user.id) resp_with_query_param = self.api.get( f'/users/{user.public_id}/appointments?event_url={event1.url}', headers={'x-access-token': auth_token}, content_type='application/json') data_with_query = json.loads(resp_with_query_param.data.decode()) resp_no_query_param = self.api.get( f'/users/{user.public_id}/appointments', headers={'x-access-token': auth_token}, content_type='application/json') data_no_query_param = json.loads(resp_no_query_param.data.decode()) self.assertEqual(len(data_with_query), 1) self.assertEqual(len(data_no_query_param), 2)
def test_availability_model(self): """Tests whether the availability model is working correctly.""" sunday = True start = dt.time(hour=6, tzinfo=dt.timezone.utc) end = dt.time(hour=9, tzinfo=dt.timezone.utc) add_user() user_id = User.query.first().id availability = create_availability(sunday=sunday, start=start, end=end) add_event(user_id=user_id, availability=availability) availability = Availability.query.filter_by(start=start).first() self.assertEqual(availability.sunday, sunday) self.assertEqual(availability.end, end)
def test_multiple_appointments(self, _mock_email, _mock_event): """Tests whether a single participant can have multiple appointments.""" add_user() db.session.commit() user = User.query.first() user_public_id = user.public_id add_event(user.id, create_availability()) db.session.commit() event = Event.query.first() event_url = event.url name = 'Fabulous Johnny' email = '*****@*****.**' start1 = dt.datetime(year=2020, month=3, day=2, hour=9, tzinfo=dt.timezone.utc) start2 = start1 + dt.timedelta(hours=2) route = f'/users/{user_public_id}/events/{event_url}/appointments' response1 = self.api.post(route, data=create_appointment_json( start=start1.isoformat(), name=name, email=email), content_type='application/json') response2 = self.api.post(route, data=create_appointment_json( start=start2.isoformat(), name=name, email=email), content_type='application/json') data1 = json.loads(response1.data.decode()) data2 = json.loads(response2.data.decode()) self.assertEqual(response1.status_code, 201) self.assertEqual(data1['message'], 'success') self.assertEqual(response2.status_code, 201) self.assertEqual(data2['message'], 'success') appointments = db.session.query(Appointment).\ filter(Event.url == event_url).\ all() self.assertEqual(len(appointments), 2) for appointment in appointments: self.assertTrue(appointment.start in [start1, start2]) participant = Participant.query.filter_by(email=email).all() self.assertEqual(len(participant), 1) self.assertEqual(participant[0].name, name) self.assertEqual(participant[0].email, email)
def test_availability_foreign_key(self): """Tests whether the foreign key relationship is working between Availability and Event.""" add_user() user_id = User.query.first().id start = dt.time(hour=6, tzinfo=dt.timezone.utc) availability = create_availability(start=start) url = 'acleverurl' add_event(url=url, user_id=user_id, availability=availability) db.session.commit() event, availability = db.session.query(Event, Availability).join()\ .first() self.assertEqual(availability.start, start) self.assertEqual(event.url, url)
def test_event_model(self): """Tests whether the event model is working correctly.""" name = '♪┏(・o・)┛♪┗ ( ・o・) ┓♪' url = 'myCoolParty' location = 'da street!' add_user() user_id = User.query.first().id availability = create_availability() add_event(url=url, name=name, location=location, user_id=user_id, availability=availability) event = Event.query.filter_by(url=url).first() self.assertEqual(event.name, name) self.assertEqual(event.location, location)
def test_participant_model(self): """Tests whether the participant model is working correctly.""" add_user() db.session.commit() user = User.query.first() availability = create_availability() add_event(user_id=user.id, availability=availability) db.session.commit() event = Event.query.first() name = 'User Jeff' email = '*****@*****.**' add_appointment( event_id=event.id, participants=[create_participant(name=name, email=email)]) db.session.commit() participant = Participant.query.filter_by(name=name).first() self.assertEqual(participant.email, email)
def test_missing_token(self): """Tests whether a request with a missing token returns a 401 response""" add_user(email='*****@*****.**') db.session.commit() user = User.query.first() add_event(user.id, create_availability()) db.session.commit() event = Event.query.first() add_appointment(event_id=event.id, participants=[create_participant()]) db.session.commit() route = f'/users/{user.public_id}/events/{event.url}/appointments' response = self.api.get(route, content_type='application/json') data = json.loads(response.data.decode()) self.assertEqual(response.status_code, 401) self.assertEqual(data['message'], 'Token is missing!')
def test_event_marshal(self): user = add_user() db.session.commit() auth_token = user.encode_auth_token(user.id) start = dt.time(hour=6, tzinfo=dt.timezone.utc) sunday = True availability = create_availability(start=start, sunday=sunday) url = 'funnyUrl' color = '#7851a9' add_event(user.id, availability, url=url, color=color.lstrip('#')) db.session.commit() response = self.api.get(f'/users/{user.public_id}/events/{url}', headers={'x-access-token': auth_token}, content_type='application/json') data = json.loads(response.data.decode()) self.assertEqual(data['url'], url) self.assertEqual(data['availability']['start'], start.isoformat()) self.assertEqual(data['color'], color) self.assertEqual(data['availability']['days']['sunday'], sunday)
def post(self, public_id, current_user=None): """Creates an Event for the specified user.""" if current_user.public_id != public_id: raise PermissionError payload = api.payload if not verify_at_least_1_day_available(payload['availability']): raise NoDayAvailable if starttime_after_endtime(payload['availability']): raise StartAfterEnd if ' ' in payload['url']: raise UrlContainsSpace user_id = current_user.id availability = create_availability( sunday=payload['availability']['days']['sunday'], monday=payload['availability']['days']['monday'], tuesday=payload['availability']['days']['tuesday'], wednesday=payload['availability']['days']['wednesday'], thursday=payload['availability']['days']['thursday'], friday=payload['availability']['days']['friday'], saturday=payload['availability']['days']['saturday'], start=dt.time.fromisoformat(payload['availability']['start']), end=dt.time.fromisoformat(payload['availability']['end'])) add_event( user_id=user_id, availability=availability, name=payload['name'], location=payload['location'], description=payload['description'], duration=payload['duration'], url=payload['url'], color=payload['color'].lstrip('#')) db.session.commit() if current_user.role == Role.ON_BOARDING: promote_to_member(current_user) return {'message': 'success'}, 201
def test_multiple_participants(self): """Tests whether an appointment can have multiple participants.""" add_user() db.session.commit() user = User.query.first() availability = create_availability() add_event(user_id=user.id, availability=availability) db.session.commit() event = Event.query.first() names = ['Rex', 'Fives', 'Echo', 'Dogma', 'Wolffe'] emails = [f'{name}@trooper.com' for name in names] participants = [ create_participant(name=names[i], email=emails[i]) for i in range(4) ] add_appointment(event_id=event.id, participants=participants) db.session.commit() appointment = Appointment.query.first() for i in range(4): self.assertEqual(appointment.participants[i].name, names[i]) self.assertEqual(appointment.participants[i].email, emails[i])
def test_post_appointments(self, _mock_email, _mock_event): """Tests whether an appointment can be successfully created and the appointment's attributes match what was supplied.""" add_user() db.session.commit() user = User.query.first() user_public_id = user.public_id add_event(user.id, create_availability()) db.session.commit() event = Event.query.first() event_url = event.url start = '2020-03-20T08:30:00Z' comments = "I don't know about this appointment man..." name = 'Little Timmy' email = '*****@*****.**' route = f'/users/{user_public_id}/events/{event_url}/appointments' request = create_appointment_json(start=start, comments=comments, name=name, email=email) response = self.api.post(route, data=request, content_type='application/json') data = json.loads(response.data.decode()) self.assertEqual(response.status_code, 201) self.assertEqual(data['message'], 'success') appointment = db.session.query(Appointment).\ filter(User.public_id == user_public_id, Event.url == event_url, Appointment.start == start).\ first() self.assertEqual(appointment.comments, comments) participant = appointment.participants[0] self.assertEqual(participant.name, name) self.assertEqual(participant.email, email)
def seed_event(): result = {} user = add_user() cred = add_cred() user.cred = cred user_id = User.query.first().id availability = create_availability() name = '♪┏(・o・)┛♪┗ ( ・o・) ┓♪' url = 'myCoolParty' location = 'da street!' event = add_event(url=url, name=name, location=location, user_id=user_id, availability=availability) result['user'] = user result['event'] = event return result
def test_default_override(self): """Tests whether default setting in the marshal are overriding set values.""" user = add_user() db.session.commit() url = 'iwontfail' duration = 15 event = add_event(user.id, create_availability(), duration=duration, url=url) auth_token = user.encode_auth_token(user.id) db.session.commit() response = self.api.put(f'/users/{user.public_id}/events/{event.url}', headers={'x-access-token': auth_token}, data=json.dumps({'name': "please don't fail"}), content_type='application/json') data = json.loads(response.data.decode()) self.assertEqual(response.status_code, 200) self.assertEqual(data['message'], 'Success') event = Event.query.filter_by(url=url).first() self.assertEqual(event.duration, duration)