public void Can_Perform_Update_On_ContentTypeRepository()
{
// Arrange
IScopeProvider provider = ScopeProvider;
using (IScope scope = provider.CreateScope())
{
ContentTypeRepository repository = ContentTypeRepository;
// Act
IContentType contentType = repository.Get(_textpageContentType.Id);
contentType.Thumbnail = "Doc2.png";
contentType.PropertyGroups["content"].PropertyTypes.Add(new PropertyType(ShortStringHelper, "test", ValueStorageType.Ntext, "subtitle")
{
Name = "Subtitle",
Description = "Optional Subtitle",
Mandatory = false,
SortOrder = 1,
DataTypeId = -88,
LabelOnTop = true
});
repository.Save(contentType);
bool dirty = contentType.IsDirty();
// Assert
Assert.That(contentType.HasIdentity, Is.True);
Assert.That(dirty, Is.False);
Assert.That(contentType.Thumbnail, Is.EqualTo("Doc2.png"));
Assert.That(contentType.PropertyTypes.Any(x => x.Alias == "subtitle"), Is.True);
Assert.That(contentType.PropertyTypes.Single(x => x.Alias == "subtitle").LabelOnTop, Is.True);
}
}
public void QueryMedia_ContentTypeAliasFilter()
{
// we could support this, but it would require an extra join on the query,
// and we don't absolutely need it now, so leaving it out for now
// Arrange
IMediaType folderMediaType = MediaTypeService.Get(1031);
IScopeProvider provider = ScopeProvider;
using (IScope scope = provider.CreateScope())
{
MediaRepository repository = CreateRepository(provider, out MediaTypeRepository mediaTypeRepository);
// Act
for (int i = 0; i < 10; i++)
{
Media folder = MediaBuilder.CreateMediaFolder(folderMediaType, -1);
repository.Save(folder);
}
string[] types = new[] { "Folder" };
IQuery <IMedia> query = provider.CreateQuery <IMedia>().Where(x => types.Contains(x.ContentType.Alias));
IEnumerable <IMedia> result = repository.Get(query);
// Assert
Assert.That(result.Count(), Is.GreaterThanOrEqualTo(11));
}
}
public void Delete_By_User()
{
IScopeProvider provider = ScopeProvider;
using (IScope scope = provider.CreateScope())
{
var repo = new NotificationsRepository((IScopeAccessor)provider);
var userDto = new UserDto {
Email = "test", Login = "******", Password = "******", UserName = "******", UserLanguage = "en", CreateDate = DateTime.Now, UpdateDate = DateTime.Now
};
ScopeAccessor.AmbientScope.Database.Insert(userDto);
IUser userNew = Mock.Of <IUser>(e => e.Id == userDto.Id);
IUser userAdmin = Mock.Of <IUser>(e => e.Id == Constants.Security.SuperUserId);
for (int i = 0; i < 10; i++)
{
var node = new NodeDto {
CreateDate = DateTime.Now, Level = 1, NodeObjectType = Constants.ObjectTypes.ContentItem, ParentId = -1, Path = "-1," + i, SortOrder = 1, Text = "hello" + i, Trashed = false, UniqueId = Guid.NewGuid(), UserId = -1
};
object result = ScopeAccessor.AmbientScope.Database.Insert(node);
IEntity entity = Mock.Of <IEntity>(e => e.Id == node.NodeId);
Notification notification = repo.CreateNotification((i % 2 == 0) ? userAdmin : userNew, entity, i.ToString(CultureInfo.InvariantCulture));
}
int delCount = repo.DeleteNotifications(userAdmin);
Assert.AreEqual(5, delCount);
}
}
public void SaveMedia()
{
// Arrange
IScopeProvider provider = ScopeProvider;
using (IScope scope = provider.CreateScope())
{
MediaRepository repository = CreateRepository(provider, out MediaTypeRepository mediaTypeRepository);
IMediaType mediaType = mediaTypeRepository.Get(1032);
Media image = MediaBuilder.CreateMediaImage(mediaType, -1);
// Act
mediaTypeRepository.Save(mediaType);
repository.Save(image);
IMedia fetched = repository.Get(image.Id);
// Assert
Assert.That(mediaType.HasIdentity, Is.True);
Assert.That(image.HasIdentity, Is.True);
TestHelper.AssertPropertyValuesAreEqual(image, fetched);
}
}
public void GetMedia()
{
// Arrange
IScopeProvider provider = ScopeProvider;
using (IScope scope = provider.CreateScope())
{
MediaRepository repository = CreateRepository(provider, out MediaTypeRepository mediaTypeRepository);
// Act
IMedia media = repository.Get(_testImage.Id);
// Assert
Assert.That(media.Id, Is.EqualTo(_testImage.Id));
Assert.That(media.CreateDate, Is.GreaterThan(DateTime.MinValue));
Assert.That(media.UpdateDate, Is.GreaterThan(DateTime.MinValue));
Assert.That(media.ParentId, Is.Not.EqualTo(0));
Assert.That(media.Name, Is.EqualTo("Test Image"));
Assert.That(media.SortOrder, Is.EqualTo(0));
Assert.That(media.VersionId, Is.Not.EqualTo(0));
Assert.That(media.ContentTypeId, Is.EqualTo(1032));
Assert.That(media.Path, Is.Not.Empty);
Assert.That(media.Properties.Any(), Is.True);
}
}
public void ScopeContextEnlistAgain(bool complete)
{
ScopeProvider scopeProvider = ScopeProvider;
bool?completed = null;
bool?completed2 = null;
Assert.IsNull(scopeProvider.AmbientScope);
using (IScope scope = scopeProvider.CreateScope())
{
scopeProvider.Context.Enlist("name", c =>
{
completed = c;
// at that point the scope is gone, but the context is still there
IScopeContext ambientContext = scopeProvider.AmbientContext;
ambientContext.Enlist("another", c2 => completed2 = c2);
});
if (complete)
{
scope.Complete();
}
}
Assert.IsNull(scopeProvider.AmbientScope);
Assert.IsNull(scopeProvider.AmbientContext);
Assert.IsNotNull(completed);
Assert.AreEqual(complete, completed.Value);
Assert.AreEqual(complete, completed2.Value);
}
public void GivenChildThread_WhenParentDisposedBeforeChild_ParentScopeThrows()
{
ScopeProvider scopeProvider = ScopeProvider;
Assert.IsNull(ScopeProvider.AmbientScope);
IScope mainScope = scopeProvider.CreateScope();
var t = Task.Run(() =>
{
Console.WriteLine("Child Task start: " + scopeProvider.AmbientScope.InstanceId);
// This will push the child scope to the top of the Stack
IScope nested = scopeProvider.CreateScope();
Console.WriteLine("Child Task scope created: " + scopeProvider.AmbientScope.InstanceId);
Thread.Sleep(5000); // block for a bit to ensure the parent task is disposed first
Console.WriteLine("Child Task before dispose: " + scopeProvider.AmbientScope.InstanceId);
nested.Dispose();
Console.WriteLine("Child Task after dispose: " + scopeProvider.AmbientScope.InstanceId);
});
// provide some time for the child thread to start so the ambient context is copied in AsyncLocal
Thread.Sleep(2000);
// now dispose the main without waiting for the child thread to join
Console.WriteLine("Parent Task disposing: " + scopeProvider.AmbientScope.InstanceId);
// This will throw because at this stage a child scope has been created which means
// it is the Ambient (top) scope but here we're trying to dispose the non top scope.
Assert.Throws <InvalidOperationException>(() => mainScope.Dispose());
Task.WaitAll(t); // wait for the child to dispose
mainScope.Dispose(); // now it's ok
Console.WriteLine("Parent Task disposed: " + scopeProvider.AmbientScope?.InstanceId);
}
public void Cant_Create_Duplicate_Domain_Name()
{
int contentId = CreateTestData("en-AU", out ContentType ct);
IScopeProvider provider = ScopeProvider;
using (IScope scope = provider.CreateScope())
{
DomainRepository repo = CreateRepository(provider);
ILanguage lang = LanguageRepository.GetByIsoCode("en-AU");
IContent content = DocumentRepository.Get(contentId);
var domain1 = (IDomain) new UmbracoDomain("test.com")
{
RootContentId = content.Id, LanguageId = lang.Id
};
repo.Save(domain1);
var domain2 = (IDomain) new UmbracoDomain("test.com")
{
RootContentId = content.Id, LanguageId = lang.Id
};
Assert.Throws <DuplicateNameException>(() => repo.Save(domain2));
}
}
public void Can_Delete()
{
int contentId = CreateTestData("en-AU", out ContentType ct);
IScopeProvider provider = ScopeProvider;
using (IScope scope = provider.CreateScope())
{
DomainRepository repo = CreateRepository(provider);
ILanguage lang = LanguageRepository.GetByIsoCode("en-AU");
IContent content = DocumentRepository.Get(contentId);
var domain = (IDomain) new UmbracoDomain("test.com")
{
RootContentId = content.Id, LanguageId = lang.Id
};
repo.Save(domain);
repo.Delete(domain);
// re-get
domain = repo.Get(domain.Id);
Assert.IsNull(domain);
}
}
public void Can_Verify_AllowedChildContentTypes_On_ContentType()
{
// Arrange
IScopeProvider provider = ScopeProvider;
using (IScope scope = provider.CreateScope())
{
ContentTypeRepository repository = ContentTypeRepository;
ContentType subpageContentType = ContentTypeBuilder.CreateSimpleContentType("umbSubpage", "Subpage");
ContentType simpleSubpageContentType = ContentTypeBuilder.CreateSimpleContentType("umbSimpleSubpage", "Simple Subpage");
repository.Save(subpageContentType);
repository.Save(simpleSubpageContentType);
// Act
IContentType contentType = repository.Get(_simpleContentType.Id);
contentType.AllowedContentTypes = new List <ContentTypeSort>
{
new ContentTypeSort(new Lazy <int>(() => subpageContentType.Id), 0, subpageContentType.Alias),
new ContentTypeSort(new Lazy <int>(() => simpleSubpageContentType.Id), 1, simpleSubpageContentType.Alias)
};
repository.Save(contentType);
// Assert
IContentType updated = repository.Get(_simpleContentType.Id);
Assert.That(updated.AllowedContentTypes.Any(), Is.True);
Assert.That(updated.AllowedContentTypes.Any(x => x.Alias == subpageContentType.Alias), Is.True);
Assert.That(updated.AllowedContentTypes.Any(x => x.Alias == simpleSubpageContentType.Alias), Is.True);
}
}
public void Can_Verify_Usage_Of_New_PropertyType_On_Content()
{
// Arrange
IScopeProvider provider = ScopeProvider;
using (IScope scope = provider.CreateScope())
{
ContentTypeRepository repository = ContentTypeRepository;
IContentType contentType = repository.Get(_textpageContentType.Id);
Content subpage = ContentBuilder.CreateTextpageContent(contentType, "Text Page 1", contentType.Id);
DocumentRepository.Save(subpage);
PropertyGroup propertyGroup = contentType.PropertyGroups.First(x => x.Name == "Meta");
propertyGroup.PropertyTypes.Add(new PropertyType(ShortStringHelper, "test", ValueStorageType.Ntext, "metaAuthor")
{
Name = "Meta Author", Description = string.Empty, Mandatory = false, SortOrder = 1, DataTypeId = -88
});
repository.Save(contentType);
// Act
IContent content = DocumentRepository.Get(subpage.Id);
content.SetValue("metaAuthor", "John Doe");
DocumentRepository.Save(content);
// Assert
IContent updated = DocumentRepository.Get(subpage.Id);
Assert.That(updated.GetValue("metaAuthor").ToString(), Is.EqualTo("John Doe"));
Assert.That(contentType.PropertyTypes.Count(), Is.EqualTo(5));
Assert.That(contentType.PropertyTypes.Any(x => x.Alias == "metaAuthor"), Is.True);
}
}
public void Maps_Templates_Correctly()
{
// Arrange
IScopeProvider provider = ScopeProvider;
using (IScope scope = provider.CreateScope())
{
var templateRepo = new TemplateRepository((IScopeAccessor)provider, AppCaches.Disabled, LoggerFactory.CreateLogger <TemplateRepository>(), FileSystems, IOHelper, ShortStringHelper, Mock.Of <IViewHelper>());
ContentTypeRepository repository = ContentTypeRepository;
Template[] templates = new[]
{
new Template(ShortStringHelper, "test1", "test1"),
new Template(ShortStringHelper, "test2", "test2"),
new Template(ShortStringHelper, "test3", "test3")
};
foreach (Template template in templates)
{
templateRepo.Save(template);
}
ContentType contentType = ContentTypeBuilder.CreateSimpleContentType();
contentType.AllowedTemplates = new[] { templates[0], templates[1] };
contentType.SetDefaultTemplate(templates[0]);
repository.Save(contentType);
// re-get
IContentType result = repository.Get(contentType.Id);
Assert.AreEqual(2, result.AllowedTemplates.Count());
Assert.AreEqual(templates[0].Id, result.DefaultTemplate.Id);
}
}
public void Can_Perform_Query_On_ContentTypeRepository_Sort_By_Name()
{
IContentType contentType;
// Arrange
IScopeProvider provider = ScopeProvider;
using (IScope scope = provider.CreateScope())
{
ContentTypeRepository repository = ContentTypeRepository;
contentType = repository.Get(_textpageContentType.Id);
ContentType child1 = ContentTypeBuilder.CreateSimpleContentType("abc", "abc", contentType, randomizeAliases: true, defaultTemplateId: 0);
repository.Save(child1);
ContentType child3 = ContentTypeBuilder.CreateSimpleContentType("zyx", "zyx", contentType, randomizeAliases: true, defaultTemplateId: 0);
repository.Save(child3);
ContentType child2 = ContentTypeBuilder.CreateSimpleContentType("a123", "a123", contentType, randomizeAliases: true, defaultTemplateId: 0);
repository.Save(child2);
scope.Complete();
}
using (IScope scope = provider.CreateScope())
{
ContentTypeRepository repository = ContentTypeRepository;
// Act
IEnumerable <IContentType> contentTypes = repository.Get(provider.CreateQuery <IContentType>().Where(x => x.ParentId == contentType.Id));
// Assert
Assert.That(contentTypes.Count(), Is.EqualTo(3));
Assert.AreEqual("a123", contentTypes.ElementAt(0).Name);
Assert.AreEqual("abc", contentTypes.ElementAt(1).Name);
Assert.AreEqual("zyx", contentTypes.ElementAt(2).Name);
}
}
public void Can_Perform_Delete_With_Heirarchy_On_ContentTypeRepository()
{
// Arrange
IScopeProvider provider = ScopeProvider;
using (IScope scope = provider.CreateScope())
{
ContentTypeRepository repository = ContentTypeRepository;
ContentType ctMain = ContentTypeBuilder.CreateSimpleContentType(defaultTemplateId: 0);
ContentType ctChild1 = ContentTypeBuilder.CreateSimpleContentType("child1", "Child 1", ctMain, randomizeAliases: true, defaultTemplateId: 0);
ContentType ctChild2 = ContentTypeBuilder.CreateSimpleContentType("child2", "Child 2", ctChild1, randomizeAliases: true, defaultTemplateId: 0);
repository.Save(ctMain);
repository.Save(ctChild1);
repository.Save(ctChild2);
// Act
IContentType resolvedParent = repository.Get(ctMain.Id);
repository.Delete(resolvedParent);
// Assert
Assert.That(repository.Exists(ctMain.Id), Is.False);
Assert.That(repository.Exists(ctChild1.Id), Is.False);
Assert.That(repository.Exists(ctChild2.Id), Is.False);
}
}
public void Transaction()
{
ScopeProvider scopeProvider = ScopeProvider;
using (IScope scope = scopeProvider.CreateScope())
{
ScopeAccessor.AmbientScope.Database.Execute("CREATE TABLE tmp3 (id INT, name NVARCHAR(64))");
scope.Complete();
}
using (IScope scope = scopeProvider.CreateScope())
{
ScopeAccessor.AmbientScope.Database.Execute("INSERT INTO tmp3 (id, name) VALUES (1, 'a')");
string n = ScopeAccessor.AmbientScope.Database.ExecuteScalar <string>("SELECT name FROM tmp3 WHERE id=1");
Assert.AreEqual("a", n);
}
using (IScope scope = scopeProvider.CreateScope())
{
string n = ScopeAccessor.AmbientScope.Database.ExecuteScalar <string>("SELECT name FROM tmp3 WHERE id=1");
Assert.IsNull(n);
}
using (IScope scope = scopeProvider.CreateScope())
{
ScopeAccessor.AmbientScope.Database.Execute("INSERT INTO tmp3 (id, name) VALUES (1, 'a')");
scope.Complete();
}
using (IScope scope = scopeProvider.CreateScope())
{
string n = ScopeAccessor.AmbientScope.Database.ExecuteScalar <string>("SELECT name FROM tmp3 WHERE id=1");
Assert.AreEqual("a", n);
}
}
public void Get_By_Name()
{
int contentId = CreateTestData("en-AU", out ContentType ct);
IScopeProvider provider = ScopeProvider;
using (IScope scope = provider.CreateScope())
{
DomainRepository repo = CreateRepository(provider);
ILanguage lang = LanguageRepository.GetByIsoCode("en-AU");
IContent content = DocumentRepository.Get(contentId);
for (int i = 0; i < 10; i++)
{
var domain = (IDomain) new UmbracoDomain("test" + i + ".com")
{
RootContentId = content.Id, LanguageId = lang.Id
};
repo.Save(domain);
}
IDomain found = repo.GetByName("test1.com");
Assert.IsNotNull(found);
}
}
public void ScopeContextEnlist(bool complete)
{
ScopeProvider scopeProvider = ScopeProvider;
bool? completed = null;
IScope ambientScope = null;
IScopeContext ambientContext = null;
Assert.IsNull(scopeProvider.AmbientScope);
using (IScope scope = scopeProvider.CreateScope())
{
scopeProvider.Context.Enlist("name", c =>
{
completed = c;
ambientScope = scopeProvider.AmbientScope;
ambientContext = scopeProvider.AmbientContext;
});
if (complete)
{
scope.Complete();
}
}
Assert.IsNull(scopeProvider.AmbientScope);
Assert.IsNull(scopeProvider.AmbientContext);
Assert.IsNotNull(completed);
Assert.AreEqual(complete, completed.Value);
Assert.IsNull(ambientScope); // the scope is gone
Assert.IsNotNull(ambientContext); // the context is still there
}
public void Get_All_Ids()
{
int contentId = CreateTestData("en-AU", out ContentType ct);
IScopeProvider provider = ScopeProvider;
using (IScope scope = provider.CreateScope())
{
DomainRepository repo = CreateRepository(provider);
ILanguage lang = LanguageRepository.GetByIsoCode("en-AU");
IContent content = DocumentRepository.Get(contentId);
var ids = new List <int>();
for (int i = 0; i < 10; i++)
{
var domain = (IDomain) new UmbracoDomain("test " + i + ".com")
{
RootContentId = content.Id, LanguageId = lang.Id
};
repo.Save(domain);
ids.Add(domain.Id);
}
IEnumerable <IDomain> all = repo.GetMany(ids.Take(8).ToArray());
Assert.AreEqual(8, all.Count());
}
}
public void ScopeContextException()
{
ScopeProvider scopeProvider = ScopeProvider;
bool?completed = null;
Assert.IsNull(scopeProvider.AmbientScope);
using (IScope scope = scopeProvider.CreateScope())
{
IScope detached = scopeProvider.CreateDetachedScope();
scopeProvider.AttachScope(detached);
// the exception does not prevent other enlisted items to run
// *and* it does not prevent the scope from properly going down
scopeProvider.Context.Enlist("name", c => throw new Exception("bang"));
scopeProvider.Context.Enlist("other", c => completed = c);
detached.Complete();
Assert.Throws <AggregateException>(() => detached.Dispose());
// even though disposing of the scope has thrown, it has exited
// properly ie it has removed itself, and the app remains clean
Assert.AreSame(scope, scopeProvider.AmbientScope);
scope.Complete();
}
Assert.IsNull(scopeProvider.AmbientScope);
Assert.IsNull(scopeProvider.AmbientContext);
Assert.IsNotNull(completed);
Assert.AreEqual(true, completed);
}
public void Get_All_Without_Wildcards()
{
int contentId = CreateTestData("en-AU", out ContentType ct);
IScopeProvider provider = ScopeProvider;
using (IScope scope = provider.CreateScope())
{
DomainRepository repo = CreateRepository(provider);
ILanguage lang = LanguageRepository.GetByIsoCode("en-AU");
IContent content = DocumentRepository.Get(contentId);
for (int i = 0; i < 10; i++)
{
var domain = (IDomain) new UmbracoDomain((i % 2 == 0) ? "test " + i + ".com" : ("*" + i))
{
RootContentId = content.Id,
LanguageId = lang.Id
};
repo.Save(domain);
}
IEnumerable <IDomain> all = repo.GetAll(false);
Assert.AreEqual(5, all.Count());
}
}
public void Can_Persist_Member_Type()
{
IScopeProvider provider = ScopeProvider;
using (IScope scope = provider.CreateScope())
{
MemberTypeRepository repository = CreateRepository(provider);
var memberType = (IMemberType)MemberTypeBuilder.CreateSimpleMemberType();
repository.Save(memberType);
IMemberType sut = repository.Get(memberType.Id);
Dictionary <string, PropertyType> standardProps = ConventionsHelper.GetStandardPropertyTypeStubs(ShortStringHelper);
Assert.That(sut, Is.Not.Null);
Assert.That(sut.PropertyGroups.Count, Is.EqualTo(2));
Assert.That(sut.PropertyTypes.Count(), Is.EqualTo(3 + standardProps.Count));
Assert.That(sut.PropertyGroups.Any(x => x.HasIdentity == false || x.Id == 0), Is.False);
Assert.That(sut.PropertyTypes.Any(x => x.HasIdentity == false || x.Id == 0), Is.False);
TestHelper.AssertPropertyValuesAreEqual(sut, memberType);
}
}
public void Can_Create_And_Get_By_Id_Empty_lang()
{
int contentId = CreateTestData("en-AU", out ContentType ct);
IScopeProvider provider = ScopeProvider;
using (IScope scope = provider.CreateScope())
{
DomainRepository repo = CreateRepository(provider);
IContent content = DocumentRepository.Get(contentId);
var domain = (IDomain) new UmbracoDomain("test.com")
{
RootContentId = content.Id
};
repo.Save(domain);
// re-get
domain = repo.Get(domain.Id);
Assert.NotNull(domain);
Assert.IsTrue(domain.HasIdentity);
Assert.Greater(domain.Id, 0);
Assert.AreEqual("test.com", domain.DomainName);
Assert.AreEqual(content.Id, domain.RootContentId);
Assert.IsFalse(domain.LanguageId.HasValue);
}
}
public void SaveMediaMultiple()
{
// Arrange
IScopeProvider provider = ScopeProvider;
using (IScope scope = provider.CreateScope())
{
MediaRepository repository = CreateRepository(provider, out MediaTypeRepository mediaTypeRepository);
IMediaType mediaType = mediaTypeRepository.Get(1032);
Media file = MediaBuilder.CreateMediaFile(mediaType, -1);
// Act
repository.Save(file);
Media image = MediaBuilder.CreateMediaImage(mediaType, -1);
repository.Save(image);
// Assert
Assert.That(file.HasIdentity, Is.True);
Assert.That(image.HasIdentity, Is.True);
Assert.That(file.Name, Is.EqualTo("Test File"));
Assert.That(image.Name, Is.EqualTo("Test Image"));
Assert.That(file.ContentTypeId, Is.EqualTo(mediaType.Id));
Assert.That(image.ContentTypeId, Is.EqualTo(mediaType.Id));
}
}
public void GivenChildThread_WhenChildDisposedBeforeParent_OK()
{
ScopeProvider scopeProvider = ScopeProvider;
Assert.IsNull(ScopeProvider.AmbientScope);
IScope mainScope = scopeProvider.CreateScope();
// Task.Run will flow the execution context unless ExecutionContext.SuppressFlow() is explicitly called.
// This is what occurs in normal async behavior since it is expected to await (and join) the main thread,
// but if Task.Run is used as a fire and forget thread without being done correctly then the Scope will
// flow to that thread.
var t = Task.Run(() =>
{
Console.WriteLine("Child Task start: " + scopeProvider.AmbientScope.InstanceId);
IScope nested = scopeProvider.CreateScope();
Console.WriteLine("Child Task before dispose: " + scopeProvider.AmbientScope.InstanceId);
nested.Dispose();
Console.WriteLine("Child Task after disposed: " + scopeProvider.AmbientScope.InstanceId);
});
Console.WriteLine("Parent Task waiting: " + scopeProvider.AmbientScope?.InstanceId);
Task.WaitAll(t);
Console.WriteLine("Parent Task disposing: " + scopeProvider.AmbientScope.InstanceId);
mainScope.Dispose();
Console.WriteLine("Parent Task disposed: " + scopeProvider.AmbientScope?.InstanceId);
Assert.Pass();
}
public void QueryMedia_ContentTypeIdFilter()
{
// Arrange
IMediaType folderMediaType = MediaTypeService.Get(1031);
IScopeProvider provider = ScopeProvider;
using (IScope scope = provider.CreateScope())
{
MediaRepository repository = CreateRepository(provider, out MediaTypeRepository mediaTypeRepository);
// Act
for (int i = 0; i < 10; i++)
{
Media folder = MediaBuilder.CreateMediaFolder(folderMediaType, -1);
repository.Save(folder);
}
int[] types = new[] { 1031 };
IQuery <IMedia> query = provider.CreateQuery <IMedia>().Where(x => types.Contains(x.ContentTypeId));
IEnumerable <IMedia> result = repository.Get(query);
// Assert
Assert.That(result.Count(), Is.GreaterThanOrEqualTo(11));
}
}
public void NestedCreateScopeContext()
{
ScopeProvider scopeProvider = ScopeProvider;
Assert.IsNull(scopeProvider.AmbientScope);
using (IScope scope = scopeProvider.CreateScope())
{
Assert.IsInstanceOf <Scope>(scope);
Assert.IsNotNull(scopeProvider.AmbientScope);
Assert.AreSame(scope, scopeProvider.AmbientScope);
Assert.IsNotNull(scopeProvider.AmbientContext);
IScopeContext context;
using (IScope nested = scopeProvider.CreateScope())
{
Assert.IsInstanceOf <Scope>(nested);
Assert.IsNotNull(scopeProvider.AmbientScope);
Assert.AreSame(nested, scopeProvider.AmbientScope);
Assert.AreSame(scope, ((Scope)nested).ParentScope);
Assert.IsNotNull(scopeProvider.Context);
Assert.IsNotNull(scopeProvider.AmbientContext);
context = scopeProvider.Context;
}
Assert.IsNotNull(scopeProvider.AmbientContext);
Assert.AreSame(context, scopeProvider.AmbientContext);
}
Assert.IsNull(scopeProvider.AmbientScope);
Assert.IsNull(scopeProvider.AmbientContext);
}
public void GetAllMedia()
{
// Arrange
IScopeProvider provider = ScopeProvider;
using (IScope scope = provider.CreateScope())
{
MediaRepository repository = CreateRepository(provider, out MediaTypeRepository mediaTypeRepository);
// Act
IEnumerable <IMedia> medias = repository.GetMany();
// Assert
Assert.That(medias, Is.Not.Null);
Assert.That(medias.Any(), Is.True);
Assert.That(medias.Count(), Is.GreaterThanOrEqualTo(3));
medias = repository.GetMany(medias.Select(x => x.Id).ToArray());
Assert.That(medias, Is.Not.Null);
Assert.That(medias.Any(), Is.True);
Assert.That(medias.Count(), Is.GreaterThanOrEqualTo(3));
medias = ((IReadRepository <Guid, IMedia>)repository).GetMany(medias.Select(x => x.Key).ToArray());
Assert.That(medias, Is.Not.Null);
Assert.That(medias.Any(), Is.True);
Assert.That(medias.Count(), Is.GreaterThanOrEqualTo(3));
}
}
public void NestedCreateScopeDatabase()
{
ScopeProvider scopeProvider = ScopeProvider;
IUmbracoDatabase database;
Assert.IsNull(scopeProvider.AmbientScope);
using (IScope scope = scopeProvider.CreateScope())
{
Assert.IsInstanceOf <Scope>(scope);
Assert.IsNotNull(scopeProvider.AmbientScope);
Assert.AreSame(scope, scopeProvider.AmbientScope);
database = ScopeAccessor.AmbientScope.Database; // populates scope's database
Assert.IsNotNull(database);
Assert.IsNotNull(database.Connection); // in a transaction
using (IScope nested = scopeProvider.CreateScope())
{
Assert.IsInstanceOf <Scope>(nested);
Assert.IsNotNull(scopeProvider.AmbientScope);
Assert.AreSame(nested, scopeProvider.AmbientScope);
Assert.AreSame(scope, ((Scope)nested).ParentScope);
Assert.AreSame(database, ScopeAccessor.AmbientScope.Database);
}
Assert.IsNotNull(database.Connection); // still
}
Assert.IsNull(scopeProvider.AmbientScope);
Assert.IsNull(database.Connection); // poof gone
}
public void CreateNotification()
{
IScopeProvider provider = ScopeProvider;
using (IScope scope = provider.CreateScope())
{
var repo = new NotificationsRepository((IScopeAccessor)provider);
var node = new NodeDto // create bogus item so we can add a notification
{
CreateDate = DateTime.Now,
Level = 1,
NodeObjectType = Constants.ObjectTypes.ContentItem,
ParentId = -1,
Path = "-1,123",
SortOrder = 1,
Text = "hello",
Trashed = false,
UniqueId = Guid.NewGuid(),
UserId = Constants.Security.SuperUserId
};
object result = ScopeAccessor.AmbientScope.Database.Insert(node);
IEntity entity = Mock.Of <IEntity>(e => e.Id == node.NodeId);
IUser user = Mock.Of <IUser>(e => e.Id == node.UserId);
Notification notification = repo.CreateNotification(user, entity, "A");
Assert.AreEqual("A", notification.Action);
Assert.AreEqual(node.NodeId, notification.EntityId);
Assert.AreEqual(node.NodeObjectType, notification.EntityType);
Assert.AreEqual(node.UserId, notification.UserId);
}
}
public void Can_Perform_Add_On_ContentTypeRepository()
{
// Arrange
IScopeProvider provider = ScopeProvider;
using (IScope scope = provider.CreateScope())
{
// Act
ContentType contentType = ContentTypeBuilder.CreateSimpleContentType("test", "Test", propertyGroupAlias: "testGroup", propertyGroupName: "testGroup");
ContentTypeRepository.Save(contentType);
IContentType fetched = ContentTypeRepository.Get(contentType.Id);
// Assert
Assert.That(contentType.HasIdentity, Is.True);
Assert.That(contentType.PropertyGroups.All(x => x.HasIdentity), Is.True);
Assert.That(contentType.PropertyTypes.All(x => x.HasIdentity), Is.True);
Assert.That(contentType.Path.Contains(","), Is.True);
Assert.That(contentType.SortOrder, Is.GreaterThan(0));
Assert.That(contentType.PropertyGroups.ElementAt(0).Name == "testGroup", Is.True);
int groupId = contentType.PropertyGroups.ElementAt(0).Id;
Assert.That(contentType.PropertyTypes.All(x => x.PropertyGroupId.Value == groupId), Is.True);
foreach (IPropertyType propertyType in contentType.PropertyTypes)
{
Assert.AreNotEqual(propertyType.Key, Guid.Empty);
}
TestHelper.AssertPropertyValuesAreEqual(fetched, contentType, ignoreProperties: new[] { "DefaultTemplate", "AllowedTemplates", "UpdateDate", "HistoryCleanup" });
}
}
