public UserDTO GetByUserName(string name)
{
User user = null;
UserDTO userDTO;
try
{
using (EntityRepositoryFactory factory = new EntityRepositoryFactory())
{
user = factory.GetRepository <User>().GetByName(name);
}
}
catch
{
}
userDTO = new UserDTO()
{
id = user.id,
FirstName = user.Firstname,
LastName = user.Lastname,
Limit = user.Limit
};
return(userDTO);
}
public void TestRejectsNullRepositoryInterface()
{
var repositoryFactory = new EntityRepositoryFactory(context);
var entityRepository = repositoryFactory.GetRepository <IEntityRepository>();
Assert.NotNull(entityRepository);
}
public List <BookDTO> GetBooks()
{
IList <Book> books = null;
List <BookDTO> booksDTO = new List <BookDTO>();
using (EntityRepositoryFactory factory = new EntityRepositoryFactory())
{
books = factory.GetRepository <Book>().Load();
}
foreach (Book book in books)
{
BookDTO dto = new BookDTO()
{
id = book.id,
Author = book.Author,
Name = book.Name,
ReleaseDate = book.Releasedate,
TotalCount = book.Totalcount
};
booksDTO.Add(dto);
}
return(booksDTO);
}
public NhibernateTestSetupHelper(string dataSource, SupportedNHDrivers supportedNhDrivers, string sessionContext, bool executeSchema, FakeFrameworkContext frameworkContext = null, bool useNhProf = false, bool outputMappings = false, bool leaveSessionOpenOnRepositoryDispose = true, bool useSingleSessionForTest = true)
{
_useNhProfiler = useNhProf;
var builder = new NHibernateConfigBuilder(dataSource, "unit-tester", supportedNhDrivers, sessionContext, outputMappings, _useNhProfiler);
NhConfigurationCacheKey cacheKey;
Config = builder.BuildConfiguration(false, out cacheKey, "on_close");
SessionFactory = SessionFactoryCache.GetOrAdd(cacheKey, key => Config.BuildSessionFactory());
SessionForTest = SessionFactory.OpenSession();
var schemaWriter = new StringWriter(new StringBuilder());
if (executeSchema)
{
new SchemaExport(Config).Execute(false, true, false, SessionForTest.Connection, schemaWriter);
}
FakeFrameworkContext = frameworkContext ?? new FakeFrameworkContext();
//var dataContextFactory = new DataContextFactory(fakeFrameworkContext, SessionForTest, true);
//var readWriteRepositoryUnitOfWorkFactory = new ReadWriteUnitOfWorkFactory();
//var writer = new HiveReadWriteProvider(new HiveProviderSetup(fakeFrameworkContext, "r-unit-tester", new FakeHiveProviderBootstrapper(), null, readWriteRepositoryUnitOfWorkFactory, dataContextFactory));
var providerMetadata = new ProviderMetadata("r-unit-tester", new Uri("tester://"), true, false);
//var schemaRepositoryFactory = new NullProviderSchemaRepositoryFactory(providerMetadata, fakeFrameworkContext);
//var revisionRepositoryFactory = new NullProviderRevisionRepositoryFactory<TypedEntity>(providerMetadata, fakeFrameworkContext);
var revisionSchemaSessionFactory = new NullProviderRevisionRepositoryFactory <EntitySchema>(providerMetadata,
FakeFrameworkContext);
ProviderDependencyHelper helper = null;
if (!useSingleSessionForTest)
{
helper = new DependencyHelper(new NhFactoryHelper(Config, null, leaveSessionOpenOnRepositoryDispose, false, FakeFrameworkContext), providerMetadata);
}
else
{
helper = new DependencyHelper(new NhFactoryHelper(null, SessionForTest, leaveSessionOpenOnRepositoryDispose, false, FakeFrameworkContext), providerMetadata);
}
var revisionRepositoryFactory = new RevisionRepositoryFactory(providerMetadata, FakeFrameworkContext, helper);
var schemaRepositoryFactory = new SchemaRepositoryFactory(providerMetadata, revisionSchemaSessionFactory,
FakeFrameworkContext, helper);
var entityRepositoryFactory = new EntityRepositoryFactory(providerMetadata, revisionRepositoryFactory,
schemaRepositoryFactory, FakeFrameworkContext,
helper);
var readUnitFactory = new ReadonlyProviderUnitFactory(entityRepositoryFactory);
var unitFactory = new ProviderUnitFactory(entityRepositoryFactory);
ProviderSetup = new ProviderSetup(unitFactory, providerMetadata, FakeFrameworkContext, null, 0);
ReadonlyProviderSetup = new ReadonlyProviderSetup(readUnitFactory, providerMetadata, FakeFrameworkContext, null, 0);
Func <AbstractMappingEngine> addTypemapper = () => new ManualMapperv2(new NhLookupHelper(entityRepositoryFactory), providerMetadata);
FakeFrameworkContext.TypeMappers.Add(new Lazy <AbstractMappingEngine, TypeMapperMetadata>(addTypemapper, new TypeMapperMetadata(true)));
}
public CacheTestSetupHelper()
{
_cacheReference = new MemoryCache("unit-tester");
var metadata = new ProviderMetadata("cache", new Uri("cache://"), false, true);
var frameworkContext = new FakeFrameworkContext();
var schemaRepositoryFactory = new SchemaRepositoryFactory(
metadata,
new NullProviderRevisionRepositoryFactory <EntitySchema>(metadata, frameworkContext),
frameworkContext,
new DependencyHelper(metadata, new CacheHelper(CacheReference)));
var revisionRepositoryFactory = new EntityRevisionRepositoryFactory(
metadata,
frameworkContext,
new DependencyHelper(metadata, new CacheHelper(CacheReference)));
var entityRepositoryFactory = new EntityRepositoryFactory(
metadata,
revisionRepositoryFactory,
schemaRepositoryFactory,
frameworkContext,
new DependencyHelper(metadata, new CacheHelper(CacheReference)));
var unitFactory = new ProviderUnitFactory(entityRepositoryFactory);
var readonlyUnitFactory = new ReadonlyProviderUnitFactory(entityRepositoryFactory);
ProviderSetup = new ProviderSetup(unitFactory, metadata, frameworkContext, new NoopProviderBootstrapper(), 0);
ReadonlyProviderSetup = new ReadonlyProviderSetup(readonlyUnitFactory, metadata, frameworkContext, new NoopProviderBootstrapper(), 0);
}
public override void Init()
{
var dbConnectionUri = ((IDatabaseSC)Engine.ServiceProvider.GetService("TOM Database")).ConnectionUri;
var factory = new EntityRepositoryFactory(dbConnectionUri);
Engine.ServiceProvider.RegisterService(typeof(IEntityRepositoryFactory), factory);
}
/// <summary>
/// Creates a Hive mapping group for templates
/// </summary>
/// <param name="frameworkContext"></param>
/// <param name="path"></param>
/// <returns></returns>
public static ProviderMappingGroup CreateFakeTemplateMappingGroup(FakeFrameworkContext frameworkContext, string path = "")
{
string binPath;
if (path.IsNullOrWhiteSpace())
{
binPath = Path.Combine(Common.CurrentAssemblyDirectory, "Templates");
}
else
{
binPath = path;
}
// TODO: Would rather we weren't creating files during unit tests esp unless their paths are thread-agnostic and we're sure of deleting them too (APN)
using (new WriteLockDisposable(_fileCreationLocker))
{
//ensure the folder exists
if (!Directory.Exists(binPath))
{
Directory.CreateDirectory(binPath);
}
//create 3 empty template files
var homePagePath = Path.Combine(binPath, "home-page.cshtml");
var textPagePath = Path.Combine(binPath, "text-page.cshtml");
var faqPagePath = Path.Combine(binPath, "faq-page.cshtml");
if (!File.Exists(homePagePath))
{
File.Create(homePagePath);
}
if (!File.Exists(textPagePath))
{
File.Create(textPagePath);
}
if (!File.Exists(faqPagePath))
{
File.Create(faqPagePath);
}
}
var providerMetadata = new ProviderMetadata("templates", new Uri("storage://templates"), true, false);
var dependencyHelper = new DependencyHelper(new Settings("*.cshtml", binPath, "/", "", "", "~/"), providerMetadata);
var entityRepositoryFactory = new EntityRepositoryFactory(providerMetadata, null, null, frameworkContext, dependencyHelper);
var readUnitFactory = new ReadonlyProviderUnitFactory(entityRepositoryFactory);
var readWriteUnitFactory = new ProviderUnitFactory(entityRepositoryFactory);
var bootstrapper = new FakeHiveProviderBootstrapper();
var readonlyProviderSetup = new ReadonlyProviderSetup(readUnitFactory, providerMetadata, frameworkContext, bootstrapper, 0);
var providerSetup = new ProviderSetup(readWriteUnitFactory, providerMetadata, frameworkContext, bootstrapper, 0);
var uriMatch = new WildcardUriMatch(new Uri("storage://templates"));
var persistenceMappingGroup = new ProviderMappingGroup(
"templates",
uriMatch,
readonlyProviderSetup,
providerSetup,
frameworkContext);
return(persistenceMappingGroup);
}
public DbFixture()
{
Context = TestContext.NewInstance();
// 1. Default
// PersonRepository = new PersonRepository(Context);
// 2. Provided
var repositoryFactory = new EntityRepositoryFactory(Context);
PersonRepository = repositoryFactory.GetRepository <IPersonRepository>();
}
public MembershipWrapperTestSetupHelper(FakeFrameworkContext frameworkContext = null)
{
//clear out the Roles/Users xml files for the test membership provider
var current = new DirectoryInfo(Common.CurrentAssemblyDirectory);
while (current.Parent.GetDirectories("App_Data").SingleOrDefault() == null)
{
current = current.Parent;
}
var appData = current.Parent.GetDirectories("App_Data").Single();
foreach (var f in appData.GetFiles("*.xml"))
{
f.Delete();
}
foreach (var f in appData.GetFiles("*.orig"))
{
f.CopyTo(Path.Combine(f.Directory.FullName, Path.GetFileNameWithoutExtension(f.Name) + ".xml"));
}
_fakeFrameworkContext = frameworkContext ?? new FakeFrameworkContext();
var attributeTypeRegistry = new CmsAttributeTypeRegistry();
var mapper = new MembershipWrapperModelMapper(attributeTypeRegistry, _fakeFrameworkContext);
_fakeFrameworkContext.SetTypeMappers(new FakeTypeMapperCollection(new AbstractMappingEngine[] { mapper, new FrameworkModelMapper(_fakeFrameworkContext) }));
var providerMetadata = new ProviderMetadata("r-unit-tester", new Uri("tester://"), true, false);
//need to reset our custom membership provider before each test
var membershipProvider = global::System.Web.Security.Membership.Providers.Cast <MembershipProvider>().OfType <CustomXmlMembershipProvider>().Single();
membershipProvider.Reset();
var configuredProviders = new List <ProviderElement>(new[] { new ProviderElement()
{
Name = "test", WildcardCharacter = "*"
} });
var revisionSchemaFactory = new NullProviderRevisionRepositoryFactory <EntitySchema>(providerMetadata, _fakeFrameworkContext);
var revisionRepositoryFactory = new NullProviderRevisionRepositoryFactory <TypedEntity>(providerMetadata, _fakeFrameworkContext);
var schemaRepositoryFactory = new NullProviderSchemaRepositoryFactory(providerMetadata, _fakeFrameworkContext);
var entityRepositoryFactory = new EntityRepositoryFactory(providerMetadata, revisionRepositoryFactory, schemaRepositoryFactory, _fakeFrameworkContext,
new Lazy <IEnumerable <MembershipProvider> >(() => global::System.Web.Security.Membership.Providers.Cast <MembershipProvider>()),
configuredProviders);
var readUnitFactory = new ReadonlyProviderUnitFactory(entityRepositoryFactory);
var unitFactory = new ProviderUnitFactory(entityRepositoryFactory);
ProviderSetup = new ProviderSetup(unitFactory, providerMetadata, _fakeFrameworkContext, null, 0);
ReadonlyProviderSetup = new ReadonlyProviderSetup(readUnitFactory, providerMetadata, _fakeFrameworkContext, null, 0);
}
public IoHiveTestSetupHelper(string supportedExtensions, FakeFrameworkContext frameworkContext = null)
{
FrameworkContext = frameworkContext ?? new FakeFrameworkContext();
TestDirectory = GetTestDirectory();
ProviderMetadata = new ProviderMetadata("test-provider", new Uri("storage://"), true, false);
Settings = new Settings(supportedExtensions, TestDirectory.FullName, TestDirectory.FullName, String.Empty, String.Empty, "~/");
EntityRepositoryFactory = new EntityRepositoryFactory(ProviderMetadata, null, null, Settings, FrameworkContext);
EntityRepository = EntityRepositoryFactory.GetRepository() as EntityRepository;
var readonlyFactory = new ReadonlyProviderUnitFactory(EntityRepositoryFactory);
var factory = new ProviderUnitFactory(EntityRepositoryFactory);
ReadonlyProviderSetup = new ReadonlyProviderSetup(readonlyFactory, ProviderMetadata, FrameworkContext, new NoopProviderBootstrapper(), 0);
ProviderSetup = new ProviderSetup(factory, ProviderMetadata, FrameworkContext, new NoopProviderBootstrapper(), 0);
}
public BookDTO GetBookById(int index)
{
BookDTO book = new BookDTO();
using (EntityRepositoryFactory factory = new EntityRepositoryFactory())
{
var cache = factory.GetRepository <Book>().GetByIndex(index);
book.id = cache.id;
book.Name = cache.Name;
book.Author = cache.Author;
book.ReleaseDate = cache.Releasedate;
book.TotalCount = cache.Totalcount;
}
return(book);
}
public List <UserDTO> GetUsers()
{
IList <User> users = null;
List <UserDTO> usersDTO = new List <UserDTO>();
try
{
using (EntityRepositoryFactory factory = new EntityRepositoryFactory())
{
users = factory.GetRepository <User>().Load();
}
}
catch
{
}
foreach (User user in users)
{
UserDTO dto = new UserDTO()
{
id = user.id.Value,
FirstName = user.Firstname,
LastName = user.Lastname,
Limit = user.Limit,
/*
* bookDTO = new BookDTO
* {
* id = user.book.id.Value,
* Author = user.book.Author,
* Name = user.book.Name,
* ReleaseDate = user.book.Releasedate,
* TotalCount = user.book.Totalcount
* }
*/
};
usersDTO.Add(dto);
}
///here shit happens
return(usersDTO);
}
public List <UserDTO> GetUsers()
{
IList <User> users = null;
List <UserDTO> usersDTO = new List <UserDTO>();
using (EntityRepositoryFactory factory = new EntityRepositoryFactory())
{
users = factory.GetRepository <User>().Load();
}
foreach (User user in users)
{
UserDTO dto = new UserDTO()
{
id = user.id.Value,
FirstName = user.Firstname,
LastName = user.Lastname,
Limit = user.Limit
};
usersDTO.Add(dto);
}
return(usersDTO);
}
public ProviderUnit Create()
{
return(new ProviderUnit(EntityRepositoryFactory.GetRepository(), UnitScopedCacheFactory()));
}
public ExamineTestSetupHelper(FakeFrameworkContext frameworkContext = null, bool isPassthrough = false)
{
var examineWorkingFolder = new DirectoryInfo(Path.Combine(Common.CurrentAssemblyDirectory, "Examine", Guid.NewGuid().ToString() + Thread.CurrentThread.ManagedThreadId));
if (!examineWorkingFolder.Exists)
{
Directory.CreateDirectory(examineWorkingFolder.FullName);
}
//clear out old folders
var parentFolder = examineWorkingFolder.Parent;
foreach (var f in parentFolder.GetDirectories().Where(x => x.CreationTimeUtc < DateTime.UtcNow.Subtract(TimeSpan.FromMinutes(5))))
{
try
{
Directory.Delete(f.FullName, true);
}
catch (IOException)
{
//ignore
}
}
LogHelper.TraceIfEnabled <ExamineTestSetupHelper>("Index setup in folder {0}", () => examineWorkingFolder.FullName);
//var disk = new Lucene.Net.Store.RAMDirectory();
var disk = new Lucene.Net.Store.SimpleFSDirectory(examineWorkingFolder);
Indexer = new UmbracoExamineIndexer(
new StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_29),
SynchronizationType.Synchronized,
disk);
_fakeFrameworkContext = frameworkContext ?? new FakeFrameworkContext();
Searcher = new LuceneSearcher(new StandardAnalyzer(Lucene.Net.Util.Version.LUCENE_29), disk);
ExamineManager = new ExamineManager(new[] { Searcher }, new[] { Indexer }, Searcher);
ExamineHelper = new ExamineHelper(ExamineManager, _fakeFrameworkContext, false); //false to not use cache
var examineMapper = new ExamineModelMapper(ExamineHelper, _fakeFrameworkContext);
_fakeFrameworkContext.SetTypeMappers(new FakeTypeMapperCollection(new AbstractMappingEngine[] { examineMapper, new FrameworkModelMapper(_fakeFrameworkContext) }));
var providerMetadata = new ProviderMetadata("r-examine-unit-tester", new Uri("tester://"), true, isPassthrough);
var revisionSchemaSessionFactory = new NullProviderRevisionRepositoryFactory <EntitySchema>(providerMetadata, FrameworkContext);
var revisionRepositoryFactory = new RevisionRepositoryFactory(providerMetadata, FrameworkContext, ExamineHelper);
//var revisionRepositoryFactory = new NullProviderRevisionSessionFactory<TypedEntity>(providerMetadata, FrameworkContext);
var schemaRepositoryFactory = new SchemaRepositoryFactory(providerMetadata, revisionSchemaSessionFactory, FrameworkContext, ExamineHelper);
var entityRepositoryFactory = new EntityRepositoryFactory(providerMetadata, revisionRepositoryFactory, schemaRepositoryFactory, FrameworkContext, ExamineHelper);
var readUnitFactory = new ReadonlyProviderUnitFactory(entityRepositoryFactory);
var unitFactory = new ProviderUnitFactory(entityRepositoryFactory);
ProviderSetup = new ProviderSetup(unitFactory, providerMetadata, FrameworkContext, null, 0);
ReadonlyProviderSetup = new ReadonlyProviderSetup(readUnitFactory, providerMetadata, FrameworkContext, null, 0);
//ensure that the index exists
Indexer.CreateIndex(true);
}