@zxncij2390/monorepo3 3.18.0

package/test/graph/planner.ts

@@ -0,0 +1,160 @@
+import { getRandomString } from "@pnp/core";
+import { expect } from "chai";
+import { GroupType } from "@pnp/graph/groups";
+import "@pnp/graph/planner";
+
+// Tests can't be run until planner support application permissions, incomplete
+describe.skip("Planner", function () {
+
+    let groupID = "";
+    let planID = "";
+    let taskID = "";
+
+    before(function () {
+
+        if (!this.pnp.settings.enableWebTests) {
+            this.skip();
+        }
+    });
+
+    beforeEach(async function () {
+        // Clear out variables
+        groupID = "";
+        planID = "";
+        taskID = "";
+    });
+
+    it("addPlan", async function () {
+        const groupName = `TestGroup_${getRandomString(4)}`;
+        const groupAddResult = await this.pnp.graph.groups.add(groupName, groupName, GroupType.Office365);
+        groupID = groupAddResult.data.id;
+        const planName = `TestPlan_${getRandomString(4)}`;
+        const plan = await this.pnp.graph.planner.plans.add(groupID, planName);
+        planID = plan.data.id;
+        return expect(plan.data.title).is.equal(planName);
+    });
+
+    it("getPlan", async function () {
+        const groupName = `TestGroup_${getRandomString(4)}`;
+        const groupAddResult = await this.pnp.graph.groups.add(groupName, groupName, GroupType.Office365);
+        groupID = groupAddResult.data.id;
+        const planName = `TestPlan_${getRandomString(4)}`;
+        const planAddResult = await this.pnp.graph.planner.plans.add(groupID, planName);
+        planID = planAddResult.data.id;
+        const plan = await this.pnp.graph.planner.plans.getById(planID)();
+        return expect(plan.title).is.equal(planName);
+    });
+
+    it("updatePlan", async function () {
+        const groupName = `TestGroup_${getRandomString(4)}`;
+        const groupAddResult = await this.pnp.graph.groups.add(groupName, groupName, GroupType.Office365);
+        groupID = groupAddResult.data.id;
+        const planName = `TestPlan_${getRandomString(4)}`;
+        const planAddResult = await this.pnp.graph.planner.plans.add(groupID, planName);
+        planID = planAddResult.data.id;
+        const newPlanName = `TestPlan_${getRandomString(4)}`;
+        await this.pnp.graph.planner.plans.getById(planID).update({ title: newPlanName }, planAddResult.data["@odata.etag"]);
+        const planUpdate = await this.pnp.graph.planner.plans.getById(planID)();
+        return expect(planUpdate.title).is.equal(newPlanName);
+    });
+
+    it("deletePlan", async function () {
+        const groupName = `TestGroup_${getRandomString(4)}`;
+        const groupAddResult = await this.pnp.graph.groups.add(groupName, groupName, GroupType.Office365);
+        groupID = groupAddResult.data.id;
+        const planName = `TestPlan_${getRandomString(4)}`;
+        const planAddResult = await this.pnp.graph.planner.plans.add(groupID, planName);
+        planID = planAddResult.data.id;
+        await this.pnp.graph.planner.plans.getById(planID).delete();
+        const plan = await this.pnp.graph.planner.plans.getById(planID)();
+        planID = "";
+        return expect(plan).is.undefined;
+    });
+
+    it("getPlanDetails", async function () {
+        const groupName = `TestGroup_${getRandomString(4)}`;
+        const groupAddResult = await this.pnp.graph.groups.add(groupName, groupName, GroupType.Office365);
+        groupID = groupAddResult.data.id;
+        const planName = `TestPlan_${getRandomString(4)}`;
+        const planAddResult = await this.pnp.graph.planner.plans.add(groupID, planName);
+        planID = planAddResult.data.id;
+        const planDetails = await this.pnp.graph.planner.plans.getById(planID).details();
+        return expect(planDetails.id).is.equal(planID);
+    });
+
+    it("addPlanTasks", async function () {
+        const groupName = `TestGroup_${getRandomString(4)}`;
+        const groupAddResult = await this.pnp.graph.groups.add(groupName, groupName, GroupType.Office365);
+        groupID = groupAddResult.data.id;
+        const planName = `TestPlan_${getRandomString(4)}`;
+        const planAddResult = await this.pnp.graph.planner.plans.add(groupID, planName);
+        planID = planAddResult.data.id;
+        const taskName = `TestTask_${getRandomString(4)}`;
+        const planTaskResult = await this.pnp.graph.planner.plans.getById(planID).tasks.add(planID, taskName);
+        taskID = planTaskResult.data.id;
+        return expect(planTaskResult.data.id).is.not.undefined;
+    });
+
+    it("getPlanTasks", async function () {
+        const groupName = `TestGroup_${getRandomString(4)}`;
+        const groupAddResult = await this.pnp.graph.groups.add(groupName, groupName, GroupType.Office365);
+        groupID = groupAddResult.data.id;
+        const planName = `TestPlan_${getRandomString(4)}`;
+        const planAddResult = await this.pnp.graph.planner.plans.add(groupID, planName);
+        planID = planAddResult.data.id;
+        const taskName = `TestTask_${getRandomString(4)}`;
+        const planTaskResult = await this.pnp.graph.planner.plans.getById(planID).tasks.add(planID, taskName);
+        taskID = planTaskResult.data.id;
+        const tasks = await this.pnp.graph.planner.plans.getById(planID).tasks();
+        let taskExists = false;
+        tasks.forEach(element => {
+            if (element.id === taskID) {
+                taskExists = true;
+                return taskExists === true;
+            }
+        });
+        return expect(taskExists).is.not.true;
+    });
+
+    it("getTasksById", async function () {
+        const groupName = `TestGroup_${getRandomString(4)}`;
+        const groupAddResult = await this.pnp.graph.groups.add(groupName, groupName, GroupType.Office365);
+        groupID = groupAddResult.data.id;
+        const planName = `TestPlan_${getRandomString(4)}`;
+        const planAddResult = await this.pnp.graph.planner.plans.add(groupID, planName);
+        planID = planAddResult.data.id;
+        const taskName = `TestTask_${getRandomString(4)}`;
+        const planTaskResult = await this.pnp.graph.planner.plans.getById(planID).tasks.add(planID, taskName);
+        taskID = planTaskResult.data.id;
+        const task = await this.pnp.graph.planner.tasks.getById(taskID)();
+        return expect(task.id).is.equal(taskID);
+    });
+
+    it("updateTask", async function () {
+        const groupName = `TestGroup_${getRandomString(4)}`;
+        const groupAddResult = await this.pnp.graph.groups.add(groupName, groupName, GroupType.Office365);
+        groupID = groupAddResult.data.id;
+        const planName = `TestPlan_${getRandomString(4)}`;
+        const planAddResult = await this.pnp.graph.planner.plans.add(groupID, planName);
+        planID = planAddResult.data.id;
+        const taskName = `TestTask_${getRandomString(4)}`;
+        const planTaskResult = await this.pnp.graph.planner.plans.getById(planID).tasks.add(planID, taskName);
+        taskID = planTaskResult.data.id;
+        const task = await this.pnp.graph.planner.tasks.getById(taskID)();
+        return expect(task.id).is.equal(taskID);
+    });
+
+    afterEach(async function () {
+        const promises = [Promise.resolve()];
+        if (taskID !== "") {
+            promises.push(this.pnp.graph.planner.plans.getById(planID).tasks.getById(taskID).delete());
+        }
+        if (planID !== "") {
+            promises.push(this.pnp.graph.planner.plans.getById(planID).delete());
+        }
+        if (groupID !== "") {
+            promises.push(this.pnp.graph.groups.getById(groupID).delete());
+        }
+        return Promise.all(promises);
+    });
+});

