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 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");
}
}
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\\rebel.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 });
}
}
protected virtual void Init()
{
var attributeTypeRegistry = new CmsAttributeTypeRegistry();
AttributeTypeRegistry.SetCurrent(attributeTypeRegistry);
FrameworkContext = new FakeFrameworkContext();
var hive = CreateHiveManager();
RebelApplicationContext = CreateApplicationContext(hive);
var resolverContext = new MockedMapResolverContext(FrameworkContext, hive, new MockedPropertyEditorFactory(RebelApplicationContext), new MockedParameterEditorFactory());
var webmModelMapper = new CmsModelMapper(resolverContext);
FrameworkContext.SetTypeMappers(new FakeTypeMapperCollection(new AbstractMappingEngine[] { webmModelMapper, new FrameworkModelMapper(FrameworkContext) }));
DevDataset = DemoDataHelper.GetDemoData(RebelApplicationContext, attributeTypeRegistry);
FixedPropertyEditors = new FixedPropertyEditors(RebelApplicationContext);
//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 RebelModelMetadataProvider();
}
/// <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 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 RebelExamineIndexer(
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 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 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));
}
/// <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 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);
}
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 NHibernateHiveTests()
{
_fakeFrameworkContext = new FakeFrameworkContext();
_repository = new NHibernateInMemoryRepository(_fakeFrameworkContext);
}
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);
}
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 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);
}
}
}
private ProviderMappingGroup CreateFakeDictionaryMappingGroup(FakeFrameworkContext frameworkContext)
{
var helper = new NhibernateTestSetupHelper(frameworkContext, useNhProf:true);
var uriMatch = new WildcardUriMatch(new Uri("dictionary://"));
var persistenceMappingGroup = new ProviderMappingGroup(
"dictionary",
uriMatch,
helper.ReadonlyProviderSetup,
helper.ProviderSetup,
frameworkContext);
return persistenceMappingGroup;
}
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 NhibernateTestSetupHelper(FakeFrameworkContext frameworkContext = null, bool useNhProf = false, string dataSource = "data source=:memory:", SupportedNHDrivers supportedNhDrivers = SupportedNHDrivers.SqlLite)
: this(dataSource, supportedNhDrivers, "call", true, frameworkContext, useNhProf : useNhProf)
{
}
/// <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));
}
/// <summary>
/// Creates a new HiveManager with an NHibernate default mapping group and the supplied provider mapping groups
/// appended
/// </summary>
/// <param name="providerMappingGroups"></param>
/// <param name="frameworkContext"></param>
/// <returns></returns>
public static IHiveManager NewWithNhibernate(IEnumerable <ProviderMappingGroup> providerMappingGroups, FakeFrameworkContext frameworkContext)
{
var helper = new NhibernateTestSetupHelper(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));
}
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 RebelExamineIndexer(
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);
}
private HiveId ExecuteBinding(IValueProvider form, RouteData routeData, out ModelBindingContext bindingContext, out ControllerContext controllerContext)
{
var modelBinder = new HiveIdModelBinder();
var httpContextFactory = new FakeHttpContextFactory("~/Rebel/Editors/ContentEditor/Edit/1", routeData);
var fakeFrameworkContext = new FakeFrameworkContext();
var hive = FakeHiveCmsManager.New(fakeFrameworkContext);
var appContext = new FakeRebelApplicationContext(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 rebelApplicationContext = new FakeRebelApplicationContext(hive);
controllerContext = new ControllerContext(
httpContextFactory.RequestContext,
new ContentEditorController(new FakeBackOfficeRequestContext(rebelApplicationContext)));
//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 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 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 IoHiveTestSetupHelper(FakeFrameworkContext frameworkContext = null)
: this("*.dll", frameworkContext)
{
}
