Example #1
0
        protected override IPublishedSnapshotService CreatePublishedSnapshotService()
        {
            var options = new PublishedSnapshotServiceOptions {
                IgnoreLocalDb = true
            };
            var publishedSnapshotAccessor = new UmbracoContextPublishedSnapshotAccessor(Umbraco.Web.Composing.Current.UmbracoContextAccessor);
            var runtimeStateMock          = new Mock <IRuntimeState>();

            runtimeStateMock.Setup(x => x.Level).Returns(() => RuntimeLevel.Run);

            var contentTypeFactory = Factory.GetInstance <IPublishedContentTypeFactory>();
            var documentRepository = Mock.Of <IDocumentRepository>();
            var mediaRepository    = Mock.Of <IMediaRepository>();
            var memberRepository   = Mock.Of <IMemberRepository>();

            return(new PublishedSnapshotService(
                       options,
                       null,
                       runtimeStateMock.Object,
                       ServiceContext,
                       contentTypeFactory,
                       null,
                       publishedSnapshotAccessor,
                       Mock.Of <IVariationContextAccessor>(),
                       ProfilingLogger,
                       ScopeProvider,
                       documentRepository, mediaRepository, memberRepository,
                       DefaultCultureAccessor,
                       new DatabaseDataSource(),
                       Factory.GetInstance <IGlobalSettings>(),
                       Factory.GetInstance <IEntityXmlSerializer>(),
                       Mock.Of <IPublishedModelFactory>(),
                       new UrlSegmentProviderCollection(new[] { new DefaultUrlSegmentProvider() }),
                       new TestSyncBootStateAccessor(SyncBootState.WarmBoot)));
        }
Example #2
0
        protected override void Initialize()
        {
            base.Initialize();

            if (!(PublishedSnapshotService is PublishedSnapshotService))
            {
                var options = new PublishedSnapshotServiceOptions {
                    IgnoreLocalDb = true
                };
                var runtime = Mock.Of <IRuntimeState>();
                PublishedSnapshotService = new PublishedSnapshotService(
                    options,
                    null,
                    runtime,
                    ServiceContext,
                    Factory.GetInstance <IPublishedContentTypeFactory>(),
                    null,
                    new TestPublishedSnapshotAccessor(),
                    new TestVariationContextAccessor(),
                    Mock.Of <IProfilingLogger>(),
                    ScopeProvider,
                    Factory.GetInstance <IDocumentRepository>(), Factory.GetInstance <IMediaRepository>(), Factory.GetInstance <IMemberRepository>(),
                    DefaultCultureAccessor,
                    new DatabaseDataSource(new JsonContentNestedDataSerializerFactory()),
                    new GlobalSettings(),
                    Factory.GetInstance <IEntityXmlSerializer>(),
                    Factory.GetInstance <IPublishedModelFactory>(),
                    new UrlSegmentProviderCollection(new[] { new DefaultUrlSegmentProvider() }),
                    new TestSyncBootStateAccessor(SyncBootState.WarmBoot),
                    new JsonContentNestedDataSerializerFactory()
                    );
            }
        }
        protected override IPublishedSnapshotService CreatePublishedSnapshotService(GlobalSettings globalSettings = null)
        {
            var options = new PublishedSnapshotServiceOptions {
                IgnoreLocalDb = true
            };
            var publishedSnapshotAccessor = new UmbracoContextPublishedSnapshotAccessor(Current.UmbracoContextAccessor);
            var runtimeStateMock          = new Mock <IRuntimeState>();

            runtimeStateMock.Setup(x => x.Level).Returns(() => RuntimeLevel.Run);

            var contentTypeFactory = Factory.GetRequiredService <IPublishedContentTypeFactory>();
            var documentRepository = Mock.Of <IDocumentRepository>();
            var mediaRepository    = Mock.Of <IMediaRepository>();
            var memberRepository   = Mock.Of <IMemberRepository>();
            var hostingEnvironment = TestHelper.GetHostingEnvironment();

            var typeFinder = TestHelper.GetTypeFinder();

            var nuCacheSettings = new NuCacheSettings();
            var lifetime        = new Mock <IUmbracoApplicationLifetime>();
            var repository      = new NuCacheContentRepository(ScopeProvider, AppCaches.Disabled, Mock.Of <ILogger <NuCacheContentRepository> >(), memberRepository, documentRepository, mediaRepository, Mock.Of <IShortStringHelper>(), new UrlSegmentProviderCollection(new[] { new DefaultUrlSegmentProvider(ShortStringHelper) }));
            var snapshotService = new PublishedSnapshotService(
                options,
                null,
                ServiceContext,
                contentTypeFactory,
                publishedSnapshotAccessor,
                Mock.Of <IVariationContextAccessor>(),
                base.ProfilingLogger,
                NullLoggerFactory.Instance,
                ScopeProvider,
                new NuCacheContentService(repository, ScopeProvider, NullLoggerFactory.Instance, Mock.Of <IEventMessagesFactory>()),
                DefaultCultureAccessor,
                Microsoft.Extensions.Options.Options.Create(globalSettings ?? new GlobalSettings()),
                Factory.GetRequiredService <IEntityXmlSerializer>(),
                new NoopPublishedModelFactory(),
                hostingEnvironment,
                Microsoft.Extensions.Options.Options.Create(nuCacheSettings));

            return(snapshotService);
        }
