def test_persistence(self):
brain_config = BrainConfiguration()
test_brain = Brain(brain_config)
bot_config = BotConfiguration()
bot_config.conversations._type = "file"
bot_config.conversations._storage = BotConversationsFileStorageConfiguration(
"test")
bot_config.conversations._storage._dir = os.path.dirname(__file__)
bot_config.conversations._max_histories = 3
test_bot = Bot(test_brain, bot_config)
clientid = "test"
filename = bot_config.conversations._storage._dir + os.sep + clientid + ".convo"
if os.path.exists(filename):
os.remove(filename)
self.assertFalse(os.path.exists(filename))
conversation = test_bot.get_conversation(clientid)
conversation.properties['name'] = "fred"
test_bot.save_conversation(clientid)
self.assertTrue(os.path.exists(filename))
test_bot2 = Bot(test_brain, bot_config)
conversation2 = test_bot2.get_conversation(clientid)
self.assertIsNotNone(conversation2.property('name'))
self.assertEqual('fred', conversation2.property('name'))
self.assertTrue(os.path.exists(filename))
if os.path.exists(filename):
os.remove(filename)
self.assertFalse(os.path.exists(filename))
class TemplateGraphTestClient(unittest.TestCase):
def setUp(self):
self.parser = TemplateGraph(AIMLParser())
self.assertIsNotNone(self.parser)
self.test_brain = None
self.test_sentence = Sentence("test sentence")
test_node = PatternOneOrMoreWildCardNode("*")
self.test_sentence._matched_context = MatchContext()
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, '*')]
test_config = ClientConfiguration()
self.test_bot = Bot(Brain(BrainConfiguration()), config=test_config.bot_configuration)
self.test_clientid = "testid"
conversation = self.test_bot.get_conversation(self.test_clientid)
question = Question.create_from_sentence(self.test_sentence)
conversation._questions.append(question)
class TemplateGraphTestClient(unittest.TestCase):
def setUp(self):
self.parser = TemplateGraph(AIMLParser())
self.assertIsNotNone(self.parser)
self.test_brain = None
self.test_sentence = Sentence("test sentence")
test_node = PatternOneOrMoreWildCardNode("*")
self.test_sentence._matched_context = MatchContext()
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, '*')
]
test_config = ClientConfiguration()
self.test_bot = Bot(Brain(BrainConfiguration()),
config=test_config.bot_configuration)
self.test_clientid = "testid"
conversation = self.test_bot.get_conversation(self.test_clientid)
question = Question.create_from_sentence(self.test_sentence)
conversation._questions.append(question)
def test_bot_chat_loop(self):
test_brain = Brain(BrainConfiguration())
self.assertIsNotNone(test_brain)
self.assertIsInstance(test_brain, Brain)
bot = Bot(test_brain, BotConfiguration())
self.assertIsNotNone(bot)
self.assertIsInstance(bot, Bot)
bot.configuration._default_response = "Sorry, I don't have an answer for that right now"
response = bot.ask_question("testid", "hello")
self.assertIsNotNone(response)
self.assertEqual(response, "Sorry, I don't have an answer for that right now")
response = bot.ask_question("testid", "hello again")
self.assertIsNotNone(response)
self.assertEqual(response, "Sorry, I don't have an answer for that right now")
response = bot.ask_question("testid", "goodbye")
self.assertIsNotNone(response)
self.assertEqual(response, "Sorry, I don't have an answer for that right now")
conversation = bot.get_conversation("testid")
self.assertIsNotNone(conversation)
self.assertEqual(conversation.nth_question(3).sentence(0).text(), "hello")
self.assertEqual(conversation.nth_question(3).sentence(0).response, "Sorry, I don't have an answer for that right now")
self.assertEqual(conversation.nth_question(2).sentence(0).text(), "hello again")
self.assertEqual(conversation.nth_question(2).sentence(0).response, "Sorry, I don't have an answer for that right now")
self.assertEqual(conversation.nth_question(1).sentence(0).text(), "goodbye")
self.assertEqual(conversation.nth_question(1).sentence(0).response, "Sorry, I don't have an answer for that right now")
def test_bot_chat_loop(self):
test_brain = TestBrain(BrainConfiguration())
self.assertIsNotNone(test_brain)
self.assertIsInstance(test_brain, Brain)
bot = Bot(test_brain, BotConfiguration())
self.assertIsNotNone(bot)
self.assertIsInstance(bot, Bot)
test_brain.setresponse ("response1")
response = bot.ask_question("testid", "hello")
self.assertIsNotNone(response)
self.assertEqual(response, "response1")
test_brain.setresponse ("response2")
response = bot.ask_question("testid", "hello again")
self.assertIsNotNone(response)
self.assertEqual(response, "response2")
test_brain.setresponse("response3")
response = bot.ask_question("testid", "goodbye")
self.assertIsNotNone(response)
self.assertEqual(response, "response3")
conversation = bot.get_conversation("testid")
self.assertIsNotNone(conversation)
self.assertEqual(conversation.nth_question(3).sentence(0).text(), "hello")
self.assertEqual(conversation.nth_question(3).sentence(0).response, "response1")
self.assertEqual(conversation.nth_question(2).sentence(0).text(), "hello again")
self.assertEqual(conversation.nth_question(2).sentence(0).response, "response2")
self.assertEqual(conversation.nth_question(1).sentence(0).text(), "goodbye")
self.assertEqual(conversation.nth_question(1).sentence(0).response, "response3")
class TemplateGraphThinkTests(unittest.TestCase):
def setUp(self):
self.parser = TemplateGraph()
self.assertIsNotNone(self.parser)
self.test_brain = None
self.test_sentence = Sentence("test sentence")
self.test_sentence._stars = ['one', 'two', 'three', 'four', 'five', 'six']
self.test_sentence._thatstars = ["*"]
self.test_sentence._topicstars = ["*"]
test_config = ClientConfiguration()
self.test_bot = Bot(Brain(BrainConfiguration()), config=test_config.bot_configuration)
self.test_clientid = "testid"
conversation = self.test_bot.get_conversation(self.test_clientid)
question = Question.create_from_sentence(self.test_sentence)
conversation._questions.append(question)
def test_think(self):
template = ET.fromstring("""
<template>
<think>XYZ</think>
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertEqual(ast.resolve(None, None), "")
class TemplateGraphTopicTests(unittest.TestCase):
def setUp(self):
self.parser = TemplateGraph()
self.assertIsNotNone(self.parser)
self.test_brain = None
self.test_sentence = Sentence("test sentence")
self.test_sentence._stars = [
'one', 'two', 'three', 'four', 'five', 'six'
]
self.test_sentence._thatstars = ["*"]
self.test_sentence._topicstars = ["*"]
test_config = ClientConfiguration()
self.test_bot = Bot(Brain(BrainConfiguration()),
config=test_config.bot_configuration)
self.test_clientid = "testid"
conversation = self.test_bot.get_conversation(self.test_clientid)
question = Question.create_from_sentence(self.test_sentence)
conversation._questions.append(question)
def test_topicstar_index_as_attrib_full(self):
template = ET.fromstring("""
<template>
<topicstar index="1"></topicstar>
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertEqual(ast.children[0].to_string(), "TOPICSTAR Index=1")
self.assertEqual(ast.resolve(self.test_bot, self.test_clientid), "*")
def test_persistence(self):
client = TestClient()
client_context = client.create_client_context("testid")
bot_config = BotConfiguration()
bot_config.conversations._type = "file"
bot_config.conversations._storage = BotConversationsFileStorageConfiguration("test")
bot_config.conversations._storage._dir = os.path.dirname(__file__)
bot_config.conversations._max_histories = 3
client_context.bot = Bot(bot_config)
filename = bot_config.conversations._storage._dir + os.sep + client_context.userid + ".convo"
if os.path.exists(filename):
os.remove(filename)
self.assertFalse(os.path.exists(filename))
conversation = client_context.bot.get_conversation(client_context)
conversation.properties['name'] = "fred"
client_context.bot.save_conversation(client_context.userid)
self.assertTrue(os.path.exists(filename))
test_bot2 = Bot(bot_config)
conversation2 = test_bot2.get_conversation(client_context)
self.assertIsNotNone(conversation2.property('name'))
self.assertEqual('fred', conversation2.property('name'))
self.assertTrue(os.path.exists(filename))
if os.path.exists(filename):
os.remove(filename)
self.assertFalse(os.path.exists(filename))
def test_bot_chat_loop(self):
client = TestClient()
bot = Bot(BotConfiguration(), client)
self.assertIsNotNone(bot)
self.assertIsInstance(bot, Bot)
bot.configuration._default_response = "Sorry, I don't have an answer for that right now"
response = bot.ask_question(self._client_context, "hello")
self.assertIsNotNone(response)
self.assertEqual(response, "Sorry, I don't have an answer for that right now.")
response = bot.ask_question(self._client_context, "hello again")
self.assertIsNotNone(response)
self.assertEqual(response, "Sorry, I don't have an answer for that right now.")
response = bot.ask_question(self._client_context, "goodbye")
self.assertIsNotNone(response)
self.assertEqual(response, "Sorry, I don't have an answer for that right now.")
conversation = bot.get_conversation(self._client_context)
self.assertIsNotNone(conversation)
self.assertEqual(conversation.previous_nth_question(2).sentence(0).text(), "hello")
self.assertEqual(conversation.previous_nth_question(2).sentence(0).response, "Sorry, I don't have an answer for that right now")
self.assertEqual(conversation.previous_nth_question(1).sentence(0).text(), "hello again")
self.assertEqual(conversation.previous_nth_question(1).sentence(0).response, "Sorry, I don't have an answer for that right now")
self.assertEqual(conversation.previous_nth_question(0).sentence(0).text(), "goodbye")
self.assertEqual(conversation.previous_nth_question(0).sentence(0).response, "Sorry, I don't have an answer for that right now")
def test_bot_chat_loop(self):
bot = Bot(BotConfiguration())
self.assertIsNotNone(bot)
self.assertIsInstance(bot, Bot)
bot.configuration._default_response = "Sorry, I don't have an answer for that right now"
response = bot.ask_question(self._client_context, "hello")
self.assertIsNotNone(response)
self.assertEqual(response, "Sorry, I don't have an answer for that right now")
response = bot.ask_question(self._client_context, "hello again")
self.assertIsNotNone(response)
self.assertEqual(response, "Sorry, I don't have an answer for that right now")
response = bot.ask_question(self._client_context, "goodbye")
self.assertIsNotNone(response)
self.assertEqual(response, "Sorry, I don't have an answer for that right now")
conversation = bot.get_conversation(self._client_context)
self.assertIsNotNone(conversation)
self.assertEqual(conversation.previous_nth_question(2).sentence(0).text(), "hello")
self.assertEqual(conversation.previous_nth_question(2).sentence(0).response, "Sorry, I don't have an answer for that right now")
self.assertEqual(conversation.previous_nth_question(1).sentence(0).text(), "hello again")
self.assertEqual(conversation.previous_nth_question(1).sentence(0).response, "Sorry, I don't have an answer for that right now")
self.assertEqual(conversation.previous_nth_question(0).sentence(0).text(), "goodbye")
self.assertEqual(conversation.previous_nth_question(0).sentence(0).response, "Sorry, I don't have an answer for that right now")
def test_max_recusion(self):
client = TestClient()
bot = Bot(BotConfiguration(), client)
self.assertIsNotNone(bot)
bot.configuration._default_response = "Sorry, I don't have an answer for that right now"
bot.configuration._max_question_recursion = 0
bot.ask_question(self._client_context, "hello")
self.assertEqual("Maximum recursion limit [0] exceeded", bot.get_conversation(self._client_context)._exception)
def test_delete_valiables_srai_false(self):
client = TestClient()
bot = Bot(BotConfiguration(), client)
self.assertIsNotNone(bot)
self._client_context.deleteVariable = True
conversation = bot.get_conversation(self._client_context)
conversation.set_data_property("test", "value")
bot.ask_question(self._client_context, "hello", srai=False)
self.assertIsNone(conversation.data_property("test"))
class TemplateGraphSraixTests(unittest.TestCase):
def setUp(self):
self.parser = TemplateGraph()
self.assertIsNotNone(self.parser)
self.test_brain = None
self.test_sentence = Sentence("test sentence")
self.test_sentence._stars = [
'one', 'two', 'three', 'four', 'five', 'six'
]
self.test_sentence._thatstars = ["*"]
self.test_sentence._topicstars = ["*"]
test_config = ClientConfiguration()
self.test_bot = Bot(Brain(BrainConfiguration()),
config=test_config.bot_configuration)
self.test_clientid = "testid"
conversation = self.test_bot.get_conversation(self.test_clientid)
question = Question.create_from_sentence(self.test_sentence)
conversation._questions.append(question)
def test_sraix_template_params_as_attribs(self):
template = ET.fromstring("""
<template>
<sraix host="hostname" botid="testbot" hint="test query" apikey="1234567890" service="/ask">
Ask this question
</sraix>
</template>
""")
ast = self.parser.parse_template_expression(template)
def test_sraix_template_params_as_children(self):
template = ET.fromstring("""
<template>
<sraix>
<host>hostname</host>
<botid>testbot</botid>
<hint>test query</hint>
<apikey>1234567890</apikey>
<service>/ask</service>
Ask this question
</sraix>
</template>
""")
ast = self.parser.parse_template_expression(template)
class TemplateGraphBasicTests(unittest.TestCase):
def setUp(self):
self.parser = TemplateGraph()
self.assertIsNotNone(self.parser)
self.test_brain = None
self.test_sentence = Sentence("test sentence")
self.test_sentence._stars = [
'one', 'two', 'three', 'four', 'five', 'six'
]
self.test_sentence._thatstars = ["*"]
self.test_sentence._topicstars = ["*"]
test_config = ClientConfiguration()
self.test_bot = Bot(Brain(BrainConfiguration()),
config=test_config.bot_configuration)
self.test_clientid = "testid"
conversation = self.test_bot.get_conversation(self.test_clientid)
question = Question.create_from_sentence(self.test_sentence)
conversation._questions.append(question)
def test_template_no_content(self):
template = ET.fromstring("""
<template>
</template>
""")
with self.assertRaises(ParserException):
ast = self.parser.parse_template_expression(template)
def test_base_template(self):
template = ET.fromstring("""
<template>HELLO WORLD</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertEqual(2, len(ast.children))
self.assertIsInstance(ast.children[0], TemplateWordNode)
self.assertIsInstance(ast.children[1], TemplateWordNode)
class TemplateGraphSystemTests(unittest.TestCase):
def setUp(self):
self.parser = TemplateGraph()
self.assertIsNotNone(self.parser)
self.test_brain = None
self.test_sentence = Sentence("test sentence")
self.test_sentence._stars = ['one', 'two', 'three', 'four', 'five', 'six']
self.test_sentence._thatstars = ["*"]
self.test_sentence._topicstars = ["*"]
test_config = ClientConfiguration()
self.test_bot = Bot(Brain(BrainConfiguration()), config=test_config.bot_configuration)
self.test_clientid = "testid"
conversation = self.test_bot.get_conversation(self.test_clientid)
question = Question.create_from_sentence(self.test_sentence)
conversation._questions.append(question)
def test_system_timeout_as_attrib_full(self):
template = ET.fromstring("""
<template>
<system timeout="1000">echo "Hello World"</system>
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertEqual(ast.resolve(self.test_bot, self.test_clientid), "Hello World")
def test_size(self):
template = ET.fromstring("""
<template>
<size />
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertEqual(ast.resolve(self.test_bot, self.test_clientid), "0")
class TemplateGraphBasicRequestResponseTests(unittest.TestCase):
def setUp(self):
self.parser = TemplateGraph()
self.assertIsNotNone(self.parser)
self.test_brain = None
self.test_sentence = Sentence("test sentence")
self.test_sentence._stars = [
'one', 'two', 'three', 'four', 'five', 'six'
]
self.test_sentence._thatstars = ["*"]
self.test_sentence._topicstars = ["*"]
test_config = ClientConfiguration()
self.test_bot = Bot(Brain(BrainConfiguration()),
config=test_config.bot_configuration)
self.test_clientid = "testid"
conversation = self.test_bot.get_conversation(self.test_clientid)
question = Question.create_from_sentence(self.test_sentence)
conversation._questions.append(question)
def test_response_index_as_attrib_full(self):
template = ET.fromstring("""
<template>
<response index="9"></response>
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
def test_request_index_as_attrib_full(self):
template = ET.fromstring("""
<template>
<request index="8"></request>
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
class TemplateGraphStarTests(unittest.TestCase):
def setUp(self):
self.parser = TemplateGraph()
self.assertIsNotNone(self.parser)
self.test_brain = None
self.test_sentence = Sentence("test sentence")
self.test_sentence._stars = [
'one', 'two', 'three', 'four', 'five', 'six'
]
self.test_sentence._thatstars = ["*"]
self.test_sentence._topicstars = ["*"]
test_config = ClientConfiguration()
self.test_bot = Bot(Brain(BrainConfiguration()),
config=test_config.bot_configuration)
self.test_clientid = "testid"
conversation = self.test_bot.get_conversation(self.test_clientid)
question = Question.create_from_sentence(self.test_sentence)
conversation._questions.append(question)
def test_star_no_index_full(self):
template = ET.fromstring("""
<template>
<star></star>
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertIsNotNone(ast.children)
self.assertEqual(1, len(ast.children))
self.assertIsInstance(ast.children[0], TemplateStarNode)
self.assertEqual(ast.resolve(self.test_bot, self.test_clientid), "one")
def test_star_no_index_full_embedded(self):
template = ET.fromstring("""
<template>
Hello <star></star>
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertIsNotNone(ast.children)
self.assertEqual(2, len(ast.children))
self.assertIsInstance(ast.children[0], TemplateWordNode)
self.assertIsInstance(ast.children[1], TemplateStarNode)
self.assertEqual(ast.resolve(self.test_bot, self.test_clientid),
"Hello one")
def test_star_no_index_short(self):
template = ET.fromstring("""
<template>
<star />
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertIsNotNone(ast.children)
self.assertEqual(1, len(ast.children))
self.assertIsInstance(ast.children[0], TemplateStarNode)
self.assertEqual(ast.resolve(self.test_bot, self.test_clientid), "one")
def test_star_index_as_child(self):
template = ET.fromstring("""
<template>
<star><index>2</index></star>
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertIsNotNone(ast.children)
self.assertEqual(1, len(ast.children))
self.assertIsInstance(ast.children[0], TemplateStarNode)
self.assertEqual(ast.resolve(self.test_bot, self.test_clientid), "two")
def test_star_index_as_attrib_full(self):
template = ET.fromstring("""
<template>
<star index="3"></star>
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsInstance(ast, TemplateNode)
self.assertIsNotNone(ast)
self.assertIsNotNone(ast.children)
self.assertEqual(1, len(ast.children))
self.assertIsInstance(ast.children[0], TemplateStarNode)
self.assertEqual(ast.resolve(self.test_bot, self.test_clientid),
"three")
def test_star_index_as_attrib_short(self):
template = ET.fromstring("""
<template>
<star index="4" />
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertIsNotNone(ast.children)
self.assertEqual(1, len(ast.children))
self.assertIsInstance(ast.children[0], TemplateStarNode)
self.assertEqual(ast.resolve(self.test_bot, self.test_clientid),
"four")
class TemplateGraphMapTests(unittest.TestCase):
def setUp(self):
self.parser = TemplateGraph()
self.assertIsNotNone(self.parser)
self.test_brain = None
self.test_sentence = Sentence("test sentence")
self.test_sentence._stars = [
'one', 'two', 'three', 'four', 'five', 'six'
]
self.test_sentence._thatstars = ["*"]
self.test_sentence._topicstars = ["*"]
test_config = ClientConfiguration()
self.test_bot = Bot(Brain(BrainConfiguration()),
config=test_config.bot_configuration)
self.test_clientid = "testid"
conversation = self.test_bot.get_conversation(self.test_clientid)
question = Question.create_from_sentence(self.test_sentence)
conversation._questions.append(question)
def test_map_name_as_attrib(self):
template = ET.fromstring("""
<template>
<map name="somemap">sometext</map>
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertIsInstance(ast, TemplateNode)
self.assertIsNotNone(ast.children)
self.assertEqual(len(ast.children), 1)
set_node = ast.children[0]
self.assertIsNotNone(set_node)
self.assertIsInstance(set_node, TemplateMapNode)
self.assertIsNotNone(set_node.name)
self.assertIsInstance(set_node.name, TemplateNode)
self.assertEqual(set_node.name.resolve(None, None), "somemap")
self.assertEqual(len(set_node.children), 1)
self.assertEqual(set_node.children[0].resolve(None, None), "sometext")
def test_map_name_as_child(self):
template = ET.fromstring("""
<template>
<map><name>somemap</name>sometext</map>
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertIsInstance(ast, TemplateNode)
self.assertIsNotNone(ast.children)
self.assertEqual(len(ast.children), 1)
set_node = ast.children[0]
self.assertIsNotNone(set_node)
self.assertIsInstance(set_node, TemplateMapNode)
self.assertIsNotNone(set_node.name)
self.assertIsInstance(set_node.name, TemplateNode)
self.assertEqual(set_node.name.resolve(None, None), "somemap")
self.assertEqual(len(set_node.children), 1)
self.assertEqual(set_node.children[0].resolve(None, None), "sometext")
class TemplateGraphConditionTests(unittest.TestCase):
def setUp(self):
self.parser = TemplateGraph()
self.assertIsNotNone(self.parser)
self.test_brain = None
self.test_sentence = Sentence("test sentence")
self.test_sentence._stars = [
'one', 'two', 'three', 'four', 'five', 'six'
]
self.test_sentence._thatstars = ["*"]
self.test_sentence._topicstars = ["*"]
test_config = ClientConfiguration()
self.test_bot = Bot(Brain(BrainConfiguration()),
config=test_config.bot_configuration)
self.test_clientid = "testid"
conversation = self.test_bot.get_conversation(self.test_clientid)
question = Question.create_from_sentence(self.test_sentence)
conversation._questions.append(question)
def test_condition_template_no_attribs(self):
template = ET.fromstring("""
<template>
<condition>
</condition>
</template>
""")
with self.assertRaises(ParserException):
self.parser.parse_template_expression(template)
def test_condition_template_type1_variant1_name(self):
template = ET.fromstring("""
<template>
<condition name="aname" value="avalue">X <random><li>1</li><li>2</li></random> Y</condition>
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertIsInstance(ast, TemplateNode)
self.assertIsNotNone(ast.children)
template_node = ast.children[0]
self.assertIsNotNone(template_node)
self.assertIsInstance(template_node, TemplateType1ConditionNode)
self.assertFalse(template_node.local)
self.assertEqual(template_node.name, "aname")
self.assertEqual(template_node.value, "avalue")
self.assertEqual(len(template_node.children), 3)
def test_condition_template_type1_variant1_var(self):
template = ET.fromstring("""
<template>
<condition var="aname" value="avalue">X <random><li>1</li><li>2</li></random> Y</condition>
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertIsInstance(ast, TemplateNode)
self.assertIsNotNone(ast.children)
template_node = ast.children[0]
self.assertIsNotNone(template_node)
self.assertIsInstance(template_node, TemplateType1ConditionNode)
self.assertTrue(template_node.local)
self.assertEqual(template_node.name, "aname")
self.assertEqual(template_node.value, "avalue")
self.assertEqual(len(template_node.children), 3)
def test_condition_template_type1_variant2_name(self):
template = ET.fromstring("""
<template>
<condition name="aname"><value>avalue</value>X</condition>
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertIsInstance(ast, TemplateNode)
self.assertIsNotNone(ast.children)
template_node = ast.children[0]
self.assertIsNotNone(template_node)
self.assertIsInstance(template_node, TemplateType1ConditionNode)
self.assertFalse(template_node.local)
self.assertEqual(template_node.name, "aname")
self.assertEqual(template_node.value, "avalue")
self.assertEqual(len(template_node.children), 1)
def test_condition_template_type1_variant2_var(self):
template = ET.fromstring("""
<template>
<condition var="aname"><value>avalue</value>X</condition>
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertIsInstance(ast, TemplateNode)
self.assertIsNotNone(ast.children)
template_node = ast.children[0]
self.assertIsNotNone(template_node)
self.assertIsInstance(template_node, TemplateType1ConditionNode)
self.assertTrue(template_node.local)
self.assertEqual(template_node.name, "aname")
self.assertEqual(template_node.value, "avalue")
self.assertEqual(len(template_node.children), 1)
def test_condition_template_type1_variant3_name(self):
template = ET.fromstring("""
<template>
<condition value="avalue"><name>aname</name>X</condition>
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertIsInstance(ast, TemplateNode)
self.assertIsNotNone(ast.children)
template_node = ast.children[0]
self.assertIsNotNone(template_node)
self.assertIsInstance(template_node, TemplateType1ConditionNode)
self.assertFalse(template_node.local)
self.assertEqual(template_node.name, "aname")
self.assertEqual(template_node.value, "avalue")
self.assertEqual(len(template_node.children), 1)
def test_condition_template_type1_variant3_var(self):
template = ET.fromstring("""
<template>
<condition value="avalue"><var>aname</var>X</condition>
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertIsInstance(ast, TemplateNode)
self.assertIsNotNone(ast.children)
template_node = ast.children[0]
self.assertIsNotNone(template_node)
self.assertIsInstance(template_node, TemplateType1ConditionNode)
self.assertTrue(template_node.local)
self.assertEqual(template_node.name, "aname")
self.assertEqual(template_node.value, "avalue")
self.assertEqual(len(template_node.children), 1)
def test_condition_template_type1_variant4_name(self):
template = ET.fromstring("""
<template>
<condition><name>aname</name><value>avalue</value>X</condition>
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertIsInstance(ast, TemplateNode)
self.assertIsNotNone(ast.children)
template_node = ast.children[0]
self.assertIsNotNone(template_node)
self.assertIsInstance(template_node, TemplateType1ConditionNode)
self.assertFalse(template_node.local)
self.assertEqual(template_node.name, "aname")
self.assertEqual(template_node.value, "avalue")
self.assertEqual(len(template_node.children), 1)
def test_condition_template_type1_variant4_var(self):
template = ET.fromstring("""
<template>
<condition><var>aname</var><value>avalue</value>X</condition>
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertIsInstance(ast, TemplateNode)
self.assertIsNotNone(ast.children)
template_node = ast.children[0]
self.assertIsNotNone(template_node)
self.assertIsInstance(template_node, TemplateType1ConditionNode)
self.assertTrue(template_node.local)
self.assertEqual(template_node.name, "aname")
self.assertEqual(template_node.value, "avalue")
self.assertEqual(len(template_node.children), 1)
def test_condition_template_type2_variant1_name(self):
template = ET.fromstring("""
<template>
<condition>
<name>aname</name>
<li value="a">A</li>
<li value="b">B</li>
<li><value>c</value>C</li>
<li>D</li>
</condition>
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertIsInstance(ast, TemplateNode)
self.assertIsNotNone(ast.children)
template_node = ast.children[0]
self.assertIsNotNone(template_node)
self.assertIsInstance(template_node, TemplateType2ConditionNode)
self.assertFalse(template_node.local)
self.assertEqual(template_node.name, "aname")
self.assertEqual(len(template_node.children), 4)
node = template_node.children[0]
self.assertIsInstance(node, TemplateConditionListItemNode)
self.assertFalse(node.local)
self.assertFalse(node.loop)
self.assertIsNone(node.name)
self.assertEqual(node.value, "a")
self.assertFalse(node.is_default())
self.assertEqual(len(node.children), 1)
self.assertEqual(node.children[0].resolve(None, None), "A")
node = template_node.children[1]
self.assertIsInstance(node, TemplateConditionListItemNode)
self.assertFalse(node.local)
self.assertFalse(node.loop)
self.assertIsNone(node.name)
self.assertEqual(node.value, "b")
self.assertFalse(node.is_default())
self.assertEqual(len(node.children), 1)
self.assertEqual(node.children[0].resolve(None, None), "B")
node = template_node.children[2]
self.assertIsInstance(node, TemplateConditionListItemNode)
self.assertFalse(node.local)
self.assertFalse(node.loop)
self.assertIsNone(node.name)
self.assertEqual(node.value, "c")
self.assertFalse(node.is_default())
self.assertEqual(len(node.children), 1)
self.assertEqual(node.children[0].resolve(None, None), "C")
node = template_node.children[3]
self.assertIsInstance(node, TemplateConditionListItemNode)
self.assertFalse(node.local)
self.assertFalse(node.loop)
self.assertIsNone(node.name)
self.assertIsNone(node.value)
self.assertTrue(node.is_default())
self.assertEqual(len(node.children), 1)
self.assertEqual(node.children[0].resolve(None, None), "D")
def test_condition_template_type2_variant1_name_with_loop(self):
template = ET.fromstring("""
<template>
<condition>
<name>aname</name>
<li value="a">A <loop /></li>
<li value="b">B</li>
<li><value>c</value>C</li>
<li>D</li>
</condition>
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertIsInstance(ast, TemplateNode)
self.assertIsNotNone(ast.children)
template_node = ast.children[0]
self.assertIsNotNone(template_node)
self.assertIsInstance(template_node, TemplateType2ConditionNode)
self.assertFalse(template_node.local)
self.assertEqual(template_node.name, "aname")
self.assertEqual(len(template_node.children), 4)
node = template_node.children[0]
self.assertIsInstance(node, TemplateConditionListItemNode)
self.assertFalse(node.local)
self.assertTrue(node.loop)
self.assertIsNone(node.name)
self.assertEqual(node.value, "a")
self.assertFalse(node.is_default())
self.assertEqual(len(node.children), 1)
self.assertEqual(node.children[0].resolve(None, None), "A")
node = template_node.children[1]
self.assertIsInstance(node, TemplateConditionListItemNode)
self.assertFalse(node.local)
self.assertFalse(node.loop)
self.assertIsNone(node.name)
self.assertEqual(node.value, "b")
self.assertFalse(node.is_default())
self.assertEqual(len(node.children), 1)
self.assertEqual(node.children[0].resolve(None, None), "B")
node = template_node.children[2]
self.assertIsInstance(node, TemplateConditionListItemNode)
self.assertFalse(node.local)
self.assertFalse(node.loop)
self.assertIsNone(node.name)
self.assertEqual(node.value, "c")
self.assertFalse(node.is_default())
self.assertEqual(len(node.children), 1)
self.assertEqual(node.children[0].resolve(None, None), "C")
node = template_node.children[3]
self.assertIsInstance(node, TemplateConditionListItemNode)
self.assertFalse(node.local)
self.assertFalse(node.loop)
self.assertIsNone(node.name)
self.assertIsNone(node.value)
self.assertTrue(node.is_default())
self.assertEqual(len(node.children), 1)
self.assertEqual(node.children[0].resolve(None, None), "D")
def test_condition_template_type2_variant1_var(self):
template = ET.fromstring("""
<template>
<condition>
<var>aname</var>
<li value="a">A</li>
<li value="b">B</li>
<li><value>c</value>C</li>
<li>D</li>
</condition>
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertIsInstance(ast, TemplateNode)
self.assertIsNotNone(ast.children)
template_node = ast.children[0]
self.assertIsNotNone(template_node)
self.assertIsInstance(template_node, TemplateType2ConditionNode)
self.assertTrue(template_node.local)
self.assertEqual(template_node.name, "aname")
self.assertEqual(len(template_node.children), 4)
node = template_node.children[0]
self.assertIsInstance(node, TemplateConditionListItemNode)
self.assertTrue(node.local)
self.assertFalse(node.loop)
self.assertIsNone(node.name)
self.assertEqual(node.value, "a")
self.assertFalse(node.is_default())
self.assertEqual(len(node.children), 1)
self.assertEqual(node.children[0].resolve(None, None), "A")
node = template_node.children[1]
self.assertIsInstance(node, TemplateConditionListItemNode)
self.assertTrue(node.local)
self.assertFalse(node.loop)
self.assertIsNone(node.name)
self.assertEqual(node.value, "b")
self.assertFalse(node.is_default())
self.assertEqual(len(node.children), 1)
self.assertEqual(node.children[0].resolve(None, None), "B")
node = template_node.children[2]
self.assertIsInstance(node, TemplateConditionListItemNode)
self.assertTrue(node.local)
self.assertFalse(node.loop)
self.assertIsNone(node.name)
self.assertEqual(node.value, "c")
self.assertFalse(node.is_default())
self.assertEqual(len(node.children), 1)
self.assertEqual(node.children[0].resolve(None, None), "C")
node = template_node.children[3]
self.assertIsInstance(node, TemplateConditionListItemNode)
self.assertTrue(node.local)
self.assertFalse(node.loop)
self.assertIsNone(node.name)
self.assertIsNone(node.value)
self.assertTrue(node.is_default())
self.assertEqual(len(node.children), 1)
self.assertEqual(node.children[0].resolve(None, None), "D")
def test_condition_template_type2_variant2_name(self):
template = ET.fromstring("""
<template>
<condition name="aname">
<li value="a">A</li>
<li value="b">B</li>
<li><value>c</value>C</li>
<li>D</li>
</condition>
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertIsInstance(ast, TemplateNode)
self.assertIsNotNone(ast.children)
template_node = ast.children[0]
self.assertIsNotNone(template_node)
self.assertIsInstance(template_node, TemplateType2ConditionNode)
self.assertFalse(template_node.local)
self.assertEqual(template_node.name, "aname")
self.assertEqual(len(template_node.children), 4)
node = template_node.children[0]
self.assertIsInstance(node, TemplateConditionListItemNode)
self.assertFalse(node.local)
self.assertFalse(node.loop)
self.assertIsNone(node.name)
self.assertEqual(node.value, "a")
self.assertFalse(node.is_default())
self.assertEqual(len(node.children), 1)
self.assertEqual(node.children[0].resolve(None, None), "A")
node = template_node.children[1]
self.assertIsInstance(node, TemplateConditionListItemNode)
self.assertFalse(node.local)
self.assertFalse(node.loop)
self.assertIsNone(node.name)
self.assertEqual(node.value, "b")
self.assertFalse(node.is_default())
self.assertEqual(len(node.children), 1)
self.assertEqual(node.children[0].resolve(None, None), "B")
node = template_node.children[2]
self.assertIsInstance(node, TemplateConditionListItemNode)
self.assertFalse(node.local)
self.assertFalse(node.loop)
self.assertIsNone(node.name)
self.assertEqual(node.value, "c")
self.assertFalse(node.is_default())
self.assertEqual(len(node.children), 1)
self.assertEqual(node.children[0].resolve(None, None), "C")
node = template_node.children[3]
self.assertIsInstance(node, TemplateConditionListItemNode)
self.assertFalse(node.local)
self.assertFalse(node.loop)
self.assertIsNone(node.name)
self.assertIsNone(node.value)
self.assertTrue(node.is_default())
self.assertEqual(len(node.children), 1)
self.assertEqual(node.children[0].resolve(None, None), "D")
def test_condition_template_type2_variant2_var(self):
template = ET.fromstring("""
<template>
<condition var="aname">
<li value="a">A</li>
<li value="b">B</li>
<li><value>c</value>C</li>
<li>D</li>
</condition>
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertIsInstance(ast, TemplateNode)
self.assertIsNotNone(ast.children)
template_node = ast.children[0]
self.assertIsNotNone(template_node)
self.assertIsInstance(template_node, TemplateType2ConditionNode)
self.assertTrue(template_node.local)
self.assertEqual(template_node.name, "aname")
self.assertEqual(len(template_node.children), 4)
node = template_node.children[0]
self.assertIsInstance(node, TemplateConditionListItemNode)
self.assertTrue(node.local)
self.assertFalse(node.loop)
self.assertIsNone(node.name)
self.assertEqual(node.value, "a")
self.assertFalse(node.is_default())
self.assertEqual(len(node.children), 1)
self.assertEqual(node.children[0].resolve(None, None), "A")
node = template_node.children[1]
self.assertIsInstance(node, TemplateConditionListItemNode)
self.assertTrue(node.local)
self.assertFalse(node.loop)
self.assertIsNone(node.name)
self.assertEqual(node.value, "b")
self.assertFalse(node.is_default())
self.assertEqual(len(node.children), 1)
self.assertEqual(node.children[0].resolve(None, None), "B")
node = template_node.children[2]
self.assertIsInstance(node, TemplateConditionListItemNode)
self.assertTrue(node.local)
self.assertFalse(node.loop)
self.assertIsNone(node.name)
self.assertEqual(node.value, "c")
self.assertFalse(node.is_default())
self.assertEqual(len(node.children), 1)
self.assertEqual(node.children[0].resolve(None, None), "C")
node = template_node.children[3]
self.assertIsInstance(node, TemplateConditionListItemNode)
self.assertTrue(node.local)
self.assertFalse(node.loop)
self.assertIsNone(node.name)
self.assertIsNone(node.value)
self.assertTrue(node.is_default())
self.assertEqual(len(node.children), 1)
self.assertEqual(node.children[0].resolve(None, None), "D")
def test_condition_template_type3_variant1_name(self):
template = ET.fromstring("""
<template>
<condition>
<li name='name1' value="a">Val1</li>
<li value="b"><name>name2</name>Val2</li>
<li name="name3"><value>c</value>Val3</li>
<li><name>name4</name><value>d</value>Val4</li>
<li>Val5</li>
</condition>
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertIsInstance(ast, TemplateNode)
self.assertIsNotNone(ast.children)
template_node = ast.children[0]
self.assertIsNotNone(template_node)
self.assertIsInstance(template_node, TemplateType3ConditionNode)
self.assertEqual(len(template_node.children), 5)
node = template_node.children[0]
self.assertIsInstance(node, TemplateConditionListItemNode)
self.assertFalse(node.local)
self.assertFalse(node.loop)
self.assertIsNotNone(node.name)
self.assertEqual(node.name, "name1")
self.assertIsNotNone(node.value)
self.assertEqual(node.value, "a")
self.assertFalse(node.is_default())
self.assertEqual(len(node.children), 1)
self.assertEqual(node.children[0].resolve(None, None), "Val1")
node = template_node.children[1]
self.assertIsInstance(node, TemplateConditionListItemNode)
self.assertFalse(node.local)
self.assertFalse(node.loop)
self.assertIsNotNone(node.name)
self.assertEqual(node.name, "name2")
self.assertIsNotNone(node.value)
self.assertEqual(node.value, "b")
self.assertFalse(node.is_default())
self.assertEqual(len(node.children), 1)
self.assertEqual(node.children[0].resolve(None, None), "Val2")
node = template_node.children[2]
self.assertIsInstance(node, TemplateConditionListItemNode)
self.assertFalse(node.local)
self.assertFalse(node.loop)
self.assertIsNotNone(node.name)
self.assertEqual(node.name, "name3")
self.assertIsNotNone(node.value)
self.assertEqual(node.value, "c")
self.assertFalse(node.is_default())
self.assertEqual(len(node.children), 1)
self.assertEqual(node.children[0].resolve(None, None), "Val3")
node = template_node.children[3]
self.assertIsInstance(node, TemplateConditionListItemNode)
self.assertFalse(node.local)
self.assertFalse(node.loop)
self.assertEqual(node.name, "name4")
self.assertIsNotNone(node.value)
self.assertEqual(node.value, "d")
self.assertFalse(node.is_default())
self.assertEqual(len(node.children), 1)
self.assertEqual(node.children[0].resolve(None, None), "Val4")
node = template_node.children[4]
self.assertIsInstance(node, TemplateConditionListItemNode)
self.assertFalse(node.local)
self.assertFalse(node.loop)
self.assertIsNone(node.name)
self.assertIsNone(node.value)
self.assertTrue(node.is_default())
self.assertEqual(len(node.children), 1)
self.assertEqual(node.children[0].resolve(None, None), "Val5")
def test_condition_template_type3_variant1_name_with_loop(self):
template = ET.fromstring("""
<template>
<condition>
<li name='name1' value="a">Val1 <loop /></li>
<li value="b"><name>name2</name>Val2</li>
<li name="name3"><value>c</value>Val3</li>
<li><name>name4</name><value>d</value>Val4</li>
<li>Val5</li>
</condition>
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertIsInstance(ast, TemplateNode)
self.assertIsNotNone(ast.children)
template_node = ast.children[0]
self.assertIsNotNone(template_node)
self.assertIsInstance(template_node, TemplateType3ConditionNode)
self.assertEqual(len(template_node.children), 5)
node = template_node.children[0]
self.assertIsInstance(node, TemplateConditionListItemNode)
self.assertFalse(node.local)
self.assertTrue(node.loop)
self.assertIsNotNone(node.name)
self.assertEqual(node.name, "name1")
self.assertIsNotNone(node.value)
self.assertEqual(node.value, "a")
self.assertFalse(node.is_default())
self.assertEqual(len(node.children), 1)
self.assertEqual(node.children[0].resolve(None, None), "Val1")
node = template_node.children[1]
self.assertIsInstance(node, TemplateConditionListItemNode)
self.assertFalse(node.local)
self.assertFalse(node.loop)
self.assertIsNotNone(node.name)
self.assertEqual(node.name, "name2")
self.assertIsNotNone(node.value)
self.assertEqual(node.value, "b")
self.assertFalse(node.is_default())
self.assertEqual(len(node.children), 1)
self.assertEqual(node.children[0].resolve(None, None), "Val2")
node = template_node.children[2]
self.assertIsInstance(node, TemplateConditionListItemNode)
self.assertFalse(node.local)
self.assertFalse(node.loop)
self.assertIsNotNone(node.name)
self.assertEqual(node.name, "name3")
self.assertIsNotNone(node.value)
self.assertEqual(node.value, "c")
self.assertFalse(node.is_default())
self.assertEqual(len(node.children), 1)
self.assertEqual(node.children[0].resolve(None, None), "Val3")
node = template_node.children[3]
self.assertIsInstance(node, TemplateConditionListItemNode)
self.assertFalse(node.local)
self.assertFalse(node.loop)
self.assertEqual(node.name, "name4")
self.assertIsNotNone(node.value)
self.assertEqual(node.value, "d")
self.assertFalse(node.is_default())
self.assertEqual(len(node.children), 1)
self.assertEqual(node.children[0].resolve(None, None), "Val4")
node = template_node.children[4]
self.assertIsInstance(node, TemplateConditionListItemNode)
self.assertFalse(node.local)
self.assertFalse(node.loop)
self.assertIsNone(node.name)
self.assertIsNone(node.value)
self.assertTrue(node.is_default())
self.assertEqual(len(node.children), 1)
self.assertEqual(node.children[0].resolve(None, None), "Val5")
def test_condition_template_type3_variant1_var(self):
template = ET.fromstring("""
<template>
<condition>
<li var='name1' value="a">Val1</li>
<li value="b"><var>name2</var>Val2</li>
<li var="name3"><value>c</value>Val3</li>
<li><var>name4</var><value>d</value>Val4</li>
<li>Val5</li>
</condition>
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertIsInstance(ast, TemplateNode)
self.assertIsNotNone(ast.children)
template_node = ast.children[0]
self.assertIsNotNone(template_node)
self.assertIsInstance(template_node, TemplateType3ConditionNode)
self.assertEqual(len(template_node.children), 5)
node = template_node.children[0]
self.assertIsInstance(node, TemplateConditionListItemNode)
self.assertTrue(node.local)
self.assertFalse(node.loop)
self.assertIsNotNone(node.name)
self.assertEqual(node.name, "name1")
self.assertIsNotNone(node.value)
self.assertEqual(node.value, "a")
self.assertFalse(node.is_default())
self.assertEqual(len(node.children), 1)
self.assertEqual(node.children[0].resolve(None, None), "Val1")
node = template_node.children[1]
self.assertIsInstance(node, TemplateConditionListItemNode)
self.assertTrue(node.local)
self.assertFalse(node.loop)
self.assertIsNotNone(node.name)
self.assertEqual(node.name, "name2")
self.assertIsNotNone(node.value)
self.assertEqual(node.value, "b")
self.assertFalse(node.is_default())
self.assertEqual(len(node.children), 1)
self.assertEqual(node.children[0].resolve(None, None), "Val2")
node = template_node.children[2]
self.assertIsInstance(node, TemplateConditionListItemNode)
self.assertTrue(node.local)
self.assertFalse(node.loop)
self.assertIsNotNone(node.name)
self.assertEqual(node.name, "name3")
self.assertIsNotNone(node.value)
self.assertEqual(node.value, "c")
self.assertFalse(node.is_default())
self.assertEqual(len(node.children), 1)
self.assertEqual(node.children[0].resolve(None, None), "Val3")
node = template_node.children[3]
self.assertIsInstance(node, TemplateConditionListItemNode)
self.assertTrue(node.local)
self.assertFalse(node.loop)
self.assertIsNotNone(node.name)
self.assertEqual(node.name, "name4")
self.assertIsNotNone(node.value)
self.assertEqual(node.value, "d")
self.assertFalse(node.is_default())
self.assertEqual(len(node.children), 1)
self.assertEqual(node.children[0].resolve(None, None), "Val4")
node = template_node.children[4]
self.assertIsInstance(node, TemplateConditionListItemNode)
self.assertFalse(node.local)
self.assertFalse(node.loop)
self.assertIsNone(node.name)
self.assertIsNone(node.value)
self.assertTrue(node.is_default())
self.assertEqual(len(node.children), 1)
self.assertEqual(node.children[0].resolve(None, None), "Val5")
class TemplateGraphDateTimeTests(unittest.TestCase):
def setUp(self):
self.parser = TemplateGraph()
self.assertIsNotNone(self.parser)
self.test_brain = None
self.test_sentence = Sentence("test sentence")
self.test_sentence._stars = ['one', 'two', 'three', 'four', 'five', 'six']
self.test_sentence._thatstars = ["*"]
self.test_sentence._topicstars = ["*"]
test_config = ClientConfiguration()
self.test_bot = Bot(Brain(BrainConfiguration()), config=test_config.bot_configuration)
self.test_clientid = "testid"
conversation = self.test_bot.get_conversation(self.test_clientid)
question = Question.create_from_sentence(self.test_sentence)
conversation._questions.append(question)
def test_date_format_as_attrib(self):
template = ET.fromstring("""
<template>
<date format="%c" />
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertIsNotNone(ast.resolve(self.test_bot, self.test_clientid))
def test_date_format_as_attrib_full(self):
template = ET.fromstring("""
<template>
<date format="%c"></date>
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertIsNotNone(ast.resolve(self.test_bot, self.test_clientid))
def test_date_format_as_attrib_default(self):
template = ET.fromstring("""
<template>
<date/>
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertIsNotNone(ast.resolve(self.test_bot, self.test_clientid))
def test_interval_values_as_attribs(self):
template = ET.fromstring("""
<template>
<interval>
<format>%c</format>
<style>days</style>
<from>Wed Oct 5 16:35:11 2016</from>
<to>Fri Oct 7 16:35:11 2016</to>
</interval>
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertEqual(ast.resolve(self.test_bot, self.test_clientid), "2")
class TemplateGraphLearnTests(unittest.TestCase):
def setUp(self):
self.parser = TemplateGraph(AIMLParser())
self.assertIsNotNone(self.parser)
self.test_brain = None
self.test_sentence = Sentence("test sentence")
self.test_sentence._stars = [
'one', 'two', 'three', 'four', 'five', 'six'
]
self.test_sentence._thatstars = ["*"]
self.test_sentence._topicstars = ["*"]
test_config = ClientConfiguration()
self.test_bot = Bot(Brain(BrainConfiguration()),
config=test_config.bot_configuration)
self.test_clientid = "testid"
conversation = self.test_bot.get_conversation(self.test_clientid)
question = Question.create_from_sentence(self.test_sentence)
conversation._questions.append(question)
def test_eval_simple(self):
template = ET.fromstring("""
<template>
<eval>sometext</eval>
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertIsInstance(ast, TemplateNode)
self.assertIsNotNone(ast.children)
self.assertEqual(len(ast.children), 1)
eval_node = ast.children[0]
self.assertIsNotNone(eval_node)
self.assertIsInstance(eval_node, TemplateEvalNode)
self.assertIsNotNone(eval_node.children)
self.assertEqual(len(eval_node.children), 1)
self.assertIsInstance(eval_node.children[0], TemplateWordNode)
self.assertEqual(eval_node.resolve(self.test_bot, self.test_clientid),
"sometext")
def test_learn_simple(self):
template = ET.fromstring("""
<template>
<learn>
<category>
<pattern>HELLO <eval>WORLD</eval> THERE</pattern>
<template>HIYA</template>
</category>
</learn>
</template>
""")
ast = self.parser.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.assertIsNotNone(learn_node._pattern)
self.assertIsInstance(learn_node._pattern, ET.Element)
self.assertIsNotNone(learn_node._topic)
self.assertIsInstance(learn_node._topic, ET.Element)
self.assertIsNotNone(learn_node._that)
self.assertIsInstance(learn_node._that, ET.Element)
self.assertIsNotNone(learn_node._template)
self.assertIsInstance(learn_node._template, TemplateNode)
resolved = learn_node.resolve(self.test_bot, self.test_clientid)
self.assertEqual(resolved, "")
response = self.test_bot.ask_question(self.test_clientid,
"HELLO WORLD THERE")
self.assertEqual("HIYA", response)
def test_learnf_simple(self):
template = ET.fromstring("""
<template>
<learnf>
<category>
<pattern>HELLO <eval>WORLD</eval> THERE</pattern>
<template>HIYA</template>
</category>
</learnf>
</template>
""")
self.test_bot.brain._configuration._aiml_files = BrainFileConfiguration(
"/tmp", ".aiml", False)
ast = self.parser.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.assertIsNotNone(learn_node._pattern)
self.assertIsInstance(learn_node._pattern, ET.Element)
self.assertIsNotNone(learn_node._topic)
self.assertIsInstance(learn_node._topic, ET.Element)
self.assertIsNotNone(learn_node._that)
self.assertIsInstance(learn_node._that, ET.Element)
self.assertIsNotNone(learn_node._template)
self.assertIsInstance(learn_node._template, TemplateNode)
resolved = learn_node.resolve(self.test_bot, self.test_clientid)
self.assertEqual(resolved, "")
response = self.test_bot.ask_question(self.test_clientid,
"HELLO WORLD THERE")
self.assertEqual("HIYA", response)
class TemplateGraphGetTests(unittest.TestCase):
def setUp(self):
self.parser = TemplateGraph()
self.assertIsNotNone(self.parser)
self.test_brain = None
self.test_sentence = Sentence("test sentence")
self.test_sentence._stars = ['one', 'two', 'three', 'four', 'five', 'six']
self.test_sentence._thatstars = ["*"]
self.test_sentence._topicstars = ["*"]
test_config = ClientConfiguration()
self.test_bot = Bot(Brain(BrainConfiguration()), config=test_config.bot_configuration)
self.test_clientid = "testid"
conversation = self.test_bot.get_conversation(self.test_clientid)
question = Question.create_from_sentence(self.test_sentence)
conversation._questions.append(question)
def test_get_template_predicate_as_attrib(self):
template = ET.fromstring("""
<template>
<get name="somepred" />
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertIsInstance(ast, TemplateNode)
self.assertIsNotNone(ast.children)
self.assertEqual(len(ast.children), 1)
get_node = ast.children[0]
self.assertIsNotNone(get_node)
self.assertIsInstance(get_node, TemplateGetNode)
self.assertIsNotNone(get_node.name)
self.assertIsInstance(get_node.name, TemplateNode)
self.assertEqual(get_node.name.resolve(None, None), "somepred")
self.assertFalse(get_node.local)
def test_get_template_predicate_as_attrib_mixed(self):
template = ET.fromstring("""
<template>
Hello <get name="somepred" /> how are you
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertIsInstance(ast, TemplateNode)
self.assertIsNotNone(ast.children)
self.assertEqual(len(ast.children), 5)
get_node = ast.children[1]
self.assertIsNotNone(get_node)
self.assertIsInstance(get_node, TemplateGetNode)
self.assertIsNotNone(get_node.name)
self.assertIsInstance(get_node.name, TemplateNode)
self.assertEqual(get_node.name.resolve(None, None), "somepred")
self.assertFalse(get_node.local)
def test_get_template_var_as_attrib(self):
template = ET.fromstring("""
<template>
<get var="somevar" />
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertIsInstance(ast, TemplateNode)
self.assertIsNotNone(ast.children)
self.assertEqual(len(ast.children), 1)
get_node = ast.children[0]
self.assertIsNotNone(get_node)
self.assertIsInstance(get_node, TemplateGetNode)
self.assertIsNotNone(get_node.name)
self.assertIsInstance(get_node.name, TemplateNode)
self.assertEqual(get_node.name.resolve(None, None), "somevar")
self.assertTrue(get_node.local)
def test_get_template_predicate_as_child(self):
template = ET.fromstring("""
<template>
<get><name>somepred as text</name></get>
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertIsInstance(ast, TemplateNode)
self.assertIsNotNone(ast.children)
self.assertEqual(len(ast.children), 1)
get_node = ast.children[0]
self.assertIsNotNone(get_node)
self.assertIsInstance(get_node, TemplateGetNode)
self.assertIsNotNone(get_node.name)
self.assertIsInstance(get_node.name, TemplateNode)
self.assertEqual(get_node.name.resolve(None, None), "somepred as text")
self.assertFalse(get_node.local)
def test_get_template_local_as_child(self):
template = ET.fromstring("""
<template>
<get><var>somevar</var></get>
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertIsInstance(ast, TemplateNode)
self.assertIsNotNone(ast.children)
self.assertEqual(len(ast.children), 1)
get_node = ast.children[0]
self.assertIsNotNone(get_node)
self.assertIsInstance(get_node, TemplateGetNode)
self.assertIsNotNone(get_node.name)
self.assertIsInstance(get_node.name, TemplateNode)
self.assertEqual(get_node.name.resolve(None, None), "somevar")
self.assertTrue(get_node.local)
class TemplateGraphTransformsTests(unittest.TestCase):
def setUp(self):
self.parser = TemplateGraph()
self.assertIsNotNone(self.parser)
self.test_brain = None
self.test_sentence = Sentence("test sentence")
self.test_sentence._stars = [
'one', 'two', 'three', 'four', 'five', 'six'
]
self.test_sentence._thatstars = ["*"]
self.test_sentence._topicstars = ["*"]
test_config = ClientConfiguration()
self.test_bot = Bot(Brain(BrainConfiguration()),
config=test_config.bot_configuration)
self.test_clientid = "testid"
conversation = self.test_bot.get_conversation(self.test_clientid)
question = Question.create_from_sentence(self.test_sentence)
conversation._questions.append(question)
def test_lowercase(self):
template = ET.fromstring("""
<template>
<lowercase>This is a Sentence</lowercase>
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertEqual(ast.resolve(None, None), "this is a sentence")
def test_uppercase(self):
template = ET.fromstring("""
<template>
<uppercase>This is a Sentence</uppercase>
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertEqual(ast.resolve(None, None), "THIS IS A SENTENCE")
def test_formal(self):
template = ET.fromstring("""
<template>
<formal>This is a Sentence</formal>
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertEqual(ast.resolve(None, None), "This Is A Sentence")
def test_sentence(self):
template = ET.fromstring("""
<template>
<sentence>This is a Sentence</sentence>
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertEqual(ast.resolve(None, None), "This is a sentence")
def test_normalize(self):
template = ET.fromstring("""
<template>
<normalize>XYZ</normalize>
</template>
""")
ast = self.parser.parse_template_expression(template)
def test_denormalize(self):
template = ET.fromstring("""
<template>
<denormalize>XYZ</denormalize>
</template>
""")
ast = self.parser.parse_template_expression(template)
def test_person(self):
template = ET.fromstring("""
<template>
<person>XYZ</person>
</template>
""")
ast = self.parser.parse_template_expression(template)
def test_person2(self):
template = ET.fromstring("""
<template>
<person2>XYZ</person2>
</template>
""")
ast = self.parser.parse_template_expression(template)
def test_gender(self):
template = ET.fromstring("""
<template>
<gender>XYZ</gender>
</template>
""")
ast = self.parser.parse_template_expression(template)
def test_sr(self):
template = ET.fromstring("""
<template>
<sr>XYZ</sr>
</template>
""")
ast = self.parser.parse_template_expression(template)
def test_id(self):
template = ET.fromstring("""
<template>
<id />
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertEqual(ast.resolve(None, "clientid"), "clientid")
def test_vocabulary(self):
template = ET.fromstring("""
<template>
<vocabulary>XYZ</vocabulary>
</template>
""")
ast = self.parser.parse_template_expression(template)
def test_program(self):
template = ET.fromstring("""
<template>
<program>XYZ</program>
</template>
""")
ast = self.parser.parse_template_expression(template)
def test_explode(self):
template = ET.fromstring("""
<template>
<explode>XYZ</explode>
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertEqual(ast.resolve(None, None), "X Y Z")
def test_implode(self):
template = ET.fromstring("""
<template>
<implode>X Y Z</implode>
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertEqual(ast.resolve(None, None), "XYZ")
class TemplateGraphSraiTests(unittest.TestCase):
def setUp(self):
self.parser = TemplateGraph()
self.assertIsNotNone(self.parser)
self.test_brain = None
self.test_sentence = Sentence("test sentence")
self.test_sentence._stars = [
'one', 'two', 'three', 'four', 'five', 'six'
]
self.test_sentence._thatstars = ["*"]
self.test_sentence._topicstars = ["*"]
test_config = ClientConfiguration()
self.test_bot = Bot(Brain(BrainConfiguration()),
config=test_config.bot_configuration)
self.test_clientid = "testid"
conversation = self.test_bot.get_conversation(self.test_clientid)
question = Question.create_from_sentence(self.test_sentence)
conversation._questions.append(question)
def test_srai_template_simple(self):
template = ET.fromstring("""
<template>
<srai>
SRAI this text
</srai>
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertIsInstance(ast, TemplateNode)
self.assertIsNotNone(ast.children)
self.assertIsNotNone(ast.children[0])
self.assertIsInstance(ast.children[0], TemplateSRAINode)
self.assertIsNotNone(ast.children[0].children)
self.assertEqual(3, len(ast.children[0].children))
self.assertIsInstance(ast.children[0].children[0], TemplateWordNode)
self.assertIsInstance(ast.children[0].children[1], TemplateWordNode)
self.assertIsInstance(ast.children[0].children[2], TemplateWordNode)
def test_srai_template_nested(self):
template = ET.fromstring("""
<template>
<srai>
SRAI This and <srai>SRAI that</srai>
</srai>
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertIsInstance(ast, TemplateNode)
self.assertIsNotNone(ast.children)
self.assertIsNotNone(ast.children[0])
self.assertIsInstance(ast.children[0], TemplateSRAINode)
self.assertIsNotNone(ast.children[0].children)
self.assertEqual(4, len(ast.children[0].children))
self.assertIsInstance(ast.children[0].children[0], TemplateWordNode)
self.assertIsInstance(ast.children[0].children[1], TemplateWordNode)
self.assertIsInstance(ast.children[0].children[2], TemplateWordNode)
self.assertIsInstance(ast.children[0].children[3], TemplateSRAINode)
self.assertIsNotNone(ast.children[0].children[3].children)
self.assertEqual(2, len(ast.children[0].children[3].children))
self.assertIsInstance(ast.children[0].children[3].children[0],
TemplateWordNode)
self.assertIsInstance(ast.children[0].children[3].children[1],
TemplateWordNode)
class TemplateGraphRandomTests(unittest.TestCase):
def setUp(self):
self.parser = TemplateGraph()
self.assertIsNotNone(self.parser)
self.test_brain = None
self.test_sentence = Sentence("test sentence")
self.test_sentence._stars = ['one', 'two', 'three', 'four', 'five', 'six']
self.test_sentence._thatstars = ["*"]
self.test_sentence._topicstars = ["*"]
test_config = ClientConfiguration()
self.test_bot = Bot(Brain(BrainConfiguration()), config=test_config.bot_configuration)
self.test_clientid = "testid"
conversation = self.test_bot.get_conversation(self.test_clientid)
question = Question.create_from_sentence(self.test_sentence)
conversation._questions.append(question)
def test_random_template_no_li(self):
template = ET.fromstring("""
<template>
<random>
</random>
</template>
""")
with self.assertRaises(ParserException):
ast = self.parser.parse_template_expression(template)
def test_random_template(self):
template = ET.fromstring("""
<template>
<random>
<li>1</li>
<li>2</li>
<li>3</li>
</random>
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertIsNotNone(ast)
self.assertIsInstance(ast, TemplateNode)
self.assertIsNotNone(ast.children)
self.assertIsNotNone(ast.children[0])
self.assertIsInstance(ast.children[0], TemplateRandomNode)
self.assertEqual(3, len(ast.children[0].children))
self.assertIsInstance(ast.children[0].children[0], TemplateNode)
self.assertIsInstance(ast.children[0].children[1], TemplateNode)
self.assertIsInstance(ast.children[0].children[2], TemplateNode)
selection = ast.children[0].resolve(self.test_bot, self.test_clientid)
self.assertIsNotNone(selection)
self.assertIn(selection, ['1', '2', '3'])
def test_random_nested_template(self):
template = ET.fromstring("""
<template>
<random>
<li>
<random>
<li>Say something</li>
<li>Say the other</li>
</random>
</li>
<li>
<random>
<li>Hello world!</li>
<li>Goodbye cruel world</li>
</random>
</li>
</random>
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertIsInstance(ast, TemplateNode)
self.assertIsNotNone(ast.children)
self.assertIsNotNone(ast.children[0])
self.assertIsInstance(ast.children[0], TemplateRandomNode)
self.assertEqual(2, len(ast.children[0].children))
self.assertIsInstance(ast.children[0].children[0], TemplateNode)
self.assertEqual(1, len(ast.children[0].children[0].children))
self.assertIsInstance(ast.children[0].children[0].children[0], TemplateRandomNode)
self.assertEqual(2, len(ast.children[0].children[0].children[0].children))
self.assertIsInstance(ast.children[0].children[1], TemplateNode)
self.assertEqual(1, len(ast.children[0].children[1].children))
self.assertIsInstance(ast.children[0].children[1].children[0], TemplateRandomNode)
self.assertEqual(2, len(ast.children[0].children[1].children[0].children))
selection = ast.children[0].resolve(self.test_bot, self.test_clientid)
self.assertIsNotNone(selection)
self.assertIn(selection, ['Say something', 'Say the other', 'Hello world!', 'Goodbye cruel world'])
class TemplateGraphSetTests(unittest.TestCase):
def setUp(self):
self.parser = TemplateGraph()
self.assertIsNotNone(self.parser)
self.test_brain = None
self.test_sentence = Sentence("test sentence")
self.test_sentence._stars = ['one', 'two', 'three', 'four', 'five', 'six']
self.test_sentence._thatstars = ["*"]
self.test_sentence._topicstars = ["*"]
test_config = ClientConfiguration()
self.test_bot = Bot(Brain(BrainConfiguration()), config=test_config.bot_configuration)
self.test_clientid = "testid"
conversation = self.test_bot.get_conversation(self.test_clientid)
question = Question.create_from_sentence(self.test_sentence)
conversation._questions.append(question)
def test_set_template_predicate_as_attrib(self):
template = ET.fromstring("""
<template>
<set name="somepred">Value1</set>
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertIsInstance(ast, TemplateNode)
self.assertIsNotNone(ast.children)
self.assertEqual(len(ast.children), 1)
set_node = ast.children[0]
self.assertIsNotNone(set_node)
self.assertIsInstance(set_node, TemplateSetNode)
self.assertIsNotNone(set_node.name)
self.assertIsInstance(set_node.name, TemplateNode)
self.assertEqual(set_node.name.resolve(None, None), "somepred")
self.assertFalse(set_node.local)
self.assertEqual(len(set_node.children), 1)
self.assertEqual(set_node.children[0].resolve(None, None), "Value1")
def test_set_template_multi_word_predicate_as_attrib(self):
template = ET.fromstring("""
<template>
<set name="somepred other">Value1</set>
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertIsInstance(ast, TemplateNode)
self.assertIsNotNone(ast.children)
self.assertEqual(len(ast.children), 1)
set_node = ast.children[0]
self.assertIsNotNone(set_node)
self.assertIsInstance(set_node, TemplateSetNode)
self.assertIsNotNone(set_node.name)
self.assertIsInstance(set_node.name, TemplateNode)
self.assertEqual(set_node.name.resolve(None, None), "somepred other")
self.assertFalse(set_node.local)
self.assertEqual(len(set_node.children), 1)
self.assertEqual(set_node.children[0].resolve(None, None), "Value1")
def test_set_template_predicate_nested(self):
template = ET.fromstring("""
<template>
Some text here
<set name="somepred">Value1</set>
Some text there
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertIsInstance(ast, TemplateNode)
self.assertIsNotNone(ast.children)
self.assertEqual(len(ast.children), 7)
set_node = ast.children[3]
self.assertIsNotNone(set_node)
self.assertIsInstance(set_node, TemplateSetNode)
self.assertIsNotNone(set_node.name)
self.assertIsInstance(set_node.name, TemplateNode)
self.assertEqual(set_node.name.resolve(None, None), "somepred")
self.assertFalse(set_node.local)
self.assertEqual(len(set_node.children), 1)
self.assertEqual(set_node.children[0].resolve(None, None), "Value1")
def test_set_template_local_as_attrib(self):
template = ET.fromstring("""
<template>
<set var="somevar">Value2</set>
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertIsInstance(ast, TemplateNode)
self.assertIsNotNone(ast.children)
self.assertEqual(len(ast.children), 1)
set_node = ast.children[0]
self.assertIsNotNone(set_node)
self.assertIsInstance(set_node, TemplateSetNode)
self.assertIsNotNone(set_node.name)
self.assertIsInstance(set_node.name, TemplateNode)
self.assertEqual(set_node.name.resolve(None, None), "somevar")
self.assertTrue(set_node.local)
self.assertEqual(len(set_node.children), 1)
self.assertEqual(set_node.children[0].resolve(None, None), "Value2")
def test_set_template_predicate_as_child(self):
template = ET.fromstring("""
<template>
<set><name>somepred</name>Value3</set>
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertIsInstance(ast, TemplateNode)
self.assertIsNotNone(ast.children)
self.assertEqual(len(ast.children), 1)
set_node = ast.children[0]
self.assertIsNotNone(set_node)
self.assertIsInstance(set_node, TemplateSetNode)
self.assertIsNotNone(set_node.name)
self.assertIsInstance(set_node.name, TemplateNode)
self.assertEqual(set_node.name.resolve(None, None), "somepred")
self.assertFalse(set_node.local)
self.assertEqual(len(set_node.children), 1)
self.assertEqual(set_node.children[0].resolve(None, None), "Value3")
def test_set_template_local_as_child(self):
template = ET.fromstring("""
<template>
<set><var>somepred</var>Value4</set>
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertIsInstance(ast, TemplateNode)
self.assertIsNotNone(ast.children)
self.assertEqual(len(ast.children), 1)
set_node = ast.children[0]
self.assertIsNotNone(set_node)
self.assertIsInstance(set_node, TemplateSetNode)
self.assertIsNotNone(set_node.name)
self.assertIsInstance(set_node.name, TemplateNode)
self.assertEqual(set_node.name.resolve(None, None), "somepred")
self.assertTrue(set_node.local)
self.assertEqual(len(set_node.children), 1)
self.assertEqual(set_node.children[0].resolve(None, None), "Value4")
class TemplateGraphBotTests(unittest.TestCase):
def setUp(self):
self.parser = TemplateGraph()
self.assertIsNotNone(self.parser)
self.test_brain = None
self.test_sentence = Sentence("test sentence")
self.test_sentence._stars = ['one', 'two', 'three', 'four', 'five', 'six']
self.test_sentence._thatstars = ["*"]
self.test_sentence._topicstars = ["*"]
test_config = ClientConfiguration()
self.test_bot = Bot(Brain(BrainConfiguration()), config=test_config.bot_configuration)
self.test_clientid = "testid"
conversation = self.test_bot.get_conversation(self.test_clientid)
question = Question.create_from_sentence(self.test_sentence)
conversation._questions.append(question)
def test_extension_as_attrib(self):
template = ET.fromstring("""
<template>
<extension path="test.parser.template.graph.test_extension.TestExtension">
1 2 3
</extension>
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertIsInstance(ast, TemplateNode)
self.assertIsNotNone(ast.children)
self.assertEqual(len(ast.children), 1)
ext_node = ast.children[0]
self.assertIsNotNone(ext_node)
self.assertIsInstance(ext_node, TemplateExtensionNode)
self.assertIsNotNone(ext_node._path)
self.assertEqual(len(ext_node.children), 3)
self.assertEqual("executed", ext_node.resolve(None, None))
def test_extension_as_child(self):
template = ET.fromstring("""
<template>
<extension>
<path>test.parser.template.graph.test_extension.TestExtension</path>
1 2 3
</extension>
</template>
""")
ast = self.parser.parse_template_expression(template)
self.assertIsNotNone(ast)
self.assertIsInstance(ast, TemplateNode)
self.assertIsNotNone(ast.children)
self.assertEqual(len(ast.children), 1)
ext_node = ast.children[0]
self.assertIsNotNone(ext_node)
self.assertIsInstance(ext_node, TemplateExtensionNode)
self.assertIsNotNone(ext_node._path)
self.assertEqual(len(ext_node.children), 3)
self.assertEqual("executed", ext_node.resolve(None, None))