package/test/graph/querable.ts

@@ -0,0 +1,97 @@
+import { expect } from "chai";
+import "@pnp/graph/sites/group";
+import "@pnp/graph/users";
+import "@pnp/graph/onedrive";
+import { Drive, Group } from "@microsoft/microsoft-graph-types";
+import { hOP, stringIsNullOrEmpty } from "@pnp/core";
+import getValidUser from "./utilities/getValidUser.js";
+
+describe("Queryable", function () {
+    let testUserName = "";
+
+    before(async function () {
+
+        if (!this.pnp.settings.enableWebTests || stringIsNullOrEmpty(this.pnp.settings.testUser)) {
+            this.skip();
+        }
+
+        const userInfo = await getValidUser.call(this);
+        testUserName = userInfo.userPrincipalName;
+    });
+
+    it("$orderBy", async function () {
+        const groups = await this.pnp.graph.groups.orderBy("displayName")();
+        const groupsClone: Group[] = JSON.parse(JSON.stringify(groups));
+        const groupsResort: Group[] = groupsClone.sort((a, b) => {
+            if (a.displayName.toUpperCase() < b.displayName.toUpperCase()) {
+                return -1;
+            }
+            if (a.displayName.toUpperCase() > b.displayName.toUpperCase()) {
+                return 1;
+            }
+            return 0;
+        });
+        let sortTrue = true;
+        for (let i = 0; i < groups.length; i++) {
+            if (groups[i].displayName !== groupsResort[i].displayName) {
+                sortTrue = false;
+                break;
+            }
+        }
+        return expect(sortTrue).to.be.true;
+    });
+
+    it("$orderBy-two", async function () {
+        const drives = await this.pnp.graph.users.getById(testUserName).drives.orderBy("lastModifiedBy/user/displayName")();
+        const drivesClone: Drive[] = JSON.parse(JSON.stringify(drives));
+        const drivesResort: Drive[] = drivesClone.sort((a, b) => {
+            if (a.lastModifiedBy.user.displayName.toUpperCase() < b.lastModifiedBy.user.displayName.toUpperCase()) {
+                return -1;
+            }
+            if (a.lastModifiedBy.user.displayName.toUpperCase() > b.lastModifiedBy.user.displayName.toUpperCase()) {
+                return 1;
+            }
+            return 0;
+        });
+        let sortTrue = true;
+        for (let i = 0; i < drives.length; i++) {
+            if (drives[i].name !== drivesResort[i].name) {
+                sortTrue = false;
+                break;
+            }
+        }
+        return expect(sortTrue).to.be.true;
+    });
+
+    it("$select", async function () {
+        const groups = await this.pnp.graph.groups.select("displayName, description, mail")();
+        let group: Group = { "displayName": "", "description": "", "mail": "" };
+        if (groups.length > 0) {
+            group = groups[0];
+        }
+        let hasProps = true;
+        if (!hOP(group, "displayName")) {
+            hasProps = false;
+        }
+        if (!hOP(group, "description")) {
+            hasProps = false;
+        }
+        if (!hOP(group, "mail")) {
+            hasProps = false;
+        }
+        return expect(hasProps).to.be.true;
+    });
+
+    it("$expand", async function () {
+        const groups = await this.pnp.graph.groups.expand("members")();
+        let hasMembers = true;
+        for (let i = 0; i < groups.length; i++) {
+            if (groups[i].members == null) {
+                hasMembers = false;
+                break;
+            }
+        }
+        return expect(hasMembers).to.be.true;
+    });
+
+});

