public void DoesNotAddArrayTypes()
{
var meta = TestMetaData.CreateClassWithArrayField();
var db = Configure(DatabaseMetaInfo.Create(meta, TestUtils.NewName()));
Assert.NotNull(db);
}
private static Tuple <DatabaseConfigurator, DatabaseMetaInfo> Configurator(IConnectionInfo cxInfo, Assembly assembly)
{
using (var tmpDb = OpenDB(cxInfo))
{
var meta = DatabaseMetaInfo.Create(tmpDb, CreateTypeLoader(cxInfo), assembly);
return(Tuple.Create(DatabaseConfigurator.Create(meta), meta));
}
}
public void CanReuseAssembly()
{
var theClass = QueryForPersonClass(toTest);
var result = DatabaseMetaInfo.Create(DB, TestUtils.TestTypeResolver(), theClass.Assembly);
var theClassAsSencondTime = QueryForPersonClass(result);
Assert.AreEqual(theClass.Assembly, theClassAsSencondTime.Assembly);
Assert.AreEqual(theClass, theClassAsSencondTime);
}
private IObjectContainer Configure(DatabaseMetaInfo info)
{
return(MemoryDBForTests.NewDB(
config =>
{
var toTest = new DatabaseConfigurator(info);
toTest.Configure(config);
}));
}
public void DoesAddPartialGenerics()
{
var meta = TestMetaData.CreateClassListGenericOf(TestMetaData.CreateEmptyClassMetaInfo().Single());
var db = Configure(DatabaseMetaInfo.Create(meta, TestUtils.NewName()));
var typeWithGenericField = meta.First();
var fieldType = typeWithGenericField.Fields.Single();
var typeInfo = db.Ext().Reflector().ForName(fieldType.Type.TypeName.FullName);
Assert.NotNull(typeInfo);
Assert.IsTrue(typeInfo.GetName().StartsWith("System.Collections.Generic.List`1[[ANamespace"));
}
public void HasConfiguredReflector()
{
var meta = TestMetaData.CreateEmptyClassMetaInfo();
var dynamicClass = meta.Single();
var metaInfo =
DatabaseMetaInfo.Create(
TestMetaData.CreateEmptyClassMetaInfo(), AssemblyName());
var db = Configure(metaInfo);
var typeInfo = db.Ext().Reflector().ForName(dynamicClass.TypeName.FullName);
Assert.AreEqual(dynamicClass.TypeName.FullName, typeInfo.GetName());
}
private static Tuple <DatabaseConfigurator, DatabaseMetaInfo> GetConfig(string dbName)
{
var cfg = Db4oEmbedded.NewConfiguration();
cfg.File.ReadOnly = true;
using (var metaInfoDB = Db4oEmbedded.OpenFile(cfg, dbName))
{
var name = TestUtils.NewName();
var meta = DatabaseMetaInfo.Create(metaInfoDB, TypeLoader.Create(new string[0]), name);
var config = DatabaseConfigurator.Create(meta);
return(Tuple.Create(config, meta));
}
}
private Tuple <DatabaseConfigurator, DatabaseMetaInfo> PrepareConfigurator()
{
using (var container = Db4oEmbedded.OpenFile(Databasename))
{
var assembly = new AssemblyName("New.Name")
{
CodeBase = Path.GetTempFileName()
};
var metaInfo =
DatabaseMetaInfo.Create(container, assembly);
return(Tuple.Create(DatabaseConfigurator.Create(metaInfo), metaInfo));
}
}
public questStatus GetDatabaseMetainfo(DatabaseId databaseId, out DatabaseMetaInfo databaseMetaInfo)
{
// Initialize
questStatus status = null;
// Get database metainfo.
status = _dbDatabaseMgr.GetDatabaseMetainfo(databaseId, out databaseMetaInfo);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
return(new questStatus(Severity.Success));
}
public void SetsReflector()
{
var configMock = new Mock <IEmbeddedConfiguration>();
var commonConfig = new Mock <ICommonConfiguration>();
configMock.Setup(c => c.Common).Returns(commonConfig.Object);
var meatInfo = DatabaseMetaInfo.Create(new ITypeDescription[0], AssemblyName());
var toTest = new DatabaseConfigurator(meatInfo);
toTest.Configure(configMock.Object);
commonConfig.Verify(c => c.ReflectWith(It.IsAny <IReflector>()));
}
public void CanOpenCarExample()
{
TestUtils.CopyTestDB(CarDatabase);
var name = TestUtils.NewName();
DatabaseMetaInfo meta = null;
using (
var ctx = DatabaseContext.Create(Db4oEmbedded.OpenFile(CarDatabase), name,
TypeLoader.Create(new string[0])))
{
meta = ctx.MetaInfo;
Assert.NotNull(meta);
}
using (var ctx = DatabaseContext.Create(Db4oEmbedded.OpenFile(CarDatabase), meta))
{
var meta2 = ctx.MetaInfo;
Assert.NotNull(meta2);
}
}
public static DatabaseContext Create(IObjectContainer db, DatabaseMetaInfo metaInfo)
{
return(new DatabaseContext(db, metaInfo));
}
private Type QueryForPersonClass(DatabaseMetaInfo theInfoSource)
{
return((from t in theInfoSource.DyanmicTypesRepresentation.Values
where t.Name.Contains("Person")
select t).Single());
}
public static DatabaseContext Create(IObjectContainer db, AssemblyName theAssembly, TypeResolver resolver)
{
var meta = DatabaseMetaInfo.Create(db, resolver, theAssembly);
return(new DatabaseContext(db, meta));
}
private DatabaseContext(IObjectContainer container, DatabaseMetaInfo metaInfo)
{
this.metaInfo = metaInfo;
disposer.Add(container);
theContainer = container;
}
protected override void FixtureSetup(IObjectContainer db)
{
db.Store(new Person("Roman", "Stoffel", 24));
this.toTest = DatabaseMetaInfo.Create(db, TestUtils.TestTypeResolver(),
TestUtils.NewName());
}
public static DatabaseConfigurator Create(DatabaseMetaInfo metaInfo)
{
return(new DatabaseConfigurator(metaInfo));
}
public DatabaseConfigurator(DatabaseMetaInfo info)
{
this.info = info;
}
