public AbstractProviderSetup(ProviderMetadata providerMetadata, IFrameworkContext frameworkContext, AbstractProviderBootstrapper bootstrapper, int priorityOrdinal)
{
ProviderMetadata = providerMetadata;
FrameworkContext = frameworkContext;
Bootstrapper = bootstrapper;
PriorityOrdinal = priorityOrdinal;
}
internal EntityRepositoryFactory(ProviderMetadata providerMetadata,
AbstractRevisionRepositoryFactory<TypedEntity> revisionRepositoryFactory,
AbstractSchemaRepositoryFactory schemaRepositoryFactory, Settings settings,
IFrameworkContext frameworkContext)
: base(providerMetadata, revisionRepositoryFactory, schemaRepositoryFactory, frameworkContext, new DependencyHelper(settings, providerMetadata))
{
}
/// <summary>
/// Initializes a new instance of the <see cref="EntityRepositoryFactory"/> class. This constructor is used internally for unit testing where a single session must be used
/// irrespective of the NHibernate session factory mechanisms.
/// </summary>
/// <param name="providerMetadata">The provider metadata.</param>
/// <param name="revisionRepositoryFactory">The revision repository factory.</param>
/// <param name="schemaRepositoryFactory">The schema repository factory.</param>
/// <param name="frameworkContext">The framework context.</param>
/// <param name="singleProvidedSession">The single provided session.</param>
/// <param name="leaveSessionOpenOnDispose">if set to <c>true</c> [leave session open on dispose].</param>
/// <remarks></remarks>
internal EntityRepositoryFactory(ProviderMetadata providerMetadata,
AbstractRevisionRepositoryFactory<TypedEntity> revisionRepositoryFactory,
AbstractSchemaRepositoryFactory schemaRepositoryFactory,
IFrameworkContext frameworkContext, ISession singleProvidedSession, bool leaveSessionOpenOnDispose)
: base(providerMetadata, revisionRepositoryFactory, schemaRepositoryFactory, frameworkContext, new DependencyHelper(new NhFactoryHelper(null, singleProvidedSession, leaveSessionOpenOnDispose, false, frameworkContext), providerMetadata))
{
}
protected ReadonlyProviderSetup(ProviderMetadata providerMetadata, IFrameworkContext frameworkContext, AbstractProviderBootstrapper bootstrapper, int priorityOrdinal)
: base(providerMetadata, frameworkContext, bootstrapper, priorityOrdinal)
{
Mandate.ParameterNotNull(frameworkContext, "frameworkContext");
Mandate.ParameterNotNull(bootstrapper, "bootstrapper");
Mandate.ParameterNotNull(providerMetadata, "providerMetadata");
}
//public EntityRepositoryFactory(ProviderMetadata providerMetadata,
// ProviderRevisionSessionFactory<TypedEntity> revisionRepositoryFactory,
// ProviderSchemaSessionFactory schemaRepositoryFactory,
// IFrameworkContext frameworkContext, global::NHibernate.Cfg.Configuration nhConfig)
// : base(providerMetadata, revisionRepositoryFactory, schemaRepositoryFactory, frameworkContext)
//{
// Helper = new NhFactoryHelper(nhConfig, null, false, false, frameworkContext);
//}
public EntityRepositoryFactory(ProviderMetadata providerMetadata,
AbstractRevisionRepositoryFactory<TypedEntity> revisionRepositoryFactory,
AbstractSchemaRepositoryFactory schemaRepositoryFactory,
IFrameworkContext frameworkContext, ProviderDependencyHelper dependencyHelper)
: base(providerMetadata, revisionRepositoryFactory, schemaRepositoryFactory, frameworkContext, dependencyHelper)
{
}
public ProviderSetup(ProviderUnitFactory unitFactory, ProviderMetadata providerMetadata, IFrameworkContext frameworkContext, AbstractProviderBootstrapper bootstrapper, int priorityOrdinal)
: base(providerMetadata, frameworkContext, bootstrapper, priorityOrdinal)
{
Mandate.ParameterNotNull(unitFactory, "unitFactory");
UnitFactory = unitFactory;
}
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);
}
/// <summary>
/// Constructor used for testing
/// </summary>
/// <param name="providerMetadata"></param>
/// <param name="revisionRepositoryFactory"></param>
/// <param name="frameworkContext"></param>
/// <param name="helper"></param>
internal SchemaRepositoryFactory(
ProviderMetadata providerMetadata,
AbstractRevisionRepositoryFactory<EntitySchema> revisionRepositoryFactory,
IFrameworkContext frameworkContext,
ExamineHelper helper)
: base(providerMetadata, revisionRepositoryFactory, frameworkContext, new DependencyHelper(helper, providerMetadata))
{
}
protected AbstractProviderRepository(ProviderMetadata providerMetadata, IFrameworkContext frameworkContext)
{
CanRead = true;
ProviderMetadata = providerMetadata;
FrameworkContext = frameworkContext;
RepositoryScopedCache = new DictionaryScopedCache();
//HiveContext = new RepositoryContext(RuntimeCacheProvider.Default, PerHttpRequestCacheProvider.Default, 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);
}
public DependencyHelper(
IEnumerable<ProviderElement> configuredProviders,
Lazy<IEnumerable<MembershipProvider>> membershipProviders,
ProviderMetadata providerMetadata)
: base(providerMetadata)
{
MembershipProviders = membershipProviders;
ConfiguredProviders = configuredProviders;
}
public void WhenProviderMetadataIsPassthrough_ProviderId_IsNotSet_OnHiveId()
{
// Arrange
var metadata = new ProviderMetadata("test", new Uri("mappingroot://"), false, true);
var originalId = new HiveId(1);
// Act
var newId = ProviderRepositoryHelper.CreateMappedProviderId(metadata, originalId);
// Assert
Assert.IsNull(newId.ProviderId);
Assert.AreNotEqual(metadata.Alias, newId.ProviderId);
}
public void WhenProviderMetadataIsNotPassthrough_ButProviderIdIsAlreadySet_ProviderId_IsNotOverriden_OnHiveId()
{
// Arrange
var metadata = new ProviderMetadata("test", new Uri("mappingroot://"), false, false);
var originalId = new HiveId(new Uri("myroot://"), "myprovider", new HiveIdValue(1));
// Act
var newId = ProviderRepositoryHelper.CreateMappedProviderId(metadata, originalId);
// Assert
Assert.NotNull(newId.ProviderId);
Assert.AreNotEqual(metadata.Alias, newId.ProviderId);
Assert.AreEqual(originalId.ProviderId, newId.ProviderId);
}
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 static ProviderMappingGroup GenerateProviderGroup(int numberOfProviders, int numberOfPassthroughProviders, int numberOfMockedEntities, IFrameworkContext frameworkContext)
{
Func<int, bool, IEnumerable<Tuple<ProviderSetup, ReadonlyProviderSetup>>> generate = (count, isPassthrough) =>
{
var generateProviders = new List<Tuple<ProviderSetup, ReadonlyProviderSetup>>();
for (int i = 0; i < count; i++)
{
var mockKey = "test" + (isPassthrough ? "_passthrough" : String.Empty) + i;
var metadata = new ProviderMetadata(mockKey, new Uri("content://"), true, isPassthrough);
var factory = MockEntityRepositoryFactory(numberOfMockedEntities, metadata, frameworkContext);
var setup = new ProviderSetup(new ProviderUnitFactory(factory), metadata, frameworkContext, null, 0);
var readonlySetup = new ReadonlyProviderSetup(new ReadonlyProviderUnitFactory(factory), metadata, frameworkContext, null, 0);
generateProviders.Add(new Tuple<ProviderSetup, ReadonlyProviderSetup>(setup, readonlySetup));
}
return generateProviders;
};
var uris = new[] { "content://boots/", "content://bags/", "content://shoes/" };
var uriMatches = EnumerableExtensions.Range(count => new WildcardUriMatch(new Uri(uris[count])), 3);
var injectMockedProviders = generate.Invoke(numberOfProviders, false)
.Concat(generate.Invoke(numberOfPassthroughProviders, true));
return new ProviderMappingGroup("test", uriMatches, injectMockedProviders.Select(x => x.Item2), injectMockedProviders.Select(x => x.Item1), new FakeFrameworkContext());
}
public void Build(IContainerBuilder containerBuilder, IBuilderContext context)
{
var config2 = context.ConfigurationResolver.GetConfigSection(HiveConfigSection.ConfigXmlKey) as HiveConfigSection;
if (config2 == null)
throw new ConfigurationErrorsException(string.Format("Cannot find {0} section in application configuration.", HiveConfigSection.ConfigXmlKey));
var providerMapElements = DeepConfigManager.Default.GetPluginSettings<HiveConfigSection, ProviderMappingElementCollection>(HiveConfigSection.ConfigXmlKey, x => x.ProviderMappings).SelectMany(x => x);
var mappings = providerMapElements.Distinct().ToArray();
var mergedMappings = mappings.Select(x => new
{
MappingName = x.Key,
Original = x,
ReadWriters = mappings.Where(y => y.Key == x.Key).SelectMany(y => y.ReadWriters).Distinct().ToArray(),
Readers = mappings.Where(y => y.Key == x.Key).SelectMany(y => y.Readers).Distinct().ToArray(),
UriMatches = mappings.Where(y => y.Key == x.Key).SelectMany(y => y.UriMatches).Distinct().ToArray(),
TotalOriginalsWithSameKey = mappings.Count(y => y.Key == x.Key)
}).ToArray();
foreach (var providerMapping in mergedMappings.DistinctBy(x => x.MappingName))
{
// Check for duplicates in config
var mappingName = providerMapping.MappingName;
if (providerMapping.TotalOriginalsWithSameKey > 1)
LogHelper.TraceIfEnabled<HiveDemandBuilder>("Warning: more than one provider group has been specified in Hive configuration with key '{0}', possibly as a result of a plugin's config. {1} sets of configuration have been merged.".InvariantFormat(mappingName, providerMapping.TotalOriginalsWithSameKey));
var mappedReaderKeys = providerMapping.Readers.OrderBy(x => x.Ordinal).Select(x => x.ProviderKey).ToArray();
var mappedReadWriterKeys = providerMapping.ReadWriters.OrderBy(x => x.Ordinal).Select(x => x.ProviderKey).ToArray();
foreach (ReadWriterTypeReferenceElement readWriter in providerMapping.ReadWriters)
{
// Register ProviderSetups for each read-writer
ReadWriterTypeReferenceElement writer = readWriter;
var mappingKey = mappingName;
containerBuilder.ForFactory(x =>
{
var metadata = new ProviderMetadata(writer.ProviderKey, null, false, writer.IsPassthrough);
var getBootstrapper = x.TryResolve<AbstractProviderBootstrapper>(writer.ProviderKey);
if (!getBootstrapper.Success)
LogHelper.Warn<HiveDemandBuilder>("No bootstrapper was registered for Hive provider {0}", writer.ProviderKey);
var getRepositoryFactory = x.TryResolve<AbstractEntityRepositoryFactory>(writer.ProviderKey);
if (getRepositoryFactory.Success)
{
var unitFactory = new ProviderUnitFactory(getRepositoryFactory.Value);
return new ProviderSetup(unitFactory, metadata, x.Resolve<IFrameworkContext>(),
getBootstrapper.Value, 0);
}
if (getRepositoryFactory.Error != null)
{
var inner = getRepositoryFactory.Error.InnerException;
string innerMessage = (inner != null) ? inner.Message : string.Empty;
var message = "Hive group '{0}' has its config pointing at writer key '{1}', but an error occurred trying to create it. Error: {2}";
if (!innerMessage.IsNullOrWhiteSpace()) message = message + " Inner error: " + innerMessage;
LogHelper.Error<HiveDemandBuilder>(message.InvariantFormat(mappingKey, writer.ProviderKey, getRepositoryFactory.Error.Message), getRepositoryFactory.Error);
}
else
{
LogHelper.Warn<HiveDemandBuilder>("Config '{0}' wants read-write provider with key {1} but it's not registered", mappingKey, writer.ProviderKey);
}
// We couldn't get a session factory, so register an "UninstalledProviderSetup" instead
return new UninstalledProviderSetup(metadata, x.Resolve<IFrameworkContext>(), getBootstrapper.Value, 0);
})
//.KnownAsSelf()
.Named<ProviderSetup>(writer.ProviderKey)
.ScopedAs.Singleton();
}
foreach (ReaderTypeReferenceElement reader in providerMapping.Readers)
{
// Register ReadonlyProviderSetups for each reader
ReaderTypeReferenceElement readerLocalCopy = reader;
var mappingKey = mappingName;
containerBuilder.ForFactory(x =>
{
var metadata = new ProviderMetadata(readerLocalCopy.ProviderKey, null, false, readerLocalCopy.IsPassthrough);
var getBootstrapper = x.TryResolve<AbstractProviderBootstrapper>(readerLocalCopy.ProviderKey);
if (!getBootstrapper.Success)
LogHelper.Warn<HiveDemandBuilder>("No bootstrapper was registered for Hive provider {0}", readerLocalCopy.ProviderKey);
var getRepositoryFactory = x.TryResolve<AbstractEntityRepositoryFactory>(readerLocalCopy.ProviderKey);
if (getRepositoryFactory.Success)
{
var unitFactory = new ReadonlyProviderUnitFactory(getRepositoryFactory.Value);
return new ReadonlyProviderSetup(unitFactory, metadata,
x.Resolve<IFrameworkContext>(),
getBootstrapper.Value, 0);
}
if (getRepositoryFactory.Error != null)
{
var inner = getRepositoryFactory.Error.InnerException;
string innerMessage = (inner != null) ? inner.Message : string.Empty;
var message = "Hive group '{0}' has its config pointing at reader key '{1}', but an error occurred trying to create it. Error: {2}";
if (!innerMessage.IsNullOrWhiteSpace()) message = message + " Inner error: " + innerMessage;
LogHelper.Error<HiveDemandBuilder>(message.InvariantFormat(mappingKey, reader.ProviderKey, getRepositoryFactory.Error.Message), getRepositoryFactory.Error);
}
else
{
LogHelper.Warn<HiveDemandBuilder>("Config '{0}' wants read provider with key {1} but it's not registered", mappingKey, reader.ProviderKey);
}
// We couldn't get a session factory, so register an "UninstalledReadonlyProviderSetup" instead
return new UninstalledReadonlyProviderSetup(metadata, x.Resolve<IFrameworkContext>(), getBootstrapper.Value, 0);
})
//.KnownAsSelf()
.Named<ReadonlyProviderSetup>(readerLocalCopy.ProviderKey)
.ScopedAs.Singleton();
}
// Register IUriMatches for each mapping group
foreach (UriMatchElement uriMatch in providerMapping.UriMatches)
{
// Copy to a locally-scoped instance since the variable usage is wrapped in an anon delegate for later use
var match = uriMatch;
containerBuilder.ForFactory(x =>
{
if (!Uri.IsWellFormedUriString(match.UriPattern, UriKind.Absolute))
throw new InvalidOperationException("Hive config is invalid: '{0}' needs to be changed to a valid absolute Uri".InvariantFormat(match.UriPattern));
return new WildcardUriMatch(new Uri(match.UriPattern));
})
.Named<WildcardUriMatch>(mappingName)
.ScopedAs.Singleton();
}
// For every mapping group in config, register a DefaultHiveMappingGroup
// with a constructor which accepts the map key, and all the available readers and writers which
// map the keys selected in this group
containerBuilder.ForFactory(
x => GenerateMappingGroup(mappingName, x, mappedReadWriterKeys, mappedReaderKeys))
.KnownAsSelf() // Register unnamed as well as named services to aid passing all registered groups into ctor params of type IEnumerable<ProviderMappingGroup>
.Named<ProviderMappingGroup>(mappingName)
.ScopedAs.Singleton();
}
//TODO: Remove magic strings for perf counter declarations
containerBuilder
.ForInstanceOfType(new HiveCounterManager("Hive 5.0", "TBD", "DEV"))
.ScopedAs.Singleton();
containerBuilder.ForFactory(x =>
{
var groups = x.ResolveAll<ProviderMappingGroup>().DistinctBy(y => y.Key);
var framework = x.Resolve<IFrameworkContext>();
var perf = x.TryResolve<HiveCounterManager>();
return new HiveManager(groups, perf.Success ? perf.Value : null, framework);
})
.KnownAs<IHiveManager>()
.KnownAsSelf()
.ScopedAs.Singleton();
containerBuilder.ForFactory(x => GetCacheWatcherTaskFactory(x, TaskTriggers.Hive.PostAddOrUpdateOnUnitComplete))
.KnownAs<Lazy<AbstractTask, TaskMetadata>>()
.ScopedAs.Singleton();
containerBuilder.ForFactory(x => GetCacheWatcherTaskFactory(x, TaskTriggers.Hive.PostReadEntity))
.KnownAs<Lazy<AbstractTask, TaskMetadata>>()
.ScopedAs.Singleton();
}
public DependencyHelper(ExamineHelper helper, ProviderMetadata providerMetadata)
: base(providerMetadata)
{
ExamineHelper = helper;
}
public ReadonlyProviderSetup(ReadonlyProviderUnitFactory unitFactory, ProviderMetadata providerMetadata, IFrameworkContext frameworkContext, AbstractProviderBootstrapper bootstrapper, int priorityOrdinal)
: base(providerMetadata, frameworkContext, bootstrapper, priorityOrdinal)
{
ReadonlyUnitFactory = unitFactory;
}
public UninstalledReadonlyProviderSetup(ProviderMetadata providerMetadata, IFrameworkContext frameworkContext, AbstractProviderBootstrapper bootstrapper, int priorityOrdinal)
: base(providerMetadata, frameworkContext, bootstrapper, priorityOrdinal)
{
}
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 static AbstractEntityRepositoryFactory MockEntityRepositoryFactory(int allItemCount, ProviderMetadata metadata, IFrameworkContext frameworkContext)
{
var entitySession = Substitute.For<AbstractEntityRepository>(metadata, new TransactionMock(), frameworkContext);
entitySession.CanReadRelations.Returns(true);
entitySession.CanWriteRelations.Returns(true);
entitySession
.PerformGet<TypedEntity>(Arg.Any<bool>(), Arg.Any<HiveId[]>())
.Returns(x => EnumerableExtensions.Range(count => HiveModelCreationHelper.MockTypedEntity(HiveId.ConvertIntToGuid(count + 1)), 3));
entitySession
.PerformGetAll<TypedEntity>()
.Returns(x => EnumerableExtensions.Range(count => HiveModelCreationHelper.MockTypedEntity(HiveId.ConvertIntToGuid(count + 5)), allItemCount));
entitySession
.PerformGetAncestorRelations(Arg.Any<HiveId>(), Arg.Any<RelationType>())
.Returns(MockRelations(MockRelationCount));
entitySession
.PerformGetDescendentRelations(Arg.Any<HiveId>(), Arg.Any<RelationType>())
.Returns(MockRelations(MockRelationCount));
entitySession
.PerformGetParentRelations(Arg.Any<HiveId>(), Arg.Any<RelationType>())
.Returns(MockRelations(MockRelationCount));
entitySession
.PerformGetChildRelations(Arg.Any<HiveId>(), Arg.Any<RelationType>())
.Returns(MockRelations(MockRelationCount));
var factory = Substitute.For<AbstractEntityRepositoryFactory>(null, null, null, frameworkContext, null);
factory.GetRepository().Returns(entitySession);
return factory;
}
public DependencyHelper(ProviderMetadata providerMetadata, CacheHelper cacheHelper)
: base(providerMetadata)
{
Mandate.ParameterNotNull(cacheHelper, "cacheHelper");
CacheHelper = cacheHelper;
}
private void AssignFakeIdsIfPassthrough(ProviderMetadata providerMetadata, params IReferenceByHiveId[] entity)
{
if (!providerMetadata.IsPassthroughProvider)
return;
entity.ForEach(
x =>
{
var allItems = x.GetAllIdentifiableItems();
foreach (var referenceByHiveId in allItems)
{
// Only change / set certain ids otherwise relations are broken e.g. between an attributedefinition and its group
if (referenceByHiveId.Id.IsNullValueOrEmpty() && (TypeFinder.IsTypeAssignableFrom<TypedEntity>(referenceByHiveId)
|| TypeFinder.IsTypeAssignableFrom<EntitySchema>(referenceByHiveId)
|| TypeFinder.IsTypeAssignableFrom<Revision<TypedEntity>>(referenceByHiveId)))
referenceByHiveId.Id = new HiveId(providerMetadata.MappingRoot, providerMetadata.Alias, new HiveIdValue(Guid.NewGuid()));
}
// If we've specifically been given the item, then set its id irrespective of the rule above
if (x.Id.IsNullValueOrEmpty())
x.Id = new HiveId(providerMetadata.MappingRoot, providerMetadata.Alias, new HiveIdValue(Guid.NewGuid()));
});
}
public NullProviderSchemaRepositoryFactory(ProviderMetadata providerMetadata, AbstractRevisionRepositoryFactory<EntitySchema> revisionRepositoryFactory, IFrameworkContext frameworkContext)
: base(providerMetadata, revisionRepositoryFactory, frameworkContext, new NullProviderDependencyHelper(providerMetadata))
{
}
public DependencyHelper(Settings settings, ProviderMetadata providerMetadata) : base(providerMetadata)
{
Settings = settings;
}
protected ProviderDependencyHelper(ProviderMetadata providerMetadata)
{
ProviderMetadata = providerMetadata;
}
public NullProviderSchemaRepositoryFactory(ProviderMetadata providerMetadata, IFrameworkContext frameworkContext)
: this(providerMetadata, new NullProviderRevisionRepositoryFactory<EntitySchema>(providerMetadata, frameworkContext), frameworkContext)
{
}
public NullProviderDependencyHelper(ProviderMetadata providerMetadata) : base(providerMetadata)
{
}