@zxncij2390/monorepo3 3.18.0

package/test/sp/groupsitemanager.ts

@@ -0,0 +1,88 @@
+import { expect } from "chai";
+import "@pnp/graph/groups";
+import "@pnp/sp/groupsitemanager";
+import { stringIsNullOrEmpty } from "@pnp/core/util";
+
+describe.skip("GroupSiteManager (without group context)", function () {
+    // skip because app only tests.
+    it("canUserCreateGroup", async function () {
+        const isGroupCreationEnable = await this.pnp.sp.groupSiteManager.canUserCreateGroup();
+        return expect(isGroupCreationEnable).to.be.false;
+    });
+
+    it("getAllOrgLabels", async function () {
+        const orgLabels = await this.pnp.sp.groupSiteManager.getAllOrgLabels(0);
+        return expect(orgLabels).to.not.be.null;
+    });
+
+    it("getGroupCreationContext", async function () {
+        const groupCreationCtx = await this.pnp.sp.groupSiteManager.getGroupCreationContext();
+        return expect(groupCreationCtx).to.not.be.null;
+    });
+
+    it("getGroupSiteConversionData", async function () {
+        const grpSiteConversationData = await this.pnp.sp.groupSiteManager.getGroupSiteConversionData();
+        return expect(grpSiteConversationData).to.not.be.null;
+    });
+
+    it("getUserSharedChannelMemberGroups", async function () {
+        if (this.pnp.settings.testUser?.length < 1) {
+            this.skip();
+        }
+
+        const sharedChannel = await this.pnp.sp.groupSiteManager.getUserSharedChannelMemberGroups(this.pnp.settings.testUser.split("|")[2]);
+        return expect(sharedChannel).to.contain("Exchange.MemberGroup");
+    });
+
+    it("getUserTeamConnectedMemberGroups", async function () {
+        if (this.pnp.settings.testUser?.length < 1) {
+            this.skip();
+        }
+
+        const teamConnected = await this.pnp.sp.groupSiteManager.getUserTeamConnectedMemberGroups(this.pnp.settings.testUser.split("|")[2]);
+        return expect(teamConnected).to.contain("Exchange.MemberGroup");
+    });
+
+    it("getValidSiteUrlFromAlias", async function () {
+        const validSiteUrl = await this.pnp.sp.groupSiteManager.getValidSiteUrlFromAlias("contoso");
+        return expect(validSiteUrl).to.not.be.null;
+    });
+
+    it("isTeamifyPromptHidden", async function () {
+        const teamifyHidden = await this.pnp.sp.groupSiteManager.isTeamifyPromptHidden(this.pnp.settings.sp.url);
+        return expect(teamifyHidden).to.not.be.null;
+    });
+});
+
+describe("GroupSiteManager (group context)", function () {
+
+    before(async function () {
+        if (stringIsNullOrEmpty(this.pnp.settings.testGroupId)) {
+            this.skip();
+        }
+    });
+
+    it("create", async function () {
+        const grpSite = await this.pnp.sp.groupSiteManager.create(this.pnp.settings.testGroupId);
+        return expect(grpSite.SiteStatus).to.eq(2);
+    });
+
+    it("getSiteStatus", async function () {
+        const parentGrp = await this.pnp.sp.groupSiteManager.getSiteStatus(this.pnp.settings.testGroupId);
+        return expect(parentGrp.SiteStatus).to.to.eq(2);
+    });
+
+    it("notebook", async function () {
+        const grpNotebook = await this.pnp.sp.groupSiteManager.notebook(this.pnp.settings.testGroupId);
+        console.log(grpNotebook);
+        return expect(grpNotebook).to.contain("SiteAssets");
+    });
+
+    // Remove the test data we created
+    after(async function () {
+        if (!stringIsNullOrEmpty(this.pnp.settings.testGroupId)) {
+            await this.pnp.graph.groups.getById(this.pnp.settings.testGroupId).delete();
+        }
+        return;
+    });
+});

package/test/sp/hubsites.ts

