Beispiel #1
0
    def test_save_learnf_with_exception(self):
        config = FileStorageConfiguration()
        tmpdir = os.path.dirname(__file__) + os.sep + "learnf"
        config.learnf_storage._dirs = [tmpdir]
        engine = FileStorageEngine(config)
        engine.initialise()
        store = FileLearnfStore(engine)

        test_client = TestClient()
        client_context = test_client.create_client_context("test1")

        learnf_path = store._get_storage_path()
        learnf_fullpath = store.create_learnf_path(client_context, learnf_path)

        if os.path.exists(learnf_fullpath):
            os.remove(learnf_fullpath)

        self.assertFalse(os.path.exists(learnf_fullpath))

        pattern = ET.Element('pattern')
        pattern.text = "HELLO"
        topic = ET.Element('topic')
        topic.text = '*'
        that = ET.Element('that')
        that.text = '*'
        template = TemplateNode()
        template.append(TemplateWordNode("Hello"))

        category = LearnCategory(pattern, topic, that, template)

        self.assertFalse(store.save_learnf(client_context, category))
Beispiel #2
0
    def test_reload_from_file(self):
        config = FileStorageConfiguration()
        config._rdf_storage = FileStoreConfiguration(dirs=[
            os.path.dirname(__file__) + os.sep + "test_files" + os.sep + "rdfs"
        ])

        factory = StorageFactory()

        storage_engine = FileStorageEngine(config)

        factory._storage_engines[StorageFactory.RDF] = storage_engine
        factory._store_to_engine_map[StorageFactory.RDF] = storage_engine

        storage_engine.initialise()

        collection = RDFCollection()
        self.assertIsNotNone(collection)

        collection.load(factory)

        self.assertTrue(collection.has_subject("TEST1"))
        self.assertTrue(collection.has_predicate("TEST1", "HASPURPOSE"))
        self.assertTrue(collection.has_object("TEST1", "HASPURPOSE",
                                              "to test"))

        collection.delete_entity("TEST1", "HASPURPOSE", "to test")
        self.assertFalse(
            collection.has_object("TEST1", "HASPURPOSE", "to test"))

        collection.reload(factory, "TESTDATA")

        self.assertTrue(collection.has_subject("TEST1"))
        self.assertTrue(collection.has_predicate("TEST1", "HASPURPOSE"))
        self.assertTrue(collection.has_object("TEST1", "HASPURPOSE",
                                              "to test"))
Beispiel #3
0
    def test_load_triggers(self):
        config = TriggerConfiguration()
        config._manager = TriggerConfiguration.LOCAL_MANAGER

        mgr = TriggerManager.load_trigger_manager(config)

        trigger_file = os.path.dirname(__file__) + os.sep + "triggers.txt"
        self.assertTrue(os.path.exists(trigger_file))

        config = FileStorageConfiguration()
        config._triggers_storage = FileStoreConfiguration(file=trigger_file, format="text", encoding="utf-8", delete_on_start=False)
        engine = FileStorageEngine(config)
        engine.initialise()

        storage_factory = StorageFactory()

        storage_factory._storage_engines[StorageFactory.TRIGGERS] = engine
        storage_factory._store_to_engine_map[StorageFactory.TRIGGERS] = engine

        mgr.load_triggers(storage_factory)

        triggers = mgr.get_triggers("SYSTEM_STARTUP")
        self.assertIsNotNone(triggers)
        self.assertEquals(2, len(triggers))

        triggers = mgr.get_triggers("SYSTEM_SHUTDOWN")
        self.assertIsNotNone(triggers)
        self.assertEquals(1, len(triggers))

        triggers = mgr.get_triggers("CONVERSATION_START")
        self.assertIsNotNone(triggers)
        self.assertEquals(1, len(triggers))
    def test_apply_updates(self):
        config = FileStorageConfiguration()
        config._rdf_storage = FileStoreConfiguration(dirs=[
            os.path.dirname(__file__) + os.sep + "test_files" + os.sep + "rdfs"
        ])
        tmpdir = os.path.dirname(__file__) + os.sep + "rdf_updates"
        config.rdf_updates_storage._dirs = [tmpdir]
        config.rdf_updates_storage._has_single_file = True

        factory = StorageFactory()

        storage_engine = FileStorageEngine(config)
        factory._storage_engines[StorageFactory.RDF] = storage_engine
        factory._store_to_engine_map[StorageFactory.RDF] = storage_engine
        factory._storage_engines[StorageFactory.RDF_UPDATES] = storage_engine
        factory._store_to_engine_map[
            StorageFactory.RDF_UPDATES] = storage_engine

        storage_engine.initialise()
        updates_engine = factory.entity_storage_engine(
            StorageFactory.RDF_UPDATES)
        updates_store = updates_engine.rdf_updates_store()
        updates_store.empty()

        collection = RDFCollection()
        self.assertIsNotNone(collection)

        collection.load(factory)

        self.assertTrue(collection.has_subject("TEST1"))
        self.assertTrue(collection.has_predicate("TEST1", "HASPURPOSE"))
        self.assertTrue(collection.has_object("TEST1", "HASPURPOSE",
                                              "to test"))

        collection.apply_updates()
