@zxncij2390/monorepo3 3.18.0

package/test/sp/taxonomy.ts

@@ -0,0 +1,178 @@
+import { expect } from "chai";
+import "@pnp/sp/taxonomy";
+import { ITermSet } from "@pnp/sp/taxonomy";
+
+describe("Taxonomy", function () {
+
+    before(function () {
+
+        if (!this.pnp.settings.enableWebTests) {
+            this.skip();
+        }
+    });
+
+    describe("TermStore", function () {
+        it("-invoke", async function () {
+
+            const info = await this.pnp.sp.termStore();
+            return expect(info).has.property("id");
+        });
+
+        it("groups", async function () {
+            const info = await this.pnp.sp.termStore.groups();
+
+            if (info === undefined || info.length < 1) {
+                return expect(info).to.be.an("Array");
+            }
+
+            return expect(info[0]).has.property("id");
+        });
+
+        // TODO: sets gives API not found error on termStore... need to remove/or fix.
+        it.skip(".sets", async function () {
+            const url = this.pnp.sp.termStore.sets.toRequestUrl();
+            console.log(`Sets: ${url}`);
+            const info = await this.pnp.sp.termStore.sets();
+            if (info === undefined || info.length < 1) {
+                return expect(info).to.be.an("Array");
+            }
+
+            return expect(info[0]).has.property("id");
+        });
+
+        it("groups.getById", async function () {
+
+            const info = await this.pnp.sp.termStore.groups();
+
+            if (info === undefined || info.length < 1) {
+                return expect(info).to.be.an("Array");
+            }
+
+            const group = await this.pnp.sp.termStore.groups.getById(info[0].id)();
+
+            return expect(group).has.property("id");
+        });
+
+        // TODO: sets gives API not found error on termStore... need to remove/or fix.
+        it.skip(".sets.getById", async function () {
+
+            const info = await this.pnp.sp.termStore.sets();
+
+            if (info === undefined || info.length < 1) {
+                return expect(info).to.be.an("Array");
+            }
+
+            const set = await this.pnp.sp.termStore.sets.getById(info[0].id)();
+            return expect(set).has.property("id");
+        });
+    });
+    /**
+     * Term Sets
+     */
+    describe("TermSets", function () {
+        let termset: ITermSet = null;
+
+        before(async function () {
+            const groups = await this.pnp.sp.termStore.groups();
+
+            if (groups === undefined || groups?.length < 1) {
+                this.skip();
+            }
+            const groupId = groups[0].id;
+
+            const sets = await this.pnp.sp.termStore.groups.getById(groupId).sets();
+            if (sets === undefined || sets?.length < 1) {
+                this.skip();
+            }
+            const termsetId = sets[0].id;
+            termset = this.pnp.sp.termStore.groups.getById(groupId).sets.getById(termsetId);
+        });
+
+        it("terms", async function () {
+            const terms = await termset.terms();
+            return expect(terms).to.be.an("Array");
+        });
+
+        // TODO: parentGroup gives API not found error on termset... need to remove/or fix.
+        it.skip(".parentGroup", async function () {
+            const parentGroup = await termset.parentGroup();
+            return expect(parentGroup).has.property("id");
+        });
+
+        it("children", async function () {
+            const children = await termset.children();
+            return expect(children).to.be.an("Array");
+        });
+
+        it("relations", async function () {
+            const relations = await termset.relations();
+            return expect(relations).to.be.an("Array");
+        });
+
+        it("getTermById", async function () {
+            const terms = await termset.terms();
+            if (terms.length < 1) {
+                return;
+            }
+            const termById = await termset.getTermById(terms[0].id)();
+            return expect(termById).has.property("id");
+        });
+        it("getAllChildrenAsOrderedTree", async function () {
+            const tree = await termset.getAllChildrenAsOrderedTree();
+            return expect(tree).to.be.an("Array");
+        });
+        it("getAllChildrenAsOrderedTree-retreiveProperties", async function () {
+            const tree = await termset.getAllChildrenAsOrderedTree({ retrieveProperties: true });
+            if (tree.length < 1) {
+                return;
+            }
+            const term = tree[0];
+            return expect(term).has.property("localProperties");
+        });
+    });
+
+    /**
+     * Terms
+     */
+    describe("Terms", function () {
+        let term = null;
+
+        before(async function () {
+            const groups = await this.pnp.sp.termStore.groups();
+
+            if (groups === undefined || groups?.length < 1) {
+                this.skip();
+            }
+            const groupId = groups[0].id;
+
+            const sets = await this.pnp.sp.termStore.groups.getById(groupId).sets();
+
+            if (sets === undefined || sets?.length < 1) {
+                this.skip();
+            }
+            const setId = sets[0].id;
+
+            const terms = await this.pnp.sp.termStore.groups.getById(groupId).sets.getById(setId).terms();
+            if (terms === undefined || terms?.length < 1) {
+                this.skip();
+            }
+            const termId = terms[0].id;
+            term = this.pnp.sp.termStore.groups.getById(groupId).sets.getById(setId).terms.getById(termId);
+        });
+
+        it("getById", async function () {
+            const info = await term();
+            return expect(info).has.property("id");
+        });
+
+        it("term.children", async function () {
+            const children = await term.children();
+            return expect(children).to.be.an("Array");
+        });
+
+        it("term.relations", async function () {
+            const relations = await term.relations();
+            return expect(relations).to.be.an("Array");
+        });
+    });
+});