@@ -0,0 +1,41 @@
+import { expect } from "chai";
+import "@pnp/sp/sites";
+import "@pnp/sp/hubsites";
+import { spfi } from "@pnp/sp";
+
+describe("Hubsites", function () {
+
+    let hubSiteId: string;
+
+    before(async function () {
+
+        if (!this.pnp.settings.enableWebTests) {
+            this.skip();
+        }
+
+        const rootSite = spfi([this.pnp.sp.site, this.pnp.settings.sp.url]);
+
+        await rootSite.site.registerHubSite();
+        const r = await rootSite.site.select("Id")();
+        hubSiteId = r.Id;
+    });
+
+    it("getById", function () {
+        return expect(this.pnp.sp.hubSites.getById(hubSiteId)()).to.eventually.be.fulfilled;
+    });
+
+    it("getSite", async function () {
+
+        const hs = await this.pnp.sp.hubSites.getById(hubSiteId).getSite();
+
+        return expect(hs.select("Title")()).to.eventually.be.fulfilled;
+    });
+
+    // unregister the test site, so that tests will run successfully next time as well
+    after(async function () {
+        if (this.pnp.settings.enableWebTests) {
+            return this.pnp.sp.site.unRegisterHubSite();
+        }
+        return;
+    });
+});

package/test/sp/items.ts

