@zxncij2390/monorepo3 3.18.0

package/test/sp/site-scripts.ts

@@ -0,0 +1,162 @@
+import { getRandomString } from "@pnp/core";
+import { expect } from "chai";
+import "@pnp/sp/site-scripts";
+import { IList } from "@pnp/sp/lists";
+import { spfi, SPFI } from "@pnp/sp";
+
+describe("SiteScripts", function () {
+
+    const defaultScriptSchema = {
+        "$schema": "schema.json",
+        "actions": [
+            {
+                themeName: "Dummy Theme",
+                verb: "applyTheme",
+            },
+        ],
+        bindata: {},
+        version: 1,
+    };
+
+    let _rootSite: SPFI = null;
+
+    const createdSiteScriptIds: string[] = [];
+    const createdLists: IList[] = [];
+
+    before(function () {
+
+        if (!this.pnp.settings.enableWebTests) {
+            this.skip();
+        }
+
+        _rootSite = spfi([this.pnp.sp.site, this.pnp.settings.sp.url]);
+    });
+
+    it("createSiteScript", function () {
+
+        const title = `Test_create_sitescript_${getRandomString(8)}`;
+        const description = `${getRandomString(25)}`;
+        const p = _rootSite.siteScripts.createSiteScript(title, description, defaultScriptSchema)
+            .then(ss => createdSiteScriptIds.push(ss.Id));
+
+        return expect(p, `site script '${title}' should've been created`).to.eventually.be.fulfilled;
+    });
+
+    it("createSiteScript (fail - bad title)", function () {
+
+        const title = `Test_create_sitescript_${getRandomString(8)}'`;
+        const description = `${getRandomString(25)}`;
+        const p = _rootSite.siteScripts.createSiteScript(title, description, defaultScriptSchema)
+            .then(ss => createdSiteScriptIds.push(ss.Id));
+
+        return expect(p, `site script '${title}' should not have been created`).to.eventually.be.fulfilled;
+    });
+
+    it("createSiteScript (fail - no actions)", function () {
+
+        const schema = {
+            "$schema": "schema.json",
+            "actions": [],
+            "bindata": {},
+            "version": 1,
+        };
+
+        const title = `Test_create_sitescript_no_actions_${getRandomString(8)}`;
+        const description = `${getRandomString(25)}`;
+
+        return expect(_rootSite.siteScripts.createSiteScript(title, description, schema),
+            `site script '${title}' should not have been created`).to.eventually.be.rejected;
+    });
+
+    it("deleteSiteScript", async function () {
+
+        const title = `Test_create_sitescript_to_be_deleted_${getRandomString(8)}`;
+        const description = `${getRandomString(25)}`;
+        const ss = await _rootSite.siteScripts.createSiteScript(title, description, defaultScriptSchema);
+
+        return expect(_rootSite.siteScripts.deleteSiteScript(ss.Id),
+            `site script '${title}' should've been deleted`).to.eventually.be.fulfilled;
+    });
+
+    it("deleteSiteScript (fail)", function () {
+
+        return expect(_rootSite.siteScripts.deleteSiteScript(null),
+            "site script should NOT have been deleted").to.eventually.be.rejected;
+    });
+
+    it("getSiteScriptMetadata", async function () {
+
+        const title = `Test_get_metadata_sitescript${getRandomString(8)}`;
+        const description = `${getRandomString(25)}`;
+        const ss = await _rootSite.siteScripts.createSiteScript(title, description, defaultScriptSchema);
+
+        createdSiteScriptIds.push(ss.Id);
+
+        return expect(_rootSite.siteScripts.getSiteScriptMetadata(ss.Id),
+            `metadata of site script '${title}' should have been retrieved`).to.eventually.be.fulfilled;
+    });
+
+
+    it("updateSiteScript", async function () {
+
+        const title = `Test_to_update_sitescript_${getRandomString(8)}`;
+        const description = `${getRandomString(25)}`;
+        const ss = await _rootSite.siteScripts.createSiteScript(title, description, defaultScriptSchema);
+
+        createdSiteScriptIds.push(ss.Id);
+
+        const updatedTitle = `Test_updated_title_sitescript_${getRandomString(8)}`;
+
+        const updatedScriptSchema = {
+            "$schema": "schema.json",
+            actions: [
+                {
+                    themeName: "Dummy Theme 2",
+                    verb: "applyTheme",
+                },
+            ],
+            bindata: {},
+            version: 2,
+        };
+
+        return expect(_rootSite.siteScripts.updateSiteScript({
+            Id: ss.Id,
+            Title: updatedTitle,
+        }, updatedScriptSchema), `site script '${title}' should've been updated`).to.eventually.be.fulfilled;
+    });
+
+    it("getSiteScripts", async function () {
+
+        return expect(_rootSite.siteScripts.getSiteScripts(),
+            "all the site scripts should've been fetched").to.eventually.be.fulfilled;
+    });
+
+    it("getSiteScript (list)", async function () {
+        const listTitle = `sc_list_${getRandomString(8)}`;
+        const listResult = await _rootSite.web.lists.add(listTitle);
+        createdLists.push(listResult.list);
+
+        return expect(listResult.list.getSiteScript(),
+            "the lists site script should've been fetched").to.eventually.be.fulfilled;
+    });
+
+    it.skip(".getSiteScript (web)", async function () {
+        return expect(_rootSite.web.getSiteScript(),
+            "the webs site script should've been fetched").to.eventually.be.fulfilled;
+    });
+
+    after(function () {
+
+        const promises: Promise<void>[] = [];
+
+        createdSiteScriptIds.forEach((sdId) => {
+            promises.push(_rootSite.siteScripts.deleteSiteScript(sdId));
+        });
+
+        createdLists.forEach((list: IList) => {
+            promises.push(list.delete());
+        });
+
+        return Promise.all(promises);
+    });
+});