package/test/sp/user-custom-actions.ts

@@ -0,0 +1,31 @@
+import { expect } from "chai";
+import "@pnp/sp/webs";
+import "@pnp/sp/user-custom-actions";
+
+describe("UserCustomActions", function () {
+
+    before(function () {
+
+        if (!this.pnp.settings.enableWebTests) {
+            this.skip();
+        }
+    });
+
+    it("-invoke", async function () {
+        const actions = await this.pnp.sp.web.userCustomActions();
+        return expect(actions).to.be.an("Array");
+    });
+
+    it("getById", async function () {
+        const actions = await this.pnp.sp.web.userCustomActions();
+        if (actions === undefined || actions.length < 1) {
+            this.skip();
+        }
+        const action = await this.pnp.sp.web.userCustomActions.getById(actions[0].Id)();
+        return expect(action).to.haveOwnProperty("update");
+    });
+
+    it("clear", function () {
+        return expect(this.pnp.sp.web.userCustomActions.clear()).to.eventually.to.fulfilled;
+    });
+});

package/test/sp/views.ts

@@ -0,0 +1,117 @@
+import { expect } from "chai";
+import { getRandomString } from "@pnp/core";
+import "@pnp/sp/webs";
+import "@pnp/sp/lists";
+import "@pnp/sp/views";
+import { IList } from "@pnp/sp/lists";
+
+describe("Views", function () {
+
+    let list: IList;
+
+    before(async function () {
+
+        if (!this.pnp.settings.enableWebTests) {
+            this.skip();
+        }
+
+        // we need to create a list for manipulating views
+        const result = await this.pnp.sp.web.lists.ensure(`ViewTestList_${getRandomString(4)}`, "Testing Views");
+
+        list = result.list;
+    });
+
+    it("-invoke", function () {
+        return expect(list.views()).to.eventually.be.fulfilled;
+    });
+
+    it("defaultView", function () {
+        return expect(list.defaultView()).to.eventually.be.fulfilled;
+    });
+
+    it("getById", async function () {
+        const v: { Id: string } = await list.defaultView.select("Id")();
+        return expect(list.views.getById(v.Id)()).to.eventually.be.fulfilled;
+    });
+
+    it("getView", async function () {
+        const v: { Id: string } = await list.defaultView.select("Id")();
+        const vId = v.Id;
+        const lv = await list.getView(vId)();
+        return expect(lv.Id).to.equal(vId);
+    });
+
+    it("getByTitle", async function () {
+        const v = await list.views.top(1).select("Title")<{ Title: string }[]>();
+        if (v.length > 0) {
+            const vTitle = v[0].Title;
+            const lv = await list.views.getByTitle(vTitle)();
+            return expect(lv.Title).to.eq(vTitle);
+        } else {
+            return false;
+        }
+    });
+
+    it("add", async function () {
+        const viewTitle = `Test-Add-View_${getRandomString(4)}`;
+        const av = await list.views.add(viewTitle, false);
+        return expect(av.data.Title).to.eq(viewTitle);
+    });
+
+    it("fields", async function () {
+        const vf = await list.defaultView.fields();
+        return expect(vf).to.have.property("SchemaXml");
+    });
+
+    it("update", async function () {
+        const r = await list.views.add(`Update-Test-View_${getRandomString(4)}`);
+        await r.view.update({
+            RowLimit: 20,
+        });
+        const v = await list.views.getById(r.data.Id)();
+        return expect(v.RowLimit).to.eq(20);
+    });
+
+    it("renderAsHtml", async function () {
+        const vHtml = await list.defaultView.renderAsHtml();
+        return expect(vHtml).to.have.length.greaterThan(0);
+    });
+
+    it("setViewXml", async function () {
+        const r = await list.views.add(`setViewXml-Test-View_${getRandomString(4)}`);
+        const xml = "<View><Query><Where><Eq><FieldRef Name='Title'/><Value Type='Text'>Test</Value></Eq></Where></Query></View>";
+        return expect(r.view.setViewXml(xml)).to.eventually.be.fulfilled;
+    });
+
+    describe("ViewFields", function () {
+
+        it("getSchemaXml", async function () {
+            const fieldSchema = await list.defaultView.fields.getSchemaXml();
+            return expect(fieldSchema).to.have.length.greaterThan(0);
+        });
+
+        it("add", async function () {
+            const r = await list.views.add(`add-Test-ViewFields_${getRandomString(4)}`);
+            return expect(r.view.fields.add("Created")).to.eventually.be.fulfilled;
+        });
+
+        it("move", async function () {
+            const r = await list.views.add(`move-Test-ViewFields_${getRandomString(4)}`);
+            await r.view.fields.add("Modified");
+            return expect(r.view.fields.move("Modified", 0)).to.eventually.be.fulfilled;
+        });
+
+        it("remove", async function () {
+            const r = await list.views.add(`remove-Test-ViewFields_${getRandomString(4)}`);
+            await r.view.fields.add("Author");
+            return expect(r.view.fields.remove("Author")).to.eventually.be.fulfilled;
+        });
+
+        it("removeAll", async function () {
+            const r = await list.views.add(`removeAll-Test-ViewFields_${getRandomString(4)}`);
+            return expect(r.view.fields.removeAll()).to.eventually.be.fulfilled;
+        });
+    });
+});
+
+

