def test_load_oobs(self):
config = MongoStorageConfiguration()
engine = MongoStorageEngine(config)
engine.initialise()
store = MongoOOBStore(engine)
self.assert_load(store)
def test_set_storage(self):
config = MongoStorageConfiguration()
engine = MongoStorageEngine(config)
engine.initialise()
store = MongoSetsStore(engine)
self.assert_set_storage(store)
def test_upload_from_file_exception(self):
config = MongoStorageConfiguration()
engine = MongoStorageEngine(config)
engine.initialise()
store = MongoOOBStore(engine)
self.assert_upload_from_file_exception(store)
def test_upload_from_file_verbose_no_corpus(self):
config = MongoStorageConfiguration()
engine = MongoStorageEngine(config)
engine.initialise()
store = MongoSpellingStore(engine)
self.assert_upload_from_file_no_corpus(store, verbose=False)
def test_upload_from_file_add_document_false(self):
config = MongoStorageConfiguration()
engine = MongoStorageEngine(config)
engine.initialise()
store = MongoSpellingStore(engine)
self.assert_upload_from_file_exception(store, verbose=False)
def test_upload_from_csv_file(self):
config = MongoStorageConfiguration()
engine = MongoStorageEngine(config)
engine.initialise()
store = MongoSetsStore(engine)
self.assert_upload_from_csv_file(store)
def test_empty_variables(self):
config = MongoStorageConfiguration()
engine = MongoStorageEngine(config)
engine.initialise()
store = MongoVariableStore(engine)
self.assert_empty_variables(store)
def test_save_learnf(self):
config = MongoStorageConfiguration()
engine = MongoStorageEngine(config)
engine.initialise()
store = MongoLearnfStore(engine)
self.assert_save_learnf(store)
def test_upload_text_files_from_directory_no_subdir(self):
config = MongoStorageConfiguration()
engine = MongoStorageEngine(config)
engine.initialise()
store = MongoSetsStore(engine)
self.assert_upload_text_files_from_directory_no_subdir(store)
def test_linkedaccounts_storage(self):
config = MongoStorageConfiguration()
engine = MongoStorageEngine(config)
engine.initialise()
store = MongoLinkedAccountStore(engine)
self.assert_linkedaccounts_storage(store)
def test_empty_named(self):
config = MongoStorageConfiguration()
engine = MongoStorageEngine(config)
engine.initialise()
store = MongoCategoryStore(engine)
self.assertEqual(store.storage_engine, engine)
self.assert_empty_name(store)
def test_category_by_groupid_storage(self):
config = MongoStorageConfiguration()
engine = MongoStorageEngine(config)
engine.initialise()
store = MongoCategoryStore(engine)
self.assertEqual(store.storage_engine, engine)
self.assert_category_by_groupid_storage(store)
def tests_conversation_storage(self):
config = MongoStorageConfiguration()
engine = MongoStorageEngine(config)
engine.initialise()
store = MongoConversationStore(engine)
self.assertEqual(store.storage_engine, engine)
self.assert_conversation_storage(store)
def test_upload_from_directory(self):
config = MongoStorageConfiguration()
engine = MongoStorageEngine(config)
engine.initialise()
store = MongoCategoryStore(engine)
self.assertEqual(store.storage_engine, engine)
self.assert_upload_from_directory(store)
def test_links_storage(self):
config = MongoStorageConfiguration()
engine = MongoStorageEngine(config)
engine.initialise()
store = MongoLinkStore(engine)
self.assertEqual(store.storage_engine, engine)
self.assert_links_storage(store)
def setUp(self):
config = MongoStorageConfiguration()
self.storage_engine = MongoStorageEngine(config)
self.storage_engine.initialise()
client = TestClient()
self.context = client.create_client_context("TESTUSER")
self.context.brain._security._account_linker = BasicAccountLinkerService(
self.storage_engine)
def test_get_lookup_not_present(self):
config = MongoStorageConfiguration()
engine = MongoStorageEngine(config)
engine.initialise()
store = TestMongoLookupStore(engine)
store.drop()
collection = store.get_lookup()
self.assertEquals({}, collection)
class MongoAccountLinkerExtensionTests(AccountLinkerExtensionAsserts):
def setUp(self):
config = MongoStorageConfiguration()
config.drop_all_first = True
self.storage_engine = MongoStorageEngine(config)
self.storage_engine.initialise()
client = TestClient()
self.context = client.create_client_context("TESTUSER")
self.context.brain._security._account_linker = BasicAccountLinkerService(
self.storage_engine)
@unittest.skipIf(Engines.mongo is False, Engines.mongo_disabled)
def test_unknown_command(self):
self.assert_unknown_command(self.context)
@unittest.skipIf(Engines.mongo is False, Engines.mongo_disabled)
def test_primary_account_link_success(self):
self.assert_primary_account_link_success(self.context)
def patch_get_account_linker_service(self, context):
return None
@unittest.skipIf(Engines.mongo is False, Engines.mongo_disabled)
@patch(
'programy.security.linking.extension.AccountLinkingExtension.get_account_linker_service',
patch_get_account_linker_service)
def test_primary_account_link_no_service(self):
self.assert_primary_account_link_no_service(self.context)
def patch_link_user_to_client(self, userid, account_name):
return False
@patch(
'programy.security.linking.accountlinker.BasicAccountLinkerService.link_user_to_client',
patch_link_user_to_client)
def test_primary_account_link_link_user_to_client_fails(self):
self.assert_primary_account_link_user_to_client_fails(self.context)
@unittest.skipIf(Engines.mongo is False, Engines.mongo_disabled)
def test_primary_account_link_failures(self):
self.assert_primary_account_link_failures(self.context)
@unittest.skipIf(Engines.mongo is False, Engines.mongo_disabled)
def test_secondary_account_link_success(self):
self.assert_secondary_account_link_success(self.context)
@unittest.skipIf(Engines.mongo is False, Engines.mongo_disabled)
def test_secondary_account_link_failures(self):
self.assert_secondary_account_link_failures(self.context)
@unittest.skipIf(Engines.mongo is False, Engines.mongo_disabled)
@patch(
'programy.security.linking.extension.AccountLinkingExtension.get_account_linker_service',
patch_get_account_linker_service)
def test_secondary_account_link_no_service(self):
self.assert_secondary_account_link_no_service(self.context)
class MongoAccountLinkerServiceTests(AccountLinkerAsserts):
def setUp(self):
config = MongoStorageConfiguration()
self.storage_engine = MongoStorageEngine(config)
self.storage_engine.initialise()
@unittest.skipIf(Engines.mongo is False, Engines.mongo_disabled)
def test_init(self):
mgr = BasicAccountLinkerService(self.storage_engine)
self.assertIsNotNone(mgr)
@unittest.skipIf(Engines.mongo is False, Engines.mongo_disabled)
def test_generate_key(self):
mgr = BasicAccountLinkerService(self.storage_engine)
self.assert_generate_key(mgr)
@unittest.skipIf(Engines.mongo is False, Engines.mongo_disabled)
def test_generate_expirary(self):
mgr = BasicAccountLinkerService(self.storage_engine)
self.assert_generate_expirary(mgr)
@unittest.skipIf(Engines.mongo is False, Engines.mongo_disabled)
def test_happy_path(self):
mgr = BasicAccountLinkerService(self.storage_engine)
self.assert_happy_path(mgr)
@unittest.skipIf(Engines.mongo is False, Engines.mongo_disabled)
def test_user_client_link_already_exists(self):
mgr = BasicAccountLinkerService(self.storage_engine)
self.assert_user_client_link_already_exists(mgr)
@unittest.skipIf(Engines.mongo is False, Engines.mongo_disabled)
def test_provided_key_not_matched(self):
mgr = BasicAccountLinkerService(self.storage_engine)
self.assert_provided_key_not_matched(mgr)
@unittest.skipIf(Engines.mongo is False, Engines.mongo_disabled)
def test_generated_key_not_matched(self):
mgr = BasicAccountLinkerService(self.storage_engine)
self.assert_generated_key_not_matched(mgr)
@unittest.skipIf(Engines.mongo is False, Engines.mongo_disabled)
def test_generated_key_expired(self):
mgr = BasicAccountLinkerService(self.storage_engine)
self.assert_generated_key_expired(mgr)
@unittest.skipIf(Engines.mongo is False, Engines.mongo_disabled)
def test_lockout_after_max_retries(self):
mgr = BasicAccountLinkerService(self.storage_engine)
self.assert_lockout_after_max_retries(mgr)
@unittest.skipIf(Engines.mongo is False, Engines.mongo_disabled)
def test_unlink_user_from_client(self):
mgr = BasicAccountLinkerService(self.storage_engine)
self.assert_unlink_user_from_client(mgr)
def test_upload_from_file_with_exception(self):
config = MongoStorageConfiguration()
engine = MongoStorageEngine(config)
engine.initialise()
store = MongoLicenseKeysStore(engine)
store.empty()
count, success = store.upload_from_file(os.path.dirname(__file__) + os.sep + "data" + os.sep + "licenses" + os.sep + "test_license.keys")
self.assertEquals(0, count)
self.assertEquals(0, success)
def test_get_lookup_present(self):
config = MongoStorageConfiguration()
engine = MongoStorageEngine(config)
engine.initialise()
store = TestMongoLookupStore(engine)
store.drop()
store.add_to_lookup("key1", "value1", overwrite_existing=True)
collection = store.get_lookup()
self.assertIsNotNone(collection)
def test_load_no_collection(self):
config = MongoStorageConfiguration()
engine = MongoStorageEngine(config)
engine.initialise()
store = TestMongoLookupStore(engine)
collection = TestCollection()
store.load(collection)
self.assertEquals(0, len(collection.pairs.keys()))
def test_initialise(self):
config = unittest.mock.Mock()
engine = MongoStorageEngine(config)
store = MongoStore(engine)
self.assertEqual(store.storage_engine, engine)
def test_load_all(self):
config = MongoStorageConfiguration()
engine = MongoStorageEngine(config)
engine.initialise()
store = TestMongoLookupStore(engine)
store.add_to_lookup("key1", "value1", overwrite_existing=True)
collection = TestCollection()
store.load_all(collection)
self.assertEquals(1, len(collection.pairs.keys()))
self.assertTrue(collection.has_key("key1"))
self.assertEqual(
[re.compile('(^key1|key1|key1$)', re.IGNORECASE), 'VALUE1'],
collection.value("key1"))
def upload(type,
url,
database,
filename,
dirname,
subdir,
extension,
drop_all=False,
verbose=False):
config = MongoStorageConfiguration()
config._url = url
config._database = database
config._drop_all_first = drop_all
engine = MongoStorageEngine(config)
engine.initialise()
store = Uploader._get_store(type, engine)
if drop_all is True:
print("Dropped database")
exit(0)
print("Emptying [%s]" % type)
store.empty()
print("Loading [%s]" % type)
if filename is not None:
count, success = store.upload_from_file(filename,
format=Store.TEXT_FORMAT,
commit=True,
verbose=verbose)
print("Lines processed ", count)
print("Entities successful", success)
elif dirname is not None:
count, success = store.upload_from_directory(directory=dirname,
subdir=subdir,
extension=extension,
commit=True,
verbose=verbose)
print("Lines processed ", count)
print("Entities successful", success)
else:
raise Exception("You must specify either --file or --dir")
def upload(storetype,
url,
database,
filename,
dirname,
subdir,
extension,
verbose=False):
config = MongoStorageConfiguration()
config.url = url
config.database = database
config.drop_all_first = False
engine = MongoStorageEngine(config)
engine.initialise()
store = Uploader._get_store(storetype, engine)
outputLog(None, "Emptying [%s]" % storetype)
store.empty()
outputLog(None, "Loading [%s]" % storetype)
if filename is not None:
count, success = store.upload_from_file(
filename,
fileformat=Store.TEXT_FORMAT,
commit=True,
verbose=verbose)
outputLog(None, "Lines processed: %d" % count)
outputLog(None, "Entities successful: %d" % success)
elif dirname is not None:
count, success = store.upload_from_directory(directory=dirname,
subdir=subdir,
extension=extension,
commit=True,
verbose=verbose)
outputLog(None, "Lines processed: %d" % count)
outputLog(None, "Entities successful: %d" % success)
else:
raise Exception("You must specify either --file or --dir")
return count, success
def test_key_methods(self):
config = unittest.mock.Mock()
engine = MongoStorageEngine(config)
store = MongoStore(engine)
with self.assertRaises(NotImplementedError):
store.drop()
store.commit()
store.rollback()
with self.assertRaises(NotImplementedError):
store.collection_name()
def test_initialise(self):
config = MongoStorageConfiguration()
engine = MongoStorageEngine(config)
engine.initialise()
store = MongoPostQuestionProcessorStore(engine)
self.assertEqual(store.storage_engine, engine)
def test_initialise(self):
config = MongoStorageConfiguration()
engine = MongoStorageEngine(config)
engine.initialise()
store = MongoUserGroupsStore(engine)
self.assertEqual(store.storage_engine, engine)
def create_engine(self):
engine = MongoStorageEngine(self)
engine.initialise()
return engine
