public void NotAllowTwoSameIds()
{
TypeDiscriminatorFactory fac = new TypeDiscriminatorFactory();
Assert.Throws <Exception>(() =>
{
fac.Register(typeof(BaseDao));
fac.Register(typeof(BaseDto));
});
}
public void RegisterGeneric()
{
TypeDiscriminatorFactory fac = new TypeDiscriminatorFactory();
fac.RegisterTree(typeof(FileDvo <>));
fac.Register(typeof(BaseDvo <>));
TypeDiscriminator dis = fac.FromType(typeof(DocumentDvo <>));
Assert.Equal(2, dis.Inclusions.Count());
Assert.Single(dis.Exclusions);
}
public void RegisterTwice()
{
TypeDiscriminatorFactory fac = new TypeDiscriminatorFactory();
// Register from Base
fac.Register <BaseDao>();
Assert.Throws <Exception>(() =>
{
fac.Register <BaseDao>();
});
}
public void RegisterAllTree()
{
TypeDiscriminatorFactory fac = new TypeDiscriminatorFactory();
// Register from Base
fac.RegisterTree <BaseDao>();
TypeDiscriminator dis = fac.FromType <DocumentDao>();
Assert.Equal(2, dis.Inclusions.Count());
Assert.Single(dis.Exclusions);
}
public void AllowMoreThanOneTypeByDiscriminator()
{
var fac = new TypeDiscriminatorFactory();
fac.AllowMoreThanOneTypeByDiscriminator = true;
fac.RegisterTree(typeof(BaseDvo <>), typeof(BaseDvo <>).Assembly.DefinedTypes.ToArray());
var res = fac.AllFromId(TypeDiscriminatorIds.Person);
Assert.Equal(2, res.Count());
}
public static void Load(string key)
{
//TypeDiscriminator.KnownTypes = AppDomain.CurrentDomain.GetAssemblies()
// .Where(a => a.FullName.StartsWith("Fuxion"))
// .SelectMany(a => a.DefinedTypes).ToArray();
Factory.RemoveAllInjectors();
if (key == MEMORY)
{
if (memoryFactory == null)
{
var con = new Container();
con.RegisterInstance <ICurrentUserNameProvider>(new AlwaysRootCurrentUserNameProvider());
con.RegisterInstance <IPasswordProvider>(new PasswordProviderMock());
var rep = new IdentityMemoryTestRepository();
con.RegisterInstance <IKeyValueRepository <string, IIdentity> >(rep);
con.RegisterInstance <IIdentityTestRepository>(rep);
con.RegisterSingleton <IdentityManager>();
var fac = new TypeDiscriminatorFactory();
fac.RegisterTree <BaseDao>(typeof(BaseDao).Assembly.DefinedTypes.ToArray());
con.RegisterInstance(fac);
memoryFactory = new SimpleInjectorFactoryInjector(con);
}
Factory.AddInjector(memoryFactory);
}
else if (key == DATABASE)
{
if (databaseFactory == null)
{
var con = new Container();
con.RegisterInstance <ICurrentUserNameProvider>(new AlwaysRootCurrentUserNameProvider());
con.RegisterInstance <IPasswordProvider>(new PasswordProviderMock());
var rep = new IdentityDatabaseEFTestRepository();
rep.Initialize();
con.RegisterInstance <IKeyValueRepository <string, IIdentity> >(new MemoryCachedKeyValueRepository <string, IIdentity>(rep));
con.RegisterInstance <IIdentityTestRepository>(rep);
con.RegisterSingleton <IdentityManager>();
var fac = new TypeDiscriminatorFactory();
fac.RegisterTree <BaseDao>(typeof(BaseDao).Assembly.DefinedTypes.ToArray());
con.RegisterInstance(fac);
databaseFactory = new SimpleInjectorFactoryInjector(con);
}
Factory.AddInjector(databaseFactory);
}
else
{
throw new NotImplementedException($"El escenario '{key}' no esta soportado");
}
}
public void RegisterDisabgleState()
{
TypeDiscriminatorFactory fac = new TypeDiscriminatorFactory();
fac.RegisterTree <BaseDao>();
TypeDiscriminator dis = fac.FromType <FileDao>();
Assert.Equal(3, dis.Inclusions.Count());
Assert.Single(dis.Exclusions);
dis = fac.FromType <BaseDao>();
Assert.Equal(7, dis.Inclusions.Count());
Assert.Empty(dis.Exclusions);
}
public void RegisterTwoTrees()
{
TypeDiscriminatorFactory fac = new TypeDiscriminatorFactory
{
AllowMoreThanOneTypeByDiscriminator = true
};
// Register from Base
fac.RegisterTree <BaseDao>();
fac.RegisterTree(typeof(BaseDvo <>));
fac.FromType <BaseDao>();
}
public void AllowMoreThanOneTypeByDiscriminator()
{
TypeDiscriminatorFactory fac = new TypeDiscriminatorFactory
{
AllowMoreThanOneTypeByDiscriminator = true
};
fac.RegisterTree(typeof(BaseDvo <>), typeof(BaseDvo <>).Assembly.DefinedTypes.ToArray());
IEnumerable <TypeDiscriminator> res = fac.AllFromId(TypeDiscriminatorIds.Person);
Assert.Single(res);
}
public void ManyClassesSameDiscriminators()
{
TypeDiscriminatorFactory fac = new TypeDiscriminatorFactory
{
AllowMoreThanOneTypeByDiscriminator = true
};
// Register from Base
fac.RegisterTree(typeof(BaseDvo <>));
TypeDiscriminator d2 = fac.FromType(typeof(BaseDvo <>));
Assert.Single(d2.Inclusions.Where(d => d.Name == "Person"));
}
public void RegisterTree()
{
var fac = new TypeDiscriminatorFactory();
// Register from Base
fac.RegisterTree <Dao.BaseDao>(typeof(Dao.BaseDao).Assembly.DefinedTypes.ToArray());
var dis = fac.FromType <DocumentDao>();
Assert.Equal(3, dis.Inclusions.Count());
Assert.Equal(1, dis.Exclusions.Count());
fac.ClearAllRegisters();
// Register from File
fac.RegisterTree <FileDao>(typeof(FileDao).Assembly.DefinedTypes.ToArray());
dis = fac.FromType <DocumentDao>();
Assert.Equal(3, dis.Inclusions.Count());
Assert.Equal(1, dis.Exclusions.Count());
fac.ClearAllRegisters();
fac.AllowMoreThanOneTypeByDiscriminator = true;
// Register from generic type BaseDvo<>
fac.RegisterTree(typeof(BaseDvo <>), typeof(BaseDvo <>).Assembly.DefinedTypes.ToArray());
dis = fac.FromType(typeof(LocationDvo <>));
Assert.Equal(3, dis.Inclusions.Count());
Assert.Equal(1, dis.Exclusions.Count());
fac.ClearAllRegisters();
fac.AllowMoreThanOneTypeByDiscriminator = false;
// Register from generic type LicationDvo<>
fac.RegisterTree(typeof(LocationDvo <>), typeof(LocationDvo <>).Assembly.DefinedTypes.ToArray());
dis = fac.FromType <CityDvo>();
Assert.Equal(0, dis.Inclusions.Count());
Assert.Equal(1, dis.Exclusions.Count());
fac.ClearAllRegisters();
// Register from Base and check disable state for Skill
fac.RegisterTree <Dao.BaseDao>(typeof(Dao.BaseDao).Assembly.DefinedTypes.ToArray());
dis = fac.FromType <FileDao>();
Assert.Equal(3, dis.Inclusions.Count());
Assert.Equal(1, dis.Exclusions.Count());
dis = fac.FromType <Dao.BaseDao>();
Assert.Equal(6, dis.Inclusions.Count());
Assert.Equal(0, dis.Exclusions.Count());
}
public void Create()
{
var fac = new TypeDiscriminatorFactory();
fac.GetIdFunction = type => type.Name;
fac.GetNameFunction = type => type.Name.ToUpper();
fac.RegisterTree <Dao.BaseDao>(typeof(Dao.BaseDao).Assembly.DefinedTypes.ToArray());
var dis = fac.FromType <DocumentDao>();
Assert.Equal(dis.Id, typeof(DocumentDao).Name);
Assert.Equal(dis.Name, typeof(DocumentDao).Name.ToUpper());
Assert.Equal(dis.TypeId, fac.DiscriminatorTypeId);
Assert.Equal(dis.TypeName, fac.DiscriminatorTypeName);
Assert.Equal(3, dis.Inclusions.Count());
Assert.Equal(1, dis.Exclusions.Count());
}
public void Create()
{
TypeDiscriminatorFactory fac = new TypeDiscriminatorFactory
{
GetIdFunction = (type, att) => att?.Id ?? type.Name,
GetNameFunction = (type, att) => att?.Name ?? type.Name.ToUpper()
};
fac.RegisterTree <BaseDao>(typeof(BaseDao).Assembly.DefinedTypes.ToArray());
TypeDiscriminator dis = fac.FromType <DocumentDao>();
Assert.Equal(Helpers.TypeDiscriminatorIds.Document, dis.Id);
Assert.Equal(Helpers.TypeDiscriminatorIds.Document, dis.Name);
Assert.Equal(TypeDiscriminator.TypeDiscriminatorId, dis.TypeKey);
Assert.Equal(fac.DiscriminatorTypeName, dis.TypeName);
Assert.Equal(2, dis.Inclusions.Count());
Assert.Single(dis.Exclusions);
}
public void NewTest()
{
TypeDiscriminatorFactory fac = new TypeDiscriminatorFactory();
fac.Register(typeof(BaseDao));
fac.Register(typeof(LocationDao));
fac.Register(typeof(CityDao));
fac.Register(typeof(CountryDao));
TypeDiscriminator dao = fac.FromType <BaseDao>();
fac.Reset();
fac.Register(typeof(BaseDao));
fac.Register(typeof(FileDao));
fac.Register(typeof(DocumentDao));
fac.Register(typeof(WordDocumentDao));
dao = fac.FromType <BaseDao>();
}
public void RegisterFileTree()
{
TypeDiscriminatorFactory fac = new TypeDiscriminatorFactory();
// Register from File
fac.RegisterTree <FileDao>();
TypeDiscriminator dis = null;
Assert.Throws <TypeDiscriminatorRegistrationValidationException>(() =>
{
dis = fac.FromType <DocumentDao>();
});
fac.Reset();
fac.RegisterTree <FileDao>();
fac.Register <BaseDao>();
dis = fac.FromType <DocumentDao>();
Assert.Equal(2, dis.Inclusions.Count());
Assert.Single(dis.Exclusions);
}
public void Equality()
{
TypeDiscriminatorFactory fac = new TypeDiscriminatorFactory
{
AllowMoreThanOneTypeByDiscriminator = true
};
// Register from Base
fac.RegisterTree <BaseDao>();
fac.RegisterTree(typeof(BaseDvo <>));
TypeDiscriminator d1 = fac.FromType <FileDao>();
TypeDiscriminator d2 = fac.FromType(typeof(FileDvo <>));
Assert.True(d1 == d2);
Assert.Equal(d1, d2);
Assert.Same(d1, d2);
TypeDiscriminator[] d1c = new[] { d1 };
Assert.Contains(d2, d1c);
}
public void TypeDiscriminatorAttribute()
{
var fac = new TypeDiscriminatorFactory();
fac.Register(typeof(BaseDao));
fac.Register(typeof(LocationDao));
fac.Register(typeof(CityDao));
fac.Register(typeof(CountryDao));
var dao = fac.FromType <CityDao>();
fac.ClearAllRegisters();
fac.Register(typeof(BaseDto));
fac.Register(typeof(LocationDto));
fac.Register(typeof(CityDto));
fac.Register(typeof(CountryDto));
var dto = fac.FromType <CityDto>();
Assert.True(dao.Id == dto.Id, $"Type discriminators DAO & DTO must have same Id. Values are '{dao.Id}' and '{dto.Id}'");
fac.ClearAllRegisters();
fac.Register(typeof(BaseDvo <>));
fac.Register(typeof(LocationDvo <>));
//fac.Register(typeof(LocationDvo<CityDvo>));
fac.Register(typeof(CityDvo));
fac.Register(typeof(CountryDvo));
var dvo = fac.FromId(TypeDiscriminatorIds.City);
var dvo2 = fac.FromId(TypeDiscriminatorIds.Location);
var dvo3 = fac.FromType(typeof(LocationDvo <>));
//var dvo3 = fac.FromType(typeof(LocationDvo<CityDvo>));
Assert.True(dao.Id == dvo.Id, $"Type discriminators DAO & DVO must have same Id. Values are '{dao.Id}' and '{dvo.Id}'");
Assert.True(dvo2.Id == dvo3.Id, $"Type discriminators DAO & DVO must have same Id. Values are '{dvo2.Id}' and '{dvo3.Id}'");
Assert.True(dvo2.Inclusions.Contains(dvo), $"Type discriminator 'Location' must include 'City'");
}
public void RegisterOnlyttttFile()
{
TypeDiscriminatorFactory fac = new TypeDiscriminatorFactory
{
AllowMoreThanOneTypeByDiscriminator = true
};
// Register from generic type BaseDvo<>
fac.RegisterTree(typeof(BaseDvo <>));
TypeDiscriminator dis = fac.FromType(typeof(LocationDvo <>));
Assert.Equal(3, dis.Inclusions.Count());
Assert.Single(dis.Exclusions);
fac.Reset();
fac.AllowMoreThanOneTypeByDiscriminator = false;
// Register from generic type LocationDvo<>
fac.RegisterTree(typeof(LocationDvo <>));
dis = fac.FromType <CityDvo>();
Assert.Empty(dis.Inclusions);
Assert.Single(dis.Exclusions);
fac.Reset();
}
public static void Reset(this TypeDiscriminatorFactory me)
{
me.AllowMoreThanOneTypeByDiscriminator = false;
me.ClearRegistrations();
}