package/test/sp/webparts.ts

@@ -0,0 +1,38 @@
+import { expect } from "chai";
+import "@pnp/sp/webs";
+import { combine, getRandomString } from "@pnp/core";
+import { ILimitedWebPartManager, WebPartsPersonalizationScope } from "@pnp/sp/presets/all";
+
+describe("WebParts", function () {
+
+    before(function () {
+
+        if (!this.pnp.settings.enableWebTests) {
+            this.skip();
+        }
+    });
+
+    it("ensureLimitedWebPartManager-ScopeShared", async function () {
+        const lwm = this.pnp.sp.web.folders.getByUrl("SitePages").files.getByUrl("Home.aspx").getLimitedWebPartManager(WebPartsPersonalizationScope.Shared);
+        const scope = await lwm.scope();
+
+        return expect(scope).to.be.equal(1);
+    });
+
+    it("ensureLimitedWebPartManager-ScopeUser", async function () {
+        const lwm = this.pnp.sp.web.folders.getByUrl("SitePages").files.getByUrl("Home.aspx").getLimitedWebPartManager(WebPartsPersonalizationScope.User);
+        const scope = await lwm.scope();
+
+        return expect(scope).to.be.equal(0);
+    });
+
+    it("webpartDefinitions", async function () {
+        const currentWeb = await this.pnp.sp.web.select("ServerRelativeUrl")();
+        const pageName = `Test_Page_${getRandomString(5)}.aspx`;
+        const pageAddress = combine("/", currentWeb.ServerRelativeUrl, "/SitePages/", pageName);
+        await this.pnp.sp.web.addClientsidePage(pageName);
+        const lwm: ILimitedWebPartManager = this.pnp.sp.web.getFileByUrl(pageAddress).getLimitedWebPartManager();
+        const webparts = await lwm.webparts();
+        return expect(webparts).to.be.an.instanceOf(Array).and.be.empty;
+    });
+});

