def test_standup_start():
#standup_start(token, channel_id), returns time_finish
#SETUP TESTS BEGIN
#create new users:
authRegDict = auth_register("*****@*****.**",
"password", "Ben", "Kah")
token = authRegDict["token"]
authRegDict2 = auth_register("*****@*****.**", "password",
"Jeffrey", "Oh")
token2 = authRegDict2["token"]
#create channel
chanCreateDict = channels_create(token, "test channel", True)
chanId = chanCreateDict["channel_id"]
channel_join(token, chanId)
#SETUP TESTS END
# low = datetime.now() + timedelta(seconds=4)
# up = datetime.now() + timedelta(seconds=6)
low_bound = time() + float(4.8)
up_bound = time() + float(5.2)
finish = standup_start(token, chanId, 5)
standup_finish = finish["time_finish"]
# low_bound = low.replace(tzinfo=timezone.utc).timestamp()
# up_bound = up.replace(tzinfo=timezone.utc).timestamp()
assert low_bound < standup_finish
assert up_bound > standup_finish
with pytest.raises(ValueError):
assert standup_start(token, 5555,
5) # channel_id is not a valid channel
with pytest.raises(ValueError):
assert standup_start(token2, chanId, 5) # token is invalid
def test_search_valid():
ch_id = channels_create(hamish['token'], 'comp', True)
# Send a message
new_message_id = message_send(hamish['token'], ch_id['channel_id'], 'yes')
# Save the time created
message_store = get_messages_store()
for id in message_store['Messages']:
if id['message_id'] == new_message_id['message_id']:
time_created = id['time_created']
reacts = id['reacts']
pin_status = id['is_pinned']
assert(search(hamish['token'], 'yes') == {
'messages':
[
{
'message_id': new_message_id['message_id'],
'u_id': hamish['u_id'],
'message': 'yes',
'time_created': str(time_created),
'reacts': reacts,
'is_pinned': pin_status,
}
]
}
) # Valid Display
def test_channels_create_valid():
channel_id = channels_create(hamish_token['token'], 'New_channel', True)
# Now to call our storage and assert that the channel_id is present in our store
channel_store = get_channel_store()
result = False
for probe in channel_store['Channels']:
if probe['channel_id'] == channel_id['channel_id']:
result = True
# Now we assert the value of result
assert (result == True)
def c_create():
data = request.get_json()
token = data['token']
name = data['name']
is_public = bool(data['is_public'])
channel_id = channels_create(token, name, is_public)
print(get_channel_store())
#message_id = {'message_id':1}
return dumps(channel_id)
def test_admin_userpermission_change():
#admin_userpermission_change(token, u_id, permission_id), no return value
#SETUP TESTS BEGIN
#create new admin:
authRegDict = auth_login("*****@*****.**", "password")
token = authRegDict["token"]
userId = authRegDict["u_id"]
#create regular user:
authRegDict2 = auth_register("*****@*****.**", "password",
"Jeffrey", "Oh")
token2 = authRegDict2["token"]
userId2 = authRegDict2["u_id"]
#create channel from admin:
chanCreateDict = channels_create(token, "test channel", True)
chanId = chanCreateDict["channel_id"]
channel_join(token, chanId)
#add regular user to first channel:
channel_invite(token, chanId, userId2)
#SETUP TESTS END
with pytest.raises(ValueError):
assert admin_userpermission_change(token, userId,
0) #invalid permission_id
with pytest.raises(ValueError):
assert admin_userpermission_change(token, userId, 4)
with pytest.raises(AccessError):
assert admin_userpermission_change(token, 55555, 3) #invalid user ID
user2 = user_from_token(token2)
# check user2 is a member (not an owner or admin)
assert check_slackr_owner(user2) == False
assert check_slackr_admin(user2) == False
# check user2 is an owner
admin_userpermission_change(token, userId2, 1)
assert check_slackr_owner(user2) == True
assert check_slackr_admin(user2) == False
# check user2 is an admin
admin_userpermission_change(token, userId2, 2)
assert check_slackr_owner(user2) == False
assert check_slackr_admin(user2) == True
# change user2 back to member
admin_userpermission_change(token, userId2, 3)
# check user2 cannot change permission of user1
with pytest.raises(AccessError):
admin_userpermission_change(token2, userId, 3)
user = user_from_token(token)
# check slackr owner can be made admin
admin_userpermission_change(token, userId, 2)
assert check_slackr_admin(user)
def test_standup_send():
#standup_send(token, channel_id, message), no return value
#SETUP TESTS BEGIN
#create new users:
authRegDict = auth_register("*****@*****.**",
"password", "Ben", "Kah")
token = authRegDict["token"]
authRegDict2 = auth_register("*****@*****.**", "password",
"Jeffrey", "Oh")
token2 = authRegDict2["token"]
#create channels:
chanCreateDict = channels_create(token, "test channel", True)
chanId = chanCreateDict["channel_id"]
channel_join(token, chanId)
chanCreateDict2 = channels_create(token, "test channel 2", True)
chanId2 = chanCreateDict2["channel_id"]
channel_join(token, chanId2)
#SETUP TESTS END
with pytest.raises(ValueError):
assert standup_send(token, chanId,
"this is sent before standup_start is called")
#create time_finish
finish = standup_start(token, chanId, 5)
standup_finish = finish["time_finish"]
standup_send(token, chanId, "Standup message")
with pytest.raises(AccessError):
assert standup_send(
token2, chanId,
"Standup message with user not a member of the channel")
strOver1000 = "yeah bo" + "i" * 1000
with pytest.raises(ValueError):
assert standup_send(token, chanId, strOver1000)
with pytest.raises(ValueError):
assert standup_send(token, chanId2,
"Standup message with wrong chanId")
def c_create():
""" This is a flask wrapper for the channels_create function
Parameters:
No parameters
Returns:
(dictionary): A dictionary with the channel_id of the new channel
"""
data = request.get_json()
token = data['token']
name = data['name']
is_public = bool(data['is_public'])
channel_id = channels_create(token, name, is_public)
return dumps(channel_id)
def test_search():
#search(token, query_str), returns messages
#SETUP TESTS BEGIN
#create new users:
authRegDict = auth_register("*****@*****.**",
"password", "Ben", "Kah")
token = authRegDict["token"]
#create channel
chanCreateDict = channels_create(token, "test channel", True)
chanId = chanCreateDict["channel_id"]
channel_join(token, chanId)
#create messages
msg_send(token, "New message sent", chanId)
msg_send(token, "Another message", chanId)
msg_send(token, "A completely different string", chanId)
#SETUP TESTS END
searchResultsList = search(token, "message") #first search query
searchResultsList2 = search(token, "nothing to find") #second search query
assert searchResultsList["messages"][1][
"message"] == "New message sent" #search results should contain these strings
assert searchResultsList["messages"][0]["message"] == "Another message"
assert len(searchResultsList["messages"]) == 2
assert len(searchResultsList2["messages"]) == 0 #list should be empty
def route_channels_create():
token = request.form.get('token')
name = request.form.get('name')
is_public = request.form.get('is_public')
return dumps(channels_create(token, name, is_public))
def test_channels_create_invalid():
with pytest.raises(InputError):
channels_create(hamish['token'],
'BenBenBenBenBenBenBenBenBenBenBenBenBenBen', True)
channel_id = channels_create(hamish_token['token'], 'New_channel', True)
# Now to call our storage and assert that the channel_id is present in our store
channel_store = get_channel_store()
result = False
for probe in channel_store['Channels']:
if probe['channel_id'] == channel_id['channel_id']:
result = True
# Now we assert the value of result
assert (result == True)
for probe in channel_store['Channels']:
if probe['channel_id'] == channel_id['channel_id']:
channel_store['Channels'].remove(probe)
# Lets go to our next tests
channel_id_hamish = channels_create(hamish_token['token'], 'Hamish_channel',
True)
# Zachs channel will be private
channel_id_zach = channels_create(zach_token['token'], 'Zach_channel', False)
channel_id_kelly = channels_create(kelly_token['token'], 'Kelly_channel', True)
# As of now, each uer is a owner and a member of their channel
# Test invalid channel
def test_channel_details_invalid():
with pytest.raises(AccessError):
channel_details(zach['token'], channel_id_hamish['channel_id'])
with pytest.raises(InputError):
channel_details(zach['token'], 12345)
from error import InputError
from server import defaultHandler
from channel import channel_messages, channels_create
from db import get_messages_store, get_user_store, get_channel_store, token_check, channel_check, message_check, react_check, get_standup_queue
from message import message_edit, message_remove
from message import message_send, message_send_later, message_react, message_unreact, message_pin, message_unpin
from standup import standup_start, standup_active, standup_send
from other import search
from auth import auth_register
from other import users_all
from auth import auth_register
import datetime
from datetime import timezone
hayden_dict = auth_register('*****@*****.**', 'password', 'hayden', 'smith')
chan_id = channels_create(hayden_dict['token'], 'Hayden', True)
print(hayden_dict)
print()
print(chan_id)
APP = Flask(__name__)
CORS(APP)
APP.config['TRAP_HTTP_EXCEPTIONS'] = True
APP.register_error_handler(Exception, defaultHandler)
@APP.route("/standup/start", methods=['POST'])
def standup_start_flask():
data = request.get_json()
token = data['token']
def create_channel():
token = request.form.get('token')
name = request.form.get('name')
is_public = request.form.get('is_public')
dic = channel.channels_create(token, name, is_public)
return dumps(dic)
from server import defaultHandler
from channel import channel_messages, channel_invite, channel_details, channel_messages
from channel import channel_list, channels_list_all, check_if_user_in_channel_member, check_if_channel_is_public
from channel import channel_leave, channel_join, channel_addowner, channel_removeowner, check_if_user_in_channel_owner, check_if_user_in_channel_owner_uid, channels_create, channel_invite
from auth import auth_register
from other import search
from db import login, make_user, get_channel_store, get_messages_store
from db import get_user_store, add_user, login, make_user
from db import token_check, channel_check, u_id_check, handle_check, email_check, email_dupe_check
from message import message_send
from other import users_all
input_dict = auth_register('*****@*****.**', 'password', 'hayden', 'smith')
rob_dict = auth_register('*****@*****.**', 'robword', 'rob', 'yalater')
channel_id = channels_create(input_dict['token'], "Chan1", True)
message_id = message_send(input_dict['token'], channel_id['channel_id'], "Hey")
message_id1 = message_send(input_dict['token'], channel_id['channel_id'], "wassup")
message_id2 = message_send(input_dict['token'], channel_id['channel_id'], "hru")
message_id3 = message_send(input_dict['token'], channel_id['channel_id'], "hru")
#chan_id = channels_create(input_dict['token'], 'Hayden', True)
print(input_dict)
print()
print(rob_dict)
print()
print()
APP = Flask(__name__)
CORS(APP)
APP.config['TRAP_HTTP_EXCEPTIONS'] = True
#import message
#import channels
#import channel
import pytest
from error import InputError, AccessError
from auth import auth_register
from channel import channels_create, channel_invite
from message import message_send, message_send_later, message_react, message_unreact, message_pin, message_unpin
from message import message_remove, message_edit
from db import get_messages_store
import datetime
from datetime import timezone
#Assumptions
#All the inputs are valid
hayden_dict = auth_register('*****@*****.**', 'password', 'hayden', 'smith')
chan_id = channels_create(hayden_dict['token'], 'Hayden', True)
rob_dict = auth_register("*****@*****.**", "paswword123", "Rob", "Ever")
#channel_invite(hayden_dict['token'], chan_id["channel_id"], rob_dict["u_id"])
message_id = message_send(hayden_dict['token'], chan_id['channel_id'],
"Haydens Message")
def test_message_send():
assert get_messages_store()['Messages'][0] == {
'channel_id': chan_id["channel_id"],
'message_id': message_id['message_id'],
'user_id': hayden_dict['u_id'],
'message': 'Haydens Message',
'reacts': [],
'time_created': get_messages_store()['Messages'][0]['time_created'],
from datetime import datetime, timedelta, timezone
from class_defines import User, Channel, Mesg, Reacts, data, perm_admin, perm_owner, perm_member
# setup
auth_register('*****@*****.**', 'password', 'kenny', 'han')
auth_register('*****@*****.**', 'password', 'k', 'h')
auth_register('*****@*****.**', 'password', 'h', 'k')
auth_login('*****@*****.**', 'password')
token1 = data['accounts'][0].token
# user 2 does not belong to any channel
auth_login('*****@*****.**', 'password')
token2 = data['accounts'][1].token
auth_login('*****@*****.**', 'password')
token3 = data['accounts'][2].token
# user 1 is the owner of channel1
channels_create(token1, 'channel1', True)
chan_id1 = data['channels'][0].channel_id
# user 3 is a member of channel1 but not owner
channel_join(token3, chan_id1)
# a long message
long_msg = 'a' * 1000
invalid_msg = 'a' * 1001 # more than 1000 characters
# setup end
def test_successful_msg_send():
# a normal msg
assert msg_send(token1, '1st msg', chan_id1) == {'message_id': 1}
assert data['channels'][0].messages[0].message_id == 1
# a msg with 1000 characters
assert msg_send(token3, long_msg, chan_id1) == {'message_id': 2}