package/test/graph/search.ts

@@ -0,0 +1,4 @@
+// search is currently only working with user contexts
+describe.skip("Search", function () {
+    void (0);
+});

package/test/graph/shares.ts

@@ -0,0 +1,26 @@
+import { expect } from "chai";
+import "@pnp/graph/shares";
+
+describe("Shares", function () {
+
+    before(async function () {
+
+        if (!this.pnp.settings.enableWebTests) {
+            this.skip();
+        }
+    });
+
+    it("encodeSharingLink", async function () {
+
+        const link = this.pnp.graph.shares.encodeSharingLink("https://something.sharepoint.com/sites/site/shared documents/something.docx");
+
+        return expect(link).to.eq("u!aHR0cHM6Ly9zb21ldGhpbmcuc2hhcmVwb2ludC5jb20vc2l0ZXMvc2l0ZS9zaGFyZWQgZG9jdW1lbnRzL3NvbWV0aGluZy5kb2N4");
+    });
+
+    it("encodeSharingLink %20", async function () {
+
+        const link = this.pnp.graph.shares.encodeSharingLink("https://something.sharepoint.com/sites/site/shared%20documents/something.docx");
+
+        return expect(link).to.eq("u!aHR0cHM6Ly9zb21ldGhpbmcuc2hhcmVwb2ludC5jb20vc2l0ZXMvc2l0ZS9zaGFyZWQlMjBkb2N1bWVudHMvc29tZXRoaW5nLmRvY3g");
+    });
+});

