def setUp(self):
client = TestClient()
self._bot = Bot(BotConfiguration(), client)
class SentimentExtensionTests(unittest.TestCase):
def setUp(self):
self._client = TestClient()
config = BotConfiguration()
config.sentiment_analyser._classname = "programy.sentiment.textblob_sentiment.TextBlobSentimentAnalyser"
config.sentiment_analyser._scores = "programy.sentiment.scores.SentimentScores"
self.client_context = self._client.create_client_context("testuser")
self.client_context._bot = Bot(config=config, client=self._client)
self.client_context._bot.initiate_sentiment_analyser()
def test_invalid_command(self):
extension = SentimentExtension()
self.assertIsNotNone(extension)
result = extension.execute(self.client_context, "XXX")
self.assertIsNotNone(result)
self.assertEqual("SENTIMENT INVALID COMMAND", result)
result = extension.execute(self.client_context, "SENTIMENT")
self.assertIsNotNone(result)
self.assertEqual("SENTIMENT INVALID COMMAND", result)
result = extension.execute(self.client_context, "SENTIMENT SCOREX")
self.assertIsNotNone(result)
self.assertEqual("SENTIMENT INVALID COMMAND", result)
result = extension.execute(self.client_context, "SENTIMENT FEELING")
self.assertIsNotNone(result)
self.assertEqual("SENTIMENT INVALID COMMAND", result)
result = extension.execute(self.client_context,
"SENTIMENT FEELING LAST")
self.assertIsNotNone(result)
self.assertEqual("SENTIMENT INVALID COMMAND", result)
result = extension.execute(self.client_context, "SENTIMENT SCORES")
self.assertIsNotNone(result)
self.assertEqual("SENTIMENT INVALID COMMAND", result)
result = extension.execute(self.client_context, "SENTIMENT CURRENT")
self.assertIsNotNone(result)
self.assertEqual("SENTIMENT INVALID COMMAND", result)
def test_valid_scores_command(self):
extension = SentimentExtension()
self.assertIsNotNone(extension)
result = extension.execute(self.client_context, "SENTIMENT ENABLED")
self.assertIsNotNone(result)
self.assertEqual("SENTIMENT ENABLED", result)
result = extension.execute(self.client_context,
"SENTIMENT FEELING LAST 1")
self.assertIsNotNone(result)
self.assertEqual("SENTIMENT FEELING NEUTRAL AND NEUTRAL", result)
result = extension.execute(self.client_context,
"SENTIMENT FEELING OVERALL")
self.assertIsNotNone(result)
self.assertEqual("SENTIMENT FEELING NEUTRAL AND NEUTRAL", result)
result = extension.execute(self.client_context,
"SENTIMENT SCORE I LIKE YOU")
self.assertIsNotNone(result)
self.assertEqual(
"SENTIMENT SCORES POSITIVITY NEUTRAL SUBJECTIVITY COMPLETELY OBJECTIVE",
result)
def __init__(self):
TestClient.__init__(self)
def test_bot_init_supplied_brain(self):
client = TestClient()
bot = Bot(BotConfiguration(), client)
self.assertIsNotNone(bot)
self.assertIsNotNone(bot.brain)
class SentimentTests(unittest.TestCase):
def setUp(self):
self._client = TestClient()
config = BotConfiguration()
config.sentiment_analyser._classname = "programy.nlp.sentiment.textblob_sentiment.TextBlobSentimentAnalyser"
self.client_context = self._client.create_client_context("testuser")
self.client_context._bot = Bot(config=config, client=self._client)
self.client_context._bot.initiate_sentiment_analyser()
def test_sentence_sentiment(self):
sentence = Sentence(self.client_context, "HELLO")
sentence.calculate_sentinment_score(self.client_context)
self.assertEqual(0.00, sentence.positivity)
self.assertEqual(0.00, sentence.subjectivity)
sentence = Sentence(self.client_context, "I hate you")
sentence.calculate_sentinment_score(self.client_context)
self.assertEqual(-0.8, sentence.positivity)
self.assertEqual(0.9, sentence.subjectivity)
def test_question_sentiment(self):
question = Question.create_from_text(self.client_context,
"Hello There. How Are you")
for sentence in question.sentences:
sentence.calculate_sentinment_score(self.client_context)
positivity, subjectivity = question.calculate_sentinment_score()
self.assertEqual(0.0, positivity)
self.assertEqual(0.0, subjectivity)
question = Question.create_from_text(
self.client_context, "I hate you. Your car is rubbish")
question.recalculate_sentinment_score(self.client_context)
positivity, subjectivity = question.calculate_sentinment_score()
self.assertEqual(-0.4, positivity)
self.assertEqual(0.45, subjectivity)
def test_conversation_sentiment(self):
conversation = Conversation(self.client_context)
question1 = Question.create_from_text(self.client_context,
"I am so unhappy")
conversation.record_dialog(question1)
question2 = Question.create_from_text(self.client_context,
"I do not like the colour red")
conversation.record_dialog(question2)
question3 = Question.create_from_text(self.client_context,
"Custard makes me feel sick")
conversation.record_dialog(question3)
conversation.recalculate_sentiment_score(self.client_context)
positivity, subjectivity = conversation.calculate_sentiment_score()
self.assertEqual(-0.4380952380952381, positivity)
self.assertEqual(0.5857142857142857, subjectivity)
def setUp(self):
self._client_context = ClientContext(TestClient(), "testid")
def test_bot_init_no_spellchecker(self):
bot_config = BotConfiguration()
bot_config.spelling._classname = None
client = TestClient()
bot = Bot(BotConfiguration(), client)
self.assertIsNotNone(bot)
def test_to_json(self):
client = TestClient()
client_context = ClientContext(client, "testid")
client_context.bot = Bot(BotConfiguration(), client)
client_context.bot.configuration.conversations._max_histories = 3
client_context.brain = client_context.bot.brain
conversation1 = Conversation(client_context)
conversation1.properties["convo1"] = "value1"
matched_context = MatchContext(100, 100)
matched_context.matched_nodes.append(Match(Match.WORD, PatternWordNode("Hello"), "Hello"))
sentence = Sentence(client_context, text="Hi", response="Hello there", matched_context=matched_context)
question1 = Question.create_from_sentence(sentence)
question1.properties['quest1'] = "value2"
conversation1.record_dialog(question1)
json_data = conversation1.to_json()
self.assertIsNotNone(json_data)
self.assertEqual("testclient", json_data['client_context']['clientid'])
self.assertEqual("testid", json_data['client_context']['userid'])
self.assertEqual("bot", json_data['client_context']['botid'])
self.assertEqual("brain", json_data['client_context']['brainid'])
self.assertEqual(0, json_data['client_context']['depth'])
conversation2 = Conversation.from_json(client_context, json_data)
self.assertEqual(conversation1._client_context.client.id, conversation2._client_context.client.id)
self.assertEqual(conversation1._client_context.userid, conversation2._client_context.userid)
self.assertEqual(conversation1._client_context.bot.id, conversation2._client_context.bot.id)
self.assertEqual(conversation1._client_context.brain.id, conversation2._client_context.brain.id)
self.assertEqual(conversation1._client_context._question_start_time,
conversation2._client_context._question_start_time)
self.assertEqual(conversation1._client_context._question_depth, conversation2._client_context._question_depth)
self.assertEqual(conversation1._client_context._id, conversation2._client_context._id)
self.assertEqual(conversation1.properties, conversation2.properties)
self.assertEqual(conversation1.max_histories, conversation2.max_histories)
self.assertNotEquals(0, len(conversation1.questions))
self.assertNotEquals(0, len(conversation2.questions))
self.assertEqual(len(conversation1.questions), len(conversation2.questions))
for i in range(len(conversation2.questions)):
q1 = conversation1.questions[i]
q2 = conversation2.questions[i]
self.assertEqual(q1.srai, q2.srai)
self.assertEqual(q1._current_sentence_no, q2._current_sentence_no)
self.assertEqual(q1.properties, q2.properties)
self.assertNotEquals(0, len(q1.sentences))
self.assertNotEquals(0, len(q2.sentences))
self.assertEqual(len(q1.sentences), len(q2.sentences))
for j in range(len(q2.sentences)):
s1 = q1.sentences[j]
s2 = q2.sentences[j]
self.assertEqual(s1.words, s2.words)
self.assertEqual(s1.response, s2.response)
self.assertEqual(s1.positivity, s2.positivity)
self.assertEqual(s1.subjectivity, s2.subjectivity)
mc1 = s1.matched_context
mc2 = s2.matched_context
self.assertEquals(mc1.template_node, mc2.template_node)
self.assertEquals(mc1.max_search_depth, mc2.max_search_depth)
self.assertEquals(mc1.max_search_timeout, mc2.max_search_timeout)
time1 = mc1._total_search_start.strftime("%d/%m/%Y, %H:%M:%S")
time2 = mc2._total_search_start.strftime("%d/%m/%Y, %H:%M:%S")
self.assertEquals(time1, time2)
self.assertNotEquals(0, len(mc1.matched_nodes))
self.assertNotEquals(0, len(mc2.matched_nodes))
self.assertEquals(len(mc1.matched_nodes), len(mc2.matched_nodes))
for k in range(len(mc1.matched_nodes)):
mn1 = mc1.matched_nodes[k]
mn2 = mc2.matched_nodes[k]
self.assertEquals(mn1._matched_node_str, mn2._matched_node_str)
self.assertEquals(mn1._matched_node_type, mn2._matched_node_type)
self.assertEquals(mn1._matched_node_multi_word, mn2._matched_node_multi_word)
self.assertEquals(mn1._matched_node_wildcard, mn2._matched_node_wildcard)
self.assertEquals(mn1._matched_node_words, mn2._matched_node_words)
def __init__(self, aiml_file, score):
self._aiml_file = aiml_file
self._score = score
TestClient.__init__(self)
def test_init_context_and_converstion(self):
client = TestClient()
client_context = client.create_client_context("testuser")
convo = Convo(client_context)
question = Question.create_from_text(client_context, "Hello world")
question.current_sentence()._response = "Hello matey"
convo.record_dialog(question)
conversation = Conversation(client_context, convo)
self.assertIsNotNone(conversation)
self.assertEqual(client_context.client.id, conversation.clientid)
self.assertEqual(client_context.userid, conversation.userid)
self.assertEqual(client_context.bot.id, conversation.botid)
self.assertEqual(client_context.brain.id, conversation.brainid)
self.assertIsNotNone(conversation.conversation)
doc = conversation.to_document()
self.assertEqual(
{
'clientid': 'testclient',
'userid': 'testuser',
'botid': 'bot',
'brainid': 'brain',
'conversation': {
'client_context': {
'clientid': 'testclient',
'userid': 'testuser',
'botid': 'bot',
'brainid': 'brain',
'depth': 0
},
'questions': [{
'srai':
False,
'sentences': [{
'words': ['Hello', 'world'],
'response': 'Hello matey',
'positivity': 0.0,
'subjectivity': 0.5
}],
'current_sentence_no':
-1,
'properties': {}
}],
'max_histories':
100,
'properties': {
'topic': '*'
}
}
}, doc)
conversation2 = Conversation.from_document(client_context, doc)
self.assertIsNotNone(conversation2)
self.assertEqual(conversation2.clientid, conversation.clientid)
self.assertEqual(conversation2.userid, conversation.userid)
self.assertEqual(conversation2.botid, conversation.botid)
self.assertEqual(conversation2.brainid, conversation.brainid)
def setUp(self):
self.client = TestClient()
def setUp(self):
self._test_client = TestClient()
ProgramyScheduler.schedulers.clear()
self.assertEqual(0, len(ProgramyScheduler.schedulers.keys()))
def setUp(self):
client = TestClient()
self._client_context = client.create_client_context("test1")
bot_config = BotConfiguration()
bot_config.conversations._max_histories = 3
self._bot = Bot(bot_config, client)
class SentimentScoreTests(unittest.TestCase):
def setUp(self):
self._client = TestClient()
config = BotConfiguration()
config.sentiment_analyser._classname = "programy.nlp.sentiment.textblob_sentiment.TextBlobSentimentAnalyser"
config.sentiment_analyser._scores = "programy.nlp.sentiment.scores.SentimentScores"
self.client_context = self._client.create_client_context("testuser")
self.client_context._bot = Bot(config=config, client=self._client)
self.client_context._bot.initiate_sentiment_analyser()
def test_sentence_scores(self):
sentence = Sentence(self.client_context, "")
sentence.calculate_sentinment_score(self.client_context)
self.assertEqual(0.0, sentence.positivity)
self.assertEqual(0.5, sentence.subjectivity)
sentence = Sentence(self.client_context, "I like you")
sentence.calculate_sentinment_score(self.client_context)
self.assertEqual(0.0, sentence.positivity)
self.assertEqual(0.0, sentence.subjectivity)
sentence = Sentence(self.client_context, "I hate you")
sentence.calculate_sentinment_score(self.client_context)
self.assertEqual(-0.8, sentence.positivity)
self.assertEqual(0.9, sentence.subjectivity)
sentence = Sentence(self.client_context, "I think like you")
sentence.calculate_sentinment_score(self.client_context)
self.assertEqual(0.0, sentence.positivity)
self.assertEqual(0.0, sentence.subjectivity)
def test_question_scores(self):
question = Question.create_from_text(self.client_context, "")
pos, sub = question.calculate_sentinment_score()
self.assertEqual(0.0, pos)
self.assertEqual(0.5, sub)
def test_conversation_scores(self):
conversation = Conversation(self.client_context)
pos, sub = conversation.calculate_sentiment_score()
self.assertEqual(0.0, pos)
self.assertEqual(0.5, sub)
question1 = Question.create_from_text(self.client_context,
"Hello There")
conversation.record_dialog(question1)
pos, sub = conversation.calculate_sentiment_score()
self.assertEqual(0.0, pos)
self.assertEqual(0.0, sub)
question2 = Question.create_from_text(self.client_context,
"I really like you")
conversation.record_dialog(question2)
pos, sub = conversation.calculate_sentiment_score()
self.assertEqual(0.1, pos)
self.assertEqual(0.1, sub)
question3 = Question.create_from_text(self.client_context,
"Do you like me")
conversation.record_dialog(question3)
pos, sub = conversation.calculate_sentiment_score()
self.assertEqual(0.06666666666666667, pos)
self.assertEqual(0.06666666666666667, sub)
def __init__(self, aiml_file, response_type=None, nlu_invalid=False):
self._aiml_file = aiml_file
self._response_type = response_type
self._nlu_invalid = nlu_invalid
TestClient.__init__(self)
def __init__(self, filename, save_bin=False, load_bin=False):
self._filename = filename
self._save_bin = save_bin
self._load_bin = load_bin
TestClient.__init__(self)
def setUp(self):
client = TestClient()
self._client_context = ClientContext(client, "unknown")
self._client_context.bot = Bot(BotConfiguration(), client)
self._client_context.bot.configuration.conversations._max_histories = 3
self._client_context.brain = self._client_context.bot.brain
class SentimentExtensionTests(unittest.TestCase):
def setUp(self):
self._client = TestClient()
config = BotConfiguration()
config.sentiment_analyser._classname = "programy.nlp.sentiment.textblob_sentiment.TextBlobSentimentAnalyser"
config.sentiment_analyser._scores = "programy.nlp.sentiment.scores.SentimentScores"
self.client_context = self._client.create_client_context("testuser")
self.client_context._bot = Bot(config=config, client=self._client)
self.client_context._bot.initiate_sentiment_analyser()
def test_invalid_command(self):
extension = SentimentExtension()
self.assertIsNotNone(extension)
result = extension.execute(self.client_context, "")
self.assertIsNotNone(result)
self.assertEqual("SENTIMENT INVALID COMMAND", result)
result = extension.execute(self.client_context, "XXX")
self.assertIsNotNone(result)
self.assertEqual("SENTIMENT INVALID COMMAND", result)
result = extension.execute(self.client_context, "SENTIMENT")
self.assertIsNotNone(result)
self.assertEqual("SENTIMENT INVALID COMMAND", result)
result = extension.execute(self.client_context, "SENTIMENT SCOREX")
self.assertIsNotNone(result)
self.assertEqual("SENTIMENT INVALID COMMAND", result)
result = extension.execute(self.client_context, "SENTIMENT FEELING")
self.assertIsNotNone(result)
self.assertEqual("SENTIMENT INVALID COMMAND", result)
result = extension.execute(self.client_context, "SENTIMENT FEELING X")
self.assertIsNotNone(result)
self.assertEqual("SENTIMENT INVALID COMMAND", result)
result = extension.execute(self.client_context, "SENTIMENT FEELING LAST")
self.assertIsNotNone(result)
self.assertEqual("SENTIMENT INVALID COMMAND", result)
result = extension.execute(self.client_context, "SENTIMENT FEELING LAST ONE")
self.assertIsNotNone(result)
self.assertEqual("SENTIMENT INVALID COMMAND", result)
result = extension.execute(self.client_context, "SENTIMENT FEELING OTHER ")
self.assertIsNotNone(result)
self.assertEqual("SENTIMENT INVALID COMMAND", result)
result = extension.execute(self.client_context, "SENTIMENT SCORES")
self.assertIsNotNone(result)
self.assertEqual("SENTIMENT INVALID COMMAND", result)
result = extension.execute(self.client_context, "SENTIMENT CURRENT")
self.assertIsNotNone(result)
self.assertEqual("SENTIMENT INVALID COMMAND", result)
def test_sentiment_enabled(self):
extension = SentimentExtension()
self.assertIsNotNone(extension)
result = extension.execute(self.client_context, "SENTIMENT ENABLED")
self.assertIsNotNone(result)
self.assertEqual("SENTIMENT ENABLED", result)
def test_sentiment_disabled(self):
extension = SentimentExtension()
self.assertIsNotNone(extension)
self.client_context.bot._sentiment_analyser = None
result = extension.execute(self.client_context, "SENTIMENT ENABLED")
self.assertIsNotNone(result)
self.assertEqual("SENTIMENT DISABLED", result)
def test_sentiment_feeling_current_numeric(self):
extension = SentimentExtension()
self.assertIsNotNone(extension)
conversation = self.client_context.bot.get_conversation(self.client_context)
self.assertIsNotNone(conversation)
conversation.properties['positivity'] = 0.00
conversation.properties['subjectivity'] = 0.00
result = extension.execute(self.client_context, "SENTIMENT CURRENT NUMERIC")
self.assertIsNotNone(result)
self.assertEqual("SENTIMENT SCORES POSITIVITY 0.0 SUBJECTIVITY 0.0", result)
def test_sentiment_feeling_current_text(self):
extension = SentimentExtension()
self.assertIsNotNone(extension)
conversation = self.client_context.bot.get_conversation(self.client_context)
self.assertIsNotNone(conversation)
conversation.properties['positivity'] = 0.00
conversation.properties['subjectivity'] = 0.00
result = extension.execute(self.client_context, "SENTIMENT CURRENT TEXT")
self.assertIsNotNone(result)
self.assertEqual("SENTIMENT SCORES POSITIVITY NEUTRAL SUBJECTIVITY COMPLETELY OBJECTIVE", result)
def test_sentiment_feeling_current_other(self):
extension = SentimentExtension()
self.assertIsNotNone(extension)
conversation = self.client_context.bot.get_conversation(self.client_context)
self.assertIsNotNone(conversation)
conversation.properties['positivity'] = 0.00
conversation.properties['subjectivity'] = 0.00
result = extension.execute(self.client_context, "SENTIMENT CURRENT OTHER")
self.assertIsNotNone(result)
self.assertEqual("SENTIMENT INVALID COMMAND", result)
def test_sentiment_score(self):
extension = SentimentExtension()
self.assertIsNotNone(extension)
result = extension.execute(self.client_context, "SENTIMENT SCORE I LIKE PEAS")
self.assertIsNotNone(result)
self.assertEqual("SENTIMENT SCORES POSITIVITY NEUTRAL SUBJECTIVITY COMPLETELY OBJECTIVE", result)
def test_sentiment_score_no_analyser(self):
extension = SentimentExtension()
self.assertIsNotNone(extension)
self.client_context.bot._sentiment_analyser = None
result = extension.execute(self.client_context, "SENTIMENT SCORE I LIKE PEAS")
self.assertIsNotNone(result)
self.assertEqual("SENTIMENT DISABLED", result)
def test_sentiment_feeling_last(self):
extension = SentimentExtension()
self.assertIsNotNone(extension)
# Need to create a conversation first
conversation = self.client_context.bot.get_conversation(self.client_context)
question1 = Question.create_from_text(self.client_context, "Hello", self.client_context.bot.sentence_splitter)
conversation.record_dialog(question1)
question2 = Question.create_from_text(self.client_context, "Hello", self.client_context.bot.sentence_splitter)
conversation.record_dialog(question2)
conversation.recalculate_sentiment_score(self.client_context)
result = extension.execute(self.client_context, "SENTIMENT FEELING LAST 1")
self.assertIsNotNone(result)
self.assertEqual("SENTIMENT FEELING NEUTRAL AND COMPLETELY OBJECTIVE", result)
def test_sentiment_feeling_last_10(self):
extension = SentimentExtension()
self.assertIsNotNone(extension)
# Need to create a conversation first
conversation = self.client_context.bot.get_conversation(self.client_context)
self.assertIsNotNone(conversation)
question = Question.create_from_text(self.client_context, "Hello", self.client_context.bot.sentence_splitter)
conversation.record_dialog(question)
result = extension.execute(self.client_context, "SENTIMENT FEELING LAST 10")
self.assertIsNotNone(result)
self.assertEqual("SENTIMENT FEELING NEUTRAL AND NEUTRAL", result)
def test_sentiment_feeling_overall(self):
extension = SentimentExtension()
self.assertIsNotNone(extension)
result = extension.execute(self.client_context, "SENTIMENT FEELING OVERALL")
self.assertIsNotNone(result)
self.assertEqual("SENTIMENT FEELING NEUTRAL AND NEUTRAL", result)
def test_sentiment_feeling_no_scores(self):
extension = SentimentExtension()
self.assertIsNotNone(extension)
self.client_context.bot._sentiment_scores = None
result = extension.execute(self.client_context, "SENTIMENT FEELING OVERALL")
self.assertIsNotNone(result)
self.assertEqual("SENTIMENT FEELING NEUTRAL AND NEUTRAL", result)
def test_sentiment_feeling_disabled(self):
extension = SentimentExtension()
self.assertIsNotNone(extension)
self.client_context.bot._sentiment_analyser = None
result = extension.execute(self.client_context, "SENTIMENT FEELING LAST 1")
self.assertIsNotNone(result)
self.assertEqual("SENTIMENT DISABLED", result)
def test_sentiment_score_disabled(self):
extension = SentimentExtension()
self.assertIsNotNone(extension)
self.client_context.bot._sentiment_scores = None
result = extension.execute(self.client_context, "SENTIMENT SCORE I LIKE YOU")
self.assertIsNotNone(result)
self.assertEqual("SENTIMENT SCORES POSITIVITY UNKNOWN SUBJECTIVITY UNKNOWN", result)
def test_sentiment_sentiment_score(self):
extension = SentimentExtension()
self.assertIsNotNone(extension)
result = extension.execute(self.client_context, "SENTIMENT SCORE I LIKE YOU")
self.assertIsNotNone(result)
self.assertEqual("SENTIMENT SCORES POSITIVITY NEUTRAL SUBJECTIVITY COMPLETELY OBJECTIVE", result)
def test_sentiment_sentiment_positivity(self):
extension = SentimentExtension()
self.assertIsNotNone(extension)
result = extension.execute(self.client_context, "SENTIMENT POSITIVITY 0.1")
self.assertIsNotNone(result)
self.assertEqual("NEUTRAL", result)
def test_sentiment_sentiment_positivity(self):
extension = SentimentExtension()
self.assertIsNotNone(extension)
result = extension.execute(self.client_context, "SENTIMENT SUBJECTIVITY 0.5")
self.assertIsNotNone(result)
self.assertEqual("NEUTRAL", result)
def setUp(self):
self._client = TestClient()
self.lat = 56.0720397
self.lng = -3.1752001
def setUp(self):
client = TestClient()
client.add_default_stores()
self._client_context = ClientContext(client, "testid")
self._client_context.bot = TestBot(BotConfiguration(), client)
self._client_context.brain = self._client_context.bot.brain
def test_bot_init_with_invalid_spellchecker(self):
bot_config = BotConfiguration()
bot_config.spelling._classname = "programy.spelling.checker.SpellingCheckerX"
client = TestClient()
bot = Bot(BotConfiguration(), client)
self.assertIsNotNone(bot)
def setUp(self):
storage_engine = MockStorageEngine()
client = TestClient()
self.context = client.create_client_context("TESTUSER")
self.context.brain._security._account_linker = BasicAccountLinkerService(storage_engine)
def __init__(self):
TestClient.__init__(self, debug=True)
def test_missing_keys(self):
client = TestClient()
with self.assertRaises(Exception):
_ = NewsAPI(client.license_keys)
def __init__(self):
self._learnf_path = os.path.dirname(__file__) + os.sep + 'learnf'
TestClient.__init__(self)
def __init__(self, aiml_type=None, category_file=None, set_store=True):
self._aiml_type = aiml_type
self._category_file = category_file
self._set_store = set_store
TestClient.__init__(self)
def setUp(self):
self.client = TestClient()
self.bot = Bot(config=BotConfiguration(), client=self.client)
def setUp(self):
client = TestClient()
client.add_license_keys_store()
self._client_context = client.create_client_context("testid")
def setUp(self):
client = TestClient()
self._client_context = client.create_client_context("testid")
class TranslateExtensionTests(unittest.TestCase):
def setUp(self):
self._client = TestClient()
config = BotConfiguration()
config._from_translator._classname = "programy.nlp.translate.textblob_translator.TextBlobTranslator"
self.client_context = self._client.create_client_context("testuser")
self.client_context._bot = Bot(config=config, client=self._client)
self.client_context._bot.initiate_translator()
def test_invalid_command(self):
extension = TranslateExtension()
self.assertIsNotNone(extension)
result = extension.execute(self.client_context, "XXX")
self.assertIsNotNone(result)
self.assertEqual("TRANSLATE INVALID COMMAND", result)
result = extension.execute(self.client_context, "TRANSLATE")
self.assertIsNotNone(result)
self.assertEqual("TRANSLATE INVALID COMMAND", result)
result = extension.execute(self.client_context, "TRANSLATE FROM")
self.assertIsNotNone(result)
self.assertEqual("TRANSLATE INVALID COMMAND", result)
result = extension.execute(self.client_context, "TRANSLATE FROM EN")
self.assertIsNotNone(result)
self.assertEqual("TRANSLATE INVALID COMMAND", result)
result = extension.execute(self.client_context, "TRANSLATE FROM EN TO")
self.assertIsNotNone(result)
self.assertEqual("TRANSLATE INVALID COMMAND", result)
result = extension.execute(self.client_context,
"TRANSLATE FROM EN TO FR")
self.assertIsNotNone(result)
self.assertEqual("TRANSLATE INVALID COMMAND", result)
result = extension.execute(self.client_context,
"OTHER FROM EN TO FR HELLO I LOVE YOU")
self.assertIsNotNone(result)
self.assertEqual("TRANSLATE INVALID COMMAND", result)
result = extension.execute(
self.client_context, "TRANSLATE OTHER EN TO FR HELLO I LOVE YOU")
self.assertIsNotNone(result)
self.assertEqual("TRANSLATE INVALID COMMAND", result)
result = extension.execute(
self.client_context, "TRANSLATE FROM EN OTHER FR HELLO I LOVE YOU")
self.assertIsNotNone(result)
self.assertEqual("TRANSLATE INVALID COMMAND", result)
def test_enabled(self):
extension = TranslateExtension()
self.assertIsNotNone(extension)
result = extension.execute(self.client_context, "TRANSLATE ENABLED")
self.assertEquals("TRANSLATE ENABLED", result)
self.client_context.bot._from_translator = None
result = extension.execute(self.client_context, "TRANSLATE ENABLED")
self.assertEquals("TRANSLATE DISABLED", result)
@unittest.skipIf(Externals.google_translate is False
or Externals.all_externals is False,
Externals.google_translate_disabled)
def test_translate(self):
extension = TranslateExtension()
self.assertIsNotNone(extension)
result = extension.execute(self.client_context, "TRANSLATE ENABLED")
self.assertIsNotNone(result)
self.assertEqual("TRANSLATE ENABLED", result)
result = extension.execute(self.client_context,
"TRANSLATE FROM EN TO FR HELLO I LOVE YOU")
self.assertIsNotNone(result)
self.assertEqual("TRANSLATED SALUT JE T'AIME", result)
def test_translate_disabled(self):
extension = TranslateExtension()
self.assertIsNotNone(extension)
self.client_context.bot._from_translator = None
result = extension.execute(self.client_context,
"TRANSLATE FROM EN TO FR HELLO I LOVE YOU")
self.assertIsNotNone(result)
self.assertEqual("TRANSLATE DISABLED", result)