package/test/sp/site-users.ts

@@ -0,0 +1,93 @@
+import { expect } from "chai";
+import "@pnp/sp/site-users";
+import { ISiteUserProps, IUserUpdateResult, ISiteUserInfo } from "@pnp/sp/site-users";
+import { ISiteGroups } from "@pnp/sp/presets/all";
+import { stringIsNullOrEmpty } from "@pnp/core";
+
+function testISiteUserInfo(siteUser: ISiteUserInfo): boolean {
+    return Reflect.has(siteUser, "Email") &&
+        Reflect.has(siteUser, "Id") &&
+        Reflect.has(siteUser, "IsHiddenInUI") &&
+        Reflect.has(siteUser, "IsShareByEmailGuestUser") &&
+        Reflect.has(siteUser, "IsSiteAdmin") &&
+        Reflect.has(siteUser, "LoginName") &&
+        Reflect.has(siteUser, "PrincipalType") &&
+        Reflect.has(siteUser, "Title") &&
+        Reflect.has(siteUser, "Expiration") &&
+        Reflect.has(siteUser, "IsEmailAuthenticationGuestUser") &&
+        Reflect.has(siteUser, "UserId") &&
+        Reflect.has(siteUser, "UserPrincipalName");
+}
+
+describe("Site Users", function () {
+
+    before(function () {
+
+        if (!this.pnp.settings.enableWebTests) {
+            this.skip();
+        }
+    });
+
+    describe(".web", function () {
+
+        it("siteUsers", async function () {
+            const siteUsers: ISiteUserInfo[] = await this.pnp.sp.web.siteUsers();
+            const hasResults = siteUsers.length > 0;
+            const siteUser = siteUsers[0];
+            const hasProps = testISiteUserInfo(siteUser);
+            return expect(hasResults && hasProps).to.be.true;
+        });
+
+        it("currentUser", async function () {
+            const currentUser: ISiteUserInfo = await this.pnp.sp.web.currentUser();
+            const hasProps = testISiteUserInfo(currentUser);
+            return expect(hasProps).to.be.true;
+        });
+
+        it("ensureUser", async function () {
+            const e: ISiteUserProps = await this.pnp.sp.web.currentUser();
+            return expect(this.pnp.sp.web.ensureUser(e.LoginName)).to.eventually.fulfilled;
+        });
+
+        it("getUserById", async function () {
+            const user: ISiteUserProps = await this.pnp.sp.web.currentUser();
+            return expect(this.pnp.sp.web.getUserById(user.Id)()).to.eventually.fulfilled;
+        });
+    });
+
+    describe(".siteUsers", function () {
+
+        it("getById", async function () {
+            const e: ISiteUserProps = await this.pnp.sp.web.currentUser();
+            return expect(this.pnp.sp.web.siteUsers.getById(e.Id)()).to.eventually.fulfilled;
+        });
+
+        it("getByEmail", async function () {
+            const e: ISiteUserProps = await this.pnp.sp.web.currentUser();
+            if (!stringIsNullOrEmpty(e.Email)) {
+                return expect(this.pnp.sp.web.siteUsers.getByEmail(e.Email)()).to.eventually.fulfilled;
+            }
+        });
+
+        it("getByLoginName", async function () {
+            const e: ISiteUserProps = await this.pnp.sp.web.currentUser();
+            return expect(this.pnp.sp.web.siteUsers.getByLoginName(e.LoginName)()).to.eventually.fulfilled;
+        });
+    });
+
+    describe(".currentUser", function () {
+
+        it("groups", async function () {
+            const e: ISiteGroups = await this.pnp.sp.web.currentUser.groups();
+            return expect(e.length).to.be.gte(0);
+        });
+
+        it("update", async function () {
+            const _props: ISiteUserProps = await this.pnp.sp.web.currentUser();
+            _props.Title = "Changed Title";
+            const e: IUserUpdateResult = await this.pnp.sp.web.currentUser.update(_props);
+            const _newProps = await e.user();
+            return expect(_newProps.Title).to.be.eq("Changed Title");
+        });
+    });
+});