Beispiel #5
0
    def test_apply_rdf_updates_No_files(self):
        config = FileStorageConfiguration()
        config._rdf_storage = FileStoreConfiguration(dirs=[
            os.path.dirname(__file__) + os.sep + "data" + os.sep + "rdfs" +
            os.sep + "text"
        ],
                                                     extension="rdf",
                                                     subdirs=True,
                                                     format="text",
                                                     encoding="utf-8",
                                                     delete_on_start=False)
        tmpdir = os.path.dirname(__file__) + os.sep + "rdf_updates"
        config.rdf_updates_storage._dirs = [tmpdir]
        config.rdf_updates_storage._has_single_file = True

        engine = FileStorageEngine(config)
        engine.initialise()
        rdf_store = FileRDFStore(engine)
        updates_store = FileRDFUpdatesStore(engine)
        filepath = updates_store._updates_filename(
            updates_store._get_storage_path())

        updates_store.empty_updates()
        self.assertFalse(os.path.exists(filepath))

        map_collection = RDFCollection()
        rdf_store.load_all(map_collection)

        updates_store.apply_rdf_updates(map_collection, None)

        updates_store.empty_updates()
        self.assertFalse(os.path.exists(filepath))
Beispiel #6
0
    def test_rdf_updates_other_case(self):
        config = FileStorageConfiguration()
        config._rdf_storage = FileStoreConfiguration(dirs=[
            os.path.dirname(__file__) + os.sep + "data" + os.sep + "rdfs" +
            os.sep + "text"
        ],
                                                     extension="rdf",
                                                     subdirs=True,
                                                     format="text",
                                                     encoding="utf-8",
                                                     delete_on_start=False)
        tmpdir = os.path.dirname(__file__) + os.sep + "rdf_updates"
        config.rdf_updates_storage._dirs = [tmpdir, tmpdir]
        config.rdf_updates_storage._has_single_file = True
        engine = FileStorageEngine(config)
        engine.initialise()
        updates_store = FileRDFUpdatesStore(engine)
        filepath = updates_store._updates_filename(
            updates_store._get_storage_path())

        updates_store.empty()
        self.assertFalse(os.path.exists(filepath))

        self.assertEqual(updates_store.get_storage(),
                         config.rdf_updates_storage)
Beispiel #7
0
    def test_load_errors(self):
        config = FileStorageConfiguration()
        tmpdir = os.path.dirname(__file__) + os.sep + "errors"
        tmpfile = tmpdir + os.sep + "errors.txt"
        config.errors_storage._dirs = [tmpfile]
        config.errors_storage._has_single_file = True
        engine = FileStorageEngine(config)
        engine.initialise()
        store = FileErrorsStore(engine)

        path = store._get_dir_from_path(store._get_storage_path())
        if os.path.exists(path):
            shutil.rmtree(path)
        self.assertFalse(os.path.exists(path))

        store.empty()

        errors = [["aiml1.xml", "10", "20", "1", "5", "node", "Error_1"]]
        store.save_errors(errors)
        self.assertTrue(os.path.exists(store._get_storage_path()))

        errorInfo = store.load_errors()
        self.assertIsNotNone(errorInfo)
        self.assertIsNotNone(errorInfo['errors'])
        errors = errorInfo['errors']
        error = errors[0]
        self.assertEqual("aiml1.xml", error['file'])

        store.empty()
        self.assertFalse(os.path.exists(store._get_storage_path()))

        shutil.rmtree(tmpdir)
        self.assertFalse(os.path.exists(tmpdir))
    def test_load_duplicates(self):
        config = FileStorageConfiguration()
        tmpdir = os.path.dirname(__file__) + os.sep + "duplicates"
        tmpfile = tmpdir + os.sep + "duplicates.txt"
        config.duplicates_storage._dirs = [tmpfile]
        config.duplicates_storage._has_single_file = True
        engine = FileStorageEngine(config)
        engine.initialise()
        store = FileDuplicatesStore(engine)

        path = store._get_dir_from_path(store._get_storage_path())
        if os.path.exists(path):
            shutil.rmtree(path)
        self.assertFalse(os.path.exists(path))

        store.empty()

        duplicates = [["aiml1.xml", "10", "20", "1", "5", "Duplicate_1"]]
        store.save_duplicates(duplicates)
        self.assertTrue(os.path.exists(store._get_storage_path()))

        duplicateInfo = store.load_duplicates()
        self.assertIsNotNone(duplicateInfo)
        self.assertIsNotNone(duplicateInfo['duplicates'])
        duplicates = duplicateInfo['duplicates']
        duplicate = duplicates[0]
        self.assertEqual("aiml1.xml", duplicate['file'])

        store.empty()
        self.assertFalse(os.path.exists(store._get_storage_path()))

        shutil.rmtree(tmpdir)
        self.assertFalse(os.path.exists(tmpdir))
