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_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 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_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_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_max_recursion(self):
client = MockClient("clientid")
bot_config = MockBotConfiguration(1, 1)
bot = MockBot("botid", bot_config)
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("question1")
context.check_max_recursion()
context.mark_question_start("question2")
with self.assertRaises(Exception):
context.check_max_recursion()
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_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_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))