Example #4
0
        private void Init()
        {
            Current.Reset();

            var factory = Mock.Of <IFactory>();

            Current.Factory = factory;

            var configs = new Configs();

            Mock.Get(factory).Setup(x => x.GetInstance(typeof(Configs))).Returns(configs);
            var globalSettings = new GlobalSettings();

            configs.Add(SettingsForTests.GenerateMockUmbracoSettings);
            configs.Add <IGlobalSettings>(() => globalSettings);

            var publishedModelFactory = new NoopPublishedModelFactory();

            Mock.Get(factory).Setup(x => x.GetInstance(typeof(IPublishedModelFactory))).Returns(publishedModelFactory);

            // create a content node kit
            var kit = new ContentNodeKit
            {
                ContentTypeId = 2,
                Node          = new ContentNode(1, Guid.NewGuid(), 0, "-1,1", 0, -1, DateTime.Now, 0),
                DraftData     = new ContentData
                {
                    Name        = "It Works2!",
                    Published   = false,
                    TemplateId  = 0,
                    VersionId   = 2,
                    VersionDate = DateTime.Now,
                    WriterId    = 0,
                    Properties  = new Dictionary <string, PropertyData[]> {
                        { "prop", new[]
                          {
                              new PropertyData {
                                  Culture = "", Segment = "", Value = "val2"
                              },
                              new PropertyData {
                                  Culture = "fr-FR", Segment = "", Value = "val-fr2"
                              },
                              new PropertyData {
                                  Culture = "en-UK", Segment = "", Value = "val-uk2"
                              },
                              new PropertyData {
                                  Culture = "dk-DA", Segment = "", Value = "val-da2"
                              },
                              new PropertyData {
                                  Culture = "de-DE", Segment = "", Value = "val-de2"
                              }
                          } }
                    },
                    CultureInfos = new Dictionary <string, CultureVariation>
                    {
                        // draft data = everything, and IsDraft indicates what's edited
                        { "fr-FR", new CultureVariation {
                              Name = "name-fr2", IsDraft = true, Date = new DateTime(2018, 01, 03, 01, 00, 00)
                          } },
                        { "en-UK", new CultureVariation {
                              Name = "name-uk2", IsDraft = true, Date = new DateTime(2018, 01, 04, 01, 00, 00)
                          } },
                        { "dk-DA", new CultureVariation {
                              Name = "name-da2", IsDraft = true, Date = new DateTime(2018, 01, 05, 01, 00, 00)
                          } },
                        { "de-DE", new CultureVariation {
                              Name = "name-de1", IsDraft = false, Date = new DateTime(2018, 01, 02, 01, 00, 00)
                          } }
                    }
                },
                PublishedData = new ContentData
                {
                    Name        = "It Works1!",
                    Published   = true,
                    TemplateId  = 0,
                    VersionId   = 1,
                    VersionDate = DateTime.Now,
                    WriterId    = 0,
                    Properties  = new Dictionary <string, PropertyData[]> {
                        { "prop", new[]
                          {
                              new PropertyData {
                                  Culture = "", Segment = "", Value = "val1"
                              },
                              new PropertyData {
                                  Culture = "fr-FR", Segment = "", Value = "val-fr1"
                              },
                              new PropertyData {
                                  Culture = "en-UK", Segment = "", Value = "val-uk1"
                              }
                          } }
                    },
                    CultureInfos = new Dictionary <string, CultureVariation>
                    {
                        // published data = only what's actually published, and IsDraft has to be false
                        { "fr-FR", new CultureVariation {
                              Name = "name-fr1", IsDraft = false, Date = new DateTime(2018, 01, 01, 01, 00, 00)
                          } },
                        { "en-UK", new CultureVariation {
                              Name = "name-uk1", IsDraft = false, Date = new DateTime(2018, 01, 02, 01, 00, 00)
                          } },
                        { "de-DE", new CultureVariation {
                              Name = "name-de1", IsDraft = false, Date = new DateTime(2018, 01, 02, 01, 00, 00)
                          } }
                    }
                }
            };

            // create a data source for NuCache
            var dataSource = new TestDataSource(kit);

            var runtime = Mock.Of <IRuntimeState>();

            Mock.Get(runtime).Setup(x => x.Level).Returns(RuntimeLevel.Run);

            // create data types, property types and content types
            var dataType = new DataType(new VoidEditor("Editor", Mock.Of <ILogger>()))
            {
                Id = 3
            };

            var dataTypes = new[]
            {
                dataType
            };

            _propertyType = new PropertyType("Umbraco.Void.Editor", ValueStorageType.Nvarchar)
            {
                Alias = "prop", DataTypeId = 3, Variations = ContentVariation.Culture
            };
            _contentType = new ContentType(-1)
            {
                Id = 2, Alias = "alias-ct", Variations = ContentVariation.Culture
            };
            _contentType.AddPropertyType(_propertyType);

            var contentTypes = new[]
            {
                _contentType
            };

            var contentTypeService = new Mock <IContentTypeService>();

            contentTypeService.Setup(x => x.GetAll()).Returns(contentTypes);
            contentTypeService.Setup(x => x.GetAll(It.IsAny <int[]>())).Returns(contentTypes);

            var mediaTypeService = new Mock <IMediaTypeService>();

            mediaTypeService.Setup(x => x.GetAll()).Returns(Enumerable.Empty <IMediaType>());
            mediaTypeService.Setup(x => x.GetAll(It.IsAny <int[]>())).Returns(Enumerable.Empty <IMediaType>());

            var contentTypeServiceBaseFactory = new Mock <IContentTypeBaseServiceProvider>();

            contentTypeServiceBaseFactory.Setup(x => x.For(It.IsAny <IContentBase>())).Returns(contentTypeService.Object);

            var dataTypeService = Mock.Of <IDataTypeService>();

            Mock.Get(dataTypeService).Setup(x => x.GetAll()).Returns(dataTypes);

            // create a service context
            var serviceContext = ServiceContext.CreatePartial(
                dataTypeService: dataTypeService,
                memberTypeService: Mock.Of <IMemberTypeService>(),
                memberService: Mock.Of <IMemberService>(),
                contentTypeService: contentTypeService.Object,
                mediaTypeService: mediaTypeService.Object,
                localizationService: Mock.Of <ILocalizationService>(),
                domainService: Mock.Of <IDomainService>()
                );

            // create a scope provider
            var scopeProvider = Mock.Of <IScopeProvider>();

            Mock.Get(scopeProvider)
            .Setup(x => x.CreateScope(
                       It.IsAny <IsolationLevel>(),
                       It.IsAny <RepositoryCacheMode>(),
                       It.IsAny <IEventDispatcher>(),
                       It.IsAny <bool?>(),
                       It.IsAny <bool>(),
                       It.IsAny <bool>()))
            .Returns(Mock.Of <IScope>);

            // create a published content type factory
            var contentTypeFactory = new PublishedContentTypeFactory(
                Mock.Of <IPublishedModelFactory>(),
                new PropertyValueConverterCollection(Array.Empty <IPropertyValueConverter>()),
                dataTypeService);

            // create a variation accessor
            _variationAccesor = new TestVariationContextAccessor();

            // at last, create the complete NuCache snapshot service!
            var options = new PublishedSnapshotServiceOptions {
                IgnoreLocalDb = true
            };

            _snapshotService = new PublishedSnapshotService(options,
                                                            null,
                                                            runtime,
                                                            serviceContext,
                                                            contentTypeFactory,
                                                            null,
                                                            new TestPublishedSnapshotAccessor(),
                                                            _variationAccesor,
                                                            Mock.Of <IProfilingLogger>(),
                                                            scopeProvider,
                                                            Mock.Of <IDocumentRepository>(),
                                                            Mock.Of <IMediaRepository>(),
                                                            Mock.Of <IMemberRepository>(),
                                                            new TestDefaultCultureAccessor(),
                                                            dataSource,
                                                            globalSettings,
                                                            Mock.Of <IEntityXmlSerializer>(),
                                                            Mock.Of <IPublishedModelFactory>(),
                                                            new UrlSegmentProviderCollection(new[] { new DefaultUrlSegmentProvider() }));

            // invariant is the current default
            _variationAccesor.VariationContext = new VariationContext();

            Mock.Get(factory).Setup(x => x.GetInstance(typeof(IVariationContextAccessor))).Returns(_variationAccesor);
        }