private Track(int key, CsvReader csvReader)
{
Key = key;
FileName = csvReader.ReadString();
FullFileName = csvReader.ReadString();
var locationKey = csvReader.ReadInt();
Location = DC.Data._Locations.GetItem(locationKey) ?? Location.NoLocation;
Title = csvReader.ReadStringNull();
TitleLowerCase = Title?.ToLowerInvariant();
Duration = csvReader.ReadTimeNull();
Album = csvReader.ReadStringNull();
AlbumLowerCase = Album?.ToLowerInvariant();
AlbumTrack = csvReader.ReadIntNull();
Artists = csvReader.ReadStringNull();
ArtistsLowerCase = Artists?.ToLowerInvariant();
Composers = csvReader.ReadStringNull();
ComposersLowerCase = Composers?.ToLowerInvariant();
Publisher = csvReader.ReadStringNull();
PublisherLowerCase = Publisher?.ToLowerInvariant();
Year = csvReader.ReadIntNull();
Genres = csvReader.ReadStringNull();
Weight = csvReader.ReadIntNull();
Volume = csvReader.ReadIntNull();
SkipStart = csvReader.ReadIntNull();
SkipEnd = csvReader.ReadIntNull();
TitleArtists = csvReader.ReadString();
DC.Data._TracksByTitleArtists.Add(TitleArtists, this);
playlistTracks = new StorageList <PlaylistTrack>();
if (Location != Location.NoLocation)
{
Location.AddToTracks(this);
}
onCsvConstruct();
}
public void WeakDependencies()
{
var register = MockRegister();
var composition = new Composition(register, MockTypeLoader(), Mock.Of <IProfilingLogger>(), MockRuntimeState(RuntimeLevel.Unknown));
var types = new[] { typeof(Composer10) };
var composers = new Composers(composition, types, Mock.Of <IProfilingLogger>());
Composed.Clear();
composers.Compose();
Assert.AreEqual(1, Composed.Count);
Assert.AreEqual(typeof(Composer10), Composed[0]);
types = new[] { typeof(Composer11) };
composers = new Composers(composition, types, Mock.Of <IProfilingLogger>());
Composed.Clear();
Assert.Throws <Exception>(() => composers.Compose());
types = new[] { typeof(Composer2) };
composers = new Composers(composition, types, Mock.Of <IProfilingLogger>());
Composed.Clear();
Assert.Throws <Exception>(() => composers.Compose());
types = new[] { typeof(Composer12) };
composers = new Composers(composition, types, Mock.Of <IProfilingLogger>());
Composed.Clear();
composers.Compose();
Assert.AreEqual(1, Composed.Count);
Assert.AreEqual(typeof(Composer12), Composed[0]);
}
/// <summary>
/// Populates the object with metadata from the taglib file object
/// </summary>
protected override void PopulateMediaMetadata()
{
if (!string.IsNullOrEmpty(Path))
{
// try to create the file object
TagLib.File file = null;
try
{
file = TagLib.File.Create(Path);
}
catch { }
// if the file obj was successfully created, get data from it
if (file != null)
{
Artists.AddRange(file.Tag.AlbumArtists);
Album = file.Tag.Album;
Genres.AddRange(file.Tag.Genres);
Composers.AddRange(file.Tag.Composers);
Title = file.Tag.Title;
Year = file.Tag.Year;
Track = file.Tag.Track;
Disc = file.Tag.Disc;
Duration = file.Properties.Duration;
Lyrics = file.Tag.Lyrics;
Comment = file.Tag.Comment;
}
}
}
public void Initialize()
{
Composed.Clear();
Initialized.Clear();
Terminated.Clear();
var register = MockRegister();
var factory = MockFactory(m =>
{
m.Setup(x => x.TryGetInstance(It.Is <Type>(t => t == typeof(ISomeResource)))).Returns(() => new SomeResource());
m.Setup(x => x.GetInstance(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>(), Mock.Of <IProfiler>()));
}
throw new NotSupportedException(type.FullName);
});
});
var composition = new Composition(register, MockTypeLoader(), Mock.Of <IProfilingLogger>(), MockRuntimeState(RuntimeLevel.Unknown));
var types = new[] { typeof(Composer1), typeof(Composer5) };
var composers = new Composers(composition, types, Mock.Of <IProfilingLogger>());
Assert.IsEmpty(Composed);
composers.Compose();
AssertTypeArray(TypeArray <Composer1, Composer5>(), Composed);
var builder = composition.WithCollectionBuilder <ComponentCollectionBuilder>();
builder.RegisterWith(register);
var components = builder.CreateCollection(factory);
Assert.IsEmpty(Initialized);
components.Initialize();
AssertTypeArray(TypeArray <Component5>(), Initialized);
Assert.IsEmpty(Terminated);
components.Terminate();
AssertTypeArray(TypeArray <Component5>(), Terminated);
}
public void Boot1A()
{
var register = MockRegister();
var typeLoader = MockTypeLoader();
var composition = new Composition(register, typeLoader, Mock.Of <IProfilingLogger>(), MockRuntimeState(RuntimeLevel.Unknown));
var types = TypeArray <Composer1, Composer2, Composer3, Composer4>();
var composers = new Composers(composition, types, Enumerable.Empty <Attribute>(), Mock.Of <IProfilingLogger>());
Composed.Clear();
// 2 is Core and requires 4
// 3 is User - goes away with RuntimeLevel.Unknown
// => reorder components accordingly
composers.Compose();
AssertTypeArray(TypeArray <Composer1, Composer4, Composer2>(), Composed);
var factory = MockFactory(m =>
{
m.Setup(x => x.TryGetInstance(It.Is <Type>(t => t == typeof(ISomeResource)))).Returns(() => new SomeResource());
m.Setup(x => x.GetInstance(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>(), Mock.Of <IProfiler>()));
}
throw new NotSupportedException(type.FullName);
});
});
var builder = composition.WithCollectionBuilder <ComponentCollectionBuilder>();
builder.RegisterWith(register);
var components = builder.CreateCollection(factory);
Assert.IsEmpty(components);
components.Initialize();
Assert.IsEmpty(Initialized);
components.Terminate();
Assert.IsEmpty(Terminated);
}
public void Requires1()
{
var register = MockRegister();
var composition = new Composition(register, MockTypeLoader(), Mock.Of <IProfilingLogger>(), MockRuntimeState(RuntimeLevel.Unknown));
var types = new[] { typeof(Composer6), typeof(Composer7), typeof(Composer8) };
var composers = new Composers(composition, types, Mock.Of <IProfilingLogger>());
Composed.Clear();
composers.Compose();
Assert.AreEqual(2, Composed.Count);
Assert.AreEqual(typeof(Composer6), Composed[0]);
Assert.AreEqual(typeof(Composer8), Composed[1]);
}
public void Boot2()
{
var register = MockRegister();
var composition = new Composition(register, MockTypeLoader(), Mock.Of <IProfilingLogger>(), MockRuntimeState(RuntimeLevel.Unknown));
var types = TypeArray <Composer20, Composer21>();
var composers = new Composers(composition, types, Mock.Of <IProfilingLogger>());
Composed.Clear();
// 21 is required by 20
// => reorder components accordingly
composers.Compose();
AssertTypeArray(TypeArray <Composer21, Composer20>(), Composed);
}
public void DisableMissing()
{
var register = MockRegister();
var composition = new Composition(register, MockTypeLoader(), Mock.Of <IProfilingLogger>(), MockRuntimeState(RuntimeLevel.Unknown));
var types = new[] { typeof(Composer6), typeof(Composer8) }; // 8 disables 7 which is not in the list
var composers = new Composers(composition, types, Mock.Of <IProfilingLogger>());
Composed.Clear();
composers.Compose();
Assert.AreEqual(2, Composed.Count);
Assert.AreEqual(typeof(Composer6), Composed[0]);
Assert.AreEqual(typeof(Composer8), Composed[1]);
}
public void Requires2A()
{
var register = MockRegister();
var composition = new Composition(register, MockTypeLoader(), Mock.Of <IProfilingLogger>(), MockRuntimeState(RuntimeLevel.Unknown));
var types = new[] { typeof(Composer9), typeof(Composer2), typeof(Composer4) };
var composers = new Composers(composition, types, Mock.Of <IProfilingLogger>());
Composed.Clear();
composers.Compose();
Assert.AreEqual(2, Composed.Count);
Assert.AreEqual(typeof(Composer4), Composed[0]);
Assert.AreEqual(typeof(Composer2), Composed[1]);
//Assert.AreEqual(typeof(Component9), Composed[2]); -- goes away with RuntimeLevel.Unknown
}
public void Boot1B()
{
var register = MockRegister();
var composition = new Composition(register, MockTypeLoader(), Mock.Of <IProfilingLogger>(), MockRuntimeState(RuntimeLevel.Run));
var types = TypeArray <Composer1, Composer2, Composer3, Composer4>();
var composers = new Composers(composition, types, Mock.Of <IProfilingLogger>());
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 void Boot3()
{
var register = MockRegister();
var composition = new Composition(register, MockTypeLoader(), Mock.Of <IProfilingLogger>(), MockRuntimeState(RuntimeLevel.Unknown));
var types = TypeArray <Composer22, Composer24, Composer25>();
var composers = new Composers(composition, types, Mock.Of <IProfilingLogger>());
Composed.Clear();
// i23 requires 22
// 24, 25 implement i23
// 25 required by i23
// => reorder components accordingly
composers.Compose();
AssertTypeArray(TypeArray <Composer22, Composer25, Composer24>(), Composed);
}
public void BrokenRequired()
{
var register = MockRegister();
var composition = new Composition(register, MockTypeLoader(), Mock.Of <IProfilingLogger>(), MockRuntimeState(RuntimeLevel.Unknown));
var types = TypeArray <Composer2, Composer4, Composer13>();
var composers = new Composers(composition, types, Mock.Of <IProfilingLogger>());
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 AllComposers()
{
var typeLoader = new TypeLoader(AppCaches.Disabled.RuntimeCache, IOHelper.MapPath("~/App_Data/TEMP"), Mock.Of <IProfilingLogger>());
var register = MockRegister();
var composition = new Composition(register, typeLoader, Mock.Of <IProfilingLogger>(), MockRuntimeState(RuntimeLevel.Run));
var types = typeLoader.GetTypes <IComposer>().Where(x => x.FullName.StartsWith("Umbraco.Core.") || x.FullName.StartsWith("Umbraco.Web"));
var composers = new Composers(composition, types, Enumerable.Empty <Attribute>(), Mock.Of <IProfilingLogger>());
var requirements = composers.GetRequirements();
var report = Composers.GetComposersReport(requirements);
Console.WriteLine(report);
var composerTypes = composers.SortComposers(requirements);
foreach (var type in composerTypes)
{
Console.WriteLine(type);
}
}
public void AttributesPriorities()
{
var register = MockRegister();
var composition = new Composition(register, MockTypeLoader(), Mock.Of <IProfilingLogger>(), MockRuntimeState(RuntimeLevel.Unknown));
var types = new[] { typeof(Composer26) }; // 26 disabled by assembly attribute
var composers = new Composers(composition, types, Mock.Of <IProfilingLogger>());
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 Composers(composition, types, Mock.Of <IProfilingLogger>());
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()
{
var register = MockRegister();
var factory = MockFactory();
var composition = new Composition(register, MockTypeLoader(), Mock.Of <IProfilingLogger>(), MockRuntimeState(RuntimeLevel.Run));
var types = new[] { typeof(Composer9), typeof(Composer2), typeof(Composer4) };
var composers = new Composers(composition, types, Mock.Of <IProfilingLogger>());
Composed.Clear();
composers.Compose();
var builder = composition.WithCollectionBuilder <ComponentCollectionBuilder>();
builder.RegisterWith(register);
var 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 WeakDependencies()
{
var register = MockRegister();
var typeLoader = MockTypeLoader();
var composition = new Composition(register, typeLoader, Mock.Of <IProfilingLogger>(), MockRuntimeState(RuntimeLevel.Unknown));
var types = new[] { typeof(Composer10) };
var composers = new Composers(composition, types, Enumerable.Empty <Attribute>(), Mock.Of <IProfilingLogger>());
Composed.Clear();
composers.Compose();
Assert.AreEqual(1, Composed.Count);
Assert.AreEqual(typeof(Composer10), Composed[0]);
types = new[] { typeof(Composer11) };
composers = new Composers(composition, types, Enumerable.Empty <Attribute>(), Mock.Of <IProfilingLogger>());
Composed.Clear();
Assert.Throws <Exception>(() => composers.Compose());
Console.WriteLine("throws:");
composers = new Composers(composition, types, Enumerable.Empty <Attribute>(), Mock.Of <IProfilingLogger>());
var requirements = composers.GetRequirements(false);
Console.WriteLine(Composers.GetComposersReport(requirements));
types = new[] { typeof(Composer2) };
composers = new Composers(composition, types, Enumerable.Empty <Attribute>(), Mock.Of <IProfilingLogger>());
Composed.Clear();
Assert.Throws <Exception>(() => composers.Compose());
Console.WriteLine("throws:");
composers = new Composers(composition, types, Enumerable.Empty <Attribute>(), Mock.Of <IProfilingLogger>());
requirements = composers.GetRequirements(false);
Console.WriteLine(Composers.GetComposersReport(requirements));
types = new[] { typeof(Composer12) };
composers = new Composers(composition, types, Enumerable.Empty <Attribute>(), Mock.Of <IProfilingLogger>());
Composed.Clear();
composers.Compose();
Assert.AreEqual(1, Composed.Count);
Assert.AreEqual(typeof(Composer12), Composed[0]);
}
public void BrokenRequire()
{
var register = MockRegister();
var composition = new Composition(register, MockTypeLoader(), Mock.Of <IProfilingLogger>(), MockRuntimeState(RuntimeLevel.Unknown));
var types = TypeArray <Composer1, Composer2, Composer3>();
var composers = new Composers(composition, types, Mock.Of <IProfilingLogger>());
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.Tests.Components.ComponentTests+Composer2 -> Umbraco.Tests.Components.ComponentTests+Composer4.", e.Message);
}
}
public override Task NavigatedToAsync(object parameter = null)
{
return(Task.Factory.StartNew(async() =>
{
do
{
await Task.Delay(100);
} while (ComposerList.Count == 0);
Device.BeginInvokeOnMainThread(() =>
{
if (Device.RuntimePlatform.Equals(Device.iOS)) //iOS
{
if (ComposerSimpleList.Any())
{
return;
}
ComposerSimpleList.AddRange(ComposerList);
}
else
{
if (Composers.Any())
{
return;
}
var groups = ComposerList.GroupBy(x => x.Name.First().ToString());
foreach (var group in groups)
{
var coll = new ComposerGroup();
coll.AddRange(group);
coll.ShortName = group.Key;
Composers.Add(coll);
}
}
});
}));
}
public void StandaloneTest()
{
IFactory factory = null;
// clear
foreach (var file in Directory.GetFiles(Path.Combine(IOHelper.MapPath("~/App_Data")), "NuCache.*"))
{
File.Delete(file);
}
// settings
// reset the current version to 0.0.0, clear connection strings
ConfigurationManager.AppSettings[Constants.AppSettings.ConfigurationStatus] = "";
// FIXME: we need a better management of settings here (and, true config files?)
// create the very basic and essential things we need
var logger = new ConsoleLogger();
var profiler = new LogProfiler(logger);
var profilingLogger = new ProfilingLogger(logger, profiler);
var appCaches = new AppCaches(); // FIXME: has HttpRuntime stuff?
var databaseFactory = new UmbracoDatabaseFactory(logger, new Lazy <IMapperCollection>(() => factory.GetInstance <IMapperCollection>()));
var typeLoader = new TypeLoader(appCaches.RuntimeCache, IOHelper.MapPath("~/App_Data/TEMP"), profilingLogger);
var mainDom = new SimpleMainDom();
var runtimeState = new RuntimeState(logger, null, null, new Lazy <IMainDom>(() => mainDom), new Lazy <IServerRegistrar>(() => factory.GetInstance <IServerRegistrar>()));
// create the register and the composition
var register = RegisterFactory.Create();
var composition = new Composition(register, typeLoader, profilingLogger, runtimeState);
composition.RegisterEssentials(logger, profiler, profilingLogger, mainDom, appCaches, databaseFactory, typeLoader, runtimeState);
// create the core runtime and have it compose itself
var coreRuntime = new CoreRuntime();
coreRuntime.Compose(composition);
// determine actual runtime level
runtimeState.DetermineRuntimeLevel(databaseFactory, logger);
Console.WriteLine(runtimeState.Level);
// going to be Install BUT we want to force components to be there (nucache etc)
runtimeState.Level = RuntimeLevel.Run;
var composerTypes = typeLoader.GetTypes <IComposer>() // all of them
.Where(x => !x.FullName.StartsWith("Umbraco.Tests.")) // exclude test components
.Where(x => x != typeof(WebInitialComposer) && x != typeof(WebFinalComposer)); // exclude web runtime
var composers = new Composers(composition, composerTypes, Enumerable.Empty <Attribute>(), profilingLogger);
composers.Compose();
// must registers stuff that WebRuntimeComponent would register otherwise
// FIXME: UmbracoContext creates a snapshot that it does not register with the accessor
// and so, we have to use the UmbracoContextPublishedSnapshotAccessor
// the UmbracoContext does not know about the accessor
// else that would be a catch-22 where they both know about each other?
//composition.Register<IPublishedSnapshotAccessor, TestPublishedSnapshotAccessor>(Lifetime.Singleton);
composition.Register <IPublishedSnapshotAccessor, UmbracoContextPublishedSnapshotAccessor>(Lifetime.Singleton);
composition.Register <IUmbracoContextAccessor, TestUmbracoContextAccessor>(Lifetime.Singleton);
composition.Register <IVariationContextAccessor, TestVariationContextAccessor>(Lifetime.Singleton);
composition.Register <IDefaultCultureAccessor, TestDefaultCultureAccessor>(Lifetime.Singleton);
composition.Register <ISiteDomainHelper>(_ => Mock.Of <ISiteDomainHelper>(), Lifetime.Singleton);
composition.Register(_ => Mock.Of <IImageUrlGenerator>(), Lifetime.Singleton);
composition.RegisterUnique(f => new DistributedCache());
composition.WithCollectionBuilder <UrlProviderCollectionBuilder>().Append <DefaultUrlProvider>();
composition.RegisterUnique <IDistributedCacheBinder, DistributedCacheBinder>();
composition.RegisterUnique <IExamineManager>(f => ExamineManager.Instance);
composition.RegisterUnique <IUmbracoContextFactory, UmbracoContextFactory>();
composition.RegisterUnique <IMacroRenderer, MacroRenderer>();
composition.RegisterUnique <MediaUrlProviderCollection>(_ => new MediaUrlProviderCollection(Enumerable.Empty <IMediaUrlProvider>()));
// initialize some components only/individually
composition.WithCollectionBuilder <ComponentCollectionBuilder>()
.Clear()
.Append <DistributedCacheBinderComponent>();
// configure
composition.Configs.Add(SettingsForTests.GetDefaultGlobalSettings);
composition.Configs.Add(SettingsForTests.GetDefaultUmbracoSettings);
// create and register the factory
Current.Factory = factory = composition.CreateFactory();
// instantiate and initialize components
var components = factory.GetInstance <ComponentCollection>();
// do stuff
Console.WriteLine(runtimeState.Level);
// install
if (true || runtimeState.Level == RuntimeLevel.Install)
{
var path = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
var file = databaseFactory.Configured ? Path.Combine(path, "UmbracoNPocoTests.sdf") : Path.Combine(path, "Umbraco.sdf");
if (File.Exists(file))
{
File.Delete(file);
}
// create the database file
// databaseBuilder.ConfigureEmbeddedDatabaseConnection() can do it too,
// but then it wants to write the connection string to web.config = bad
var connectionString = databaseFactory.Configured ? databaseFactory.ConnectionString : "Data Source=|DataDirectory|\\Umbraco.sdf;Flush Interval=1;";
using (var engine = new SqlCeEngine(connectionString))
{
engine.CreateDatabase();
}
//var databaseBuilder = factory.GetInstance<DatabaseBuilder>();
//databaseFactory.Configure(DatabaseBuilder.EmbeddedDatabaseConnectionString, Constants.DbProviderNames.SqlCe);
//databaseBuilder.CreateDatabaseSchemaAndData();
if (!databaseFactory.Configured)
{
databaseFactory.Configure(DatabaseBuilder.EmbeddedDatabaseConnectionString, Constants.DbProviderNames.SqlCe);
}
var scopeProvider = factory.GetInstance <IScopeProvider>();
using (var scope = scopeProvider.CreateScope())
{
var creator = new DatabaseSchemaCreator(scope.Database, logger);
creator.InitializeDatabaseSchema();
scope.Complete();
}
}
// done installing
runtimeState.Level = RuntimeLevel.Run;
components.Initialize();
// instantiate to register events
// should be done by Initialize?
// should we invoke Initialize?
_ = factory.GetInstance <IPublishedSnapshotService>();
// at that point, Umbraco can run!
// though, we probably still need to figure out what depends on HttpContext...
var contentService = factory.GetInstance <IContentService>();
var content = contentService.GetById(1234);
Assert.IsNull(content);
// create a document type and a document
var contentType = new ContentType(-1)
{
Alias = "ctype", Name = "ctype"
};
factory.GetInstance <IContentTypeService>().Save(contentType);
content = new Content("test", -1, contentType);
contentService.Save(content);
// assert that it is possible to get the document back
content = contentService.GetById(content.Id);
Assert.IsNotNull(content);
Assert.AreEqual("test", content.Name);
// need an UmbracoCOntext to access the cache
// FIXME: not exactly pretty, should not depend on HttpContext
var httpContext = Mock.Of <HttpContextBase>();
var umbracoContextFactory = factory.GetInstance <IUmbracoContextFactory>();
var umbracoContextReference = umbracoContextFactory.EnsureUmbracoContext(httpContext);
var umbracoContext = umbracoContextReference.UmbracoContext;
// assert that there is no published document
var pcontent = umbracoContext.Content.GetById(content.Id);
Assert.IsNull(pcontent);
// but a draft document
pcontent = umbracoContext.Content.GetById(true, content.Id);
Assert.IsNotNull(pcontent);
Assert.AreEqual("test", pcontent.Name());
Assert.IsTrue(pcontent.IsDraft());
// no published URL
Assert.AreEqual("#", pcontent.Url());
// now publish the document + make some unpublished changes
contentService.SaveAndPublish(content);
content.Name = "testx";
contentService.Save(content);
// assert that snapshot has been updated and there is now a published document
pcontent = umbracoContext.Content.GetById(content.Id);
Assert.IsNotNull(pcontent);
Assert.AreEqual("test", pcontent.Name());
Assert.IsFalse(pcontent.IsDraft());
// but the URL is the published one - no draft URL
Assert.AreEqual("/test/", pcontent.Url());
// and also an updated draft document
pcontent = umbracoContext.Content.GetById(true, content.Id);
Assert.IsNotNull(pcontent);
Assert.AreEqual("testx", pcontent.Name());
Assert.IsTrue(pcontent.IsDraft());
// and the published document has a URL
Assert.AreEqual("/test/", pcontent.Url());
umbracoContextReference.Dispose();
mainDom.Stop();
components.Terminate();
// exit!
}
public void ValidateComposition()
{
// this is almost what CoreRuntime does, without
// - managing MainDom
// - configuring for unhandled exceptions, assembly resolution, application root path
// - testing for database, and for upgrades (runtime level)
// - assigning the factory to Current.Factory
// create the very basic and essential things we need
var logger = new ConsoleLogger();
var profiler = Mock.Of <IProfiler>();
var profilingLogger = new ProfilingLogger(logger, profiler);
var appCaches = AppCaches.Disabled;
var databaseFactory = Mock.Of <IUmbracoDatabaseFactory>();
var typeLoader = new TypeLoader(appCaches.RuntimeCache, IOHelper.MapPath("~/App_Data/TEMP"), profilingLogger);
var runtimeState = Mock.Of <IRuntimeState>();
Mock.Get(runtimeState).Setup(x => x.Level).Returns(RuntimeLevel.Run);
var mainDom = Mock.Of <IMainDom>();
Mock.Get(mainDom).Setup(x => x.IsMainDom).Returns(true);
// create the register and the composition
var register = RegisterFactory.Create();
var composition = new Composition(register, typeLoader, profilingLogger, runtimeState);
composition.RegisterEssentials(logger, profiler, profilingLogger, mainDom, appCaches, databaseFactory, typeLoader, runtimeState);
// create the core runtime and have it compose itself
var coreRuntime = new CoreRuntime();
coreRuntime.Compose(composition);
// get the components
// all of them?
var composerTypes = typeLoader.GetTypes <IComposer>();
// filtered
composerTypes = composerTypes
.Where(x => !x.FullName.StartsWith("Umbraco.Tests"));
// single?
//var componentTypes = new[] { typeof(CoreRuntimeComponent) };
var composers = new Composers(composition, composerTypes, Enumerable.Empty <Attribute>(), profilingLogger);
// get components to compose themselves
composers.Compose();
// create the factory
var factory = composition.CreateFactory();
// at that point Umbraco is fully composed
// but nothing is initialized (no maindom, nothing - beware!)
// to actually *run* Umbraco standalone, better use a StandaloneRuntime
// that would inherit from CoreRuntime and ensure everything starts
// get components to initialize themselves
//components.Initialize(factory);
// and then, validate
var lightInjectContainer = (LightInject.ServiceContainer)factory.Concrete;
var results = lightInjectContainer.Validate().ToList();
foreach (var resultGroup in results.GroupBy(x => x.Severity).OrderBy(x => x.Key))
{
Console.WriteLine($"{resultGroup.Key}: {resultGroup.Count()}");
}
foreach (var resultGroup in results.GroupBy(x => x.Severity).OrderBy(x => x.Key))
{
foreach (var result in resultGroup)
{
Console.WriteLine();
Console.Write(ToText(result));
}
}
Assert.AreEqual(0, results.Count);
}
/// <summary>
/// Boots the runtime within a timer.
/// </summary>
protected virtual IFactory Boot(IRegister register, DisposableTimer timer)
{
Composition composition = null;
try
{
// Setup event listener
UnattendedInstalled += CoreRuntime_UnattendedInstalled;
// throws if not full-trust
new AspNetHostingPermission(AspNetHostingPermissionLevel.Unrestricted).Demand();
// run handlers
RuntimeOptions.DoRuntimeBoot(ProfilingLogger);
// application caches
var appCaches = GetAppCaches();
// database factory
var databaseFactory = GetDatabaseFactory();
// configs
var configs = GetConfigs();
// type loader
var typeLoader = new TypeLoader(appCaches.RuntimeCache, configs.Global().LocalTempPath, ProfilingLogger);
// runtime state
// beware! must use '() => _factory.GetInstance<T>()' and NOT '_factory.GetInstance<T>'
// as the second one captures the current value (null) and therefore fails
_state = new RuntimeState(Logger,
configs.Settings(), configs.Global(),
new Lazy <IMainDom>(() => _factory.GetInstance <IMainDom>()),
new Lazy <IServerRegistrar>(() => _factory.GetInstance <IServerRegistrar>()))
{
Level = RuntimeLevel.Boot
};
// TODO: remove this in netcore, this is purely backwards compat hacks with the empty ctor
if (MainDom == null)
{
MainDom = new MainDom(Logger, new MainDomSemaphoreLock(Logger));
}
// create the composition
composition = new Composition(register, typeLoader, ProfilingLogger, _state, configs);
composition.RegisterEssentials(Logger, Profiler, ProfilingLogger, MainDom, appCaches, databaseFactory, typeLoader, _state);
// run handlers
RuntimeOptions.DoRuntimeEssentials(composition, appCaches, typeLoader, databaseFactory);
// register runtime-level services
// there should be none, really - this is here "just in case"
Compose(composition);
// acquire the main domain - if this fails then anything that should be registered with MainDom will not operate
AcquireMainDom(MainDom);
// determine our runtime level
DetermineRuntimeLevel(databaseFactory, ProfilingLogger);
// get composers, and compose
var composerTypes = ResolveComposerTypes(typeLoader);
IEnumerable <Attribute> enableDisableAttributes;
using (ProfilingLogger.DebugDuration <CoreRuntime>("Scanning enable/disable composer attributes"))
{
enableDisableAttributes = typeLoader.GetAssemblyAttributes(typeof(EnableComposerAttribute), typeof(DisableComposerAttribute));
}
var composers = new Composers(composition, composerTypes, enableDisableAttributes, ProfilingLogger);
composers.Compose();
// create the factory
_factory = Current.Factory = composition.CreateFactory();
// determines if unattended install is enabled and performs it if required
DoUnattendedInstall(databaseFactory);
// determine our runtime level (AFTER UNATTENDED INSTALL)
// TODO: Feels kinda weird to call this again
DetermineRuntimeLevel(databaseFactory, ProfilingLogger);
// if level is Run and reason is UpgradeMigrations, that means we need to perform an unattended upgrade
if (_state.Reason == RuntimeLevelReason.UpgradeMigrations && _state.Level == RuntimeLevel.Run)
{
// do the upgrade
DoUnattendedUpgrade(_factory.GetInstance <DatabaseBuilder>());
// upgrade is done, set reason to Run
_state.Reason = RuntimeLevelReason.Run;
}
// create & initialize the components
_components = _factory.GetInstance <ComponentCollection>();
_components.Initialize();
}
catch (Exception e)
{
var bfe = e as BootFailedException ?? new BootFailedException("Boot failed.", e);
if (_state != null)
{
_state.Level = RuntimeLevel.BootFailed;
_state.BootFailedException = bfe;
}
timer?.Fail(exception: bfe); // be sure to log the exception - even if we repeat ourselves
// if something goes wrong above, we may end up with no factory
// meaning nothing can get the runtime state, etc - so let's try
// to make sure we have a factory
if (_factory == null)
{
try
{
_factory = Current.Factory = composition?.CreateFactory();
}
catch
{
// In this case we are basically dead, we do not have a factory but we need
// to report on the state so we need to manually set that, this is the only time
// we ever do this.
Current.RuntimeState = _state;
}
}
Debugger.Break();
// throwing here can cause w3wp to hard-crash and we want to avoid it.
// instead, we're logging the exception and setting level to BootFailed.
// various parts of Umbraco such as UmbracoModule and UmbracoDefaultOwinStartup
// understand this and will nullify themselves, while UmbracoModule will
// throw a BootFailedException for every requests.
}
return(_factory);
}
private void CloseIconPressedLoreItem()
{
Composers.Remove("loreItem");
}
/// <summary>
/// Boots the runtime within a timer.
/// </summary>
protected virtual IFactory Boot(IRegister register, DisposableTimer timer)
{
Composition composition = null;
try
{
// throws if not full-trust
new AspNetHostingPermission(AspNetHostingPermissionLevel.Unrestricted).Demand();
// application caches
var appCaches = GetAppCaches();
var runtimeCache = appCaches.RuntimeCache;
// database factory
var databaseFactory = GetDatabaseFactory();
// configs
var configs = GetConfigs();
// type loader
var localTempStorage = configs.Global().LocalTempStorageLocation;
var typeLoader = new TypeLoader(runtimeCache, localTempStorage, ProfilingLogger);
// runtime state
// beware! must use '() => _factory.GetInstance<T>()' and NOT '_factory.GetInstance<T>'
// as the second one captures the current value (null) and therefore fails
_state = new RuntimeState(Logger,
configs.Settings(), configs.Global(),
new Lazy <IMainDom>(() => _factory.GetInstance <IMainDom>()),
new Lazy <IServerRegistrar>(() => _factory.GetInstance <IServerRegistrar>()))
{
Level = RuntimeLevel.Boot
};
// main dom
var mainDom = new MainDom(Logger);
// create the composition
composition = new Composition(register, typeLoader, ProfilingLogger, _state, configs);
composition.RegisterEssentials(Logger, Profiler, ProfilingLogger, mainDom, appCaches, databaseFactory, typeLoader, _state);
// register runtime-level services
// there should be none, really - this is here "just in case"
Compose(composition);
// acquire the main domain, determine our runtime level
AcquireMainDom(mainDom);
DetermineRuntimeLevel(databaseFactory, ProfilingLogger);
// get composers, and compose
var composerTypes = ResolveComposerTypes(typeLoader);
composition.WithCollectionBuilder <ComponentCollectionBuilder>();
var composers = new Composers(composition, composerTypes, ProfilingLogger);
composers.Compose();
// create the factory
_factory = Current.Factory = composition.CreateFactory();
// create & initialize the components
_components = _factory.GetInstance <ComponentCollection>();
_components.Initialize();
}
catch (Exception e)
{
var bfe = e as BootFailedException ?? new BootFailedException("Boot failed.", e);
if (_state != null)
{
_state.Level = RuntimeLevel.BootFailed;
_state.BootFailedException = bfe;
}
timer.Fail(exception: bfe); // be sure to log the exception - even if we repeat ourselves
// if something goes wrong above, we may end up with no factory
// meaning nothing can get the runtime state, etc - so let's try
// to make sure we have a factory
if (_factory == null)
{
try
{
_factory = Current.Factory = composition?.CreateFactory();
}
catch { /* yea */ }
}
Debugger.Break();
// throwing here can cause w3wp to hard-crash and we want to avoid it.
// instead, we're logging the exception and setting level to BootFailed.
// various parts of Umbraco such as UmbracoModule and UmbracoDefaultOwinStartup
// understand this and will nullify themselves, while UmbracoModule will
// throw a BootFailedException for every requests.
}
return(_factory);
}