Beispiel #9
0
    def test_load_from_test_dir_with_subdir(self):
        config = FileStorageConfiguration()
        config._maps_storage = FileStoreConfiguration(dirs=[
            os.path.dirname(__file__) + os.sep + "data" + os.sep + "maps" +
            os.sep + "text"
        ],
                                                      extension="txt",
                                                      subdirs=True,
                                                      format="text",
                                                      encoding="utf-8",
                                                      delete_on_start=False)
        engine = FileStorageEngine(config)
        engine.initialise()
        store = FileMapsStore(engine)

        map_collection = MapCollection()
        store.load_all(map_collection)

        self.assertTrue(map_collection.contains('TESTMAP'))
        the_map = map_collection.map('TESTMAP')
        self.assertIsNotNone(the_map)
        self.assertEqual("6", the_map['ANT'])

        self.assertTrue(map_collection.contains('TESTMAP2'))
        the_map = map_collection.map('TESTMAP2')
        self.assertIsNotNone(the_map)
        self.assertEqual("grrrrr", the_map['BEAR'])
Beispiel #10
0
    def test_save_braintree(self):
        config = FileStorageConfiguration()
        config._categories_storage = FileStoreConfiguration(dirs=[os.path.dirname(__file__) + os.sep + "data" + os.sep + "categories"], extension="aiml", subdirs=False, format="xml", encoding="utf-8", delete_on_start=False)
        tmpdir = os.path.dirname(__file__) + os.sep + "braintree"
        tmpfile = tmpdir + os.sep + "braintree.xml"
        config.braintree_storage._dirs = [tmpfile]
        config.braintree_storage._has_single_file = True
        engine = FileStorageEngine(config)
        engine.initialise()
        store = FileBraintreeStore(engine)

        path = store._get_dir_from_path(store._get_storage_path())
        if os.path.exists(path):
            shutil.rmtree(path)
        self.assertFalse(os.path.exists(path))

        test_client = TestClient()
        client_context = test_client.create_client_context("test1")
        pattern_graph = client_context.brain.aiml_parser.pattern_parser

        store.save_braintree(client_context, pattern_graph)

        self.assertTrue(os.path.exists(store._get_storage_path()))

        shutil.rmtree(tmpdir)
        self.assertFalse(os.path.exists(tmpdir))
Beispiel #11
0
    def test_save_load_binaries(self):
        config = FileStorageConfiguration()
        tmpdir = os.path.dirname(__file__) + os.sep + "braintree"
        tmpfile = tmpdir + os.sep + "braintree.bin"
        config.binaries_storage._dirs = [tmpfile]
        config.binaries_storage._has_single_file = True
        engine = FileStorageEngine(config)
        engine.initialise()
        store = FileBinariesStore(engine)

        aiml_parser = PretendAimlParser("pretend1")

        path = store._get_dir_from_path(store._get_storage_path())
        if os.path.exists(path):
            shutil.rmtree(path)
        self.assertFalse(os.path.exists(path))

        store.save_binary(aiml_parser)

        self.assertTrue(os.path.exists(store._get_storage_path()))

        aiml_parser2 = store.load_binary()
        self.assertIsNotNone(aiml_parser2)

        self.assertEqual(aiml_parser2._name, "pretend1")

        shutil.rmtree(tmpdir)
        self.assertFalse(os.path.exists(tmpdir))
