public void TestFirstInitialVersionSetToActiveOnPublishAndReadOnly()
{
LocalPolicyCache cache = new LocalPolicyCache(m_testFiles.RootPath, false);
string newpolicyset = Guid.NewGuid().ToString();
IPolicySetCache set = cache.NewPolicySet(newpolicyset);
IPolicySetVersionCache ver1 = set.NewVersion("ver1");
IPolicyCatalogueCache masterCat = ver1.NewMasterCatalogue("<cat>the master</cat>");
IPolicyLanguageTableCache master_eng = masterCat.NewLanguage("en", "<lang>english</lang>", true);
IPolicyLanguageTableCache master_fr = masterCat.NewLanguage("fr", "<lang>french</lang>", true);
ICompiledPolicySetCache cps_1 = ver1.NewCompiledPolicySet("stmp", "client", "<cps>stuff</cps>", "<obj>stuff</obj>");
ICompiledPolicySetCache cps_2 = ver1.NewCompiledPolicySet("stmp", "server", "<cps>stuff</cps>", "<obj>stuff</obj>");
IPolicyLanguageTableCache cps_1_eng = cps_1.NewLanguage("en", "<lang>english</lang>", true);
IPolicyLanguageTableCache cps_1_fr = cps_1.NewLanguage("fr", "<lang>french</lang>", true);
IPolicyLanguageTableCache cps_2_eng = cps_2.NewLanguage("en", "<lang>english</lang>", true);
IPolicyLanguageTableCache cps_2_fr = cps_2.NewLanguage("fr", "<lang>french</lang>", true);
Assert.AreEqual(ver1.Status, PolicySetVersionStatus.InProgress);
set.Save(SaveOption.Publish);
Assert.AreEqual(ver1.Status, PolicySetVersionStatus.Enabled);
Assert.IsTrue(ver1.Latest);
set.Save(SaveOption.SaveNew);
CacheTestHelper.TestVersionIsReadOnly(ver1);
IPolicySetVersionCache ver2 = set.LatestVersion;
Assert.AreEqual(ver2.Status, PolicySetVersionStatus.InProgress);
Assert.IsTrue(ver2.Latest);
Assert.AreNotEqual(ver1.Version, ver2.Version);
Assert.AreEqual(ver1.Content, ver2.Content);
Assert.AreEqual(ver1.MasterCatalogue.Content, ver2.MasterCatalogue.Content);
Assert.AreEqual(ver1.MasterCatalogue.Languages.Count, ver2.MasterCatalogue.Languages.Count);
for (int i = 0; i < ver1.MasterCatalogue.Languages.Count; i++)
Assert.AreEqual(ver1.MasterCatalogue.Languages[i].Content, ver2.MasterCatalogue.Languages[i].Content);
Assert.AreEqual(ver1.CompiledPolicySets.Count, ver2.CompiledPolicySets.Count);
for (int i = 0; i < ver1.CompiledPolicySets.Count; i++)
{
Assert.AreEqual(ver1.CompiledPolicySets[i].Channel, ver2.CompiledPolicySets[i].Channel);
Assert.AreEqual(ver1.CompiledPolicySets[i].Target, ver2.CompiledPolicySets[i].Target);
Assert.AreEqual(ver1.CompiledPolicySets[i].Content, ver2.CompiledPolicySets[i].Content);
Assert.AreEqual(ver1.CompiledPolicySets[i].ObjectReferences, ver2.CompiledPolicySets[i].ObjectReferences);
Assert.AreEqual(ver1.CompiledPolicySets[i].Languages.Count, ver2.CompiledPolicySets[i].Languages.Count);
for (int j = 0; j < ver1.CompiledPolicySets[i].Languages.Count; j++)
Assert.AreEqual(ver1.CompiledPolicySets[i].Languages[j].Content, ver2.CompiledPolicySets[i].Languages[j].Content);
}
}
public void TestFirstInitialVersionOfPolicySetIsInProgress()
{
LocalPolicyCache cache = new LocalPolicyCache(m_testFiles.RootPath, false);
string newpolicyset = Guid.NewGuid().ToString();
IPolicySetCache set = cache.NewPolicySet(newpolicyset);
IPolicySetVersionCache ver1 = set.NewVersion("ver1");
Assert.AreEqual(ver1.Status, PolicySetVersionStatus.InProgress);
set.Save(SaveOption.SaveOnly);
Assert.AreEqual(ver1.Status, PolicySetVersionStatus.InProgress);
}
public void Test02_GetPolicySet_MultiplePolicyLocation_NonRuntime()
{
string policyA = Path.Combine(LocalPolicyCache.LOCAL_BASEPATH_USER, "PolicySetA.policy");
try
{
File.Copy(Workshare.TestUtils.TestFileUtils.MakeRootPathAbsolute(@"\projects\Hygiene\src\PolicySuite.Tests\TestFiles\PolicySetA.policy"),
policyA);
Assert.IsTrue(File.Exists(policyA));
LocalPolicyCache plc = new LocalPolicyCache(false);
Assert.IsTrue(1 == plc.PolicySets.Count, "Incorrect number of policy sets were found.");
}
finally
{
if (File.Exists(policyA))
{
File.Delete(policyA);
Assert.IsFalse(File.Exists(policyA));
}
}
}
public void TestNonRuntimePolicyNotLoadableFromRuntimeCache()
{
string policy = Path.Combine(LocalPolicyCache.LOCAL_BASEPATH_COMMON, "PolicySetA.policy");
try
{
File.Copy(TestUtils.TestFileUtils.MakeRootPathAbsolute(@"\projects\Hygiene\src\PolicySuite.Tests\TestFiles\PolicySetA.policy"),
policy);
Assert.IsTrue(File.Exists(policy));
LocalPolicyCache cache = new LocalPolicyCache(true);
Assert.AreEqual(0, cache.PolicySets.Count,
"We should still not be able to see policy files in the runtime cache.");
Assert.IsNull(cache.GetPolicySet(policy), "It should not be possible to load a policy into this cache, so this should return null.");
}
finally
{
if (File.Exists(policy))
{
File.Delete(policy);
Assert.IsFalse(File.Exists(policy));
}
}
}
public void TestDetectDeletedAndOutOfDate_RemoveAndAddFile()
{
PollingInterval.Interval = new TimeSpan(0, 0, 0);
using (TempPolicyFolder folder = new TempPolicyFolder(Workshare.TestUtils.TestFileUtils.MakeRootPathAbsolute(@"\projects\Hygiene\Policies\p5default.runtimepolicy")))
{
Assert.AreEqual(1, folder.Files.Length, "We have only put the p5 default policy there.");
string policyFile = folder.Files[0];
LocalPolicyCache lpc = new LocalPolicyCache(folder.Path, true);
Assert.AreEqual(1, lpc.PolicySets.Count, "We have only put the p5 default policy there so the cache should only load one.");
File.Delete(policyFile);
Assert.AreEqual(1, lpc.PolicySets.Count, "The update should not happen yet.");
lpc.AttemptRefresh();
Assert.AreEqual(0, lpc.PolicySets.Count, "We killed the file, the policy set should not be there anymore.");
File.Copy(Workshare.TestUtils.TestFileUtils.MakeRootPathAbsolute(@"\projects\Hygiene\Policies\p5default.runtimepolicy"), policyFile);
lpc.AttemptRefresh();
Assert.AreEqual(1, lpc.PolicySets.Count, "We replaced the file so this should be good again.");
}
PollingInterval.Interval = new TimeSpan(0, 0, 10);
}
public void TestReloadsChangedPolicies()
{
LocalPolicyCache lpc = new LocalPolicyCache(m_testFiles.RootPath, false);
PollingInterval.Interval = new TimeSpan(0, 0, 0);
Assert.AreEqual(lpc.PolicySets.Count, 2);
IPolicySetCache lps = lpc.GetPolicySet("policyset2");
LocalPolicySetVersionCache ver = lps.LatestVersion as LocalPolicySetVersionCache;
Assert.AreEqual(ver.ID, 1);
LocalPolicyCatalogueCache master = ver.MasterCatalogue as LocalPolicyCatalogueCache;
Assert.AreEqual(master.ID, 2);
IPolicySetVersionCache lpsv = lps.LatestVersion;
Assert.AreEqual("this is the content of the policyset xml", lpsv.Content);
System.Threading.Thread.Sleep(500); // make sure the timestamp is different when we change the file
UpdatePolicy2();
lps = lpc.GetPolicySet("policyset2");
ver = lps.LatestVersion as LocalPolicySetVersionCache;
Assert.AreEqual(ver.ID, 1);
master = ver.MasterCatalogue as LocalPolicyCatalogueCache;
Assert.AreEqual(master.ID, 2);
lpsv = lps.LatestVersion;
Assert.AreEqual("this is the new content of the policyset xml", lpsv.Content);
PollingInterval.Interval = new TimeSpan(0, 0, 10);
}
public void TestModifiedFlag()
{
LocalPolicyCache lpc = new LocalPolicyCache(m_testFiles.RootPath, false);
IPolicySetCache lps = lpc.GetPolicySet("policyset2");
LocalPolicySetVersionCache ver = lps.LatestVersion as LocalPolicySetVersionCache;
Assert.IsFalse(ver.Modified);
ver.Content = "changes";
Assert.IsTrue(ver.Modified);
}
public void TestIDSetForEachObject()
{
LocalPolicyCache lpc = new LocalPolicyCache(m_testFiles.RootPath, false);
IPolicySetCache lps = lpc.GetPolicySet("policyset2");
LocalPolicySetVersionCache ver = lps.LatestVersion as LocalPolicySetVersionCache;
Assert.AreEqual(ver.ID, 1);
LocalPolicyCatalogueCache master = ver.MasterCatalogue as LocalPolicyCatalogueCache;
Assert.AreEqual(master.ID, 2);
LocalPolicyLanguageTableCache lang_master_en = master.Languages[0] as LocalPolicyLanguageTableCache;
LocalPolicyLanguageTableCache lang_master_jp = master.Languages[1] as LocalPolicyLanguageTableCache;
Assert.AreEqual(lang_master_en.ID, 3);
Assert.AreEqual(lang_master_jp.ID, 4);
LocalPolicyCatalogueCache refcat = ver.ReferenceCatalogues[0] as LocalPolicyCatalogueCache;
Assert.AreEqual(refcat.ID, 5);
LocalPolicyLanguageTableCache lang_ref_en = refcat.Languages[0] as LocalPolicyLanguageTableCache;
LocalPolicyLanguageTableCache lang_ref_jp = refcat.Languages[1] as LocalPolicyLanguageTableCache;
Assert.AreEqual(lang_ref_en.ID, 6);
Assert.AreEqual(lang_ref_jp.ID, 7);
LocalCompiledPolicySetCache cps = ver.CompiledPolicySets[0] as LocalCompiledPolicySetCache;
Assert.AreEqual(cps.ID, 8);
LocalPolicyLanguageTableCache lang_cps_en = cps.Languages[0] as LocalPolicyLanguageTableCache;
LocalPolicyLanguageTableCache lang_cps_jp = cps.Languages[1] as LocalPolicyLanguageTableCache;
Assert.AreEqual(lang_cps_en.ID, 9);
Assert.AreEqual(lang_cps_jp.ID, 10);
}
public void TestCreateDefaultPolicyPack()
{
LocalPolicyCache cache = new LocalPolicyCache(m_testFiles.RootPath, false);
LocalPolicySetCache set = cache.NewPolicySet("P5-default") as LocalPolicySetCache;
Assert.IsNotNull(set);
string policy = m_testFiles.GetXmlFromResource(this.GetType(), "Workshare.Policy.ClientCache.Tests.TestFiles.Default.p5-policy.xml");
string catalogue = m_testFiles.GetXmlFromResource(this.GetType(), "Workshare.Policy.ClientCache.Tests.TestFiles.Default.p5-cat.xml");
string language = m_testFiles.GetXmlFromResource(this.GetType(), "Workshare.Policy.ClientCache.Tests.TestFiles.Default.p5-en.xml");
string smtp_client_policy = m_testFiles.GetXmlFromResource(this.GetType(), "Workshare.Policy.ClientCache.Tests.TestFiles.Default.p5_beta_client_rules.xml");
string smtp_client_objects = m_testFiles.GetXmlFromResource(this.GetType(), "Workshare.Policy.ClientCache.Tests.TestFiles.Default.p5_beta_client_objects.xml");
string smtp_server_policy = m_testFiles.GetXmlFromResource(this.GetType(), "Workshare.Policy.ClientCache.Tests.TestFiles.Default.p5_beta_server_smtp_rules.xml");
string smtp_server_objects = m_testFiles.GetXmlFromResource(this.GetType(), "Workshare.Policy.ClientCache.Tests.TestFiles.Default.p5_beta_server_smtp_objects.xml");
string http_server_policy = m_testFiles.GetXmlFromResource(this.GetType(), "Workshare.Policy.ClientCache.Tests.TestFiles.Default.p5_beta_server_http_rules.xml");
string http_server_objects = m_testFiles.GetXmlFromResource(this.GetType(), "Workshare.Policy.ClientCache.Tests.TestFiles.Default.p5_beta_server_http_objects.xml");
string file_client_policy = m_testFiles.GetXmlFromResource(this.GetType(), "Workshare.Policy.ClientCache.Tests.TestFiles.Default.p5_beta_client_activecontent_rules.xml");
string file_client_objects = m_testFiles.GetXmlFromResource(this.GetType(), "Workshare.Policy.ClientCache.Tests.TestFiles.Default.p5_beta_client_activecontent_objects.xml");
string smart_tag_policy = m_testFiles.GetXmlFromResource(this.GetType(), "Workshare.Policy.ClientCache.Tests.TestFiles.Default.p5_beta_client_smarttag_policy.xml");
LocalPolicySetVersionCache version = set.LatestVersion as LocalPolicySetVersionCache;
version.Content = policy;
LocalPolicyCatalogueCache masterCat = version.NewMasterCatalogue(catalogue) as LocalPolicyCatalogueCache;
masterCat.NewLanguage("en", language, true);
version.NewCompiledPolicySet("SMTP", "Client", smtp_client_policy, smtp_client_objects);
version.NewCompiledPolicySet("SMTP", "Server", smtp_server_policy, smtp_server_objects);
version.NewCompiledPolicySet("HTTP", "Server", http_server_policy, http_server_objects);
version.NewCompiledPolicySet("ActiveContent", "Client", file_client_policy, file_client_objects);
version.NewCompiledPolicySet("SmartTagActiveContent", "Client", smart_tag_policy, string.Empty);
string p5policyfile = System.IO.Path.GetTempFileName();
set.ExportCompiledPolicySet(p5policyfile);
LocalPolicySetCache newset = cache.GetPolicySet("P5-default") as LocalPolicySetCache;
Assert.IsNotNull(newset);
//System.IO.File.Copy(p5policyfile, Workshare.TestUtils.TestFileUtils.MakeRootPathAbsolute(@"\Projects\Hygiene\Policies\p5default.policy"), true);
System.IO.File.Delete(p5policyfile);
System.IO.File.Delete(m_testFiles.RootPath + "P5-default" + Definitions.PolicyFileExtension);
}
public void TestAddSuperSetAndSave()
{
string policySet3 = m_testFiles.RootPath + "policyset3" + Definitions.PolicyFileExtension;
System.IO.File.Copy(m_testFiles.PolicySet1, policySet3, true);
LocalPolicyCache cache = new LocalPolicyCache(m_testFiles.RootPath, false);
LocalPolicySetCache lps = cache.GetPolicySet("policyset3") as LocalPolicySetCache;
IPolicySetVersionCache lpsv_old = lps.LatestVersion;
string policyset1_v4 = m_testFiles.GetXmlFromResource(this.GetType(), "Workshare.Policy.ClientCache.Tests.TestFiles.TestPolicySet_1.4.0.version");
IPolicySetVersionCache lpsv_new = lps.NewSuperSet(policyset1_v4, PolicySetVersionStatus.InProgress);
Assert.IsFalse(lpsv_old.Latest);
Assert.IsTrue(lpsv_new.Latest);
Assert.AreEqual(lpsv_new.Version, "4.0");
lps.Save(SaveOption.SaveOnly);
IPolicySetCache lps_new = new LocalPolicySetCache(policySet3);
IPolicySetVersionCache lpsv_new_new = lps_new.LatestVersion;
Assert.AreEqual(lpsv_new_new.Version, "4.0");
System.IO.File.Delete(policySet3);
}
public void TestLocalPolicyCache()
{
LocalPolicyCache lpc = new LocalPolicyCache(m_testFiles.RootPath, false);
Assert.AreEqual(lpc.PolicySets.Count, 2);
}
public void TestGetPolicySet()
{
LocalPolicyCache lpc = new LocalPolicyCache(m_testFiles.RootPath, false);
LocalPolicySetCache policyset = null;
foreach (LocalPolicySetCache set in lpc.PolicySets)
{
if (set.Id == "policyset2")
{
policyset = set;
break;
}
}
Assert.IsNotNull(policyset);
}
public void TestLocalPolicySetProperties()
{
LocalPolicyCache lpc = new LocalPolicyCache(m_testFiles.RootPath, false);
IPolicySetCache lps = lpc.GetPolicySet("policyset1");
IPolicySetVersionCache lpsv = lps.LatestVersion;
Assert.AreEqual(lpsv.Version, "3.0");
Assert.AreEqual(lpsv.Status, PolicySetVersionStatus.Enabled);
}
public void Test04_PolicySetLoadedFromCommonLocation()
{
string policy1 = Path.Combine(LocalPolicyCache.LOCAL_BASEPATH_COMMON, "PolicySetA.policy");
try
{
File.Copy(Workshare.TestUtils.TestFileUtils.MakeRootPathAbsolute(@"\projects\Hygiene\src\PolicySuite.Tests\TestFiles\PolicySetA.policy"),
policy1);
Assert.IsTrue(File.Exists(policy1));
LocalPolicyCache plc = new LocalPolicyCache(false);
Assert.IsTrue(1 == plc.PolicySets.Count, "Incorrect number of policy sets were found.");
}
finally
{
if (File.Exists(policy1))
{
File.Delete(policy1);
Assert.IsFalse(File.Exists(policy1));
}
}
}
public void TestExportPolicySetToFile()
{
string originalsetname = Guid.NewGuid().ToString();
string originalsetfilename = originalsetname + Definitions.PolicyFileExtension;
System.IO.File.Copy(m_testFiles.RootPath + "policyset1" + Definitions.PolicyFileExtension, m_testFiles.RootPath + originalsetfilename, true);
LocalPolicyCache cache = new LocalPolicyCache(m_testFiles.RootPath, false);
LocalPolicySetCache set = cache.GetPolicySet(originalsetname) as LocalPolicySetCache;
string tempfile = System.IO.Path.GetTempFileName();
set.ExportCompiledPolicySet(tempfile);
Assert.AreEqual(set.LatestVersion.Status, PolicySetVersionStatus.Enabled);
LocalPolicySetCache exportset = new LocalPolicySetCache(tempfile);
Assert.IsNotNull(exportset);
Assert.AreEqual(exportset.LatestVersion.Status, PolicySetVersionStatus.Enabled);
System.IO.File.Delete(cache.LocalBasePath + originalsetfilename);
System.IO.File.Delete(tempfile);
}
public void TestSaveAs()
{
LocalPolicyCache cache = new LocalPolicyCache(m_testFiles.RootPath, false);
LocalPolicySetCache set = cache.GetPolicySet("policyset1") as LocalPolicySetCache;
Assert.IsNotNull(set);
Assert.IsTrue(System.IO.File.Exists(m_testFiles.RootPath + "policyset1" + Definitions.PolicyFileExtension));
string newfile = Guid.NewGuid().ToString();
set.SaveAs(SaveOption.SaveOnly, newfile);
Assert.IsTrue(System.IO.File.Exists(m_testFiles.RootPath + newfile + Definitions.PolicyFileExtension));
System.IO.File.Delete(m_testFiles.RootPath + newfile + Definitions.PolicyFileExtension);
}
public void TestCreateNewCatalogues()
{
LocalPolicyCache lpc = new LocalPolicyCache(m_testFiles.RootPath, false);
Assert.IsNotNull(lpc);
IPolicySetCache lps = lpc.NewPolicySet("policyset4");
Assert.IsNotNull(lps);
IPolicySetVersionCache lpsv = lps.NewVersion("<policysetxml>this is the content of the policy set for v1.0</policysetxml>");
Assert.IsNotNull(lpsv);
IPolicyCatalogueCache mastercat = lpsv.NewMasterCatalogue("<mastercatalogue>this is the conent of the master catalogue</mastercatalogue>");
Assert.IsNotNull(mastercat);
IPolicyCatalogueCache refcat = lpsv.NewReferenceCatalgue("<refcatalogue>this is the conent of the reference catalogue</refcatalogue>");
Assert.IsNotNull(refcat);
lps.Save(SaveOption.SaveOnly);
IPolicySetCache lps2 = new LocalPolicySetCache(m_testFiles.RootPath + "\\policyset4" + Definitions.PolicyFileExtension);
Assert.IsNotNull(lps2);
Assert.AreEqual(1, lps2.PolicySetVersions.Count);
IPolicySetVersionCache lpsv2 = lps2.PolicySetVersions[0];
Assert.IsNotNull(lpsv2);
IPolicyCatalogueCache pcm = lpsv2.MasterCatalogue;
Assert.IsNotNull(pcm);
Assert.AreEqual(pcm.Content, "<mastercatalogue>this is the conent of the master catalogue</mastercatalogue>");
IPolicyCatalogueCache pcr = lpsv2.ReferenceCatalogues[0];
Assert.IsNotNull(pcr);
Assert.AreEqual(pcr.Content, "<refcatalogue>this is the conent of the reference catalogue</refcatalogue>");
System.IO.File.Delete(m_testFiles.RootPath + "\\policyset4" + Definitions.PolicyFileExtension);
}
public void TestNewSetAddedToList()
{
LocalPolicyCache cache = new LocalPolicyCache(m_testFiles.RootPath, false);
Assert.AreEqual(cache.PolicySets.Count, 2);
cache.NewPolicySet("steve");
Assert.AreEqual(cache.PolicySets.Count, 3);
}
public void TestCreateNewCatalogueLanguages()
{
LocalPolicyCache lpc = new LocalPolicyCache(m_testFiles.RootPath, false);
Assert.IsNotNull(lpc);
IPolicySetCache lps = lpc.NewPolicySet("policyset4");
Assert.IsNotNull(lps);
IPolicySetVersionCache lpsv = lps.NewVersion("<policysetxml>this is the content of the policy set for v1.0</policysetxml>");
Assert.IsNotNull(lpsv);
IPolicyCatalogueCache mastercat = lpsv.NewMasterCatalogue("<mastercatalogue>this is the conent of the master catalogue</mastercatalogue>");
Assert.IsNotNull(mastercat);
IPolicyLanguageTableCache engLang = mastercat.NewLanguage("en", "<language>this is the language content for english for master cat</language>", true);
Assert.IsNotNull(engLang);
IPolicyLanguageTableCache jpLang = mastercat.NewLanguage("jp", "<language>this is the language content for japanese for master cat</language>", false);
Assert.IsNotNull(jpLang);
lps.Save(SaveOption.SaveOnly);
IPolicySetCache lps2 = new LocalPolicySetCache(m_testFiles.RootPath + "\\policyset4" + Definitions.PolicyFileExtension);
Assert.IsNotNull(lps2);
Assert.AreEqual(1, lps2.PolicySetVersions.Count);
IPolicySetVersionCache lpsv2 = lps2.PolicySetVersions[0];
Assert.IsNotNull(lpsv2);
IPolicyCatalogueCache pcm = lpsv2.MasterCatalogue;
Assert.IsNotNull(pcm);
IPolicyLanguageTableCache pl_eng = pcm.Languages[0];
Assert.IsNotNull(pl_eng);
Assert.AreEqual(pl_eng.Content, "<language>this is the language content for english for master cat</language>");
Assert.AreEqual(pl_eng.Language.Code, "en");
IPolicyLanguageTableCache pl_jp = pcm.Languages[1];
Assert.IsNotNull(pl_jp);
Assert.AreEqual(pl_jp.Content, "<language>this is the language content for japanese for master cat</language>");
Assert.AreEqual(pl_jp.Language.Code, "jp");
System.IO.File.Delete(m_testFiles.RootPath + "\\policyset4" + Definitions.PolicyFileExtension);
}
public void TestIDZeroedForCopiedObjects()
{
LocalPolicyCache cache = new LocalPolicyCache(m_testFiles.RootPath, false);
LocalPolicySetCache set = cache.NewPolicySet("steve") as LocalPolicySetCache;
LocalPolicySetVersionCache ver1 = set.LatestVersion as LocalPolicySetVersionCache;
ver1.ID = 100;
LocalPolicyCatalogueCache master = ver1.NewMasterCatalogue("hello") as LocalPolicyCatalogueCache;
master.ID = 101;
LocalPolicyLanguageTableCache lang = master.NewLanguage("en", "stuff", true) as LocalPolicyLanguageTableCache;
lang.ID = 102;
set.Save(SaveOption.Publish);
set.Save(SaveOption.SaveNew);
LocalPolicySetVersionCache ver2 = set.LatestVersion as LocalPolicySetVersionCache;
Assert.AreEqual(ver2.ID, 0);
LocalPolicyCatalogueCache master2 = ver2.MasterCatalogue as LocalPolicyCatalogueCache;
Assert.AreEqual(master2.ID, 0);
LocalPolicyLanguageTableCache lang2 = master2.Languages[0] as LocalPolicyLanguageTableCache;
Assert.AreEqual(lang2.ID, 0);
System.IO.File.Delete(m_testFiles.RootPath + "steve" + Definitions.PolicyFileExtension);
}
public void TestCreateNewCompiledPolicySets()
{
LocalPolicyCache lpc = new LocalPolicyCache(m_testFiles.RootPath, false);
Assert.IsNotNull(lpc);
IPolicySetCache lps = lpc.NewPolicySet("policyset4");
Assert.IsNotNull(lps);
IPolicySetVersionCache lpsv = lps.NewVersion("<policysetxml>this is the content of the policy set for v1.0</policysetxml>");
Assert.IsNotNull(lpsv);
ICompiledPolicySetCache cpsc = lpsv.NewCompiledPolicySet("SMTP", "Client", "<Policy>this is the compiled policy</Policy>", "<Objects>the is the compiled policy objects</Objects>");
Assert.IsNotNull(cpsc);
lps.Save(SaveOption.SaveOnly);
IPolicySetCache lps2 = new LocalPolicySetCache(m_testFiles.RootPath + "\\policyset4" + Definitions.PolicyFileExtension);
Assert.IsNotNull(lps2);
Assert.AreEqual(1, lps2.PolicySetVersions.Count);
IPolicySetVersionCache lpsv2 = lps2.PolicySetVersions[0];
Assert.IsNotNull(lpsv2);
ICompiledPolicySetCache cps = lpsv2.GetCompiledPolicySet("SMTP", "Client");
Assert.IsNotNull(cps);
Assert.AreEqual(cps.Channel, "SMTP");
Assert.AreEqual(cps.Target, "Client");
Assert.AreEqual(cps.Content, "<Policy>this is the compiled policy</Policy>");
Assert.AreEqual(cps.ObjectReferences, "<Objects>the is the compiled policy objects</Objects>");
System.IO.File.Delete(m_testFiles.RootPath + "\\policyset4" + Definitions.PolicyFileExtension);
}
public void TestModifiedFlagOnLanguageChange()
{
LocalPolicyCache lpc = new LocalPolicyCache(m_testFiles.RootPath, false);
IPolicySetCache lps = lpc.GetPolicySet("policyset2");
LocalPolicySetVersionCache ver = lps.LatestVersion as LocalPolicySetVersionCache;
Assert.IsFalse(ver.Modified);
LocalPolicyCatalogueCache master = ver.MasterCatalogue as LocalPolicyCatalogueCache;
LocalPolicyLanguageTableCache lang = master.Languages[0] as LocalPolicyLanguageTableCache;
lang.Content = "changes";
Assert.IsTrue(ver.Modified);
}
public void TestCreateNewCompiledPolicySetLanguages()
{
LocalPolicyCache lpc = new LocalPolicyCache(m_testFiles.RootPath, false);
Assert.IsNotNull(lpc);
IPolicySetCache lps = lpc.NewPolicySet("policyset4");
Assert.IsNotNull(lps);
IPolicySetVersionCache lpsv = lps.NewVersion("<policysetxml>this is the content of the policy set for v1.0</policysetxml>");
Assert.IsNotNull(lpsv);
ICompiledPolicySetCache cpsc = lpsv.NewCompiledPolicySet("SMTP", "Client", "<Policy>this is the compiled policy</Policy>", "<Objects>the is the compiled policy objects</Objects>");
Assert.IsNotNull(cpsc);
IPolicyLanguageTableCache cpsc_eng = cpsc.NewLanguage("en", "<language>this is the language content for english for compiled policy set</language>", true);
Assert.IsNotNull(cpsc_eng);
IPolicyLanguageTableCache cpsc_jp = cpsc.NewLanguage("jp", "<language>this is the language content for japanese for compiled policy set</language>", false);
Assert.IsNotNull(cpsc_jp);
lps.Save(SaveOption.SaveOnly);
IPolicySetCache lps2 = new LocalPolicySetCache(m_testFiles.RootPath + "\\policyset4" + Definitions.PolicyFileExtension);
Assert.IsNotNull(lps2);
Assert.AreEqual(1, lps2.PolicySetVersions.Count);
IPolicySetVersionCache lpsv2 = lps2.PolicySetVersions[0];
Assert.IsNotNull(lpsv2);
ICompiledPolicySetCache cps = lpsv2.GetCompiledPolicySet("SMTP", "Client");
Assert.IsNotNull(cps);
IPolicyLanguageTableCache pl_eng = cps.Languages[0];
Assert.IsNotNull(pl_eng);
Assert.AreEqual(pl_eng.Content, "<language>this is the language content for english for compiled policy set</language>");
Assert.AreEqual(pl_eng.Language.Code, "en");
IPolicyLanguageTableCache pl_jp = cps.Languages[1];
Assert.IsNotNull(pl_jp);
Assert.AreEqual(pl_jp.Content, "<language>this is the language content for japanese for compiled policy set</language>");
Assert.AreEqual(pl_jp.Language.Code, "jp");
System.IO.File.Delete(m_testFiles.RootPath + "\\policyset4" + Definitions.PolicyFileExtension);
}
public void TestDoesntNonLoadRuntimePoliciesInRuntimeMode()
{
LocalPolicyCache lpc = new LocalPolicyCache(m_testFiles.RootPath, true);
Assert.AreEqual(lpc.PolicySets.Count, 1);
}
public void TestDisallowChangesToPreviousVersions()
{
LocalPolicyCache cache = new LocalPolicyCache(m_testFiles.RootPath, false);
LocalPolicySetCache set = cache.GetPolicySet("policyset1") as LocalPolicySetCache;
Assert.AreEqual(set.Id, "policyset1");
Assert.AreEqual(set.PolicySetVersions.Count, 3);
LocalPolicySetVersionCache latestVersion = set.LatestVersion as LocalPolicySetVersionCache;
Assert.IsNotNull(latestVersion);
LocalPolicySetVersionCache ver1 = set.GetVersion("1.0") as LocalPolicySetVersionCache;
LocalPolicySetVersionCache ver2 = set.GetVersion("2.0") as LocalPolicySetVersionCache;
LocalPolicySetVersionCache ver3 = set.GetVersion("3.0") as LocalPolicySetVersionCache;
Assert.IsFalse(ver1.Latest);
Assert.IsFalse(ver2.Latest);
Assert.AreEqual(ver3, latestVersion);
CacheTestHelper.TestVersionIsReadOnly(ver1);
CacheTestHelper.TestVersionIsReadOnly(ver2);
}
public void TestReActivateDisabledPolicy()
{
LocalPolicyCache cache = new LocalPolicyCache(m_testFiles.RootPath, false);
string newpolicyset = Guid.NewGuid().ToString();
IPolicySetCache set = cache.NewPolicySet(newpolicyset);
IPolicySetVersionCache ver1 = set.NewVersion("ver1");
Assert.AreEqual(ver1.Status, PolicySetVersionStatus.InProgress);
set.Save(SaveOption.Disable);
Assert.AreEqual(ver1.Status, PolicySetVersionStatus.InProgress);
set.Save(SaveOption.Publish);
Assert.AreEqual(ver1.Status, PolicySetVersionStatus.Enabled);
}
public void TestDisallowChangesToCurrentVersionAfterNewVersion()
{
LocalPolicyCache cache = new LocalPolicyCache(m_testFiles.RootPath, false);
LocalPolicySetCache set = cache.GetPolicySet("policyset1") as LocalPolicySetCache;
LocalPolicySetVersionCache ver1 = set.GetVersion("1.0") as LocalPolicySetVersionCache;
LocalPolicySetVersionCache ver2 = set.GetVersion("2.0") as LocalPolicySetVersionCache;
LocalPolicySetVersionCache ver3 = set.GetVersion("3.0") as LocalPolicySetVersionCache;
CacheTestHelper.TestVersionIsReadOnly(ver1);
CacheTestHelper.TestVersionIsReadOnly(ver2);
set.NewVersion("content");
CacheTestHelper.TestVersionIsReadOnly(ver3);
}
public void TestAutomaticallyCreateNewVersionOnNewPolicySet()
{
LocalPolicyCache cache = new LocalPolicyCache(m_testFiles.RootPath, false);
LocalPolicySetCache set = cache.NewPolicySet("steve") as LocalPolicySetCache;
Assert.IsNotNull(set);
Assert.IsNotNull(set.LatestVersion);
Assert.AreEqual(set.LatestVersion.Content, "");
}
public void TestRuntimePolicyLoadableFromNonRuntimePolicyCache()
{
string policy = Path.Combine(LocalPolicyCache.LOCAL_BASEPATH_COMMON, "PolicySetA.runtimepolicy");
try
{
File.Copy(TestUtils.TestFileUtils.MakeRootPathAbsolute(@"\projects\Hygiene\src\PolicySuite.Tests\TestFiles\PolicySetA.runtimepolicy"),
policy);
Assert.IsTrue(File.Exists(policy));
LocalPolicyCache cache = new LocalPolicyCache(false);
Assert.AreEqual(0, cache.PolicySets.Count, "by default, runtime policies will not be read during the initialisation stage, so will not be visible yet.");
Assert.IsNotNull(cache.GetPolicySet(policy), "It should be possible to load a runtime policy into this cache if you explicity ask to.");
}
finally
{
if (File.Exists(policy))
{
File.Delete(policy);
Assert.IsFalse(File.Exists(policy));
}
}
}
