660 lines
20 KiB
JavaScript
660 lines
20 KiB
JavaScript
import test from "node:test";
|
|
import assert from "node:assert/strict";
|
|
import { registerHooks } from "node:module";
|
|
|
|
const functionUrl = new URL("../functions/login.ts", import.meta.url);
|
|
const migrationUrl = new URL("../functions/wucaiMigration.ts", import.meta.url);
|
|
const state = {
|
|
users: [],
|
|
usersAd: [],
|
|
abConfigs: [],
|
|
orders: [],
|
|
idcount: [
|
|
{ _id: "69faba99b4d89b170da4bf56", count: 1 },
|
|
{ _id: "69fabaacb4d89b170da4bf57", count: 1 },
|
|
],
|
|
source: null,
|
|
sourceFails: false,
|
|
sourceCalls: 0,
|
|
failABUpdate: false,
|
|
};
|
|
|
|
function clone(value) {
|
|
return value == null ? value : JSON.parse(JSON.stringify(value));
|
|
}
|
|
|
|
function documents(name) {
|
|
if (name === "users") return state.users;
|
|
if (name === "usersAd") return state.usersAd;
|
|
if (name === "ab_config") return state.abConfigs;
|
|
if (name === "order") return state.orders;
|
|
if (name === "idcount") return state.idcount;
|
|
return [];
|
|
}
|
|
|
|
function matches(document, query) {
|
|
return Object.keys(query).every(key => document[key] === query[key]);
|
|
}
|
|
|
|
function collection(name) {
|
|
const api = {
|
|
field() {
|
|
return api;
|
|
},
|
|
where(query) {
|
|
return {
|
|
async get() {
|
|
return { data: documents(name).filter(item => matches(item, query)).map(clone) };
|
|
},
|
|
async getOne() {
|
|
return { data: clone(documents(name).find(item => matches(item, query)) || null) };
|
|
},
|
|
async update(payload) {
|
|
if (state.failABUpdate && Object.keys(payload).length === 1 && payload.abTests) {
|
|
throw new Error("abTests update failed");
|
|
}
|
|
const matched = documents(name).filter(item => matches(item, query));
|
|
matched.forEach(item => Object.assign(item, clone(payload)));
|
|
return { updated: matched.length };
|
|
},
|
|
};
|
|
},
|
|
async add(payload) {
|
|
const document = { _id: `user-${state.users.length + 1}`, ...clone(payload) };
|
|
documents(name).push(document);
|
|
return { id: document._id };
|
|
},
|
|
async get() {
|
|
return { data: documents(name).map(clone) };
|
|
},
|
|
};
|
|
return api;
|
|
}
|
|
|
|
globalThis.__loginWucaiCloudMock = {
|
|
database() {
|
|
return { collection };
|
|
},
|
|
async fetch() {
|
|
return {
|
|
data: {
|
|
openid: "openid-1",
|
|
session_key: "session-1",
|
|
unionid: "union-1",
|
|
},
|
|
};
|
|
},
|
|
};
|
|
|
|
globalThis.require = () => ({});
|
|
globalThis.fetch = async () => {
|
|
state.sourceCalls++;
|
|
if (state.sourceFails) {
|
|
throw new Error("source unavailable");
|
|
}
|
|
return {
|
|
ok: true,
|
|
async json() {
|
|
return { data: clone(state.source) };
|
|
},
|
|
};
|
|
};
|
|
|
|
registerHooks({
|
|
resolve(specifier, context, nextResolve) {
|
|
if (specifier === "@lafjs/cloud") {
|
|
return {
|
|
url: "data:text/javascript,export default globalThis.__loginWucaiCloudMock",
|
|
shortCircuit: true,
|
|
};
|
|
}
|
|
if (specifier === "./wucaiMigration") {
|
|
return { url: migrationUrl.href, shortCircuit: true };
|
|
}
|
|
if (specifier === "@/jungleConfig") {
|
|
return { url: "data:text/javascript,export const unused = true", shortCircuit: true };
|
|
}
|
|
if (specifier === "ip2region") {
|
|
return {
|
|
url: "data:text/javascript,export default class Ip2region { search() { return null; } }",
|
|
shortCircuit: true,
|
|
};
|
|
}
|
|
return nextResolve(specifier, context);
|
|
},
|
|
});
|
|
|
|
const { default: login } = await import(functionUrl);
|
|
|
|
function reset(users = [], source = null) {
|
|
state.users = clone(users);
|
|
state.usersAd = [];
|
|
state.abConfigs = [];
|
|
state.orders = [];
|
|
state.idcount = [
|
|
{ _id: "69faba99b4d89b170da4bf56", count: 1 },
|
|
{ _id: "69fabaacb4d89b170da4bf57", count: 1 },
|
|
];
|
|
state.source = source;
|
|
state.sourceFails = false;
|
|
state.sourceCalls = 0;
|
|
state.failABUpdate = false;
|
|
}
|
|
|
|
function abConfig(layer, extra = {}) {
|
|
return {
|
|
experimentId: `exp_layer_${layer}_001`,
|
|
layer: String(layer),
|
|
name: `Layer ${layer}`,
|
|
enabled: true,
|
|
resetAssignments: false,
|
|
resetVersion: 0,
|
|
variants: [{ group: "A", ratio: 50 }, { group: "B", ratio: 50 }],
|
|
...extra,
|
|
};
|
|
}
|
|
|
|
function existingUser(extra = {}) {
|
|
return {
|
|
_id: "u1",
|
|
openid: "openid-1",
|
|
unionid: "union-1",
|
|
session_key: "old-session",
|
|
token: "old-token",
|
|
onlyId: 1,
|
|
levelAmount: 0,
|
|
coinAmount: 0,
|
|
healthAmount: 5,
|
|
healthtimestamp: 0,
|
|
freezeAmount: 3,
|
|
hammerAmount: 3,
|
|
magicAmount: 3,
|
|
userPowerTime: 0,
|
|
monthCardReward: 0,
|
|
monthCardTime: 0,
|
|
rebornGiftCount: 0,
|
|
rebornGiftTime: 0,
|
|
pay_user: false,
|
|
starter_pack: 0,
|
|
starter_packState: 0,
|
|
winStreak: 0,
|
|
passCheck: null,
|
|
endLevelNum: 0,
|
|
totalLevel: 0,
|
|
userLevel: 0,
|
|
film: 0,
|
|
careerAmount: 0,
|
|
headArr: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17],
|
|
catArr: [1, 2, 3],
|
|
...extra,
|
|
};
|
|
}
|
|
|
|
test("ordinary legacy login initializes wucai_type -1 without reading Wucai", async () => {
|
|
reset();
|
|
const result = await login({ body: { code: "code-1" }, headers: {}, socket: {} });
|
|
|
|
assert.equal(result.code, 1);
|
|
assert.equal(state.sourceCalls, 0);
|
|
assert.equal(state.users[0].wucai_type, -1);
|
|
assert.equal("isWuCai" in state.users[0], false);
|
|
});
|
|
|
|
test("new users receive all managed layers without affecting enabled assignments", async () => {
|
|
reset();
|
|
state.abConfigs = [
|
|
abConfig(1, { enabled: false }),
|
|
abConfig(2),
|
|
];
|
|
|
|
const result = await login({ body: { code: "code-1" }, headers: {}, socket: {} });
|
|
|
|
assert.equal(result.code, 1);
|
|
assert.deepEqual(Object.keys(result.data.abTests).sort(), ["layer_1", "layer_2", "layer_3"]);
|
|
assert.equal(result.data.abTests.layer_1.experimentId, "exp_layer_1_001");
|
|
assert.equal(result.data.abTests.layer_1.enabled, false);
|
|
assert.equal(result.data.abTests.layer_1.group, "Default");
|
|
assert.equal(result.data.abTests.layer_2.experimentId, "exp_layer_2_001");
|
|
assert.match(result.data.abTests.layer_2.group, /^[AB]$/);
|
|
assert.equal(result.data.abTests.layer_3.experimentId, null);
|
|
assert.equal(result.data.abTests.layer_3.name, null);
|
|
assert.equal(result.data.abTests.layer_3.enabled, false);
|
|
assert.equal(result.data.abTests.layer_3.group, "Default");
|
|
assert.equal(result.data.abTests.layer_3.appliedResetVersion, 0);
|
|
assert.deepEqual(state.users[0].abTests, result.data.abTests);
|
|
});
|
|
|
|
test("existing users keep groups per layer while disabled and missing layers become Default", async () => {
|
|
reset([existingUser({
|
|
wucai_type: -1,
|
|
abTests: {
|
|
layer_1: {
|
|
experimentId: "exp_layer_1_001",
|
|
layer: "1",
|
|
name: "Old Layer 1",
|
|
enabled: true,
|
|
group: "B",
|
|
assignedAt: 100,
|
|
appliedResetVersion: 7,
|
|
},
|
|
layer_2: {
|
|
experimentId: "exp_layer_2_001",
|
|
layer: "2",
|
|
name: "Old Layer 2",
|
|
enabled: true,
|
|
group: "A",
|
|
assignedAt: 200,
|
|
appliedResetVersion: 0,
|
|
},
|
|
layer_3: {
|
|
experimentId: "exp_layer_3_001",
|
|
layer: "3",
|
|
name: "Removed Layer",
|
|
enabled: true,
|
|
group: "C",
|
|
assignedAt: 250,
|
|
appliedResetVersion: 0,
|
|
},
|
|
layer_4: {
|
|
experimentId: "exp_layer_4_001",
|
|
layer: "4",
|
|
name: "Future Layer",
|
|
enabled: true,
|
|
group: "H",
|
|
assignedAt: 300,
|
|
appliedResetVersion: 0,
|
|
},
|
|
},
|
|
})]);
|
|
state.abConfigs = [
|
|
abConfig(1, { experimentId: "exp_layer_1_002", name: "New Layer 1" }),
|
|
abConfig(2, { enabled: false, resetAssignments: true, resetVersion: 101 }),
|
|
];
|
|
|
|
const result = await login({ body: { code: "code-1" }, headers: {}, socket: {} });
|
|
|
|
assert.equal(result.code, 1);
|
|
assert.equal(result.data.abTests.layer_1.group, "B");
|
|
assert.equal(result.data.abTests.layer_1.experimentId, "exp_layer_1_002");
|
|
assert.equal(result.data.abTests.layer_1.name, "New Layer 1");
|
|
assert.equal(result.data.abTests.layer_1.assignedAt, 100);
|
|
assert.equal(result.data.abTests.layer_1.appliedResetVersion, 7);
|
|
assert.equal(result.data.abTests.layer_2.group, "Default");
|
|
assert.equal(result.data.abTests.layer_2.enabled, false);
|
|
assert.notEqual(result.data.abTests.layer_2.assignedAt, 200);
|
|
assert.equal(result.data.abTests.layer_3.group, "Default");
|
|
assert.equal(result.data.abTests.layer_3.experimentId, null);
|
|
assert.notEqual(result.data.abTests.layer_3.assignedAt, 250);
|
|
assert.equal(result.data.abTests.layer_4.group, "H");
|
|
assert.equal(result.data.abTests.layer_4.assignedAt, 300);
|
|
assert.deepEqual(state.users[0].abTests, result.data.abTests);
|
|
});
|
|
|
|
test("an active reset version reassigns each existing user only once", async () => {
|
|
reset([existingUser({
|
|
wucai_type: -1,
|
|
abTests: {
|
|
layer_1: {
|
|
experimentId: "exp_layer_1_001",
|
|
layer: "1",
|
|
name: "Layer 1",
|
|
enabled: true,
|
|
group: "B",
|
|
assignedAt: 100,
|
|
appliedResetVersion: 0,
|
|
},
|
|
layer_2: {
|
|
experimentId: "exp_layer_2_001",
|
|
layer: "2",
|
|
name: "Layer 2",
|
|
enabled: true,
|
|
group: "B",
|
|
assignedAt: 200,
|
|
appliedResetVersion: 0,
|
|
},
|
|
},
|
|
})]);
|
|
state.abConfigs = [
|
|
abConfig(1, {
|
|
resetAssignments: true,
|
|
resetVersion: 101,
|
|
variants: [{ group: "A", ratio: 95 }, { group: "B", ratio: 5 }],
|
|
}),
|
|
abConfig(2),
|
|
];
|
|
|
|
const first = await login({ body: { code: "code-1" }, headers: {}, socket: {} });
|
|
const assignedAt = first.data.abTests.layer_1.assignedAt;
|
|
const second = await login({ body: { code: "code-1" }, headers: {}, socket: {} });
|
|
|
|
assert.equal(first.data.abTests.layer_1.group, "A");
|
|
assert.equal(first.data.abTests.layer_1.appliedResetVersion, 101);
|
|
assert.notEqual(assignedAt, 100);
|
|
assert.equal(second.data.abTests.layer_1.group, "A");
|
|
assert.equal(second.data.abTests.layer_1.assignedAt, assignedAt);
|
|
assert.equal(second.data.abTests.layer_1.appliedResetVersion, 101);
|
|
assert.equal(second.data.abTests.layer_2.group, "B");
|
|
assert.equal(second.data.abTests.layer_2.assignedAt, 200);
|
|
});
|
|
|
|
test("users who miss a reset window keep their old group after the switch closes", async () => {
|
|
reset([existingUser({
|
|
wucai_type: -1,
|
|
abTests: {
|
|
layer_1: {
|
|
experimentId: "exp_layer_1_001",
|
|
layer: "1",
|
|
name: "Layer 1",
|
|
enabled: true,
|
|
group: "B",
|
|
assignedAt: 100,
|
|
appliedResetVersion: 0,
|
|
},
|
|
},
|
|
})]);
|
|
state.abConfigs = [abConfig(1, {
|
|
resetAssignments: false,
|
|
resetVersion: 101,
|
|
variants: [{ group: "A", ratio: 95 }, { group: "B", ratio: 5 }],
|
|
})];
|
|
|
|
const result = await login({ body: { code: "code-1" }, headers: {}, socket: {} });
|
|
|
|
assert.equal(result.data.abTests.layer_1.group, "B");
|
|
assert.equal(result.data.abTests.layer_1.assignedAt, 100);
|
|
assert.equal(result.data.abTests.layer_1.appliedResetVersion, 0);
|
|
});
|
|
|
|
test("Default remains sticky until an active reset version is available", async () => {
|
|
reset([existingUser({
|
|
wucai_type: -1,
|
|
abTests: {
|
|
layer_1: {
|
|
experimentId: "exp_layer_1_001",
|
|
layer: "1",
|
|
name: "Layer 1",
|
|
enabled: true,
|
|
group: "DEFAULT",
|
|
assignedAt: 100,
|
|
appliedResetVersion: 0,
|
|
},
|
|
},
|
|
})]);
|
|
state.abConfigs = [abConfig(1, {
|
|
resetAssignments: false,
|
|
resetVersion: 101,
|
|
variants: [{ group: "A", ratio: 95 }, { group: "B", ratio: 5 }],
|
|
})];
|
|
|
|
const beforeReset = await login({ body: { code: "code-1" }, headers: {}, socket: {} });
|
|
state.abConfigs[0].resetAssignments = true;
|
|
const afterReset = await login({ body: { code: "code-1" }, headers: {}, socket: {} });
|
|
|
|
assert.equal(beforeReset.data.abTests.layer_1.group, "Default");
|
|
assert.equal(beforeReset.data.abTests.layer_1.assignedAt, 100);
|
|
assert.equal(afterReset.data.abTests.layer_1.group, "A");
|
|
assert.equal(afterReset.data.abTests.layer_1.appliedResetVersion, 101);
|
|
assert.notEqual(afterReset.data.abTests.layer_1.assignedAt, 100);
|
|
});
|
|
|
|
test("broken AB data is repaired without blocking login when persistence fails", async () => {
|
|
reset([existingUser({ wucai_type: -1, abTests: "not-json" })]);
|
|
state.failABUpdate = true;
|
|
|
|
const result = await login({ body: { code: "code-1" }, headers: {}, socket: {} });
|
|
|
|
assert.equal(result.code, 1);
|
|
assert.deepEqual(Object.keys(result.data.abTests).sort(), ["layer_1", "layer_2", "layer_3"]);
|
|
assert.equal(result.data.abTests.layer_1.group, "Default");
|
|
assert.equal(state.users[0].abTests, "not-json");
|
|
});
|
|
|
|
test("ordinary usersAd login does not create migration fields", async () => {
|
|
reset();
|
|
const result = await login({
|
|
body: { code: "code-1", gameName: "iaa" },
|
|
headers: {},
|
|
socket: {},
|
|
});
|
|
|
|
assert.equal(result.code, 1);
|
|
assert.equal(state.usersAd.length, 1);
|
|
assert.equal("wucai_type" in state.usersAd[0], false);
|
|
assert.equal("abTests" in state.usersAd[0], false);
|
|
assert.equal("abTests" in result.data, false);
|
|
assert.equal(state.sourceCalls, 0);
|
|
});
|
|
|
|
test("new Wucai account migrates source data and returns type 0", async () => {
|
|
reset([], {
|
|
levelAmount: 0,
|
|
coinAmount: 100,
|
|
freezeAmount: 0,
|
|
hammerAmount: 1,
|
|
magicAmount: 2,
|
|
pay_user: true,
|
|
});
|
|
const result = await login({
|
|
body: { code: "code-1", from: "wucai", wucai_capability: 1 },
|
|
headers: {},
|
|
socket: {},
|
|
});
|
|
|
|
assert.equal(result.code, 1);
|
|
assert.equal(result.data.isFirst, true);
|
|
assert.equal(state.sourceCalls, 1);
|
|
assert.equal(state.users[0].wucai_type, 0);
|
|
assert.equal(state.users[0].coinAmount, 100);
|
|
assert.equal(state.users[0].freezeAmount, 0);
|
|
assert.equal(state.users[0].pay_user, true);
|
|
assert.equal(state.users[0].forcedUpdate, true);
|
|
assert.equal(result.data.wucai_type, 0);
|
|
});
|
|
|
|
test("an existing pristine level-zero account also auto-migrates", async () => {
|
|
reset([existingUser({ wucai_type: -1 })], {
|
|
levelAmount: 6,
|
|
coinAmount: 123,
|
|
freezeAmount: 4,
|
|
});
|
|
const result = await login({
|
|
body: { code: "code-1", from: "wucai", wucai_capability: 1 },
|
|
headers: {},
|
|
socket: {},
|
|
});
|
|
|
|
assert.equal(result.code, 1);
|
|
assert.equal(state.users[0].wucai_type, 0);
|
|
assert.equal(state.users[0].levelAmount, 6);
|
|
assert.equal(state.users[0].coinAmount, 123);
|
|
assert.equal(state.users[0].forcedUpdate, true);
|
|
});
|
|
|
|
test("meaningful target enters type 1 without being overwritten", async () => {
|
|
reset([existingUser({ unionid: undefined, coinAmount: 9, wucai_type: -1 })], {
|
|
levelAmount: 8,
|
|
coinAmount: 500,
|
|
freezeAmount: 6,
|
|
});
|
|
const result = await login({
|
|
body: { code: "code-1", from: "wucai", wucai_capability: 1 },
|
|
headers: {},
|
|
socket: {},
|
|
});
|
|
|
|
assert.equal(result.code, 1);
|
|
assert.equal(state.users[0].wucai_type, 1);
|
|
assert.equal(state.users[0].coinAmount, 9);
|
|
assert.equal(state.users[0].unionid, "union-1");
|
|
assert.equal(result.data.wucai_preview.coinAmount, 500);
|
|
assert.equal("token" in result.data.wucai_preview, false);
|
|
});
|
|
|
|
test("type 1 ordinary login refreshes the Wucai preview", async () => {
|
|
reset([existingUser({ coinAmount: 9, wucai_type: 1 })], {
|
|
levelAmount: 10,
|
|
coinAmount: 777,
|
|
});
|
|
const result = await login({
|
|
body: { code: "code-1", wucai_capability: 1 },
|
|
headers: {},
|
|
socket: {},
|
|
});
|
|
|
|
assert.equal(result.code, 1);
|
|
assert.equal(state.sourceCalls, 1);
|
|
assert.equal(result.data.wucai_type, 1);
|
|
assert.equal(result.data.wucai_preview.coinAmount, 777);
|
|
});
|
|
|
|
test("type 0 ordinary login keeps the popup state without reading Wucai", async () => {
|
|
reset([existingUser({ wucai_type: 0, forcedUpdate: false })], { coinAmount: 999 });
|
|
const result = await login({
|
|
body: { code: "code-1", wucai_capability: 1 },
|
|
headers: {},
|
|
socket: {},
|
|
});
|
|
|
|
assert.equal(result.code, 1);
|
|
assert.equal(result.data.wucai_type, 0);
|
|
assert.equal(state.sourceCalls, 0);
|
|
});
|
|
|
|
test("type 1 source failure does not reset or overwrite target progress", async () => {
|
|
reset([existingUser({ wucai_type: 1, coinAmount: 42 })]);
|
|
state.sourceFails = true;
|
|
const result = await login({
|
|
body: { code: "code-1", wucai_capability: 1 },
|
|
headers: {},
|
|
socket: {},
|
|
});
|
|
|
|
assert.equal(result.code, 0);
|
|
assert.equal(result.errorCode, "WUCAI_SOURCE_UNAVAILABLE");
|
|
assert.equal(state.users[0].wucai_type, 1);
|
|
assert.equal(state.users[0].coinAmount, 42);
|
|
});
|
|
|
|
test("old clients cannot bypass pending states", async () => {
|
|
reset([existingUser({ wucai_type: 1, coinAmount: 42 })], { levelAmount: 2 });
|
|
const result = await login({
|
|
body: { code: "code-1" },
|
|
headers: {},
|
|
socket: {},
|
|
});
|
|
|
|
assert.equal(result.code, 0);
|
|
assert.equal(result.errorCode, "WUCAI_CLIENT_UPGRADE_REQUIRED");
|
|
assert.equal(state.sourceCalls, 0);
|
|
assert.equal(state.users[0].wucai_type, 1);
|
|
});
|
|
|
|
test("terminal states ignore later Wucai entry", async () => {
|
|
reset([existingUser({ wucai_type: 2 })], { coinAmount: 999 });
|
|
const result = await login({
|
|
body: { code: "code-1", from: "wucai", wucai_capability: 1 },
|
|
headers: {},
|
|
socket: {},
|
|
});
|
|
|
|
assert.equal(result.code, 1);
|
|
assert.equal(result.data.wucai_type, 2);
|
|
assert.equal(state.sourceCalls, 0);
|
|
});
|
|
|
|
test("source failure creates or updates nothing", async () => {
|
|
reset();
|
|
state.sourceFails = true;
|
|
const result = await login({
|
|
body: { code: "code-1", from: "wucai", wucai_capability: 1 },
|
|
headers: {},
|
|
socket: {},
|
|
});
|
|
|
|
assert.equal(result.code, 0);
|
|
assert.equal(result.errorCode, "WUCAI_SOURCE_UNAVAILABLE");
|
|
assert.equal(state.users.length, 0);
|
|
assert.equal(state.idcount[0].count, 1);
|
|
});
|
|
|
|
test("new Wucai target ignores orphan orders and auto-migrates", async () => {
|
|
reset([], { levelAmount: 1 });
|
|
state.orders.push({ openid: "openid-1", state: 1 });
|
|
const result = await login({
|
|
body: { code: "code-1", from: "wucai", wucai_capability: 1 },
|
|
headers: {},
|
|
socket: {},
|
|
});
|
|
|
|
assert.equal(result.code, 1);
|
|
assert.equal(result.data.wucai_type, 0);
|
|
assert.equal(state.users.length, 1);
|
|
assert.equal(state.users[0].levelAmount, 1);
|
|
assert.equal(state.sourceCalls, 1);
|
|
});
|
|
|
|
test("an existing target with an order is still not auto-overwritten", async () => {
|
|
reset([existingUser({ wucai_type: -1 })], { levelAmount: 8, coinAmount: 500 });
|
|
state.orders.push({ openid: "openid-1", state: 1 });
|
|
const result = await login({
|
|
body: { code: "code-1", from: "wucai", wucai_capability: 1 },
|
|
headers: {},
|
|
socket: {},
|
|
});
|
|
|
|
assert.equal(result.code, 1);
|
|
assert.equal(result.data.wucai_type, 1);
|
|
assert.equal(state.users[0].levelAmount, 0);
|
|
assert.equal(state.users[0].coinAmount, 0);
|
|
assert.equal(state.sourceCalls, 1);
|
|
});
|
|
|
|
test("deprecated isWuCai does not affect migration state", async () => {
|
|
reset([existingUser({ isWuCai: true })]);
|
|
const result = await login({
|
|
body: { code: "code-1" },
|
|
headers: {},
|
|
socket: {},
|
|
});
|
|
|
|
assert.equal(result.code, 1);
|
|
assert.equal(state.sourceCalls, 0);
|
|
assert.equal(state.users[0].wucai_type, -1);
|
|
assert.equal("forcedUpdate" in state.users[0], false);
|
|
assert.equal("isWuCai" in result.data, false);
|
|
});
|
|
|
|
test("deprecated isWuCai cannot bypass the progress choice", async () => {
|
|
reset([existingUser({ isWuCai: true, coinAmount: 9 })], {
|
|
levelAmount: 8,
|
|
coinAmount: 500,
|
|
});
|
|
const result = await login({
|
|
body: { code: "code-1", from: "wucai", wucai_capability: 1 },
|
|
headers: {},
|
|
socket: {},
|
|
});
|
|
|
|
assert.equal(result.code, 1);
|
|
assert.equal(state.sourceCalls, 1);
|
|
assert.equal(state.users[0].wucai_type, 1);
|
|
assert.equal(state.users[0].coinAmount, 9);
|
|
});
|
|
|
|
test("paid level-zero target must choose progress", async () => {
|
|
reset([existingUser({ wucai_type: -1, pay_user: true })], {
|
|
levelAmount: 8,
|
|
coinAmount: 500,
|
|
});
|
|
const result = await login({
|
|
body: { code: "code-1", from: "wucai", wucai_capability: 1 },
|
|
headers: {},
|
|
socket: {},
|
|
});
|
|
|
|
assert.equal(result.code, 1);
|
|
assert.equal(state.sourceCalls, 1);
|
|
assert.equal(state.users[0].wucai_type, 1);
|
|
assert.equal(state.users[0].pay_user, true);
|
|
});
|