protected virtual void Init() { var attributeTypeRegistry = new CmsAttributeTypeRegistry(); AttributeTypeRegistry.SetCurrent(attributeTypeRegistry); FrameworkContext = new FakeFrameworkContext(); var hive = CreateHiveManager(); UmbracoApplicationContext = CreateApplicationContext(hive); var resolverContext = new MockedMapResolverContext(FrameworkContext, hive, new MockedPropertyEditorFactory(UmbracoApplicationContext), new MockedParameterEditorFactory()); var webmModelMapper = new CmsModelMapper(resolverContext); FrameworkContext.SetTypeMappers(new FakeTypeMapperCollection(new AbstractMappingEngine[] { webmModelMapper, new FrameworkModelMapper(FrameworkContext) })); DevDataset = DemoDataHelper.GetDemoData(UmbracoApplicationContext, attributeTypeRegistry); FixedPropertyEditors = new FixedPropertyEditors(UmbracoApplicationContext); //ensure model binders ModelBinders.Binders.Remove(typeof(HiveId)); ModelBinders.Binders.Add(typeof(HiveId), new HiveIdModelBinder()); ModelBinders.Binders.Remove(typeof(DocumentTypeEditorModel)); ModelBinders.Binders.Add(typeof(DocumentTypeEditorModel), new DocumentTypeModelBinder()); ModelBinders.Binders.Remove(typeof(SizeModelBinder)); ModelBinders.Binders.Add(typeof(SizeModelBinder), new SizeModelBinder()); //set the model meta data provider ModelMetadataProviders.Current = new UmbracoModelMetadataProvider(); }
public void WhenSourceIsAccessed_LazyRelation_CallsRepository_WithBothSourceAndDestinationId() { // Arrange var context = new FakeFrameworkContext(); var providerGroup = GroupedProviderMockHelper.GenerateProviderGroup(1, 0, 50, context); var idRoot = new Uri("oh-yeah://this-is-my-root/"); var groupUnitFactory = new GroupUnitFactory(providerGroup.Writers, idRoot, FakeHiveCmsManager.CreateFakeRepositoryContext(context), context); HiveId int1 = HiveId.ConvertIntToGuid(1); HiveId int2 = HiveId.ConvertIntToGuid(2); // Act & Assert using (var uow = groupUnitFactory.Create()) { var lazyRelation = new LazyRelation<TypedEntity>(uow.Repositories, FixedRelationTypes.DefaultRelationType, int1, int2, 0); IReadonlyRelation<IRelatableEntity, IRelatableEntity> blah = lazyRelation; IRelationById blah2 = lazyRelation; Assert.False(lazyRelation.IsLoaded); var source = lazyRelation.Source; Assert.True(lazyRelation.IsLoaded); var dest = lazyRelation.Destination; Assert.NotNull(source); Assert.NotNull(dest); } }
public XmlStoreHiveTests() { using (DisposableTimer.TraceDuration<XmlStoreHiveTests>("Start setup", "End setup")) { // Create reader var xmlPath = Path.Combine( Path.GetDirectoryName(Assembly.GetExecutingAssembly().CodeBase.Substring("file:\\\\".Length + 1)), "App_Data\\umbraco.config"); _fakeFrameworkContext = new FakeFrameworkContext(); _dataContextFactory = new DataContextFactory(xmlPath); _readOnlyUnitOfWorkFactory = new ReadOnlyUnitOfWorkFactory(); _directHiveReadProvider = new HiveReadProvider(new HiveProviderSetup(_fakeFrameworkContext, "r-unit-tester", new FakeHiveProviderBootstrapper(), _readOnlyUnitOfWorkFactory, null, _dataContextFactory)); // Create writer _readWriteUnitOfWorkFactory = new ReadWriteUnitOfWorkFactory(); _writeProvider = new HiveReadWriteProvider(new HiveProviderSetup(_fakeFrameworkContext, "rw-unit-tester", new FakeHiveProviderBootstrapper(), null, _readWriteUnitOfWorkFactory, _dataContextFactory)); // Create hive wrappers for the readers and writers var governorRUowFactory = new ReadOnlyUnitOfWorkFactoryWrapper(new[] { _directHiveReadProvider }); var governorRWUowFactory = new ReadWriteUnitOfWorkFactoryWrapper(new[] { _writeProvider }); _hiveReadProviderViaGovernor = new Framework.Hive.PersistenceGovernor.HiveReadProvider(new HiveProviderSetup(_fakeFrameworkContext, "r-unit-tester", new FakeHiveProviderBootstrapper(), governorRUowFactory, null, null), new[] { _directHiveReadProvider }); _hiveReadWriteProviderViaGovernor = new Framework.Hive.PersistenceGovernor.HiveReadWriteProvider(new HiveProviderSetup(_fakeFrameworkContext, "rw-unit-tester", new FakeHiveProviderBootstrapper(), null, governorRWUowFactory, null), new[] { _writeProvider }); } }
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 void WhenGetIsCalled_WithMultipleIds_MultipleItemsAreReturned( int allItemCount, int numbProviderCount, int numberOfPassthroughProviders) { // Arrange var context = new FakeFrameworkContext(); var providerGroup = GroupedProviderMockHelper.GenerateProviderGroup(numbProviderCount, numberOfPassthroughProviders, allItemCount, context); var idRoot = new Uri("oh-yeah://this-is-my-root/"); var groupUnitFactory = new GroupUnitFactory(providerGroup.Writers, idRoot, FakeHiveCmsManager.CreateFakeRepositoryContext(context), context); HiveId int1 = HiveId.ConvertIntToGuid(1); HiveId int2 = HiveId.ConvertIntToGuid(2); HiveId int3 = HiveId.ConvertIntToGuid(3); // Act & Assert using (var uow = groupUnitFactory.Create<IContentStore>()) { Assert.NotNull(uow.IdRoot); Assert.AreEqual(uow.IdRoot, idRoot); // TODO: This looks like a poor test since Get with multiple ids is actually just mocked to return three // but the purpose of this test is to establish that when running with multiple providers, some of which // are passthrough, only the correct number of items should be returned var items = uow.Repositories.Get<TypedEntity>(true, int1, int2, int3); Assert.That(items.Count(), Is.EqualTo(3 * numbProviderCount), "item count wrong"); // Assert that the correct number of relations are returned too including passthrough providers being filtered for var parents = uow.Repositories.GetParentRelations(HiveId.Empty); Assert.That(parents.Count(), Is.EqualTo(GroupedProviderMockHelper.MockRelationCount * numbProviderCount), "parents count wrong"); } }
/// <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 void Setup() { _frameworkContext = new FakeFrameworkContext(); _unitScopedCache = new DictionaryScopedCache(); var providerGroup = GroupedProviderMockHelper.GenerateProviderGroup(1, 0, 1, _frameworkContext); var idRoot = new Uri("oh-yeah://this-is-my-root/"); _groupUnitFactory = new GroupUnitFactory(providerGroup.Writers, idRoot, FakeHiveCmsManager.CreateFakeRepositoryContext(_frameworkContext), _frameworkContext, () => _unitScopedCache); }
public void Setup() { var frameworkContext = new FakeFrameworkContext(); var frameworkModelMapper = new FrameworkModelMapper(frameworkContext); _mapper = new MembershipWrapperModelMapper(_attributeTypeRegistry, frameworkContext); frameworkContext.SetTypeMappers(new FakeTypeMapperCollection(new AbstractMappingEngine[] {frameworkModelMapper, _mapper})); }
public void Setup() { // Setup languages _languages = new List<LanguageElement> { new LanguageElement { IsoCode = "en-GB", Name = "English (United Kingdom)", Fallbacks = new FallbackCollection { new FallbackElement { IsoCode = "en-US" } } }, new LanguageElement { IsoCode = "en-US", Name = "English (United States)", Fallbacks = new FallbackCollection() } }; // Setup hive var context = new FakeFrameworkContext(); //_hiveManager = FakeHiveCmsManager.NewWithNhibernate(new[] { CreateFakeDictionaryMappingGroup(context) }, context); _hiveManager = new HiveManager(CreateFakeDictionaryMappingGroup(context), context); var root = new TypedEntity { Id = FixedHiveIds.DictionaryVirtualRoot, EntitySchema = FixedSchemas.DictionaryRootSchema, UtcCreated = DateTime.Now, UtcModified = DateTime.Now, UtcStatusChanged = DateTime.Now }; var item1 = CreateDictionatyItem("test1", new Dictionary<string, string> { { "en-GB", "Hello GB" }, { "en-US", "Hello US" } }); var item2 = CreateDictionatyItem("test2", new Dictionary<string, string> { { "en-GB", "World GB" }, { "en-US", "World US" } }); var item3 = CreateDictionatyItem("test3", new Dictionary<string, string> { { "en-GB", "Something GB" }, { "en-US", "Something US" } }); // Act var writer = _hiveManager.GetWriter<IDictionaryStore>(); using (var uow = writer.Create<IDictionaryStore>()) { // Add entities uow.Repositories.AddOrUpdate(root); uow.Repositories.Revisions.AddOrUpdate(item1); uow.Repositories.Revisions.AddOrUpdate(item2); uow.Repositories.Revisions.AddOrUpdate(item3); // Add all relations uow.Repositories.AddRelation(FixedHiveIds.DictionaryVirtualRoot, item1.Item.Id, FixedRelationTypes.DefaultRelationType, 0); uow.Repositories.AddRelation(FixedHiveIds.DictionaryVirtualRoot, item2.Item.Id, FixedRelationTypes.DefaultRelationType, 0); uow.Repositories.AddRelation(item2.Item.Id, item3.Item.Id, FixedRelationTypes.DefaultRelationType, 0); uow.Complete(); } }
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); }
public override void TestSetUp() { var serializer = new ServiceStackSerialiser(); _frameworkContext = new FakeFrameworkContext(serializer); _configuration = new IndexConfiguration(GetPathForTest()); var controller = new IndexController(_configuration, _frameworkContext); CacheProvider = new CacheProvider(controller, false); }
public static StubIORepositoryReadWriter CreateRepositoryReadWriter(string supportedExtensions) { var frameworkContext = new FakeFrameworkContext(); var hiveProvider = new HiveReadWriteProvider(new HiveProviderSetup(frameworkContext, "rw-test-provider", null, null, null, null)); var dir = new DirectoryInfo(TestHelper.AssemblyDirectory); //var dir = new FileInfo(Assembly.GetExecutingAssembly().Location).Directory; //dir = new DirectoryInfo(Path.Combine(dir.FullName, @"..\..\")); var dataContext = new DataContext(hiveProvider, supportedExtensions, dir.FullName, string.Empty, string.Empty); return(new StubIORepositoryReadWriter(dataContext)); }
public static StubIORepositoryReadWriter CreateRepositoryReadWriter(string supportedExtensions) { var frameworkContext = new FakeFrameworkContext(); var hiveProvider = new HiveReadWriteProvider(new HiveProviderSetup(frameworkContext, "rw-test-provider", null, null, null, null)); var dir = new DirectoryInfo(TestHelper.AssemblyDirectory); //var dir = new FileInfo(Assembly.GetExecutingAssembly().Location).Directory; //dir = new DirectoryInfo(Path.Combine(dir.FullName, @"..\..\")); var dataContext = new DataContext(hiveProvider, supportedExtensions, dir.FullName, string.Empty, string.Empty); return new StubIORepositoryReadWriter(dataContext); }
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))); }
/// <summary> /// Gets a mocked IHiveManager. /// </summary> /// <param name="frameworkContext">The framework context.</param> /// <returns></returns> public static IHiveManager GetManager(IFrameworkContext frameworkContext = null) { if (frameworkContext == null) { frameworkContext = new FakeFrameworkContext(); } var hive = Substitute.For <IHiveManager>(); hive.FrameworkContext.Returns(frameworkContext); return(hive); }
public void MultipleTransactionCommits_ThrowsError() { // Arrange var context = new FakeFrameworkContext(); var provider = GroupedProviderMockHelper.MockEntityRepositoryFactory(1, new ProviderMetadata("test", new Uri("test://"), true, false), context); var factory = new ProviderUnitFactory(provider); // Act using (var uow = factory.Create()) { uow.Complete(); Assert.Throws<TransactionCompletedException>(uow.Complete, "Second completion did not throw exception"); } }
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 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); }
private static HiveReadWriteProvider CreateReadWritter() { var builder = new NHibernateConfigBuilder("data source=:memory:", "unit-tester", SupportedNHDrivers.SqlLite, "thread_static", false); var config = builder.BuildConfiguration(); var sessionFactory = config.BuildSessionFactory(); _sessionForTest = sessionFactory.OpenSession(); var schemaWriter = new StringWriter(new StringBuilder()); new SchemaExport(config).Execute(false, true, false, _sessionForTest.Connection, schemaWriter); var fakeFrameworkContext = 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)); fakeFrameworkContext.TypeMappers.Add( new Lazy<AbstractTypeMapper, TypeMapperMetadata>( () => new ManualMapper(new NhLookupHelper(dataContextFactory), writer), new TypeMapperMetadata(true))); return writer; }
public CachingProviderTests() { _fakeFrameworkContext = new FakeFrameworkContext(); var inMemory = new NHibernateInMemoryRepository(_fakeFrameworkContext); var dataContextFactory = new DataContextFactory(); var readWriteUnitOfWorkFactory = new ReadWriteUnitOfWorkFactory(); var directReaderProvider = new HiveReadWriteProvider(new HiveProviderSetup(_fakeFrameworkContext, "r-unit-tester", new FakeHiveProviderBootstrapper(), readWriteUnitOfWorkFactory, readWriteUnitOfWorkFactory, dataContextFactory)); var directReadWriteProvider = directReaderProvider; // Create hive wrappers for the readers and writers var governorRUowFactory = new ReadOnlyUnitOfWorkFactoryWrapper(new[] { directReaderProvider, inMemory.HiveReadProvider }); var governorRWUowFactory = new ReadWriteUnitOfWorkFactoryWrapper(new[] { directReadWriteProvider, inMemory.ReadWriteProvider }); _readerProviderViaHiveGovernor = _directReaderProvider = new Framework.Hive.PersistenceGovernor.HiveReadProvider(new HiveProviderSetup(_fakeFrameworkContext, "r-unit-wrapper", new FakeHiveProviderBootstrapper(), governorRUowFactory, null, null), new[] { _directReaderProvider }); _readWriteProviderViaHiveGovernor = _directReadWriteProvider = new Framework.Hive.PersistenceGovernor.HiveReadWriteProvider(new HiveProviderSetup(_fakeFrameworkContext, "rw-unit-wrapper", new FakeHiveProviderBootstrapper(), governorRUowFactory, governorRWUowFactory, null), new[] { _directReadWriteProvider }); }
public void HiveManager_OpensContentWriter_InferredFromRepositoryType() { // Arrange var context = new FakeFrameworkContext(); var metadata = new ProviderMetadata("test", new Uri("unimportant://"), true, false); var groups = new[] { new ProviderMappingGroup("default-content", new WildcardUriMatch("content://*"), new UninstalledReadonlyProviderSetup(metadata, context, new NoopProviderBootstrapper(), 0), new UninstalledProviderSetup(metadata, context, new NoopProviderBootstrapper(), 0), context), new ProviderMappingGroup("default-storage", new WildcardUriMatch("storage://*"), new UninstalledReadonlyProviderSetup(metadata, context, new NoopProviderBootstrapper(), 0), new UninstalledProviderSetup(metadata, context, new NoopProviderBootstrapper(), 0), context), new ProviderMappingGroup("default-assets", new WildcardUriMatch("assets://*"), new UninstalledReadonlyProviderSetup(metadata, context, new NoopProviderBootstrapper(), 0), new UninstalledProviderSetup(metadata, context, new NoopProviderBootstrapper(), 0), context) }; HiveManager manager = new HiveManager(groups , context); // Act var writer = manager.OpenWriter<IContentStore>(); // Assert Assert.IsNotNull(writer); }
public void HiveManagerExtension_GetsProviderMatch_FromCustomRoot(string customRoot) { // Arrange var context = new FakeFrameworkContext(); var metadata = new ProviderMetadata("test", new Uri("unimportant://"), true, false); var groups = new[] { new ProviderMappingGroup("default-content", new WildcardUriMatch("content://*"), new UninstalledReadonlyProviderSetup(metadata, context, new NoopProviderBootstrapper(), 0), new UninstalledProviderSetup(metadata, context, new NoopProviderBootstrapper(), 0), context), new ProviderMappingGroup("default-storage", new WildcardUriMatch("storage://*"), new UninstalledReadonlyProviderSetup(metadata, context, new NoopProviderBootstrapper(), 0), new UninstalledProviderSetup(metadata, context, new NoopProviderBootstrapper(), 0), context), new ProviderMappingGroup("default-assets", new WildcardUriMatch("assets://*"), new UninstalledReadonlyProviderSetup(metadata, context, new NoopProviderBootstrapper(), 0), new UninstalledProviderSetup(metadata, context, new NoopProviderBootstrapper(), 0), context) }; HiveManager manager = new HiveManager(groups, context); // Act var work = manager.GetProviderGroup(new Uri(customRoot)); // Assert Assert.NotNull(work); }
private ProviderMappingGroup CreateFakeDictionaryMappingGroup(FakeFrameworkContext frameworkContext) { var helper = new NhibernateTestSetupHelper(frameworkContext); var uriMatch = new WildcardUriMatch(new Uri("dictionary://")); var persistenceMappingGroup = new ProviderMappingGroup( "dictionary", uriMatch, helper.ReadonlyProviderSetup, helper.ProviderSetup, frameworkContext); return persistenceMappingGroup; }
private void RunTest( HiveManager hiveManager, FakeFrameworkContext frameworkContext, Action installCallback = null) { var attributeTypeRegistry = new CmsAttributeTypeRegistry(); AttributeTypeRegistry.SetCurrent(attributeTypeRegistry); var appContext = new FakeUmbracoApplicationContext(hiveManager, false); var mockedPropertyEditorFactory = new MockedPropertyEditorFactory(appContext); var resolverContext = new MockedMapResolverContext(frameworkContext, hiveManager, mockedPropertyEditorFactory, new MockedParameterEditorFactory()); var webmModelMapper = new CmsModelMapper(resolverContext); frameworkContext.SetTypeMappers(new FakeTypeMapperCollection(new AbstractMappingEngine[] { webmModelMapper, new FrameworkModelMapper(frameworkContext) })); var devDataset = DemoDataHelper.GetDemoData(appContext, attributeTypeRegistry); //Seup permissions var permissions = new Permission[] { new SavePermission(), new PublishPermission(), new HostnamesPermission(), new CopyPermission(), new MovePermission() } .Select(x => new Lazy<Permission, PermissionMetadata>(() => x, new PermissionMetadata(new Dictionary<string, object> { {"Id", x.Id}, {"Name", x.Name}, {"Type", x.Type} }))).ToArray(); var coreDataInstallTask = new EnsureCoreDataTask(frameworkContext, hiveManager, permissions); var devDatasetInstallTask = new DevDatasetInstallTask(frameworkContext, mockedPropertyEditorFactory, hiveManager, attributeTypeRegistry); //Act coreDataInstallTask.InstallOrUpgrade(); if (installCallback != null) installCallback(); devDatasetInstallTask.InstallOrUpgrade(); if (installCallback != null) installCallback(); //Assert var totalSchemaCount = CoreCmsData.RequiredCoreSchemas().Count() + devDataset.DocTypes.Count() + 1; // +1 for SystemRoot schema var totalEntityCount = CoreCmsData.RequiredCoreUserGroups(permissions).Count() + CoreCmsData.RequiredCoreRootNodes().Count() + devDataset.ContentData.Count(); var totalAttributeTypeCount = CoreCmsData.RequiredCoreSystemAttributeTypes().Count() + CoreCmsData.RequiredCoreUserAttributeTypes().Count(); DoCoreAssertions(hiveManager, totalSchemaCount, totalEntityCount, totalAttributeTypeCount, 2, permissions); }
public NhibernateTestSetupHelper(FakeFrameworkContext frameworkContext = null) : this("data source=:memory:", SupportedNHDrivers.SqlLite, "call", true, frameworkContext, useNhProf:false) { }
public NhibernateTestSetupHelper(string dataSource, SupportedNHDrivers supportedNhDrivers, string sessionContext, bool executeSchema, FakeFrameworkContext frameworkContext = null, bool useNhProf = false) { var builder = new NHibernateConfigBuilder(dataSource, "unit-tester", supportedNhDrivers, sessionContext, false, useNhProf); NhConfigurationCacheKey cacheKey; Config = builder.BuildConfiguration(false, out cacheKey); 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); var revisionRepositoryFactory = new RevisionRepositoryFactory(providerMetadata, FakeFrameworkContext, SessionForTest, true); var schemaRepositoryFactory = new SchemaRepositoryFactory(providerMetadata, revisionSchemaSessionFactory, FakeFrameworkContext, SessionForTest, true); var entityRepositoryFactory = new EntityRepositoryFactory(providerMetadata, revisionRepositoryFactory, schemaRepositoryFactory, FakeFrameworkContext, SessionForTest, true); 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))); }
/// <summary> /// Creates a new HiveManager with an Examine default mapping group and the supplied provider mapping groups appended /// </summary> /// <param name="providerMappingGroups"></param> /// <param name="frameworkContext"></param> /// <returns></returns> public static IHiveManager NewWithExamine(IEnumerable <ProviderMappingGroup> providerMappingGroups, FakeFrameworkContext frameworkContext) { var helper = new ExamineTestSetupHelper(frameworkContext); var uriMatch = new WildcardUriMatch(new Uri("content://")); var persistenceMappingGroup = new ProviderMappingGroup( "default", uriMatch, helper.ReadonlyProviderSetup, helper.ProviderSetup, frameworkContext); return(new HiveManager(new[] { persistenceMappingGroup }.Union(providerMappingGroups), frameworkContext)); }
private HiveId ExecuteBinding(IValueProvider form, RouteData routeData, out ModelBindingContext bindingContext, out ControllerContext controllerContext) { var modelBinder = new HiveIdModelBinder(); var httpContextFactory = new FakeHttpContextFactory("~/Umbraco/Editors/ContentEditor/Edit/1", routeData); var fakeFrameworkContext = new FakeFrameworkContext(); var hive = FakeHiveCmsManager.New(fakeFrameworkContext); var appContext = new FakeUmbracoApplicationContext(hive); var resolverContext = new MockedMapResolverContext(fakeFrameworkContext, hive, new MockedPropertyEditorFactory(appContext), new MockedParameterEditorFactory()); var webmModelMapper = new CmsModelMapper(resolverContext); fakeFrameworkContext.SetTypeMappers(new FakeTypeMapperCollection(new AbstractMappingEngine[] { webmModelMapper, new FrameworkModelMapper(fakeFrameworkContext) })); var umbracoApplicationContext = new FakeUmbracoApplicationContext(hive); controllerContext = new ControllerContext( httpContextFactory.RequestContext, new ContentEditorController(new FakeBackOfficeRequestContext(umbracoApplicationContext))); //put both the form and route values in the value provider var routeDataValueProvider = new RouteDataValueProvider(controllerContext); var values = new ValueProviderCollection(new List<IValueProvider>() { form, routeDataValueProvider }); bindingContext = GetBindingContext(new HiveId(1), values); //do the binding! var model = modelBinder.BindModel(controllerContext, bindingContext); //assert! Assert.That(model, Is.InstanceOf<HiveId>(), "Model isn't a HiveId"); var boundModel = (HiveId)model; return boundModel; }
public NHibernateHiveTests() { _fakeFrameworkContext = new FakeFrameworkContext(); _repository = new NHibernateInMemoryRepository(_fakeFrameworkContext); }
/// <summary> /// Creates a new HiveManager with only the NHibernate default mapping group /// </summary> /// <param name="frameworkContext"></param> /// <returns></returns> public static IHiveManager New(FakeFrameworkContext frameworkContext) { return(NewWithNhibernate(new ProviderMappingGroup[] {}, frameworkContext)); }
public void WhenTypedEntity_IsReturnedFromGroupEntityRepository_AllObjects_HaveProviderId() { // Arrange var context = new FakeFrameworkContext(); var providerGroup = GroupedProviderMockHelper.GenerateProviderGroup(1, 0, 50, context); var idRoot = new Uri("myroot://yeah/"); var groupUnitFactory = new GroupUnitFactory(providerGroup.Writers, idRoot, FakeHiveCmsManager.CreateFakeRepositoryContext(context), context); // Act & Assert using (var uow = groupUnitFactory.Create()) { Assert.NotNull(uow.IdRoot); Assert.AreEqual(uow.IdRoot, idRoot); var singleItem = uow.Repositories.Get<TypedEntity>(HiveId.Empty); var allDependentItems = singleItem.GetAllIdentifiableItems().ToArray(); Assert.IsTrue(allDependentItems.Any()); Assert.That(allDependentItems.Select(x => x.Id).Distinct().Count(), Is.GreaterThan(1)); foreach (var referenceByHiveId in allDependentItems) { AssertEntityIdIsRooted(idRoot, referenceByHiveId.Id); } } }
public void WhenTypedEntity_IsReturnedFromGroupEntityRepository_ItsRelationProxies_HaveAbsoluteId() { // Arrange var context = new FakeFrameworkContext(); var providerGroup = GroupedProviderMockHelper.GenerateProviderGroup(1, 0, 50, context); var idRoot = new Uri("myroot://yeah/"); var groupUnitFactory = new GroupUnitFactory(providerGroup.Writers, idRoot, FakeHiveCmsManager.CreateFakeRepositoryContext(context), context); // Act & Assert using (var uow = groupUnitFactory.Create()) { Assert.NotNull(uow.IdRoot); Assert.AreEqual(uow.IdRoot, idRoot); var item = uow.Repositories.Get<TypedEntity>(HiveId.Empty); AssertIdsOfRelationProxiesForEntity(item, idRoot); var items = uow.Repositories.GetAll<TypedEntity>(); Assert.True(items.Any()); foreach (var typedEntity in items) { AssertIdsOfRelationProxiesForEntity(typedEntity, idRoot); } } }
public IoHiveTestSetupHelper(FakeFrameworkContext frameworkContext = null) : this("*.dll", frameworkContext) { }
public void ProviderMappingGroup_IsMatchForUri(string assertUri, string[] wildcardMatches, bool shouldMatch) { // Arrange var matches = wildcardMatches.Select(x => new WildcardUriMatch(x)).ToList(); var context = new FakeFrameworkContext(); var metadata = new ProviderMetadata("test", new Uri("unimportant://"), true, false); var readonlySetup = new UninstalledReadonlyProviderSetup(metadata, context, new NoopProviderBootstrapper(), 0); var setup = new UninstalledProviderSetup(metadata, context, new NoopProviderBootstrapper(), 0); var group = new ProviderMappingGroup("default", matches, Enumerable.Repeat(readonlySetup, 1), Enumerable.Repeat(setup, 1), new FakeFrameworkContext()); // Assert Assert.That(shouldMatch, Is.EqualTo(group.IsMatchForUri(new Uri(assertUri)).Success)); }
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); }
public NhibernateTestSetupHelper(FakeFrameworkContext frameworkContext = null) : this("data source=:memory:", SupportedNHDrivers.SqlLite, "call", true, frameworkContext, useNhProf : false) { }
public void WhenProviderIsMatched_IdIsRemappedToMappingGroup_OnReturn( int allItemCount, int numbProviderCount, int numberOfPassthroughProviders) { // Arrange var context = new FakeFrameworkContext(); var providerGroup = GroupedProviderMockHelper.GenerateProviderGroup(numbProviderCount, numberOfPassthroughProviders, allItemCount, context); var idRoot = new Uri("oh-yeah://this-is-my-root/"); var groupUnitFactory = new GroupUnitFactory(providerGroup.Writers, idRoot, FakeHiveCmsManager.CreateFakeRepositoryContext(context), context); // Act & Assert using (var uow = groupUnitFactory.Create<IContentStore>()) { Assert.NotNull(uow.IdRoot); Assert.AreEqual(uow.IdRoot, idRoot); var singleItem = uow.Repositories.Get<TypedEntity>(HiveId.Empty); Assert.NotNull(singleItem); Assert.NotNull(singleItem.Id.ProviderGroupRoot); Assert.AreEqual(singleItem.Id.ProviderGroupRoot, idRoot); Assert.NotNull(singleItem.Id.ProviderId); Assert.True(singleItem.Id.ToString(HiveIdFormatStyle.AsUri).StartsWith(idRoot.ToString()), "Was: " + singleItem.Id.ToFriendlyString()); var items = uow.Repositories.GetAll<TypedEntity>(); var itemShouldBeCount = allItemCount * numbProviderCount; Assert.AreEqual(itemShouldBeCount, items.Count()); foreach (var typedEntity in items) { AssertEntityIdIsRooted(idRoot, ((IReferenceByHiveId)typedEntity).Id); } AssertRelationsIdsHaveRoot(uow.Repositories.GetParentRelations(HiveId.Empty), idRoot); AssertRelationsIdsHaveRoot(uow.Repositories.GetDescendentRelations(HiveId.Empty), idRoot); AssertRelationsIdsHaveRoot(uow.Repositories.GetChildRelations(HiveId.Empty), idRoot); AssertRelationsIdsHaveRoot(uow.Repositories.GetAncestorRelations(HiveId.Empty), idRoot); } }
public NhibernateTestSetupHelper(FakeFrameworkContext frameworkContext = null, bool useNhProf = false, string dataSource = "data source=:memory:", SupportedNHDrivers supportedNhDrivers = SupportedNHDrivers.SqlLite) : this(dataSource, supportedNhDrivers, "call", true, frameworkContext, useNhProf: useNhProf) { }