Beispiel #12
0
    def test_save_learnf(self):
        config = FileStorageConfiguration()
        tmpdir = os.path.dirname(__file__) + os.sep + "learnf"
        config.learnf_storage._dirs = [tmpdir]
        engine = FileStorageEngine(config)
        engine.initialise()
        store = FileLearnfStore(engine)

        test_client = TestClient()
        client_context = test_client.create_client_context("test1")

        learnf_path = store._get_storage_path()
        learnf_fullpath = store.create_learnf_path(client_context, learnf_path)

        if os.path.exists(learnf_fullpath):
            os.remove(learnf_fullpath)
        self.assertFalse(os.path.exists(learnf_fullpath))

        template = TemplateNode()
        template.append(TemplateWordNode("Hello"))

        category = LearnCategory("HELLO *", "*", "*", template)

        store.save_learnf(client_context, category)

        self.assertTrue(os.path.exists(learnf_fullpath))

        shutil.rmtree(tmpdir)
        self.assertFalse(os.path.exists(tmpdir))
    def test_load_from_test_dir_with_subdir(self):
        config = FileStorageConfiguration()
        config._sets_storage = FileStoreConfiguration(dirs=[
            os.path.dirname(__file__) + os.sep + "data" + os.sep + "sets" +
            os.sep + "text"
        ],
                                                      extension="txt",
                                                      subdirs=True,
                                                      format="text",
                                                      encoding="utf-8",
                                                      delete_on_start=False)
        engine = FileStorageEngine(config)
        engine.initialise()
        store = FileSetsStore(engine)

        set_collection = SetCollection()
        store.load_all(set_collection)

        self.assertTrue(set_collection.contains('TESTSET'))
        values = set_collection.set_list('TESTSET')
        self.assertTrue('VAL1' in values)
        self.assertTrue('VAL2' in values)
        self.assertTrue('VAL3' in values)
        self.assertTrue('VAL4' in values)

        self.assertTrue(set_collection.contains('TESTSET2'))
        values = set_collection.set_list('TESTSET2')
        self.assertEqual(4, len(values))
        self.assertTrue('VAL5' in values)
        self.assertTrue('VAL6' in values)
        self.assertTrue('VAL7' in values)
        self.assertTrue('VAL8' in values)
Beispiel #14
0
    def test_store_logs(self):
        self.tearDown()

        config = FileStorageConfiguration()
        config.logs_storage._dirs = [self._tmpdir]

        engine = FileStorageEngine(config)
        engine.initialise()
        store = FileLogsStore(engine)
        self.assertEqual(store.storage_engine, engine)

        store.empty()

        client = TestClient()
        client_context = client.create_client_context("user1")
        conversation = Conversation(client_context)

        error_log = {"error": "logger ERROR log"}
        warning_log = {"warning": "logger WARNING log"}
        info_log = {"info": "logger INFO log"}
        debug_log = {"debug": "logger DEBUG log"}

        conversation.append_log(error_log)
        conversation.append_log(warning_log)
        conversation.append_log(info_log)
        conversation.append_log(debug_log)

        store.store_logs(client_context, conversation)

        store.empty()
Beispiel #15
0
    def test_load_users_groups_with_exception(self):
        config = FileStorageConfiguration()
        engine = FileStorageEngine(config)
        engine.initialise()
        store = FileUserGroupStore(engine)

        usersgroupsauthorisor = BasicUserGroupAuthorisationService(config)
        self.assertFalse(store.load_usergroups(usersgroupsauthorisor))
Beispiel #16
0
    def test_storage_path(self):
        config = FileStorageConfiguration()
        engine = FileStorageEngine(config)
        engine.initialise()
        store = FileUserGroupStore(engine)

        self.assertEquals('/tmp/security/usergroups.yaml', store._get_storage_path())
        self.assertIsInstance(store.get_storage(), FileStoreConfiguration)
Beispiel #17
0
    def test_storage_path(self):
        config = FileStorageConfiguration()
        engine = FileStorageEngine(config)
        engine.initialise()
        store = FileCategoryStore(engine)

        self.assertEquals(['/tmp/categories'], store._get_storage_path())
        self.assertIsInstance(store.get_storage(), FileStoreConfiguration)
Beispiel #18
0
    def test_storage_path(self):
        config = FileStorageConfiguration()
        engine = FileStorageEngine(config)
        engine.initialise()
        store = FilePersonStore(engine)

        self.assertEquals('/tmp/lookups/person.txt', store._get_storage_path())
        self.assertIsInstance(store.get_storage(), FileStoreConfiguration)
    def test_storage_path(self):
        config = FileStorageConfiguration()
        engine = FileStorageEngine(config)
        engine.initialise()
        store = FilePostQuestionProcessorsStore(engine)

        self.assertEquals('/tmp/processing/postquestionprocessors.conf', store._get_storage_path())
        self.assertIsInstance(store.get_storage(), FileStoreConfiguration)