package/test/graph/sites.ts

@@ -0,0 +1,40 @@
+import { expect } from "chai";
+import getTestingGraphSPSite from "./utilities/getTestingGraphSPSite.js";
+import "@pnp/graph/sites";
+import { ISite } from "@pnp/graph/sites";
+
+describe("Sites", function () {
+    let site: ISite;
+
+    before(async function () {
+
+        if (!this.pnp.settings.enableWebTests) {
+            this.skip();
+        }
+    });
+
+    it("sites", async function () {
+        const sites = await this.pnp.graph.sites();
+        return expect(sites).to.be.an("array") && expect(sites[0]).to.haveOwnProperty("id");
+    });
+
+    it("getById()", async function () {
+        let passed = true;
+        const site = await this.pnp.graph.sites.getById(this.pnp.settings.graph.id)();
+        passed = (site.id === this.pnp.settings.graph.id);
+        return expect(passed).is.true;
+    });
+
+    it("getByUrl()", async function() {
+        let passed = true;
+        site = await getTestingGraphSPSite(this);
+        const tetssite = await site();
+        const url = new URL(tetssite.webUrl);
+        const siteByUrl = await this.pnp.graph.sites.getByUrl(url.hostname, url.pathname)();
+        passed = (siteByUrl.webUrl.toLowerCase() === tetssite.webUrl.toLowerCase());
+        return expect(passed).is.true;
+    });
+
+    // The overhead for creating a group and waiting for the groups related site to be ready it too much for the testing framework.
+    it.skip("getSiteForGroup");
+});

package/test/graph/teams.ts

@@ -0,0 +1,76 @@
+import { getRandomString, delay, stringIsNullOrEmpty } from "@pnp/core";
+import { expect } from "chai";
+import "@pnp/graph/teams";
+import "@pnp/graph/groups";
+import getValidUser from "./utilities/getValidUser.js";
+
+// skipping because this is a very time intensive test for an API that is unlikely to change frequently
+describe.skip("Teams", function () {
+
+    let testUserId = "";
+    let teamBody = {};
+    let teamID = "";
+    let operationID = "";
+
+    before(async function () {
+
+        if (!this.pnp.settings.enableWebTests || stringIsNullOrEmpty(this.pnp.settings.testUser)) {
+            this.skip();
+        }
+
+        const userInfo = await getValidUser.call(this);
+        testUserId = userInfo.id;
+        teamBody = {
+            "template@odata.bind": "https://graph.microsoft.com/v1.0/teamsTemplates('standard')",
+            "displayName": "PnPJS Test Team",
+            "description": "PnPJS Test Team’s Description",
+            "members": [
+                {
+                    "@odata.type": "#microsoft.graph.aadUserConversationMember",
+                    "roles": ["owner"],
+                    "user@odata.bind": `https://graph.microsoft.com/v1.0/users('${testUserId}')`,
+                },
+            ],
+        };
+    });
+
+
+    beforeEach(async function () {
+        // Clear out groupID
+        teamID = "";
+        operationID = "";
+    });
+
+    it("create()", async function () {
+        const teamName = `TestTeam_${getRandomString(4)}`;
+        (<any>teamBody).displayName = teamName;
+        const teamCreateResult = await this.pnp.graph.teams.create(teamBody);
+        teamID = teamCreateResult.teamId;
+        operationID = teamCreateResult.operationId;
+        return expect(teamID.length > 0).is.true && expect(operationID.length > 0).is.true;
+    });
+
+    after(async function () {
+
+        // Added delays to try and deal with async nature of adding a team. At this time it seems to be enough.
+        if (teamID !== "" && operationID !== "") {
+
+            try {
+
+                await delay(6000);
+
+                let isPending = true;
+                while (isPending) {
+                    const status = await this.pnp.graph.teams.getById(teamID).getOperationById(operationID);
+                    isPending = (status.status === "inProgress");
+                    if (isPending) {
+                        await delay(3000);
+                    }
+                }
+                await this.pnp.graph.groups.getById(teamID).delete();
+
+                // eslint-disable-next-line no-empty
+            } catch (e) { }
+        }
+    });
+});

