private void ExplicitLoading(DbAssemblyMetadata loadedRoot)
{
context.Entry(loadedRoot).Collection(a => a.EFNamespaces).Load();
foreach (DbNamespaceMetadata _namespace in loadedRoot.EFNamespaces)
{
context.Entry(_namespace).Collection(n => n.EFTypes).Load();
foreach (DbTypeMetadata type in _namespace.EFTypes)
{
context.Entry(type).Reference(t => t.EFDeclaringType)?.Load();
context.Entry(type).Reference(t => t.EFBaseType)?.Load();
context.Entry(type).Collection(t => t.EFAttributes)?.Load();
context.Entry(type).Collection(t => t.EFGenericArguments)?.Load();
context.Entry(type).Collection(t => t.EFImplementedInterfaces)?.Load();
context.Entry(type).Collection(t => t.EFNestedTypes)?.Load();
context.Entry(type).Collection(t => t.EFMethodsAndConstructors)?.Load();
context.Entry(type).Collection(t => t.EFProperties)?.Load();
foreach (DbPropertyMetadata property in type.EFProperties)
{
context.Entry(property).Reference(p => p.EFMyType).Load();
}
foreach (DbMethodMetadata method in type.EFMethodsAndConstructors)
{
context.Entry(method).Reference(m => m.EFReturnType).Load();
context.Entry(method).Collection(m => m.EFParameters).Load();
context.Entry(method).Collection(m => m.EFGenericArguments).Load();
foreach (DbParameterMetadata parameter in method.EFParameters)
{
context.Entry(parameter).Reference(p => p.EFMyType).Load();
}
}
}
}
}
public Task Save(IAssemblyMetadata obj)
{
DbAssemblyMetadata root = obj as DbAssemblyMetadata ?? new DbAssemblyMetadata(obj);
context.Assemblies.Add(root);
context.SaveChanges();
return(Task.FromResult(true));
}
public void CopyCtorTest()
{
AssemblyTest tmp = new AssemblyTest();
DbAssemblyMetadata sut = new DbAssemblyMetadata(tmp);
Assert.IsTrue(tmp.Name.Equals(sut.Name));
Assert.AreEqual(tmp.SavedHash, sut.SavedHash);
Assert.AreEqual(tmp.Namespaces.Count(), sut.Namespaces.Count());
}
public async Task <IAssemblyMetadata> Load()
{
DbAssemblyMetadata result = await context.Assemblies
.OrderByDescending(n => n.Id).FirstOrDefaultAsync();
ExplicitLoading(result);
InsertRedundantData(result);
return(result);
}
public void DbAssemblyMetadataNamespacesPropertyTest()
{
DbAssemblyMetadata sut = new DbAssemblyMetadata
{
Namespaces = new[] { new DbNamespaceMetadata {
Name = "test1"
} }
};
Assert.IsNotNull(sut.EFNamespaces);
Assert.AreEqual(1, sut.EFNamespaces.Count);
}
private void InsertRedundantData(DbAssemblyMetadata loadedRoot)
{
foreach (DbNamespaceMetadata _namespace in loadedRoot.EFNamespaces)
{
foreach (DbTypeMetadata type in _namespace.EFTypes)
{
type.NamespaceName = _namespace.Name;
AbstractEnum isAbstract = AbstractEnum.NotAbstract;
if (type.IsAbstract)
{
isAbstract = AbstractEnum.Abstract;
}
SealedEnum isSealed = SealedEnum.NotSealed;
if (type.IsSealed)
{
isSealed = SealedEnum.Sealed;
}
type.Modifiers = new Tuple <AccessLevelEnum, SealedEnum, AbstractEnum>(
type.AccessLevel, isSealed, isAbstract);
foreach (DbMethodMetadata method in type.EFMethodsAndConstructors)
{
isAbstract = AbstractEnum.NotAbstract;
if (method.IsAbstract)
{
isAbstract = AbstractEnum.Abstract;
}
StaticEnum isStatic = StaticEnum.NotStatic;
if (method.IsStatic)
{
isStatic = StaticEnum.Static;
}
VirtualEnum isVirtual = VirtualEnum.NotVirtual;
if (method.IsVirtual)
{
isVirtual = VirtualEnum.Virtual;
}
method.Modifiers = new Tuple <AccessLevelEnum, AbstractEnum, StaticEnum, VirtualEnum>(
method.AccessLevel, isAbstract, isStatic, isVirtual);
}
}
}
}
public void DeepMappingTest()
{
AssemblyTest assemblyMetadata = new AssemblyTest {
Name = "test0", SavedHash = 0
};
NamespaceTest namespaceMeta1 = new NamespaceTest {
Name = "test1", SavedHash = 1
};
NamespaceTest namespaceMeta2 = new NamespaceTest {
Name = "test2", SavedHash = 2
};
TypeTest type1 = new TypeTest {
Name = "Type1", SavedHash = 3
};
type1.Properties = new[] { new PropertyTest {
Name = "prop", MyType = type1, SavedHash = 4
} };
type1.Attributes = new[] { new AttributeTest {
Name = "attr", SavedHash = 5
} };
MethodTest method1 = new MethodTest
{
Name = "method1",
SavedHash = 6,
Parameters = new[] { new ParameterTest {
Name = "param1", MyType = type1, SavedHash = 7
} }
};
type1.Methods = new[] { method1 };
namespaceMeta1.Types = new[] { type1 };
assemblyMetadata.Namespaces = new[] { namespaceMeta1, namespaceMeta2 };
DbAssemblyMetadata sut = new DbAssemblyMetadata(assemblyMetadata);
Assert.AreEqual(2, sut.Namespaces.Count());
Assert.AreEqual(1, sut.Namespaces.First().Types.Count());
Assert.AreEqual(1, sut.Namespaces.First().Types.First().Methods.Count());
Assert.AreEqual(1, sut.Namespaces.First().Types.First().Properties.Count());
Assert.AreEqual(1, sut.Namespaces.First().Types.First().Attributes.Count());
Assert.AreEqual(1, sut.Namespaces.First().Types.First().Methods.First().Parameters.Count());
}
