public void Convert_MultipleClasses()
{
SecurableClassInfo baseClassInfo = new SecurableClassInfo();
baseClassInfo.ID = "4bbb1bab-8d37-40c0-918d-7a07cc7de44f";
baseClassInfo.Name = "File";
_cache.AddSecurableClassInfo(typeof(File), baseClassInfo);
SecurableClassInfo derivedClassInfo1 = new SecurableClassInfo();
derivedClassInfo1.ID = "00000000-0000-0000-0002-000000000000";
derivedClassInfo1.Name = "PaperFile";
_cache.AddSecurableClassInfo(typeof(PaperFile), derivedClassInfo1);
SecurableClassInfo derivedClassInfo2 = new SecurableClassInfo();
derivedClassInfo2.ID = "118a9d5e-4f89-40af-ade5-e4613e4638d5";
derivedClassInfo2.Name = "InputFile";
_cache.AddSecurableClassInfo(typeof(SecurableClassInfo), derivedClassInfo2);
XmlDocument document = _converter.Convert(_cache);
string expectedXml = @"<?xml version=""1.0""?>
<securityMetadata xmlns=""http://www.re-motion.org/Security/Metadata/1.0"">
<classes>
<class id=""4bbb1bab-8d37-40c0-918d-7a07cc7de44f"" name=""File"" />
<class id=""00000000-0000-0000-0002-000000000000"" name=""PaperFile"" />
<class id=""118a9d5e-4f89-40af-ade5-e4613e4638d5"" name=""InputFile"" />
</classes>
</securityMetadata>";
XmlAssert.AreDocumentsEqual(expectedXml, document);
}
private SecurableClassInfo AddSecurableClassInfo(MetadataCache metadataCache, Type type, string id)
{
SecurableClassInfo classInfo = new SecurableClassInfo();
classInfo.Name = type.FullName;
classInfo.ID = id;
metadataCache.AddSecurableClassInfo(type, classInfo);
return(classInfo);
}
public void GetMetadataFromCache()
{
ClassReflector reflector = new ClassReflector();
SecurableClassInfo paperFileInfo = reflector.GetMetadata(typeof(PaperFile), _cache);
Assert.That(paperFileInfo, Is.Not.Null);
Assert.That(_cache.GetSecurableClassInfo(typeof(PaperFile)), Is.EqualTo(paperFileInfo));
SecurableClassInfo fileInfo = _cache.GetSecurableClassInfo(typeof(File));
Assert.That(fileInfo, Is.Not.Null);
Assert.That(fileInfo.Name, Is.EqualTo("Remotion.Security.UnitTests.TestDomain.File, Remotion.Security.UnitTests.TestDomain"));
}
public void GetCachedSecurableClassInfos()
{
SecurableClassInfo fileTypeInfo = new SecurableClassInfo();
SecurableClassInfo paperFileTypeInfo = new SecurableClassInfo();
_cache.AddSecurableClassInfo(typeof(File), fileTypeInfo);
_cache.AddSecurableClassInfo(typeof(PaperFile), paperFileTypeInfo);
List <SecurableClassInfo> infos = _cache.GetSecurableClassInfos();
Assert.That(infos, Is.Not.Null);
Assert.That(infos.Count, Is.EqualTo(2));
Assert.That(infos, Has.Member(fileTypeInfo));
Assert.That(infos, Has.Member(paperFileTypeInfo));
}
public void Convert_ClassWithStateProperties()
{
SecurableClassInfo classInfo = new SecurableClassInfo();
classInfo.ID = "4bbb1bab-8d37-40c0-918d-7a07cc7de44f";
classInfo.Name = "File";
_cache.AddSecurableClassInfo(typeof(File), classInfo);
StatePropertyInfo propertyInfo = new StatePropertyInfo();
propertyInfo.ID = "4bbb1bab-8d37-40c0-918d-7a07cc7de44f";
propertyInfo.Name = "Confidentiality";
propertyInfo.Values.Add(new EnumValueInfo("Domain.Confidentiality, Domain", "Normal", 0));
propertyInfo.Values.Add(new EnumValueInfo("Domain.Confidentiality, Domain", "Confidential", 1));
propertyInfo.Values.Add(new EnumValueInfo("Domain.Confidentiality, Domain", "Private", 2));
Type type = typeof(File);
PropertyInfo property = type.GetProperty("Confidentiality");
_cache.AddStatePropertyInfo(property, propertyInfo);
classInfo.Properties.Add(propertyInfo);
XmlDocument document = _converter.Convert(_cache);
string expectedXml = @"<?xml version=""1.0""?>
<securityMetadata xmlns=""http://www.re-motion.org/Security/Metadata/1.0"">
<classes>
<class id=""4bbb1bab-8d37-40c0-918d-7a07cc7de44f"" name=""File"">
<stateProperties>
<statePropertyRef>4bbb1bab-8d37-40c0-918d-7a07cc7de44f</statePropertyRef>
</stateProperties>
</class>
</classes>
<stateProperties>
<stateProperty id=""4bbb1bab-8d37-40c0-918d-7a07cc7de44f"" name=""Confidentiality"">
<state name=""Normal|Domain.Confidentiality, Domain"" value=""0"" />
<state name=""Confidential|Domain.Confidentiality, Domain"" value=""1"" />
<state name=""Private|Domain.Confidentiality, Domain"" value=""2"" />
</stateProperty>
</stateProperties>
</securityMetadata>";
XmlAssert.AreDocumentsEqual(expectedXml, document);
}
public void GetMetadata()
{
List <EnumValueInfo> fileAccessTypes = new List <EnumValueInfo> ();
fileAccessTypes.Add(AccessTypes.Read);
fileAccessTypes.Add(AccessTypes.Write);
fileAccessTypes.Add(AccessTypes.Journalize);
List <EnumValueInfo> paperFileAccessTypes = new List <EnumValueInfo> ();
paperFileAccessTypes.Add(AccessTypes.Read);
paperFileAccessTypes.Add(AccessTypes.Write);
paperFileAccessTypes.Add(AccessTypes.Journalize);
paperFileAccessTypes.Add(AccessTypes.Archive);
Expect.Call(_statePropertyReflectorMock.GetMetadata(typeof(PaperFile).GetProperty("Confidentiality"), _cache)).Return(_confidentialityProperty);
Expect.Call(_statePropertyReflectorMock.GetMetadata(typeof(PaperFile).GetProperty("State"), _cache)).Return(_stateProperty);
Expect.Call(_statePropertyReflectorMock.GetMetadata(typeof(File).GetProperty("Confidentiality"), _cache)).Return(_confidentialityProperty);
Expect.Call(_accessTypeReflectorMock.GetAccessTypesFromType(typeof(File), _cache)).Return(fileAccessTypes);
Expect.Call(_accessTypeReflectorMock.GetAccessTypesFromType(typeof(PaperFile), _cache)).Return(paperFileAccessTypes);
_mocks.ReplayAll();
SecurableClassInfo info = _classReflector.GetMetadata(typeof(PaperFile), _cache);
_mocks.VerifyAll();
Assert.That(info, Is.Not.Null);
Assert.That(info.Name, Is.EqualTo("Remotion.Security.UnitTests.TestDomain.PaperFile, Remotion.Security.UnitTests.TestDomain"));
Assert.That(info.ID, Is.EqualTo("00000000-0000-0000-0002-000000000000"));
Assert.That(info.DerivedClasses.Count, Is.EqualTo(0));
Assert.That(info.BaseClass, Is.Not.Null);
Assert.That(info.BaseClass.Name, Is.EqualTo("Remotion.Security.UnitTests.TestDomain.File, Remotion.Security.UnitTests.TestDomain"));
Assert.That(info.BaseClass.DerivedClasses.Count, Is.EqualTo(1));
Assert.That(info.BaseClass.DerivedClasses, Has.Member(info));
Assert.That(info.Properties.Count, Is.EqualTo(2));
Assert.That(info.Properties, Has.Member(_confidentialityProperty));
Assert.That(info.Properties, Has.Member(_stateProperty));
Assert.That(info.AccessTypes.Count, Is.EqualTo(4));
foreach (EnumValueInfo accessType in paperFileAccessTypes)
{
Assert.That(info.AccessTypes, Has.Member(accessType));
}
}
public void Convert_OneEmptyClass()
{
SecurableClassInfo classInfo = new SecurableClassInfo();
classInfo.ID = "4bbb1bab-8d37-40c0-918d-7a07cc7de44f";
classInfo.Name = "File";
_cache.AddSecurableClassInfo(typeof(File), classInfo);
XmlDocument document = _converter.Convert(_cache);
string expectedXml = @"<?xml version=""1.0""?>
<securityMetadata xmlns=""http://www.re-motion.org/Security/Metadata/1.0"">
<classes>
<class id=""4bbb1bab-8d37-40c0-918d-7a07cc7de44f"" name=""File"" />
</classes>
</securityMetadata>";
XmlAssert.AreDocumentsEqual(expectedXml, document);
}
public void Convert_ClassWithAccessTypes()
{
SecurableClassInfo classInfo = new SecurableClassInfo();
classInfo.ID = "4bbb1bab-8d37-40c0-918d-7a07cc7de44f";
classInfo.Name = "File";
_cache.AddSecurableClassInfo(typeof(File), classInfo);
EnumValueInfo accessType1 = new EnumValueInfo("Domain.AccessType, Domain", "Archive", 0);
accessType1.ID = "64d8f74e-685f-44ab-9705-1fda9ff836a4";
_cache.AddAccessType(DomainAccessTypes.Archive, accessType1);
EnumValueInfo accessType2 = new EnumValueInfo("Domain.AccessType, Domain", "Journalize", 1);
accessType2.ID = "c6995b9b-7fed-42df-a2d1-897600b00fb0";
_cache.AddAccessType(DomainAccessTypes.Journalize, accessType2);
classInfo.AccessTypes.Add(accessType1);
classInfo.AccessTypes.Add(accessType2);
XmlDocument document = _converter.Convert(_cache);
string expectedXml = @"<?xml version=""1.0""?>
<securityMetadata xmlns=""http://www.re-motion.org/Security/Metadata/1.0"">
<classes>
<class id=""4bbb1bab-8d37-40c0-918d-7a07cc7de44f"" name=""File"">
<accessTypes>
<accessTypeRef>64d8f74e-685f-44ab-9705-1fda9ff836a4</accessTypeRef>
<accessTypeRef>c6995b9b-7fed-42df-a2d1-897600b00fb0</accessTypeRef>
</accessTypes>
</class>
</classes>
<accessTypes>
<accessType id=""64d8f74e-685f-44ab-9705-1fda9ff836a4"" name=""Archive|Domain.AccessType, Domain"" value=""0"" />
<accessType id=""c6995b9b-7fed-42df-a2d1-897600b00fb0"" name=""Journalize|Domain.AccessType, Domain"" value=""1"" />
</accessTypes>
</securityMetadata>";
XmlAssert.AreDocumentsEqual(expectedXml, document);
}
public void CacheSecurableClassInfos()
{
Type fileType = typeof(File);
Type paperFileType = typeof(PaperFile);
SecurableClassInfo fileTypeInfo = new SecurableClassInfo();
SecurableClassInfo paperFileTypeInfo = new SecurableClassInfo();
Assert.That(_cache.ContainsSecurableClassInfo(fileType), Is.False);
Assert.That(_cache.GetSecurableClassInfo(fileType), Is.Null);
_cache.AddSecurableClassInfo(fileType, fileTypeInfo);
Assert.That(_cache.GetSecurableClassInfo(fileType), Is.SameAs(fileTypeInfo));
Assert.That(_cache.ContainsSecurableClassInfo(paperFileType), Is.False);
Assert.That(_cache.GetSecurableClassInfo(paperFileType), Is.Null);
_cache.AddSecurableClassInfo(paperFileType, paperFileTypeInfo);
Assert.That(_cache.GetSecurableClassInfo(fileType), Is.SameAs(fileTypeInfo));
Assert.That(_cache.GetSecurableClassInfo(paperFileType), Is.SameAs(paperFileTypeInfo));
}
public void ConvertAndSave_LocalizedClassName()
{
CultureInfo[] cultures = CreateCultureInfos("de", "en");
LocalizingMetadataConverter converter = new LocalizingMetadataConverter(_localizationConverter, cultures);
string filename = "metadata.xml";
MetadataCache cache = new MetadataCache();
SecurableClassInfo classInfo = AddSecurableClassInfo(cache, typeof(SecurableObject), "21df1db3-affd-4c1a-b14e-340c1405bd69");
LocalizedName expectedGermanName = CreateLocalizedName(classInfo);
_localizationConverter.ConvertAndSave(new LocalizedName[] { expectedGermanName }, cultures[0], filename);
LocalizedName expectedEnglishName = CreateLocalizedName(classInfo);
_localizationConverter.ConvertAndSave(new LocalizedName[] { expectedEnglishName }, cultures[1], filename);
_mocks.ReplayAll();
converter.ConvertAndSave(cache, filename);
_mocks.VerifyAll();
}
public void Convert_IntegrationTest()
{
SecurableClassInfo classInfo = new SecurableClassInfo();
classInfo.ID = "4bbb1bab-8d37-40c0-918d-7a07cc7de44f";
classInfo.Name = "File";
_cache.AddSecurableClassInfo(typeof(File), classInfo);
SecurableClassInfo derivedClassInfo = new SecurableClassInfo();
derivedClassInfo.ID = "ac101f66-6d1f-4002-b32b-f951db36582c";
derivedClassInfo.Name = "PaperFile";
_cache.AddSecurableClassInfo(typeof(PaperFile), derivedClassInfo);
classInfo.DerivedClasses.Add(derivedClassInfo);
derivedClassInfo.BaseClass = classInfo;
StatePropertyInfo propertyInfo1 = new StatePropertyInfo();
propertyInfo1.ID = "d81b1521-ea06-4338-af6f-ff8510394efd";
propertyInfo1.Name = "Confidentiality";
propertyInfo1.Values.Add(new EnumValueInfo("Domain.Confidentiality, Domain", "Normal", 0));
propertyInfo1.Values.Add(new EnumValueInfo("Domain.Confidentiality, Domain", "Confidential", 1));
propertyInfo1.Values.Add(new EnumValueInfo("Domain.Confidentiality, Domain", "Private", 2));
StatePropertyInfo propertyInfo2 = new StatePropertyInfo();
propertyInfo2.ID = "40749391-5c45-4fdd-a698-53a6cf167ae7";
propertyInfo2.Name = "SomeEnum";
propertyInfo2.Values.Add(new EnumValueInfo("Namespace.TypeName, Assembly", "First", 0));
propertyInfo2.Values.Add(new EnumValueInfo("Namespace.TypeName, Assembly", "Second", 1));
propertyInfo2.Values.Add(new EnumValueInfo("Namespace.TypeName, Assembly", "Third", 2));
Type type = typeof(File);
PropertyInfo property1 = type.GetProperty("Confidentiality");
_cache.AddStatePropertyInfo(property1, propertyInfo1);
PropertyInfo property2 = type.GetProperty("SimpleEnum");
_cache.AddStatePropertyInfo(property2, propertyInfo2);
classInfo.Properties.Add(propertyInfo1);
derivedClassInfo.Properties.Add(propertyInfo1);
derivedClassInfo.Properties.Add(propertyInfo2);
EnumValueInfo accessType1 = new EnumValueInfo("Domain.AccessType, Domain", "Archive", 0);
accessType1.ID = "64d8f74e-685f-44ab-9705-1fda9ff836a4";
_cache.AddAccessType(DomainAccessTypes.Archive, accessType1);
EnumValueInfo accessType2 = new EnumValueInfo("Domain.AccessType, Domain", "Journalize", 1);
accessType2.ID = "c6995b9b-7fed-42df-a2d1-897600b00fb0";
_cache.AddAccessType(DomainAccessTypes.Journalize, accessType2);
classInfo.AccessTypes.Add(accessType1);
derivedClassInfo.AccessTypes.Add(accessType1);
derivedClassInfo.AccessTypes.Add(accessType2);
EnumValueInfo abstractRole1 = new EnumValueInfo("Domain.AbstractRole, Domain", "Administrator", 0);
abstractRole1.ID = "00000004-0001-0000-0000-000000000000";
_cache.AddAbstractRole(SpecialAbstractRoles.Administrator, abstractRole1);
EnumValueInfo abstractRole2 = new EnumValueInfo("Domain.AbstractRole, Domain", "PowerUser", 1);
abstractRole2.ID = "3b84739a-7f35-4224-989f-3d5b05047cbb";
_cache.AddAbstractRole(SomeEnum.First, abstractRole2);
XmlDocument document = _converter.Convert(_cache);
string expectedXml = @"<?xml version=""1.0""?>
<securityMetadata xmlns=""http://www.re-motion.org/Security/Metadata/1.0"">
<classes>
<class id=""4bbb1bab-8d37-40c0-918d-7a07cc7de44f"" name=""File"">
<stateProperties>
<statePropertyRef>d81b1521-ea06-4338-af6f-ff8510394efd</statePropertyRef>
</stateProperties>
<accessTypes>
<accessTypeRef>64d8f74e-685f-44ab-9705-1fda9ff836a4</accessTypeRef>
</accessTypes>
</class>
<class id=""ac101f66-6d1f-4002-b32b-f951db36582c"" name=""PaperFile"" base=""4bbb1bab-8d37-40c0-918d-7a07cc7de44f"">
<stateProperties>
<statePropertyRef>d81b1521-ea06-4338-af6f-ff8510394efd</statePropertyRef>
<statePropertyRef>40749391-5c45-4fdd-a698-53a6cf167ae7</statePropertyRef>
</stateProperties>
<accessTypes>
<accessTypeRef>64d8f74e-685f-44ab-9705-1fda9ff836a4</accessTypeRef>
<accessTypeRef>c6995b9b-7fed-42df-a2d1-897600b00fb0</accessTypeRef>
</accessTypes>
</class>
</classes>
<stateProperties>
<stateProperty id=""d81b1521-ea06-4338-af6f-ff8510394efd"" name=""Confidentiality"">
<state name=""Normal|Domain.Confidentiality, Domain"" value=""0"" />
<state name=""Confidential|Domain.Confidentiality, Domain"" value=""1"" />
<state name=""Private|Domain.Confidentiality, Domain"" value=""2"" />
</stateProperty>
<stateProperty id=""40749391-5c45-4fdd-a698-53a6cf167ae7"" name=""SomeEnum"">
<state name=""First|Namespace.TypeName, Assembly"" value=""0"" />
<state name=""Second|Namespace.TypeName, Assembly"" value=""1"" />
<state name=""Third|Namespace.TypeName, Assembly"" value=""2"" />
</stateProperty>
</stateProperties>
<accessTypes>
<accessType id=""64d8f74e-685f-44ab-9705-1fda9ff836a4"" name=""Archive|Domain.AccessType, Domain"" value=""0"" />
<accessType id=""c6995b9b-7fed-42df-a2d1-897600b00fb0"" name=""Journalize|Domain.AccessType, Domain"" value=""1"" />
</accessTypes>
<abstractRoles>
<abstractRole id=""00000004-0001-0000-0000-000000000000"" name=""Administrator|Domain.AbstractRole, Domain"" value=""0"" />
<abstractRole id=""3b84739a-7f35-4224-989f-3d5b05047cbb"" name=""PowerUser|Domain.AbstractRole, Domain"" value=""1"" />
</abstractRoles>
</securityMetadata>";
XmlAssert.AreDocumentsEqual(expectedXml, document);
}
private LocalizedName CreateLocalizedName(SecurableClassInfo classInfo)
{
return(new LocalizedName(classInfo.ID, classInfo.Name, classInfo.Name));
}
