public void AddRedirection_GetDestination_RemovePageFromRedirections_Clear()
{
ICacheProviderV30 prov = GetProvider();
Assert.IsNull(prov.GetRedirectionDestination("Page"), "No redirection should be in cache");
prov.AddRedirection("Page", "NS.OtherPage");
prov.AddRedirection("NS.OtherPage", "Page3");
prov.AddRedirection("ThirdPage", "Page");
Assert.AreEqual("NS.OtherPage", prov.GetRedirectionDestination("Page"), "Wrong destination");
Assert.AreEqual("Page3", prov.GetRedirectionDestination("NS.OtherPage"), "Wrong destination");
Assert.AreEqual("Page", prov.GetRedirectionDestination("ThirdPage"), "Wrong destination");
prov.RemovePageFromRedirections("Page");
Assert.IsNull(prov.GetRedirectionDestination("Page"), "No redirection should be in cache for Page");
Assert.AreEqual("Page3", prov.GetRedirectionDestination("NS.OtherPage"), "Wrong destination");
Assert.IsNull(prov.GetRedirectionDestination("Page"), "No redirection should be in cache for ThirdPage");
prov.ClearRedirections();
Assert.IsNull(prov.GetRedirectionDestination("Page"), "No redirection should be in cache");
Assert.IsNull(prov.GetRedirectionDestination("NS.OtherPage"), "No redirection should be in cache");
Assert.IsNull(prov.GetRedirectionDestination("Page"), "No redirection should be in cache");
}
public void CutCache()
{
ICacheProviderV30 prov = GetProvider();
PageInfo p1 = new PageInfo("Page1", MockPagesProvider(), DateTime.Now);
PageInfo p2 = new PageInfo("Page2", MockPagesProvider(), DateTime.Now);
PageInfo p3 = new PageInfo("Page3", MockPagesProvider(), DateTime.Now);
PageContent c1 = new PageContent(p1, "Page 1", "admin", DateTime.Now, "Comment", "Content", null, null);
PageContent c2 = new PageContent(p2, "Page 2", "user", DateTime.Now, "", "Blah", null, null);
PageContent c3 = new PageContent(p3, "Page 3", "admin", DateTime.Now, "", "Content", null, null);
Assert.AreEqual(0, prov.PageCacheUsage, "Wrong cache usage");
prov.SetPageContent(p1, c1);
prov.SetPageContent(p2, c2);
prov.SetPageContent(p3, c3);
prov.SetFormattedPageContent(p1, "Content 1");
prov.SetFormattedPageContent(p3, "Content 2");
prov.GetPageContent(p3);
Assert.AreEqual(3, prov.PageCacheUsage, "Wrong cache usage");
prov.CutCache(2);
Assert.AreEqual(1, prov.PageCacheUsage, "Wrong cache usage");
Assert.IsNotNull(prov.GetPageContent(p3), "GetPageContent should not return null");
Assert.IsNull(prov.GetPageContent(p2), "GetPageContent should not null");
Assert.IsNull(prov.GetPageContent(p1), "GetPageContent should not null");
Assert.IsNotNull(prov.GetFormattedPageContent(p3), "GetFormattedPageContent should not return null");
Assert.IsNull(prov.GetFormattedPageContent(p2), "GetFormattedPageContent should not null");
Assert.IsNull(prov.GetFormattedPageContent(p1), "GetFormattedPageContent should not null");
}
public void CancelEditingSession_IsPageBeingEdited()
{
ICacheProviderV30 prov = GetProvider();
prov.RenewEditingSession("Page", "User");
Assert.IsFalse(prov.IsPageBeingEdited("Page", "User"), "IsPageBeingEditing should return false");
Assert.IsTrue(prov.IsPageBeingEdited("Page", "User2"), "IsPageBeingEditing should return true");
prov.CancelEditingSession("Page", "User");
Assert.IsFalse(prov.IsPageBeingEdited("Page", "User"), "IsPageBeingEditing should return false");
Assert.IsFalse(prov.IsPageBeingEdited("Page", "User2"), "IsPageBeingEditing should return false");
prov.RenewEditingSession("Page", "User1");
prov.RenewEditingSession("Page", "User2");
prov.CancelEditingSession("Page", "User1");
Assert.IsTrue(prov.IsPageBeingEdited("Page", "User1"), "IsPageBeingEditing should return true");
Assert.IsFalse(prov.IsPageBeingEdited("Page", "User2"), "IsPageBeingEditing should return false");
prov.CancelEditingSession("Page", "User2");
Assert.IsFalse(prov.IsPageBeingEdited("Page", "User2"), "IsPageBeingEditing should return false");
}
public void SetFormattedPageContent_NullContent()
{
ICacheProviderV30 prov = GetProvider();
PageInfo p1 = new PageInfo("Page1", MockPagesProvider(), DateTime.Now);
prov.SetFormattedPageContent(p1, null);
}
public void Init()
{
ICacheProviderV30 prov = GetProvider();
prov.Init(MockHost(), "");
Assert.IsNotNull(prov.Information, "Information should not be null");
}
public void SetFormattedPageContent_NullContent()
{
ICacheProviderV30 prov = GetProvider();
PageInfo p1 = new PageInfo("Page1", MockPagesProvider(), DateTime.Now);
Assert.That(() => prov.SetFormattedPageContent(p1, null), Throws.ArgumentNullException);
}
public void SetPageContent_NullContent()
{
ICacheProviderV30 prov = GetProvider();
PageInfo p1 = new PageInfo("Page1", MockPagesProvider(), DateTime.Now);
PageContent c1 = new PageContent(p1, "Page 1", "admin", DateTime.Now, "Comment", "Content", null, null);
prov.SetPageContent(p1, null);
}
public void SetPageContent_NullPage()
{
ICacheProviderV30 prov = GetProvider();
PageInfo p1 = new PageInfo("Page1", MockPagesProvider(), DateTime.Now);
PageContent c1 = new PageContent(p1, "Page 1", "admin", DateTime.Now, "Comment", "Content", null, null);
Assert.That(() => prov.SetPageContent(null, c1), Throws.ArgumentNullException);
}
public void ClearPseudoCache()
{
ICacheProviderV30 prov = GetProvider();
prov.SetPseudoCacheValue("Test", "Value");
prov.SetPseudoCacheValue("222", "VVV");
prov.ClearPseudoCache();
Assert.IsNull(prov.GetPseudoCacheValue("Test"), "GetPseudoCacheValue should return null");
Assert.IsNull(prov.GetPseudoCacheValue("222"), "GetPseudoCacheValue should return null");
}
public void SetOnlineUsers_GetOnlineUsers()
{
ICacheProviderV30 prov = GetProvider();
prov.OnlineUsers = 100;
Assert.AreEqual(100, prov.OnlineUsers, "Wrong online users count");
prov.OnlineUsers++;
Assert.AreEqual(101, prov.OnlineUsers, "Wrong online users count");
prov.OnlineUsers--;
Assert.AreEqual(100, prov.OnlineUsers, "Wrong online users count");
}
public void RenewEditingSession_IsPageBeingEdited()
{
ICacheProviderV30 prov = GetProvider();
prov.RenewEditingSession("Page", "User");
Assert.IsFalse(prov.IsPageBeingEdited("Page", "User"), "IsPageBeingEditing should return false");
Assert.IsTrue(prov.IsPageBeingEdited("Page", "User2"), "IsPageBeingEditing should return true");
Assert.IsFalse(prov.IsPageBeingEdited("Page2", "User"), "IsPageBeingEditing should return false");
Assert.IsFalse(prov.IsPageBeingEdited("Page2", "User2"), "IsPageBeingEditing should return false");
// Wait for timeout to expire
System.Threading.Thread.Sleep(6500);
Assert.IsFalse(prov.IsPageBeingEdited("Page", "User2"), "IsPageBeingEdited should return false");
}
public void SetPseudoCacheValue_GetPseudoCacheValue()
{
ICacheProviderV30 prov = GetProvider();
prov.SetPseudoCacheValue("Name", "Value");
prov.SetPseudoCacheValue("Test", "Blah");
Assert.AreEqual("Value", prov.GetPseudoCacheValue("Name"), "Wrong pseudo-cache value");
Assert.AreEqual("Blah", prov.GetPseudoCacheValue("Test"), "Wrong pseudo-cache value");
Assert.IsNull(prov.GetPseudoCacheValue("Inexistent"), "Pseudo-cache value should be null");
prov.SetPseudoCacheValue("Name", null);
prov.SetPseudoCacheValue("Test", "");
Assert.IsNull(prov.GetPseudoCacheValue("Name"), "Pseudo-cache value should be null");
Assert.AreEqual("", prov.GetPseudoCacheValue("Test"), "Wrong pseudo-cache value");
}
public void WhosEditing()
{
ICacheProviderV30 prov = GetProvider();
prov.RenewEditingSession("Page", "User1");
prov.RenewEditingSession("Page", "User2");
Assert.AreEqual("", prov.WhosEditing("Inexistent"), "Wrong result (should be empty)");
Assert.AreEqual("User1", prov.WhosEditing("Page"), "Wrong user");
prov.CancelEditingSession("Page", "User1");
Assert.AreEqual("User2", prov.WhosEditing("Page"), "Wrong user");
prov.CancelEditingSession("Page", "User2");
Assert.AreEqual("", prov.WhosEditing("Page"), "Wrong user");
}
public void SetPageContent_GetPageContent()
{
ICacheProviderV30 prov = GetProvider();
PageInfo p1 = new PageInfo("Page1", MockPagesProvider(), DateTime.Now);
PageInfo p2 = new PageInfo("Page2", MockPagesProvider(), DateTime.Now);
PageContent c1 = new PageContent(p1, "Page 1", "admin", DateTime.Now, "Comment", "Content", new string[] { "test", "page" }, null);
PageContent c2 = new PageContent(p2, "Page 2", "user", DateTime.Now, "", "Blah", null, null);
PageContent c3 = new PageContent(p2, "Page 5", "john", DateTime.Now, "Comm.", "Blah 222", null, "Description");
Assert.AreEqual(0, prov.PageCacheUsage, "Wrong cache usage");
prov.SetPageContent(p1, c1);
prov.SetPageContent(p2, c2);
prov.SetPageContent(p2, c3);
Assert.AreEqual(2, prov.PageCacheUsage, "Wrong cache usage");
PageContent res = prov.GetPageContent(p1);
Assert.AreEqual(c1.PageInfo, res.PageInfo, "Wrong page info");
Assert.AreEqual(c1.Title, res.Title, "Wrong title");
Assert.AreEqual(c1.User, res.User, "Wrong user");
Assert.AreEqual(c1.LastModified, res.LastModified, "Wrong date/time");
Assert.AreEqual(c1.Comment, res.Comment, "Wrong comment");
Assert.AreEqual(c1.Content, res.Content, "Wrong content");
Assert.AreEqual(2, c1.Keywords.Length, "Wrong keyword count");
Assert.AreEqual("test", c1.Keywords[0], "Wrong keyword");
Assert.AreEqual("page", c1.Keywords[1], "Wrong keyword");
Assert.IsNull(c1.Description, "Description should be null");
res = prov.GetPageContent(p2);
Assert.AreEqual(c3.PageInfo, res.PageInfo, "Wrong page info");
Assert.AreEqual(c3.Title, res.Title, "Wrong title");
Assert.AreEqual(c3.User, res.User, "Wrong user");
Assert.AreEqual(c3.LastModified, res.LastModified, "Wrong date/time");
Assert.AreEqual(c3.Comment, res.Comment, "Wrong comment");
Assert.AreEqual(c3.Content, res.Content, "Wrong content");
Assert.AreEqual(0, c3.Keywords.Length, "Keywords should be empty");
Assert.AreEqual("Description", c3.Description, "Wrong description");
Assert.IsNull(prov.GetPageContent(new PageInfo("Blah", MockPagesProvider(), DateTime.Now)), "GetPageContent should return null");
}
public void SetFormattedPageContent_GetFormattedPageContent()
{
ICacheProviderV30 prov = GetProvider();
PageInfo p1 = new PageInfo("Page1", MockPagesProvider(), DateTime.Now);
PageInfo p2 = new PageInfo("Page2", MockPagesProvider(), DateTime.Now);
Assert.AreEqual(0, prov.PageCacheUsage, "Wrong cache usage");
prov.SetFormattedPageContent(p1, "Content 1");
prov.SetFormattedPageContent(p2, "Content 2");
prov.SetFormattedPageContent(p1, "Content 1 mod");
Assert.AreEqual(0, prov.PageCacheUsage, "Wrong cache usage");
Assert.AreEqual("Content 1 mod", prov.GetFormattedPageContent(p1), "Wrong content");
Assert.AreEqual("Content 2", prov.GetFormattedPageContent(p2), "Wrong content");
Assert.IsNull(prov.GetFormattedPageContent(new PageInfo("Blah", MockPagesProvider(), DateTime.Now)), "GetFormattedPageContent should return null");
}
public void SetFormattedPageContent_NullPage()
{
ICacheProviderV30 prov = GetProvider();
prov.SetFormattedPageContent(null, "Content");
}
public void Init_NullConfig()
{
ICacheProviderV30 prov = GetProvider();
prov.Init(MockHost(), null);
}
public void RemovePageFromRedirections_InvalidName(string name)
{
ICacheProviderV30 prov = GetProvider();
prov.RemovePageFromRedirections(name);
}
public void GetRedirectionDestination_InvalidSource(string src)
{
ICacheProviderV30 prov = GetProvider();
prov.GetRedirectionDestination(src);
}
public void AddRedirection_InvalidParameters(string src, string dest)
{
ICacheProviderV30 prov = GetProvider();
prov.AddRedirection(src, dest);
}
public void WhosEditing_InvalidPage(string p)
{
ICacheProviderV30 prov = GetProvider();
prov.WhosEditing(p);
}
public void RemovePageContent_NullPage()
{
ICacheProviderV30 prov = GetProvider();
prov.RemovePage(null);
}
public void GetPseudoCacheValue_InvalidName(string n)
{
ICacheProviderV30 prov = GetProvider();
prov.GetPseudoCacheValue(n);
}
public void CancelEditingSession_InvalidUser(string u)
{
ICacheProviderV30 prov = GetProvider();
prov.CancelEditingSession("Page", u);
}
public void CancelEditingSession_InvalidPage(string p)
{
ICacheProviderV30 prov = GetProvider();
prov.CancelEditingSession(p, "User");
}
public void IsPageBeingEdited_InvalidUser(string u)
{
ICacheProviderV30 prov = GetProvider();
prov.IsPageBeingEdited("Page", u);
}
public void IsPageBeingEdited_InvalidPage(string p)
{
ICacheProviderV30 prov = GetProvider();
prov.IsPageBeingEdited(p, "User");
}
public void CutCache_InvalidSize(int s)
{
ICacheProviderV30 prov = GetProvider();
prov.CutCache(s);
}
/// <summary>
/// Loads Providers from an assembly.
/// </summary>
/// <param name="assembly">The path of the Assembly to load the Providers from.</param>
/// <param name="users">The Users Providers.</param>
/// <param name="files">The Files Providers.</param>
/// <param name="pages">The Pages Providers.</param>
/// <param name="formatters">The Formatter Providers.</param>
/// <param name="cache">The Cache Providers.</param>
/// <remarks>The Components returned are <b>not</b> initialized.</remarks>
public static void LoadFrom(string assembly, out IUsersStorageProviderV30[] users, out IPagesStorageProviderV30[] pages,
out IFilesStorageProviderV30[] files, out IFormatterProviderV30[] formatters, out ICacheProviderV30[] cache)
{
Assembly asm = null;
try
{
//asm = Assembly.LoadFile(assembly);
// This way the DLL is not locked and can be deleted at runtime
asm = Assembly.Load(LoadAssemblyFromProvider(Path.GetFileName(assembly)));
}
catch
{
files = new IFilesStorageProviderV30[0];
users = new IUsersStorageProviderV30[0];
pages = new IPagesStorageProviderV30[0];
formatters = new IFormatterProviderV30[0];
cache = new ICacheProviderV30[0];
Log.LogEntry("Unable to load assembly " + Path.GetFileNameWithoutExtension(assembly), EntryType.Error, Log.SystemUsername);
return;
}
Type[] types = null;
try
{
types = asm.GetTypes( );
}
catch (ReflectionTypeLoadException)
{
files = new IFilesStorageProviderV30[0];
users = new IUsersStorageProviderV30[0];
pages = new IPagesStorageProviderV30[0];
formatters = new IFormatterProviderV30[0];
cache = new ICacheProviderV30[0];
Log.LogEntry("Unable to load providers from (probably v2) assembly " + Path.GetFileNameWithoutExtension(assembly), EntryType.Error, Log.SystemUsername);
return;
}
List <IUsersStorageProviderV30> urs = new List <IUsersStorageProviderV30>( );
List <IPagesStorageProviderV30> pgs = new List <IPagesStorageProviderV30>( );
List <IFilesStorageProviderV30> fls = new List <IFilesStorageProviderV30>( );
List <IFormatterProviderV30> frs = new List <IFormatterProviderV30>( );
List <ICacheProviderV30> che = new List <ICacheProviderV30>( );
Type[] interfaces;
for (int i = 0; i < types.Length; i++)
{
// Avoid to load abstract classes as they cannot be instantiated
if (types[i].IsAbstract)
{
continue;
}
interfaces = types[i].GetInterfaces( );
foreach (Type iface in interfaces)
{
if (iface == typeof(IUsersStorageProviderV30))
{
IUsersStorageProviderV30 tmpu = CreateInstance <IUsersStorageProviderV30>(asm, types[i]);
if (tmpu != null)
{
urs.Add(tmpu);
Collectors.FileNames[tmpu.GetType( ).FullName] = assembly;
}
}
if (iface == typeof(IPagesStorageProviderV30))
{
IPagesStorageProviderV30 tmpp = CreateInstance <IPagesStorageProviderV30>(asm, types[i]);
if (tmpp != null)
{
pgs.Add(tmpp);
Collectors.FileNames[tmpp.GetType( ).FullName] = assembly;
}
}
if (iface == typeof(IFilesStorageProviderV30))
{
IFilesStorageProviderV30 tmpd = CreateInstance <IFilesStorageProviderV30>(asm, types[i]);
if (tmpd != null)
{
fls.Add(tmpd);
Collectors.FileNames[tmpd.GetType( ).FullName] = assembly;
}
}
if (iface == typeof(IFormatterProviderV30))
{
IFormatterProviderV30 tmpf = CreateInstance <IFormatterProviderV30>(asm, types[i]);
if (tmpf != null)
{
frs.Add(tmpf);
Collectors.FileNames[tmpf.GetType( ).FullName] = assembly;
}
}
if (iface == typeof(ICacheProviderV30))
{
ICacheProviderV30 tmpc = CreateInstance <ICacheProviderV30>(asm, types[i]);
if (tmpc != null)
{
che.Add(tmpc);
Collectors.FileNames[tmpc.GetType( ).FullName] = assembly;
}
}
}
}
users = urs.ToArray( );
pages = pgs.ToArray( );
files = fls.ToArray( );
formatters = frs.ToArray( );
cache = che.ToArray( );
}
public void Init_NullHost()
{
ICacheProviderV30 prov = GetProvider();
prov.Init(null, "");
}