Beispiel #20
0
    def test_storage_path(self):
        config = FileStorageConfiguration()
        engine = FileStorageEngine(config)
        engine.initialise()
        store = FileRegexStore(engine)

        self.assertEquals('/tmp/regex/regex-templates.txt', store._get_storage_path())
        self.assertIsInstance(store.get_storage(), FileStoreConfiguration)
    def test_initialise(self):
        config = FileStorageConfiguration()
        config.conversation_storage._dirs = [self._tmpdir]

        engine = FileStorageEngine(config)
        engine.initialise()
        store = FileConversationStore(engine)
        self.assertEqual(store.storage_engine, engine)
Beispiel #22
0
    def test_storage_path(self):
        config = FileStorageConfiguration()
        engine = FileStorageEngine(config)
        engine.initialise()
        store = FileServiceStore(engine)

        self.assertEquals('/tmp/services', store._get_storage_path())
        self.assertIsInstance(store.get_storage(), FileStoreConfiguration)
Beispiel #23
0
    def test_load_spelling_with_exception(self):
        config = FileStorageConfiguration()
        config._spelling_storage =  FileStoreConfiguration(file=os.path.dirname(__file__) + os.sep + "data" + os.sep + "spelling" + os.sep + "corpus.txt", fileformat="text", encoding="utf-8", delete_on_start=False)
        engine = FileStorageEngine(config)
        engine.initialise()
        store = FileSpellingStore(engine)

        spelling_checker = NorvigSpellingChecker()
        self.assertFalse(store.load_spelling(spelling_checker))
Beispiel #24
0
    def test_storage_path(self):
        config = FileStorageConfiguration()
        engine = FileStorageEngine(config)
        engine.initialise()
        store = FileDefaultVariablesStore(engine)

        self.assertEquals('/tmp/properties/defaults.txt',
                          store._get_storage_path())
        self.assertIsInstance(store.get_storage(), FileStoreConfiguration)
Beispiel #25
0
    def test_load_file_contents(self):
        config = FileStorageConfiguration()
        engine = FileStorageEngine(config)
        engine.initialise()
        store = FileProcessorsStore(engine)

        collection = ProcessorCollection()
        count = store._load_file_contents(collection, os.path.dirname(__file__) + os.sep + "data" + os.sep + "processors" + os.sep + "preprocessors.conf")
        self.assertEquals(2, count)
Beispiel #26
0
    def test_process_line_with_exception(self):
        config = FileStorageConfiguration()
        engine = FileStorageEngine(config)
        engine.initialise()
        store = FileProcessorsStore(engine)

        collection = ProcessorCollection()
        count = store._process_line("XXXXXX", collection, 0)
        self.assertEquals(0, count)
Beispiel #27
0
    def test_process_line(self):
        config = FileStorageConfiguration()
        engine = FileStorageEngine(config)
        engine.initialise()
        store = FilePropertyStore(engine)

        self.assertFalse(store._process_line("", {}))
        self.assertFalse(store._process_line("#name:Y-Bot", {}))
        self.assertTrue(store._process_line("name:Y-Bot", {}))
Beispiel #28
0
    def test_storage_path(self):
        config = FileStorageConfiguration()
        engine = FileStorageEngine(config)
        engine.initialise()
        store = FileTemplateNodeStore(engine)

        self.assertEquals('/tmp/nodes/template_nodes.conf',
                          store._get_storage_path())
        self.assertIsInstance(store.get_storage(), FileStoreConfiguration)
Beispiel #29
0
    def test_process_config_line_with_exception(self):
        config = FileStorageConfiguration()
        engine = FileStorageEngine(config)
        engine.initialise()
        store = FileNodeStore(engine)

        node_factory = MockNodeFactory()

        self.assertFalse(store.process_config_line(node_factory, "root=programy.parser.pattern.nodes.root.PatternRootNode", "nodes.txt"))
Beispiel #30
0
    def test_storage_path(self):
        config = FileStorageConfiguration()
        engine = FileStorageEngine(config)
        engine.initialise()
        store = FileDuplicatesStore(engine)

        self.assertEquals('/tmp/debug/duplicates.txt',
                          store._get_storage_path())
        self.assertIsInstance(store.get_storage(), FileStoreConfiguration)