@mcpher/gas-fakes 2.3.14 → 2.3.16

package/src/services/gmailapp/fakegmailthread.js

@@ -167,7 +167,7 @@ class FakeGmailThread {
     }
 
     Gmail.Users.Threads.modify({ addLabelIds: [label.getId()] }, 'me', this.getId());
-    return this;
+    return this.refresh();
   }
 
   removeLabel(label) {
@@ -215,6 +215,156 @@ class FakeGmailThread {
       }
     }
     Gmail.Users.Threads.modify({ removeLabelIds: [label.getId()] }, 'me', this.getId());
+    return this.refresh();
+  }
+
+  __hasLabel(label) {
+    if (!this.__threadResource.messages) return false;
+    for (const m of this.__threadResource.messages) {
+      if (m.labelIds && m.labelIds.includes(label)) return true;
+    }
+    return false;
+  }
+
+  hasStarredMessages() {
+    ScriptApp.__behavior.checkMethod('GmailThread', 'hasStarredMessages');
+    return this.__hasLabel('STARRED');
+  }
+
+  isImportant() {
+    ScriptApp.__behavior.checkMethod('GmailThread', 'isImportant');
+    return this.__hasLabel('IMPORTANT');
+  }
+
+  isInChats() {
+    ScriptApp.__behavior.checkMethod('GmailThread', 'isInChats');
+    return this.__hasLabel('CHAT');
+  }
+
+  isInInbox() {
+    ScriptApp.__behavior.checkMethod('GmailThread', 'isInInbox');
+    return this.__hasLabel('INBOX');
+  }
+
+  isInPriorityInbox() {
+    ScriptApp.__behavior.checkMethod('GmailThread', 'isInPriorityInbox');
+    return this.__hasLabel('INBOX') && this.__hasLabel('IMPORTANT');
+  }
+
+  isInSpam() {
+    ScriptApp.__behavior.checkMethod('GmailThread', 'isInSpam');
+    return this.__hasLabel('SPAM');
+  }
+
+  isInTrash() {
+    ScriptApp.__behavior.checkMethod('GmailThread', 'isInTrash');
+    return this.__hasLabel('TRASH');
+  }
+
+  isUnread() {
+    ScriptApp.__behavior.checkMethod('GmailThread', 'isUnread');
+    return this.__hasLabel('UNREAD');
+  }
+
+  getFirstMessageSubject() {
+    ScriptApp.__behavior.checkMethod('GmailThread', 'getFirstMessageSubject');
+    const msgs = this.getMessages();
+    return msgs.length > 0 ? msgs[0].getSubject() : '';
+  }
+
+  getLastMessageDate() {
+    ScriptApp.__behavior.checkMethod('GmailThread', 'getLastMessageDate');
+    const msgs = this.getMessages();
+    return msgs.length > 0 ? msgs[msgs.length - 1].getDate() : new Date();
+  }
+
+  getMessageCount() {
+    ScriptApp.__behavior.checkMethod('GmailThread', 'getMessageCount');
+    return this.getMessages().length;
+  }
+
+  getPermalink() {
+    ScriptApp.__behavior.checkMethod('GmailThread', 'getPermalink');
+    return `https://mail.google.com/mail/u/0/#inbox/${this.getId()}`;
+  }
+
+  refresh() {
+    ScriptApp.__behavior.checkMethod('GmailThread', 'refresh');
+    this.__threadResource = Gmail.Users.Threads.get('me', this.getId());
+    return this;
+  }
+
+  markImportant() {
+    ScriptApp.__behavior.checkMethod('GmailThread', 'markImportant');
+    Gmail.Users.Threads.modify({ addLabelIds: ['IMPORTANT'] }, 'me', this.getId());
+    return this.refresh();
+  }
+
+  markRead() {
+    ScriptApp.__behavior.checkMethod('GmailThread', 'markRead');
+    Gmail.Users.Threads.modify({ removeLabelIds: ['UNREAD'] }, 'me', this.getId());
+    return this.refresh();
+  }
+
+  markUnimportant() {
+    ScriptApp.__behavior.checkMethod('GmailThread', 'markUnimportant');
+    Gmail.Users.Threads.modify({ removeLabelIds: ['IMPORTANT'] }, 'me', this.getId());
+    return this.refresh();
+  }
+
+  markUnread() {
+    ScriptApp.__behavior.checkMethod('GmailThread', 'markUnread');
+    Gmail.Users.Threads.modify({ addLabelIds: ['UNREAD'] }, 'me', this.getId());
+    return this.refresh();
+  }
+
+  moveToArchive() {
+    ScriptApp.__behavior.checkMethod('GmailThread', 'moveToArchive');
+    Gmail.Users.Threads.modify({ removeLabelIds: ['INBOX'] }, 'me', this.getId());
+    return this.refresh();
+  }
+
+  moveToInbox() {
+    ScriptApp.__behavior.checkMethod('GmailThread', 'moveToInbox');
+    Gmail.Users.Threads.modify({ addLabelIds: ['INBOX'] }, 'me', this.getId());
+    return this.refresh();
+  }
+
+  moveToSpam() {
+    ScriptApp.__behavior.checkMethod('GmailThread', 'moveToSpam');
+    Gmail.Users.Threads.modify({ addLabelIds: ['SPAM'] }, 'me', this.getId());
+    return this.refresh();
+  }
+
+  moveToTrash() {
+    ScriptApp.__behavior.checkMethod('GmailThread', 'moveToTrash');
+    Gmail.Users.Threads.trash('me', this.getId());
+    return this.refresh();
+  }
+
+  createDraftReply(body, options) {
+    ScriptApp.__behavior.checkMethod('GmailThread', 'createDraftReply');
+    const msgs = this.getMessages();
+    return msgs.length > 0 ? msgs[msgs.length - 1].createDraftReply(body, options) : null;
+  }
+
+  createDraftReplyAll(body, options) {
+    ScriptApp.__behavior.checkMethod('GmailThread', 'createDraftReplyAll');
+    const msgs = this.getMessages();
+    return msgs.length > 0 ? msgs[msgs.length - 1].createDraftReplyAll(body, options) : null;
+  }
+
+  reply(body, options) {
+    ScriptApp.__behavior.checkMethod('GmailThread', 'reply');
+    const msgs = this.getMessages();
+    if (msgs.length > 0) msgs[msgs.length - 1].reply(body, options);
+    return this;
+  }
+
+  replyAll(body, options) {
+    ScriptApp.__behavior.checkMethod('GmailThread', 'replyAll');
+    const msgs = this.getMessages();
+    if (msgs.length > 0) msgs[msgs.length - 1].replyAll(body, options);
     return this;
   }
 