package/test/sp/webs.ts

@@ -0,0 +1,249 @@
+import { combine, getRandomString } from "@pnp/core";
+import { expect } from "chai";
+import "@pnp/sp/webs";
+import "@pnp/sp/content-types/web";
+import "@pnp/sp/lists/web";
+import "@pnp/sp/navigation/web";
+import "@pnp/sp/site-users/web";
+import "@pnp/sp/site-groups/web";
+import "@pnp/sp/folders/web";
+import "@pnp/sp/files/web";
+import "@pnp/sp/user-custom-actions/web";
+import "@pnp/sp/related-items/web";
+import "@pnp/sp/fields/web";
+import "@pnp/sp/features/web";
+import "@pnp/sp/hubsites/web";
+import "@pnp/sp/appcatalog";
+import "@pnp/sp/regional-settings/web";
+import "@pnp/sp/clientside-pages";
+import "@pnp/sp/security";
+import { INavNodeInfo } from "@pnp/sp/navigation/types.js";
+import testSPInvokables from "../test-invokable-props.js";
+import { Web } from "@pnp/sp/webs";
+
+describe("Webs", function () {
+
+    before(function () {
+
+        if (!this.pnp.settings.enableWebTests) {
+            this.skip();
+        }
+    });
+
+    it.skip("add 1", function () {
+        const title = `Test_ChildWebAdd1_${getRandomString(8)}`;
+        return expect(this.pnp.sp.web.webs.add(title, title)).to.eventually.be.fulfilled;
+    });
+
+    it.skip("add 2", function () {
+        const title = `Test_ChildWebAdd2_${getRandomString(8)}`;
+        return expect(this.pnp.sp.web.webs.add(title, title, "description", "FunSite#0", 1033, false)).to.eventually.be.fulfilled;
+    });
+});
+
+describe("Web static Tests", function () {
+
+    it("properly parses different contructor args", function () {
+
+        const w1 = Web("https://something.com");
+        expect(w1.toUrl(), "test 1").to.eq("https://something.com/_api/web");
+
+        const w2 = Web("https://something.com/_api/web");
+        expect(w2.toUrl(), "test 2").to.eq("https://something.com/_api/web");
+
+        const w3 = Web("https://something.com/_api/web/_api/web");
+        expect(w3.toUrl(), "test 3").to.eq("https://something.com/_api/web");
+
+        const w4 = Web("https://something.com/_api/web/lists/getById('2984791847')/items");
+        expect(w4.toUrl(), "test 4").to.eq("https://something.com/_api/web");
+
+        const w5a = Web("https://something.com/");
+        const w5b = Web(w5a);
+        expect(w5b.toUrl(), "test 5").to.eq("https://something.com/_api/web");
+
+        const w6a = Web("https://something.com/_api/web/rootweb/something/random('asdfa')");
+        const w6b = Web(w6a);
+        expect(w6b.toUrl(), "test 6").to.eq("https://something.com/_api/web");
+    });
+});
+
+describe("Web", function () {
+
+    let web;
+    before(function () {
+
+        if (!this.pnp.settings.enableWebTests) {
+            this.skip();
+        }
+        web = this.pnp.sp.web;
+    });
+
+    describe("Invokable Properties", testSPInvokables(() => web,
+        "roleDefinitions",
+        "webs",
+        "contentTypes",
+        "lists",
+        "siteUserInfoList",
+        "defaultDocumentLibrary",
+        "customListTemplates",
+        "siteUsers",
+        "siteGroups",
+        "userCustomActions",
+        "allProperties",
+        "webinfos",
+        "features",
+        "fields",
+        "availablefields",
+        "folders",
+        "rootFolder",
+        "regionalSettings"));
+
+    it("navigation", async function () {
+        const ql: INavNodeInfo[] = await this.pnp.sp.web.navigation.quicklaunch();
+        const tn: INavNodeInfo[] = await this.pnp.sp.web.navigation.topNavigationBar();
+        const success = (ql.constructor === Array) && (tn.constructor === Array);
+        return expect(success).to.be.true;
+    });
+
+    it("getParentWeb", async function () {
+
+        const v = await this.pnp.sp.web.getParentWeb();
+        const parentWeb = await v.select("Title")();
+
+        return expect(parentWeb).to.haveOwnProperty("Title");
+    });
+
+    it("getSubwebsFilteredForCurrentUser", async function () {
+
+        return expect(this.pnp.sp.web.getSubwebsFilteredForCurrentUser()()).to.eventually.be.fulfilled;
+    });
+
+    it("update", function () {
+
+        const p = this.pnp.sp.web.select("Title")<{ Title: string }>().then((w) => {
+
+            const newTitle = w.Title + " updated";
+            this.pnp.sp.web.update({ Title: newTitle }).then(() => {
+
+                this.pnp.sp.web.select("Title")<{ Title: string }>().then(function (w2) {
+                    if (w2.Title !== newTitle) {
+                        throw Error("Update web failed");
+                    }
+                });
+            });
+        });
+
+        return expect(p).to.eventually.be.fulfilled;
+    });
+
+    // skipping this test as the code hasn't changed in years and it takes longer than any other test
+    it.skip("applyTheme", function () {
+
+        const index = this.pnp.settings.sp.testWebUrl.indexOf("/sites/");
+        const colorUrl = "/" + combine(this.pnp.settings.sp.testWebUrl.substr(index), "/_catalogs/theme/15/palette011.spcolor");
+        const fontUrl = "/" + combine(this.pnp.settings.sp.testWebUrl.substr(index), "/_catalogs/theme/15/fontscheme007.spfont");
+
+        return expect(this.pnp.sp.web.applyTheme(colorUrl, fontUrl, "", false)).to.eventually.be.fulfilled;
+    });
+
+    // Cannot test because once a template has been applied a new site must be created to apply a different template
+    it("applyWebTemplate");
+
+    it("availableWebTemplates", async function () {
+
+        const webTemplates = await this.pnp.sp.web.availableWebTemplates()();
+        return expect(webTemplates).to.be.an.instanceOf(Array).and.be.not.empty;
+    });
+
+    it("getChanges", function () {
+
+        return expect(this.pnp.sp.web.getChanges({
+            Add: true,
+        })).to.eventually.be.fulfilled;
+    });
+
+    it("mapToIcon", function () {
+
+        return expect(this.pnp.sp.web.mapToIcon("test.docx")).to.eventually.be.fulfilled;
+    });
+
+    it("delete", async function () {
+        const url = getRandomString(4);
+        const result = await this.pnp.sp.web.webs.add("Better be deleted!", url);
+        return expect(result.web.delete()).to.eventually.be.fulfilled;
+    });
+
+    describe("client-side-pages", function () {
+        it("getClientSideWebParts", async function () {
+            const webparts = await this.pnp.sp.web.getClientsideWebParts();
+            return expect(webparts).to.be.an.instanceOf(Array).and.be.not.empty;
+        });
+    });
+
+    describe("files", function () {
+        it("getFileByServerRelativePath", async function () {
+            const w = await this.pnp.sp.web.select("ServerRelativeUrl")<{ ServerRelativeUrl: string }>();
+            const path = combine("/", w.ServerRelativeUrl, "SitePages", "Home.aspx");
+            const file = await this.pnp.sp.web.getFileByServerRelativePath(path)();
+            return expect(file.Name).to.equal("Home.aspx");
+        });
+    });
+
+    describe("folders", function () {
+        it("getFolderByServerRelativePath", async function () {
+            const w = await this.pnp.sp.web.select("ServerRelativeUrl")<{ ServerRelativeUrl: string }>();
+            const path = combine("/", w.ServerRelativeUrl, "SitePages");
+            const folder = await this.pnp.sp.web.getFolderByServerRelativePath(path)();
+            return expect(folder.Name).to.equal("SitePages");
+        });
+    });
+
+    describe("hub-sites", function () {
+
+        it("hubSiteData", async function () {
+
+            return expect(this.pnp.sp.web.hubSiteData()).to.eventually.be.fulfilled;
+        });
+
+        it("hubSiteData force refresh", async function () {
+
+            return expect(this.pnp.sp.web.hubSiteData(true)).to.eventually.be.fulfilled;
+        });
+
+        it("syncHubSiteTheme", async function () {
+
+            return expect(this.pnp.sp.web.syncHubSiteTheme()).to.eventually.be.fulfilled;
+        });
+    });
+
+    describe("lists", function () {
+
+        it("getList", async function () {
+            const w = await this.pnp.sp.web.select("ServerRelativeUrl")<{ ServerRelativeUrl: string }>();
+            const url = combine(w.ServerRelativeUrl, "SitePages");
+            const list = await this.pnp.sp.web.getList(url)();
+            return expect(list.Title).to.equal("Site Pages");
+        });
+
+        it("getCatalog", function () {
+            return expect(this.pnp.sp.web.getCatalog(113)).to.eventually.be.fulfilled;
+        });
+    });
+
+    describe("related-items", function () {
+
+        it("relatedItems", function () {
+
+            return expect(this.pnp.sp.web.relatedItems).to.not.be.null;
+        });
+    });
+
+    describe("site-users", function () {
+
+        it("getUserById", async function () {
+
+            const users = await this.pnp.sp.web.siteUsers();
+            return expect(this.pnp.sp.web.getUserById(users[0].Id)()).to.eventually.be.fulfilled;
+        });
+    });
+});

package/test/test-invokable-props.ts

@@ -0,0 +1,35 @@
+import { IInvokable } from "@pnp/queryable";
+import { expect } from "chai";
+
+// eslint-disable-next-line max-len
+function testInvokableProps<TargetType extends IInvokable, Keys extends string & keyof TargetType>(targetF: () => TargetType, ...keys: (Keys | [string, () => IInvokable])[]): () => void {
+
+    return () => {
+
+        let target = null;
+
+        before(function () {
+            if (typeof targetF === "function") {
+                target = targetF();
+            }
+        });
+
+        for (let i = 0; i < keys.length; i++) {
+
+            if (typeof keys[i] === "string") {
+
+                it(<string>keys[i], function () {
+                    return expect((<any>target)[keys[i]]()).to.eventually.be.fulfilled;
+                });
+
+            } else {
+
+                it(keys[i][0], function () {
+                    return expect((<any>keys)[i][1]()()).to.eventually.be.fulfilled;
+                });
+            }
+        }
+    };
+}
+
+export default testInvokableProps;