@@ -0,0 +1,179 @@
+import { getRandomString } from "@pnp/core";
+import { expect } from "chai";
+import "@pnp/sp/lists/web";
+import "@pnp/sp/items/list";
+import "@pnp/sp/items/get-all";
+import "@pnp/sp/batching";
+import { IList } from "@pnp/sp/lists";
+import testSPInvokables from "../test-invokable-props.js";
+import { IItem } from "@pnp/sp/items";
+
+describe("Items", function () {
+
+    let list: IList = null;
+    let item: IItem = null;
+    const listTitle = "ItemTestList";
+
+    before(async function () {
+
+        if (!this.pnp.settings.enableWebTests) {
+            this.skip();
+        }
+
+        const ler = await this.pnp.sp.web.lists.ensure(listTitle, "Used to test item operations");
+        list = ler.list;
+
+        if (ler.created) {
+            // add a few items to get started
+            const [spBatch, execute] = this.pnp.sp.batched();
+            spBatch.web.lists.getByTitle(listTitle).items.add({ Title: `Item ${getRandomString(4)}` });
+            spBatch.web.lists.getByTitle(listTitle).items.add({ Title: `Item ${getRandomString(4)}` });
+            spBatch.web.lists.getByTitle(listTitle).items.add({ Title: `Item ${getRandomString(4)}` });
+            spBatch.web.lists.getByTitle(listTitle).items.add({ Title: `Item ${getRandomString(4)}` });
+            spBatch.web.lists.getByTitle(listTitle).items.add({ Title: `Item ${getRandomString(4)}` });
+            await execute();
+        }
+
+        const itemData = await this.pnp.sp.web.lists.getByTitle(listTitle).items.select("Id").top(1)<{ Id: number }[]>();
+        item = this.pnp.sp.web.lists.getByTitle(listTitle).items.getById(itemData[0].Id);
+    });
+
+    after(async function () {
+        // Cleanup list
+        if (list != null) {
+            list.delete();
+        }
+    });
+
+    describe("Invokable Properties - IItem", testSPInvokables(() => item,
+        "effectiveBasePermissions",
+        "effectiveBasePermissionsForUI",
+        "fieldValuesAsHTML",
+        "fieldValuesAsText",
+        "fieldValuesForEdit",
+        "versions",
+        "getParentInfos",
+        "list",
+        "getWopiFrameUrl"));
+
+    it("items", async function () {
+
+        const items = await list.items();
+        expect(items.length).to.be.gt(0);
+    });
+
+    it("getById", async function () {
+
+        const items = await list.items.select("Id").top(1)();
+        const item = items[0];
+        return expect(list.items.getById(item.Id)()).to.eventually.be.fulfilled;
+    });
+
+    it("getPaged", async function () {
+
+        let page = await list.items.top(2).getPaged();
+        // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+        expect(page.hasNext).to.be.true;
+        expect(page.results.length).to.eql(2);
+        page = await page.getNext();
+        // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+        expect(page.hasNext).to.be.true;
+        expect(page.results.length).to.eql(2);
+    });
+
+    it("getAll", async function () {
+
+        const itemCount = await list.select("ItemCount")().then(r => r.ItemCount);
+        const page = await list.items.getAll();
+        return expect(page.length).to.eq(itemCount);
+    });
+
+
+    it("getAll top(2)", async function () {
+
+        const itemCount = await list.select("ItemCount")().then(r => r.ItemCount);
+        const page = await list.items.top(2).getAll();
+        return expect(page.length).to.eq(itemCount);
+    });
+
+    it("effectiveBasePermissions", async function () {
+
+        const item = await list.items.top(1)().then(r => r[0]);
+        return expect(list.items.getById(item.Id).effectiveBasePermissions()).to.eventually.be.fulfilled;
+    });
+
+    it("effectiveBasePermissionsForUI", async function () {
+
+        const item = await list.items.top(1)().then(r => r[0]);
+        return expect(list.items.getById(item.Id).effectiveBasePermissionsForUI()).to.eventually.be.fulfilled;
+    });
+
+    it("fieldValuesAsHTML", async function () {
+
+        const item = await list.items.top(1)().then(r => r[0]);
+        return expect(list.items.getById(item.Id).fieldValuesAsHTML()).to.eventually.be.fulfilled;
+    });
+
+    it("fieldValuesAsText", async function () {
+
+        const item = await list.items.top(1)().then(r => r[0]);
+        return expect(list.items.getById(item.Id).fieldValuesAsText()).to.eventually.be.fulfilled;
+    });
+
+    it("versions", async function () {
+
+        const item = await list.items.top(1)().then(r => r[0]);
+        return expect(list.items.getById(item.Id).versions()).to.eventually.be.fulfilled;
+    });
+
+    it("list", async function () {
+
+        const item = await list.items.top(1)().then(r => r[0]);
+        const listTitle = await list.select("Title")().then(r => r.Title);
+        const itemListTitle = await list.items.getById(item.Id).list.select("Title")().then(r => r.Title);
+        return expect(listTitle).to.eq(itemListTitle);
+    });
+
+    it("update", async function () {
+
+        const item = await list.items.select("Id").top(1)().then(r => r[0]);
+        const iur = await list.items.getById(item.Id).update({
+            Title: `Item ${getRandomString(4)}`,
+        });
+        // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+        expect(iur).to.not.be.null;
+    });
+
+    it("recycle", async function () {
+
+        const item = await list.items.add({
+            Title: "Recycle Me",
+        });
+        return expect(item.item.recycle()).to.eventually.be.fulfilled;
+    });
+
+    /**
+     * Skipped because only system accounts can call this method for items.
+     */
+    it.skip(".deleteWithParams", async function () {
+
+        const title = `test_delparams_${getRandomString(4)}`;
+
+        const item = await list.items.add({
+            Title: title,
+        });
+
+        await item.item.deleteWithParams({
+            BypassSharedLock: false,
+        });
+
+        const r = await list.items.filter(`Title eq '${title}'`)();
+        expect(r.length).to.eq(0);
+    });
+
+    it("getWopiFrameUrl", async function () {
+
+        const item = await list.items.select("Id").top(1)().then(r => r[0]);
+        return expect(list.items.getById(item.Id).getWopiFrameUrl()).to.eventually.be.fulfilled;
+    });
+});

package/test/sp/lists.ts

