def test_getMessageResponse_GamesAlreadyStarted(self):
self.utilities.resetValues()
self.utilities.witCategories = {"game": "tic-tac-toe"}
setInDB(self.SENDER_ID, {"state": {"game": "ticTacToe"}})
response = self.utilities.getMessageResponse()
self.assertEqual("text_message", response["type"])
setInDB(self.SENDER_ID, {"state": None, "play": False, "game": None})
def continueQuestion(self):
senderId = self.senderId
self.newFavorite = getInDB(senderId, "response")
self.newFavoriteType = getInDB(senderId, "type")
if self.acceptNewFavorite() and self.newFavorite and self.newFavorite != "None":
messageToSend = self.setNewFavoriteInDb()
elif (
self.newFavoriteType
and self.newFavoriteType != "None"
and self.categories.get("favorite")
):
self.newFavorite = self.categories.get("favorite")
messageToSend = self.setNewFavoriteInDb()
elif (
self.newFavoriteType
and self.newFavoriteType != "None"
and self.categories.get("response")
and "oui" not in self.getCategoryValue("response")
and "correct" not in self.getCategoryValue("response")
and "bien sûr" not in self.getCategoryValue("response")
and "non" not in self.getCategoryValue("response")
):
self.newFavorite = self.categories.get("response")
messageToSend = self.setNewFavoriteInDb()
elif self.acceptNewFavorite():
messageToSend = self.askNewFavorite()
else:
messageToSend = "Ah, ok. Donc on ne change pas"
setInDB(senderId, {"response": None, "question": None, "type": None})
return messageToSend
def test_getResponseWithDatabase(self):
deleteFromDB(self.SENDER_ID)
setInDB(self.SENDER_ID, {"rickPartLastLyrics": 5})
response = self.functionality.getResponse()
self.assertEqual("text_message", response["type"])
self.assertEqual(putNotesEmojisAround("Never gonna let you down"),
response["message"])
def test_findInDB(self):
"""
tests setInDB, findInDB and deleteFromDB
"""
setInDB(0, {"name": "Joe"})
self.assertTrue(findInDB(0), "is in db")
deleteFromDB(1)
self.assertFalse(findInDB(1), "is not in db anymore")
def test_deleteFromDB(self):
"""
tests setInDB, deleteFromDB and getInDB
"""
setInDB(0, {"name": "Joe"})
self.assertTrue(getInDB(0, "name"), "is in db")
deleteFromDB(0)
self.assertFalse(getInDB(0, "name"), "is not in db anymore")
def test_getResponse_whenNewFavorite(self):
setInDB(self.SENDER_ID, {"question": None})
setInDB(self.SENDER_ID, {"favorite": {"Animal": "Chat"}})
response = self.functionality.getResponse()
self.assertEqual(
"Hmmm...si je me souviens bien...Animal préféré(e) pour l'instant est Chat! Est-ce que tu veux changer?",
response["message"],
)
self.assertEqual("text_message", response["type"])
def askNewFavorite(self):
messageToSend = "Good! Donc, quel est ton/ta {0} préféré(e)?".format(
self.newFavoriteType
)
setInDB(
self.senderId,
{"question": "favorite", "type": self.newFavoriteType, "response": None,},
)
return messageToSend
def getResponseContinueWithQuestion(self):
getInDB(self.senderId, "question")
if "response" in self.categories:
setInDB(self.senderId, {"question": None})
messageToSend = self.getContinueHowAreYouQuestion()
else:
setInDB(self.senderId, {"question": None})
messageToSend = {"RICKROLL": ["hmm, ok", "voici ce que je pense"]}
return messageToSend
def continueQuestion(self):
senderId = self.senderId
self.newLocation = getInDB(senderId, "response")
if self.acceptNewLocation():
messageToSend = self.setNewLocationInDb()
else:
messageToSend = "Ah, ok. Donc on ne change pas"
setInDB(senderId, {"response": None})
return messageToSend
def test_getResponse_whenNotChangingFavorite(self):
setInDB(self.SENDER_ID, {"question": None})
setInDB(self.SENDER_ID, {"favorite": {"Animal": "Chien"}})
response = self.functionality.getResponse()
self.assertEqual(
"Ok, donc je garde Chien en note pour Animal préféré(e)!",
response["message"],
)
self.assertEqual("text_message", response["type"])
def test_getResponse_whenNotChangingLocation(self):
# check default message and type
setInDB(self.SENDER_ID, {"question": None})
setInDB(self.SENDER_ID, {"location": "Canada"})
response = self.functionality.getResponse()
self.assertEqual(
"Ok, donc je garde Canada en note comme étant ta localisation préférée!",
response["message"],
)
self.assertEqual("text_message", response["type"])
def test_getResponse_whenSayingNoChangingLocation(self):
# check default message and type
setInDB(
self.SENDER_ID,
{"question": "location", "response": "India", "location": "India"},
)
response = self.functionality.getResponse()
self.assertEqual("Ah, ok. Donc on ne change pas", response["message"])
self.assertEqual("text_message", response["type"])
setInDB(self.SENDER_ID, {"location": "Canada"})
def getGreetingsResponse(self):
value = self.categories["greetings"]
if value == "wazza":
messageToSend = "wazzaa \n wazzaaaa"
else:
messageToSend = random.choice([
value, "Yo!", "Salut!", "Hey! "
]) + random.choice([" ça va?", " comment tu vas?", " what's up?"])
setInDB(self.senderId, {"question2": "howAreYou2"})
return messageToSend
def test_TicTacToeResponse(self):
categories = {"response": "oui"}
functionality = GameFunctionality(self.SENDER_ID, self.bot, categories,
self.payload)
deleteFromDB(self.SENDER_ID)
setInDB(self.SENDER_ID, {"game": "ticTacToe"})
response = functionality.getResponse()
self.assertEqual("text_message", response["type"])
self.assertIsInstance(response["message"], str)
self.assertIsNotNone(getInDB(self.SENDER_ID, "grid"))
def test_TicTacToeGameStarted(self):
deleteFromDB(self.SENDER_ID)
setInDB(
self.SENDER_ID,
{"grid": [["0", "1", "2"], ["3", "4", "5"], ["6", "7", "8"]]},
)
response = self.functionality.continuePlayingTicTacToe()
self.assertIsInstance(response, str)
setInDB(self.SENDER_ID, {"grid": None})
def askToChangeLocation(self):
newLocation = self.newLocation
senderId = self.senderId
oldLocation = getInDB(senderId, "location")
if not oldLocation:
oldLocation = "inconnue"
messageToSend = (
"Ton endroit préféré jusqu'à maintenant était {0}"
", est-ce que tu veux le changer?".format(oldLocation))
setInDB(senderId, {"question": "location", "response": newLocation})
return messageToSend
def test_getMessageToSendIfQuestion(self):
setInDB(self.SENDER_ID, {"question": "howAreYou"})
messageToSend = self.functionality.getMessageToSend()
self.assertFalse(getInDB(self.SENDER_ID, "question"))
self.assertIn(
messageToSend,
[
"Tant mieux!",
"Et ben. Ça va bien aller" + emojis.RAINBOW + ", comme on dit",
"Tout va bien alors " + emojis.HAPPY_FACE + "!",
],
)
def getMessageToSend(self):
categories = self.categories
senderId = self.senderId
question = []
if getInDB(senderId, "question"):
question = getInDB(senderId, "question")
setInDB(senderId, {"question": None})
if "location" in question:
messageToSend = self.continueQuestion()
else:
self.newLocation = str(categories["location"])
if getInDB(senderId, "location") != self.newLocation:
messageToSend = self.askToChangeLocation()
else:
messageToSend = self.setNewLocationInDb()
return messageToSend
def nextLyrics(self):
lyricFromUser = self.categories.get("rickSong")
nextLyrics = "We're no strangers to love"
lyricIndice = 0
if getInDB(self.senderId, "rickPartLastLyrics"):
if int(getInDB(self.senderId, "rickPartLastLyrics") +
2) < len(neverGonnaGiveYouUp):
nextLyrics = neverGonnaGiveYouUp[int(
getInDB(self.senderId, "rickPartLastLyrics") + 2)]
lyricIndice = getInDB(self.senderId, "rickPartLastLyrics")
for i in range(lyricIndice, len(neverGonnaGiveYouUp)):
if neverGonnaGiveYouUp[i] == lyricFromUser:
nextLyrics = neverGonnaGiveYouUp[i + 1]
setInDB(self.senderId, {"rickPartLastLyrics": i + 1})
break
return nextLyrics
def test_getResponse_whenAskingFavorite(self):
categories = {"favoriteType": "Animal"}
functionality = FavoriteThingFunctionality(self.SENDER_ID, self.bot,
categories)
setInDB(
self.SENDER_ID,
{"favorite": {
"Animal": "chien"
}},
)
response = functionality.getResponse()
self.assertEqual(
"Hmmm...si je me souviens bien...Animal préféré(e) pour l'instant est chien! Est-ce que tu veux changer?",
response["message"],
)
self.assertEqual("text_message", response["type"])
def setNewFavoriteInDb(self):
newFavorite = self.newFavorite
newFavoriteType = self.newFavoriteType
senderId = self.senderId
setInDB(
senderId,
{
"favorite": {self.newFavoriteType: newFavorite},
"response": None,
"question": None,
"type": None,
},
)
return "Ok, donc je garde {0} en note pour {1} préféré(e)!".format(
newFavorite, newFavoriteType
)
def setNewsRecurrence(self):
if "frequence" in self.categories:
frequence = self.categories.get("frequence")
if "jour" in frequence:
setInDB(self.senderId, {"newsRecurrence": "jour"})
messageToSend = "C'est noté! Toutefois, cette fonction ne marche pas présentement, dsl"
setInDB(self.senderId, {"question": None})
elif "semaine" in frequence:
setInDB(self.senderId, {"newsRecurrence": "semaine"})
messageToSend = "C'est noté! Toutefois, cette fonction ne marche pas présentement, dsl"
setInDB(self.senderId, {"question": None})
else:
messageToSend = "Je ne sais pas trop quelle est cette fréquence, désolé"
else:
messageToSend = "D'accord, tu me demanderas des nouvelles quand tu en veux!"
setInDB(self.senderId, {"newsRecurrence": None})
return {"message": messageToSend, "type": "text_message"}
def test_getResponse_whenChangingFavorite(self):
categories = {"response": "oui"}
functionality = FavoriteThingFunctionality(self.SENDER_ID, self.bot,
categories)
setInDB(
self.SENDER_ID,
{
"question": "favorite",
"type": "Animal",
"response": "Chat"
},
)
response = functionality.getResponse()
self.assertEqual(
"Ok, donc je garde Chat en note pour Animal préféré(e)!",
response["message"],
)
self.assertEqual("text_message", response["type"])
def test_getMessageResponse_FavoriteFollowUp(self):
deleteFromDB(self.SENDER_ID)
self.utilities.resetValues()
setInDB(
self.SENDER_ID,
{
"question": "favorite",
"type": "animal",
"response": "chien"
},
)
self.utilities.witCategories = {"response": "oui"}
response = self.utilities.getMessageResponse()
self.assertEqual("text_message", response["type"])
self.assertEqual(
"Ok, donc je garde chien en note pour animal préféré(e)!",
response["message"],
)
def getTicTacToeMove(self, grid):
try:
move = "0"
if self.payload:
move = str(self.payload)
else:
if self.categories["number"]:
move = int(self.categories["number"])
if move not in range(9) or move == 0:
move = "0"
return str(move)
except Exception as err:
if self.categories.get("stop"):
setInDB(self.senderId, {
"state": None,
"play": False,
"game": None
})
raise TypeError("Ok, On arrête pour l'instant")
else:
raise TypeError("Mais ce n'est pas un numéro ça!")
def getMessageToSend(self):
categories = self.categories
senderId = self.senderId
question = []
if getInDB(senderId, "question"):
question = getInDB(senderId, "question")
setInDB(senderId, {"question": None})
if "favorite" in question:
messageToSend = self.continueQuestion()
else:
self.newFavorite = str(categories.get("favorite"))
self.newFavoriteType = str(categories.get("favoriteType"))
if (type(getInDB(senderId, "favorite")) == dict) and (
getInDB(senderId, "favorite").get(self.newFavoriteType)
!= self.newFavorite
):
messageToSend = self.askToChangeFavorite()
elif "favorite" in categories and "favoriteType" in categories:
messageToSend = self.setNewFavoriteInDb()
else:
messageToSend = self.continueQuestion()
return messageToSend
def askToChangeFavorite(self):
newFavorite = self.newFavorite
newFavoriteType = self.newFavoriteType
senderId = self.senderId
if (type(getInDB(senderId, "favorite")) == dict) and (
getInDB(senderId, "favorite").get(self.newFavoriteType)
):
oldFavorite = getInDB(senderId, "favorite").get(self.newFavoriteType)
else:
oldFavorite = "inconnue"
messageToSend = str(
"Hmmm...si je me souviens bien...{0} préféré(e) pour l'instant est {1}! "
"Est-ce que tu veux changer?"
).format(newFavoriteType, oldFavorite)
if newFavorite:
setInDB(
senderId,
{
"question": "favorite",
"type": newFavoriteType,
"response": newFavorite,
},
)
return messageToSend
def test_getResponse_whenNewLocation(self):
# check default message and type
setInDB(self.SENDER_ID, {"question": None})
setInDB(self.SENDER_ID, {"location": "India"})
response = self.functionality.getResponse()
self.assertEqual(
"Ton endroit préféré jusqu'à maintenant était India, est-ce que tu veux le changer?",
response["message"],
)
self.assertEqual("text_message", response["type"])
setInDB(self.SENDER_ID, {"location": "Canada"})
def test_givenKeyAndValue_findAllInDB(self):
"""
tests setInDB, deleteFromDB and getInDB
"""
setInDB(0, {"potatoe": "Joe"})
setInDB(1, {"potatoe": "meh"})
setInDB(2, {"potatoe": None})
peopleFound = findAllInDB("potatoe", "meh")
self.assertEqual(1, (peopleFound[0]).get("_id"))
deleteFromDB(0)
deleteFromDB(1)
deleteFromDB(2)
def test_getResponseRecurrence(self):
deleteFromDB(self.SENDER_ID)
response = self.functionality.getResponse()
self.assertEqual("generic_message", response["type"])
self.assertTrue(len(response["message"]) != 0)
setInDB(self.SENDER_ID, {"newsRecurrence": None})
