public void WriteValueToListItem_GivenGuidFieldInfo_ShouldUseGuidValueWriter()
{
using (ShimsContext.Create())
{
// Arrange
var correctWriterWasUsed = false;
var fieldInfo = new GuidFieldInfo("InternalName", Guid.NewGuid(), string.Empty, string.Empty, string.Empty);
ShimGuidValueWriter.AllInstances.WriteValueToListItemSPListItemFieldValueInfo = (inst, listItem, fieldValueInfo) =>
{
correctWriterWasUsed = true;
};
var fakeListItem = new ShimSPListItem().Instance;
IFieldValueWriter writer;
using (var scope = UnitTestServiceLocator.BeginLifetimeScope())
{
writer = scope.Resolve <IFieldValueWriter>();
}
// Act
writer.WriteValueToListItem(fakeListItem, new FieldValueInfo(fieldInfo, null));
// Assert
Assert.IsTrue(correctWriterWasUsed, "The GuidValueWriter should have been used for the GuidFieldInfo type.");
}
}
public void ToEntity_WhenAllValuesInListItemAreNull_AndEntityTypeHasNullablePrimitiveValues_ShouldInitializeEntityWithEmptyNullable()
{
using (var testScope = SiteTestScope.BlankSite())
{
// Arrange
IntegerFieldInfo integerFieldInfo = new IntegerFieldInfo(
"TestInternalNameInteger",
new Guid("{12E262D0-C7C4-4671-A266-064CDBD3905A}"),
"NameKeyInt",
"DescriptionKeyInt",
"GroupKey");
NumberFieldInfo numberFieldInfo = new NumberFieldInfo(
"TestInternalNameNumber",
new Guid("{5DD4EE0F-8498-4033-97D0-317A24988786}"),
"NameKeyNumber",
"DescriptionKeyNumber",
"GroupKey");
CurrencyFieldInfo currencyFieldInfo = new CurrencyFieldInfo(
"TestInternalNameCurrency",
new Guid("{9E9963F6-1EE6-46FB-9599-783BBF4D6249}"),
"NameKeyCurrency",
"DescriptionKeyCurrency",
"GroupKey");
BooleanFieldInfo boolFieldInfoBasic = new BooleanFieldInfo(
"TestInternalNameBool",
new Guid("{F556AB6B-9E51-43E2-99C9-4A4E551A4BEF}"),
"NameKeyBool",
"DescriptionKeyBool",
"GroupKey");
DateTimeFieldInfo dateTimeFieldInfo = new DateTimeFieldInfo(
"TestInternalNameDate",
new Guid("{016BF8D9-CEDC-4BF4-BA21-AC6A8F174AD5}"),
"NameKeyDateTimeDefault",
"DescriptionKeyDateTimeDefault",
"GroupKey");
GuidFieldInfo guidFieldInfo = new GuidFieldInfo(
"TestInternalNameGuid",
new Guid("{308C0899-DDBE-44EE-A8A8-226F7A6A7C89}"),
"NameKeyGuid",
"DescriptionKeyGuid",
"GroupKey");
var fieldsToEnsure = new List<BaseFieldInfo>()
{
integerFieldInfo,
numberFieldInfo,
currencyFieldInfo,
boolFieldInfoBasic,
dateTimeFieldInfo,
guidFieldInfo
};
ListInfo lookupListInfo = new ListInfo("sometestlistpathlookup", "DynamiteTestListNameKeyLookup", "DynamiteTestListDescriptionKeyLookup");
ListInfo listInfo = new ListInfo("sometestlistpath", "DynamiteTestListNameKey", "DynamiteTestListDescriptionKey")
{
FieldDefinitions = fieldsToEnsure
};
// Note how we need to specify SPSite for injection context - ISharePointEntityBinder's implementation
// is lifetime-scoped to InstancePerSite.
using (var injectionScope = IntegrationTestServiceLocator.BeginLifetimeScope(testScope.SiteCollection))
{
var listHelper = injectionScope.Resolve<IListHelper>();
// Create the test list
SPList list = listHelper.EnsureList(testScope.SiteCollection.RootWeb, listInfo);
list.EnableVersioning = true;
list.Update();
// Create an empty item
var itemOnList = list.AddItem();
itemOnList.Update();
// Act
var entityBinder = injectionScope.Resolve<ISharePointEntityBinder>();
var entityMappedFromSingleItem = new TestItemEntityWithNullablePrimitivesOnly();
var entityMappedFromItemVersion = new TestItemEntityWithNullablePrimitivesOnly();
// Act
// Map from SPListItem
entityBinder.ToEntity<TestItemEntityWithNullablePrimitivesOnly>(entityMappedFromSingleItem, itemOnList);
// Map from SPListItemVersion
entityBinder.ToEntity<TestItemEntityWithNullablePrimitivesOnly>(entityMappedFromItemVersion, itemOnList.Versions[0]);
// Map from DataRow/SPListItemCollection
var entitiesMappedFromItemCollection = entityBinder.Get<TestItemEntityWithNullablePrimitivesOnly>(list.Items);
// Assert
// #1 Check SPListItem-mapped values
Assert.IsFalse(entityMappedFromSingleItem.IntegerProperty.HasValue);
Assert.IsFalse(entityMappedFromSingleItem.DoubleProperty.HasValue);
Assert.IsFalse(entityMappedFromSingleItem.CurrencyProperty.HasValue);
Assert.IsFalse(entityMappedFromSingleItem.BoolProperty.HasValue);
Assert.IsFalse(entityMappedFromSingleItem.DateTimeProperty.HasValue);
Assert.IsFalse(entityMappedFromSingleItem.GuidProperty.HasValue);
// #2 Check SPListItemVersion-mapped values
Assert.IsFalse(entityMappedFromItemVersion.IntegerProperty.HasValue);
Assert.IsFalse(entityMappedFromItemVersion.DoubleProperty.HasValue);
Assert.IsFalse(entityMappedFromItemVersion.CurrencyProperty.HasValue);
Assert.IsFalse(entityMappedFromItemVersion.BoolProperty.HasValue);
Assert.IsFalse(entityMappedFromItemVersion.DateTimeProperty.HasValue);
Assert.IsFalse(entityMappedFromItemVersion.GuidProperty.HasValue);
// #1 Check SPListItemCollection/DataRow-mapped values
// Note that the DataRow item conversion prevents us from distinguishing
// empty integer value from 0.
Assert.AreEqual(0, entitiesMappedFromItemCollection[0].IntegerProperty);
Assert.IsFalse(entitiesMappedFromItemCollection[0].DoubleProperty.HasValue);
Assert.IsFalse(entitiesMappedFromItemCollection[0].CurrencyProperty.HasValue);
Assert.IsFalse(entitiesMappedFromItemCollection[0].BoolProperty.HasValue);
Assert.IsFalse(entitiesMappedFromItemCollection[0].DateTimeProperty.HasValue);
Assert.IsFalse(entitiesMappedFromItemCollection[0].GuidProperty.HasValue);
}
}
}
public void EnsureField_WhenAttemptingToSetEnforceUniqueValue_ButFieldTypeDoesntSupportUniqueness_ShouldThrowNotSupportedException()
{
using (var testScope = SiteTestScope.BlankSite())
{
// Arrange
BooleanFieldInfo boolFieldInfoBasic = new BooleanFieldInfo(
"TestInternalNameBool",
new Guid("{F556AB6B-9E51-43E2-99C9-4A4E551A4BEF}"),
"NameKeyBool",
"DescriptionKeyBool",
"GroupKey")
{
EnforceUniqueValues = true
};
GuidFieldInfo guidFieldInfo = new GuidFieldInfo(
"TestInternalNameGuid",
new Guid("{7F486426-D3BC-48D8-8E28-85CFC9A457A0}"),
"NameKeyGuid",
"DescriptionKeyGuid",
"GroupKey")
{
EnforceUniqueValues = true
};
NoteFieldInfo noteFieldInfo = new NoteFieldInfo(
"TestInternalNameNote",
new Guid("{E315BB24-19C3-4F2E-AABC-9DE5EFC3D5C2}"),
"NameKeyAlt",
"DescriptionKeyAlt",
"GroupKey")
{
EnforceUniqueValues = true
};
HtmlFieldInfo htmlFieldInfo = new HtmlFieldInfo(
"TestInternalNameHtml",
new Guid("{D16958E7-CF9A-4C38-A8BB-99FC03BFD913}"),
"NameKeyAlt",
"DescriptionKeyAlt",
"GroupKey")
{
EnforceUniqueValues = true
};
ImageFieldInfo imageFieldInfo = new ImageFieldInfo(
"TestInternalNameImage",
new Guid("{6C5B9E77-B621-43AA-BFBF-B333093EFCAE}"),
"NameKeyImage",
"DescriptionKeyImage",
"GroupKey")
{
EnforceUniqueValues = true
};
UrlFieldInfo urlFieldInfo = new UrlFieldInfo(
"TestInternalNameUrl",
new Guid("{208F904C-5A1C-4E22-9A79-70B294FABFDA}"),
"NameKeyUrl",
"DescriptionKeyUrl",
"GroupKey")
{
EnforceUniqueValues = true
};
UrlFieldInfo urlFieldInfoImage = new UrlFieldInfo(
"TestInternalNameUrlImg",
new Guid("{96D22CFF-5B40-4675-B632-28567792E11B}"),
"NameKeyUrlImg",
"DescriptionKeyUrlImg",
"GroupKey")
{
Format = UrlFieldFormat.Image,
EnforceUniqueValues = true
};
LookupMultiFieldInfo lookupMultiFieldInfo = new LookupMultiFieldInfo(
"TestInternalNameLookupM",
new Guid("{2C9D4C0E-21EB-4742-8C6C-4C30DCD08A05}"),
"NameKeyMulti",
"DescriptionKeyMulti",
"GroupKey")
{
EnforceUniqueValues = true
};
var ensuredUser1 = testScope.SiteCollection.RootWeb.EnsureUser(Environment.UserDomainName + "\\" + Environment.UserName);
var ensuredUser2 = testScope.SiteCollection.RootWeb.EnsureUser("OFFICE\\maxime.boissonneault");
UserMultiFieldInfo userMultiFieldInfo = new UserMultiFieldInfo(
"TestInternalNameUserMulti",
new Guid("{8C662588-D54E-4905-B232-856C2239B036}"),
"NameKeyUserMulti",
"DescriptionKeyUserMulti",
"GroupKey")
{
EnforceUniqueValues = true
};
MediaFieldInfo mediaFieldInfo = new MediaFieldInfo(
"TestInternalNameMedia",
new Guid("{A2F070FE-FE33-44FC-9FDF-D18E74ED4D67}"),
"NameKeyMedia",
"DescriptionKeyMEdia",
"GroupKey")
{
EnforceUniqueValues = true
};
var testTermSet = new TermSetInfo(Guid.NewGuid(), "Test Term Set"); // keep Ids random because, if this test fails midway, the term
// set will not be cleaned up and upon next test run we will
// run into a term set and term ID conflicts.
var levelOneTermA = new TermInfo(Guid.NewGuid(), "Term A", testTermSet);
var levelOneTermB = new TermInfo(Guid.NewGuid(), "Term B", testTermSet);
var levelTwoTermAA = new TermInfo(Guid.NewGuid(), "Term A-A", testTermSet);
var levelTwoTermAB = new TermInfo(Guid.NewGuid(), "Term A-B", testTermSet);
TaxonomySession session = new TaxonomySession(testScope.SiteCollection);
TermStore defaultSiteCollectionTermStore = session.DefaultSiteCollectionTermStore;
Group defaultSiteCollectionGroup = defaultSiteCollectionTermStore.GetSiteCollectionGroup(testScope.SiteCollection);
TermSet newTermSet = defaultSiteCollectionGroup.CreateTermSet(testTermSet.Label, testTermSet.Id);
Term createdTermA = newTermSet.CreateTerm(levelOneTermA.Label, Language.English.Culture.LCID, levelOneTermA.Id);
Term createdTermB = newTermSet.CreateTerm(levelOneTermB.Label, Language.English.Culture.LCID, levelOneTermB.Id);
Term createdTermAA = createdTermA.CreateTerm(levelTwoTermAA.Label, Language.English.Culture.LCID, levelTwoTermAA.Id);
Term createdTermAB = createdTermA.CreateTerm(levelTwoTermAB.Label, Language.English.Culture.LCID, levelTwoTermAB.Id);
defaultSiteCollectionTermStore.CommitAll();
TaxonomyMultiFieldInfo taxoMultiFieldInfo = new TaxonomyMultiFieldInfo(
"TestInternalNameTaxoMulti",
new Guid("{2F49D362-B014-41BB-9959-1000C9A7FFA0}"),
"NameKeyMulti",
"DescriptionKey",
"GroupKey")
{
EnforceUniqueValues = true,
TermStoreMapping = new TaxonomyContext(levelOneTermA) // choices limited to children of a specific term, instead of having full term set choices
};
ListInfo lookupListInfo = new ListInfo("sometestlistpathlookup", "DynamiteTestListNameKeyLookup", "DynamiteTestListDescriptionKeyLookup");
ListInfo listInfo = new ListInfo("sometestlistpathalt", "DynamiteTestListNameKeyAlt", "DynamiteTestListDescriptionKeyAlt");
using (var injectionScope = IntegrationTestServiceLocator.BeginLifetimeScope())
{
var fieldHelper = injectionScope.Resolve<IFieldHelper>();
var listHelper = injectionScope.Resolve<IListHelper>();
// Lookup field ListId setup
SPList lookupList = listHelper.EnsureList(testScope.SiteCollection.RootWeb, lookupListInfo);
lookupMultiFieldInfo.ListId = lookupList.ID;
// Create the looked-up items
var lookupItem1 = lookupList.Items.Add();
lookupItem1["Title"] = "Test Item 1";
lookupItem1.Update();
var lookupItem2 = lookupList.Items.Add();
lookupItem2["Title"] = "Test Item 2";
lookupItem2.Update();
// Create the test list (which should provision both site columns and list columns)
SPList list = listHelper.EnsureList(testScope.SiteCollection.RootWeb, listInfo);
// Act + Assert
try
{
fieldHelper.EnsureField(list.Fields, boolFieldInfoBasic);
Assert.Fail("Should've thrown NotSupportedException because Boolean fields don't support EnforceUniqueValues.");
}
catch (NotSupportedException)
{
}
try
{
fieldHelper.EnsureField(list.Fields, guidFieldInfo);
Assert.Fail("Should've thrown NotSupportedException because Guid fields don't support EnforceUniqueValues.");
}
catch (NotSupportedException)
{
}
try
{
fieldHelper.EnsureField(list.Fields, noteFieldInfo);
Assert.Fail("Should've thrown NotSupportedException because Note fields don't support EnforceUniqueValues.");
}
catch (NotSupportedException)
{
}
try
{
fieldHelper.EnsureField(list.Fields, htmlFieldInfo);
Assert.Fail("Should've thrown NotSupportedException because Html fields don't support EnforceUniqueValues.");
}
catch (NotSupportedException)
{
}
try
{
fieldHelper.EnsureField(list.Fields, imageFieldInfo);
Assert.Fail("Should've thrown NotSupportedException because Image fields don't support EnforceUniqueValues.");
}
catch (NotSupportedException)
{
}
try
{
fieldHelper.EnsureField(list.Fields, urlFieldInfo);
Assert.Fail("Should've thrown NotSupportedException because URL fields don't support EnforceUniqueValues.");
}
catch (NotSupportedException)
{
}
try
{
fieldHelper.EnsureField(list.Fields, urlFieldInfoImage);
Assert.Fail("Should've thrown NotSupportedException because URL-Image fields don't support EnforceUniqueValues.");
}
catch (NotSupportedException)
{
}
try
{
fieldHelper.EnsureField(list.Fields, lookupMultiFieldInfo);
Assert.Fail("Should've thrown NotSupportedException because LookupMulti fields don't support EnforceUniqueValues.");
}
catch (NotSupportedException)
{
}
try
{
fieldHelper.EnsureField(list.Fields, userMultiFieldInfo);
Assert.Fail("Should've thrown NotSupportedException because UserMulti fields don't support EnforceUniqueValues.");
}
catch (NotSupportedException)
{
}
try
{
fieldHelper.EnsureField(list.Fields, mediaFieldInfo);
Assert.Fail("Should've thrown NotSupportedException because Media fields don't support EnforceUniqueValues.");
}
catch (NotSupportedException)
{
}
try
{
fieldHelper.EnsureField(list.Fields, taxoMultiFieldInfo);
Assert.Fail("Should've thrown NotSupportedException because TaxoMulti fields don't support EnforceUniqueValues.");
}
catch (NotSupportedException)
{
}
}
}
}
public void EnsureField_WhenGuidField_ShouldApplyGuidFieldDefinitionAndDefaultValue()
{
using (var testScope = SiteTestScope.BlankSite())
{
GuidFieldInfo guidFieldInfo = new GuidFieldInfo(
"TestInternalNameGuid",
new Guid("{0C58B4A1-B360-47FE-84F7-4D8F58AE80F6}"),
"NameKey",
"DescriptionKey",
"GroupKey")
{
};
GuidFieldInfo guidFieldInfoAlt = new GuidFieldInfo(
"TestInternalNameGuidAlt",
new Guid("{04EDC708-CD42-434D-860D-85D8CF09AE3D}"),
"NameKeyAlt",
"DescriptionKeyAlt",
"GroupKey")
{
DefaultValue = new Guid("{365193B4-77F9-4C69-A131-6963B3DE3C38}")
};
using (var injectionScope = IntegrationTestServiceLocator.BeginLifetimeScope())
{
IFieldHelper fieldHelper = injectionScope.Resolve<IFieldHelper>();
var fieldsCollection = testScope.SiteCollection.RootWeb.Fields;
// 1) Basic guid field definition (all default property values)
SPFieldGuid guidField = (SPFieldGuid)fieldHelper.EnsureField(fieldsCollection, guidFieldInfo);
this.ValidateFieldBasicValues(guidFieldInfo, guidField);
Assert.IsTrue(string.IsNullOrEmpty(guidField.DefaultValue));
SPFieldGuid guidFieldRefetched = (SPFieldGuid)testScope.SiteCollection.RootWeb.Fields[guidFieldInfo.Id];
this.ValidateFieldBasicValues(guidFieldInfo, guidFieldRefetched);
Assert.IsTrue(string.IsNullOrEmpty(guidFieldRefetched.DefaultValue));
// 2) Guid field with a default value
SPFieldGuid guidFieldAlt = (SPFieldGuid)fieldHelper.EnsureField(fieldsCollection, guidFieldInfoAlt);
this.ValidateFieldBasicValues(guidFieldInfoAlt, guidFieldAlt);
Assert.AreEqual(new Guid("{365193B4-77F9-4C69-A131-6963B3DE3C38}"), new Guid(guidFieldAlt.DefaultValue));
SPFieldGuid guidFieldAltRefetched = (SPFieldGuid)testScope.SiteCollection.RootWeb.Fields[guidFieldInfoAlt.Id];
this.ValidateFieldBasicValues(guidFieldInfoAlt, guidFieldAltRefetched);
Assert.AreEqual(new Guid("{365193B4-77F9-4C69-A131-6963B3DE3C38}"), new Guid(guidFieldAltRefetched.DefaultValue));
}
}
}
public void WriteValueToListItem_GivenGuidFieldInfo_ShouldUseGuidValueWriter()
{
using (ShimsContext.Create())
{
// Arrange
var correctWriterWasUsed = false;
var fieldInfo = new GuidFieldInfo("InternalName", Guid.NewGuid(), string.Empty, string.Empty, string.Empty);
ShimGuidValueWriter.AllInstances.WriteValueToListItemSPListItemFieldValueInfo = (inst, listItem, fieldValueInfo) =>
{
correctWriterWasUsed = true;
};
var fakeListItem = new ShimSPListItem().Instance;
IFieldValueWriter writer;
using (var scope = UnitTestServiceLocator.BeginLifetimeScope())
{
writer = scope.Resolve<IFieldValueWriter>();
}
// Act
writer.WriteValueToListItem(fakeListItem, new FieldValueInfo(fieldInfo, null));
// Assert
Assert.IsTrue(correctWriterWasUsed, "The GuidValueWriter should have been used for the GuidFieldInfo type.");
}
}