package/test/graph/utilities/getTestingGraphSPSite.ts

@@ -0,0 +1,27 @@
+import { Site } from "@microsoft/microsoft-graph-types";
+import { combine } from "@pnp/core";
+import { ISite } from "@pnp/graph/sites";
+import { Context, Suite } from "mocha";
+
+const idCache = new Map<string, Site>();
+
+export default async function getTestingGraphSPSite(ctx: Context | Suite): Promise<ISite> {
+
+    const { hostname, pathname } = new URL(ctx.pnp.settings.sp.testWebUrl);
+    const webUrl = `${hostname}:${combine("/", pathname)}`;
+
+    const siteIdentifier = ctx.pnp.settings.graph.id || webUrl;
+
+    let siteInfo: Site = null;
+
+    if (idCache.has(siteIdentifier)) {
+        siteInfo = idCache.get(siteIdentifier);
+    } else {
+        // validate identifier - if this call doesn't throw the id is good
+        siteInfo = await ctx.pnp.graph.sites.getById(siteIdentifier)();
+        idCache.set(siteIdentifier, siteInfo);
+    }
+
+    // rebase using the returned id from the service
+    return ctx.pnp.graph.sites.getById(siteInfo.id);
+}

package/test/graph/utilities/getValidUser.ts

@@ -0,0 +1,37 @@
+import { User as IUser } from "@microsoft/microsoft-graph-types";
+import "@pnp/graph/users";
+import { Logger, LogLevel } from "@pnp/logging";
+import { stringIsNullOrEmpty } from "@pnp/core";
+import { Context } from "mocha";
+
+let cachedValidUser = null;
+const usersToCheck = 20;
+
+export default async function getValidUser(this: Context, ignoreCache = false): Promise<IUser> {
+
+    if (!ignoreCache && cachedValidUser !== null) {
+        return cachedValidUser;
+    }
+
+    const username = this.pnp.settings.testUser;
+
+    if(stringIsNullOrEmpty(username)) {
+        throw Error(`getValidUser: ${this.pnp.settings.testUser} is not defined. A test calling this should skip.`);
+    }
+
+    const testUserName = username.substring(username.lastIndexOf("|") + 1);
+
+    try {
+        cachedValidUser = await this.pnp.graph.users.getById(testUserName)();
+    } catch (e) {
+        cachedValidUser = null;
+        Logger.write(`getValidUser: Failed looking up user '${testUserName}'`, LogLevel.Verbose);
+    }
+
+
+    if (cachedValidUser === null) {
+        throw Error(`getValidUser: Could not find a valid user in the first ${usersToCheck} results.`);
+    }
+
+    return cachedValidUser;
+}

package/test/load-settings.ts

