public void LazyCollectionBuilderHandlesTypesAndProducers()
{
var container = CreateRegister();
var composition = new UmbracoBuilder(container, Mock.Of <IConfiguration>(), TestHelper.GetMockedTypeLoader());
composition.WithCollectionBuilder <TestCollectionBuilder>()
.Add <TransientObject3>()
.Add <TransientObject2>()
.Add <TransientObject3>()
.Add(() => new[] { typeof(TransientObject1) });
var factory = composition.CreateServiceProvider();
var values = factory.GetRequiredService <TestCollection>();
Assert.AreEqual(3, values.Count());
Assert.IsTrue(values.Select(x => x.GetType())
.ContainsAll(new[] { typeof(TransientObject1), typeof(TransientObject2), typeof(TransientObject3) }));
var other = factory.GetRequiredService <TestCollection>();
Assert.AreNotSame(values, other); // transient
var o1 = other.FirstOrDefault(x => x is TransientObject1);
Assert.IsFalse(values.Contains(o1)); // transient
}
public UmbracoIocExtensionTests()
{
_serviceCollection = new ServiceCollection();
var dirName = Path.GetDirectoryName(
Assembly.GetExecutingAssembly()
.Location
.Replace("bin\\Debug", string.Empty));
var typeLoader = new TypeLoader(
Substitute.For <ITypeFinder>(),
new VaryingRuntimeHash(),
Substitute.For <IAppPolicyCache>(),
new DirectoryInfo(dirName),
Substitute.For <ILogger <TypeLoader> >(),
Substitute.For <IProfiler>());
_umbracoBuilder = new UmbracoBuilder(
_serviceCollection,
Substitute.For <IConfiguration>(),
typeLoader);
_containerBuilder = _umbracoBuilder.RegisterAzureSearch()
.RegisterClientOptions("test", "test", "https://localhost")
.RegisterIndexOptions(false, false)
.RegisterIndexDefinitions <FirstTestDocumentModel>(FirstDocumentIndexName)
.RegisterIndexDefinitions <SecondTestDocumentModel>(SecondDocumentIndexName)
.RegisterIndexDefinitions <ThirdTestDocumentModel>(customIndex: new SearchIndex(ThirdDocumentIndexName));
}
protected void ConfigureServices(IServiceCollection services)
{
services.AddTransient <TestUmbracoDatabaseFactoryProvider>();
Core.Hosting.IHostingEnvironment hostingEnvironment = TestHelper.GetHostingEnvironment();
TypeLoader typeLoader = services.AddTypeLoader(
GetType().Assembly,
hostingEnvironment,
TestHelper.ConsoleLoggerFactory,
AppCaches.NoCache,
Configuration,
TestHelper.Profiler);
services.AddLogger(TestHelper.GetWebHostEnvironment(), Configuration);
var builder = new UmbracoBuilder(services, Configuration, typeLoader, TestHelper.ConsoleLoggerFactory, TestHelper.Profiler, AppCaches.NoCache, hostingEnvironment);
builder
.AddConfiguration()
.AddUmbracoCore()
.AddWebComponents()
.AddNuCache()
.AddRuntimeMinifier()
.AddBackOfficeCore()
.AddBackOfficeAuthentication()
.AddBackOfficeIdentity()
.AddMembersIdentity()
.AddBackOfficeAuthorizationPolicies(TestAuthHandler.TestAuthenticationScheme)
.AddPreviewSupport()
.AddMvcAndRazor(mvcBuilding: mvcBuilder =>
{
// Adds Umbraco.Web.BackOffice
mvcBuilder.AddApplicationPart(typeof(ContentController).Assembly);
// Adds Umbraco.Web.Common
mvcBuilder.AddApplicationPart(typeof(RenderController).Assembly);
// Adds Umbraco.Web.Website
mvcBuilder.AddApplicationPart(typeof(SurfaceController).Assembly);
// Adds Umbraco.Tests.Integration
mvcBuilder.AddApplicationPart(typeof(UmbracoTestServerTestBase).Assembly);
})
.AddWebServer()
.AddWebsite()
.AddUmbracoSqlServerSupport()
.AddUmbracoSqliteSupport()
.AddTestServices(TestHelper); // This is the important one!
CustomTestSetup(builder);
builder.Build();
}
protected void ConfigureServices(IServiceCollection services)
{
services.AddUnique(CreateLoggerFactory());
services.AddTransient <TestUmbracoDatabaseFactoryProvider>();
IWebHostEnvironment webHostEnvironment = TestHelper.GetWebHostEnvironment();
services.AddRequiredNetCoreServices(TestHelper, webHostEnvironment);
// We register this service because we need it for IRuntimeState, if we don't this breaks 900 tests
services.AddSingleton <IConflictingRouteService, TestConflictingRouteService>();
// Add it!
Core.Hosting.IHostingEnvironment hostingEnvironment = TestHelper.GetHostingEnvironment();
TypeLoader typeLoader = services.AddTypeLoader(
GetType().Assembly,
hostingEnvironment,
TestHelper.ConsoleLoggerFactory,
AppCaches.NoCache,
Configuration,
TestHelper.Profiler);
var builder = new UmbracoBuilder(services, Configuration, typeLoader, TestHelper.ConsoleLoggerFactory, TestHelper.Profiler, AppCaches.NoCache, hostingEnvironment);
builder.Services.AddLogger(hostingEnvironment, TestHelper.GetLoggingConfiguration(), Configuration);
builder.AddConfiguration()
.AddUmbracoCore()
.AddWebComponents()
.AddRuntimeMinifier()
.AddBackOfficeAuthentication()
.AddBackOfficeIdentity()
.AddMembersIdentity()
.AddExamine()
.AddUmbracoSqlServerSupport()
.AddUmbracoSqliteSupport()
.AddTestServices(TestHelper);
if (TestOptions.Mapper)
{
// TODO: Should these just be called from within AddUmbracoCore/AddWebComponents?
builder
.AddCoreMappingProfiles()
.AddWebMappingProfiles();
}
services.AddSignalR();
services.AddMvc();
CustomTestSetup(builder);
builder.Build();
}
public void Requires2A()
{
IServiceCollection register = MockRegister();
var composition = new UmbracoBuilder(register, Mock.Of <IConfiguration>(), TestHelper.GetMockedTypeLoader());
Type[] types = new[] { typeof(Composer9), typeof(Composer2), typeof(Composer4) };
var composers = new ComposerGraph(composition, types, Enumerable.Empty <Attribute>(), Mock.Of <ILogger <ComposerGraph> >());
Composed.Clear();
composers.Compose();
Assert.AreEqual(3, Composed.Count);
Assert.AreEqual(typeof(Composer4), Composed[0]);
Assert.AreEqual(typeof(Composer2), Composed[1]);
}
public void DisableMissing()
{
IServiceCollection register = MockRegister();
var composition = new UmbracoBuilder(register, Mock.Of <IConfiguration>(), TestHelper.GetMockedTypeLoader());
Type[] types = new[] { typeof(Composer6), typeof(Composer8) }; // 8 disables 7 which is not in the list
var composers = new ComposerGraph(composition, types, Enumerable.Empty <Attribute>(), Mock.Of <ILogger <ComposerGraph> >());
Composed.Clear();
composers.Compose();
Assert.AreEqual(2, Composed.Count);
Assert.AreEqual(typeof(Composer6), Composed[0]);
Assert.AreEqual(typeof(Composer8), Composed[1]);
}
public void Boot2()
{
IServiceCollection register = MockRegister();
var composition = new UmbracoBuilder(register, Mock.Of <IConfiguration>(), TestHelper.GetMockedTypeLoader());
Type[] types = TypeArray <Composer20, Composer21>();
var composers = new ComposerGraph(composition, types, Enumerable.Empty <Attribute>(), Mock.Of <ILogger <ComposerGraph> >());
Composed.Clear();
// 21 is required by 20
// => reorder components accordingly
composers.Compose();
AssertTypeArray(TypeArray <Composer21, Composer20>(), Composed);
}
public void Boot1B()
{
IServiceCollection register = MockRegister();
var composition = new UmbracoBuilder(register, Mock.Of <IConfiguration>(), TestHelper.GetMockedTypeLoader());
Type[] types = TypeArray <Composer1, Composer2, Composer3, Composer4>();
var composers = new ComposerGraph(composition, types, Enumerable.Empty <Attribute>(), Mock.Of <ILogger <ComposerGraph> >());
Composed.Clear();
// 2 is Core and requires 4
// 3 is User - stays with RuntimeLevel.Run
// => reorder components accordingly
composers.Compose();
AssertTypeArray(TypeArray <Composer1, Composer4, Composer2, Composer3>(), Composed);
}
public virtual void ConfigureServices(IServiceCollection services)
{
services.AddSingleton(TestHelper.DbProviderFactoryCreator);
services.AddTransient <TestUmbracoDatabaseFactoryProvider>();
IWebHostEnvironment webHostEnvironment = TestHelper.GetWebHostEnvironment();
services.AddRequiredNetCoreServices(TestHelper, webHostEnvironment);
// Add it!
Core.Hosting.IHostingEnvironment hostingEnvironment = TestHelper.GetHostingEnvironment();
TypeLoader typeLoader = services.AddTypeLoader(
GetType().Assembly,
hostingEnvironment,
TestHelper.ConsoleLoggerFactory,
AppCaches.NoCache,
Configuration,
TestHelper.Profiler);
var builder = new UmbracoBuilder(services, Configuration, typeLoader, TestHelper.ConsoleLoggerFactory, TestHelper.Profiler, AppCaches.NoCache, hostingEnvironment);
builder.Services.AddLogger(hostingEnvironment, TestHelper.GetLoggingConfiguration(), Configuration);
builder.AddConfiguration()
.AddUmbracoCore()
.AddWebComponents()
.AddRuntimeMinifier()
.AddBackOfficeAuthentication()
.AddBackOfficeIdentity()
.AddMembersIdentity()
.AddExamine()
.AddTestServices(TestHelper, GetAppCaches());
if (TestOptions.Mapper)
{
// TODO: Should these just be called from within AddUmbracoCore/AddWebComponents?
builder
.AddCoreMappingProfiles()
.AddWebMappingProfiles();
}
services.AddSignalR();
services.AddMvc();
CustomTestSetup(builder);
builder.Build();
}
public void BrokenRequired()
{
IServiceCollection register = MockRegister();
var composition = new UmbracoBuilder(register, Mock.Of <IConfiguration>(), TestHelper.GetMockedTypeLoader());
Type[] types = TypeArray <Composer2, Composer4, Composer13>();
var composers = new ComposerGraph(composition, types, Enumerable.Empty <Attribute>(), Mock.Of <ILogger <ComposerGraph> >());
Composed.Clear();
// 2 is Core and requires 4
// 13 is required by 1
// 1 is missing
// => reorder components accordingly
composers.Compose();
AssertTypeArray(TypeArray <Composer4, Composer2, Composer13>(), Composed);
}
public void LazyCollectionBuilderThrowsOnIllegalTypes()
{
var container = CreateRegister();
var composition = new UmbracoBuilder(container, Mock.Of <IConfiguration>(), TestHelper.GetMockedTypeLoader());
composition.WithCollectionBuilder <TestCollectionBuilder>()
.Add <TransientObject3>()
// illegal, does not implement the interface!
////.Add<TransientObject4>()
// legal so far...
.Add(() => new[] { typeof(TransientObject4) });
Assert.Throws <InvalidOperationException>(() =>
{
// but throws here when trying to register the types, right before creating the factory
var factory = composition.CreateServiceProvider();
});
}
public void AttributesPriorities()
{
IServiceCollection register = MockRegister();
var composition = new UmbracoBuilder(register, Mock.Of <IConfiguration>(), TestHelper.GetMockedTypeLoader());
Type[] types = new[] { typeof(Composer26) };
DisableComposerAttribute[] enableDisableAttributes = new[] { new DisableComposerAttribute(typeof(Composer26)) };
var composers = new ComposerGraph(composition, types, enableDisableAttributes, Mock.Of <ILogger <ComposerGraph> >());
Composed.Clear();
composers.Compose();
Assert.AreEqual(0, Composed.Count); // 26 gone
types = new[] { typeof(Composer26), typeof(Composer27) }; // 26 disabled by assembly attribute, enabled by 27
composers = new ComposerGraph(composition, types, enableDisableAttributes, Mock.Of <ILogger <ComposerGraph> >());
Composed.Clear();
composers.Compose();
Assert.AreEqual(2, Composed.Count); // both
Assert.AreEqual(typeof(Composer26), Composed[0]);
Assert.AreEqual(typeof(Composer27), Composed[1]);
}
public void Requires2B()
{
IServiceCollection register = MockRegister();
TypeLoader typeLoader = MockTypeLoader();
IServiceProvider factory = MockFactory();
var composition = new UmbracoBuilder(register, Mock.Of <IConfiguration>(), TestHelper.GetMockedTypeLoader());
Type[] types = new[] { typeof(Composer9), typeof(Composer2), typeof(Composer4) };
var composers = new ComposerGraph(composition, types, Enumerable.Empty <Attribute>(), Mock.Of <ILogger <ComposerGraph> >());
Composed.Clear();
composers.Compose();
ComponentCollectionBuilder builder = composition.WithCollectionBuilder <ComponentCollectionBuilder>();
builder.RegisterWith(register);
ComponentCollection components = builder.CreateCollection(factory);
Assert.AreEqual(3, Composed.Count);
Assert.AreEqual(typeof(Composer4), Composed[0]);
Assert.AreEqual(typeof(Composer2), Composed[1]);
Assert.AreEqual(typeof(Composer9), Composed[2]);
}
public void BrokenRequire()
{
IServiceCollection register = MockRegister();
var composition = new UmbracoBuilder(register, Mock.Of <IConfiguration>(), TestHelper.GetMockedTypeLoader());
Type[] types = TypeArray <Composer1, Composer2, Composer3>();
var composers = new ComposerGraph(composition, types, Enumerable.Empty <Attribute>(), Mock.Of <ILogger <ComposerGraph> >());
Composed.Clear();
try
{
// 2 is Core and requires 4
// 4 is missing
// => throw
composers.Compose();
Assert.Fail("Expected exception.");
}
catch (Exception e)
{
Assert.AreEqual("Broken composer dependency: Umbraco.Cms.Tests.UnitTests.Umbraco.Core.Components.ComponentTests+Composer2 -> Umbraco.Cms.Tests.UnitTests.Umbraco.Core.Components.ComponentTests+Composer4.", e.Message);
}
}
public void WeakDependencies()
{
IServiceCollection register = MockRegister();
var composition = new UmbracoBuilder(register, Mock.Of <IConfiguration>(), TestHelper.GetMockedTypeLoader());
Type[] types = new[] { typeof(Composer10) };
var composers = new ComposerGraph(composition, types, Enumerable.Empty <Attribute>(), Mock.Of <ILogger <ComposerGraph> >());
Composed.Clear();
composers.Compose();
Assert.AreEqual(1, Composed.Count);
Assert.AreEqual(typeof(Composer10), Composed[0]);
types = new[] { typeof(Composer11) };
composers = new ComposerGraph(composition, types, Enumerable.Empty <Attribute>(), Mock.Of <ILogger <ComposerGraph> >());
Composed.Clear();
Assert.Throws <Exception>(() => composers.Compose());
Console.WriteLine("throws:");
composers = new ComposerGraph(composition, types, Enumerable.Empty <Attribute>(), Mock.Of <ILogger <ComposerGraph> >());
Dictionary <Type, List <Type> > requirements = composers.GetRequirements(false);
Console.WriteLine(ComposerGraph.GetComposersReport(requirements));
types = new[] { typeof(Composer2) };
composers = new ComposerGraph(composition, types, Enumerable.Empty <Attribute>(), Mock.Of <ILogger <ComposerGraph> >());
Composed.Clear();
Assert.Throws <Exception>(() => composers.Compose());
Console.WriteLine("throws:");
composers = new ComposerGraph(composition, types, Enumerable.Empty <Attribute>(), Mock.Of <ILogger <ComposerGraph> >());
requirements = composers.GetRequirements(false);
Console.WriteLine(ComposerGraph.GetComposersReport(requirements));
types = new[] { typeof(Composer12) };
composers = new ComposerGraph(composition, types, Enumerable.Empty <Attribute>(), Mock.Of <ILogger <ComposerGraph> >());
Composed.Clear();
composers.Compose();
Assert.AreEqual(1, Composed.Count);
Assert.AreEqual(typeof(Composer12), Composed[0]);
}
public virtual void Initialize()
{
var services = TestHelper.GetRegister();
var ioHelper = TestHelper.IOHelper;
var logger = new ProfilingLogger(Mock.Of <ILogger <ProfilingLogger> >(), Mock.Of <IProfiler>());
var typeFinder = TestHelper.GetTypeFinder();
var typeLoader = new TypeLoader(typeFinder, NoAppCache.Instance,
new DirectoryInfo(ioHelper.MapPath(Constants.SystemDirectories.TempData)),
Mock.Of <ILogger <TypeLoader> >(),
logger,
false);
var composition = new UmbracoBuilder(services, Mock.Of <IConfiguration>(), TestHelper.GetMockedTypeLoader());
services.AddUnique <ILogger>(_ => Mock.Of <ILogger>());
services.AddUnique <ILoggerFactory>(_ => NullLoggerFactory.Instance);
services.AddUnique <IProfiler>(_ => Mock.Of <IProfiler>());
services.AddUnique(typeLoader);
composition.WithCollectionBuilder <MapperCollectionBuilder>()
.AddCoreMappers();
services.AddUnique <ISqlContext>(_ => SqlContext);
var factory = Current.Factory = TestHelper.CreateServiceProvider(composition);
var pocoMappers = new NPoco.MapperCollection {
new PocoMapper()
};
var pocoDataFactory = new FluentPocoDataFactory((type, iPocoDataFactory) => new PocoDataBuilder(type, pocoMappers).Init());
var sqlSyntax = new SqlCeSyntaxProvider(Options.Create(new GlobalSettings()));
SqlContext = new SqlContext(sqlSyntax, DatabaseType.SQLCe, pocoDataFactory, new Lazy <IMapperCollection>(() => factory.GetRequiredService <IMapperCollection>()));
Mappers = factory.GetRequiredService <IMapperCollection>();
SetUp();
}
public void AllComposers()
{
ITypeFinder typeFinder = TestHelper.GetTypeFinder();
var typeLoader = new TypeLoader(typeFinder, new VaryingRuntimeHash(), AppCaches.Disabled.RuntimeCache, new DirectoryInfo(TestHelper.GetHostingEnvironment().MapPathContentRoot(Constants.SystemDirectories.TempData)), Mock.Of <ILogger <TypeLoader> >(), Mock.Of <IProfiler>());
IServiceCollection register = MockRegister();
var builder = new UmbracoBuilder(register, Mock.Of <IConfiguration>(), TestHelper.GetMockedTypeLoader());
var allComposers = typeLoader.GetTypes <IComposer>().ToList();
var types = allComposers.Where(x => x.FullName.StartsWith("Umbraco.Core.") || x.FullName.StartsWith("Umbraco.Web")).ToList();
var composers = new ComposerGraph(builder, types, Enumerable.Empty <Attribute>(), Mock.Of <ILogger <ComposerGraph> >());
Dictionary <Type, List <Type> > requirements = composers.GetRequirements();
string report = ComposerGraph.GetComposersReport(requirements);
Console.WriteLine(report);
IEnumerable <Type> composerTypes = composers.SortComposers(requirements);
foreach (Type type in composerTypes)
{
Console.WriteLine(type);
}
}
public virtual void Setup()
{
IServiceCollection container = TestHelper.GetServiceCollection();
TypeLoader typeLoader = TestHelper.GetMockedTypeLoader();
var composition = new UmbracoBuilder(container, Mock.Of <IConfiguration>(), TestHelper.GetMockedTypeLoader());
composition.WithCollectionBuilder <MapperCollectionBuilder>()
.AddCoreMappers();
composition.Services.AddUnique(_ => SqlContext);
IServiceProvider factory = composition.CreateServiceProvider();
var pocoMappers = new NPoco.MapperCollection
{
new NullableDateMapper()
};
var pocoDataFactory = new FluentPocoDataFactory((type, iPocoDataFactory) => new PocoDataBuilder(type, pocoMappers).Init());
var sqlSyntax = new SqlServerSyntaxProvider(Options.Create(new GlobalSettings()));
SqlContext = new SqlContext(sqlSyntax, DatabaseType.SqlServer2012, pocoDataFactory, factory.GetRequiredService <IMapperCollection>());
Mappers = factory.GetRequiredService <IMapperCollection>();
}
public void Setup()
{
var register = TestHelper.GetServiceCollection();
_builder = new UmbracoBuilder(register, Mock.Of <IConfiguration>(), TestHelper.GetMockedTypeLoader());
}
public void SimpleConverter3Test()
{
var register = new ServiceCollection();
var composition = new UmbracoBuilder(register, Mock.Of <IConfiguration>(), TestHelper.GetMockedTypeLoader());
composition.WithCollectionBuilder <PropertyValueConverterCollectionBuilder>()
.Append <SimpleConverter3A>()
.Append <SimpleConverter3B>();
IPublishedModelFactory factory = new PublishedModelFactory(
new[]
{
typeof(PublishedSnapshotTestObjects.TestElementModel1),
typeof(PublishedSnapshotTestObjects.TestElementModel2),
typeof(PublishedSnapshotTestObjects.TestContentModel1),
typeof(PublishedSnapshotTestObjects.TestContentModel2)
}, Mock.Of <IPublishedValueFallback>());
register.AddTransient(f => factory);
var cacheMock = new Mock <IPublishedContentCache>();
var cacheContent = new Dictionary <int, IPublishedContent>();
cacheMock.Setup(x => x.GetById(It.IsAny <int>())).Returns <int>(id =>
cacheContent.TryGetValue(id, out IPublishedContent content) ? content : null);
var publishedSnapshotMock = new Mock <IPublishedSnapshot>();
publishedSnapshotMock.Setup(x => x.Content).Returns(cacheMock.Object);
var publishedSnapshotAccessorMock = new Mock <IPublishedSnapshotAccessor>();
var localPublishedSnapshot = publishedSnapshotMock.Object;
publishedSnapshotAccessorMock.Setup(x => x.TryGetPublishedSnapshot(out localPublishedSnapshot)).Returns(true);
register.AddTransient(f => publishedSnapshotAccessorMock.Object);
IServiceProvider registerFactory = composition.CreateServiceProvider();
PropertyValueConverterCollection converters =
registerFactory.GetRequiredService <PropertyValueConverterCollection>();
var serializer = new ConfigurationEditorJsonSerializer();
var dataTypeServiceMock = new Mock <IDataTypeService>();
var dataType1 = new DataType(
new VoidEditor(
Mock.Of <IDataValueEditorFactory>()),
serializer)
{
Id = 1
};
var dataType2 = new DataType(
new VoidEditor(
"2",
Mock.Of <IDataValueEditorFactory>()),
serializer)
{
Id = 2
};
dataTypeServiceMock.Setup(x => x.GetAll()).Returns(new[] { dataType1, dataType2 });
var contentTypeFactory = new PublishedContentTypeFactory(factory, converters, dataTypeServiceMock.Object);
IEnumerable <IPublishedPropertyType> CreatePropertyTypes(IPublishedContentType contentType, int i)
{
yield return(contentTypeFactory.CreatePropertyType(contentType, "prop" + i, i));
}
IPublishedContentType elementType1 =
contentTypeFactory.CreateContentType(Guid.NewGuid(), 1000, "element1", t => CreatePropertyTypes(t, 1));
IPublishedContentType elementType2 =
contentTypeFactory.CreateContentType(Guid.NewGuid(), 1001, "element2", t => CreatePropertyTypes(t, 2));
IPublishedContentType contentType1 =
contentTypeFactory.CreateContentType(Guid.NewGuid(), 1002, "content1", t => CreatePropertyTypes(t, 1));
IPublishedContentType contentType2 =
contentTypeFactory.CreateContentType(Guid.NewGuid(), 1003, "content2", t => CreatePropertyTypes(t, 2));
var element1 = new PublishedElement(
elementType1,
Guid.NewGuid(),
new Dictionary <string, object> {
{ "prop1", "val1" }
},
false);
var element2 = new PublishedElement(
elementType2,
Guid.NewGuid(),
new Dictionary <string, object> {
{ "prop2", "1003" }
},
false);
var cnt1 = new InternalPublishedContent(contentType1)
{
Id = 1003,
Properties = new[]
{
new InternalPublishedProperty {
Alias = "prop1", SolidHasValue = true, SolidValue = "val1"
}
}
};
var cnt2 = new InternalPublishedContent(contentType1)
{
Id = 1004,
Properties = new[]
{
new InternalPublishedProperty {
Alias = "prop2", SolidHasValue = true, SolidValue = "1003"
}
}
};
IPublishedModelFactory publishedModelFactory = registerFactory.GetRequiredService <IPublishedModelFactory>();
cacheContent[cnt1.Id] = cnt1.CreateModel(publishedModelFactory);
cacheContent[cnt2.Id] = cnt2.CreateModel(publishedModelFactory);
// can get the actual property Clr type
// ie ModelType gets properly mapped by IPublishedContentModelFactory
// must test ModelClrType with special equals 'cos they are not ref-equals
Assert.IsTrue(ModelType.Equals(
typeof(IEnumerable <>).MakeGenericType(ModelType.For("content1")),
contentType2.GetPropertyType("prop2").ModelClrType));
Assert.AreEqual(
typeof(IEnumerable <PublishedSnapshotTestObjects.TestContentModel1>),
contentType2.GetPropertyType("prop2").ClrType);
// can create a model for an element
IPublishedElement model1 = factory.CreateModel(element1);
Assert.IsInstanceOf <PublishedSnapshotTestObjects.TestElementModel1>(model1);
Assert.AreEqual("val1", ((PublishedSnapshotTestObjects.TestElementModel1)model1).Prop1);
// can create a model for a published content
IPublishedElement model2 = factory.CreateModel(element2);
Assert.IsInstanceOf <PublishedSnapshotTestObjects.TestElementModel2>(model2);
var mmodel2 = (PublishedSnapshotTestObjects.TestElementModel2)model2;
// and get direct property
Assert.IsInstanceOf <PublishedSnapshotTestObjects.TestContentModel1[]>(
model2.Value(Mock.Of <IPublishedValueFallback>(), "prop2"));
Assert.AreEqual(
1,
((PublishedSnapshotTestObjects.TestContentModel1[])model2.Value(Mock.Of <IPublishedValueFallback>(), "prop2")).Length);
// and get model property
Assert.IsInstanceOf <IEnumerable <PublishedSnapshotTestObjects.TestContentModel1> >(mmodel2.Prop2);
Assert.IsInstanceOf <PublishedSnapshotTestObjects.TestContentModel1[]>(mmodel2.Prop2);
PublishedSnapshotTestObjects.TestContentModel1 mmodel1 = mmodel2.Prop2.First();
// and we get what we want
Assert.AreSame(cacheContent[mmodel1.Id], mmodel1);
}
public void Boot1A()
{
IServiceCollection register = MockRegister();
var composition = new UmbracoBuilder(register, Mock.Of <IConfiguration>(), TestHelper.GetMockedTypeLoader());
Type[] types = TypeArray <Composer1, Composer2, Composer4>();
var composers = new ComposerGraph(composition, types, Enumerable.Empty <Attribute>(), Mock.Of <ILogger <ComposerGraph> >());
Composed.Clear();
// 2 is Core and requires 4
// 3 is User
// => reorder components accordingly
composers.Compose();
AssertTypeArray(TypeArray <Composer1, Composer4, Composer2>(), Composed);
IServiceProvider factory = MockFactory(m =>
{
m.Setup(x => x.GetService(It.Is <Type>(t => t == typeof(ISomeResource)))).Returns(() => new SomeResource());
m.Setup(x => x.GetService(It.IsAny <Type>())).Returns <Type>((type) =>
{
if (type == typeof(Composer1))
{
return(new Composer1());
}
if (type == typeof(Composer5))
{
return(new Composer5());
}
if (type == typeof(Component5))
{
return(new Component5(new SomeResource()));
}
if (type == typeof(IProfilingLogger))
{
return(new ProfilingLogger(Mock.Of <ILogger <ProfilingLogger> >(), Mock.Of <IProfiler>()));
}
if (type == typeof(ILogger <ComponentCollection>))
{
return(Mock.Of <ILogger <ComponentCollection> >());
}
throw new NotSupportedException(type.FullName);
});
});
ComponentCollectionBuilder builder = composition.WithCollectionBuilder <ComponentCollectionBuilder>();
builder.RegisterWith(register);
ComponentCollection components = builder.CreateCollection(factory);
Assert.IsEmpty(components);
components.Initialize();
Assert.IsEmpty(Initialized);
components.Terminate();
Assert.IsEmpty(Terminated);
}
public virtual void SetUp()
{
// should not need this if all other tests were clean
// but hey, never know, better avoid garbage-in
Reset();
// get/merge the attributes marking the method and/or the classes
Options = TestOptionAttributeBase.GetTestOptions <UmbracoTestAttribute>();
// FIXME: align to runtimes & components - don't redo everything here !!!! Yes this is getting painful
var loggerFactory = GetLoggerFactory(Options.Logger);
_loggerFactory = loggerFactory;
var profiler = new LogProfiler(loggerFactory.CreateLogger <LogProfiler>());
var msLogger = loggerFactory.CreateLogger("msLogger");
var proflogger = new ProfilingLogger(loggerFactory.CreateLogger <ProfilingLogger>(), profiler);
IOHelper = TestHelper.IOHelper;
TypeFinder = new TypeFinder(loggerFactory.CreateLogger <TypeFinder>(), new DefaultUmbracoAssemblyProvider(GetType().Assembly, loggerFactory), new VaryingRuntimeHash());
var appCaches = GetAppCaches();
var globalSettings = new GlobalSettings();
var settings = new WebRoutingSettings();
IBackOfficeInfo backOfficeInfo = new AspNetBackOfficeInfo(globalSettings, IOHelper, loggerFactory.CreateLogger <AspNetBackOfficeInfo>(), Microsoft.Extensions.Options.Options.Create(settings));
IIpResolver ipResolver = new AspNetIpResolver();
UmbracoVersion = new UmbracoVersion();
LocalizedTextService = new LocalizedTextService(new Dictionary <CultureInfo, Lazy <XDocument> >(), loggerFactory.CreateLogger <LocalizedTextService>());
var typeLoader = GetTypeLoader(IOHelper, TypeFinder, appCaches.RuntimeCache, HostingEnvironment, loggerFactory.CreateLogger <TypeLoader>(), proflogger, Options.TypeLoader);
var services = TestHelper.GetRegister();
Builder = new UmbracoBuilder(services, Mock.Of <IConfiguration>(), typeLoader);
//TestHelper.GetConfigs().RegisterWith(register);
services.AddUnique(typeof(ILoggerFactory), loggerFactory);
services.AddTransient(typeof(ILogger <>), typeof(Logger <>));
services.AddSingleton <ILogger>(msLogger);
services.AddUnique(IOHelper);
services.AddUnique(UriUtility);
services.AddUnique(UmbracoVersion);
services.AddUnique(TypeFinder);
services.AddUnique(LocalizedTextService);
services.AddUnique(typeLoader);
services.AddUnique <IProfiler>(profiler);
services.AddUnique <IProfilingLogger>(proflogger);
services.AddUnique(appCaches);
services.AddUnique(HostingEnvironment);
services.AddUnique(backOfficeInfo);
services.AddUnique(ipResolver);
services.AddUnique <IPasswordHasher, AspNetPasswordHasher>();
services.AddUnique(TestHelper.ShortStringHelper);
//services.AddUnique<IPublicAccessChecker, PublicAccessChecker>();
var memberService = Mock.Of <IMemberService>();
var memberTypeService = Mock.Of <IMemberTypeService>();
TestObjects = new TestObjects();
Compose();
Current.Factory = Factory = TestHelper.CreateServiceProvider(Builder);
Initialize();
}
