Beispiel #1
0
        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);
                }
            }
        }
Beispiel #3
0
        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)
                    {
                    }
                }
            }
        }
Beispiel #4
0
        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.");
            }
        }