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 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 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 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 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 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 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);
}