[Test] public void tm_Server_Save()
{
var tmFileStorage = new TM_FileStorage();
Assert.NotNull(tmFileStorage.path_XmlDatabase());
var tmServerLocation = tmFileStorage.tmServer_Location();
var tmServer_withDefaultData = new TM_Server().setDefaultData();
Assert.IsTrue(tmServerLocation.fileExists());
// Assert.Ignore("TO FIX (Refactor Side Effect");
Assert.AreEqual(tmFileStorage.Server.toXml(), tmServer_withDefaultData.toXml());
var tmpName1 = 10.randomLetters();
tmFileStorage.Server.UserData_Configs.first().Name = tmpName1;
Assert.IsTrue(tmFileStorage.tmServer_Save());
Assert.AreEqual(tmServerLocation.load <TM_Server>().UserData_Configs.first().Name, tmpName1); //check that it was saved
/*
* // this works but makes the test run in 10s (and the test being done is if there is no exception)
*
* var tmpName2 = 10.randomLetters();
* tmServerLocation.fileInfo()
* .setAccessControl("Users", FileSystemRights.Write, AccessControlType.Deny);
*
* tmXmlDatabase.Server.UserData_Configs.first().Name = tmpName2;
*
* Assert.IsFalse(tmXmlDatabase.tmServer_Save());
*
* Assert.AreEqual(tmServerLocation.load<TM_Server>().UserData_Configs.first().Name, tmpName1); //check that it was not saved
*
* Assert.IsTrue(tmServerLocation.delete_File());
* Assert.IsFalse(tmServerLocation.fileExists());
*/
tmFileStorage.delete_Database();
Assert.IsFalse(tmServerLocation.fileExists());
Assert.IsFalse(tmFileStorage.path_XmlDatabase().dirExists());
//check when not UsingFileStorage
//check for nulls
tmFileStorage.Path_XmlDatabase = null;
Assert.IsFalse(tmFileStorage.tmServer_Save());
Assert.IsFalse(new TM_FileStorage(false).tmServer_Save());
}
[Test][Assert_Admin] public void set_Path_XmlDatabase__UsingFileStorage_On_Custom_WebRoot_without_Read_Privs()
{
admin.assert();
var tmFileStorage = new TM_FileStorage(false);
var tmXmlDatabase = tmFileStorage.TMXmlDatabase;
var baseReadOnlyDir = "_tmp_webRoot".tempDir();
var webRootVirualPath = @"virtual/path";
tmFileStorage.WebRoot = baseReadOnlyDir.pathCombine(webRootVirualPath).createDir();
//Check that ensure we can write to baseReadOnlyDir
Assert.IsTrue(baseReadOnlyDir.dirExists());
Assert.IsTrue(tmFileStorage.WebRoot.dirExists());
Assert.IsTrue(tmFileStorage.WebRoot.contains(baseReadOnlyDir));
Assert.IsTrue(baseReadOnlyDir.canWriteToPath());
Assert.AreEqual(tmFileStorage.WebRoot.parentFolder().parentFolder(), baseReadOnlyDir);
//Now remote the write privileges for all users (on baseReadOnlyDir) while keeping TM_Server.WebRoot writeable
baseReadOnlyDir.directoryInfo().deny_Write_Users();
tmFileStorage.WebRoot.directoryInfo().allow_Write_Users();
Assert.IsFalse(baseReadOnlyDir.canWriteToPath());
Assert.IsTrue(tmFileStorage.WebRoot.canWriteToPath());
//Since baseReadOnlyDir can be written, creating an TM_Xml_Database should now default to the App_Data folder (which is on webRootVirualPath )
// var tmXmlDatabase = new TM_Xml_Database().useFileStorage();
tmFileStorage.set_Path_XmlDatabase();
Assert.IsNotNull(tmFileStorage.path_XmlDatabase());
none.assert();
Assert.Ignore("TO FIX (Refactor Side Effect");
Assert.IsTrue(tmFileStorage.path_XmlDatabase().contains("App_Data"));
Assert.IsTrue(tmFileStorage.path_XmlDatabase().contains(tmFileStorage.WebRoot));
Assert.IsTrue(tmFileStorage.path_XmlDatabase().contains(PublicDI.config.O2TempDir));
//Finally re enable write so that we can delete the folder
baseReadOnlyDir.directoryInfo().allow_Write_Users();
Assert.IsTrue(baseReadOnlyDir.canWriteToPath());
Files.deleteFolder(baseReadOnlyDir, true);
Assert.IsFalse(baseReadOnlyDir.dirExists());
}
public void CheckDatabaseSetup()
{
UserGroup.Admin.assert();
Assert.NotNull(tmXmlDatabase);
Assert.NotNull(userData);
Assert.NotNull(tmServer);
Assert.NotNull(tmConfig);
if (tmXmlDatabase.tmLibraries().notEmpty()) // temp while refactoring
{
tmFileStorage.delete_Database();
}
if (tmFileStorage.getCacheLocation().fileExists())
{
tmFileStorage.clear_GuidanceItemsCache();
}
if (userData.tmUsers().notEmpty())
{
userData.delete_All_Users();
}
// userData.createDefaultAdminUser();
Assert.NotNull(tmFileStorage.path_XmlDatabase(), "path_XmlDatabase()"); // null since we are running TM memory (default setting)
Assert.NotNull(tmFileStorage.path_XmlLibraries(), "Path_XmlLibraries"); // null since we are running TM memory (default setting)
Assert.IsEmpty(tmXmlDatabase.Cached_GuidanceItems, "Cached_GuidanceItems");
Assert.IsEmpty(userData.validSessions(), "ActiveSessions");
Assert.AreEqual(userData.TMUsers.size(), 0, "TMUsers"); // there should be no users
UserGroup.None.assert();
}
[Test] public void set_Path_SiteData()
{
var tmFileStorage = new TM_FileStorage();
var expectedPath = tmFileStorage.path_XmlDatabase().pathCombine(TMConsts.TM_SERVER_DEFAULT_NAME_SITEDATA);
tmFileStorage.set_Path_SiteData();
Assert.AreEqual(tmFileStorage.Path_SiteData, expectedPath);
Assert.True(tmFileStorage.Path_SiteData.dirExists());
// try with a different Name value
var tempName = 10.randomLetters();
tmFileStorage.Server.siteData_Config().Name = tempName;
tmFileStorage.set_Path_SiteData();
Assert.IsTrue(tmFileStorage.Path_SiteData.contains(tempName));
//check bad data handling
tmFileStorage.Server.siteData_Config().Name = null;
tmFileStorage.set_Path_SiteData();
Assert.IsTrue(tmFileStorage.Path_SiteData.contains(TMConsts.TM_SERVER_DEFAULT_NAME_SITEDATA));
tmFileStorage.Server.siteData_Config().Name = "aaa:bbb"; // will fail to create the SiteData folder and force memory mode
tmFileStorage.set_Path_SiteData();
Assert.IsNull(tmFileStorage.Path_SiteData);
}
public static TM_FileStorage delete_Database(this TM_FileStorage tmFileStorage)
{
tmFileStorage.assert_Not_Null()
.path_XmlDatabase().assert_Not_Null()
.assert_Is_Not_Equal_To(tmFileStorage.WebRoot);
if (tmFileStorage.path_XmlDatabase().dirExists()) // check if the folder exists
{
//Assert.IsNotEmpty(tmDatabase.path_XmlDatabase().files());
tmFileStorage.path_XmlDatabase().files(true).files_Attribute_ReadOnly_Remove(); // make all files writable
tmFileStorage.waitForComplete_Save_GuidanceItemsCache();
tmFileStorage.clear_GuidanceItemsCache();
Files.deleteFolder(tmFileStorage.path_XmlDatabase(), true); // delete all files recusively
tmFileStorage.path_XmlDatabase().folder_Wait_For_Deleted();
tmFileStorage.path_XmlDatabase().assert_Folder_Doesnt_Exist();
Assert.IsFalse(tmFileStorage.path_XmlDatabase().dirExists()); // ensure the deletion happened
Assert.IsEmpty(tmFileStorage.path_XmlDatabase().files());
Assert.IsEmpty(tmFileStorage.tmXmlDatabase().Cached_GuidanceItems);
Assert.IsFalse(tmFileStorage.getCacheLocation().fileExists());
"[Test][TM_Xml_Database][delete_Database]TM database files were deleted from: {0}".info(tmFileStorage.path_XmlDatabase());
}
return(tmFileStorage);
}
[Test] public void set_WebRoot()
{
TM_FileStorage.Custom_WebRoot = null;
var custom_WebRoot = "Custom_WebRoot".tempDir().assert_Folder_Exists();
var expected_Path_XmlDatabase = custom_WebRoot.pathCombine(@"App_Data\TeamMentor");
UserRole.Admin.assert();
TM_FileStorage.Custom_WebRoot.assert_Null();
var tmFileStorage = new TM_FileStorage(loadData: false);
tmFileStorage.webRoot().assert_Null();
tmFileStorage.set_WebRoot();
tmFileStorage.webRoot().assert_Not_Null()
.assert_Equal(AppDomain.CurrentDomain.BaseDirectory);
TM_FileStorage.Custom_WebRoot = custom_WebRoot;
tmFileStorage.webRoot().assert_Equal(AppDomain.CurrentDomain.BaseDirectory) // should still point to the AppDomain base directory
.assert_Not_Equal(custom_WebRoot);
tmFileStorage.using_Custom_WebRoot().assert_False(); // this should only be true when the values match
tmFileStorage.set_WebRoot() // set WebRoot
.webRoot().assert_Equals(custom_WebRoot); // and confirm its location
tmFileStorage.using_Custom_WebRoot().assert_True(); // now it should be true
tmFileStorage.path_XmlDatabase().assert_Null(); // confirm that not set
tmFileStorage.set_Path_XmlDatabase(); // this should set the TM_Xml_Database inside the Web_Root
tmFileStorage.path_XmlDatabase().contains(custom_WebRoot);
tmFileStorage.path_XmlDatabase().assert_Is_Equal_To(expected_Path_XmlDatabase); // check that the current Path_XmlDatabase matches the expected location
//reset values
TM_FileStorage.Custom_WebRoot = null;
tmFileStorage.set_WebRoot()
.webRoot().assert_Not_Equals(custom_WebRoot);
Files.delete_Folder_Recursively(custom_WebRoot).assert_True();
custom_WebRoot.assert_Folder_Doesnt_Exist();
}
[Test] public void set_Path_XmlDatabase__UsingFileStorage_On_Custom_WebRoot()
{
var tmFileStorage = new TM_FileStorage(false);
//Assert.AreEqual(tmFileStorage.WebRoot, AppDomain.CurrentDomain.BaseDirectory);
tmFileStorage.WebRoot = "_tmp_webRoot".tempDir().info();
tmFileStorage.WebRoot.delete_Folder();
Assert.IsFalse(tmFileStorage.WebRoot.dirExists());
tmFileStorage.set_Path_XmlDatabase();
Assert.IsTrue(tmFileStorage.path_XmlDatabase().dirExists(), "db ctor should create a library folder");
var usingAppDataFolder = TM_Status.Current.TM_Database_Location_Using_AppData;
"*** DB path: {0}".info(tmFileStorage.path_XmlDatabase());
"*** Lib path: {0}".info(tmFileStorage.Path_XmlLibraries);
"*** Current WebRoot: {0}".debug(tmFileStorage.WebRoot);
"*** Current WebRoot exists: {0}".debug(tmFileStorage.WebRoot.dirExists());
"*** TM_Status.Current.TM_Database_Location_Using_AppData: {0}".debug(TM_Status.Current.TM_Database_Location_Using_AppData);
Assert.AreEqual(usingAppDataFolder, tmFileStorage.WebRoot.dirExists(), "db ctor should not create a Web Root (if it doesn't exist)");
Assert.AreEqual(usingAppDataFolder, tmFileStorage.path_XmlDatabase().contains("App_Data"));
Assert.AreEqual(usingAppDataFolder, tmFileStorage.path_XmlDatabase().contains(tmFileStorage.WebRoot));
Assert.AreEqual(usingAppDataFolder, tmFileStorage.path_XmlDatabase().contains(PublicDI.config.O2TempDir));
tmFileStorage.delete_Database();
Assert.AreEqual(usingAppDataFolder, tmFileStorage.WebRoot.dirExists(), "if not usingAppDataFolder the TM_Server.WebRoot shouldn't exist");
Assert.IsFalse(tmFileStorage.path_XmlDatabase().dirExists(), "should had been deleted");
}
[Test] public void tm_Server_Load_UsingFileStorage()
{
var tmFileStorage = new TM_FileStorage(false);
var baseReadOnlyDir = "_tmp_webRoot".tempDir();
var webRootVirualPath = @"site\wwwroot"; // simulates use of AppData
tmFileStorage.WebRoot = baseReadOnlyDir.pathCombine(webRootVirualPath).createDir();
tmFileStorage.set_Path_XmlDatabase()
.set_Path_UserData()
.tmServer_Load();
var tmServerFile = tmFileStorage.tmServer_Location();
var expectedLocation = tmFileStorage.Path_XmlDatabase.pathCombine(TMConsts.TM_SERVER_FILENAME);
Assert.IsNotNull(tmFileStorage.path_XmlDatabase());
Assert.IsTrue(TM_Status.Current.TM_Database_Location_Using_AppData);
Assert.NotNull(tmFileStorage.Server);
Assert.IsTrue(tmServerFile.fileExists());
Assert.AreEqual(tmServerFile, expectedLocation);
// Assert.Ignore("TO FIX (Refactor Side Effect");
// Assert.Ignore("TO FIX (Refactor Side Effect");
var tmServer_withDefaultData = new TM_Server().setDefaultData();
Assert.AreEqual(tmFileStorage.Server.toXml(), tmServer_withDefaultData.toXml());
//make a change, saved it and ensure it gets loaded ok
var tmpName1 = 10.randomLetters();
var tmpName2 = 10.randomLetters();
tmFileStorage.Server.UserData_Configs.first().Name = tmpName1;
tmFileStorage.tmServer_Save();
tmFileStorage.Server.UserData_Configs.first().Name = tmpName2;
tmFileStorage.tmServer_Load();
Assert.AreEqual(tmFileStorage.Server.UserData_Configs.first().Name, tmpName1);
Assert.AreNotEqual(tmFileStorage.Server.toXml(), tmServer_withDefaultData.toXml());
//Try loading up an corrupted tmServer (whcih will default to load a default TM_Server
"aaaa".saveAs(tmServerFile);
tmFileStorage.tmServer_Load();
Assert.AreNotEqual(tmFileStorage.Server.UserData_Configs.first().Name, tmpName1);
Assert.AreEqual(tmFileStorage.Server.toXml(), tmServer_withDefaultData.toXml());
Files.deleteFolder(baseReadOnlyDir, true);
Assert.IsFalse(baseReadOnlyDir.dirExists());
//tmXmlDatabase.delete_Database();
}
[Test] public void set_Path_XmlDatabase__UsingFileStorage()
{
var tmFileStorage = new TM_FileStorage();
var tmXmlDatabase = tmFileStorage.TMXmlDatabase;
tmFileStorage.set_Path_XmlDatabase();
Assert.AreEqual(tmXmlDatabase, TM_Xml_Database.Current);
Assert.IsTrue(tmXmlDatabase.usingFileStorage());
Assert.IsNotNull(tmFileStorage.path_XmlDatabase());
tmFileStorage.delete_Database();
}
public static bool loadDataIntoMemory(this TM_FileStorage tmFileStorage)
{
if (tmFileStorage.path_XmlDatabase().dirExists().isFalse())
{
"[TM_Xml_Database] in loadDataIntoMemory, provided pathXmlDatabase didn't exist: {0}".error(tmFileStorage.path_XmlDatabase());
return(false);
}
tmFileStorage.loadLibraryDataFromDisk();
//tmXmlDatabase.setupGitSupport();
//tmXmlDatabase.UserData.loadTmUserData();
return(true);
}
[Test] public void set_Path_UserData()
{
var tmFileStorage = new TM_FileStorage();
var expectedPath = tmFileStorage.path_XmlDatabase().pathCombine(TMConsts.TM_SERVER_DEFAULT_NAME_USERDATA);
tmFileStorage.set_Path_UserData();
var userData = tmFileStorage.UserData;
//Assert.NotNull (tmServer);
Assert.NotNull(userData);
Assert.AreEqual(tmFileStorage.Path_UserData, expectedPath);
Assert.True(tmFileStorage.Path_UserData.dirExists());
// try with a different Name value
var tempName = 10.randomLetters();
tmFileStorage.Server.userData_Config().Name = tempName;
tmFileStorage.set_Path_UserData();
Assert.IsTrue(tmFileStorage.Path_UserData.contains(tempName));
tmFileStorage.delete_Database();
Assert.False(tmFileStorage.Path_UserData.dirExists());
//check bad data handling
tmFileStorage.Server.userData_Config().Name = null;
tmFileStorage.set_Path_UserData();
Assert.IsTrue(tmFileStorage.Path_UserData.contains(TMConsts.TM_SERVER_DEFAULT_NAME_USERDATA));
tmFileStorage.Server.userData_Config().Name = "aaa:bbb"; // will fail to create the UserData folder and force memory mode
tmFileStorage.set_Path_UserData();
Assert.IsNotNull(tmFileStorage.UserData);
Assert.IsNull(tmFileStorage.Path_UserData);
//test nulls
tmFileStorage.Server = null;
tmFileStorage.UserData = null;
tmFileStorage.TMXmlDatabase = null;
tmFileStorage.set_Path_UserData();
Assert.IsNull(tmFileStorage.Path_UserData);
//Assert.IsNull (new TM_FileStorage(false).set_Path_UserData().Path_UserData);
}
[Test] public void set_Path_XmlDatabase__In_Memory()
{
var tmFileStorage = new TM_FileStorage(false);
var tmXmlDatabase = tmFileStorage.TMXmlDatabase;
Assert.AreEqual(tmFileStorage, tmFileStorage.set_Path_XmlDatabase());
Assert.AreEqual(tmXmlDatabase, TM_Xml_Database.Current);
Assert.IsNull(tmFileStorage.path_XmlDatabase());
Assert.IsFalse(tmXmlDatabase.usingFileStorage());
var tmXmlDatabase2 = new TM_Xml_Database();
Assert.AreNotEqual(tmXmlDatabase, tmXmlDatabase2, "A new tmXmlDatabase1 should had been created");
Assert.AreEqual(tmXmlDatabase2, TM_Xml_Database.Current);
}
[Test] public void set_Path_XmlLibraries()
{
var tmFileStorage = new TM_FileStorage(false);
TMConfig.Current = null;
//this is the sequence that needs to be loaded in order to have a Path for Xml Libraries
tmFileStorage.set_WebRoot()
.set_Path_XmlDatabase()
.tmServer_Load()
.set_Path_UserData() //
.tmConfig_Load() //
.set_Path_XmlLibraries();
Assert.NotNull(tmFileStorage.path_XmlDatabase());
Assert.NotNull(tmFileStorage.path_XmlLibraries());
Assert.IsTrue(tmFileStorage.path_XmlDatabase().dirExists());
Assert.IsTrue(tmFileStorage.path_XmlLibraries().dirExists());
Assert.NotNull(TMConfig.Current);
//test nulls
tmFileStorage.Path_XmlLibraries = null;
//in the scenarios below the tmFileStorage.Path_XmlLibraries should not be set
if (TMConfig.Current.notNull())
{
TMConfig.Current.TMSetup = null;
}
tmFileStorage.set_Path_XmlLibraries();
TMConfig.Current = null;
tmFileStorage.set_Path_XmlLibraries();
Assert.IsNull(tmFileStorage.Path_XmlLibraries);
//tmXmlDatabase.delete_Database();
//TMConfig.Current = new TMConfig();
}
public void Application_Start()
{
UserGroup.Admin.assert(); // impersonate an admin to load the database
"[TM_StartUp] Application Start".info();
TmFileStorage = new TM_FileStorage(); // this will trigger the load of all TM_Xml_Database data
TmFileStorage.UserData.createDefaultAdminUser(); // ensures that there is an valid admin
TrackingApplication = new Tracking_Application(TmFileStorage.path_XmlDatabase()); // Enabled Application Tracking
TM_REST.SetRouteTable(); // Set REST routes
MVC5.MapDefaultRoutes(); // Map MVC 5 routes
TrackingApplication.saveLog(); // save log
UserGroup.None.assert(); // revert admin user impersonation
}
[Test] public void set_Path_XmlDatabase__UsingFileStorage_On_AppData__without_Read_Privs()
{
var tmFileStorage = new TM_FileStorage(false);
var tmXmlDatabase = tmFileStorage.TMXmlDatabase;
var baseReadOnlyDir = "_tmp_webRoot".tempDir();
var webRootVirualPath = @"site\wwwroot"; // simulates use of AppData
tmFileStorage.WebRoot = baseReadOnlyDir.pathCombine(webRootVirualPath).createDir();
tmFileStorage.WebRoot.directoryInfo().deny_CreateDirectories_Users();
//var tmXmlDatabase = new TM_Xml_Database().useFileStorage(); // usually a true paramater will set UsingFileStorage to true
tmFileStorage.set_Path_XmlDatabase();
Assert.IsNull(tmFileStorage.path_XmlDatabase()); // if we can't write to the AppData folder then this value can't be set automatically
Assert.IsFalse(tmXmlDatabase.usingFileStorage()); // and the offline mode (i.e. UsingFileStorage = false) should be activated
Files.deleteFolder(baseReadOnlyDir, true);
Assert.IsFalse(baseReadOnlyDir.dirExists());
}
[Admin][Test] public void set_Path_XmlDatabase()
{
admin.assert();
var custom_WebRoot = TM_FileStorage.Custom_WebRoot = "Custom_WebRoot".tempDir().assert_Folder_Exists();
var tmFileStorage = new TM_FileStorage(loadData: false)
.set_WebRoot()
.set_Path_XmlDatabase();
var path_XmlDatabase = tmFileStorage.path_XmlDatabase().assert_Folder_Exists()
.assert_Contains(custom_WebRoot);
// check use of TM_FileStorage.Custom_Path_TM_Xml_Database
TM_FileStorage.Custom_Path_XmlDatabase.assert_Null();
TM_FileStorage.Custom_Path_XmlDatabase = 10.randomLetters(); // with a random value
tmFileStorage.set_Path_XmlDatabase()
.path_XmlDatabase().assert_Is_Equal_To(path_XmlDatabase); // this value should not be changed
var custom_Path_TM_Xml_Database = "Custom_Path_TM_Xml_Database".add_5_RandomLetters()
.inTempDir()
.assert_Folder_Doesnt_Exist();
TM_FileStorage.Custom_Path_XmlDatabase = custom_Path_TM_Xml_Database; // with a folder that doesn't exist
tmFileStorage.set_Path_XmlDatabase()
.path_XmlDatabase().assert_Is_Equal_To(path_XmlDatabase); // should still be unchanged
custom_Path_TM_Xml_Database.createDir().assert_Folder_Exists(); // create the folder
tmFileStorage.set_Path_XmlDatabase()
.path_XmlDatabase().assert_Is_Equal_To(custom_Path_TM_Xml_Database); // and the value should be set
Files.delete_Folder_Recursively(custom_Path_TM_Xml_Database).assert_True();
Files.delete_Folder_Recursively(custom_WebRoot).assert_True();
none.assert();
}
public void set_Default_Values()
{
var tmFileStorage = new TM_FileStorage(false);
var tmXmlDatabase = tmFileStorage.TMXmlDatabase;
var events = tmXmlDatabase.Events; // this value should not change
tmXmlDatabase.set_Default_Values();
Assert.NotNull(tmXmlDatabase);
Assert.IsEmpty(tmXmlDatabase.Cached_GuidanceItems);
Assert.IsEmpty(tmFileStorage.GuidanceItems_FileMappings);
Assert.IsEmpty(tmXmlDatabase.GuidanceExplorers_XmlFormat);
Assert.IsEmpty(tmXmlDatabase.VirtualArticles);
Assert.AreEqual(tmXmlDatabase.Events, events);
Assert.IsNull(tmFileStorage.path_XmlDatabase());
Assert.IsEmpty(tmFileStorage.GuidanceExplorers_Paths);
Assert.IsNull(tmFileStorage.Path_XmlLibraries);
Assert.IsNotNull(tmFileStorage.UserData);
Assert.IsNotNull(tmFileStorage.Server);
}
public static string getCacheLocation(this TM_FileStorage tmFileStorage) //, TM_Library library)
{
var pathXmlDatabase = tmFileStorage.path_XmlDatabase();
return(pathXmlDatabase.pathCombine("Cache_guidanceItems.cacheXml"));//.format(library.Caption));
}