public void Invariant_Child_Content_Published_No_Domains()
{
var contentType = MockedContentTypes.CreateBasicContentType();
var parent = MockedContent.CreateBasicContent(contentType);
parent.Id = 1046; // FIXME: we are using this ID only because it's built into the test XML published cache
parent.Name = "home";
parent.Path = "-1,1046";
parent.Published = true;
var child = MockedContent.CreateBasicContent(contentType);
child.Name = "sub1";
child.Id = 1173; // FIXME: we are using this ID only because it's built into the test XML published cache
child.Path = "-1,1046,1173";
child.Published = true;
var umbracoSettings = Current.Configs.Settings();
var umbContext = GetUmbracoContext("http://localhost:8000",
urlProviders: new[] { new DefaultUrlProvider(umbracoSettings.RequestHandler, Logger, TestObjects.GetGlobalSettings(), new SiteDomainHelper()) });
var publishedRouter = CreatePublishedRouter(Factory,
contentFinders: new ContentFinderCollection(new[] { new ContentFinderByUrl(Logger) }));
var urls = child.GetContentUrls(publishedRouter,
umbContext,
GetLangService("en-US", "fr-FR"), GetTextService(), ServiceContext.ContentService,
Logger).ToList();
Assert.AreEqual(1, urls.Count);
Assert.AreEqual("/home/sub1/", urls[0].Text);
Assert.AreEqual("en-US", urls[0].Culture);
Assert.IsTrue(urls[0].IsUrl);
}
public async Task Content_Not_Published()
{
var contentType = MockedContentTypes.CreateBasicContentType();
var content = MockedContent.CreateBasicContent(contentType);
content.Id = 1046; // FIXME: we are using this ID only because it's built into the test XML published cache
content.Path = "-1,1046";
var umbContext = GetUmbracoContext("http://localhost:8000");
var publishedRouter = CreatePublishedRouter(
GetUmbracoContextAccessor(umbContext),
Factory,
contentFinders: new ContentFinderCollection(new[] { new ContentFinderByUrl(LoggerFactory.CreateLogger <ContentFinderByUrl>(), GetUmbracoContextAccessor(umbContext)) }));
var urls = (await content.GetContentUrlsAsync(publishedRouter,
umbContext,
GetLangService("en-US", "fr-FR"), GetTextService(), ServiceContext.ContentService,
VariationContextAccessor,
LoggerFactory.CreateLogger <IContent>(),
UriUtility,
PublishedUrlProvider)).ToList();
Assert.AreEqual(1, urls.Count);
Assert.AreEqual("content/itemNotPublished", urls[0].Text);
Assert.IsFalse(urls[0].IsUrl);
}
public void LastIn()
{
DoSaveForContent += OnDoThingFail;
var now = DateTime.Now;
var contentType = MockedContentTypes.CreateBasicContentType();
var content1 = MockedContent.CreateBasicContent(contentType);
content1.Id = 123;
content1.UpdateDate = now.AddMinutes(1);
var content2 = MockedContent.CreateBasicContent(contentType);
content2.Id = 123;
content2.UpdateDate = now.AddMinutes(2);
var content3 = MockedContent.CreateBasicContent(contentType);
content3.Id = 123;
content3.UpdateDate = now.AddMinutes(3);
var scopeProvider = _testObjects.GetScopeProvider(Mock.Of <ILogger>());
using (var scope = scopeProvider.CreateScope(eventDispatcher: new PassiveEventDispatcher()))
{
scope.Events.Dispatch(DoSaveForContent, this, new SaveEventArgs <IContent>(content1));
scope.Events.Dispatch(DoSaveForContent, this, new SaveEventArgs <IContent>(content2));
scope.Events.Dispatch(DoSaveForContent, this, new SaveEventArgs <IContent>(content3));
// events have been queued
var events = scope.Events.GetEvents(EventDefinitionFilter.LastIn).ToArray();
Assert.AreEqual(1, events.Length);
Assert.AreEqual(content3, ((SaveEventArgs <IContent>)events[0].Args).SavedEntities.First());
Assert.IsTrue(object.ReferenceEquals(content3, ((SaveEventArgs <IContent>)events[0].Args).SavedEntities.First()));
Assert.AreEqual(content3.UpdateDate, ((SaveEventArgs <IContent>)events[0].Args).SavedEntities.First().UpdateDate);
}
}
/// <summary>
/// Creates a bunch of content/media items return relation objects for them (unsaved)
/// </summary>
/// <param name="count"></param>
/// <returns></returns>
private IEnumerable <IRelation> CreateRelations(int count)
{
var rs = ServiceContext.RelationService;
var rtName = Guid.NewGuid().ToString();
var rt = new RelationType(rtName, rtName, false, null, null);
rs.Save(rt);
var ct = MockedContentTypes.CreateBasicContentType();
ServiceContext.ContentTypeService.Save(ct);
var mt = MockedContentTypes.CreateImageMediaType("img");
ServiceContext.MediaTypeService.Save(mt);
return(Enumerable.Range(1, count).Select(index =>
{
var c1 = MockedContent.CreateBasicContent(ct);
var c2 = MockedMedia.CreateMediaImage(mt, -1);
ServiceContext.ContentService.Save(c1);
ServiceContext.MediaService.Save(c2);
return new Relation(c1.Id, c2.Id, rt);
}).ToList());
}
private IRelation CreateAndSaveRelation(string name, string alias)
{
var rs = ServiceContext.RelationService;
var rt = new RelationType(name, alias, false, null, null);
rs.Save(rt);
var ct = MockedContentTypes.CreateBasicContentType();
ServiceContext.ContentTypeService.Save(ct);
var mt = MockedContentTypes.CreateImageMediaType("img");
ServiceContext.MediaTypeService.Save(mt);
var c1 = MockedContent.CreateBasicContent(ct);
var c2 = MockedMedia.CreateMediaImage(mt, -1);
ServiceContext.ContentService.Save(c1);
ServiceContext.MediaService.Save(c2);
var r = new Relation(c1.Id, c2.Id, rt);
ServiceContext.RelationService.Save(r);
return(r);
}
private void CreateTestDataForPagingTests(out List <IContent> createdContent, out List <IMember> createdMembers, out List <IMedia> createdMedia)
{
//Create content
createdContent = new List <IContent>();
var contentType = MockedContentTypes.CreateBasicContentType("blah");
ServiceContext.ContentTypeService.Save(contentType);
for (int i = 0; i < 10; i++)
{
var c1 = MockedContent.CreateBasicContent(contentType);
ServiceContext.ContentService.Save(c1);
createdContent.Add(c1);
}
//Create media
createdMedia = new List <IMedia>();
var imageType = MockedContentTypes.CreateImageMediaType("myImage");
ServiceContext.MediaTypeService.Save(imageType);
for (int i = 0; i < 10; i++)
{
var c1 = MockedMedia.CreateMediaImage(imageType, -1);
ServiceContext.MediaService.Save(c1);
createdMedia.Add(c1);
}
// Create members
var memberType = MockedContentTypes.CreateSimpleMemberType("simple");
ServiceContext.MemberTypeService.Save(memberType);
createdMembers = MockedMember.CreateSimpleMember(memberType, 10).ToList();
ServiceContext.MemberService.Save(createdMembers);
var relType = ServiceContext.RelationService.GetRelationTypeByAlias(Constants.Conventions.RelationTypes.RelatedMediaAlias);
// Relate content to media
foreach (var content in createdContent)
{
foreach (var media in createdMedia)
{
ServiceContext.RelationService.Relate(content.Id, media.Id, relType);
}
}
// Relate members to media
foreach (var member in createdMembers)
{
foreach (var media in createdMedia)
{
ServiceContext.RelationService.Relate(member.Id, media.Id, relType);
}
}
}
public void Get_Paged_Relations_By_Relation_Type()
{
//Create content
var createdContent = new List <IContent>();
var contentType = MockedContentTypes.CreateBasicContentType("blah");
ServiceContext.ContentTypeService.Save(contentType);
for (int i = 0; i < 10; i++)
{
var c1 = MockedContent.CreateBasicContent(contentType);
ServiceContext.ContentService.Save(c1);
createdContent.Add(c1);
}
//Create media
var createdMedia = new List <IMedia>();
var imageType = MockedContentTypes.CreateImageMediaType("myImage");
ServiceContext.MediaTypeService.Save(imageType);
for (int i = 0; i < 10; i++)
{
var c1 = MockedMedia.CreateMediaImage(imageType, -1);
ServiceContext.MediaService.Save(c1);
createdMedia.Add(c1);
}
var relType = ServiceContext.RelationService.GetRelationTypeByAlias(Constants.Conventions.RelationTypes.RelatedMediaAlias);
// Relate content to media
foreach (var content in createdContent)
{
foreach (var media in createdMedia)
{
ServiceContext.RelationService.Relate(content.Id, media.Id, relType);
}
}
var paged = ServiceContext.RelationService.GetPagedByRelationTypeId(relType.Id, 0, 51, out var totalRecs).ToList();
Assert.AreEqual(100, totalRecs);
Assert.AreEqual(51, paged.Count);
//next page
paged.AddRange(ServiceContext.RelationService.GetPagedByRelationTypeId(relType.Id, 1, 51, out totalRecs));
Assert.AreEqual(100, totalRecs);
Assert.AreEqual(100, paged.Count);
Assert.IsTrue(createdContent.Select(x => x.Id).ContainsAll(paged.Select(x => x.ParentId)));
Assert.IsTrue(createdMedia.Select(x => x.Id).ContainsAll(paged.Select(x => x.ChildId)));
}
public void SupersededEvents()
{
DoSaveForContent += OnDoThingFail;
DoDeleteForContent += OnDoThingFail;
DoForTestArgs += OnDoThingFail;
DoForTestArgs2 += OnDoThingFail;
var contentType = MockedContentTypes.CreateBasicContentType();
var content1 = MockedContent.CreateBasicContent(contentType);
content1.Id = 123;
var content2 = MockedContent.CreateBasicContent(contentType);
content2.Id = 456;
var content3 = MockedContent.CreateBasicContent(contentType);
content3.Id = 789;
var scopeProvider = _testObjects.GetScopeProvider(Mock.Of <ILogger>());
using (var scope = scopeProvider.CreateScope(eventDispatcher: new PassiveEventDispatcher()))
{
//content1 will be filtered from the args
scope.Events.Dispatch(DoSaveForContent, this, new SaveEventArgs <IContent>(new[] { content1, content3 }));
scope.Events.Dispatch(DoDeleteForContent, this, new DeleteEventArgs <IContent>(content1), "DoDeleteForContent");
scope.Events.Dispatch(DoSaveForContent, this, new SaveEventArgs <IContent>(content2));
//this entire event will be filtered
scope.Events.Dispatch(DoForTestArgs, this, new TestEventArgs(content1));
scope.Events.Dispatch(DoForTestArgs2, this, new TestEventArgs2(content1));
// events have been queued
var events = scope.Events.GetEvents(EventDefinitionFilter.All).ToArray();
Assert.AreEqual(4, events.Length);
Assert.AreEqual(typeof(SaveEventArgs <IContent>), events[0].Args.GetType());
Assert.AreEqual(1, ((SaveEventArgs <IContent>)events[0].Args).SavedEntities.Count());
Assert.AreEqual(content3.Id, ((SaveEventArgs <IContent>)events[0].Args).SavedEntities.First().Id);
Assert.AreEqual(typeof(DeleteEventArgs <IContent>), events[1].Args.GetType());
Assert.AreEqual(content1.Id, ((DeleteEventArgs <IContent>)events[1].Args).DeletedEntities.First().Id);
Assert.AreEqual(typeof(SaveEventArgs <IContent>), events[2].Args.GetType());
Assert.AreEqual(content2.Id, ((SaveEventArgs <IContent>)events[2].Args).SavedEntities.First().Id);
Assert.AreEqual(typeof(TestEventArgs2), events[3].Args.GetType());
}
}
public async Task Invariant_Child_Content_Published_No_Domains()
{
var contentType = MockedContentTypes.CreateBasicContentType();
var parent = MockedContent.CreateBasicContent(contentType);
parent.Id = 1046; // FIXME: we are using this ID only because it's built into the test XML published cache
parent.Name = "home";
parent.Path = "-1,1046";
parent.Published = true;
var child = MockedContent.CreateBasicContent(contentType);
child.Name = "sub1";
child.Id = 1173; // FIXME: we are using this ID only because it's built into the test XML published cache
child.Path = "-1,1046,1173";
child.Published = true;
var umbContext = GetUmbracoContext("http://localhost:8000");
var umbracoContextAccessor = GetUmbracoContextAccessor(umbContext);
var urlProvider = new DefaultUrlProvider(
Microsoft.Extensions.Options.Options.Create(_requestHandlerSettings),
LoggerFactory.CreateLogger <DefaultUrlProvider>(),
new SiteDomainMapper(), umbracoContextAccessor, UriUtility);
var publishedUrlProvider = new UrlProvider(
umbracoContextAccessor,
Microsoft.Extensions.Options.Options.Create(_webRoutingSettings),
new UrlProviderCollection(new [] { urlProvider }),
new MediaUrlProviderCollection(Enumerable.Empty <IMediaUrlProvider>()),
Mock.Of <IVariationContextAccessor>()
);
var publishedRouter = CreatePublishedRouter(
umbracoContextAccessor,
Factory,
contentFinders: new ContentFinderCollection(new[] { new ContentFinderByUrl(LoggerFactory.CreateLogger <ContentFinderByUrl>(), umbracoContextAccessor) }));
var urls = (await child.GetContentUrlsAsync(publishedRouter,
umbContext,
GetLangService("en-US", "fr-FR"), GetTextService(), ServiceContext.ContentService,
VariationContextAccessor,
LoggerFactory.CreateLogger <IContent>(),
UriUtility,
publishedUrlProvider
)).ToList();
Assert.AreEqual(1, urls.Count);
Assert.AreEqual("/home/sub1/", urls[0].Text);
Assert.AreEqual("en-US", urls[0].Culture);
Assert.IsTrue(urls[0].IsUrl);
}
public void PropertyDataAssignedCorrectly()
{
var provider = TestObjects.GetScopeProvider(Logger);
using (var scope = provider.CreateScope())
{
var repository = CreateRepository((IScopeAccessor)provider, out var contentTypeRepository, out DataTypeRepository _);
var emptyContentType = MockedContentTypes.CreateBasicContentType();
var hasPropertiesContentType = MockedContentTypes.CreateSimpleContentType("umbTextpage1", "Textpage");
contentTypeRepository.Save(emptyContentType);
contentTypeRepository.Save(hasPropertiesContentType);
ServiceContext.FileService.SaveTemplate(hasPropertiesContentType.DefaultTemplate); // else, FK violation on contentType!
var content1 = MockedContent.CreateSimpleContent(hasPropertiesContentType);
var content2 = MockedContent.CreateBasicContent(emptyContentType);
var content3 = MockedContent.CreateSimpleContent(hasPropertiesContentType);
repository.Save(content1);
repository.Save(content2);
repository.Save(content3);
// this will cause the GetPropertyCollection to execute and we need to ensure that
// all of the properties and property types are all correct
var result = repository.GetMany(content1.Id, content2.Id, content3.Id).ToArray();
var n1 = result[0];
var n2 = result[1];
var n3 = result[2];
Assert.AreEqual(content1.Id, n1.Id);
Assert.AreEqual(content2.Id, n2.Id);
Assert.AreEqual(content3.Id, n3.Id);
// compare everything including properties and their values
// this ensures that they have been properly retrieved
TestHelper.AssertPropertyValuesAreEqual(content1, n1);
TestHelper.AssertPropertyValuesAreEqual(content2, n2);
TestHelper.AssertPropertyValuesAreEqual(content3, n3);
}
}
public void LatestEntities()
{
DoSaveForContent += OnDoThingFail;
var now = DateTime.Now;
var contentType = MockedContentTypes.CreateBasicContentType();
var content1 = MockedContent.CreateBasicContent(contentType);
content1.Id = 123;
content1.UpdateDate = now.AddMinutes(1);
var content2 = MockedContent.CreateBasicContent(contentType);
content2.Id = 123;
content2.UpdateDate = now.AddMinutes(2);
var content3 = MockedContent.CreateBasicContent(contentType);
content3.Id = 123;
content3.UpdateDate = now.AddMinutes(3);
var scopeProvider = new ScopeProvider(Mock.Of <IDatabaseFactory2>());
using (var scope = scopeProvider.CreateScope(eventDispatcher: new PassiveEventDispatcher()))
{
scope.Events.Dispatch(DoSaveForContent, this, new SaveEventArgs <IContent>(content1));
scope.Events.Dispatch(DoSaveForContent, this, new SaveEventArgs <IContent>(content2));
scope.Events.Dispatch(DoSaveForContent, this, new SaveEventArgs <IContent>(content3));
// events have been queued
var events = scope.Events.GetEvents(EventDefinitionFilter.All).ToArray();
Assert.AreEqual(3, events.Length);
foreach (var t in events)
{
var args = (SaveEventArgs <IContent>)t.Args;
foreach (var entity in args.SavedEntities)
{
Assert.AreEqual(content3, entity);
Assert.IsTrue(object.ReferenceEquals(content3, entity));
}
}
}
}
public void Content_Not_Published()
{
var contentType = MockedContentTypes.CreateBasicContentType();
var content = MockedContent.CreateBasicContent(contentType);
content.Id = 1046; // FIXME: we are using this ID only because it's built into the test XML published cache
content.Path = "-1,1046";
var umbContext = GetUmbracoContext("http://localhost:8000");
var publishedRouter = CreatePublishedRouter(Factory,
contentFinders: new ContentFinderCollection(new[] { new ContentFinderByUrl(Logger) }));
var urls = content.GetContentUrls(publishedRouter,
umbContext,
GetLangService("en-US", "fr-FR"), GetTextService(), ServiceContext.ContentService,
Logger).ToList();
Assert.AreEqual(1, urls.Count);
Assert.AreEqual("content/itemNotPublished", urls[0].Text);
Assert.IsFalse(urls[0].IsUrl);
}
public void Can_Perform_Update_On_UserRepository()
{
var ct = MockedContentTypes.CreateBasicContentType("test");
var mt = MockedContentTypes.CreateSimpleMediaType("testmedia", "TestMedia");
// Arrange
var provider = TestObjects.GetScopeProvider(Logger);
using (var scope = provider.CreateScope())
{
var userRepository = CreateRepository(provider);
var contentRepository = CreateContentRepository(provider, out var contentTypeRepo);
var mediaRepository = CreateMediaRepository(provider, out var mediaTypeRepo);
var userGroupRepository = CreateUserGroupRepository(provider);
contentTypeRepo.Save(ct);
mediaTypeRepo.Save(mt);
var content = MockedContent.CreateBasicContent(ct);
var media = MockedMedia.CreateSimpleMedia(mt, "asdf", -1);
contentRepository.Save(content);
mediaRepository.Save(media);
var user = CreateAndCommitUserWithGroup(userRepository, userGroupRepository);
// Act
var resolved = (User)userRepository.Get(user.Id);
resolved.Name = "New Name";
//the db column is not used, default permissions are taken from the user type's permissions, this is a getter only
//resolved.DefaultPermissions = "ZYX";
resolved.Language = "fr";
resolved.IsApproved = false;
resolved.RawPasswordValue = "new";
resolved.IsLockedOut = true;
resolved.StartContentIds = new[] { content.Id };
resolved.StartMediaIds = new[] { media.Id };
resolved.Email = "*****@*****.**";
resolved.Username = "******";
userRepository.Save(resolved);
var updatedItem = (User)userRepository.Get(user.Id);
// Assert
Assert.That(updatedItem.Id, Is.EqualTo(resolved.Id));
Assert.That(updatedItem.Name, Is.EqualTo(resolved.Name));
Assert.That(updatedItem.Language, Is.EqualTo(resolved.Language));
Assert.That(updatedItem.IsApproved, Is.EqualTo(resolved.IsApproved));
Assert.That(updatedItem.RawPasswordValue, Is.EqualTo(resolved.RawPasswordValue));
Assert.That(updatedItem.IsLockedOut, Is.EqualTo(resolved.IsLockedOut));
Assert.IsTrue(updatedItem.StartContentIds.UnsortedSequenceEqual(resolved.StartContentIds));
Assert.IsTrue(updatedItem.StartMediaIds.UnsortedSequenceEqual(resolved.StartMediaIds));
Assert.That(updatedItem.Email, Is.EqualTo(resolved.Email));
Assert.That(updatedItem.Username, Is.EqualTo(resolved.Username));
Assert.That(updatedItem.AllowedSections.Count(), Is.EqualTo(resolved.AllowedSections.Count()));
foreach (var allowedSection in resolved.AllowedSections)
{
Assert.IsTrue(updatedItem.AllowedSections.Contains(allowedSection));
}
}
}
public void Index_Property_Data_With_Value_Indexer()
{
var contentValueSetBuilder = IndexInitializer.GetContentValueSetBuilder(Factory.GetInstance <PropertyEditorCollection>(), false);
using (var luceneDir = new RandomIdRamDirectory())
using (var indexer = IndexInitializer.GetUmbracoIndexer(ProfilingLogger, luceneDir,
validator: new ContentValueSetValidator(false)))
using (indexer.ProcessNonAsync())
{
indexer.CreateIndex();
var contentType = MockedContentTypes.CreateBasicContentType();
contentType.AddPropertyType(new PropertyType("test", ValueStorageType.Ntext)
{
Alias = "grid",
Name = "Grid",
PropertyEditorAlias = Core.Constants.PropertyEditors.Aliases.Grid
});
var content = MockedContent.CreateBasicContent(contentType);
content.Id = 555;
content.Path = "-1,555";
var gridVal = new GridValue
{
Name = "n1",
Sections = new List <GridValue.GridSection>
{
new GridValue.GridSection
{
Grid = "g1",
Rows = new List <GridValue.GridRow>
{
new GridValue.GridRow
{
Id = Guid.NewGuid(),
Name = "row1",
Areas = new List <GridValue.GridArea>
{
new GridValue.GridArea
{
Grid = "g2",
Controls = new List <GridValue.GridControl>
{
new GridValue.GridControl
{
Editor = new GridValue.GridEditor
{
Alias = "editor1",
View = "view1"
},
Value = "value1"
},
new GridValue.GridControl
{
Editor = new GridValue.GridEditor
{
Alias = "editor1",
View = "view1"
},
Value = "value2"
}
}
}
}
}
}
}
}
};
var json = JsonConvert.SerializeObject(gridVal);
content.Properties["grid"].SetValue(json);
var valueSet = contentValueSetBuilder.GetValueSets(content);
indexer.IndexItems(valueSet);
var searcher = indexer.GetSearcher();
var results = searcher.CreateQuery().Id(555).Execute();
Assert.AreEqual(1, results.TotalItemCount);
var result = results.First();
Assert.IsTrue(result.Values.ContainsKey("grid.row1"));
Assert.AreEqual("value1", result.AllValues["grid.row1"][0]);
Assert.AreEqual("value2", result.AllValues["grid.row1"][1]);
Assert.IsTrue(result.Values.ContainsKey("grid"));
Assert.AreEqual("value1 value2 ", result["grid"]);
Assert.IsTrue(result.Values.ContainsKey($"{UmbracoExamineIndex.RawFieldPrefix}grid"));
Assert.AreEqual(json, result[$"{UmbracoExamineIndex.RawFieldPrefix}grid"]);
}
}
public void Can_Perform_Update_On_UserRepository()
{
var ct = MockedContentTypes.CreateBasicContentType("test");
var content = MockedContent.CreateBasicContent(ct);
var mt = MockedContentTypes.CreateSimpleMediaType("testmedia", "TestMedia");
var media = MockedMedia.CreateSimpleMedia(mt, "asdf", -1);
// Arrange
var provider = new PetaPocoUnitOfWorkProvider(Logger);
var unitOfWork = provider.GetUnitOfWork();
IContentTypeRepository contentTypeRepo;
IMediaTypeRepository mediaTypeRepo;
using (var contentRepository = CreateContentRepository(unitOfWork, out contentTypeRepo))
using (var mediaRepository = CreateMediaRepository(unitOfWork, out mediaTypeRepo))
using (contentTypeRepo)
using (mediaTypeRepo)
using (var userRepository = CreateRepository(unitOfWork))
using (var userGroupRepository = CreateUserGroupRepository(unitOfWork))
{
contentTypeRepo.AddOrUpdate(ct);
mediaTypeRepo.AddOrUpdate(mt);
unitOfWork.Commit();
contentRepository.AddOrUpdate(content);
mediaRepository.AddOrUpdate(media);
unitOfWork.Commit();
var user = CreateAndCommitUserWithGroup(userRepository, userGroupRepository, unitOfWork);
// Act
var resolved = (User)userRepository.Get((int)user.Id);
resolved.Name = "New Name";
resolved.Language = "fr";
resolved.IsApproved = false;
resolved.RawPasswordValue = "new";
resolved.IsLockedOut = true;
resolved.StartContentIds = new[] { content.Id };
resolved.StartMediaIds = new[] { media.Id };
resolved.Email = "*****@*****.**";
resolved.Username = "******";
userRepository.AddOrUpdate(resolved);
unitOfWork.Commit();
var updatedItem = (User)userRepository.Get((int)user.Id);
// Assert
Assert.That(updatedItem.Id, Is.EqualTo(resolved.Id));
Assert.That(updatedItem.Name, Is.EqualTo(resolved.Name));
Assert.That(updatedItem.Language, Is.EqualTo(resolved.Language));
Assert.That(updatedItem.IsApproved, Is.EqualTo(resolved.IsApproved));
Assert.That(updatedItem.RawPasswordValue, Is.EqualTo(resolved.RawPasswordValue));
Assert.That(updatedItem.IsLockedOut, Is.EqualTo(resolved.IsLockedOut));
Assert.IsTrue(updatedItem.StartContentIds.UnsortedSequenceEqual(resolved.StartContentIds));
Assert.IsTrue(updatedItem.StartMediaIds.UnsortedSequenceEqual(resolved.StartMediaIds));
Assert.That(updatedItem.Email, Is.EqualTo(resolved.Email));
Assert.That(updatedItem.Username, Is.EqualTo(resolved.Username));
Assert.That(updatedItem.AllowedSections.Count(), Is.EqualTo(2));
Assert.IsTrue(updatedItem.AllowedSections.Contains("content"));
Assert.IsTrue(updatedItem.AllowedSections.Contains("media"));
}
}
public void Get_Paged_Mixed_Entities_By_Ids()
{
//Create content
var createdContent = new List <IContent>();
var contentType = MockedContentTypes.CreateBasicContentType("blah");
ServiceContext.ContentTypeService.Save(contentType);
for (int i = 0; i < 10; i++)
{
var c1 = MockedContent.CreateBasicContent(contentType);
ServiceContext.ContentService.Save(c1);
createdContent.Add(c1);
}
//Create media
var createdMedia = new List <IMedia>();
var imageType = MockedContentTypes.CreateImageMediaType("myImage");
ServiceContext.MediaTypeService.Save(imageType);
for (int i = 0; i < 10; i++)
{
var c1 = MockedMedia.CreateMediaImage(imageType, -1);
ServiceContext.MediaService.Save(c1);
createdMedia.Add(c1);
}
// Create members
var memberType = MockedContentTypes.CreateSimpleMemberType("simple");
ServiceContext.MemberTypeService.Save(memberType);
var createdMembers = MockedMember.CreateSimpleMember(memberType, 10).ToList();
ServiceContext.MemberService.Save(createdMembers);
var provider = TestObjects.GetScopeProvider(Logger);
using (var scope = provider.CreateScope())
{
var repo = CreateRepository((IScopeAccessor)provider);
var ids = createdContent.Select(x => x.Id).Concat(createdMedia.Select(x => x.Id)).Concat(createdMembers.Select(x => x.Id));
var objectTypes = new[] { Constants.ObjectTypes.Document, Constants.ObjectTypes.Media, Constants.ObjectTypes.Member };
var query = SqlContext.Query <IUmbracoEntity>()
.WhereIn(e => e.Id, ids);
var entities = repo.GetPagedResultsByQuery(query, objectTypes, 0, 20, out var totalRecords, null, null).ToList();
Assert.AreEqual(20, entities.Count);
Assert.AreEqual(30, totalRecords);
//add the next page
entities.AddRange(repo.GetPagedResultsByQuery(query, objectTypes, 1, 20, out totalRecords, null, null));
Assert.AreEqual(30, entities.Count);
Assert.AreEqual(30, totalRecords);
var contentEntities = entities.OfType <IDocumentEntitySlim>().ToList();
var mediaEntities = entities.OfType <IMediaEntitySlim>().ToList();
var memberEntities = entities.OfType <IMemberEntitySlim>().ToList();
Assert.AreEqual(10, contentEntities.Count);
Assert.AreEqual(10, mediaEntities.Count);
Assert.AreEqual(10, memberEntities.Count);
}
}
