public void ShouldCreateItem()
{
// arrange
var itemId = ID.NewID;
var templateId = ID.NewID;
var item = ItemHelper.CreateInstance(this.database);
var destination = ItemHelper.CreateInstance(this.database);
this.dataStorage.GetSitecoreItem(itemId).Returns(item);
var command = new OpenCreateItemCommand()
{
Engine = new DataEngine(this.database)
};
command.Initialize(itemId, "home", templateId, destination);
command.Initialize(this.dataStorage);
// act
var result = command.DoExecute();
// assert
result.Should().Be(item);
this.dataStorage.Received().Create("home", itemId, templateId, destination);
}
public void ShouldAddMissingFieldToItemIfFieldExistsInTemplate()
{
// arrange
var template = new DbTemplate("Sample", this.templateId)
{
this.fieldId
};
var originalItem = new DbItem("original item", this.itemId, this.templateId);
this.dataStorage.GetFakeItem(this.itemId).Returns(originalItem);
this.dataStorage.GetFakeTemplate(this.templateId).Returns(template);
this.dataStorage.FakeItems.Add(this.itemId, originalItem);
var fields = new FieldList {
{ this.fieldId, "updated title" }
};
var updatedItem = ItemHelper.CreateInstance(this.database, "updated item", this.itemId, ID.NewID, ID.Null, fields);
this.command.Initialize(updatedItem);
// act
this.command.DoExecute();
// assert
dataStorage.FakeItems[this.itemId].Name.Should().Be("updated item");
dataStorage.FakeItems[this.itemId].Fields[this.fieldId].Value.Should().Be("updated title");
}
public void ShouldReturnItemChildren()
{
// arrange
var dbchild1 = new DbItem("child1");
var dbchild2 = new DbItem("child2");
var dbitem = new DbItem("item")
{
dbchild1, dbchild2
};
var child1 = ItemHelper.CreateInstance(this.database);
var child2 = ItemHelper.CreateInstance(this.database);
var item = ItemHelper.CreateInstance(this.database, dbitem.ID);
this.dataStorage.GetFakeItem(dbitem.ID).Returns(dbitem);
this.dataStorage.GetSitecoreItem(dbchild1.ID, item.Language).Returns(child1);
this.dataStorage.GetSitecoreItem(dbchild2.ID, item.Language).Returns(child2);
var command = new OpenGetChildrenCommand {
Engine = new DataEngine(this.database)
};
command.Initialize(item);
command.Initialize(this.dataStorage);
// act
var children = command.DoExecute();
// assert
children[0].Should().Be(child1);
children[1].Should().Be(child2);
}
public void ShouldReturnTrueIfHasChildren()
{
// arrange
var itemId = ID.NewID;
var item = ItemHelper.CreateInstance(this.database, itemId);
var fakeItemWithChildren = new DbItem("parent", itemId)
{
new DbItem("child")
};
this.dataStorage.GetSitecoreItem(itemId, item.Language).Returns(item);
this.dataStorage.GetFakeItem(itemId).Returns(fakeItemWithChildren);
var command = new OpenHasChildrenCommand {
Engine = new DataEngine(this.database)
};
command.Initialize(item);
command.Initialize(this.dataStorage);
// act
var result = command.DoExecute();
// assert
result.Should().BeTrue();
}
public void ShouldDeleteItemFromParentsChildrenCollection()
{
// arrange
var itemId = ID.NewID;
var parentId = ID.NewID;
var item = new DbItem("item", itemId)
{
ParentID = parentId
};
var parent = new DbItem("parent", parentId);
parent.Children.Add(item);
this.dataStorage.FakeItems.Add(itemId, item);
this.dataStorage.FakeItems.Add(parentId, parent);
this.command.Initialize(ItemHelper.CreateInstance(this.database, itemId), ID.NewID);
// act
this.command.DoExecute();
// assert
this.dataStorage.FakeItems[parentId].Children.Should().BeEmpty();
}
public void ShouldUpdateExistingItemInDataStorage(SaveItemCommand sut, ID itemId, ID templateId, ID fieldId)
{
// arrange
var originalItem = new DbItem("original item", itemId)
{
new DbField("Title", fieldId)
{
Value = "original title"
}
};
sut.DataStorage.GetFakeItem(itemId).Returns(originalItem);
sut.DataStorage.GetFakeTemplate(null).ReturnsForAnyArgs(new DbTemplate("Sample", templateId));
var fields = new FieldList {
{ fieldId, "updated title" }
};
var updatedItem = ItemHelper.CreateInstance(sut.Database, "updated item", itemId, ID.NewID, ID.Null, fields);
sut.Initialize(updatedItem);
// act
ReflectionUtil.CallMethod(sut, "DoExecute");
// assert
originalItem.Name.Should().Be("updated item");
originalItem.Fields[fieldId].Value.Should().Be("updated title");
}
public void ShouldGetItemVersionsCount()
{
// arrange
var itemId = ID.NewID;
var versionedItem = new DbItem("item");
versionedItem.VersionsCount.Add("en", 2);
this.dataStorage.GetFakeItem(itemId).Returns(versionedItem);
var item = ItemHelper.CreateInstance(this.database, itemId);
var language = Language.Parse("en");
var command = new OpenGetVersionsCommand();
command.Initialize(item, language);
command.Initialize(this.dataStorage);
// act
var versionCollection = command.DoExecute();
// assert
versionCollection.Count.Should().Be(2);
versionCollection.Should().BeEquivalentTo(new[] { new Version(1), new Version(2) });
}
public void ShouldGetNewItemVersion()
{
// arrange
var itemId = ID.NewID;
var dbitem = new DbItem("home")
{
{ "Title", "Hello!" }
};
this.dataStorage.GetFakeItem(itemId).Returns(dbitem);
var originalItem = ItemHelper.CreateInstance(this.database, itemId);
var itemWithNewVersion = ItemHelper.CreateInstance(this.database, itemId);
this.dataStorage.GetSitecoreItem(itemId, Language.Parse("en"), Version.Parse(2)).Returns(itemWithNewVersion);
var command = new OpenAddVersionCommand();
command.Initialize(originalItem);
command.Initialize(this.dataStorage);
// act
var result = command.DoExecute();
// assert
result.Should().BeSameAs(itemWithNewVersion);
}
public void ShouldDeleteItemDescendants()
{
// arrange
var itemId = ID.NewID;
var desc1Id = ID.NewID;
var desc2Id = ID.NewID;
var item = new DbItem("item", itemId);
var desc1 = new DbItem("descendant1", desc1Id);
var desc2 = new DbItem("descendant2", desc2Id);
item.Children.Add(desc1);
desc1.Children.Add(desc2);
this.dataStorage.FakeItems.Add(itemId, item);
this.dataStorage.FakeItems.Add(desc1Id, desc1);
this.dataStorage.FakeItems.Add(desc2Id, desc2);
this.command.Initialize(ItemHelper.CreateInstance(this.database, itemId), ID.NewID);
// act
this.command.DoExecute();
// assert
this.dataStorage.FakeItems.Should().NotContainKey(desc1Id);
this.dataStorage.FakeItems.Should().NotContainKey(desc2Id);
}
public void ShouldRemoveVersionFromFakeDbFields()
{
// arrange
var itemId = ID.NewID;
var dbitem = new DbItem("item")
{
Fields = { new DbField("Title")
{
{ "en", "Hello!" }
} }
};
this.dataStorage.GetFakeItem(itemId).Returns(dbitem);
var item = ItemHelper.CreateInstance(this.database, itemId);
var command = new OpenRemoveVersionCommand();
command.Initialize(item);
command.Initialize(this.dataStorage);
// act
var result = command.DoExecute();
// assert
result.Should().BeTrue();
dbitem.Fields.Single().Values["en"].Values.Should().BeEmpty();
}
public void ShouldAddVersionToFakeDbFieldsUsingItemLanguage()
{
// arrange
var itemId = ID.NewID;
var dbitem = new DbItem("item")
{
Fields = { new DbField("Title")
{
{ "en", "Hello!" }, { "da", "Hej!" }
} }
};
this.dataStorage.GetFakeItem(itemId).Returns(dbitem);
var item = ItemHelper.CreateInstance(this.database, itemId);
var command = new OpenAddVersionCommand();
command.Initialize(item);
command.Initialize(this.dataStorage);
// act
command.DoExecute();
// assert
dbitem.Fields.Single().Values["en"][1].Should().Be("Hello!");
dbitem.Fields.Single().Values["en"][2].Should().Be("Hello!");
dbitem.Fields.Single().Values["da"][1].Should().Be("Hej!");
dbitem.Fields.Single().Values["da"].ContainsKey(2).Should().BeFalse();
}
public void ShouldThrowExceptionIfNoFieldFoundInOriginalItem(SaveItemCommand sut, ID itemId, ID templateId, ID fieldId)
{
// arrange
var originalItem = new DbItem("original item", itemId)
{
new DbField("Title")
};
sut.DataStorage.GetFakeItem(itemId).Returns(originalItem);
sut.DataStorage.GetFakeTemplate(null).ReturnsForAnyArgs(new DbTemplate("Sample", templateId));
var fields = new FieldList {
{ fieldId, "updated title" }
};
var updatedItem = ItemHelper.CreateInstance(sut.Database, "updated item", itemId, ID.NewID, ID.Null, fields);
sut.Initialize(updatedItem);
// act
Action action = () => ReflectionUtil.CallMethod(sut, "DoExecute");
// assert
action
.ShouldThrow <TargetInvocationException>()
.WithInnerException <InvalidOperationException>()
.WithInnerMessage("Item field not found. Item: 'updated item', '{0}'; field: '{1}'.".FormatWith(itemId, fieldId));
}
public void ShouldUpdateExistingItemInDataStorage()
{
// arrange
var originalItem = new DbItem("original item", this.itemId)
{
new DbField("Title", this.fieldId)
{
Value = "original title"
}
};
this.dataStorage.GetFakeItem(this.itemId).Returns(originalItem);
this.dataStorage.FakeItems.Add(this.itemId, originalItem);
var fields = new FieldList {
{ this.fieldId, "updated title" }
};
var updatedItem = ItemHelper.CreateInstance(database, "updated item", this.itemId, ID.NewID, ID.Null, fields);
this.command.Initialize(updatedItem);
// act
this.command.DoExecute();
// assert
dataStorage.FakeItems[this.itemId].Name.Should().Be("updated item");
dataStorage.FakeItems[this.itemId].Fields[this.fieldId].Value.Should().Be("updated title");
}
public virtual Item GetSitecoreItem(ID itemId, Language language, Version version)
{
Assert.ArgumentNotNull(itemId, "itemId");
Assert.ArgumentNotNull(language, "language");
Assert.ArgumentNotNull(version, "version");
if (!this.FakeItems.ContainsKey(itemId))
{
return(null);
}
// TODO:[High] Avoid the templates resetting. Required to avoid sharing templates between unit tests.
this.Database.Engines.TemplateEngine.Reset();
var fakeItem = this.FakeItems[itemId];
if (version == Version.Latest)
{
version = Version.Parse(fakeItem.GetVersionCount(language.Name));
if (version == Version.Latest)
{
version = Version.First;
}
}
var fields = this.BuildItemFieldList(fakeItem, fakeItem.TemplateID, language, version);
return(ItemHelper.CreateInstance(this.database, fakeItem.Name, fakeItem.ID, fakeItem.TemplateID, fakeItem.BranchId, fields, language, version));
}
public void ShouldCreateItem()
{
// arrange
var itemId = ID.NewID;
var templateId = ID.NewID;
var item = ItemHelper.CreateInstance(this.database);
var destination = ItemHelper.CreateInstance(this.database);
this.dataStorage.GetSitecoreItem(itemId).Returns(item);
var command = new OpenCreateItemCommand {
Engine = new DataEngine(this.database)
};
command.Initialize(itemId, "home", templateId, destination);
command.Initialize(this.dataStorage);
// act
var result = command.DoExecute();
// assert
result.Should().Be(item);
this.dataStorage.Received().AddFakeItem(Arg.Is <DbItem>(i => i.Name == "home" &&
i.ID == itemId &&
i.TemplateID == templateId &&
i.ParentID == destination.ID));
}
public void ShouldAddMissingFieldToItemIfFieldExistsInTemplate(SaveItemCommand sut, ID itemId, ID templateId, ID fieldId)
{
// arrange
var template = new DbTemplate("Sample", templateId)
{
fieldId
};
var originalItem = new DbItem("original item", itemId, templateId);
sut.DataStorage.GetFakeItem(itemId).Returns(originalItem);
sut.DataStorage.GetFakeTemplate(templateId).Returns(template);
var fields = new FieldList {
{ fieldId, "updated title" }
};
var updatedItem = ItemHelper.CreateInstance(sut.Database, "updated item", itemId, ID.NewID, ID.Null, fields);
sut.Initialize(updatedItem);
// act
ReflectionUtil.CallMethod(sut, "DoExecute");
// assert
originalItem.Name.Should().Be("updated item");
originalItem.Fields[fieldId].Value.Should().Be("updated title");
}
public DataStorageCreateTest()
{
this.database = Database.GetDatabase("master");
this.dataStorage = new DataStorage(this.database);
this.destination = ItemHelper.CreateInstance(this.database);
this.dataStorage.FakeItems.Add(this.destination.ID, new DbItem("destination"));
}
public FakeLinkDatabaseTest()
{
this.item = ItemHelper.CreateInstance(this.database);
this.behavior = Substitute.For <LinkDatabase>();
this.linkDatabase = new FakeLinkDatabase();
this.linkDatabase.LocalProvider.Value = this.behavior;
}
public object Create(object request, ISpecimenContext context)
{
if (!typeof(TemplateItem).Equals(request))
{
return(new NoSpecimen());
}
return(new TemplateItem(ItemHelper.CreateInstance()));
}
public void ShouldCallRemoveItemTaskWithType()
{
// act
var item = ItemHelper.CreateInstance();
this.taskDatabase.RemoveItemTasks(item, typeof(Task));
// assert
this.behavior.Received().RemoveItemTasks(item, typeof(Task));
}
public FakeAuthorizationProviderTest()
{
this.provider = new FakeAuthorizationProvider();
this.localProvider = Substitute.For <AuthorizationProvider>();
this.helper = Substitute.For <ItemAuthorizationHelper>();
this.entity = Substitute.For <ISecurable>();
this.item = ItemHelper.CreateInstance();
this.rules = new AccessRuleCollection();
}
public void ShouldReturnFalseIfNoItemFound()
{
// arrange
this.command.Initialize(ItemHelper.CreateInstance(this.database), ID.NewID);
// act
var result = this.command.DoExecute();
// assert
result.Should().BeFalse();
}
public void ShouldThrowIfNoParentFound()
{
// arrange
var parentId = new ID("eb09ce25-f03b-48bd-bdf1-0794b94aaf72");
var missingParent = ItemHelper.CreateInstance(this.database, parentId);
// act
Action action = () => this.dataStorage.Create("home", this.itemId, this.templateId, missingParent);
// assert
action.ShouldThrow <InvalidOperationException>().WithMessage("Parent item \"{eb09ce25-f03b-48bd-bdf1-0794b94aaf72}\" not found.");
}
public void ShouldReturnEmptyStringIfNoTemplateFound()
{
// arrange
var storage = Substitute.For <DataStorage>(this.database);
((IRequireDataStorage)this.provider).SetDataStorage(storage);
var field = new Field(ID.NewID, ItemHelper.CreateInstance(this.database));
// act & assert
this.provider.GetStandardValue(field).Should().BeEmpty();
}
public FakeAuthorizationProviderTest()
{
this.localProvider = Substitute.For <AuthorizationProvider>();
this.helper = Substitute.For <ItemAuthorizationHelper>(
Substitute.For <BaseAccessRightManager>(),
Substitute.For <BaseRolesInRolesManager>(),
Substitute.For <BaseItemManager>());
this.provider = new FakeAuthorizationProvider(helper);
this.entity = Substitute.For <ISecurable>();
this.item = ItemHelper.CreateInstance();
this.rules = new AccessRuleCollection();
}
public void ShouldSimpleCreateItem()
{
// arrange
var database = Database.GetDatabase("master");
var item = ItemHelper.CreateInstance(database, Name);
// assert
item.Name.Should().Be(Name);
item.ID.Should().NotBeNull();
item.TemplateID.Should().NotBeNull();
item.Database.Should().NotBeNull();
item.Language.Should().Be(Language.Parse("en"));
}
public void ShouldDeleteItemFromDataStorageAndReturnTrue(DeleteItemCommand sut, DbItem item, ID parentId)
{
// arrange
sut.DataStorage.GetFakeItem(item.ID).Returns(item);
sut.DataStorage.RemoveFakeItem(item.ID).Returns(true);
sut.Initialize(ItemHelper.CreateInstance(item.ID), parentId);
// act
var result = (bool)ReflectionUtil.CallMethod(sut, "DoExecute");
// assert
result.Should().BeTrue();
}
public void ShouldReturnNullIfNoParentFound()
{
// arrange
var item = ItemHelper.CreateInstance(this.database);
this.command.Initialize(item);
// act
var parent = this.command.DoExecute();
// assert
parent.Should().BeNull();
this.dataStorage.DidNotReceiveWithAnyArgs().GetSitecoreItem(null, null);
}
public void ShouldNotUpdateFieldsIfItemVersionIsZero(SaveItemCommand sut, DbItem item, FieldList fields, Language language)
{
// arrange
sut.DataStorage.GetFakeItem(item.ID).Returns(item);
var updatedItem = ItemHelper.CreateInstance(sut.Database, "updated item", item.ID, ID.NewID, ID.Null, fields, language, Version.Parse(0));
sut.Initialize(updatedItem);
// act
Action action = () => ReflectionUtil.CallMethod(sut, "DoExecute");
// assert
action.ShouldNotThrow();
}
public void ShouldUpdateBranchId(SaveItemCommand sut, DbItem item, ID branchId, FieldList fields, Language language)
{
// arrange
sut.DataStorage.GetFakeItem(item.ID).Returns(item);
var updatedItem = ItemHelper.CreateInstance(sut.Database, "updated item", item.ID, ID.NewID, branchId, fields, language, Version.Parse(0));
sut.Initialize(updatedItem);
// act
ReflectionUtil.CallMethod(sut, "DoExecute");
// assert
item.BranchId.Should().Be(branchId);
}