package/src/services/slidesapp/fakecolorscheme.js

@@ -81,9 +81,9 @@ export class FakeColorScheme {
    * @param {FakeColor} color
    * @returns {FakeColorScheme} self
    */
-  setConcreteColor(themeColorType, color) {
+  setConcreteColor(themeColorType, ...colorArgs) {
     const { nargs, matchThrow } = signatureArgs(arguments, "ColorScheme.setConcreteColor");
-    if (nargs !== 2) matchThrow();
+    if (nargs < 2 || nargs > 4) matchThrow();
 
     const master = this.__masterPage;
     if (!master) throw new Error('Could not find master page for color scheme');
@@ -96,15 +96,34 @@ export class FakeColorScheme {
     const currentResource = this.__resource;
     const colors = [...(currentResource.colors || [])];
 
-    // Convert the new Color to API format
     const apiColor = {};
-    if (color.getColorType().toString() === 'RGB') {
-      const rgb = color.asRgbColor();
-      apiColor.red = rgb.getRed() / 255;
-      apiColor.green = rgb.getGreen() / 255;
-      apiColor.blue = rgb.getBlue() / 255;
-    } else if (color.getColorType().toString() === 'THEME') {
-      apiColor.themeColor = color.asThemeColor().getThemeColorType().toString();
+    if (colorArgs.length === 3) {
+      // (ThemeColorType, r, g, b)
+      apiColor.red = colorArgs[0] / 255;
+      apiColor.green = colorArgs[1] / 255;
+      apiColor.blue = colorArgs[2] / 255;
+    } else if (typeof colorArgs[0] === 'string') {
+      // (ThemeColorType, hexString)
+      const hex = colorArgs[0];
+      const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+      if (result) {
+        apiColor.red = parseInt(result[1], 16) / 255;
+        apiColor.green = parseInt(result[2], 16) / 255;
+        apiColor.blue = parseInt(result[3], 16) / 255;
+      } else {
+        throw new Error("Invalid hex color string");
+      }
+    } else {
+      // (ThemeColorType, Color)
+      const color = colorArgs[0];
+      if (color.getColorType().toString() === 'RGB') {
+        const rgb = color.asRgbColor();
+        apiColor.red = rgb.getRed() / 255;
+        apiColor.green = rgb.getGreen() / 255;
+        apiColor.blue = rgb.getBlue() / 255;
+      } else if (color.getColorType().toString() === 'THEME') {
+        apiColor.themeColor = color.asThemeColor().getThemeColorType().toString();
+      }
     }
 
     // Find and update or add the color pair

package/src/services/slidesapp/fakepresentation.js

@@ -52,14 +52,6 @@ export class FakePresentation {
     return `https://docs.google.com/presentation/d/${this.getId()}/edit`;
   }
 
-  /**
-   * Gets the color scheme of the presentation.
-   * @returns {FakeColorScheme} The color scheme.
-   */
-  getColorScheme() {
-    return newFakeColorScheme(this);
-  }
-
   /**
    * Gets the masters in the presentation.
    * @returns {FakeMaster[]} The masters.

package/src/services/spreadsheetapp/fakeembeddedchartbuilder.js

@@ -1,5 +1,5 @@
 import { Proxies } from "../../support/proxies.js";
-import { signatureArgs } from "../../support/helpers.js";
+import { signatureArgs, notYetImplemented } from "../../support/helpers.js";
 import { Utils } from "../../support/utils.js";
 import { makeSheetsGridRange } from "./sheetrangehelpers.js";
 import { newFakeEmbeddedChart } from "./fakeembeddedchart.js";
@@ -155,6 +155,25 @@ export class FakeEmbeddedChartBuilder {
       }
     }
 
+    // Apply colors to series
+    if (this.__colors && basic && basic.series) {
+      basic.series.forEach((s, i) => {
+        if (this.__colors[i]) {
+          const hex = this.__colors[i];
+          const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+          if (result) {
+            s.colorStyle = {
+              rgbColor: {
+                red: parseInt(result[1], 16) / 255,
+                green: parseInt(result[2], 16) / 255,
+                blue: parseInt(result[3], 16) / 255
+              }
+            };
+          }
+        }
+      });
+    }
+
     // 2. Handle Specialized Spec Blocks
     if (basic && basic.chartType === "PIE") {
       spec.pieChart = {
@@ -233,43 +252,109 @@ export class FakeEmbeddedChartBuilder {
   setTransposeRowsAndColumns(transpose) { return this; }
 
   // --- Chart Specific Builder Methods ---
-  reverseCategories() { return this; }
+  __getAxis(position) {
+    if (!this.__apiChart.spec.basicChart) {
+      this.__apiChart.spec.basicChart = { axis: [], domains: [], series: [] };
+    }
+    if (!this.__apiChart.spec.basicChart.axis) {
+      this.__apiChart.spec.basicChart.axis = [];
+    }
+    let axis = this.__apiChart.spec.basicChart.axis.find(a => a.position === position);
+    if (!axis) {
+      axis = { position };
+      this.__apiChart.spec.basicChart.axis.push(axis);
+    }
+    return axis;
+  }
+
+  reverseCategories() { notYetImplemented('reverseCategories'); return this; }
   setBackgroundColor(color) { return this.setOption("backgroundColor", color); }
-  setColors(colors) { return this; }
+  
+  setColors(colors) { 
+    ScriptApp.__behavior.checkMethod("EmbeddedChartBuilder", "setColors");
+    this.__colors = Array.isArray(colors) ? colors : [colors];
+    return this; 
+  }
+  
   setLegendPosition(position) { 
     this.__apiChart.spec.basicChart.legendPosition = position ? position.toString() : "RIGHT_LEGEND";
     return this; 
   }
-  setLegendTextStyle(textStyle) { return this; }
-  setPointStyle(pointStyle) { return this; }
-  setRange(min, max) { return this; }
-  setStacked() { return this; }
+  
+  setLegendTextStyle(textStyle) { notYetImplemented('setLegendTextStyle'); return this; }
+  setPointStyle(pointStyle) { notYetImplemented('setPointStyle'); return this; }
+  
+  setRange(min, max) { 
+    ScriptApp.__behavior.checkMethod("EmbeddedChartBuilder", "setRange");
+    const chartType = this.__apiChart.spec.basicChart ? this.__apiChart.spec.basicChart.chartType : null;
+    if (chartType === "BAR") {
+      return this.setXAxisRange(min, max);
+    }
+    return this.setYAxisRange(min, max); 
+  }
+  
+  setStacked() { 
+    ScriptApp.__behavior.checkMethod("EmbeddedChartBuilder", "setStacked");
+    if (this.__apiChart.spec.basicChart) {
+      this.__apiChart.spec.basicChart.stackedType = "STACKED";
+    }
+    return this; 
+  }
+  
   setTitle(title) { 
+    ScriptApp.__behavior.checkMethod("EmbeddedChartBuilder", "setTitle");
     this.__apiChart.spec.title = title;
     return this; 
   }
-  setTitleTextStyle(textStyle) { return this; }
-  setXAxisTextStyle(textStyle) { return this; }
-  setXAxisTitle(title) { return this; }
-  setXAxisTitleTextStyle(textStyle) { return this; }
-  setYAxisTextStyle(textStyle) { return this; }
-  setYAxisTitle(title) { return this; }
-  setYAxisTitleTextStyle(textStyle) { return this; }
-  useLogScale() { return this; }
+  
+  setTitleTextStyle(textStyle) { notYetImplemented('setTitleTextStyle'); return this; }
+  setXAxisTextStyle(textStyle) { notYetImplemented('setXAxisTextStyle'); return this; }
+  
+  setXAxisTitle(title) { 
+    ScriptApp.__behavior.checkMethod("EmbeddedChartBuilder", "setXAxisTitle");
+    this.__getAxis("BOTTOM_AXIS").title = title;
+    return this; 
+  }
+  
+  setXAxisTitleTextStyle(textStyle) { notYetImplemented('setXAxisTitleTextStyle'); return this; }
+  setYAxisTextStyle(textStyle) { notYetImplemented('setYAxisTextStyle'); return this; }
+  
+  setYAxisTitle(title) { 
+    ScriptApp.__behavior.checkMethod("EmbeddedChartBuilder", "setYAxisTitle");
+    this.__getAxis("LEFT_AXIS").title = title;
+    return this; 
+  }
+  
+  setYAxisTitleTextStyle(textStyle) { notYetImplemented('setYAxisTitleTextStyle'); return this; }
+  useLogScale() { notYetImplemented('useLogScale'); return this; }
   set3D() { return this.setOption("is3D", true); }
-  enablePaging(enable, pageSize) { return this; }
-  enableRtlTable(enable) { return this; }
-  enableSorting(enable) { return this; }
-  setFirstRowNumber(number) { return this; }
-  setInitialSortingAscending(column) { return this; }
-  setInitialSortingDescending(column) { return this; }
-  showRowNumberColumn(show) { return this; }
-  useAlternatingRowStyle(use) { return this; }
-  setXAxisLogScale() { return this; }
-  setXAxisRange(min, max) { return this; }
-  setYAxisLogScale() { return this; }
-  setYAxisRange(min, max) { return this; }
-  reverseDirection() { return this; }
+  enablePaging(enable, pageSize) { notYetImplemented('enablePaging'); return this; }
+  enableRtlTable(enable) { notYetImplemented('enableRtlTable'); return this; }
+  enableSorting(enable) { notYetImplemented('enableSorting'); return this; }
+  setFirstRowNumber(number) { notYetImplemented('setFirstRowNumber'); return this; }
+  setInitialSortingAscending(column) { notYetImplemented('setInitialSortingAscending'); return this; }
+  setInitialSortingDescending(column) { notYetImplemented('setInitialSortingDescending'); return this; }
+  showRowNumberColumn(show) { notYetImplemented('showRowNumberColumn'); return this; }
+  useAlternatingRowStyle(use) { notYetImplemented('useAlternatingRowStyle'); return this; }
+  setXAxisLogScale() { notYetImplemented('setXAxisLogScale'); return this; }
+  
+  setXAxisRange(min, max) { 
+    ScriptApp.__behavior.checkMethod("EmbeddedChartBuilder", "setXAxisRange");
+    const axis = this.__getAxis("BOTTOM_AXIS");
+    axis.viewWindowOptions = { viewWindowMin: min, viewWindowMax: max };
+    return this; 
+  }
+  
+  setYAxisLogScale() { notYetImplemented('setYAxisLogScale'); return this; }
+  
+  setYAxisRange(min, max) { 
+    ScriptApp.__behavior.checkMethod("EmbeddedChartBuilder", "setYAxisRange");
+    const axis = this.__getAxis("LEFT_AXIS");
+    axis.viewWindowOptions = { viewWindowMin: min, viewWindowMax: max };
+    return this; 
+  }
+  
+  reverseDirection() { notYetImplemented('reverseDirection'); return this; }
 
   toString() {
     const type = this.__apiChart.spec.basicChart?.chartType;

package/src/services/spreadsheetapp/fakespreadsheetapp.js

@@ -91,7 +91,6 @@ export class FakeSpreadsheetApp {
       "setActiveRange",
       "setActiveRangeList",
       "getUi",
-      "open",
 
       "ChartAggregationType",
       "ChartTransformationType",
@@ -106,6 +105,21 @@ export class FakeSpreadsheetApp {
   toString() {
     return "SpreadsheetApp";
   }
+
+  /**
+   * Opens the spreadsheet that corresponds to the given File object.
+   * @param {File} file A Drive file object representing a spreadsheet.
+   * @returns {FakeSpreadsheet} the spreadsheet
+   */
+  open(file) {
+    const { nargs, matchThrow } = signatureArgs(arguments, "SpreadsheetApp.open");
+    if (nargs !== 1) matchThrow();
+    if (!file || typeof file.getId !== 'function') {
+      throw new Error('Invalid file object');
+    }
+    return this.openById(file.getId());
+  }
+
   getActiveSpreadsheet() {
     if (this.__activeSpreadsheet) return this.__activeSpreadsheet;
     // because this is a faked container bound app, we need to get the documentId from the config file

package/src/support/sxgmail.js

@@ -16,8 +16,28 @@ export const sxGmail = async (Auth, { subProp, prop, method, params, options })
   const tag = `sxGmail for ${methodName}`;
 
   return sxRetry(Auth, tag, async () => {
-    const callish = subProp ? apiClient[prop][subProp] : apiClient[prop];
-    return callish[method](params, options);
+    let context = subProp ? apiClient[prop][subProp] : apiClient[prop];
+    let methodFunc = context[method];
+    
+    if (!methodFunc && method.includes('.')) {
+      const parts = method.split('.');
+      for (const part of parts) {
+        if (!context[part]) {
+          methodFunc = undefined;
+          break;
+        }
+        methodFunc = context[part];
+        if (part !== parts[parts.length - 1]) {
+          context = methodFunc;
+        }
+      }
+    }
+
+    if (typeof methodFunc !== 'function') {
+      throw new Error(`Method ${methodName} not found on Gmail API client`);
+    }
+
+    return methodFunc.call(context, params, options);
   }, {
     skipLog: (error, response) => {
       // Don't log 404, 409, or 400 as an error. 

package/src/support/sxjdbc.js

@@ -50,11 +50,24 @@ export const sxJdbcConnect = async (Auth, { url, user, password }) => {
       ssl: disableSsl ? false : { rejectUnauthorized: false }
     };
 
-    if (user !== null && typeof user !== 'undefined' && password !== null && typeof password !== 'undefined') {
+    let finalUser = user;
+    let finalPassword = password;
+
+    if ((user === null || typeof user === 'undefined') && (password === null || typeof password === 'undefined')) {
+      try {
+        const parsedUrl = new URL(pgConnectionString);
+        if (parsedUrl.username) finalUser = decodeURIComponent(parsedUrl.username);
+        if (parsedUrl.password) finalPassword = decodeURIComponent(parsedUrl.password);
+      } catch (e) {
+        // ignore parsing errors
+      }
+    }
+
+    if (finalUser !== null && typeof finalUser !== 'undefined' && finalPassword !== null && typeof finalPassword !== 'undefined') {
       client = new pg.Client({
         ...clientConfig,
-        user: String(user),
-        password: String(password)
+        user: String(finalUser),
+        password: String(finalPassword)
       });
     } else {
       client = new pg.Client(clientConfig);

package/src/support/utils.js

@@ -363,11 +363,11 @@ const normalizeColorStringToHex = (color) => {
   if (!is.string(color)) return null;
   const lowerColor = color.toLowerCase().replace(/\s/g, '');
   if (colorNameToHex[lowerColor]) {
-    return colorNameToHex[lowerColor];
+    return colorNameToHex[lowerColor].toUpperCase();
   }
   // Check if it's a valid hex string
   if (/^#[0-9a-f]{6}$/i.test(lowerColor)) {
-    return lowerColor;
+    return lowerColor.toUpperCase();
   }
   return null; // Invalid color string
 };