package/test/sp/sites.ts

@@ -0,0 +1,156 @@
+import { expect } from "chai";
+import "@pnp/sp/sites";
+import "@pnp/sp/webs";
+import "@pnp/sp/lists/web";
+import { IDocumentLibraryInformation, IOpenWebByIdResult, ISiteLogoProperties, Site, SiteLogoAspect, SiteLogoType } from "@pnp/sp/sites";
+import { IWeb } from "@pnp/sp/webs";
+import { combine, getRandomString, stringIsNullOrEmpty } from "@pnp/core";
+import { IContextInfo } from "@pnp/sp/context-info";
+import "@pnp/sp/context-info";
+
+
+import "@pnp/sp/files";
+import { IFiles } from "@pnp/sp/files";
+import { readFileSync } from "fs";
+import { resolve, dirname } from "path";
+import findupSync from "findup-sync";
+
+// get a single reference to the projectRoot
+const projectRoot = resolve(dirname(findupSync("package.json")));
+
+describe("Sites", function () {
+
+    before(function () {
+
+        if (!this.pnp.settings.enableWebTests) {
+            this.skip();
+        }
+    });
+
+    it("rootWeb", async function () {
+        return expect(this.pnp.sp.site.rootWeb()).to.eventually.be.fulfilled;
+    });
+
+    it("getRootWeb", async function () {
+        const rootWeb: IWeb = await this.pnp.sp.site.getRootWeb();
+        return expect(rootWeb).to.haveOwnProperty("_url");
+    });
+
+    it("getContextInfo", async function () {
+        const oContext: IContextInfo = await this.pnp.sp.site.getContextInfo();
+        return expect(oContext).to.haveOwnProperty("SiteFullUrl");
+    });
+
+    it("getDocumentLibraries", async function () {
+        const webInfo: { ServerRelativeUrl: string; Url: string } = await this.pnp.sp.web.select("Url")();
+        const docLibs: IDocumentLibraryInformation[] = await this.pnp.sp.site.getDocumentLibraries(webInfo.Url);
+        return docLibs.forEach((docLib) => {
+            expect(docLib).to.haveOwnProperty("Title");
+        });
+    });
+
+    it("getWebUrlFromPageUrl", async function () {
+        const webInfo: { ServerRelativeUrl: string; Url: string } = await this.pnp.sp.web.select("ServerRelativeUrl", "Url")();
+        const path = combine(webInfo.Url, "SitePages", "Home.aspx");
+        const webUrl: string = await this.pnp.sp.site.getWebUrlFromPageUrl(path);
+        return expect(webUrl).to.be.equal(this.pnp.settings.sp.testWebUrl);
+    });
+
+    it("openWebById", async function () {
+        const oWeb = await this.pnp.sp.site.rootWeb();
+        const webIDResult: IOpenWebByIdResult = await this.pnp.sp.site.openWebById(oWeb.Id);
+        return expect(webIDResult).to.haveOwnProperty("data");
+    });
+
+    it("openWebById - chainable", async function () {
+        const oWeb = await this.pnp.sp.site.rootWeb();
+        const webIDResult: IOpenWebByIdResult = await this.pnp.sp.site.openWebById(oWeb.Id);
+        return expect(webIDResult.web.lists()).to.eventually.be.fulfilled;
+    });
+
+    it("exists", async function () {
+        const oWeb = await this.pnp.sp.site();
+        const exists: boolean = await this.pnp.sp.site.exists(oWeb.Url);
+        const notExists: boolean = await this.pnp.sp.site.exists(`${oWeb.Url}/RANDOM`);
+        const success = exists && !notExists;
+        return expect(success).to.be.true;
+    });
+
+    it("setSiteLogo", async function(){
+        const files: IFiles = this.pnp.sp.web.defaultDocumentLibrary.rootFolder.files;
+        const name = `Testing Chunked - ${getRandomString(4)}.jpg`;
+        const content = readFileSync(resolve(projectRoot, "./test/sp/assets/sample_file.jpg"));
+        const far = await files.addChunked(name, <any>content, null, true, 1000000);
+        const path = far.data.ServerRelativeUrl;
+        const logoProperties: ISiteLogoProperties = {relativeLogoUrl: path, aspect: SiteLogoAspect.Square, type: SiteLogoType.WebLogo};
+        await this.pnp.sp.site.setSiteLogo(logoProperties);
+    });
+});
+
+describe("Site static Tests", function () {
+
+    it("properly parses different contructor args", function () {
+
+        const s1 = Site("https://something.com");
+        expect(s1.toUrl()).to.eq("https://something.com/_api/site");
+
+        const s2 = Site("https://something.com/_api/site");
+        expect(s2.toUrl()).to.eq("https://something.com/_api/site");
+
+        const s3 = Site("https://something.com/_api/web/_api/site");
+        expect(s3.toUrl()).to.eq("https://something.com/_api/site");
+
+        const s4 = Site("https://something.com/_api/site/rootweb/something/random('asdfa')");
+        expect(s4.toUrl()).to.eq("https://something.com/_api/site");
+
+        const s5a = Site("https://something.com/");
+        const s5b = Site(s5a);
+        expect(s5b.toUrl()).to.eq("https://something.com/_api/site");
+
+        const s6a = Site("https://something.com/_api/site/rootweb/something/random('asdfa')");
+        const s6b = Site(s6a);
+        expect(s6b.toUrl()).to.eq("https://something.com/_api/site");
+    });
+});
+
+describe("createModern Team & Comm Sites", function () {
+
+    let testUserEmail = "";
+
+    before(function () {
+
+        if (!this.pnp.settings.enableWebTests || stringIsNullOrEmpty(this.pnp.settings.testUser)) {
+            this.skip();
+        }
+
+        const testUserEmailArray = this.pnp.settings.testUser.split("|");
+        testUserEmail = testUserEmailArray[testUserEmailArray.length - 1];
+    });
+
+    // these work but permissions are wonky
+    it.skip(".createModernTeamSite", async function () {
+        const randomNum = getRandomString(5);
+        const promise = this.pnp.sp.site.createModernTeamSite(
+            "TestModernTeamSite01" + randomNum,
+            "Alias",
+            false,
+            1033,
+            "TestModernTeamSite01" + randomNum + " description", "HBI", [testUserEmail]);
+
+        return expect(promise).to.eventually.be.fulfilled;
+    });
+
+    // these work but permissions are wonky
+    it.skip(".createCommunicationSite", async function () {
+        const randomNum = getRandomString(5);
+        const promise = this.pnp.sp.site.createCommunicationSite(
+            "TestModernCommSite01" + randomNum, 1033,
+            false,
+            this.pnp.settings.sp.testWebUrl + "/sites/commSite" + randomNum,
+            "TestModernCommSite01", "HBI",
+            "00000000-0000-0000-0000-000000000000", "00000000-0000-0000-0000-000000000000",
+            testUserEmail);
+
+        return expect(promise).to.eventually.be.fulfilled;
+    });
+});