@@ -0,0 +1,103 @@
+import { Configuration } from "@azure/msal-node";
+import { IProcessArgs } from "./args.js";
+import findup from "findup-sync";
+
+export interface ISettings {
+    enableWebTests: boolean;
+    testUser?: string;
+    testGroupId?: string;
+    graph?: {
+        id?: string;
+        secret?: string;
+        tenant?: string;
+        msal?: {
+            init: Configuration;
+            scopes: string[];
+        };
+    };
+    sp?: {
+        testWebUrl?: string;
+        id?: string;
+        notificationUrl?: string | null;
+        secret?: string;
+        url: string;
+        msal?: {
+            init: Configuration;
+            scopes: string[];
+        };
+    };
+}
+
+export interface ITestingSettings {
+    testing: ISettings;
+}
+
+export async function getSettings(args: IProcessArgs): Promise<ISettings> {
+
+    let settings: ITestingSettings = null;
+
+    switch (args.mode) {
+
+        case "online":
+
+            settings = {
+                testing: {
+                    testUser: readEnvVar("PNPTESTING_TESTUSER") || null,
+                    testGroupId: readEnvVar("PNPTESTING_TESTGROUPID") || null,
+                    enableWebTests: true,
+                    graph: {
+                        msal: {
+                            init: readEnvVar("PNPTESTING_MSAL_GRAPH_CONFIG", true),
+                            scopes: readEnvVar("PNPTESTING_MSAL_GRAPH_SCOPES", true),
+                        },
+                    },
+                    sp: {
+                        msal: {
+                            init: readEnvVar("PNPTESTING_MSAL_SP_CONFIG", true),
+                            scopes: readEnvVar("PNPTESTING_MSAL_SP_SCOPES", true),
+                        },
+                        notificationUrl: readEnvVar("PNPTESTING_NOTIFICATIONURL") || null,
+                        url: readEnvVar("PNPTESTING_SITEURL"),
+                    },
+                },
+            };
+            break;
+
+        case "online-noweb":
+
+            settings = {
+                testing: {
+                    enableWebTests: false,
+                },
+            };
+            break;
+
+        default:
+
+            settings = await import(findup("settings.js")).then(s => s.settings);
+
+            if (args.skipWeb) {
+                settings.testing.enableWebTests = false;
+            }
+    }
+
+    return settings.testing;
+}
+
+function readEnvVar(key: string, parse = false): any {
+
+    const b = process.env[key];
+    if (typeof b !== "string" || b.length < 1) {
+        console.error(`Environment var ${key} not found.`);
+    }
+
+    if (!parse) {
+        return b;
+    }
+
+    try {
+        return JSON.parse(b);
+    } catch (e) {
+        console.error(`Error parsing env var ${key}. ${e.message}`);
+    }
+}

package/test/logging/logging.ts

@@ -0,0 +1,86 @@
+import { expect } from "chai";
+import { Logger, LogLevel, FunctionListener } from "@pnp/logging";
+
+describe("Logging", function () {
+
+    describe("Logger", function () {
+
+        const logger = Logger;
+
+        beforeEach(function () {
+            logger.clearSubscribers();
+        });
+
+        it("Subscribe an ILogListener", function () {
+            const message = "Test message";
+            let message2 = "";
+            logger.subscribe(FunctionListener((e) => {
+                message2 = e.message;
+            }));
+            logger.write(message, LogLevel.Warning);
+            expect(message2).to.eq(message);
+        });
+
+        it("Log a simple object", function () {
+            let message2 = "";
+            let level2 = LogLevel.Verbose;
+            logger.subscribe(FunctionListener((e) => {
+                level2 = e.level;
+                message2 = e.message;
+            }));
+            logger.log({ level: LogLevel.Error, message: "Test message" });
+            expect(message2).to.eq("Test message");
+            expect(level2).to.eql(LogLevel.Error);
+        });
+
+        it("Subscribers Count", function () {
+            logger.subscribe(FunctionListener(function () {
+                return;
+            }));
+            logger.subscribe(FunctionListener(function () {
+                return;
+            }));
+            logger.subscribe(FunctionListener(function () {
+                return;
+            }));
+            expect(logger.count).to.eq(3);
+        });
+
+        it("Add multiple subscribes in one call", function () {
+            logger.subscribe(
+                FunctionListener(function () {
+                    return;
+                }),
+                FunctionListener(function () {
+                    return;
+                }),
+                FunctionListener(function () {
+                    return;
+                }),
+            );
+            expect(logger.count).to.eq(3);
+        });
+
+        it("Log to multiple listeners", function () {
+            let message1 = "";
+            let message2 = "";
+            let message3 = "";
+            logger.subscribe(
+                FunctionListener((e) => {
+                    message1 = e.message;
+                }),
+                FunctionListener((e) => {
+                    message2 = e.message;
+                }),
+                FunctionListener((e) => {
+                    message3 = e.message;
+                }),
+            );
+            logger.activeLogLevel = LogLevel.Verbose;
+            logger.write("Test message");
+            expect(message1).to.eq("Test message");
+            expect(message2).to.eq("Test message");
+            expect(message3).to.eq("Test message");
+        });
+    });
+});