@@ -0,0 +1,319 @@
+import { expect } from "chai";
+import "@pnp/sp/lists";
+import "@pnp/sp/content-types/list";
+import "@pnp/sp/views/list";
+import "@pnp/sp/folders/list";
+import "@pnp/sp/fields/list";
+import "@pnp/sp/forms/list";
+import "@pnp/sp/items/list";
+import "@pnp/sp/subscriptions/list";
+import "@pnp/sp/user-custom-actions/list";
+import "@pnp/sp/batching";
+import { IList, IRenderListDataParameters, ControlMode, IListEnsureResult, ICamlQuery, IChangeLogItemQuery, RenderListDataOptions } from "@pnp/sp/lists";
+import { getRandomString } from "@pnp/core";
+import testSPInvokables from "../test-invokable-props.js";
+import { Context } from "mocha";
+
+describe("Lists", function () {
+
+    let list;
+    before(function () {
+
+        if (!this.pnp.settings.enableWebTests) {
+            this.skip();
+        }
+        list = this.pnp.sp.web.lists.getByTitle("Documents");
+    });
+
+    describe("Invokable Properties", testSPInvokables(() => list,
+        "effectiveBasePermissions",
+        "eventReceivers",
+        "relatedFields",
+        "informationRightsManagementSettings",
+        "getParentInfos"));
+
+    it("getById", async function () {
+        const list = await this.pnp.sp.web.lists.getByTitle("Documents").select("ID")<{ Id: string }>();
+        const title = await this.pnp.sp.web.lists.getById(list.Id).select("Title")<{ Title: string }>();
+        return expect(title).to.have.property("Title");
+    });
+
+    it("getByTitle", async function () {
+        return expect(this.pnp.sp.web.lists.getByTitle("Documents").select("Title")()).to.eventually.be.fulfilled;
+    });
+
+    it("add 1", function () {
+        const title = `pnp testing add 1 ${getRandomString(4)}`;
+        return expect(this.pnp.sp.web.lists.add(title, title)).to.eventually.be.fulfilled;
+    });
+
+    it("add 2", function () {
+        const title = `pnp testing add 2 ${getRandomString(4)}`;
+        return expect(this.pnp.sp.web.lists.add(title, title, 101, true, <any>{ OnQuickLaunch: true })).to.eventually.be.fulfilled;
+    });
+
+    it("ensure", async function () {
+        const title = "pnp testing ensure";
+        return expect(this.pnp.sp.web.lists.ensure(title)).to.eventually.be.fulfilled;
+    });
+
+    it("ensure with too long title", async function () {
+        const title = getRandomString(512);
+        return expect(this.pnp.sp.web.lists.ensure(title)).to.eventually.be.rejected;
+    });
+
+    it("ensure fail update already existing list", async function () {
+        const title = "pnp testing ensure fail update already existing list";
+        await this.pnp.sp.web.lists.ensure(title);
+        return expect(this.pnp.sp.web.lists.ensure(title, title, 100, false, <any>{ RandomPropertyThatDoesntExistOnObject: "RandomValue" })).to.eventually.be.rejected;
+    });
+
+    it("ensure with additional settings", async function () {
+        const title = "pnp testing ensure with additional settings";
+        return expect(this.pnp.sp.web.lists.ensure(title, title, 101, true, <any>{ OnQuickLaunch: true })).to.eventually.be.fulfilled;
+    });
+
+    it("ensure existing list with additional settings", async function () {
+        const title = "pnp testing ensure existing list with additional settings";
+        await this.pnp.sp.web.lists.ensure(title);
+        return expect(this.pnp.sp.web.lists.ensure(title, title, 101, true, <any>{ OnQuickLaunch: true })).to.eventually.be.fulfilled;
+    });
+
+    it("ensure already existing list", async function () {
+        const title = "pnp testing ensure";
+        await this.pnp.sp.web.lists.ensure(title);
+        return expect(this.pnp.sp.web.lists.ensure(title)).to.eventually.be.fulfilled;
+    });
+
+    it("ensureSiteAssetsLibrary", function () {
+        return expect(this.pnp.sp.web.lists.ensureSiteAssetsLibrary()).to.eventually.be.fulfilled;
+    });
+
+    it("ensureSitePagesLibrary", function () {
+        return expect(this.pnp.sp.web.lists.ensureSitePagesLibrary()).to.eventually.be.fulfilled;
+    });
+});
+
+describe("List", function () {
+
+    let list: IList;
+
+    before(function () {
+
+        if (!this.pnp.settings.enableWebTests) {
+            this.skip();
+        }
+    });
+
+    beforeEach(async function () {
+        list = await this.pnp.sp.web.lists.getByTitle("Documents");
+    });
+
+    it("effectiveBasePermissions", async function () {
+        const listEnsure: IListEnsureResult = await this.pnp.sp.web.lists.ensure("pnp testing effectiveBasePermissions");
+        return expect(listEnsure.list.effectiveBasePermissions()).to.eventually.be.fulfilled;
+    });
+
+    it("eventReceivers", async function () {
+        const listEnsure: IListEnsureResult = await this.pnp.sp.web.lists.ensure("pnp testing eventReceivers");
+        return expect(listEnsure.list.eventReceivers()).to.eventually.be.fulfilled;
+    });
+
+    it("relatedFields", async function () {
+        const listEnsure: IListEnsureResult = await this.pnp.sp.web.lists.ensure("pnp testing relatedFields");
+        return expect(listEnsure.list.relatedFields()).to.eventually.be.fulfilled;
+    });
+
+    it("informationRightsManagementSettings", async function () {
+        const listEnsure: IListEnsureResult = await this.pnp.sp.web.lists.ensure("pnp testing informationRightsManagementSettings");
+        return expect(listEnsure.list.informationRightsManagementSettings()).to.eventually.be.fulfilled;
+    });
+
+    it("update", async function () {
+        const listEnsure: IListEnsureResult = await this.pnp.sp.web.lists.ensure("pnp testing update");
+        const newTitle = "New title after update";
+        return expect(listEnsure.list.update({ Title: newTitle })).to.eventually.be.fulfilled;
+    });
+
+    it("getChanges", async function () {
+        const listEnsure: IListEnsureResult = await this.pnp.sp.web.lists.ensure("pnp testing getChanges");
+        return expect(listEnsure.list.getChanges({
+            Add: true,
+            DeleteObject: true,
+            Restore: true,
+        })).to.eventually.be.fulfilled;
+    });
+
+    it("getItemsByCAMLQuery", async function () {
+        const listEnsure: IListEnsureResult = await this.pnp.sp.web.lists.ensure("pnp testing getItemsByCAMLQuery");
+        const caml: ICamlQuery = {
+            ViewXml: "<View><ViewFields><FieldRef Name='Title' /><FieldRef Name='RoleAssignments' /></ViewFields><RowLimit>5</RowLimit></View>",
+        };
+        return expect(listEnsure.list.getItemsByCAMLQuery(caml, "RoleAssignments")).to.eventually.be.fulfilled;
+    });
+
+    it("getListItemChangesSinceToken", async function () {
+        const listEnsure: IListEnsureResult = await this.pnp.sp.web.lists.ensure("pnp testing getListItemChangesSinceToken");
+        const query: IChangeLogItemQuery = {
+            Contains: "<Contains><FieldRef Name=\"Title\"/><Value Type=\"Text\">Testing</Value></Contains>",
+            // eslint-disable-next-line max-len
+            QueryOptions: "<QueryOptions><IncludeMandatoryColumns>FALSE</IncludeMandatoryColumns><DateInUtc>False</DateInUtc><IncludePermissions>TRUE</IncludePermissions><IncludeAttachmentUrls>FALSE</IncludeAttachmentUrls><Folder>Shared Documents/Test1</Folder></QueryOptions>",
+        };
+        return expect(listEnsure.list.getListItemChangesSinceToken(query)).to.eventually.be.fulfilled;
+    });
+
+    it("recycle", async function () {
+        const listEnsure: IListEnsureResult = await this.pnp.sp.web.lists.ensure("pnp testing recycle");
+        const recycleResponse = await listEnsure.list.recycle();
+        if (typeof recycleResponse !== "string") {
+            throw Error("Expected a string returned from recycle.");
+        }
+        return expect(listEnsure.list.select("Title")()).to.eventually.be.rejected;
+    });
+
+    it("renderListData", async function () {
+        const listEnsure: IListEnsureResult = await this.pnp.sp.web.lists.ensure("pnp testing renderListData");
+        await listEnsure.list.items.add({
+            Title: "Item 1",
+        });
+        await listEnsure.list.items.add({
+            Title: "Item 2",
+        });
+        await listEnsure.list.items.add({
+            Title: "Item 3",
+        });
+
+        return expect(listEnsure.list.renderListData("<View><RowLimit>5</RowLimit></View>")).to.eventually.have.property("Row").that.is.not.empty;
+    });
+
+    const setupRenderListDataAsStream = async function (this: Context): Promise<IList> {
+
+        const listEnsure: IListEnsureResult = await this.pnp.sp.web.lists.ensure("pnp testing renderListDataAsStream");
+
+        if (listEnsure.created) {
+            await listEnsure.list.items.add({
+                Title: "Item 1",
+            });
+            await listEnsure.list.items.add({
+                Title: "Item 2",
+            });
+            await listEnsure.list.items.add({
+                Title: "Item 3",
+            });
+        }
+
+        return listEnsure.list;
+    };
+
+    it("renderListDataAsStream", async function () {
+
+        const rList = await setupRenderListDataAsStream.call(this);
+
+        const renderListDataParams: IRenderListDataParameters = {
+            ViewXml: "<View><RowLimit>5</RowLimit></View>",
+        };
+
+        return expect(rList.renderListDataAsStream(renderListDataParams)).to.eventually.have.property("Row").that.is.not.empty;
+    });
+
+    it("renderListDataAsStream - advanced options", async function () {
+
+        const rList = await setupRenderListDataAsStream.call(this);
+
+        const renderListDataParams: IRenderListDataParameters = {
+            AddRequiredFields: true,
+            RenderOptions: [
+                RenderListDataOptions.ContextInfo,
+                RenderListDataOptions.ListSchema,
+                RenderListDataOptions.MenuView,
+                RenderListDataOptions.FileSystemItemId,
+                RenderListDataOptions.QuickLaunch,
+                RenderListDataOptions.Spotlight,
+                RenderListDataOptions.Visualization,
+                RenderListDataOptions.ViewMetadata,
+                RenderListDataOptions.DisableAutoHyperlink,
+            ],
+            ViewXml: "<View><RowLimit>5</RowLimit></View>",
+        };
+
+        return expect(rList.renderListDataAsStream(renderListDataParams)).to.eventually.be.fulfilled;
+    });
+
+    it("renderListDataAsStream - no override params", async function () {
+
+        const rList = await setupRenderListDataAsStream.call(this);
+
+        const renderListDataParams: IRenderListDataParameters = {
+            AddRequiredFields: true,
+            ViewXml: "<View><RowLimit>5</RowLimit></View>",
+        };
+
+        return expect(rList.renderListDataAsStream(renderListDataParams)).to.eventually.be.fulfilled;
+    });
+
+    it("renderListDataAsStream - query params", async function () {
+
+        const rList = await setupRenderListDataAsStream.call(this);
+
+        const renderListDataParams: IRenderListDataParameters = {
+            AddRequiredFields: false,
+            ViewXml: "<View><RowLimit>5</RowLimit></View>",
+        };
+
+        const r = await rList.renderListDataAsStream(renderListDataParams, {}, new Map([["FilterField1", "Title"], ["FilterValue1", "Item 2"]]));
+
+        // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+        expect(r).to.not.be.null;
+        expect(r.Row.length).to.eq(1);
+    });
+
+    it("renderListFormData", async function () {
+
+        const listEnsure: IListEnsureResult = await this.pnp.sp.web.lists.ensure("pnp testing renderListFormData");
+
+        await listEnsure.list.items.add({
+            Title: "Item 1",
+        });
+
+        return expect(listEnsure.list.renderListFormData(1, "editform", ControlMode.Edit)).to.be.eventually.fulfilled;
+    });
+
+    it("reserveListItemId", function () {
+        return expect(list.reserveListItemId()).to.eventually.be.fulfilled;
+    });
+
+    it("contentTypes", function () {
+        return expect(list.contentTypes()).to.eventually.be.fulfilled;
+    });
+
+    it("fields", function () {
+        return expect(list.fields()).to.eventually.be.fulfilled;
+    });
+
+    it("rootFolder", function () {
+        return expect(list.rootFolder()).to.eventually.be.fulfilled;
+    });
+
+    it("items", function () {
+        return expect(list.items()).to.eventually.be.fulfilled;
+    });
+
+    it("views", async function () {
+        const defaultView = await list.defaultView();
+        expect(list.getView(defaultView.Id));
+        return expect(list.views()).to.eventually.be.fulfilled;
+    });
+
+    it("subscriptions", function () {
+        return expect(list.subscriptions()).to.eventually.be.fulfilled;
+    });
+
+    it("userCustomActions", function () {
+        return expect(list.userCustomActions()).to.eventually.be.fulfilled;
+    });
+
+    it("delete", async function () {
+        const result = await this.pnp.sp.web.lists.add("pnp testing delete");
+        return expect(result.list.delete()).to.eventually.be.fulfilled;
+    });
+});