package/test/sp/social.ts

@@ -0,0 +1,2 @@
+// we cannot test social as it relies on a current user and an app doesn't work
+describe("Social", () => void(0));

package/test/sp/spfx.ts

@@ -0,0 +1,52 @@
+// these tests are meant to simulate basic functionality in SPFx through node so we can validate we aren't breaking core library
+// functionality in SPFx added after #2347
+import { expect } from "chai";
+import "@pnp/sp/webs";
+import "@pnp/sp/lists/web";
+import { ISPFXContext, SPFI, spfi, SPFx } from "@pnp/sp";
+import { NodeFetchWithRetry } from "@pnp/nodejs";
+import { CopyFrom, isArray } from "@pnp/core";
+
+describe("SPFx", function () {
+
+    let spfxSP: SPFI;
+
+    before(function () {
+
+        if (!this.pnp.settings.enableWebTests) {
+            this.skip();
+        }
+
+        const SPFxContext: ISPFXContext = {
+
+            pageContext: {
+                web: {
+                    absoluteUrl: this.pnp.settings.sp.testWebUrl,
+                },
+                legacyPageContext: null,
+            },
+        };
+
+        spfxSP = spfi().using(
+            SPFx(SPFxContext),
+            NodeFetchWithRetry({ replace: true }),
+            CopyFrom(this.pnp.sp.web, "replace", (m) => m === "auth"));
+    });
+
+    it("get web", async function () {
+
+        const webInfo = await spfxSP.web();
+        return expect(webInfo).to.haveOwnProperty("Title");
+    });
+
+    it("get lists", async function () {
+
+        const listsInfo = await spfxSP.web.lists();
+
+        // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+        expect(isArray(listsInfo)).to.be.true;
+        return expect(listsInfo).property("length").to.be.greaterThan(0);
+    });
+});
+
+

