def create_client_context(self, userid, load_variables=True):
client_context = ClientContext(self, userid)
client_context.bot = self._bot_factory.select_bot()
#TODO: here is where we need to load in variables
client_context.brain = client_context.bot.brain
if load_variables:
client_context.brain._load_variables(client_context)
return client_context
def test_init_with_bot_brain(self):
client = MockClient("clientid")
bot = MockBot("botid", None)
brain = MockBrain("brainid")
context = ClientContext(client, "testid")
context.bot = bot
context.brain = brain
self.assertEquals("[clientid] [testid] [botid] [brainid] [0]",
str(context))
def test_normalize(self):
processor = NormalizePreProcessor()
context = ClientContext(TestClient(), "testid")
context.bot = self.bot
context.brain = self.bot.brain
result = processor.process(context, "Hello")
self.assertIsNotNone(result)
self.assertEqual("Hello", result)
def test_authenticator_with_empty_config(self):
client_context = ClientContext(TestClient(), "console")
client_context.bot = Bot(BotConfiguration())
client_context.bot.configuration.conversations._max_histories = 3
client_context.brain = client_context.bot.brain
service = Authenticator(BrainSecurityConfiguration("authentication"))
self.assertIsNotNone(service)
self.assertIsNotNone(service.configuration)
self.assertIsNone(service.get_default_denied_srai())
self.assertFalse(service.authenticate(client_context))
def test_conversation(self):
client_context = ClientContext(TestClient(), "testid")
client_context.bot = Bot(BotConfiguration())
client_context.bot.configuration.conversations._max_histories = 3
client_context.brain = client_context.bot.brain
conversation = Conversation(client_context)
self.assertIsNotNone(conversation)
self.assertEqual(0, len(conversation._questions))
self.assertEqual(3, conversation._max_histories)
self.assertEqual(1, len(conversation._properties))
with self.assertRaises(Exception):
conversation.current_question()
with self.assertRaises(Exception):
conversation.previous_nth_question(0)
question1 = Question.create_from_text(
client_context.brain.nlp.tokenizer, "Hello There")
conversation.record_question(question1)
self.assertEqual(question1, conversation.current_question())
with self.assertRaises(Exception):
conversation.previous_nth_question(1)
question2 = Question.create_from_text(
client_context.brain.nlp.tokenizer, "Hello There Again")
conversation.record_question(question2)
self.assertEqual(question2, conversation.current_question())
self.assertEqual(question1, conversation.previous_nth_question(1))
with self.assertRaises(Exception):
conversation.previous_nth_question(3)
question3 = Question.create_from_text(
client_context.brain.nlp.tokenizer, "Hello There Again Again")
conversation.record_question(question3)
self.assertEqual(question3, conversation.current_question())
self.assertEqual(question2, conversation.previous_nth_question(1))
with self.assertRaises(Exception):
conversation.previous_nth_question(4)
# Max Histories for this test is 3
# Therefore we should see the first question, pop of the stack
question4 = Question.create_from_text(
client_context.brain.nlp.tokenizer,
"Hello There Again Again Again")
conversation.record_question(question4)
self.assertEqual(question4, conversation.current_question())
self.assertEqual(question3, conversation.previous_nth_question(1))
with self.assertRaises(Exception):
conversation.previous_nth_question(5)
def test_denormalize(self):
processor = DenormalizePostProcessor ()
context = ClientContext(TestClient(), "testid")
context.bot = self.bot
context.brain = self.bot.brain
result = processor.process(context, "Hello")
self.assertIsNotNone(result)
self.assertEqual("Hello", result)
result = processor.process(context, "hello dot com")
self.assertIsNotNone(result)
self.assertEqual("hello.com", result)
def test_get_initial_question_initial_question_srai_match(self):
bot_config = BotConfiguration()
self.assertIsNotNone(bot_config)
bot = MockBot(bot_config)
self.assertIsNotNone(bot)
client_context2 = ClientContext(TestClient(), "testid2")
client_context2._bot = bot
client_context2._brain = MockBrain(bot, bot.configuration.brain_config[0])
client_context2._brain._response = "Y DEFAULT RESPONSE"
self.assertEquals("Y DEFAULT RESPONSE", bot.get_initial_question(client_context2))
def setUp(self):
self._client_context = ClientContext(TestClient(), "testid")
self._client_context.bot = Bot(BotConfiguration())
self._client_context.brain = self._client_context.bot.brain
self._graph = self._client_context.bot.brain.aiml_parser.template_parser
self.test_sentence = Sentence(self._client_context.brain.nlp.tokenizer,
"test sentence")
test_node = PatternOneOrMoreWildCardNode("*")
self.test_sentence._matched_context = MatchContext(
max_search_depth=100,
max_search_timeout=-1,
tokenizer=self._client_context.brain.nlp.tokenizer)
self.test_sentence._matched_context._matched_nodes = [
Match(Match.WORD, test_node, 'one'),
Match(Match.WORD, test_node, 'two'),
Match(Match.WORD, test_node, 'three'),
Match(Match.WORD, test_node, 'four'),
Match(Match.WORD, test_node, 'five'),
Match(Match.WORD, test_node, 'six'),
Match(Match.TOPIC, test_node, '*'),
Match(Match.THAT, test_node, '*')
]
conversation = self._client_context.bot.get_conversation(
self._client_context)
question = Question.create_from_sentence(self.test_sentence)
conversation._questions.append(question)
def test_remove_html(self):
processor = RemoveHTMLPostProcessor()
context = ClientContext(TestClient(), "testid")
result = processor.process(context, "Hello World")
self.assertIsNotNone(result)
self.assertEqual("Hello World", result)
result = processor.process(context, "Hello <br/> World")
self.assertIsNotNone(result)
if os.name == 'posix':
self.assertEqual("Hello\nWorld", result)
elif os.name == 'nt':
self.assertEqual("Hello\r\nWorld", result)
else:
raise Exception("Unknown os [%s]" % os.name)
result = processor.process(context, "Hello <br /> World")
self.assertIsNotNone(result)
if os.name == 'posix':
self.assertEqual("Hello\nWorld", result)
elif os.name == 'nt':
self.assertEqual("Hello\r\nWorld", result)
else:
raise Exception("Unknown os [%s]" % os.name)
def test_merge_chinese(self):
processor = MergeChinesePostProcessor()
context = ClientContext(TestClient(), "testid")
result = processor.process(context, "Hello")
self.assertIsNotNone(result)
self.assertEqual("Hello", result)
result = processor.process(context, "Hello World")
self.assertIsNotNone(result)
self.assertEqual("Hello World", result)
result = processor.process(context, "你 好")
self.assertIsNotNone(result)
self.assertEqual("你好", result)
result = processor.process(context, "问 你 好")
self.assertIsNotNone(result)
self.assertEqual("问你好", result)
result = processor.process(context, "XX 你 好")
self.assertIsNotNone(result)
self.assertEqual("XX 你好", result)
result = processor.process(context, "XX 你 好 YY")
self.assertIsNotNone(result)
self.assertEqual("XX 你好 YY", result)
def test_format_numbers(self):
processor = FormatNumbersPostProcessor()
context = ClientContext(TestClient(), "testid")
result = processor.process(context, "23")
self.assertIsNotNone(result)
self.assertEqual("23", result)
result = processor.process(context, "23.45")
self.assertIsNotNone(result)
self.assertEqual("23.45", result)
result = processor.process(context, "23. 45")
self.assertIsNotNone(result)
self.assertEqual("23.45", result)
result = processor.process(context, "23 . 45")
self.assertIsNotNone(result)
self.assertEqual("23.45", result)
result = processor.process(context, "23,450")
self.assertIsNotNone(result)
self.assertEqual("23,450", result)
result = processor.process(context, "23, 450")
self.assertIsNotNone(result)
self.assertEqual("23,450", result)
result = processor.process(context, "23, 450, 000")
self.assertIsNotNone(result)
self.assertEqual("23,450,000", result)
def test_learn_multi_user(self):
client_context1 = ClientContext(TestClient(), "testid")
client_context1.bot = Bot(BotConfiguration())
client_context1.brain = client_context1.bot.brain
template = ET.fromstring("""
<template>
<learn>
<category>
<pattern>HELLO THERE ONE</pattern>
<template>HIYA ONE</template>
</category>
</learn>
</template>
""")
ast = self._graph.parse_template_expression(template)
learn_node = ast.children[0]
learn_node.resolve(client_context1)
response = client_context1.bot.ask_question(client_context1, "HELLO THERE ONE")
self.assertEqual("HIYA ONE", response)
client_context2 = ClientContext(TestClient(), "testid")
client_context2.bot = Bot(BotConfiguration())
client_context2.brain = client_context2.bot.brain
template = ET.fromstring("""
<template>
<learn>
<category>
<pattern>HELLO THERE TWO</pattern>
<template>HIYA TWO</template>
</category>
</learn>
</template>
""")
ast = self._graph.parse_template_expression(template)
learn_node = ast.children[0]
learn_node.resolve(client_context2)
response = client_context2.bot.ask_question(client_context2, "HELLO THERE TWO")
self.assertEqual("HIYA TWO", response)
# Now try and ask each others questions
response = client_context1.bot.ask_question(client_context1, "HELLO THERE TWO")
self.assertEqual("", response)
response = client_context2.bot.ask_question(client_context2, "HELLO THERE ONE")
self.assertEqual("", response)
def test_to_upper(self):
processor = ToUpperPreProcessor()
context = ClientContext(TestClient(), "testid")
result = processor.process(context, "Hello")
self.assertIsNotNone(result)
self.assertEqual("HELLO", result)
def test_demojize(self):
processor = EmojizePreProcessor()
context = ClientContext(TestClient(), "TestUser")
self.assertEqual("Python is 👍",
processor.process(context, 'Python is :thumbs_up:'))
self.assertEqual("Python is 👍",
processor.process(context, 'Python is :thumbsup:'))
def test_format_punctuation(self):
processor = FormatPunctuationProcessor()
context = ClientContext(TestClient(), "testid")
result = processor.process(context, 'Hello " World "')
self.assertIsNotNone(result)
self.assertEqual('Hello "World"', result)
result = processor.process(context, '"Hello World"')
self.assertIsNotNone(result)
self.assertEqual('"Hello World"', result)
result = processor.process(context, "' Hello World '")
self.assertIsNotNone(result)
self.assertEqual("'Hello World'", result)
result = processor.process(context, '" Hello World "')
self.assertIsNotNone(result)
self.assertEqual('"Hello World"', result)
result = processor.process(context, '"This" and "That"')
self.assertIsNotNone(result)
self.assertEqual('"This" and "That"', result)
result = processor.process(context, "Hello World .")
self.assertIsNotNone(result)
self.assertEqual("Hello World.", result)
result = processor.process(context, "Hello World ,")
self.assertIsNotNone(result)
self.assertEqual("Hello World,", result)
result = processor.process(context, "Hello World :")
self.assertIsNotNone(result)
self.assertEqual("Hello World:", result)
result = processor.process(context, "Hello World ;")
self.assertIsNotNone(result)
self.assertEqual("Hello World;", result)
result = processor.process(context, "Hello World ?")
self.assertIsNotNone(result)
self.assertEqual("Hello World?", result)
result = processor.process(context, "Hello World !")
self.assertIsNotNone(result)
self.assertEqual("Hello World!", result)
result = processor.process(context, "Hello World . This is it.")
self.assertIsNotNone(result)
self.assertEqual("Hello World. This is it.", result)
result = processor.process(context, "Hello World . 23.45.")
self.assertIsNotNone(result)
self.assertEqual("Hello World. 23.45.", result)
def test_get_default_response_default_response_srai_match(self):
bot_config = BotConfiguration()
self.assertIsNotNone(bot_config)
bot_config.default_response_srai = "YDEFAULTRESPONSE"
bot_config.default_response = "Default response!"
bot = MockBot(bot_config)
self.assertIsNotNone(bot)
client_context2 = ClientContext(TestClient(), "testid2")
client_context2._bot = bot
client_context2._brain = MockBrain(bot, bot.configuration.brain_config[0])
client_context2._brain._response = "Y DEFAULT RESPONSE"
response = bot.get_default_response(client_context2)
self.assertIsNotNone(response)
self.assertEquals("Y DEFAULT RESPONSE", response)
def test_learn_simple(self):
client_context1 = ClientContext(TestClient(), "testid")
client_context1.bot = Bot(BotConfiguration())
client_context1.brain = client_context1.bot.brain
template = ET.fromstring("""
<template>
<learn>
<category>
<pattern>HELLO <eval>WORLD</eval> <iset>THERE, NOW</iset></pattern>
<template>HIYA</template>
</category>
</learn>
</template>
""")
ast = self._graph.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertIsInstance(ast, TemplateNode)
self.assertIsNotNone(ast.children)
self.assertEqual(len(ast.children), 1)
learn_node = ast.children[0]
self.assertIsNotNone(learn_node)
self.assertIsInstance(learn_node, TemplateLearnNode)
self.assertEqual(1, len(learn_node.children))
self.assertIsInstance(learn_node.children[0], LearnCategory)
self.assertIsNotNone(learn_node.children[0].pattern)
self.assertIsInstance(learn_node.children[0].pattern, ET.Element)
self.assertIsNotNone(learn_node.children[0].topic)
self.assertIsInstance(learn_node.children[0].topic, ET.Element)
self.assertIsNotNone(learn_node.children[0].that)
self.assertIsInstance(learn_node.children[0].that, ET.Element)
self.assertIsNotNone(learn_node.children[0].template)
self.assertIsInstance(learn_node.children[0].template, TemplateNode)
resolved = learn_node.resolve(client_context1)
self.assertEqual(resolved, "")
response = client_context1.bot.ask_question(client_context1, "HELLO WORLD THERE")
self.assertEqual("HIYA", response)
def post_process(self, output_str):
context = ClientContext(TestClient(), "testid")
context.bot = Bot(config=BotConfiguration())
context.brain = context.bot.brain
context.bot.brain.denormals.process_splits([" dot com ", ".com"])
context.bot.brain.denormals.process_splits([" atsign ", "@"])
denormalize = DenormalizePostProcessor()
punctuation = FormatPunctuationProcessor()
numbers = FormatNumbersPostProcessor()
multispaces = RemoveMultiSpacePostProcessor()
emojize = EmojizePreProcessor()
output_str = denormalize.process(context, output_str)
output_str = punctuation.process(context, output_str)
output_str = numbers.process(context, output_str)
output_str = multispaces.process(context, output_str)
output_str = emojize.process(context, output_str)
return output_str
def test_remove_punctuation(self):
processor = RemovePunctuationPreProcessor()
context = ClientContext(TestClient(), "testid")
result = processor.process(context, "Hello!")
self.assertIsNotNone(result)
self.assertEqual("Hello", result)
result = processor.process(context, "$100")
self.assertIsNotNone(result)
self.assertEqual("$100", result)
def test_format_message_with_client_context(self):
client = TestClient()
bot_config = BotConfiguration()
bot_config._section_name = "testbot"
bot = Bot(bot_config, client)
brain_config = BrainConfiguration()
brain_config._section_name = "testbrain"
brain = Brain(bot, brain_config)
client_context = ClientContext(client, "testuser")
client_context._bot = bot
client_context._brain = brain
msg = YLogger.format_message(client_context, "Test Message")
self.assertIsNotNone(msg)
self.assertEquals(
"[testclient] [testbot] [testbrain] [testuser] - Test Message",
msg)
def test_pre_cleanup(self):
context = ClientContext(TestClient(), "testid")
context.bot = Bot(config=BotConfiguration())
context.brain = context.bot.brain
test_str = "This is my Location!"
punctuation_processor = RemovePunctuationPreProcessor()
test_str = punctuation_processor.process(context, test_str)
self.assertEqual("This is my Location", test_str)
normalize_processor = NormalizePreProcessor()
test_str = normalize_processor.process(context, test_str)
self.assertEqual("This is my Location", test_str)
toupper_processor = ToUpperPreProcessor()
test_str = toupper_processor.process(context, test_str)
self.assertEqual("THIS IS MY LOCATION", test_str)
demojize_processpr = DemojizePreProcessor()
test_str = demojize_processpr.process(context, test_str)
self.assertEqual(test_str, test_str)
def test_bot_with_conversation(self):
bot = Bot(BotConfiguration())
self.assertIsNotNone(bot)
self.assertFalse(bot.has_conversation(self._client_context))
response = bot.ask_question(self._client_context, "hello")
self.assertIsNotNone(response)
self.assertTrue(bot.has_conversation(self._client_context))
response = bot.ask_question(self._client_context, "hello")
self.assertIsNotNone(response)
self.assertTrue(bot.has_conversation(self._client_context))
client_context2 = ClientContext(TestClient(), "testid2")
client_context2._bot = bot
client_context2._brain = self._client_context.bot.brain
response = bot.ask_question(client_context2, "hello")
self.assertIsNotNone(response)
self.assertTrue(bot.has_conversation(client_context2))
def test_question(self):
client = MockClient("clientid")
bot = MockBot("botid", None)
brain = MockBrain("brainid")
context = ClientContext(client, "testid")
context.bot = bot
context.brain = brain
self.assertEquals("[clientid] [testid] [botid] [brainid] [0]",
str(context))
context.mark_question_start("question")
self.assertEquals("[clientid] [testid] [botid] [brainid] [1]",
str(context))
context.mark_question_start("question")
self.assertEquals("[clientid] [testid] [botid] [brainid] [2]",
str(context))
context.reset_question()
self.assertEquals("[clientid] [testid] [botid] [brainid] [0]",
str(context))
def test_service(self):
client_context = ClientContext(TestClient(), "unknown")
client_context.bot = Bot(BotConfiguration())
client_context.bot.configuration.conversations._max_histories = 3
client_context.brain = client_context.bot.brain
service = BasicPassThroughAuthenticationService(
BrainServiceConfiguration("authentication"))
self.assertIsNotNone(service)
self.assertIsNotNone(service.configuration)
client_context._userid = "console"
self.assertTrue(service.authenticate(client_context))
client_context._userid = "anyone"
self.assertTrue(service.authenticate(client_context))
def test_remove_multi_spaces(self):
processor = RemoveMultiSpacePostProcessor()
context = ClientContext(TestClient(), "testid")
result = processor.process(context, "Hello World")
self.assertIsNotNone(result)
self.assertEqual("Hello World", result)
result = processor.process(context, "Hello World ")
self.assertIsNotNone(result)
self.assertEqual("Hello World", result)
result = processor.process(context, " Hello World")
self.assertIsNotNone(result)
self.assertEqual("Hello World", result)
result = processor.process(context, " Hello World ")
self.assertIsNotNone(result)
self.assertEqual("Hello World", result)
def test_format_console(self):
processor = ConsoleFormatPostProcessor()
context = ClientContext(TestClient(), "testid")
result = processor.process(context, "Hello World")
self.assertIsNotNone(result)
self.assertEqual("Hello World", result)
result = processor.process(
context,
"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Rationis enim perfectio est virtus; Sed quid attinet de rebus tam apertis plura requirere?"
)
self.assertIsNotNone(result)
if os.name == 'posix':
self.assertEqual(
"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Rationis enim perfectio\nest virtus; Sed quid attinet de rebus tam apertis plura requirere?",
result)
elif os.name == 'nt':
self.assertEqual(
"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Rationis enim perfectio\r\nest virtus; Sed quid attinet de rebus tam apertis plura requirere?",
result)
else:
raise Exception("Unknown os [%s]" % os.name)
def test_ylogger(self):
client_context = ClientContext(TestClient(), "testid")
snapshot = YLoggerSnapshot()
self.assertIsNotNone(snapshot)
self.assertEquals(
str(snapshot),
"Critical(0) Fatal(0) Error(0) Exception(0) Warning(0) Info(0), Debug(0)"
)
YLogger.reset_snapshot()
YLogger.critical(client_context, "Test Message")
snapshot = YLogger.snapshot()
self.assertIsNotNone(snapshot)
self.assertEquals(
str(snapshot),
"Critical(1) Fatal(0) Error(0) Exception(0) Warning(0) Info(0), Debug(0)"
)
YLogger.fatal(client_context, "Test Message")
snapshot = YLogger.snapshot()
self.assertIsNotNone(snapshot)
self.assertEquals(
str(snapshot),
"Critical(1) Fatal(1) Error(0) Exception(0) Warning(0) Info(0), Debug(0)"
)
YLogger.error(client_context, "Test Message")
snapshot = YLogger.snapshot()
self.assertIsNotNone(snapshot)
self.assertEquals(
str(snapshot),
"Critical(1) Fatal(1) Error(1) Exception(0) Warning(0) Info(0), Debug(0)"
)
YLogger.exception(client_context, "Test Message",
Exception("Test error"))
snapshot = YLogger.snapshot()
self.assertIsNotNone(snapshot)
self.assertEquals(
str(snapshot),
"Critical(1) Fatal(1) Error(1) Exception(1) Warning(0) Info(0), Debug(0)"
)
YLogger.warning(client_context, "Test Message")
snapshot = YLogger.snapshot()
self.assertIsNotNone(snapshot)
self.assertEquals(
str(snapshot),
"Critical(1) Fatal(1) Error(1) Exception(1) Warning(1) Info(0), Debug(0)"
)
YLogger.info(client_context, "Test Message")
snapshot = YLogger.snapshot()
self.assertIsNotNone(snapshot)
self.assertEquals(
str(snapshot),
"Critical(1) Fatal(1) Error(1) Exception(1) Warning(1) Info(1), Debug(0)"
)
YLogger.debug(client_context, "Test Message")
snapshot = YLogger.snapshot()
self.assertIsNotNone(snapshot)
self.assertEquals(
str(snapshot),
"Critical(1) Fatal(1) Error(1) Exception(1) Warning(1) Info(1), Debug(1)"
)
def setUp(self):
self._client_context = ClientContext(TestClient(), "unknown")
self._client_context.bot = Bot(BotConfiguration())
self._client_context.bot.configuration.conversations._max_histories = 3
self._client_context.brain = self._client_context.bot.brain
def setUp(self):
self._client_context = ClientContext(TestClient(), "testid")
def test_demojize(self):
processor = DemojizePreProcessor()
context = ClientContext(TestClient(), "testid")
self.assertEqual("Python is :thumbs_up:", processor.process(context, 'Python is 👍'))