public void DataTypeEditorControllerTests_PreValueModel_Data_Will_Be_Updated_With_Posted_Values()
{
//Arrange
//create data type in persistence layer
var propEditor = new MandatoryPropertyEditor();
var dataTypeEntity = HiveModelCreationHelper.CreateAttributeType("test", "Test", "");
dataTypeEntity.RenderTypeProvider = propEditor.Id.ToString();
UmbracoApplicationContext.AddPersistenceData(dataTypeEntity);
var controller = new DataTypeEditorController(GetBackOfficeRequestContext());
controller.InjectDependencies(new Dictionary <string, string>(), new Dictionary <string, string>
{
{ "PreValueEditorModel.Value", "hello" }
}, GetBackOfficeRequestContext());
//Act
var result = controller.EditForm(dataTypeEntity.Id) as ViewResult;
//Assert
Assert.IsTrue(controller.ModelState.IsValidField("PreValueEditorModel.Value"));
Assert.AreEqual("hello", controller.ModelState["PreValueEditorModel.Value"].Value.AttemptedValue);
}
public void DataTypeEditorControllerTests_Invalid_Model_State_When_Missing_Required_Values()
{
//Arrange
//create data type in persistence layer
var propEditor = new MandatoryPropertyEditor();
var dataTypeEntity = HiveModelCreationHelper.CreateAttributeType("test", "Test", "");
dataTypeEntity.RenderTypeProvider = propEditor.Id.ToString();
UmbracoApplicationContext.AddPersistenceData(dataTypeEntity);
var controller = new DataTypeEditorController(GetBackOfficeRequestContext());
controller.InjectDependencies(new Dictionary <string, string>(), new Dictionary <string, string>
{
{ "Name", "" },
{ "PropertyEditorId", "" }
}, GetBackOfficeRequestContext());
//Act
var result = controller.EditForm(dataTypeEntity.Id) as ViewResult;
//Assert
Assert.IsFalse(controller.ModelState.IsValidField("Name"));
Assert.IsFalse(controller.ModelState.IsValidField("PropertyEditorId"));
}
public void DataTypeEditorControllerTests_All_Standard_Values_Bound()
{
//Arrange
//create data type in persistence layer
var propEditor = new MandatoryPropertyEditor();
var dataTypeEntity = HiveModelCreationHelper.CreateAttributeType("test", "Test", "");
dataTypeEntity.RenderTypeProvider = propEditor.Id.ToString();
UmbracoApplicationContext.AddPersistenceData(dataTypeEntity);
var controller = new DataTypeEditorController(GetBackOfficeRequestContext());
controller.InjectDependencies(new Dictionary <string, string>(), new Dictionary <string, string>
{
{ "Name", "Hello World" },
{ "PropertyEditorId", "5A379AF0-0256-4BE9-9D01-F149603DB257" }
}, GetBackOfficeRequestContext());
//Act
var result = controller.EditForm(dataTypeEntity.Id) as ViewResult;
var modelState = controller.ModelState;
//Assert
Assert.AreEqual("Hello World", controller.ModelState["Name"].Value.AttemptedValue);
Assert.IsTrue(controller.ModelState.IsValidField("Name"));
Assert.AreEqual("5A379AF0-0256-4BE9-9D01-F149603DB257", controller.ModelState["PropertyEditorId"].Value.AttemptedValue);
Assert.IsTrue(controller.ModelState.IsValidField("PropertyEditorId"));
}
public void DataTypeEditorControllerTests_Create_New_Wizard_Step_Bound_And_Validated()
{
//Arrange
var propEditor = new MandatoryPropertyEditor();
var createModel = new CreateDataTypeModel {
Name = "test", PropertyEditorId = propEditor.Id
};
//create data type in persistence layer
var dataTypeEntity = HiveModelCreationHelper.CreateAttributeType("test", "Test", "");
dataTypeEntity.RenderTypeProvider = propEditor.Id.ToString();
UmbracoApplicationContext.AddPersistenceData(dataTypeEntity);
var controller = new DataTypeEditorController(GetBackOfficeRequestContext());
controller.InjectDependencies(GetBackOfficeRequestContext());
//Act
var result = (ViewResult)controller.CreateNewForm(createModel);
var model = (CreateDataTypeModel)result.Model;
//Assert
Assert.IsTrue(controller.ModelState.IsValidField("Name"));
Assert.IsTrue(controller.ModelState.IsValidField("PropertyEditorId"));
Assert.AreEqual("test", model.Name);
Assert.AreEqual(propEditor.Id, model.PropertyEditorId);
}
public void CanSerializeThenDeserializeVerionedTypedEntity()
{
Revision <TypedEntity> revision = HiveModelCreationHelper.MockVersionedTypedEntity(true);
var result = SerializationService.ToStream(revision);
var item = SerializationService.ToStream(revision.Item);
var metadata = SerializationService.ToStream(revision.MetaData);
Assert.That(result.Success, Is.True);
Assert.That(result.ResultStream, Is.Not.Null);
Assert.That(item.Success, Is.True);
Assert.That(item.ResultStream, Is.Not.Null);
Assert.That(metadata.Success, Is.True);
Assert.That(metadata.ResultStream, Is.Not.Null);
var objTE = SerializationService.FromStream(item.ResultStream, typeof(TypedEntity));
var objRD = SerializationService.FromStream(metadata.ResultStream, typeof(RevisionData));
var objR = SerializationService.FromStream(result.ResultStream, typeof(Revision <TypedEntity>));
Assert.That(objTE, Is.Not.Null);
Assert.That(objRD, Is.Not.Null);
Assert.That(objR, Is.Not.Null);
Assert.That(objR.GetType(), Is.EqualTo(typeof(Revision <TypedEntity>)));
Assert.That(((Revision <TypedEntity>)objR).Item, Is.Not.Null);
Assert.That(((Revision <TypedEntity>)objR).MetaData, Is.Not.Null);
Assert.That(((Revision <TypedEntity>)objR).Item.Attributes.Count, Is.EqualTo(revision.Item.Attributes.Count));
}
public void CanSerializeThenDeserializeTypedEntity()
{
TypedEntity entity = HiveModelCreationHelper.MockTypedEntity(true);
var graph = entity.GetAllIdentifiableItems().Reverse().ToArray();
var testTypes = new List <object>();
foreach (var referenceByHiveId in graph.WhereNotNull())
{
object test;
try
{
test = SerializeDeserialize(referenceByHiveId);
Assert.NotNull(test);
testTypes.Add(test);
}
catch (Exception ex)
{
throw;
}
}
var obj = SerializeDeserialize(entity);
Assert.That(obj, Is.Not.Null);
Assert.That(obj.GetType(), Is.EqualTo(typeof(TypedEntity)));
Assert.That(((TypedEntity)obj).Id, Is.EqualTo(entity.Id));
Assert.That(((TypedEntity)obj).Attributes.Count, Is.EqualTo(entity.Attributes.Count));
Assert.That(((TypedEntity)obj).AttributeGroups.Count(), Is.EqualTo(entity.AttributeGroups.Count()));
}
public void DataTypeEditorControllerTests_DataType_Saved()
{
//Arrange
//create data type in persistence layer
var propEditor = new MandatoryPropertyEditor();
var dataTypeEntity = HiveModelCreationHelper.CreateAttributeType("test", "Test", "");
dataTypeEntity.RenderTypeProvider = propEditor.Id.ToString();
UmbracoApplicationContext.AddPersistenceData(dataTypeEntity);
var controller = new DataTypeEditorController(GetBackOfficeRequestContext());
controller.InjectDependencies(new Dictionary <string, string>(), new Dictionary <string, string>
{
{ "Name", "Hello World" },
{ "PropertyEditorId", "5A379AF0-0256-4BE9-9D01-F149603DB257" },
{ "submit.Save", "Save" } //set save flag
}, GetBackOfficeRequestContext(), false);
//Act
var result = controller.EditForm(dataTypeEntity.Id);
//Assert
Assert.IsTrue(result is RedirectToRouteResult);
using (var uow = UmbracoApplicationContext.Hive.OpenReader <IContentStore>())
{
var latestEntity = uow.Repositories.Schemas.Get <AttributeType>(dataTypeEntity.Id);
Assert.IsTrue(dataTypeEntity.UtcModified < latestEntity.UtcModified);
}
}
public void ReadWriteRepositoryUnitOfWorkTests_UncommitedUnitOfWork_DoesNotUpdateDataStore()
{
//arrange
var writer = CreateReadWritter();
//act
var id = new HiveId(Guid.NewGuid());
using (var uow = writer.CreateReadWriteUnitOfWork())
{
var entity = HiveModelCreationHelper.CreateAttributeType("alias", "name", "description");
entity.Id = id;
uow.ReadWriteRepository.AddOrUpdate(entity);
}
_sessionForTest.Clear();
//assert
using (var uow = writer.CreateReadWriteUnitOfWork())
{
Assert.IsNull(uow.ReadWriteRepository.GetEntity <AttributeType>(id));
}
writer.Dispose();
}
public void CanAddAtLeast300ItemsPerSecond()
{
var watch = new Stopwatch();
TypedEntity[] itemsToAdd = new TypedEntity[500];
for (int i = 0; i < 300; i++)
{
var item = HiveModelCreationHelper.MockTypedEntity(true);
itemsToAdd[i] = item;
}
watch.Start();
for (int i = 0; i < 300; i++)
{
CacheProvider.AddOrChangeValue(CacheKey.Create("Item " + i), itemsToAdd[i]);
}
watch.Stop();
var writeElapsed = watch.Elapsed;
watch.Reset();
watch.Start();
for (int i = 0; i < 300; i++)
{
var cacheKey = CacheKey.Create("Item " + i);
var item = CacheProvider.Get <TypedEntity>(cacheKey);
Assert.That(item, Is.Not.Null);
}
watch.Stop();
var readElapsed = watch.Elapsed;
LogHelper.TraceIfEnabled <AbstractCacheProviderFixture>("Write Took (s): " + writeElapsed.TotalSeconds);
LogHelper.TraceIfEnabled <AbstractCacheProviderFixture>("Read Took (s): " + readElapsed.TotalSeconds);
Assert.That(writeElapsed, Is.LessThan(TimeSpan.FromSeconds(1)));
Assert.That(readElapsed, Is.LessThan(TimeSpan.FromSeconds(1)));
}
protected EntitySchema CreateNewSchema(PropertyEditor propEditor = null, string alias = "test")
{
if (propEditor == null)
{
propEditor = new MandatoryPropertyEditor();
}
var attributeType = HiveModelCreationHelper.CreateAttributeType("test", "test", "test");
attributeType.RenderTypeProvider = propEditor.Id.ToString();
UmbracoApplicationContext.AddPersistenceData(attributeType);
var schema = HiveModelCreationHelper.MockEntitySchema(alias, alias);
schema.TryAddAttributeDefinition(HiveModelCreationHelper.CreateAttributeDefinition("siteName", "Site Name", "", attributeType, null));
schema.TryAddAttributeDefinition(HiveModelCreationHelper.CreateAttributeDefinition("bodyText", "Body Text", "", attributeType, null));
//set all attribute defs to the attribute type
schema.AttributeDefinitions.Where(x => !x.Alias.StartsWith("system-")).ForEach(x => x.AttributeType = attributeType);
schema.RelationProxies.EnlistParent(new ContentRootSchema(), FixedRelationTypes.DefaultRelationType, 0);
UmbracoApplicationContext.AddPersistenceData(schema);
return(schema);
}
public void Adding_AttributeDefinitions_WithoutIds_AddsToGroupsOnSchema()
{
// Arrange
var attributionSchema = HiveModelCreationHelper.CreateEntitySchema("test", "Test", new AttributeDefinition[] { });
Assert.AreEqual(0, attributionSchema.AttributeGroups.Count);
var nameNameType = _attributeTypeRegistry.GetAttributeType(NodeNameAttributeType.AliasValue);
var fileUploadType = _attributeTypeRegistry.GetAttributeType(FileUploadAttributeType.AliasValue);
// Act & Assert
attributionSchema.AttributeDefinitions.Add(new AttributeDefinition(NodeNameAttributeDefinition.AliasValue, "Node Name")
{
//Id = new HiveId("mi-name".EncodeAsGuid()),
AttributeType = nameNameType,
AttributeGroup = FixedGroupDefinitions.GeneralGroup,
Ordinal = 0
});
Assert.AreEqual(1, attributionSchema.AttributeDefinitions.Count);
Assert.AreEqual(1, attributionSchema.AttributeGroups.Count);
CollectionAssert.Contains(attributionSchema.AttributeGroups, FixedGroupDefinitions.GeneralGroup);
attributionSchema.AttributeDefinitions.Add(new AttributeDefinition("uploadedFile", "Uploaded File")
{
//Id = new HiveId("mi-upload".EncodeAsGuid()),
AttributeType = fileUploadType,
AttributeGroup = FixedGroupDefinitions.FileProperties,
Ordinal = 0
});
Assert.AreEqual(2, attributionSchema.AttributeDefinitions.Count);
Assert.AreEqual(2, attributionSchema.AttributeGroups.Count);
CollectionAssert.Contains(attributionSchema.AttributeGroups, FixedGroupDefinitions.GeneralGroup);
CollectionAssert.Contains(attributionSchema.AttributeGroups, FixedGroupDefinitions.FileProperties);
}
public void WhenEntityIsAdded_AndTaskCausesCancellation_EntityIsNotAdded()
{
// Arrange
var preAddMock = Substitute.For <AbstractTask>(_frameworkContext);
preAddMock.When(x => x.Execute(Arg.Any <TaskExecutionContext>())).Do(x => x.Arg <TaskExecutionContext>().Cancel = true);
var postAddMock = Substitute.For <AbstractTask>(_frameworkContext);
// Act
_frameworkContext.TaskManager.AddTask(TaskTriggers.Hive.PreAddOrUpdate, () => preAddMock, true);
_frameworkContext.TaskManager.AddTask(TaskTriggers.Hive.PostAddOrUpdate, () => postAddMock, true);
using (var uow = _groupUnitFactory.Create())
{
var anything = HiveModelCreationHelper.MockTypedEntity();
// Check the pre-add and post-add tasks have not yet been fired
DoesNotThrow(() => preAddMock.Received(0).Execute(Arg.Any <TaskExecutionContext>()));
DoesNotThrow(() => postAddMock.Received(0).Execute(Arg.Any <TaskExecutionContext>()));
// Cause the pre-add task to be fired
uow.Repositories.AddOrUpdate(anything);
// Assert the pre-add task has been fired, and the post-add task is not fired
DoesNotThrow(() => preAddMock.Received(1).Execute(Arg.Any <TaskExecutionContext>()), "Call was not received 1 times");
DoesNotThrow(() => postAddMock.Received(0).Execute(Arg.Any <TaskExecutionContext>()));
}
}
public void WhenRelationIsAdded_ViaAddRelationMethod_PreAndPostRelationAddedBeforeUnitComplete_TasksAreTriggered()
{
// Arrange
var preEventMock = Substitute.For <AbstractTask>(_frameworkContext);
var postEventMock = Substitute.For <AbstractTask>(_frameworkContext);
// Act
_frameworkContext.TaskManager.AddTask(TaskTriggers.Hive.Relations.PreRelationAdded, () => preEventMock, true);
_frameworkContext.TaskManager.AddTask(TaskTriggers.Hive.Relations.PostRelationAdded, () => postEventMock, true);
using (var uow = _groupUnitFactory.Create())
{
var parentAnything = HiveModelCreationHelper.MockTypedEntity();
var childAnything = HiveModelCreationHelper.MockTypedEntity();
// Check the task has not yet been fired
DoesNotThrow(() => preEventMock.Received(0).Execute(Arg.Any <TaskExecutionContext>()));
DoesNotThrow(() => postEventMock.Received(0).Execute(Arg.Any <TaskExecutionContext>()));
// Add items
uow.Repositories.AddOrUpdate(parentAnything);
uow.Repositories.AddOrUpdate(childAnything);
// Add relation and cause the task to be fired
uow.Repositories.AddRelation(parentAnything, childAnything, FixedRelationTypes.DefaultRelationType, 0);
// Assert the task has been fired once for the group and once for the repository (handler can check source if they only want to act once)
DoesNotThrow(() => preEventMock.Received(2).Execute(Arg.Any <TaskExecutionContext>()), "Pre-Call was not received 2 times");
DoesNotThrow(() => postEventMock.Received(2).Execute(Arg.Any <TaskExecutionContext>()), "Post-Call was not received 2 times");
}
}
public void WhenEntityIsAdded_AndUnitCompletionTaskCausesCancellation_UnitIsRolledBack()
{
// Arrange
var preAddMock = Substitute.For <AbstractTask>(_frameworkContext);
preAddMock.When(x => x.Execute(Arg.Any <TaskExecutionContext>())).Do(x => x.Arg <TaskExecutionContext>().Cancel = true);
// Act
_frameworkContext.TaskManager.AddTask(TaskTriggers.Hive.PreAddOrUpdateOnUnitComplete, () => preAddMock, true);
using (var uow = _groupUnitFactory.Create())
{
var anything = HiveModelCreationHelper.MockTypedEntity();
// Check the task has not yet been fired
DoesNotThrow(() => preAddMock.Received(0).Execute(Arg.Any <TaskExecutionContext>()));
// Cause the task to be fired
uow.Repositories.AddOrUpdate(anything);
// Check the task has still not yet been fired
DoesNotThrow(() => preAddMock.Received(0).Execute(Arg.Any <TaskExecutionContext>()));
// Complete the unit
Assert.That(uow.WasAbandoned, Is.False);
uow.Complete();
// Assert
// Check the task has been fired
DoesNotThrow(() => preAddMock.Received(1).Execute(Arg.Any <TaskExecutionContext>()), "Task was not executed");
// Check the unit was then rolled back
Assert.That(uow.WasAbandoned, Is.True);
}
}
public void OnceUnitOfWorkCommitted_SchemaDataStoreUpdated()
{
//Arrange
var setup = new NhibernateTestSetupHelper();
HiveId id;
//Act
using (var writer = setup.ProviderSetup.UnitFactory.Create())
{
var entity = HiveModelCreationHelper.CreateAttributeType("alias", "name", "description");
writer.EntityRepository.Schemas.AddOrUpdate(entity);
writer.Complete();
id = entity.Id;
Assert.IsNotNull(writer.EntityRepository.Schemas.Get <AttributeType>(id));
}
setup.SessionForTest.Clear();
//assert
using (var writer = setup.ProviderSetup.UnitFactory.Create())
{
Assert.IsNotNull(writer.EntityRepository.Schemas.Get <AttributeType>(id));
}
}
public void ReadWriteRepositoryUnitOfWorkTests_OnceUnitOfWorkCommitted_DataStoreUpdated()
{
//Arrange
var writer = CreateReadWritter();
//Act
HiveId id;
using (var uow = writer.CreateReadWriteUnitOfWork())
{
var entity = HiveModelCreationHelper.CreateAttributeType("alias", "name", "description");
uow.ReadWriteRepository.AddOrUpdate(entity);
uow.Commit();
id = entity.Id;
}
_sessionForTest.Clear();
//assert
using (var uow = writer.CreateReadWriteUnitOfWork())
{
Assert.IsNotNull(uow.ReadWriteRepository.GetEntity <AttributeType>(id));
}
writer.Dispose();
}
public void WhenRelationIsAdded_ViaRelationProxies_PreAndPostRelationAddedBeforeUnitComplete_TasksAreTriggered()
{
// Arrange
var preEventMock = Substitute.For <AbstractTask>(_frameworkContext);
var postEventMock = Substitute.For <AbstractTask>(_frameworkContext);
// Act
_frameworkContext.TaskManager.AddTask(TaskTriggers.Hive.Relations.PreRelationAdded, () => preEventMock, true);
_frameworkContext.TaskManager.AddTask(TaskTriggers.Hive.Relations.PostRelationAdded, () => postEventMock, true);
using (var uow = _groupUnitFactory.Create())
{
var parentAnything = HiveModelCreationHelper.MockTypedEntity();
var childAnything = HiveModelCreationHelper.MockTypedEntity();
// Check the task has not yet been fired
DoesNotThrow(() => preEventMock.Received(0).Execute(Arg.Any <TaskExecutionContext>()));
DoesNotThrow(() => postEventMock.Received(0).Execute(Arg.Any <TaskExecutionContext>()));
// Add items
parentAnything.RelationProxies.EnlistChild(childAnything, FixedRelationTypes.DefaultRelationType);
uow.Repositories.AddOrUpdate(parentAnything);
uow.Repositories.AddOrUpdate(childAnything);
// Complete the uow which should raise the task as relation proxies aren't added until uow completion
uow.Complete();
// Assert the task has been fired
DoesNotThrow(() => preEventMock.Received(1).Execute(Arg.Any <TaskExecutionContext>()), "Pre-Call was not received 1 times");
DoesNotThrow(() => postEventMock.Received(1).Execute(Arg.Any <TaskExecutionContext>()), "Post-Call was not received 1 times");
}
}
public void ReadWriteRepositoryUnitOfWorkTests_AddOneRemoveOne_EntityDoesntExist()
{
//Arrange
var writer = CreateReadWritter();
HiveId id;
using (var uow = writer.CreateReadWriteUnitOfWork())
{
var entity = HiveModelCreationHelper.CreateAttributeType("alias", "name", "description");
uow.ReadWriteRepository.AddOrUpdate(entity);
uow.Commit();
id = entity.Id;
}
_sessionForTest.Clear();
//Act
using (var uow = writer.CreateReadWriteUnitOfWork())
{
uow.ReadWriteRepository.Delete <AttributeType>(id);
uow.Commit();
}
//assert
using (var uow = writer.CreateReadWriteUnitOfWork())
{
Assert.IsNull(uow.ReadWriteRepository.GetEntity <AttributeType>(id));
}
writer.Dispose();
}
public void IfUnitOfWorkUncomitted_RevisionDataStoreNotUpdated()
{
//Arrange
var setup = new NhibernateTestSetupHelper();
HiveId id;
HiveId revisionId;
//act
using (var uow = setup.ProviderSetup.UnitFactory.Create())
{
var entity = HiveModelCreationHelper.MockTypedEntity(false);
var revision = new Revision <TypedEntity>(entity);
uow.EntityRepository.Revisions.AddOrUpdate(revision);
id = revision.Item.Id;
revisionId = revision.MetaData.Id;
}
setup.SessionForTest.Clear();
//assert
using (var uow = setup.ProviderSetup.UnitFactory.Create())
{
Assert.AreNotEqual(id, HiveId.Empty);
Assert.AreNotEqual(revisionId, HiveId.Empty);
Assert.IsNull(uow.EntityRepository.Revisions.Get <TypedEntity>(id, revisionId));
}
}
public void From_TypedEntity_With_Relations_To_NodeVersion()
{
//Arrange
var mapper = new ManualMapper(new FakeLookupHelper(), new FakeHiveProvider());
mapper.Configure();
var entityParent = HiveModelCreationHelper.MockTypedEntity(false);
entityParent.Id = HiveId.ConvertIntToGuid(1);
var entityChild = HiveModelCreationHelper.MockTypedEntity(false);
entityChild.Id = HiveId.ConvertIntToGuid(2);
entityParent.Relations.Add(FixedRelationTypes.ContentTreeRelationType, entityChild);
//Act
var resultParent = mapper.Map <TypedEntity, NodeVersion>(entityParent);
//var resultChild = mapper.Map<TypedEntity, NodeVersion>(entityChild);
//Assert
Assert.AreEqual(entityParent.EntitySchema.Alias, resultParent.AttributeSchemaDefinition.Alias);
Assert.AreEqual(entityParent.Attributes.Count, resultParent.Attributes.Count);
Assert.AreEqual(entityParent.Relations.Count(), resultParent.Node.OutgoingRelations.Count);
Assert.AreEqual(entityParent.Relations.Single().Source.Id, resultParent.Node.OutgoingRelations.First().StartNode.Id);
Assert.AreEqual(entityParent.Relations.Single().Destination.Id, resultParent.Node.OutgoingRelations.First().EndNode.Id);
//BUG: If you call entityChild.Relations.Count() an infinite loop occurs :(
//Assert.AreEqual(entityChild.Relations.Count(), resultChild.Node.IncomingRelations.Count);
}
public void OnceUnitOfWorkCommitted_RevisionDataStoreUpdated()
{
//Arrange
var setup = new NhibernateTestSetupHelper();
HiveId id;
HiveId revisionId;
//Act
using (var writer = setup.ProviderSetup.UnitFactory.Create())
{
//var entitySchema = HiveModelCreationHelper.MockEntitySchema("blah-alias", "blah-name");
var entity = HiveModelCreationHelper.MockTypedEntity(false);
var revision = new Revision <TypedEntity>(entity);
writer.EntityRepository.Revisions.AddOrUpdate(revision);
writer.Complete();
id = revision.Item.Id;
revisionId = revision.MetaData.Id;
Assert.IsNotNull(writer.EntityRepository.Revisions.Get <TypedEntity>(id, revisionId));
}
setup.SessionForTest.Clear();
//assert
using (var writer = setup.ProviderSetup.UnitFactory.Create())
{
Assert.AreNotEqual(id, Guid.Empty);
Assert.IsNotNull(writer.EntityRepository.Revisions.Get <TypedEntity>(id, revisionId));
}
}
public void Content_LevelExtensionMethod()
{
// Arrange
var newGuid = Guid.NewGuid();
var newGuidRedHerring = Guid.NewGuid();
var childGuid = new HiveId(Guid.NewGuid());
var child1_1Guid = new HiveId(Guid.NewGuid());
var child1_2Guid = new HiveId(Guid.NewGuid());
var child1_3Guid = new HiveId(Guid.NewGuid());
var child1_4Guid = new HiveId(Guid.NewGuid());
var child1_1_1Guid = new HiveId(Guid.NewGuid());
var child1_1_2Guid = new HiveId(Guid.NewGuid());
var child2Guid = new HiveId(Guid.NewGuid());
var parent = HiveModelCreationHelper.SetupTestData(newGuid, newGuidRedHerring, this.Setup.ProviderSetup);
var child1 = this.AddChildNodeWithId(parent, childGuid, 1);
var child1_1 = this.AddChildNodeWithId(child1, child1_1Guid, 1);
var child1_2 = this.AddChildNodeWithId(child1, child1_2Guid, 2);
var child1_3 = this.AddChildNodeWithId(child1, child1_3Guid, 3);
var child1_4 = this.AddChildNodeWithId(child1, child1_4Guid, 4);
var child1_1_1 = this.AddChildNodeWithId(child1_1, child1_1_1Guid, 1);
var child1_1_2 = this.AddChildNodeWithId(child1_1, child1_1_2Guid, 1);
var child2 = this.AddChildNodeWithId(parent, child2Guid, 2);
var child1AsContent = this.HiveManager.FrameworkContext.TypeMappers.Map <Content>(child1);
var child1_1_2AsContent = this.HiveManager.FrameworkContext.TypeMappers.Map <Content>(child1_1_2);
var child1Path = child1AsContent.GetPath(this.HiveManager);
Assert.That(child1Path.Count(), Is.EqualTo(2), "Path was: " + child1Path.ToString() + ", parent id is: " + parent.Id);
Assert.That(child1Path.Level, Is.EqualTo(2));
var child1_1_2Path = child1_1_2AsContent.GetPath(this.HiveManager);
Assert.That(child1_1_2Path.Count(), Is.EqualTo(4), "Path was: " + child1_1_2Path.ToString() + ", parent id is: " + parent.Id);
}
public void AddOneRemoveOne_EntityDoesntExist()
{
//Arrange
var setup = new NhibernateTestSetupHelper();
HiveId id;
using (var uow = setup.ProviderSetup.UnitFactory.Create())
{
var entity = HiveModelCreationHelper.CreateAttributeType("alias", "name", "description");
uow.EntityRepository.Schemas.AddOrUpdate(entity);
uow.Complete();
id = entity.Id;
}
setup.SessionForTest.Clear();
//Act
using (var uow = setup.ProviderSetup.UnitFactory.Create())
{
uow.EntityRepository.Schemas.Delete <AttributeType>(id);
uow.Complete();
}
//assert
using (var uow = setup.ProviderSetup.UnitFactory.Create())
{
Assert.IsNull(uow.EntityRepository.Schemas.Get <AttributeType>(id));
}
}
public void WhenEntityIsAdded_PostAddOrUpdateAfterUnitComplete_TaskIsTriggered()
{
// Arrange
var eventMock = Substitute.For <AbstractTask>(_frameworkContext);
// Act
_frameworkContext.TaskManager.AddTask(TaskTriggers.Hive.PostAddOrUpdateOnUnitComplete, () => eventMock, true);
using (var uow = _groupUnitFactory.Create())
{
var anything = HiveModelCreationHelper.MockTypedEntity();
// Check the task has not yet been fired
DoesNotThrow(() => eventMock.Received(0).Execute(Arg.Any <TaskExecutionContext>()));
// Cause the task to be fired
uow.Repositories.AddOrUpdate(anything);
// Check the task has still not yet been fired
DoesNotThrow(() => eventMock.Received(0).Execute(Arg.Any <TaskExecutionContext>()));
// Complete the unit
uow.Complete();
// Assert the task has been fired
DoesNotThrow(() => eventMock.Received(1).Execute(Arg.Any <TaskExecutionContext>()), "Call was not received 1 times");
}
}
public void Multiple_NewEntities_WithEmptyIds_AreNotEqual()
{
// Arrange
var entity1 = HiveModelCreationHelper.MockTypedEntity(false);
var entity2 = HiveModelCreationHelper.MockTypedEntity(false);
// Assert
Assert.AreEqual(HiveId.Empty, entity1.Id);
Assert.AreEqual(HiveId.Empty, entity2.Id);
Assert.AreNotEqual(entity1, entity2);
}
public void RepositoryExtensionsTests_GetIdPaths_SimpleMultiInheritance()
{
/*
* - Root
* - Child 1
* - Grandchild
* - Child 2
* - Grandchild
*/
// Arrange
var root = HiveModelCreationHelper.MockTypedEntity();
var child1 = HiveModelCreationHelper.MockTypedEntity();
var child2 = HiveModelCreationHelper.MockTypedEntity();
var grandchild = HiveModelCreationHelper.MockTypedEntity();
AssignFakeIdsIfPassthrough(ProviderSetup.ProviderMetadata, root, child1, child2, grandchild);
// Act
using (var uow = ProviderSetup.UnitFactory.Create())
{
// Add entities
uow.EntityRepository.AddOrUpdate(root);
uow.EntityRepository.AddOrUpdate(child1);
uow.EntityRepository.AddOrUpdate(child2);
uow.EntityRepository.AddOrUpdate(grandchild);
// Add all relations
uow.EntityRepository.AddRelation(root, child1, FixedRelationTypes.DefaultRelationType, 0);
uow.EntityRepository.AddRelation(root, child2, FixedRelationTypes.DefaultRelationType, 0);
uow.EntityRepository.AddRelation(child1, grandchild, FixedRelationTypes.DefaultRelationType, 1);
uow.EntityRepository.AddRelation(child2, grandchild, FixedRelationTypes.DefaultRelationType, 2);
uow.Complete();
}
// Assert
using (var uow = ReadonlyProviderSetup.ReadonlyUnitFactory.CreateReadonly())
{
var paths = uow.EntityRepository.GetEntityPaths(grandchild.Id, FixedRelationTypes.DefaultRelationType);
Assert.IsTrue(paths.DestinationId == grandchild.Id);
Assert.IsTrue(paths.Count() == 2);
Assert.IsTrue(paths[0].Count() == 3);
Assert.IsTrue(paths[0][0] == root.Id);
Assert.IsTrue(paths[0][1] == child1.Id);
Assert.IsTrue(paths[0][2] == grandchild.Id);
Assert.IsTrue(paths[1].Count() == 3);
Assert.IsTrue(paths[1][0] == root.Id);
Assert.IsTrue(paths[1][1] == child2.Id);
Assert.IsTrue(paths[1][2] == grandchild.Id);
}
}
public void AddingItemsManually_AsParent_CountIsCorrect()
{
// Arrange
var disconnectedParent = HiveModelCreationHelper.MockTypedEntity();
var disconnectedChild = HiveModelCreationHelper.MockTypedEntity();
var rpc = new RelationProxyCollection(disconnectedChild);
// Act
rpc.EnlistParent(disconnectedParent, FixedRelationTypes.DefaultRelationType);
// Assert
Assert.AreEqual(1, rpc.Count());
Assert.AreEqual(1, rpc.GetManualProxies().Count());
}
public void QueryAll_WithEntitySchemaAliasCriteria_StaticLinq_AsTypedEntity()
{
// Arrange
var newGuid = Guid.NewGuid();
var newGuidRedHerring = Guid.NewGuid();
HiveModelCreationHelper.SetupTestData(newGuid, newGuidRedHerring, this.Setup.ProviderSetup);
// Act
var firstItem = RenderViewModelQueryExtensions.QueryAll <TypedEntity>(this.HiveManager).FirstOrDefault(x => x.EntitySchema.Alias == "redherring-schema");
// Assert
Assert.That(firstItem, Is.Not.Null);
}
public void CanSerializeThenDeserializeAttributeGroup()
{
AttributeGroup groupDef = HiveModelCreationHelper.CreateAttributeGroup("attrGroupTest", "AttrGropTest", 0, true);
var result = SerializationService.ToStream(groupDef);
Assert.That(result.Success, Is.True);
Assert.That(result.ResultStream, Is.Not.Null);
object obj = SerializationService.FromStream(result.ResultStream, typeof(AttributeGroup));
Assert.That(obj, Is.Not.Null);
Assert.That(obj.GetType(), Is.EqualTo(typeof(AttributeGroup)));
}
public void Get_Set_String_Config_Xml_Property()
{
//Arrange
var attributionSchema = HiveModelCreationHelper.CreateEntitySchema("test", "Test", new AttributeDefinition[] { });
//Act
attributionSchema.SetXmlConfigProperty("test", "hello");
//Assert
Assert.AreEqual("hello", attributionSchema.GetXmlConfigProperty("test"));
}