package/test/sp/sputilities.ts

@@ -0,0 +1,78 @@
+import { expect } from "chai";
+import "@pnp/sp/webs";
+import "@pnp/sp/site-users/web";
+import "@pnp/sp/sputilities";
+import { PrincipalType, PrincipalSource } from "@pnp/sp";
+import { combine, stringIsNullOrEmpty } from "@pnp/core";
+import { IEmailProperties } from "@pnp/sp/sputilities";
+
+// cannot test with app permissions
+describe.skip("SPUtilities", function () {
+
+    before(async function () {
+
+        if (!this.pnp.settings.enableWebTests) {
+            this.skip();
+        }
+
+        if (!stringIsNullOrEmpty(this.pnp.settings.testUser)) {
+            await this.pnp.sp.web.ensureUser(this.pnp.settings.testUser);
+        }
+    });
+
+    it("getCurrentUserEmailAddresses", function () {
+        return expect(this.pnp.sp.utility.getCurrentUserEmailAddresses()).to.eventually.be.fulfilled;
+    });
+
+    it("resolvePrincipal", async function () {
+        const currentUserEmailAddress = await this.pnp.sp.utility.getCurrentUserEmailAddresses();
+
+        return expect(this.pnp.sp.utility.resolvePrincipal(currentUserEmailAddress, PrincipalType.User, PrincipalSource.All, true, false, true)).to.be.eventually.fulfilled;
+    });
+
+    it("createEmailBodyForInvitation", async function () {
+        const homePageAddress = combine(this.pnp.settings.sp.testWebUrl, "/SitePages/Home.aspx");
+        return expect(this.pnp.sp.utility.createEmailBodyForInvitation(homePageAddress)).to.be.eventually.fulfilled;
+    });
+
+    it("expandGroupsToPrincipals", async function () {
+        return expect(this.pnp.sp.utility.expandGroupsToPrincipals(["Everyone"], 10)).to.eventually.be.an.instanceOf(Array).and.not.be.empty;
+    });
+
+    it("sendEmail", async function () {
+
+        if (stringIsNullOrEmpty(this.pnp.settings.testUser)) {
+            this.skip();
+        }
+
+        const currentUserEmailAddress = await this.pnp.sp.utility.getCurrentUserEmailAddresses();
+
+        const headers = {
+            "content-type": "text/html",
+        };
+
+        const emailProps: IEmailProperties = {
+            AdditionalHeaders: headers,
+            BCC: [currentUserEmailAddress],
+            Body: "Here is the body. <b>It supports html</b>",
+            CC: [currentUserEmailAddress],
+            Subject: "This email is about...",
+            To: [currentUserEmailAddress],
+        };
+
+        return expect(this.pnp.sp.utility.sendEmail(emailProps)).to.eventually.be.fulfilled;
+    });
+
+    it("searchPrincipals", async function () {
+
+        if (stringIsNullOrEmpty(this.pnp.settings.testUser)) {
+            this.skip();
+        }
+
+        const ensureTestUser = await this.pnp.sp.web.ensureUser(this.pnp.settings.testUser);
+        const userId = ensureTestUser.data.Id;
+        const user = await this.pnp.sp.web.siteUsers.getById(userId)();
+
+        return expect(this.pnp.sp.utility.searchPrincipals(user.Title, PrincipalType.User, PrincipalSource.All, "", 1)).to.eventually.be.an.instanceOf(Array).and.not.be.empty;
+    });
+});

