549 lines
15 KiB
JavaScript
549 lines
15 KiB
JavaScript
const test = require("node:test");
|
|
const assert = require("node:assert/strict");
|
|
|
|
global.document = { cookie: "x=y" };
|
|
global.GM_xmlhttpRequest = undefined;
|
|
|
|
const api = require("./xhs-pgy-export.user.js");
|
|
|
|
function okJson(payload) {
|
|
return {
|
|
ok: true,
|
|
status: 200,
|
|
async json() {
|
|
return payload;
|
|
},
|
|
};
|
|
}
|
|
|
|
test("data_summary request includes business=1", async () => {
|
|
const urls = [];
|
|
|
|
async function fetchImpl(url) {
|
|
urls.push(url);
|
|
if (String(url).startsWith(api.API_BASE)) {
|
|
return okJson({ data: { userId: "u-123" } });
|
|
}
|
|
return okJson({ data: {} });
|
|
}
|
|
|
|
await api.fetchMergedBloggerRecord("any-id", fetchImpl);
|
|
|
|
const target = urls.find((u) => String(u).includes("/v1/pugongying/data_summary"));
|
|
assert.ok(target, "expected a call to /v1/pugongying/data_summary");
|
|
|
|
const parsed = new URL(target);
|
|
assert.equal(parsed.searchParams.get("business"), "1");
|
|
assert.equal(parsed.searchParams.get("userId"), "u-123");
|
|
});
|
|
|
|
test("supplemental proxy requests include cookie query parameter", async () => {
|
|
const urls = [];
|
|
|
|
async function fetchImpl(url) {
|
|
urls.push(String(url));
|
|
if (String(url).startsWith(api.API_BASE)) {
|
|
return okJson({ data: { userId: "u-123" } });
|
|
}
|
|
return okJson({ data: {} });
|
|
}
|
|
|
|
await api.fetchMergedBloggerRecord("any-id", fetchImpl);
|
|
|
|
const proxyUrls = urls.filter((url) => url.includes("/v1/pugongying/"));
|
|
assert.equal(proxyUrls.length, 2);
|
|
for (const url of proxyUrls) {
|
|
const parsed = new URL(url);
|
|
assert.equal(parsed.searchParams.get("cookie"), "x=y");
|
|
}
|
|
});
|
|
|
|
test("extractBloggerId resolves xhs short link from SSR profile HTML", async () => {
|
|
const previousGm = global.GM_xmlhttpRequest;
|
|
global.GM_xmlhttpRequest = (options) => {
|
|
assert.equal(options.url, "https://xhslink.com/m/example");
|
|
options.onload({
|
|
status: 200,
|
|
finalUrl:
|
|
"https://www.xiaohongshu.com/user/profile/2022919XN?xsec_source=app_share",
|
|
responseText:
|
|
'<script>window.__INITIAL_STATE__={"profile":{"noteData":[{"user":{"id":"60379f3c000000000101e53f","nickname":"Alice"}}]}}</script>',
|
|
});
|
|
};
|
|
|
|
try {
|
|
await assert.doesNotReject(async () => {
|
|
assert.equal(
|
|
await api.extractBloggerId("https://xhslink.com/m/example"),
|
|
"60379f3c000000000101e53f",
|
|
);
|
|
});
|
|
} finally {
|
|
global.GM_xmlhttpRequest = previousGm;
|
|
}
|
|
});
|
|
|
|
test("buildFeishuSheetValues uses labels as header row", () => {
|
|
const records = [
|
|
{
|
|
flattened: {
|
|
userId: "u-1",
|
|
name: "达人 A",
|
|
fansCount: 123,
|
|
},
|
|
},
|
|
];
|
|
|
|
const values = api.buildFeishuSheetValues(records, ["userId", "name", "fansCount"]);
|
|
|
|
assert.deepEqual(values, [
|
|
["达人ID", "达人昵称", "粉丝数"],
|
|
["u-1", "达人 A", 123],
|
|
]);
|
|
});
|
|
|
|
test("buildFeishuRange expands columns past Z", () => {
|
|
assert.equal(api.buildFeishuRange("abc123", 1, 1), "abc123!A1:A1");
|
|
assert.equal(api.buildFeishuRange("abc123", 2, 28), "abc123!A1:AB2");
|
|
});
|
|
|
|
test("exportRecordsToFeishuSpreadsheet creates spreadsheet then writes values", async () => {
|
|
const calls = [];
|
|
|
|
async function fetchImpl(url, options) {
|
|
const body = options && options.body ? JSON.parse(options.body) : null;
|
|
calls.push({
|
|
url: String(url),
|
|
method: options && options.method,
|
|
headers: options && options.headers,
|
|
body,
|
|
});
|
|
|
|
if (String(url).includes("/auth/v3/tenant_access_token/internal")) {
|
|
return okJson({ code: 0, tenant_access_token: "tenant-token" });
|
|
}
|
|
if (String(url).includes("/sheets/v3/spreadsheets")) {
|
|
return okJson({
|
|
code: 0,
|
|
data: {
|
|
spreadsheet: {
|
|
spreadsheet_token: "spreadsheet-token",
|
|
url: "https://feishu.example/spreadsheet-token",
|
|
},
|
|
},
|
|
});
|
|
}
|
|
if (String(url).includes("/metainfo")) {
|
|
return okJson({
|
|
code: 0,
|
|
data: {
|
|
sheets: [
|
|
{
|
|
sheetId: "sheet-a",
|
|
title: "Sheet1",
|
|
},
|
|
],
|
|
},
|
|
});
|
|
}
|
|
if (String(url).includes("/values_batch_update")) {
|
|
return okJson({ code: 0, data: {} });
|
|
}
|
|
|
|
throw new Error(`unexpected url: ${url}`);
|
|
}
|
|
|
|
const result = await api.exportRecordsToFeishuSpreadsheet({
|
|
appId: "cli_xxx",
|
|
appSecret: "secret",
|
|
title: "测试导出",
|
|
records: [
|
|
{
|
|
flattened: {
|
|
userId: "u-1",
|
|
name: "达人 A",
|
|
},
|
|
},
|
|
],
|
|
fields: ["userId", "name"],
|
|
fetchImpl,
|
|
});
|
|
|
|
assert.equal(result.spreadsheetToken, "spreadsheet-token");
|
|
assert.equal(result.url, "https://feishu.example/spreadsheet-token");
|
|
assert.equal(result.sheetId, "sheet-a");
|
|
assert.equal(calls.length, 4);
|
|
assert.deepEqual(calls[0].body, {
|
|
app_id: "cli_xxx",
|
|
app_secret: "secret",
|
|
});
|
|
assert.equal(calls[1].body.title, "测试导出");
|
|
assert.equal(calls[2].method, "GET");
|
|
assert.equal(calls[3].headers.Authorization, "Bearer tenant-token");
|
|
assert.deepEqual(calls[3].body, {
|
|
valueRanges: [
|
|
{
|
|
range: "sheet-a!A1:B2",
|
|
values: [
|
|
["达人ID", "达人昵称"],
|
|
["u-1", "达人 A"],
|
|
],
|
|
},
|
|
],
|
|
});
|
|
});
|
|
|
|
test("exportRecordsToFeishuBitable creates app fields and records", async () => {
|
|
const calls = [];
|
|
|
|
async function fetchImpl(url, options) {
|
|
const body = options && options.body ? JSON.parse(options.body) : null;
|
|
calls.push({
|
|
url: String(url),
|
|
method: options && options.method,
|
|
headers: options && options.headers,
|
|
body,
|
|
});
|
|
|
|
if (String(url).includes("/auth/v3/tenant_access_token/internal")) {
|
|
return okJson({ code: 0, tenant_access_token: "tenant-token" });
|
|
}
|
|
if (String(url).endsWith("/bitable/v1/apps")) {
|
|
return okJson({
|
|
code: 0,
|
|
data: {
|
|
app: {
|
|
app_token: "base-token",
|
|
default_table_id: "tbl-default",
|
|
url: "https://feishu.example/base-token",
|
|
},
|
|
},
|
|
});
|
|
}
|
|
if (String(url).includes("/fields")) {
|
|
return okJson({ code: 0, data: { field: { field_id: "fld-created" } } });
|
|
}
|
|
if (String(url).includes("/records/batch_create")) {
|
|
return okJson({ code: 0, data: { records: [{ record_id: "rec-1" }] } });
|
|
}
|
|
|
|
throw new Error(`unexpected url: ${url}`);
|
|
}
|
|
|
|
const result = await api.exportRecordsToFeishuBitable({
|
|
appId: "cli_xxx",
|
|
appSecret: "secret",
|
|
title: "测试多维表格",
|
|
records: [
|
|
{
|
|
flattened: {
|
|
userId: "u-1",
|
|
name: "达人 A",
|
|
},
|
|
},
|
|
],
|
|
fields: ["userId", "name"],
|
|
fetchImpl,
|
|
});
|
|
|
|
assert.equal(result.appToken, "base-token");
|
|
assert.equal(result.tableId, "tbl-default");
|
|
assert.equal(result.url, "https://feishu.example/base-token");
|
|
assert.equal(result.rowCount, 1);
|
|
assert.equal(calls.length, 5);
|
|
assert.deepEqual(calls[0].body, {
|
|
app_id: "cli_xxx",
|
|
app_secret: "secret",
|
|
});
|
|
assert.deepEqual(calls[1].body, {
|
|
name: "测试多维表格",
|
|
});
|
|
assert.equal(calls[2].url.endsWith("/bitable/v1/apps/base-token/tables/tbl-default/fields"), true);
|
|
assert.deepEqual(calls[2].body, {
|
|
field_name: "达人ID",
|
|
type: 1,
|
|
});
|
|
assert.deepEqual(calls[3].body, {
|
|
field_name: "达人昵称",
|
|
type: 1,
|
|
});
|
|
assert.equal(
|
|
calls[4].url.endsWith(
|
|
"/bitable/v1/apps/base-token/tables/tbl-default/records/batch_create",
|
|
),
|
|
true,
|
|
);
|
|
assert.deepEqual(calls[4].body, {
|
|
records: [
|
|
{
|
|
fields: {
|
|
"达人ID": "u-1",
|
|
"达人昵称": "达人 A",
|
|
},
|
|
},
|
|
],
|
|
});
|
|
});
|
|
|
|
test("writeFeishuBitableRecords writes records in 500-row batches", async () => {
|
|
const batches = [];
|
|
|
|
async function fetchImpl(url, options) {
|
|
assert.equal(
|
|
String(url).endsWith("/bitable/v1/apps/base-token/tables/tbl-default/records/batch_create"),
|
|
true,
|
|
);
|
|
batches.push(JSON.parse(options.body).records.length);
|
|
return okJson({ code: 0, data: {} });
|
|
}
|
|
|
|
const records = Array.from({ length: 501 }, (_, index) => ({
|
|
fields: {
|
|
"达人ID": `u-${index + 1}`,
|
|
},
|
|
}));
|
|
|
|
const result = await api.writeFeishuBitableRecords({
|
|
tenantAccessToken: "tenant-token",
|
|
appToken: "base-token",
|
|
tableId: "tbl-default",
|
|
records,
|
|
fetchImpl,
|
|
});
|
|
|
|
assert.deepEqual(batches, [500, 1]);
|
|
assert.equal(result.writtenCount, 501);
|
|
});
|
|
|
|
test("controller reads Feishu credentials from localStorage instead of bundled secrets", async () => {
|
|
const previousLocalStorage = global.localStorage;
|
|
const previousGm = global.GM_xmlhttpRequest;
|
|
const sentAuthBodies = [];
|
|
|
|
global.GM_xmlhttpRequest = undefined;
|
|
global.localStorage = {
|
|
getItem(key) {
|
|
if (key === "xhs-pgy-export:feishu-app-id") {
|
|
return JSON.stringify("cli_from_storage");
|
|
}
|
|
if (key === "xhs-pgy-export:feishu-app-secret") {
|
|
return JSON.stringify("secret_from_storage");
|
|
}
|
|
return null;
|
|
},
|
|
setItem() {},
|
|
};
|
|
|
|
async function fetchImpl(url, options) {
|
|
const body = options && options.body ? JSON.parse(options.body) : null;
|
|
if (String(url).startsWith(api.API_BASE)) {
|
|
return okJson({
|
|
code: 0,
|
|
data: {
|
|
id: "60379f3c000000000101e53f",
|
|
userId: "60379f3c000000000101e53f",
|
|
name: "达人 A",
|
|
},
|
|
});
|
|
}
|
|
if (String(url).includes("/auth/v3/tenant_access_token/internal")) {
|
|
sentAuthBodies.push(body);
|
|
return okJson({ code: 0, tenant_access_token: "tenant-token" });
|
|
}
|
|
if (String(url).includes("/sheets/v3/spreadsheets")) {
|
|
return okJson({
|
|
code: 0,
|
|
data: {
|
|
spreadsheet: {
|
|
spreadsheet_token: "spreadsheet-token",
|
|
},
|
|
},
|
|
});
|
|
}
|
|
if (String(url).includes("/metainfo")) {
|
|
return okJson({ code: 0, data: { sheets: [{ sheetId: "sheet-a" }] } });
|
|
}
|
|
if (String(url).includes("/values_batch_update")) {
|
|
return okJson({ code: 0, data: {} });
|
|
}
|
|
throw new Error(`unexpected url: ${url}`);
|
|
}
|
|
|
|
try {
|
|
const controller = api.createExportController({ fetchImpl });
|
|
await controller.preview("60379f3c000000000101e53f");
|
|
await controller.exportFeishuSpreadsheet(["userId", "name"]);
|
|
|
|
assert.deepEqual(sentAuthBodies, [
|
|
{
|
|
app_id: "cli_from_storage",
|
|
app_secret: "secret_from_storage",
|
|
},
|
|
]);
|
|
} finally {
|
|
global.localStorage = previousLocalStorage;
|
|
global.GM_xmlhttpRequest = previousGm;
|
|
}
|
|
});
|
|
|
|
test("controller saves Feishu credentials for later exports", async () => {
|
|
const previousLocalStorage = global.localStorage;
|
|
const previousGm = global.GM_xmlhttpRequest;
|
|
const storage = new Map();
|
|
const sentAuthBodies = [];
|
|
|
|
global.GM_xmlhttpRequest = undefined;
|
|
global.localStorage = {
|
|
getItem(key) {
|
|
return storage.has(key) ? storage.get(key) : null;
|
|
},
|
|
setItem(key, value) {
|
|
storage.set(key, value);
|
|
},
|
|
};
|
|
|
|
async function fetchImpl(url, options) {
|
|
const body = options && options.body ? JSON.parse(options.body) : null;
|
|
if (String(url).startsWith(api.API_BASE)) {
|
|
return okJson({
|
|
code: 0,
|
|
data: {
|
|
id: "60379f3c000000000101e53f",
|
|
userId: "60379f3c000000000101e53f",
|
|
name: "达人 A",
|
|
},
|
|
});
|
|
}
|
|
if (String(url).includes("/auth/v3/tenant_access_token/internal")) {
|
|
sentAuthBodies.push(body);
|
|
return okJson({ code: 0, tenant_access_token: "tenant-token" });
|
|
}
|
|
if (String(url).includes("/sheets/v3/spreadsheets")) {
|
|
return okJson({
|
|
code: 0,
|
|
data: {
|
|
spreadsheet: {
|
|
spreadsheet_token: "spreadsheet-token",
|
|
},
|
|
},
|
|
});
|
|
}
|
|
if (String(url).includes("/metainfo")) {
|
|
return okJson({ code: 0, data: { sheets: [{ sheetId: "sheet-a" }] } });
|
|
}
|
|
if (String(url).includes("/values_batch_update")) {
|
|
return okJson({ code: 0, data: {} });
|
|
}
|
|
throw new Error(`unexpected url: ${url}`);
|
|
}
|
|
|
|
try {
|
|
const controller = api.createExportController({ fetchImpl });
|
|
controller.saveFeishuCredentials({
|
|
appId: " cli_saved ",
|
|
appSecret: " secret_saved ",
|
|
});
|
|
await controller.preview("60379f3c000000000101e53f");
|
|
await controller.exportFeishuSpreadsheet(["userId", "name"]);
|
|
|
|
assert.equal(storage.get("xhs-pgy-export:feishu-app-id"), JSON.stringify("cli_saved"));
|
|
assert.equal(
|
|
storage.get("xhs-pgy-export:feishu-app-secret"),
|
|
JSON.stringify("secret_saved"),
|
|
);
|
|
assert.deepEqual(sentAuthBodies, [
|
|
{
|
|
app_id: "cli_saved",
|
|
app_secret: "secret_saved",
|
|
},
|
|
]);
|
|
} finally {
|
|
global.localStorage = previousLocalStorage;
|
|
global.GM_xmlhttpRequest = previousGm;
|
|
}
|
|
});
|
|
|
|
test("controller uses GM_xmlhttpRequest for Feishu even when page fetch is available", async () => {
|
|
const gmUrls = [];
|
|
const pageFetchUrls = [];
|
|
const previousGm = global.GM_xmlhttpRequest;
|
|
const previousLocalStorage = global.localStorage;
|
|
|
|
global.localStorage = {
|
|
getItem(key) {
|
|
if (key === "xhs-pgy-export:feishu-app-id") {
|
|
return JSON.stringify("cli_from_storage");
|
|
}
|
|
if (key === "xhs-pgy-export:feishu-app-secret") {
|
|
return JSON.stringify("secret_from_storage");
|
|
}
|
|
return null;
|
|
},
|
|
setItem() {},
|
|
};
|
|
|
|
global.GM_xmlhttpRequest = (options) => {
|
|
gmUrls.push(options.url);
|
|
let payload;
|
|
if (String(options.url).includes("/auth/v3/tenant_access_token/internal")) {
|
|
payload = { code: 0, tenant_access_token: "tenant-token" };
|
|
} else if (String(options.url).includes("/sheets/v3/spreadsheets")) {
|
|
payload = {
|
|
code: 0,
|
|
data: {
|
|
spreadsheet: {
|
|
spreadsheet_token: "spreadsheet-token",
|
|
url: "https://feishu.example/spreadsheet-token",
|
|
},
|
|
},
|
|
};
|
|
} else if (String(options.url).includes("/metainfo")) {
|
|
payload = {
|
|
code: 0,
|
|
data: { sheets: [{ sheetId: "sheet-a" }] },
|
|
};
|
|
} else if (String(options.url).includes("/values_batch_update")) {
|
|
payload = { code: 0, data: {} };
|
|
} else {
|
|
throw new Error(`unexpected GM url: ${options.url}`);
|
|
}
|
|
|
|
options.onload({
|
|
status: 200,
|
|
responseText: JSON.stringify(payload),
|
|
});
|
|
};
|
|
|
|
try {
|
|
async function pageFetch(url) {
|
|
pageFetchUrls.push(String(url));
|
|
if (String(url).startsWith(api.API_BASE)) {
|
|
return okJson({
|
|
code: 0,
|
|
data: {
|
|
id: "60379f3c000000000101e53f",
|
|
userId: "60379f3c000000000101e53f",
|
|
name: "达人 A",
|
|
},
|
|
});
|
|
}
|
|
return okJson({ code: 0, data: {} });
|
|
}
|
|
|
|
const controller = api.createExportController({ fetchImpl: pageFetch });
|
|
await controller.preview("60379f3c000000000101e53f");
|
|
const result = await controller.exportFeishuSpreadsheet(["userId", "name"]);
|
|
|
|
assert.equal(result.spreadsheetToken, "spreadsheet-token");
|
|
assert.equal(gmUrls.filter((url) => String(url).includes("open.feishu.cn")).length, 4);
|
|
assert.equal(
|
|
pageFetchUrls.some((url) => url.includes("open.feishu.cn")),
|
|
false,
|
|
"Feishu requests should not use page fetch because browsers block cross-origin OpenAPI calls",
|
|
);
|
|
} finally {
|
|
global.GM_xmlhttpRequest = previousGm;
|
|
global.localStorage = previousLocalStorage;
|
|
}
|
|
});
|