john
c122bd5664
Document Umami as the sole analytics platform, remove Rybbit proxy and tracker code, and classify public page traffic with discovery_channel for adm SEO/GEO dashboards. Co-authored-by: Cursor <cursoragent@cursor.com>
260 lines
5.7 KiB
JavaScript
260 lines
5.7 KiB
JavaScript
import assert from 'node:assert/strict';
|
|
import test from 'node:test';
|
|
import {
|
|
createPortalPublishedPageDelivery,
|
|
} from './portal-published-page-delivery.mjs';
|
|
|
|
function createResponse() {
|
|
return {
|
|
statusCode: 200,
|
|
body: undefined,
|
|
headers: {},
|
|
status(code) {
|
|
this.statusCode = code;
|
|
return this;
|
|
},
|
|
type(value) {
|
|
this.headers['Content-Type'] = value;
|
|
return this;
|
|
},
|
|
set(name, value) {
|
|
this.headers[name] = value;
|
|
return this;
|
|
},
|
|
send(body) {
|
|
this.body = body;
|
|
return this;
|
|
},
|
|
removeHeader(name) {
|
|
delete this.headers[name];
|
|
},
|
|
};
|
|
}
|
|
|
|
function createRequest(overrides = {}) {
|
|
return {
|
|
originalUrl:
|
|
'/u/alice/pages/demo?source=test',
|
|
url: '/u/alice/pages/demo',
|
|
query: {},
|
|
headers: {
|
|
host: 'portal.example',
|
|
},
|
|
protocol: 'https',
|
|
get(name) {
|
|
return name === 'user-agent'
|
|
? 'desktop browser'
|
|
: '';
|
|
},
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
function createResult(overrides = {}) {
|
|
return {
|
|
html: '<!doctype html><html><head><title>Demo Page</title></head><body><main>Demo</main></body></html>',
|
|
publication: {
|
|
accessMode: 'public',
|
|
},
|
|
pageSource: null,
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
test('injects umami tracker for publication HTML delivery', async () => {
|
|
const sendPublishedPage =
|
|
createPortalPublishedPageDelivery({
|
|
async registerLongImageArtifact() {},
|
|
analyticsConfig: {
|
|
enabled: true,
|
|
websiteId: 'local-website',
|
|
idSecret: 'secret',
|
|
scriptPath: '/analytics/script.js',
|
|
hostPath: '/analytics',
|
|
},
|
|
});
|
|
const response = createResponse();
|
|
await sendPublishedPage(
|
|
createRequest(),
|
|
response,
|
|
{
|
|
...createResult(),
|
|
ownerId: 'user-123',
|
|
pageSource: { pageId: 'page-1' },
|
|
publication: { id: 'pub-1', accessMode: 'login_required' },
|
|
},
|
|
{ raw: true },
|
|
);
|
|
assert.match(response.body, /src="\/analytics\/script\.js"/);
|
|
assert.match(response.body, /data-website-id="local-website"/);
|
|
assert.doesNotMatch(response.body, /user-123/);
|
|
});
|
|
|
|
test('wraps a normal full HTML publication in the share shell', async () => {
|
|
const sendPublishedPage =
|
|
createPortalPublishedPageDelivery({
|
|
async registerLongImageArtifact() {},
|
|
});
|
|
const response = createResponse();
|
|
await sendPublishedPage(
|
|
createRequest({
|
|
headers: {
|
|
host: 'portal.example',
|
|
referer: 'https://www.google.com/search?q=demo',
|
|
},
|
|
}),
|
|
response,
|
|
createResult(),
|
|
);
|
|
assert.equal(response.statusCode, 200);
|
|
assert.match(
|
|
response.body,
|
|
/class="publication-frame"/,
|
|
);
|
|
assert.match(
|
|
response.body,
|
|
/view=raw/,
|
|
);
|
|
assert.match(
|
|
response.body,
|
|
/memind_discovery=seo/,
|
|
);
|
|
assert.match(
|
|
response.body,
|
|
/memind_discovery_source=google/,
|
|
);
|
|
assert.equal(
|
|
response.headers['Cache-Control'],
|
|
'public, max-age=60',
|
|
);
|
|
});
|
|
|
|
test('raw and password publications bypass the share shell', async () => {
|
|
const sendPublishedPage =
|
|
createPortalPublishedPageDelivery({
|
|
async registerLongImageArtifact() {},
|
|
});
|
|
const rawResponse = createResponse();
|
|
await sendPublishedPage(
|
|
createRequest(),
|
|
rawResponse,
|
|
createResult(),
|
|
{ raw: true },
|
|
);
|
|
assert.doesNotMatch(
|
|
rawResponse.body,
|
|
/publication-frame/,
|
|
);
|
|
assert.match(rawResponse.body, /Demo/);
|
|
|
|
const passwordResponse = createResponse();
|
|
await sendPublishedPage(
|
|
createRequest(),
|
|
passwordResponse,
|
|
createResult({
|
|
publication: {
|
|
accessMode: 'password',
|
|
},
|
|
}),
|
|
);
|
|
assert.doesNotMatch(
|
|
passwordResponse.body,
|
|
/publication-frame/,
|
|
);
|
|
assert.equal(
|
|
passwordResponse.headers['Cache-Control'],
|
|
'private, no-store',
|
|
);
|
|
});
|
|
|
|
test('embed mode delivers embedded HTML and frame headers', async () => {
|
|
const sendPublishedPage =
|
|
createPortalPublishedPageDelivery({
|
|
async registerLongImageArtifact() {},
|
|
});
|
|
const response = createResponse();
|
|
await sendPublishedPage(
|
|
createRequest(),
|
|
response,
|
|
createResult(),
|
|
{ embed: true },
|
|
);
|
|
assert.doesNotMatch(
|
|
response.body,
|
|
/publication-frame/,
|
|
);
|
|
assert.equal(
|
|
response.headers['X-Frame-Options'],
|
|
undefined,
|
|
);
|
|
});
|
|
|
|
test('long-image download renders, registers, and returns PNG', async () => {
|
|
const calls = [];
|
|
const image = Buffer.from('png-image');
|
|
const sendPublishedPage =
|
|
createPortalPublishedPageDelivery({
|
|
async renderLongImage(options) {
|
|
calls.push(['render', options]);
|
|
return image;
|
|
},
|
|
async registerLongImageArtifact(
|
|
options,
|
|
) {
|
|
calls.push(['register', options]);
|
|
},
|
|
});
|
|
const response = createResponse();
|
|
await sendPublishedPage(
|
|
createRequest({
|
|
query: {
|
|
download: 'long-image',
|
|
},
|
|
}),
|
|
response,
|
|
createResult(),
|
|
);
|
|
assert.equal(response.body, image);
|
|
assert.equal(
|
|
response.headers['Content-Type'],
|
|
'image/png',
|
|
);
|
|
assert.equal(
|
|
response.headers['Cache-Control'],
|
|
'no-store',
|
|
);
|
|
assert.match(
|
|
calls[0][1].url,
|
|
/view=raw/,
|
|
);
|
|
assert.match(
|
|
calls[1][1].canonicalUrl,
|
|
/download=long-image/,
|
|
);
|
|
});
|
|
|
|
test('long-image failures preserve the public error response', async () => {
|
|
const sendPublishedPage =
|
|
createPortalPublishedPageDelivery({
|
|
async renderLongImage() {
|
|
throw new Error('renderer failed');
|
|
},
|
|
async registerLongImageArtifact() {},
|
|
});
|
|
const response = createResponse();
|
|
await sendPublishedPage(
|
|
createRequest({
|
|
query: {
|
|
download: 'long-image',
|
|
},
|
|
}),
|
|
response,
|
|
createResult(),
|
|
);
|
|
assert.equal(response.statusCode, 500);
|
|
assert.match(
|
|
response.body,
|
|
/renderer failed/,
|
|
);
|
|
});
|