package/test/sp/subscriptions.ts

@@ -0,0 +1,64 @@
+import { expect } from "chai";
+import "@pnp/sp/webs";
+import "@pnp/sp/lists";
+import "@pnp/sp/subscriptions";
+import { dateAdd, stringIsNullOrEmpty } from "@pnp/core";
+
+describe("Subscriptions", function () {
+
+    const listTitle = "Documents";
+    let notificationUrl = "";
+    let after120Days = (dateAdd(new Date(), "day", 120).toISOString());
+    let after180Days = (dateAdd(new Date(), "day", 180).toISOString());
+
+    before(function () {
+
+        if (!this.pnp.settings.enableWebTests || stringIsNullOrEmpty(this.pnp.settings?.sp?.notificationUrl)) {
+            this.skip();
+        }
+
+        notificationUrl = this.pnp.settings.sp.notificationUrl;
+        after120Days = (dateAdd(new Date(), "day", 120).toISOString());
+        after180Days = (dateAdd(new Date(), "day", 180).toISOString());
+    });
+
+    it("invoke", function () {
+
+        return expect(this.pnp.sp.web.lists.getByTitle(listTitle).subscriptions(), "Fetched the list of all webhooks").to.be.eventually.fulfilled;
+    });
+
+    it("add", async function () {
+
+        const r = await this.pnp.sp.web.lists.getByTitle(listTitle).subscriptions.add(notificationUrl, after120Days, "pnp client state");
+        const subID = r.data.id;
+
+        return expect(subID, `A new webhook with id :${subID} should be created`).to.not.be.null.and.not.be.empty.and.be.an.instanceOf(Number);
+    });
+
+    it("getById", async function () {
+
+        const res = await this.pnp.sp.web.lists.getByTitle(listTitle).subscriptions.add(notificationUrl, after120Days);
+
+        const p = this.pnp.sp.web.lists.getByTitle(listTitle).subscriptions.getById(res.data.id)();
+
+        return expect(p, "Get the details of a webhook with the given id").to.be.eventually.fulfilled;
+    });
+
+    it("update() - Update a webhook", async function () {
+
+        const res = await this.pnp.sp.web.lists.getByTitle(listTitle).subscriptions.add(notificationUrl, after120Days, "pnp client state");
+
+        const p = this.pnp.sp.web.lists.getByTitle(listTitle).subscriptions.getById(res.data.id).update(after180Days, notificationUrl, "pnp client state");
+
+        return expect(p, "The webhook should have been updated with the new expiry date").to.be.eventually.fulfilled;
+    });
+
+    it("delete() - Delete a webhook", async function () {
+
+        const res = await this.pnp.sp.web.lists.getByTitle(listTitle).subscriptions.add(notificationUrl, after120Days, "pnp client state");
+
+        const p = this.pnp.sp.web.lists.getByTitle(listTitle).subscriptions.getById(res.data.id).delete();
+
+        return expect(p, "The webhook should have been deleted").to.be.eventually.fulfilled;
+    });
+});