| public GetItem ( ID id ) : System.Item | ||
| id | ID | The item id. |
| return | System.Item | |
public void Update_ItemPassed_ShouldReplaceLinks([Substitute] LinkDatabase linkDb, Db db)
{
var datasourceItemId = ID.NewID;
db.Add(new DbItem("source")
{
Children =
{
new DbItem("_Local")
{
new DbItem("DatasourceItem")
}
},
Fields =
{
"testField"
}
});
;
db.Add(new DbItem("target")
{
Children =
{
new DbItem("_Local")
{
new DbItem("DatasourceItem")
}
},
Fields =
{
"testField"
}
});
;
var sourceItem = db.GetItem("/sitecore/content/source");
var targetItem = db.GetItem("/sitecore/content/target");
var datasourceItem = db.GetItem("/sitecore/content/source/_Local/DatasourceItem");
var targetDatasourceItem = db.GetItem("/sitecore/content/target/_Local/DatasourceItem");
var itemLinks = new[]
{
new ItemLink(sourceItem, FieldIDs.LayoutField, datasourceItem, string.Empty)
};
linkDb.GetReferences(sourceItem).Returns(itemLinks.ToArray());
using (new LinkDatabaseSwitcher(linkDb))
{
using (new EditContext(targetItem))
{
targetItem["__Renderings"] = datasourceItem.ID.ToString();
}
var referenceReplacer = new UpdateLocalDatasourceReferencesService(sourceItem, targetItem);
referenceReplacer.Update();
var expectedValue = targetDatasourceItem.ID.ToString();
targetItem["__Renderings"].Should().Be(expectedValue);
}
}
public void GetDatasources_LocationSetByRelativePath_ShouldReturnSourcesFromSettingItem([Frozen]ISiteSettingsProvider siteSettingsProvider, [Greedy]DatasourceProvider provider, string name, string contextItemName, Db db, string settingItemName, Item item, string sourceRootName)
{
var contextItemId = ID.NewID;
var contextDbItem = new DbItem(contextItemName.Replace("-", String.Empty), contextItemId);
var rootName = sourceRootName.Replace("-", string.Empty);
var sourceRoot = new DbItem(rootName);
contextDbItem.Add(sourceRoot);
db.Add(contextDbItem);
var settingId = ID.NewID;
var settingDbItem = new DbItem(settingItemName.Replace("-", String.Empty), settingId, Templates.DatasourceConfiguration.ID)
{
new DbField(Templates.DatasourceConfiguration.Fields.DatasourceLocation)
{
{
"en", $"./{rootName}"
}
}
};
var contextItem = db.GetItem(contextItemId);
db.Add(settingDbItem);
var sourceRootItem = db.GetItem(sourceRoot.ID);
var settingItem = db.GetItem(settingId);
siteSettingsProvider.GetSetting(Arg.Any<Item>(), Arg.Any<string>(), Arg.Any<string>()).Returns(settingItem);
var sources = provider.GetDatasourceLocations(contextItem, name);
sources.Should().NotBeNull();
sources.Should().Contain(sourceRootItem);
}
public void GetSiteDefinition_ItemInSiteHierarcy_ShouldReturnHierarchicalSiteDefinition(SiteContext siteContext, DbItem item , Db db, string siteName)
{
var siteDefinitionId = ID.NewID;
db.Add(new DbItem(siteName, siteDefinitionId, Templates.Site.ID) {item});
var contextItem = db.GetItem(item.ID);
var definitionItem = db.GetItem(siteDefinitionId);
var siteDefinition = siteContext.GetSiteDefinition(contextItem);
siteDefinition.Item.ID.ShouldBeEquivalentTo(definitionItem.ID);
}
public void CustomFields()
{
using (var db = new Db
{
new DbTemplate(Settings.CommentTemplateID)
{
new DbField("Name"),
new DbField("Email"),
new DbField("Comment"),
new DbField("Website"),
new DbField("IP Address"),
new DbField("field1"),
new DbField("field2")
},
new DbItem("blog")
{
new DbItem("entry")
}
})
{
var blog = db.GetItem("/sitecore/content/blog");
var entry = db.GetItem("/sitecore/content/blog/entry");
var blogManager = Mock.Of<IBlogManager>(x =>
x.GetCurrentBlog(entry) == new BlogHomeItem(blog)
);
var processor = new CreateCommentItem(blogManager);
var args = new CreateCommentArgs
{
Database = entry.Database,
Comment = new Comment
{
AuthorName = "commenter",
AuthorEmail = "*****@*****.**",
Text = "the comment",
Fields =
{
{ "field1", "value1" },
{ "field2", "value2" },
}
},
EntryID = entry.ID,
Language = Language.Parse("da")
};
processor.Process(args);
Assert.That(args.CommentItem, Is.Not.Null);
Assert.That(args.CommentItem.InnerItem.Axes.IsDescendantOf(entry), Is.True);
Assert.That(args.CommentItem["field1"], Is.EqualTo("value1"));
Assert.That(args.CommentItem["field2"], Is.EqualTo("value2"));
}
}
public void GetBackgroundClass_ClassFieldIsSet_ShouldReturnClassValue(Db db, [Substitute] Rendering rendering, ID itemId, string itemName,[Content] DbItem renderingItem, string classValue)
{
var rItem = db.GetItem(renderingItem.ID);
db.Add(new DbItem(itemName, itemId) {new DbField(Templates.Style.Fields.Class) { {"en", classValue}} });
var backgroundClassItem = db.GetItem(itemId);
rendering.RenderingItem.Returns(rItem);
var parameters = new RenderingParameters($"{Constants.BackgroundLayoutParameters.Background}={backgroundClassItem.ID}");
rendering.Parameters.Returns(parameters);
var bgClass = rendering.GetBackgroundClass();
bgClass.Should().BeEquivalentTo(classValue);
}
public void GetSettingsItem_ShouldReturnSettingItem(string settingName, [Frozen]Item contextItem, [Substitute]SiteContext context, Db db, string definitionItemName)
{
var provider = new SettingsProvider(context);
var settingItemId = ID.NewID;
var definitionId = ID.NewID;
db.Add(new DbItem(definitionItemName, definitionId) {new DbItem(SettingsProvider.SettingsRootName) {new DbItem(settingName, settingItemId, Templates.SiteSettings.ID)} });
var definitionItem = db.GetItem(definitionId);
var setting = db.GetItem(settingItemId);
context.GetSiteDefinition(Arg.Any<Item>()).Returns(new SiteDefinition {Item = definitionItem });
var settingItem = provider.GetSettingItem(settingName, contextItem);
settingItem.ID.ShouldBeEquivalentTo(setting.ID);
}
public void GetDatasources_ShouldReturnSourcesFromSettingItem([Frozen]ISiteSettingsProvider siteSettingsProvider, [Greedy]DatasourceProvider provider, string name, Item contextItem, Db db, string settingItemName, Item item, DbItem sourceRoot)
{
var settingId = ID.NewID;
db.Add(new DbItem(settingItemName, settingId, Templates.DatasourceConfiguration.ID) {new DbField(Templates.DatasourceConfiguration.Fields.DatasourceLocation) { {"en", sourceRoot.ID.ToString()} } });
db.Add(sourceRoot);
var sourceRootItem = db.GetItem(sourceRoot.ID);
var settingItem = db.GetItem(settingId);
siteSettingsProvider.GetSetting(Arg.Any<Item>(), Arg.Any<string>(), Arg.Any<string>()).Returns(settingItem);
var sources = provider.GetDatasourceLocations(item, name);
sources.Should().NotBeNull();
sources.Should().Contain(sourceRootItem);
}
public void GetDatasourceTemplate_ShouldReturnTemplateFromSettingItem([Frozen]ISettingsProvider settingsProvider, [Greedy]ItemDatasourceProvider provider, string name, Item contextItem, Db db, string settingItemName, Item item, DbItem sourceTemplate)
{
provider.Database = db.Database;
var settingId = ID.NewID;
db.Add(new DbItem(settingItemName, settingId) { new DbField(Templates.DatasourceConfiguration.Fields.DatasourceTemplate) { { "en", sourceTemplate.ID.ToString() } } });
db.Add(sourceTemplate);
var sourceRootItem = db.GetItem(sourceTemplate.ID);
var settingItem = db.GetItem(settingId);
settingsProvider.GetSettingItem(Arg.Any<string>(), Arg.Any<Item>()).Returns(settingItem);
var sources = provider.GetDatasourceTemplate(name, item);
sources.Should().NotBeNull();
sources.ID.ShouldBeEquivalentTo(sourceRootItem.ID);
}
public void GetDatasources_LocationSetByQuery_ShouldReturnSourcesFromSettingItem([Frozen]ISettingsProvider settingsProvider, [Greedy]ItemDatasourceProvider provider, string name, Item contextItem, Db db, string settingItemName, Item item, string sourceRootName)
{
var sourceRoot = new DbItem(sourceRootName.Replace("-", string.Empty));
provider.Database = db.Database;
var settingId = ID.NewID;
db.Add(sourceRoot);
var sourceRootItem = db.GetItem(sourceRoot.ID);
db.Add(new DbItem(settingItemName, settingId, Templates.DatasourceConfiguration.ID) { new DbField(Templates.DatasourceConfiguration.Fields.DatasourceLocation) { { "en", $"query:{sourceRootItem.Paths.Path}" } } });
var settingItem = db.GetItem(settingId);
settingsProvider.GetSettingItem(Arg.Any<string>(), Arg.Any<Item>()).Returns(settingItem);
var sources = provider.GetDatasources(name, item);
sources.Should().NotBeNull();
sources.Should().Contain(sourceRootItem);
}
public void GetProfileShouldReturnFullEditProfileModel(Db db, [Substitute] UserProfile userProfile, [RightKeys("FirstName", "LastName", "Phone", "Interest")] IDictionary<string, string> properties,
[Frozen] IProfileSettingsService profileSettingsService, [Frozen] IUserProfileProvider userProfileProvider, [Greedy] UserProfileService userProfileService)
{
using (db)
{
var id = new ID();
db.Add(new DbItem("Profile", id)
{
Fields =
{
new DbField("FirstName", Templates.UserProfile.Fields.FirstName),
new DbField("LastName", Templates.UserProfile.Fields.LastName),
new DbField("Phone", Templates.UserProfile.Fields.PhoneNumber),
new DbField("Interest", Templates.UserProfile.Fields.Interest)
}
});
profileSettingsService.GetUserDefaultProfile().Returns(db.GetItem(id));
userProfileProvider.GetCustomProperties(Arg.Any<UserProfile>()).Returns(properties);
var result = userProfileService.GetProfile(userProfile);
result.FirstName.Should().Be(properties["FirstName"]);
result.LastName.Should().Be(properties["LastName"]);
result.PhoneNumber.Should().Be(properties["Phone"]);
result.Interest.Should().Be(properties["Interest"]);
}
}
public void Create_ShouldReturnNewsRepository(NewsRepositoryFactory factory, Db db, string itemName, ID itemId)
{
db.Add(new DbItem(itemName, itemId, Templates.NewsFolder.ID));
var contextItem = db.GetItem(itemId);
var repo = factory.Create(contextItem);
repo.Should().BeAssignableTo<INewsRepository>();
}
public void ParseFields_ReturnsExpectedValues(string fieldValue, string standardValue, string expected)
{
using (var db = new Db())
{
var testFieldId = ID.NewID;
var template = new DbTemplate("Test Template") { { testFieldId, standardValue } };
db.Add(template);
var testItem = ItemManager.CreateItem("Test", db.GetItem(ItemIDs.ContentRoot), template.ID);
if (expected != null)
{
using (new EditContext(testItem))
{
testItem[testFieldId] = expected;
}
}
var sut = new FieldReader();
testItem.Fields.ReadAll();
var result = sut.ParseFields(testItem, FieldReader.FieldReadType.Versioned).FirstOrDefault(f => f.FieldId == testFieldId.Guid);
if (expected == null) result.Should().BeNull();
else result.Value.Should().Be(expected);
}
}
public void Process_LocalDatasourceNotExist_ShouldCreateDatasourceRoot(GetLocalDatasourceLocation processor, Db db, [Content] Item contextItem, [Content] DbTemplate template)
{
//arrange
db.Add(new DbItem("rendering")
{
{
Templates.RenderingOptions.Fields.SupportsLocalDatasource, "1"
}
});
var renderingItem = db.GetItem("/sitecore/content/rendering");
var getRenderingDatasourceArgs = new GetRenderingDatasourceArgs(renderingItem)
{
ContextItemPath = contextItem.Paths.FullPath
};
//act
using (new SettingsSwitcher("Foundation.LocalDatasource.LocalDatasourceFolderTemplate", template.ID.ToString()))
{
processor.Process(getRenderingDatasourceArgs);
}
//assert
var datasourceFolder = contextItem.GetChildren().First();
getRenderingDatasourceArgs.DatasourceRoots.First().ID.Should().Be(datasourceFolder.ID);
datasourceFolder.TemplateID.Should().Be(template.ID);
}
public void ResolveItem()
{
//Arrange
using (Db database = new Db
{
new Sitecore.FakeDb.DbItem("TestItem")
})
{
var config = new SitecoreTypeConfiguration();
config.ItemUriConfig = new SitecoreInfoConfiguration();
config.ItemUriConfig.PropertyInfo = typeof(StubClass).GetProperty("ItemUri");
string path = "/sitecore/content/TestItem";
var expected = database.GetItem(path);
var instance = new StubClass();
instance.ItemUri = new ItemUri(expected.ID, expected.Language, expected.Version, expected.Database);
//Act
var result = config.ResolveItem(instance, database.Database);
//Assert
Assert.AreEqual(expected.ID, result.ID);
Assert.AreEqual(expected.Version, result.Version);
Assert.AreEqual(expected.Language, result.Language);
}
}
public void ShouldShutdownLicenseWatcher()
{
using (var db = new Db())
{
db.GetItem("/sitecore/content");
}
}
public void MapToProperty_ConfigurationSetupCorrectly_CallsCreateClassOnService()
{
//Assign
using (Db database = new Db
{
new Sitecore.FakeDb.DbItem("TestItem")
})
{
var item = database.GetItem("/sitecore/content/TestItem");
var service = Substitute.For<ISitecoreService>();
var scContext = new SitecoreDataMappingContext(null, item, service);
var config = new SitecoreParentConfiguration();
config.PropertyInfo = typeof(Stub).GetProperty("Property");
var mapper = new SitecoreParentMapper();
mapper.Setup(new DataMapperResolverArgs(null, config));
//Act
var result = mapper.MapToProperty(scContext);
//Assert
//ME - I am not sure why I have to use the Arg.Is but just using item.Parent as the argument fails.
service.Received()
.CreateType(config.PropertyInfo.PropertyType, Arg.Is<Item>(x => x.ID == item.Parent.ID), true, false,
null);
}
}
public void GetFieldsToEdit_ItemHasNoCustomFields_ReturnEmptyString(Db db, DbItem item)
{
db.Add(item);
var testItem = db.GetItem(item.ID);
GetFieldsToEditService.GetFieldsToEdit(testItem).Should().BeEmpty();
}
public void GetEnumerator_Call_ReturnScoresWithKeyName(Db db, ID keyId1, ID keyId2, DbItem profileItem, IBehaviorProfileContext behaviorProfile)
{
//Arrange
using (new SecurityDisabler())
{
profileItem.Add(new DbItem("Key1", keyId1, ProfileKeyItem.TemplateID)
{
{ProfileKeyItem.FieldIDs.NameField,"key1name" }
});
profileItem.Add(new DbItem("Key2", keyId2, ProfileKeyItem.TemplateID)
{
{ProfileKeyItem.FieldIDs.NameField,"key2name" }
});
db.Add(profileItem);
var item = db.GetItem(profileItem.FullPath);
var profile = new ProfileItem(item);
var behaviorScores = new List<KeyValuePair<ID, float>>() { new KeyValuePair<ID, float>(keyId1, 10), new KeyValuePair<ID, float>(keyId2, 20) };
behaviorProfile.Scores.Returns(behaviorScores);
var behaviorProfileDecorator = new BehaviorProfileDecorator(profile, behaviorProfile);
//Act
var result = behaviorProfileDecorator.ToList();
//Assert
result.Should().BeEquivalentTo(new[] { new KeyValuePair<string, float>("key1name", 10), new KeyValuePair<string, float>("key2name", 20) });
}
}
public void GetKeywords_ContextItem_ShouldReturnKeywordsModel(Db db, string contextItemName, string keyword1ItemName, string keyword2ItemName)
{
var contextItemId = ID.NewID;
var keyword1Id = ID.NewID;
var keyword2Id = ID.NewID;
db.Add(new DbItem(contextItemName, contextItemId, Templates.PageMetadata.ID)
{
new DbField(Templates.PageMetadata.Fields.Keywords)
{
{"en", $"{keyword1Id}|{keyword2Id}"}
}
});
db.Add(new DbItem(keyword1ItemName, keyword1Id, Templates.Keyword.ID)
{
new DbField(Templates.Keyword.Fields.Keyword)
{
{"en", keyword1ItemName}
}
});
db.Add(new DbItem(keyword2ItemName, keyword2Id, Templates.Keyword.ID)
{
new DbField(Templates.Keyword.Fields.Keyword)
{
{"en", keyword2ItemName}
}
});
var contextItem = db.GetItem(contextItemId);
var keywordsModel = MetadataRepository.GetKeywords(contextItem);
keywordsModel.Should().BeOfType<MetaKeywordsModel>();
keywordsModel.Keywords.Count().Should().Be(2);
}
public void Test(string input, string expected, int limit, bool stripTags)
{
var procesor = new AutoGenerate
{
FieldName = "Text",
StripTags = stripTags,
MaximumCharacterCount = limit
};
using (var db = new Db
{
new DbItem("item")
{
new DbField("text")
{
Value = input
}
}
})
{
var args = new GetSummaryArgs
{
Entry = db.GetItem("/sitecore/content/item")
};
procesor.Process(args);
Assert.That(args.Summary, Is.EqualTo(expected));
}
}
public void GetActive_ShouldReturnLanguageModelForContextLanguage(Db db, [Content] DbItem item)
{
var contextItem = db.GetItem(item.ID);
Context.Item = contextItem;
var activeLanguage = LanguageRepository.GetActive();
activeLanguage.TwoLetterCode.Should().BeEquivalentTo(Context.Language.Name);
}
public void GetSupportedLanguages_OneSelected_ShouldReturnSelected(Db db, [Content] DbTemplate template, DbItem item, string rootName)
{
template.BaseIDs = new[]
{
Templates.Site.ID, Feature.Language.Templates.LanguageSettings.ID
};
var languageItem = new DbItem("en");
db.Add(languageItem);
var siteRootItem = new DbItem(rootName, ID.NewID, template.ID)
{
new DbField(Feature.Language.Templates.LanguageSettings.Fields.SupportedLanguages)
{
{
"en", languageItem.ID.ToString()
}
}
};
siteRootItem.Add(item);
db.Add(siteRootItem);
var contextItem = db.GetItem(item.ID);
Context.Item = contextItem;
var supportedLanguages = LanguageRepository.GetSupportedLanguages();
supportedLanguages.Count().Should().BeGreaterThan(0);
}
public void Deserialize_DeserializesNewItem()
{
using (var db = new Db())
{
var deserializer = CreateTestDeserializer(db);
var item = new FakeItem(
id: Guid.NewGuid(),
parentId: ItemIDs.ContentRoot.Guid,
templateId: _testTemplateId.Guid,
versions: new[]
{
new FakeItemVersion(1, "en", new FakeFieldValue("Hello", fieldId: _testVersionedFieldId.Guid))
});
var deserialized = deserializer.Deserialize(item);
Assert.NotNull(deserialized);
var fromDb = db.GetItem(new ID(item.Id));
Assert.NotNull(fromDb);
Assert.Equal("Hello", fromDb[_testVersionedFieldId]);
Assert.Equal(item.ParentId, fromDb.ParentID.Guid);
Assert.Equal(item.TemplateId, fromDb.TemplateID.Guid);
}
}
public void Test(string input, string expected, string xpath)
{
var procesor = new FirstContentBlock
{
FieldName = "Text",
XPath = xpath
};
using (var db = new Db
{
new DbItem("item")
{
new DbField("text")
{
Value = input
}
}
})
{
var args = new GetSummaryArgs
{
Entry = db.GetItem("/sitecore/content/item")
};
procesor.Process(args);
Assert.That(args.Summary, Is.EqualTo(expected));
}
}
public void Execute_EnforeTemplateOnlyDoesNotInheritTemplate_AbortsPipeline()
{
//Arrange
var task = new EnforcedTemplateCheck();
using (Db database = new Db
{
new DbTemplate(new ID(TemplateInferredTypeTaskFixture.StubInferred.TemplateId)),
new Sitecore.FakeDb.DbItem("Target", ID.NewID, new ID(TemplateInferredTypeTaskFixture.StubInferred.TemplateId))
})
{
var path = "/sitecore/content/Target";
var item = database.GetItem(path);
var config = new SitecoreTypeConfiguration();
config.EnforceTemplate = SitecoreEnforceTemplate.Template;
config.TemplateId = new ID(Guid.NewGuid());
var typeContext = new SitecoreTypeCreationContext();
typeContext.Item = item;
var args = new ObjectConstructionArgs(null, typeContext, config, null, new ModelCounter());
//Act
task.Execute(args);
//Assert
Assert.IsNull(args.Result);
}
}
public void DemoContent_RenderingContextItemInitialized_ShouldReturnDemoContentView(Db db, [Greedy] DemoController sut, [Content] DemoContentItem item)
{
using (RenderingContext.EnterContext(new Rendering(), db.GetItem(item.ID)))
{
sut.DemoContent().As<ViewResult>().Model.Should().BeOfType<DemoContent>();
}
}
public void GetSupportedLanguages_ShouldReturlListOfSupportedLanguages(Db db, DbItem item , string rootName)
{
var contextItemId = ID.NewID;
var rootId = ID.NewID;
var template = new DbTemplate();
template.BaseIDs = new[]
{
Foundation.Multisite.Templates.Site.ID,
Templates.LanguageSettings.ID
};
var languageItem = new DbItem("en");
db.Add(languageItem);
db.Add(new DbTemplate(Foundation.Multisite.Templates.Site.ID));
db.Add(new DbTemplate(Templates.LanguageSettings.ID) {Fields = { { Templates.LanguageSettings.Fields.SupportedLanguages, languageItem.ID.ToString()} }});
db.Add(template);
var rootItem = new DbItem(rootName, rootId, template.ID){ new DbField(Templates.LanguageSettings.Fields.SupportedLanguages) { {"en", languageItem.ID.ToString()} } };
rootItem.Add(item);
db.Add(rootItem);
var contextItem = db.GetItem(item.ID);
Sitecore.Context.Item = contextItem;
var supportedLanguages = LanguageRepository.GetSupportedLanguages();
supportedLanguages.Count().Should().BeGreaterThan(0);
}
public void Execute_CreatesInferredType()
{
//Arrange
using (Db database = new Db
{
new DbTemplate(new ID(StubInferred.TemplateId)),
new Sitecore.FakeDb.DbItem("Target", ID.NewID, new ID(StubInferred.TemplateId))
})
{
var context = Context.Create(FakeDb.Utilities.CreateStandardResolver());
var path = "/sitecore/content/Target";
context.Load(new AttributeTypeLoader(typeof(StubInferred)));
var typeContext = new SitecoreTypeCreationContext();
var args = new ConfigurationResolverArgs(context, typeContext, null, null);
var task = new TemplateInferredTypeTask();
typeContext.InferType = true;
typeContext.Item = database.GetItem(path);
typeContext.RequestedType = typeof(IBase);
args.RequestedType = typeof(IBase);
//Act
task.Execute(args);
//Assert
Assert.IsNotNull(args.Result);
Assert.AreEqual(typeof(StubInferred), args.Result.Type);
}
}
public void EnableRSS(bool enabled)
{
var blogTemplateId = ID.NewID;
var settings = Mock.Of<IWeBlogSettings>(x =>
x.ContentRootPath == "/sitecore/content" &&
x.BlogTemplateIds == new[] { ID.NewID, blogTemplateId, ID.NewID }
);
var manager = new BlogManager(settings);
using (var db = new Db
{
new DbItem("blog", ID.NewID, blogTemplateId)
{
{ "Enable RSS", enabled ? "1" : string.Empty }
}
})
{
var item = db.GetItem("/sitecore/content/blog");
var result = manager.EnableRSS(item);
if(enabled)
Assert.That(result, Is.True);
else
{
Assert.That(result, Is.False);
}
}
}
public void MapToProperty_ItemIdAsGuid_ReturnsIdAsGuid()
{
//Assign
string targetPath = "/sitecore/content/target";
using (Db database = new Db
{
new Sitecore.FakeDb.DbItem("Target")
})
{
var mapper = new SitecoreIdMapper();
var config = new SitecoreIdConfiguration();
var property = typeof(Stub).GetProperty("GuidId");
var item = database.GetItem("/sitecore/content/target");
Assert.IsNotNull(item, "Item is null, check in Sitecore that item exists");
config.PropertyInfo = property;
mapper.Setup(new DataMapperResolverArgs(null, config));
var dataContext = new SitecoreDataMappingContext(null, item, null);
var expected = item.ID.Guid;
//Act
var value = mapper.MapToProperty(dataContext);
//Assert
Assert.AreEqual(expected, value);
}
}
public void HowToCreateItemOnSpecificTemplate()
{
Sitecore.Data.ID templateId = Sitecore.Data.ID.NewID;
using (Sitecore.FakeDb.Db db = new Sitecore.FakeDb.Db
{
new DbTemplate("products", templateId)
{
"Name"
},
new DbItem("Apple")
{
TemplateID = templateId
}
})
{
Sitecore.Data.Items.Item item =
db.GetItem("/sitecore/content/apple");
Xunit.Assert.Equal(templateId, item.TemplateID);
Xunit.Assert.NotNull(item.Fields["Name"]);
}
}
