def test_that_to_root(self):
node1 = PatternRootNode()
node2 = PatternThatNode()
with self.assertRaises(ParserException) as raised:
node1.can_add(node2)
self.assertEqual(str(raised.exception), "Cannot add that node to root node")
def test_multiple_roots(self):
node1 = PatternRootNode()
node2 = PatternRootNode()
with self.assertRaises(ParserException) as raised:
node1.can_add(node2)
self.assertTrue(str(raised.exception).startswith("Cannot add root node to existing root node"))
def test_remove_0ormore_hash(self):
root = PatternRootNode()
self.assertEqual(0, len(root.children))
root.add_child(PatternZeroOrMoreWildCardNode("#"))
self.assertIsNotNone(root._0ormore_hash)
root._remove_0ormore_hash("*")
self.assertIsNone(root._0ormore_hash)
def test_remove_priorty(self):
root = PatternRootNode()
self.assertEqual(0, len(root.children))
root.add_child(PatternPriorityWordNode("WORD"))
self.assertEqual(1, len(root.priority_words))
root._remove_priority("*")
self.assertEqual(0, len(root.priority_words))
def test_equivalent_userid(self):
node1 = PatternRootNode()
node2 = PatternRootNode()
node3 = PatternRootNode(userid="testuser")
self.assertTrue(node1.equivalent(node2))
self.assertFalse(node1.equivalent(node3))
def test_wildcard(self):
wildcard = MockPatternWildCardNode("*")
self.assertIsNotNone(wildcard)
self.assertTrue(wildcard.is_wildcard())
with self.assertRaises(ParserException):
wildcard.can_add(PatternRootNode())
wildcard.can_add(PatternWordNode("test"))
self.assertEqual(["*"], wildcard.matching_wildcards())
def __init__(self, root_node=None, pattern_factory=None):
if root_node is None:
logging.debug("Defaulting root to PatternRootNode")
self._root_node = PatternRootNode()
else:
if root_node.is_root() is False:
raise ParserException(
"Root node needs to be of base type PatternRootNode")
self._root_node = root_node
if pattern_factory is None:
logging.debug("Defaulting node factory to PatternNodeFactory")
self._pattern_factory = PatternNodeFactory()
self._pattern_factory.load_nodes_config_from_file(
"dummy_config.conf")
else:
if isinstance(pattern_factory, PatternNodeFactory) is False:
raise ParserException(
"Pattern factory needs to be base class of PatternNodeFactory"
)
self._pattern_factory = pattern_factory
def test_parse_text_priority(self):
graph = PatternGraph(self._aiml_parser)
root = PatternRootNode()
final_node = graph._parse_text("$HELLO", root)
self.assertIsNotNone(final_node)
self.assertIsInstance(final_node, PatternPriorityWordNode)
def test_init(self):
node = PatternRootNode()
self.assertIsNotNone(node)
self.assertTrue(node.is_root())
self.assertFalse(node.is_priority())
self.assertFalse(node.is_wildcard())
self.assertFalse(node.is_zero_or_more())
self.assertFalse(node.is_one_or_more())
self.assertFalse(node.is_set())
self.assertFalse(node.is_bot())
self.assertFalse(node.is_template())
self.assertFalse(node.is_that())
self.assertFalse(node.is_topic())
self.assertFalse(node.is_wildcard())
self.assertIsNotNone(node.children)
self.assertFalse(node.has_children())
self.assertTrue(node.equivalent(PatternRootNode()))
self.assertEqual(node.to_string(), "ROOT [*] [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)]")
node.add_child(PatternNode())
self.assertEqual(len(node.children), 1)
self.assertEqual(node.to_string(), "ROOT [*] [P(0)^(0)#(0)C(1)_(0)*(0)To(0)Th(0)Te(0)]")
def test_remove_all_types_children_with_userid(self):
root = PatternRootNode()
root.add_child(PatternPriorityWordNode("test1", userid="user1"))
root.add_child(PatternWordNode("test2", userid="user1"))
root.add_child(PatternZeroOrMoreWildCardNode('^', userid="user1"))
root.add_child(PatternZeroOrMoreWildCardNode('#', userid="user1"))
root.add_child(PatternOneOrMoreWildCardNode('_', userid="user1"))
root.add_child(PatternOneOrMoreWildCardNode('*', userid="user1"))
self.assertEquals(1, len(root.priority_words))
self.assertIsNotNone(root._0ormore_hash)
self.assertIsNotNone(root._1ormore_underline)
self.assertEquals(1, len(root.children))
self.assertIsNotNone(root._0ormore_arrow)
self.assertIsNotNone(root._1ormore_star)
root.remove_children_with_userid("user1")
self.assertEquals(0, len(root.priority_words))
self.assertIsNone(root._0ormore_hash)
self.assertIsNone(root._1ormore_underline)
self.assertEquals(0, len(root.children))
self.assertIsNone(root._0ormore_arrow)
self.assertIsNone(root._1ormore_star)
def test_init(self):
node = PatternRootNode()
self.assertIsNotNone(node)
self.assertTrue(node.is_root())
self.assertFalse(node.is_priority())
self.assertFalse(node.is_wildcard())
self.assertFalse(node.is_zero_or_more())
self.assertFalse(node.is_one_or_more())
self.assertIsNotNone(node.children)
self.assertFalse(node.has_children())
self.assertTrue(node.equivalent(PatternRootNode()))
self.assertEqual(node.to_string(), "ROOT [P(0)^(0)#(0)C(0)_(0)*(0)To(0)Th(0)Te(0)]")
node.add_child(PatternNode())
self.assertEqual(len(node.children), 1)
self.assertEqual(node.to_string(), "ROOT [P(0)^(0)#(0)C(1)_(0)*(0)To(0)Th(0)Te(0)]")
def test_equivalent_diff_nodes(self):
node1 = PatternRootNode()
node2 = PatternWordNode("Word")
self.assertFalse(node1.equivalent(node2))