public void TypesTests()
{
DatabaseAssembly baseAssembly = serializer.Load(mockContext.Object);
Assert.AreEqual(4, baseAssembly.Namespaces.ToList()[1].Types.Count());
CollectionAssert.AreEquivalent(baseAssembly.Namespaces.ToList()[1].Types.ToList(), types);
}
public static AssemblyBase AssemblyBase(DatabaseAssembly assemblyMetadata)
{
dictionaryType.Clear();
return(new AssemblyBase()
{
Name = assemblyMetadata.Name,
Namespaces = assemblyMetadata.Namespaces?.Select(NamespaceBase)
});
}
public void Serialize(BaseAssembly _object)
{
Clear();
using (TPADatabaseContext context = new TPADatabaseContext())
{
DatabaseAssembly assemblyModel = (DatabaseAssembly)_object;
context.AssemblyModel.Add(assemblyModel);
context.SaveChanges();
}
}
public DatabaseAssembly Load(DatabaseContext ctx)
{
DatabaseAssembly assembly = ctx.AssemblyModel.FirstOrDefault();
if (assembly == null)
{
throw new ArgumentException("Database is empty");
}
return(assembly);
}
public void Serialize(IFileSelector supplier, AssemblyBase target)
{
System.Data.Entity.Database.SetInitializer(new DropCreateDatabaseAlways <DatabaseContext>());
DatabaseAssembly serializationModel = new DatabaseAssembly(target);
using (var ctx = new DatabaseContext())
{
ctx.AssemblyModel.Add(serializationModel);
ctx.SaveChanges();
}
}
public BaseAssembly Deserialize()
{
using (TPADatabaseContext context = new TPADatabaseContext())
{
context.Configuration.ProxyCreationEnabled = false;
context.NamespaceModel
.Include(n => n.Types)
.Load();
context.TypeModel
.Include(t => t.Constructors)
.Include(t => t.BaseT)
.Include(t => t.DeclaringType)
.Include(t => t.Fields)
.Include(t => t.ImplementedInterfaces)
.Include(t => t.GenericArguments)
.Include(t => t.Methods)
.Include(t => t.NestedTypes)
.Include(t => t.Properties)
.Include(t => t.TypeGenericArguments)
.Include(t => t.TypeImplementedInterfaces)
.Include(t => t.TypeNestedTypes)
.Include(t => t.MethodGenericArguments)
.Include(t => t.TypeBaseTypes)
.Include(t => t.TypeDeclaringTypes)
.Load();
context.ParameterModel
.Include(p => p.Type)
.Include(p => p.TypeFields)
.Include(p => p.MethodParameters)
.Load();
context.MethodModel
.Include(m => m.GenericArguments)
.Include(m => m.Parameters)
.Include(m => m.ReturnType)
.Include(m => m.TypeConstructors)
.Include(m => m.TypeMethods)
.Load();
context.PropertyModel
.Include(p => p.Type)
.Include(p => p.TypeProperties)
.Load();
DatabaseAssembly dbAssemblyModel = context.AssemblyModel
.Include(a => a.NamespaceModels)
.ToList().FirstOrDefault();
if (dbAssemblyModel == null)
{
throw new ArgumentException("Database is empty");
}
return(dbAssemblyModel);
}
}
public void NamespacesTests()
{
DatabaseAssembly baseAssembly = serializer.Load(mockContext.Object);
CollectionAssert.AreEquivalent(baseAssembly.Namespaces.ToList(), namespaces);
}
public void AssemblyNameTests()
{
DatabaseAssembly baseAssembly = serializer.Load(mockContext.Object);
Assert.AreEqual(@"..\..\ExampleDll\TPAApplicationArchitecture.dll", baseAssembly.Name);
}
