public void FileProvider_ViaManager_GetRelations_DefaultRelationType()
{
// Arrange
var ioTestSetup = new IoHiveTestSetupHelper();
var unitFactory = new ProviderUnitFactory(ioTestSetup.EntityRepositoryFactory);
var readonlyUnitFactory = new ReadonlyProviderUnitFactory(ioTestSetup.EntityRepositoryFactory);
var provider = new ProviderSetup(unitFactory, ioTestSetup.ProviderMetadata, null, null, 0);
var readonlyProvider = new ReadonlyProviderSetup(readonlyUnitFactory, ioTestSetup.ProviderMetadata, null, null, 0);
var providerMappingGroup = new ProviderMappingGroup("default", new WildcardUriMatch("storage://*"), readonlyProvider, provider, ioTestSetup.FrameworkContext);
var manager = new HiveManager(new[] { providerMappingGroup }, ioTestSetup.FrameworkContext);
var actualFile = ioTestSetup.TestDirectory.GetFiles(ioTestSetup.Settings.SupportedExtensions, SearchOption.AllDirectories)
.Where(x => x.FullName.Replace(ioTestSetup.Settings.AbsoluteRootedPath, string.Empty).Contains(@"\"))
.Last();
var parentFolder = actualFile.Directory;
// Act
using (var store = manager.OpenReader <IFileStore>())
{
var file = store.Repositories.Get <File>(new HiveId(actualFile.FullName));
var parentRelations = store.Repositories.GetParentRelations(file.Id, FixedRelationTypes.DefaultRelationType);
var parentsViaHandyMethod = store.Repositories.GetParentFileRelations(file);
var firstParentRelation = store.Repositories.Get <File>(parentRelations.First().SourceId);
//Assert
// Check for iterator block mistakes
Assert.That(parentRelations, Is.EquivalentTo(parentsViaHandyMethod));
Assert.That(parentRelations.Count(), Is.GreaterThanOrEqualTo(1));
Assert.AreEqual(parentFolder.FullName.NormaliseDirectoryPath(), firstParentRelation.RootedPath.NormaliseDirectoryPath());
}
}
public void TestSetup()
{
this.Setup = new NhibernateTestSetupHelper();
this._singleProvider = new ProviderMappingGroup("default", new WildcardUriMatch(new Uri("content://")), this.Setup.ReadonlyProviderSetup, this.Setup.ProviderSetup, this.Setup.FakeFrameworkContext);
this.HiveManager = new HiveManager(this._singleProvider, this._singleProvider.FrameworkContext);
this.AppContext = new FakeRebelApplicationContext(this.HiveManager, false);
this._resolverContext = new MockedMapResolverContext(this.HiveManager.FrameworkContext, this.HiveManager, new MockedPropertyEditorFactory(this.AppContext), new MockedParameterEditorFactory());
//mappers
var cmsModelMapper = new CmsModelMapper(this._resolverContext);
var persistenceToRenderModelMapper = new RenderTypesModelMapper(this._resolverContext);
this.Setup.FakeFrameworkContext.SetTypeMappers(new FakeTypeMapperCollection(new AbstractMappingEngine[] { cmsModelMapper, persistenceToRenderModelMapper }));
var membersMembershipProvider = new MembersMembershipProvider {
AppContext = AppContext
};
MembershipService = new MembershipService <Member, MemberProfile>(AppContext.FrameworkContext, HiveManager,
"security://member-profiles", "security://member-groups", Framework.Security.Model.FixedHiveIds.MemberProfileVirtualRoot,
membersMembershipProvider, Enumerable.Empty <MembershipProviderElement>());
PublicAccessService = new PublicAccessService(HiveManager, MembershipService, AppContext.FrameworkContext);
}
/// <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 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));
}
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;
}
/// <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));
}
public void TestSetup()
{
this.Setup = new NhibernateTestSetupHelper();
this._singleProvider = new ProviderMappingGroup("default", new WildcardUriMatch(new Uri("content://")), this.Setup.ReadonlyProviderSetup, this.Setup.ProviderSetup, this.Setup.FakeFrameworkContext);
this.HiveManager = new HiveManager(this._singleProvider, this._singleProvider.FrameworkContext);
this._appContext = new FakeUmbracoApplicationContext(this.HiveManager, false);
this._resolverContext = new MockedMapResolverContext(this.HiveManager.FrameworkContext, this.HiveManager, new MockedPropertyEditorFactory(this._appContext), new MockedParameterEditorFactory());
//mappers
var cmsModelMapper = new CmsModelMapper(this._resolverContext);
var persistenceToRenderModelMapper = new RenderTypesModelMapper(this._resolverContext);
this.Setup.FakeFrameworkContext.SetTypeMappers(new FakeTypeMapperCollection(new AbstractMappingEngine[] { cmsModelMapper, persistenceToRenderModelMapper }));
}
public ProviderGroupMatchResult(WildcardUriMatch uriMatch, ProviderMappingGroup @group)
{
UriMatch = uriMatch;
Group = @group;
}
internal HiveManager(ProviderMappingGroup singleProvider, IFrameworkContext frameworkContext)
: this(Enumerable.Repeat(singleProvider, 1), frameworkContext)
{
}
public ProviderGroupMatchResult(WildcardUriMatch uriMatch, ProviderMappingGroup @group)
{
UriMatch = uriMatch;
Group = @group;
}
