def testReturnMessagesEmpty(self):
responseFactory = ResponseFactory()
messages = []
response = responseFactory.returnMessages(12, messages)
self.assertEqual(
response,
'{"responseType": "Ok", "messages": [], "lastUpdate": 12}')
def testReturnMessages(self):
responseFactory = ResponseFactory()
messages = [Message(User("cam", 154, "password"), 'text', 456)]
response = responseFactory.returnMessages(123, messages)
self.assertEqual(
response,
'{"responseType": "Ok", "messages": [{"username": "******", "text": "text"}], "lastUpdate": 123}'
)
def testDuplicateChatroom(self):
responseFactory = ResponseFactory()
response = responseFactory.duplicateChatrooom()
self.assertEqual(response, '{"responseType": "DuplicateChatroom"}')
def testChatroomDoesNotExist(self):
responseFactory = ResponseFactory()
response = responseFactory.chatroomDoesNotExist()
self.assertEqual(response, '{"responseType": "ChatroomDoesNotExist"}')
def testBlocked(self):
responseFactory = ResponseFactory()
response = responseFactory.blocked()
self.assertEqual(response, '{"responseType": "Blocked"}')
class Server:
PORT = 9321
#Parameter Names
REQUEST_TYPE = 'requestType'
USERNAME = '******'
PASSWORD = '******'
USER_ID = 'userID'
CHATROOM = 'chatroom'
MESSAGE = 'message'
LAST_UPDATE = 'lastUpdate'
NEW_USERNAME = '******'
USER_TO_BLOCK = 'userToBlock'
USER_TO_UNBLOCK = 'userToUnblock'
#Request Types
SIGN_UP = 'signup'
LOGIN = '******'
SEND = 'send'
GET = 'get'
SET_ALIAS = 'set_alias'
JOIN = 'join'
CREATE = 'create'
BLOCK = 'block'
UNBLOCK = 'unblock'
DELETE = 'delete'
def __init__(self):
self.responseFactory = ResponseFactory()
self.controller = Controller()
def start(self):
s = socket.socket()
host = socket.gethostname()
print 'Starting Server'
s.bind((host, self.PORT))
s.listen(100)
while True:
client, clientAddress = s.accept()
request = client.recv(2048)
response = self.__parseRequest(request)
client.send(response)
def __parseRequest(self, request):
if not isinstance(request, str):
return self.responseFactory.requestFormatError()
try:
requestDict = json.loads(request)
except ValueError:
return self.responseFactory.requestFormatError()
try:
requestType = requestDict[self.REQUEST_TYPE]
except KeyError:
return self.responseFactory.requestTypeMissing()
#route the request to the proper function in the controller
try:
if requestType == self.SIGN_UP:
username = self.__getParameter(requestDict, self.USERNAME,
basestring, False)
password = self.__getParameter(requestDict, self.PASSWORD,
basestring, False)
return self.controller.signup(username, password)
elif requestType == self.LOGIN:
username = self.__getParameter(requestDict, self.USERNAME,
basestring, False)
password = self.__getParameter(requestDict, self.PASSWORD,
basestring, False)
return self.controller.login(username, password)
elif requestType == self.SEND:
userID = self.__getParameter(requestDict, self.USER_ID, int,
False)
password = self.__getParameter(requestDict, self.PASSWORD,
basestring, False)
chatroom = self.__getParameter(requestDict, self.CHATROOM,
basestring, False)
message = self.__getParameter(requestDict, self.MESSAGE,
basestring, False)
return self.controller.send(userID, password, chatroom,
message)
elif requestType == self.GET:
userID = self.__getParameter(requestDict, self.USER_ID, int,
False)
password = self.__getParameter(requestDict, self.PASSWORD,
basestring, False)
chatroom = self.__getParameter(requestDict, self.CHATROOM,
basestring, False)
lastUpdate = self.__getParameter(requestDict, self.LAST_UPDATE,
int, True)
return self.controller.get(userID, password, chatroom,
lastUpdate)
elif requestType == self.SET_ALIAS:
userID = self.__getParameter(requestDict, self.USER_ID, int,
False)
password = self.__getParameter(requestDict, self.PASSWORD,
basestring, False)
newUsername = self.__getParameter(requestDict,
self.NEW_USERNAME,
basestring, False)
return self.controller.set_alias(userID, password, newUsername)
elif requestType == self.JOIN:
userID = self.__getParameter(requestDict, self.USER_ID, int,
False)
password = self.__getParameter(requestDict, self.PASSWORD,
basestring, False)
chatroom = self.__getParameter(requestDict, self.CHATROOM,
basestring, False)
return self.controller.join(userID, password, chatroom)
elif requestType == self.CREATE:
userID = self.__getParameter(requestDict, self.USER_ID, int,
False)
password = self.__getParameter(requestDict, self.PASSWORD,
basestring, False)
chatroom = self.__getParameter(requestDict, self.CHATROOM,
basestring, False)
return self.controller.create(userID, password, chatroom)
elif requestType == self.BLOCK:
userID = self.__getParameter(requestDict, self.USER_ID, int,
False)
password = self.__getParameter(requestDict, self.PASSWORD,
basestring, False)
chatroom = self.__getParameter(requestDict, self.CHATROOM,
basestring, False)
userToBlock = self.__getParameter(requestDict,
self.USER_TO_BLOCK,
basestring, False)
return self.controller.block(userID, password, chatroom,
userToBlock)
elif requestType == self.UNBLOCK:
userID = self.__getParameter(requestDict, self.USER_ID, int,
False)
password = self.__getParameter(requestDict, self.PASSWORD,
basestring, False)
chatroom = self.__getParameter(requestDict, self.CHATROOM,
basestring, False)
userToUnblock = self.__getParameter(requestDict,
self.USER_TO_UNBLOCK,
basestring, False)
return self.controller.unblock(userID, password, chatroom,
userToUnblock)
elif requestType == self.DELETE:
userID = self.__getParameter(requestDict, self.USER_ID, int,
False)
password = self.__getParameter(requestDict, self.PASSWORD,
basestring, False)
chatroom = self.__getParameter(requestDict, self.CHATROOM,
basestring, False)
return self.controller.delete(userID, password, chatroom)
else:
return self.responseFactory.requestFormatError()
except ParameterFormatException:
return self.responseFactory.requestFormatError()
except ParameterMissingException:
return self.responseFactory.parametersMissing()
def __getParameter(self, requestDict, key, type, nullable):
try:
value = requestDict[key]
if isinstance(value, type):
return value
else:
raise ParameterFormatException
except KeyError:
if not nullable:
raise ParameterMissingException
return None
class Controller:
def __init__(self):
self.authenticator = Authenticator()
self.chatSystem = ChatSystem()
self.responseFactory = ResponseFactory()
#These functions deal with routing the requests to the proper ChatSystem functions,
#They assume that all parameters are not None, unless otherwise specified and the
#parameters are of the proper type
#The functions return a string corresponding to the proper response type
#The functions authenticate the users if necessary
def login(self, username, password):
try:
self.__authenticateByName(username, password)
userID = self.chatSystem.login(username, password)
if userID is None:
return self.responseFactory.invalidCredentials()
return self.responseFactory.loggedIn(userID)
except Exception as e:
return self.handleException(e)
def signup(self, username, password):
try:
userID = self.chatSystem.signup(username, password)
return self.responseFactory.loggedIn(userID)
except Exception as e:
return self.handleException(e)
def send(self, userID, password, chatroom, text):
try:
self.__authenticateByID(userID, password)
self.chatSystem.addMessage(chatroom, userID, text)
return self.responseFactory.ok()
except Exception as e:
return self.handleException(e)
def get(self, userID, password, chatroom, lastUpdate):
try:
self.__authenticateByID(userID, password)
if lastUpdate is None:
response = self.chatSystem.getMessagesByTime(chatroom, userID)
else:
response = self.chatSystem.getMessagesByIndex(chatroom,userID,lastUpdate)
return self.responseFactory.returnMessages(response[0], response[1])
except Exception as e:
return self.handleException(e)
def set_alias(self, userID, password, newUsername):
try:
self.__authenticateByID(userID, password)
self.chatSystem.set_alias(userID, newUsername, password)
return self.responseFactory.ok()
except Exception as e:
return self.handleException(e)
def join(self, userID, password, chatroom):
try:
self.__authenticateByID(userID, password)
self.chatSystem.joinChatroom(chatroom, userID)
return self.responseFactory.ok()
except Exception as e:
return self.handleException(e)
def create(self, userID, password, chatroom):
try:
self.__authenticateByID(userID, password)
self.chatSystem.addChatroom(userID,chatroom)
return self.responseFactory.ok()
except Exception as e:
return self.handleException(e)
def delete(self, userID, password, chatroom):
try:
self.__authenticateByID(userID, password)
self.chatSystem.deleteChatroom(userID, chatroom)
return self.responseFactory.ok()
except Exception as e:
return self.handleException(e)
def block(self, userID, password, chatroom, userToBlock):
try:
self.__authenticateByID(userID, password)
self.chatSystem.banUser(userID, chatroom, userToBlock)
return self.responseFactory.ok()
except Exception as e:
return self.handleException(e)
def unblock(self, userID, password, chatroom, userToUnblock):
try:
self.__authenticateByID(userID, password)
self.chatSystem.unbanUser(userID, chatroom, userToUnblock)
return self.responseFactory.ok()
except Exception as e:
return self.handleException(e)
def __authenticateByID(self,userID, password):
if not self.authenticator.authenticateByID(userID, password):
raise InvalidCredentialsException
def __authenticateByName(self, username, password):
if not self.authenticator.authenticateByName(username, password):
raise InvalidCredentialsException
def handleException(self, e):
if isinstance(e,InvalidCredentialsException):
return self.responseFactory.invalidCredentials()
if isinstance(e,ChatroomDoesNotExistException):
return self.responseFactory.chatroomDoesNotExist()
elif isinstance(e,DuplicateChatroomException):
return self.responseFactory.duplicateChatrooom()
elif isinstance(e,DuplicateUsernameException):
return self.responseFactory.duplicateUsername()
elif isinstance(e,ChatroomFormatException):
return self.responseFactory.invalidChatroom()
elif isinstance(e,MessageFormatException):
return self.responseFactory.invalidMessage()
elif isinstance(e,UsernameFormatException):
return self.responseFactory.invalidUsername()
elif isinstance(e,PasswordFormatException):
return self.responseFactory.invalidPassword()
elif isinstance(e,UserNotFoundException):
return self.responseFactory.userDoesNotExist()
elif isinstance(e,NotOwnerException):
return self.responseFactory.notOwner()
elif isinstance(e,UserBannedException):
return self.responseFactory.blocked()
elif isinstance(e,UserNotBannedException):
return self.responseFactory.userNotOnList()
elif isinstance(e,UserIsOwnerException):
return self.responseFactory.userIsOwner()
else:
return self.responseFactory.serverError()
def testLoggedIn(self):
responseFactory = ResponseFactory()
response = responseFactory.loggedIn(132)
self.assertEqual(response, '{"responseType": "Ok", "userID": 132}')
def testUserNotOnList(self):
responseFactory = ResponseFactory()
response = responseFactory.userNotOnList()
self.assertEqual(response, '{"responseType": "UserNotOnList"}')
def testDuplicateUsername(self):
responseFactory = ResponseFactory()
response = responseFactory.duplicateUsername()
self.assertEqual(response, '{"responseType": "DuplicateUsername"}')
def testRequestFormatError(self):
responseFactory = ResponseFactory()
response = responseFactory.requestFormatError()
self.assertEqual(response, '{"responseType": "RequestFormatError"}')
def testRequestTypeMissing(self):
responseFactory = ResponseFactory()
response = responseFactory.requestTypeMissing()
self.assertEqual(response, '{"responseType": "RequestTypeMissing"}')
def testInvalidChatroom(self):
responseFactory = ResponseFactory()
response = responseFactory.invalidChatroom()
self.assertEqual(response, '{"responseType": "InvalidChatroom"}')
def testUserIsOwner(self):
responseFactory = ResponseFactory()
response = responseFactory.userIsOwner()
self.assertEqual(response, '{"responseType": "UserIsOwner"}')
def testServerError(self):
responseFactory = ResponseFactory()
response = responseFactory.serverError()
self.assertEqual(response, '{"responseType": "ServerError"}')
def testOK(self):
responseFactory = ResponseFactory()
response = responseFactory.ok()
self.assertEqual(response, '{"responseType": "Ok"}')
def testNotOwner(self):
responseFactory = ResponseFactory()
response = responseFactory.notOwner()
self.assertEqual(response, '{"responseType": "NotOwner"}')
def testInvalidPassword(self):
responseFactory = ResponseFactory()
response = responseFactory.invalidPassword()
self.assertEqual(response, '{"responseType": "InvalidPassword"}')
def testParameterFormatError(self):
responseFactory = ResponseFactory()
response = responseFactory.parameterFormatError()
self.assertEqual(response, '{"responseType": "ParameterFormatError"}')
def testParametersMissing(self):
responseFactory = ResponseFactory()
response = responseFactory.parametersMissing()
self.assertEqual(response, '{"responseType": "ParametersMissing"}')
def testInvalidCredentials(self):
responseFactory = ResponseFactory()
response = responseFactory.invalidCredentials()
self.assertEqual(response, '{"responseType": "InvalidCredentials"}')
def testInvalidMessage(self):
responseFactory = ResponseFactory()
response = responseFactory.invalidMessage()
self.assertEqual(response, '{"responseType": "InvalidMessage"}')
def __init__(self):
self.authenticator = Authenticator()
self.chatSystem = ChatSystem()
self.responseFactory = ResponseFactory()
def __init__(self):
self.responseFactory = ResponseFactory()
self.controller = Controller()
