public void WhenSourceIsAccessed_LazyRelation_CallsRepository_WithBothSourceAndDestinationId()
{
// Arrange
var context = new FakeFrameworkContext();
var providerGroup = GroupedProviderMockHelper.GenerateProviderGroup(1, 0, 50, context);
var idRoot = new Uri("oh-yeah://this-is-my-root/");
var groupUnitFactory = new GroupUnitFactory(providerGroup.Writers, idRoot, FakeHiveCmsManager.CreateFakeRepositoryContext(context), context);
HiveId int1 = HiveId.ConvertIntToGuid(1);
HiveId int2 = HiveId.ConvertIntToGuid(2);
// Act & Assert
using (var uow = groupUnitFactory.Create())
{
var lazyRelation = new LazyRelation<TypedEntity>(uow.Repositories, FixedRelationTypes.DefaultRelationType, int1, int2, 0);
IReadonlyRelation<IRelatableEntity, IRelatableEntity> blah = lazyRelation;
IRelationById blah2 = lazyRelation;
Assert.False(lazyRelation.IsLoaded);
var source = lazyRelation.Source;
Assert.True(lazyRelation.IsLoaded);
var dest = lazyRelation.Destination;
Assert.NotNull(source);
Assert.NotNull(dest);
}
}
public void WhenGetIsCalled_WithMultipleIds_MultipleItemsAreReturned(
int allItemCount,
int numbProviderCount,
int numberOfPassthroughProviders)
{
// Arrange
var context = new FakeFrameworkContext();
var providerGroup = GroupedProviderMockHelper.GenerateProviderGroup(numbProviderCount, numberOfPassthroughProviders, allItemCount, context);
var idRoot = new Uri("oh-yeah://this-is-my-root/");
var groupUnitFactory = new GroupUnitFactory(providerGroup.Writers, idRoot, FakeHiveCmsManager.CreateFakeRepositoryContext(context), context);
HiveId int1 = HiveId.ConvertIntToGuid(1);
HiveId int2 = HiveId.ConvertIntToGuid(2);
HiveId int3 = HiveId.ConvertIntToGuid(3);
// Act & Assert
using (var uow = groupUnitFactory.Create<IContentStore>())
{
Assert.NotNull(uow.IdRoot);
Assert.AreEqual(uow.IdRoot, idRoot);
// TODO: This looks like a poor test since Get with multiple ids is actually just mocked to return three
// but the purpose of this test is to establish that when running with multiple providers, some of which
// are passthrough, only the correct number of items should be returned
var items = uow.Repositories.Get<TypedEntity>(true, int1, int2, int3);
Assert.That(items.Count(), Is.EqualTo(3 * numbProviderCount), "item count wrong");
// Assert that the correct number of relations are returned too including passthrough providers being filtered for
var parents = uow.Repositories.GetParentRelations(HiveId.Empty);
Assert.That(parents.Count(), Is.EqualTo(GroupedProviderMockHelper.MockRelationCount * numbProviderCount), "parents count wrong");
}
}
public void WhenExecutingCount_WithoutRevisionSpecified_OnlyPublishedResultsAreIncluded()
{
// Arrange
var newGuid = Guid.NewGuid();
var newGuidRedHerring = Guid.NewGuid();
var entity = CreateEntityForTest(newGuid, newGuidRedHerring, ProviderSetup);
AddRevision(entity, FixedStatusTypes.Published);
// Act
using (var uow = GroupUnitFactory.Create())
{
var result = uow.Repositories.Count(x => x.Id == (HiveId)newGuid);
// Assert
Assert.That(result, Is.EqualTo(1));
}
}
public void TypedEntity_ById_EqualsOperator()
{
// Arrange
var newGuid = Guid.NewGuid();
var newGuidRedHerring = Guid.NewGuid();
var entity = CreateEntityForTest(newGuid, newGuidRedHerring, ProviderSetup);
// Act
using (var uow = GroupUnitFactory.Create())
{
var query = uow.Repositories.QueryContext.Query().Where(x => x.Id == (HiveId)newGuid);
// Assert
var item = query.FirstOrDefault();
Assert.IsNotNull(item);
Assert.AreEqual(newGuid, (Guid)item.Id.Value);
}
}
public void TypedEntity_ByAttributeSubValue_EqualsOperator()
{
// Arrange
var newGuid = Guid.NewGuid();
var newGuidRedHerring = Guid.NewGuid();
var entity = CreateEntityForTest(newGuid, newGuidRedHerring, ProviderSetup);
// Act
using (var uow = GroupUnitFactory.Create())
{
var query = uow.Repositories.QueryContext.Query().Where(x => x.InnerAttribute <string>(NodeNameAttributeDefinition.AliasValue, "UrlName") == "my-test-route");
// Assert
var item = query.FirstOrDefault();
Assert.IsNotNull(item);
Assert.AreEqual(newGuid, (Guid)item.Id.Value);
}
}
public void TypedEntity_ByAttributeValue_EqualsOperator()
{
// Arrange
var newGuid = Guid.NewGuid();
var newGuidRedHerring = Guid.NewGuid();
var entity = CreateEntityForTest(newGuid, newGuidRedHerring, ProviderSetup);
// Act
using (var uow = GroupUnitFactory.Create())
{
var query = uow.Repositories.QueryContext.Query().Where(x => x.Attribute <string>(AttributeAlias2ForQuerying) == "not-on-red-herring");
// Assert
var item = query.FirstOrDefault();
Assert.IsNotNull(item);
Assert.AreEqual(newGuid, (Guid)item.Id.Value);
}
}
public void Temp_TypedEntity_WithDynamicQuery()
{
// Arrange
var newGuid = Guid.NewGuid();
var newGuidRedHerring = Guid.NewGuid();
var entity = CreateEntityForTest(newGuid, newGuidRedHerring, ProviderSetup);
// Act
using (var uow = GroupUnitFactory.Create())
{
var dynQuery = DynamicMemberMetadata.GetAsPredicate(DynamicAttributeAliasForQuerying + " == @0", "my-new-value");
var query = uow.Repositories.OfRevisionType("created").Where(dynQuery).Cast <TypedEntity>();
// Assert
var item = query.FirstOrDefault();
Assert.IsNotNull(item);
Assert.AreEqual(newGuid, (Guid)item.Id.Value);
}
}
public void WhenProviderIsMatched_IdIsRemappedToMappingGroup_OnReturn(
int allItemCount,
int numbProviderCount,
int numberOfPassthroughProviders)
{
// Arrange
var context = new FakeFrameworkContext();
var providerGroup = GroupedProviderMockHelper.GenerateProviderGroup(numbProviderCount, numberOfPassthroughProviders, allItemCount, context);
var idRoot = new Uri("oh-yeah://this-is-my-root/");
var groupUnitFactory = new GroupUnitFactory(providerGroup.Writers, idRoot, FakeHiveCmsManager.CreateFakeRepositoryContext(context), context);
// Act & Assert
using (var uow = groupUnitFactory.Create <IContentStore>())
{
Assert.NotNull(uow.IdRoot);
Assert.AreEqual(uow.IdRoot, idRoot);
var singleItem = uow.Repositories.Get <TypedEntity>(HiveId.Empty);
Assert.NotNull(singleItem);
Assert.NotNull(singleItem.Id.ProviderGroupRoot);
Assert.AreEqual(singleItem.Id.ProviderGroupRoot, idRoot);
Assert.NotNull(singleItem.Id.ProviderId);
Assert.True(singleItem.Id.ToString(HiveIdFormatStyle.AsUri).StartsWith(idRoot.ToString()), "Was: " + singleItem.Id.ToFriendlyString());
var items = uow.Repositories.GetAll <TypedEntity>();
var itemShouldBeCount = allItemCount * numbProviderCount;
Assert.AreEqual(itemShouldBeCount, items.Count());
foreach (var typedEntity in items)
{
AssertEntityIdIsRooted(idRoot, ((IReferenceByHiveId)typedEntity).Id);
}
AssertRelationsIdsHaveRoot(uow.Repositories.GetParentRelations(HiveId.Empty), idRoot);
AssertRelationsIdsHaveRoot(uow.Repositories.GetDescendentRelations(HiveId.Empty), idRoot);
AssertRelationsIdsHaveRoot(uow.Repositories.GetChildRelations(HiveId.Empty), idRoot);
AssertRelationsIdsHaveRoot(uow.Repositories.GetAncestorRelations(HiveId.Empty), idRoot);
}
}
public void TypedEntity_ByEntitSchemaAlias_EqualsOperator()
{
// Arrange
var newGuid = Guid.NewGuid();
var newGuidRedHerring = Guid.NewGuid();
var entity = CreateEntityForTest(newGuid, newGuidRedHerring, ProviderSetup);
// Act
using (var uow = GroupUnitFactory.Create())
{
var query = uow.Repositories.QueryContext.Query().Where(x => x.EntitySchema.Alias == SchemaAliasForQuerying);
// Assert
Assert.AreEqual(1, query.Count());
var item = query.FirstOrDefault();
Assert.IsNotNull(item);
Assert.AreEqual(newGuid, (Guid)item.Id.Value);
Assert.AreEqual("schema-alias1", item.EntitySchema.Alias);
}
}
public void WhenTypedEntity_IsReturnedFromGroupEntityRepository_AllObjects_HaveProviderId()
{
// Arrange
var context = new FakeFrameworkContext();
var providerGroup = GroupedProviderMockHelper.GenerateProviderGroup(1, 0, 50, context);
var idRoot = new Uri("myroot://yeah/");
var groupUnitFactory = new GroupUnitFactory(providerGroup.Writers, idRoot, FakeHiveCmsManager.CreateFakeRepositoryContext(context), context);
// Act & Assert
using (var uow = groupUnitFactory.Create())
{
Assert.NotNull(uow.IdRoot);
Assert.AreEqual(uow.IdRoot, idRoot);
var singleItem = uow.Repositories.Get <TypedEntity>(HiveId.Empty);
var allDependentItems = singleItem.GetAllIdentifiableItems().ToArray();
Assert.IsTrue(allDependentItems.Any());
Assert.That(allDependentItems.Select(x => x.Id).Distinct().Count(), Is.GreaterThan(1));
foreach (var referenceByHiveId in allDependentItems)
{
AssertEntityIdIsRooted(idRoot, referenceByHiveId.Id);
}
}
}
public void TypedEntity_Dynamic_Equals_WithBoolean()
{
// Arrange
var newGuid = Guid.NewGuid();
var newGuidRedHerring = Guid.NewGuid();
var entity = CreateEntityForTest(newGuid, newGuidRedHerring, ProviderSetup);
// Act
using (var uow = GroupUnitFactory.Create())
{
var dynQuery = DynamicMemberMetadata.GetAsPredicate(HiveModelCreationHelper.BoolDefAlias + " == @0", true);
var query = uow.Repositories.OfRevisionType(FixedStatusTypes.Created).Where(dynQuery).Cast <TypedEntity>();
// Assert
var items = query.ToList();
Assert.IsNotNull(items);
Assert.AreEqual(1, items.Count);
var firstItem = items.First();
Assert.AreEqual(newGuid, (Guid)firstItem.Id.Value);
// Query for the opposite (the red-herring node)
var dynQuery_opposite = DynamicMemberMetadata.GetAsPredicate(HiveModelCreationHelper.BoolDefAlias + " == @0", false);
var query_opposite = uow.Repositories.OfRevisionType(FixedStatusTypes.Created).Where(dynQuery_opposite).Cast <TypedEntity>();
// Assert again
var items_opposite = query_opposite.ToList();
Assert.IsNotNull(items_opposite);
Assert.AreEqual(1, items_opposite.Count);
Assert.AreEqual(newGuidRedHerring, (Guid)items_opposite.First().Id.Value);
}
}
public void UserGroup_ByName_EqualsOperator()
{
// Arrange
var permission = new Lazy <Permission, PermissionMetadata>(() => new ViewPermission(), new PermissionMetadata(new Dictionary <string, object>()));
var userGroup = CoreCmsData.RequiredCoreUserGroups(Enumerable.Repeat(permission, 1)).FirstOrDefault(x => x.Name == "Administrator");
Assert.NotNull(userGroup);
using (var uow = GroupUnitFactory.Create())
{
uow.Repositories.AddOrUpdate(new SystemRoot());
uow.Repositories.AddOrUpdate(Framework.Security.Model.FixedEntities.UserGroupVirtualRoot);
uow.Repositories.AddOrUpdate(userGroup);
uow.Complete();
}
// Act
using (var uow = GroupUnitFactory.Create())
{
var getAdminByName = uow.Repositories.Query <UserGroup>().FirstOrDefault(x => x.Name == "Administrator");
Assert.NotNull(getAdminByName);
Assert.That(userGroup.Id.Value, Is.EqualTo(getAdminByName.Id.Value));
}
}
public void CompositeEntity_ReSaves()
{
// Arrange
var childSchema = CreateAndSaveCompositeSchema(AttributeTypeRegistry, ProviderSetup);
CompositeEntitySchema merged = null;
var groupUnitFactory = new GroupUnitFactory(ProviderSetup, childSchema.Id.ToUri(), FakeHiveCmsManager.CreateFakeRepositoryContext(ProviderSetup.FrameworkContext));
using (var uow = groupUnitFactory.Create())
{
merged = uow.Repositories.Schemas.GetComposite<EntitySchema>(childSchema.Id);
}
List<TypedAttribute> attribs;
var entity = MockCompositeEntity(merged, out attribs);
AssignFakeIdsIfPassthrough(ProviderSetup.ProviderMetadata, entity);
Assert.That(entity.Attributes.Count, Is.EqualTo(attribs.Count));
var firstRevision = new Revision<TypedEntity>(entity);
using (var uow = groupUnitFactory.Create())
{
uow.Repositories.Revisions.AddOrUpdate(firstRevision);
uow.Complete();
}
PostWriteCallback.Invoke();
// Edit the data and resave
var secondRevision = firstRevision.CopyToNewRevision(FixedStatusTypes.Published);
secondRevision.Item.Attributes.Last().DynamicValue = "changed";
secondRevision.Item.Attributes.ForEach(x => x.Id = HiveId.Empty);
using (var uow = groupUnitFactory.Create())
{
uow.Repositories.Revisions.AddOrUpdate(secondRevision);
uow.Complete();
}
PostWriteCallback.Invoke();
// Load the data again to ensure these attributes are still "inherited"
using (var uow = groupUnitFactory.Create())
{
var reloaded = uow.Repositories.Get<TypedEntity>(entity.Id);
Assert.That(reloaded.EntitySchema.Id.Value, Is.EqualTo(childSchema.Id.Value));
Assert.That(reloaded.Attributes.Count, Is.EqualTo(attribs.Count));
Assert.That(reloaded.Attributes.Select(x => x.AttributeDefinition), Has.Some.TypeOf<InheritedAttributeDefinition>());
}
}
public void Create_Dynamic_Search_With_Results()
{
AttributeTypeRegistry.SetCurrent(new CmsAttributeTypeRegistry());
// Ensure parent exists for this test
Hive.AutoCommitTo <IContentStore>(x => x.Repositories.Schemas.AddOrUpdate(new ContentRootSchema()));
// Create schema
var schema1 = Hive.Cms().NewContentType <EntitySchema, IContentStore>("homePage")
.Define("pageTitle", type => type.UseExistingType("singleLineTextBox"), FixedGroupDefinitions.GeneralGroup)
.Define("pageContent", type => type.UseExistingType("singleLineTextBox"), FixedGroupDefinitions.GeneralGroup)
.Commit();
var schema2 = Hive.Cms().NewContentType <EntitySchema, IContentStore>("contentPage")
.Define("pageTitle", type => type.UseExistingType("singleLineTextBox"), FixedGroupDefinitions.GeneralGroup)
.Define("pageContent", type => type.UseExistingType("singleLineTextBox"), FixedGroupDefinitions.GeneralGroup)
.Commit();
Assert.True(schema1.Success);
Assert.True(schema2.Success);
var item1 = new Content();
item1.SetupFromSchema(schema1.Item);
item1.Id = new HiveId(Guid.NewGuid());
item1["pageTitle"] = "Hello There";
item1["pageContent"] = "some page content";
var item2 = new Content();
item2.SetupFromSchema(schema2.Item);
item2.Id = new HiveId(Guid.NewGuid());
item2["pageTitle"] = "Title 1";
item2["pageContent"] = "this is some page content. hi, hello, goodbye.";
var item3 = new Content();
item3.SetupFromSchema(schema1.Item);
item3.Id = new HiveId(Guid.NewGuid());
item3["pageTitle"] = "Another page";
item3["pageContent"] = "Say hello to my little friend.";
var writerResult = Hive.AutoCommitTo <IContentStore>(x =>
{
x.Repositories.AddOrUpdate(item1);
x.Repositories.AddOrUpdate(item2);
x.Repositories.AddOrUpdate(item3);
});
Assert.True(writerResult.WasCommitted);
AddRevision(item1, FixedStatusTypes.Published);
AddRevision(item2, FixedStatusTypes.Published);
AddRevision(item3, FixedStatusTypes.Published);
// Check can get the items normally
using (var uow = Hive.OpenReader <IContentStore>())
{
Assert.True(uow.Repositories.Exists <Content>(item1.Id));
Assert.True(uow.Repositories.Exists <Content>(item2.Id));
Assert.True(uow.Repositories.Exists <Content>(item3.Id));
}
//Create a dynamic search
var docTypes = new[] { "homePage", "contentPage" };
var fields = new[] { "pageTitle", "pageContent" };
var searchTerm = "hello";
using (var uow = GroupUnitFactory.Create())
{
var predicate = ExpressionExtensions.False <TypedEntity>();
var query = uow.Repositories.Query();
foreach (var d in docTypes)
{
//this will add an 'AND' clause, not an 'OR' clause
//query = query.Where(x => x.EntitySchema.Alias == d);
var d1 = d;
predicate = predicate.Or(x => x.EntitySchema.Alias == d1);
}
foreach (var f in fields)
{
//this will add an 'AND' clause, not an 'OR' clause
//query = query.Where(x => x.Attribute<string>(f) == searchTerm);
var f1 = f;
predicate = predicate.Or(x => x.Attribute <string>(f1) == searchTerm);
}
var result = query.Where(predicate).ToArray();
Assert.AreEqual(3, result.Count());
}
}
public void WhenTypedEntity_IsReturnedFromGroupEntityRepository_AllObjects_HaveProviderId()
{
// Arrange
var context = new FakeFrameworkContext();
var providerGroup = GroupedProviderMockHelper.GenerateProviderGroup(1, 0, 50, context);
var idRoot = new Uri("myroot://yeah/");
var groupUnitFactory = new GroupUnitFactory(providerGroup.Writers, idRoot, FakeHiveCmsManager.CreateFakeRepositoryContext(context), context);
// Act & Assert
using (var uow = groupUnitFactory.Create())
{
Assert.NotNull(uow.IdRoot);
Assert.AreEqual(uow.IdRoot, idRoot);
var singleItem = uow.Repositories.Get<TypedEntity>(HiveId.Empty);
var allDependentItems = singleItem.GetAllIdentifiableItems().ToArray();
Assert.IsTrue(allDependentItems.Any());
Assert.That(allDependentItems.Select(x => x.Id).Distinct().Count(), Is.GreaterThan(1));
foreach (var referenceByHiveId in allDependentItems)
{
AssertEntityIdIsRooted(idRoot, referenceByHiveId.Id);
}
}
}
public void WhenTypedEntity_IsReturnedFromGroupEntityRepository_ItsRelationProxies_HaveAbsoluteId()
{
// Arrange
var context = new FakeFrameworkContext();
var providerGroup = GroupedProviderMockHelper.GenerateProviderGroup(1, 0, 50, context);
var idRoot = new Uri("myroot://yeah/");
var groupUnitFactory = new GroupUnitFactory(providerGroup.Writers, idRoot, FakeHiveCmsManager.CreateFakeRepositoryContext(context), context);
// Act & Assert
using (var uow = groupUnitFactory.Create())
{
Assert.NotNull(uow.IdRoot);
Assert.AreEqual(uow.IdRoot, idRoot);
var item = uow.Repositories.Get<TypedEntity>(HiveId.Empty);
AssertIdsOfRelationProxiesForEntity(item, idRoot);
var items = uow.Repositories.GetAll<TypedEntity>();
Assert.True(items.Any());
foreach (var typedEntity in items)
{
AssertIdsOfRelationProxiesForEntity(typedEntity, idRoot);
}
}
}
public void WhenProviderIsMatched_IdIsRemappedToMappingGroup_OnReturn(
int allItemCount,
int numbProviderCount,
int numberOfPassthroughProviders)
{
// Arrange
var context = new FakeFrameworkContext();
var providerGroup = GroupedProviderMockHelper.GenerateProviderGroup(numbProviderCount, numberOfPassthroughProviders, allItemCount, context);
var idRoot = new Uri("oh-yeah://this-is-my-root/");
var groupUnitFactory = new GroupUnitFactory(providerGroup.Writers, idRoot, FakeHiveCmsManager.CreateFakeRepositoryContext(context), context);
// Act & Assert
using (var uow = groupUnitFactory.Create<IContentStore>())
{
Assert.NotNull(uow.IdRoot);
Assert.AreEqual(uow.IdRoot, idRoot);
var singleItem = uow.Repositories.Get<TypedEntity>(HiveId.Empty);
Assert.NotNull(singleItem);
Assert.NotNull(singleItem.Id.ProviderGroupRoot);
Assert.AreEqual(singleItem.Id.ProviderGroupRoot, idRoot);
Assert.NotNull(singleItem.Id.ProviderId);
Assert.True(singleItem.Id.ToString(HiveIdFormatStyle.AsUri).StartsWith(idRoot.ToString()), "Was: " + singleItem.Id.ToFriendlyString());
var items = uow.Repositories.GetAll<TypedEntity>();
var itemShouldBeCount = allItemCount * numbProviderCount;
Assert.AreEqual(itemShouldBeCount, items.Count());
foreach (var typedEntity in items)
{
AssertEntityIdIsRooted(idRoot, ((IReferenceByHiveId)typedEntity).Id);
}
AssertRelationsIdsHaveRoot(uow.Repositories.GetParentRelations(HiveId.Empty), idRoot);
AssertRelationsIdsHaveRoot(uow.Repositories.GetDescendentRelations(HiveId.Empty), idRoot);
AssertRelationsIdsHaveRoot(uow.Repositories.GetChildRelations(HiveId.Empty), idRoot);
AssertRelationsIdsHaveRoot(uow.Repositories.GetAncestorRelations(HiveId.Empty), idRoot);
}
}
/// <summary>
/// Processes a request to update the password for a membership user.
/// </summary>
/// <param name="username">The user to update the password for.</param>
/// <param name="oldPassword">The current password for the specified user.</param>
/// <param name="newPassword">The new password for the specified user.</param>
/// <returns>
/// true if the password was updated successfully; otherwise, false.
/// </returns>
public override bool ChangePassword(string username, string oldPassword, string newPassword)
{
using (var uow = _hive.Create())
{
var user = GetUmbracoUser(_appContext, uow, username, false);
if (user == null)
{
return(false);
}
if (ValidateUserInternal(user, oldPassword))
{
var args = new ValidatePasswordEventArgs(username, newPassword, false);
base.OnValidatingPassword(args);
if (args.Cancel)
{
if (args.FailureInformation != null)
{
throw args.FailureInformation;
}
throw new MembershipPasswordException("Change password canceled due to new password validation failure.");
}
if (!ValidatePassword(newPassword))
{
throw new ArgumentException("Password doesn't meet password strength requirements!");
}
var salt = "";
user.Password = TransformPassword(newPassword, ref salt);
user.PasswordSalt = salt;
user.LastPasswordChangeDate = DateTime.UtcNow;
uow.Repositories.AddOrUpdate(user);
uow.Complete();
return(true);
}
}
return(false);
}
public void GetCompositeEntity_Returns_Correct_Attributes()
{
// Arrange
var childSchema = CreateAndSaveCompositeSchema(AttributeTypeRegistry, ProviderSetup);
CompositeEntitySchema merged = null;
var groupUnitFactory = new GroupUnitFactory(ProviderSetup, childSchema.Id.ToUri(), FakeHiveCmsManager.CreateFakeRepositoryContext(ProviderSetup.FrameworkContext));
using (var uow = groupUnitFactory.Create())
{
merged = uow.Repositories.Schemas.GetComposite<EntitySchema>(childSchema.Id);
}
List<TypedAttribute> attribs;
var entity = MockCompositeEntity(merged, out attribs);
AssignFakeIdsIfPassthrough(ProviderSetup.ProviderMetadata, entity);
Assert.That(entity.Attributes.Count, Is.EqualTo(attribs.Count));
using (var uow = groupUnitFactory.Create())
{
uow.Repositories.AddOrUpdate(entity);
uow.Complete();
}
PostWriteCallback.Invoke();
using (var uow = groupUnitFactory.Create())
{
var reloaded = uow.Repositories.Get<TypedEntity>(entity.Id);
Assert.That(reloaded.EntitySchema.Id.Value, Is.EqualTo(childSchema.Id.Value));
Assert.That(reloaded.Attributes.Count, Is.EqualTo(attribs.Count));
}
}
public void GetCompositeSchema_ReturnsOnlyUniqueAttributeDefinitions()
{
// Arrange
var schema3 = CreateAndSaveCompositeSchema(AttributeTypeRegistry, ProviderSetup);
// Assert
var groupUnitFactory = new GroupUnitFactory(ProviderSetup, schema3.Id.ToUri(), FakeHiveCmsManager.CreateFakeRepositoryContext(ProviderSetup.FrameworkContext));
using (var uow = groupUnitFactory.Create())
{
var merged = uow.Repositories.Schemas.GetComposite<EntitySchema>(schema3.Id);
var defs = merged.AttributeDefinitions.Select(x => x.Alias).ToArray();
var inheritedDefs = merged.InheritedAttributeDefinitions.Select(x => x.Alias).ToArray();
Assert.That(defs, Is.Unique);
Assert.That(inheritedDefs, Is.Unique);
Assert.That(defs.Length, Is.GreaterThan(0));
Assert.That(inheritedDefs.Length, Is.GreaterThan(0));
Assert.That(inheritedDefs, Is.Not.SubsetOf(defs));
Assert.That(defs, Is.Not.SubsetOf(inheritedDefs));
}
}
public void GetComposite_Returns_Composite_Schema()
{
// Arrange
var schema3 = CreateAndSaveCompositeSchema(AttributeTypeRegistry, ProviderSetup);
// Assert
var groupUnitFactory = new GroupUnitFactory(ProviderSetup, schema3.Id.ToUri(), FakeHiveCmsManager.CreateFakeRepositoryContext(ProviderSetup.FrameworkContext));
using (var uow = groupUnitFactory.Create())
{
var merged = uow.Repositories.Schemas.GetComposite<EntitySchema>(schema3.Id);
Assert.IsTrue(merged.Id.Value == schema3.Id.Value);
Assert.AreEqual(2, merged.AttributeGroups.Count);
Assert.AreEqual(2, merged.AttributeDefinitions.Count);
Assert.AreEqual(4, merged.InheritedAttributeGroups.Count);
Assert.AreEqual(3, merged.InheritedAttributeDefinitions.Count);
Assert.AreEqual("<test />", merged.XmlConfiguration.ToString());
Assert.That(merged.AllAttributeGroups.Count(), Is.EqualTo(merged.AttributeGroups.Count + merged.InheritedAttributeGroups.Count));
Assert.That(merged.AllAttributeDefinitions.Count(), Is.EqualTo(merged.AttributeDefinitions.Count + merged.InheritedAttributeDefinitions.Count));
Assert.IsTrue(merged.InheritedAttributeGroups.Any(x => x.Alias == "empty-group"));
}
}
public void WhenEntityIsAdded_WhenCacheWatcherTaskIsRegistered_EntityIsPutInScopedCache()
{
// Arrange
_frameworkContext.TaskManager.AddTask(TaskTriggers.Hive.PostAddOrUpdateOnUnitComplete, () => new CacheWatcherTask(_frameworkContext), true);
// Act
using (var uow = _groupUnitFactory.Create())
{
var anything = HiveModelCreationHelper.MockTypedEntity();
// Cause the task to be fired
uow.Repositories.AddOrUpdate(anything);
uow.Complete();
// Assert the task has been fired
Assert.That(_unitScopedCache.GetOrCreate(anything.Id.ToString(), () => null), Is.Not.Null);
}
}
public override IDictionary <string, object> GetSerializedValue()
{
var val = new Dictionary <string, object>();
//generate an id if we need one
if (MediaId == Guid.Empty)
{
MediaId = Guid.NewGuid();
}
//add the media id to be saved
val.Add("MediaId", MediaId.ToString("N"));
// Check to see if we should delete the current file
// either becuase remove file is checked, or we have a replacement file
if (RemoveFile || HasFile())
{
if (!Value.IsNullValueOrEmpty())
{
// delete entire property folder (deletes image and any thumbnails stored)
//var folderHiveId = HiveId.Parse("storage://file-uploader/string/" + MediaId.ToString("N"));
var folderHiveId = new HiveId("storage", "file-uploader", new HiveIdValue(MediaId.ToString("N")));
using (var uow = _hive.Create())
{
uow.Repositories.Delete <File>(Value); // Must delete file entity so that relations are deleted
uow.Repositories.Delete <File>(folderHiveId);
uow.Complete();
}
}
}
// If we've received a File from the binding, we need to save it
if (HasFile())
{
// Open a new unit of work to write the file
using (var uow = _hive.Create())
{
// Create main file
var file = new File
{
RootedPath = MediaId.ToString("N") + "/" + Path.GetFileName(NewFile.FileName).Replace(" ", "")
};
var stream = NewFile.InputStream;
if (stream.CanRead && stream.CanSeek)
{
stream.Seek(0, SeekOrigin.Begin);
using (var mem = new MemoryStream())
{
stream.CopyTo(mem);
file.ContentBytes = mem.ToArray();
}
}
uow.Repositories.AddOrUpdate(file);
// Create thumbnails (TODO: Need to encapsulate this so it can be reused in other places?)
if (file.IsImage())
{
var img = Image.FromFile(file.RootedPath);
// Create default thumbnail
CreateThumbnail(uow, file, img, MediaId.ToString("N"), 100);
// Create additional thumbnails
if (!string.IsNullOrEmpty(PreValueModel.Sizes))
{
var sizes = PreValueModel.Sizes.Split(',');
foreach (var size in sizes)
{
var intSize = 0;
if (Int32.TryParse(size, out intSize))
{
CreateThumbnail(uow, file, img, MediaId.ToString("N"), intSize);
}
}
}
}
uow.Complete();
val.Add("Value", file.Id);
}
}
else if (!Value.IsNullValueOrEmpty() && !RemoveFile)
{
val.Add("Value", Value);
}
else
{
val.Add("Value", HiveId.Empty);
}
return(val);
}
