@managesome/eposmatic-toolkit 0.2.720 → 0.2.732
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/lib/helpers/types/order-engine.d.ts +40 -12
- package/lib/helpers/utils/cart-helpers.d.ts +2 -0
- package/lib/helpers/utils/halfhalf-setup-helpers.js +75 -52
- package/lib/helpers/utils/order-engine.d.ts +80 -79
- package/lib/helpers/utils/order-engine.js +351 -249
- package/lib/tests/choose-expensive-edge-cases.test.d.ts +1 -0
- package/lib/tests/choose-expensive-edge-cases.test.js +966 -0
- package/lib/tests/choose-expensive-flow-verification.test.d.ts +1 -0
- package/lib/tests/choose-expensive-flow-verification.test.js +702 -0
- package/lib/tests/halfhalf-selection-rules.test.d.ts +1 -0
- package/lib/tests/halfhalf-selection-rules.test.js +200 -0
- package/lib/tests/nested-halfhalf-segment-price.test.js +0 -227
- package/lib/tests/segment-price-floor.test.d.ts +1 -0
- package/lib/tests/segment-price-floor.test.js +143 -0
- package/lib/tests/specials-halfhalf-pricing.test.js +143 -585
- package/package.json +1 -1
|
@@ -275,7 +275,7 @@ describe('Half/Half alone — convertHalfHalfToItem pricing', () => {
|
|
|
275
275
|
orderItemType: constants_1.ORDER_ITEM_TYPE_ENUM.HALF_HALF,
|
|
276
276
|
defaultMenuId: null,
|
|
277
277
|
soldoutModifiers: [],
|
|
278
|
-
});
|
|
278
|
+
}).workingData;
|
|
279
279
|
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-1_torent', true, false);
|
|
280
280
|
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-2_torent', true, false);
|
|
281
281
|
const result = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(engine);
|
|
@@ -844,13 +844,11 @@ describe('choose_expensive_segment_price end-to-end (specials with half-half)',
|
|
|
844
844
|
{ item_id: 'torent', sort_id: 2, upsell_price: { BASE_PRICE: 200 } },
|
|
845
845
|
{ item_id: 'halfhalf-1', sort_id: 3, upsell_price: { BASE_PRICE: 100 } },
|
|
846
846
|
];
|
|
847
|
-
function
|
|
848
|
-
|
|
847
|
+
function buildState() {
|
|
848
|
+
const item = (0, specials_helpers_1.convertSpecialToItem)(modifySpecialItems(makeSpecial(), specialItems), {
|
|
849
849
|
milan: makeItem('milan', { modifiers: makePizzaSizeAndExtra() }),
|
|
850
850
|
torent: makeItem('torent', { price: { BASE_PRICE: 1200 } }),
|
|
851
851
|
}, { 'halfhalf-1': makeHalfHalfSetup() });
|
|
852
|
-
}
|
|
853
|
-
function buildEngine(item = buildSpecialItem()) {
|
|
854
852
|
return (0, order_engine_1.convertCatalogItemToOrderEngineItem)({
|
|
855
853
|
item,
|
|
856
854
|
orderItem: undefined,
|
|
@@ -861,58 +859,50 @@ describe('choose_expensive_segment_price end-to-end (specials with half-half)',
|
|
|
861
859
|
soldoutModifiers: [],
|
|
862
860
|
});
|
|
863
861
|
}
|
|
864
|
-
|
|
865
|
-
|
|
866
|
-
* top-level item options reuse their `_id`s at different prices (full upsell
|
|
867
|
-
* vs per-segment share), so the unscoped map is walk-order dependent.
|
|
868
|
-
*/
|
|
869
|
-
function nestedBasePrices(item = buildSpecialItem()) {
|
|
870
|
-
return (0, order_engine_1.getOptionPriceMapFromItem)(item, PLATFORM, { nestedHalfHalfSegmentsOnly: true });
|
|
871
|
-
}
|
|
872
|
-
/** Real UI flow: pick one option per segment of the nested half-half. */
|
|
873
|
-
function selectNested(engine, picks) {
|
|
874
|
-
let next = engine;
|
|
875
|
-
next = (0, order_engine_1.setCheckFieldInOrderEngineItem)(next, `mod-pizza_halfhalf-1_seg-1_${picks[0]}`, true);
|
|
876
|
-
next = (0, order_engine_1.setCheckFieldInOrderEngineItem)(next, `mod-pizza_halfhalf-1_seg-2_${picks[1]}`, true);
|
|
877
|
-
return next;
|
|
878
|
-
}
|
|
879
|
-
function nestedHalfHalf(engine) {
|
|
880
|
-
return engine.modifiers[0].options.find((o) => o._id === 'halfhalf-1');
|
|
881
|
-
}
|
|
882
|
-
function nestedPrice(engine, segmentIndex, optionId) {
|
|
883
|
-
return nestedHalfHalf(engine).modifiers[segmentIndex].options.find((o) => o._id === optionId).price;
|
|
884
|
-
}
|
|
885
|
-
function topLevelPrice(engine, optionId) {
|
|
886
|
-
return engine.modifiers[0].options.find((o) => o._id === optionId).price;
|
|
862
|
+
function buildEngine() {
|
|
863
|
+
return buildState().workingData;
|
|
887
864
|
}
|
|
888
865
|
function segmentOptions(engine, halfHalfId = 'halfhalf-1') {
|
|
889
866
|
const hh = engine.modifiers[0].options.find((o) => o._id === halfHalfId);
|
|
890
867
|
return hh.modifiers.map((seg) => seg.options.map((o) => ({ id: o._id, price: o.price, default: o.default })));
|
|
891
868
|
}
|
|
892
|
-
it('basic + premium selection
|
|
893
|
-
|
|
894
|
-
|
|
895
|
-
|
|
896
|
-
|
|
897
|
-
//
|
|
898
|
-
|
|
869
|
+
it('basic + premium selection levels the cheap half to the premium one (special-derived prices)', () => {
|
|
870
|
+
const state = buildState();
|
|
871
|
+
const normalize = (engine) => (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(engine, {
|
|
872
|
+
originalPriceReferences: state.originalPriceReferences,
|
|
873
|
+
});
|
|
874
|
+
// Real UI flow: the selection goes through the special's engine item (the
|
|
875
|
+
// identifier is the FULL path: group -> half-half option -> segment ->
|
|
876
|
+
// option) and the drawer normalizes right after it.
|
|
877
|
+
let engine = normalize((0, order_engine_1.setCheckFieldInOrderEngineItem)(state.workingData, 'mod-pizza_halfhalf-1_seg-1_milan', true, false));
|
|
878
|
+
// Only the cheap half is picked so far — it IS the most expensive selected
|
|
879
|
+
// half, so nothing is levelled yet.
|
|
899
880
|
expect(segmentOptions(engine)[0].find((o) => o.id === 'milan').price).toBe(0);
|
|
900
|
-
|
|
901
|
-
|
|
902
|
-
//
|
|
903
|
-
|
|
881
|
+
// Picking the premium half (100) makes it drive the rule: every cheaper
|
|
882
|
+
// option — selected or not — is levelled to it, so the drawer can show
|
|
883
|
+
// what picking it would cost. NO 575 from Pizza Size anywhere.
|
|
884
|
+
engine = normalize((0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_halfhalf-1_seg-2_torent', true, false));
|
|
885
|
+
const after = segmentOptions(engine);
|
|
904
886
|
expect(after[0].find((o) => o.id === 'milan').price).toBe(100);
|
|
905
887
|
expect(after[1].find((o) => o.id === 'torent').price).toBe(100);
|
|
906
|
-
|
|
907
|
-
|
|
888
|
+
// SEG-1's alternatives SWITCH to the other segment's level (SEG-2 still
|
|
889
|
+
// holds the premium pick), so they show the same 100.
|
|
890
|
+
expect(after[0].find((o) => o.id === 'torent').price).toBe(100);
|
|
891
|
+
// SEG-2's alternatives REPLACE its own premium pick when chosen (cheap
|
|
892
|
+
// pair = no level), so MILAN stays at its own price there.
|
|
893
|
+
expect(after[1].find((o) => o.id === 'milan').price).toBe(0);
|
|
908
894
|
});
|
|
909
895
|
it('is idempotent (re-applying never lowers or changes prices)', () => {
|
|
910
|
-
|
|
911
|
-
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(
|
|
912
|
-
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_halfhalf-1_seg-2_torent', true);
|
|
913
|
-
const once =
|
|
914
|
-
|
|
915
|
-
|
|
896
|
+
const state = buildState();
|
|
897
|
+
let engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(state.workingData, 'mod-pizza_halfhalf-1_seg-1_milan', true, false);
|
|
898
|
+
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_halfhalf-1_seg-2_torent', true, false);
|
|
899
|
+
const once = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(engine, {
|
|
900
|
+
originalPriceReferences: state.originalPriceReferences,
|
|
901
|
+
});
|
|
902
|
+
const twice = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(once, {
|
|
903
|
+
originalPriceReferences: state.originalPriceReferences,
|
|
904
|
+
});
|
|
905
|
+
expect(segmentOptions(twice)).toEqual(segmentOptions(once));
|
|
916
906
|
});
|
|
917
907
|
it('does nothing when the half-half flag is off', () => {
|
|
918
908
|
const item = (0, specials_helpers_1.convertSpecialToItem)(modifySpecialItems(makeSpecial(), specialItems), { milan: makeItem('milan'), torent: makeItem('torent') }, { 'halfhalf-1': makeHalfHalfSetup({ choose_expensive_segment_price: false }) });
|
|
@@ -924,7 +914,7 @@ describe('choose_expensive_segment_price end-to-end (specials with half-half)',
|
|
|
924
914
|
orderItemType: constants_1.ORDER_ITEM_TYPE_ENUM.SPECIAL,
|
|
925
915
|
defaultMenuId: null,
|
|
926
916
|
soldoutModifiers: [],
|
|
927
|
-
});
|
|
917
|
+
}).workingData;
|
|
928
918
|
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_halfhalf-1_seg-1_milan', true, false);
|
|
929
919
|
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_halfhalf-1_seg-2_torent', true, false);
|
|
930
920
|
const after = segmentOptions(engine);
|
|
@@ -944,7 +934,7 @@ describe('choose_expensive_segment_price end-to-end (specials with half-half)',
|
|
|
944
934
|
orderItemType: constants_1.ORDER_ITEM_TYPE_ENUM.HALF_HALF,
|
|
945
935
|
defaultMenuId: null,
|
|
946
936
|
soldoutModifiers: [],
|
|
947
|
-
});
|
|
937
|
+
}).workingData;
|
|
948
938
|
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-1_milan', true, false);
|
|
949
939
|
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-2_torent', true, false);
|
|
950
940
|
const result = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(engine);
|
|
@@ -964,7 +954,7 @@ describe('choose_expensive_segment_price end-to-end (specials with half-half)',
|
|
|
964
954
|
'hh-flag': makeHalfHalfSetup({ _id: 'hh-flag' }),
|
|
965
955
|
'hh-no-flag': makeHalfHalfSetup({ _id: 'hh-no-flag', choose_expensive_segment_price: false }),
|
|
966
956
|
});
|
|
967
|
-
|
|
957
|
+
const state = (0, order_engine_1.convertCatalogItemToOrderEngineItem)({
|
|
968
958
|
item,
|
|
969
959
|
orderItem: undefined,
|
|
970
960
|
platform: PLATFORM,
|
|
@@ -973,179 +963,54 @@ describe('choose_expensive_segment_price end-to-end (specials with half-half)',
|
|
|
973
963
|
defaultMenuId: null,
|
|
974
964
|
soldoutModifiers: [],
|
|
975
965
|
});
|
|
976
|
-
engine =
|
|
977
|
-
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_hh-flag_seg-
|
|
978
|
-
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_hh-
|
|
979
|
-
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_hh-no-flag_seg-
|
|
980
|
-
|
|
981
|
-
|
|
982
|
-
|
|
983
|
-
|
|
966
|
+
let engine = state.workingData;
|
|
967
|
+
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_hh-flag_seg-1_milan', true, false);
|
|
968
|
+
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_hh-flag_seg-2_torent', true, false);
|
|
969
|
+
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_hh-no-flag_seg-1_milan', true, false);
|
|
970
|
+
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_hh-no-flag_seg-2_torent', true, false);
|
|
971
|
+
engine = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(engine, {
|
|
972
|
+
originalPriceReferences: state.originalPriceReferences,
|
|
973
|
+
});
|
|
974
|
+
const hhFlag = engine.modifiers[0].options.find((o) => o._id === 'hh-flag');
|
|
975
|
+
const hhNoFlag = engine.modifiers[0].options.find((o) => o._id === 'hh-no-flag');
|
|
976
|
+
// Flagged: the cheap half is levelled to the selected expensive half;
|
|
984
977
|
// un-flagged: stays free.
|
|
985
978
|
expect(hhFlag.modifiers[0].options.find((o) => o._id === 'milan').price).toBe(100);
|
|
986
979
|
expect(hhNoFlag.modifiers[0].options.find((o) => o._id === 'milan').price).toBe(0);
|
|
987
980
|
});
|
|
988
|
-
it('
|
|
989
|
-
|
|
990
|
-
|
|
991
|
-
|
|
992
|
-
|
|
993
|
-
|
|
994
|
-
|
|
995
|
-
];
|
|
996
|
-
const specialItem = buildSpecialItem(halfHalfFirst);
|
|
997
|
-
const scoped = nestedBasePrices(specialItem);
|
|
998
|
-
// Segment scope only: the half-half hub and top-level items are absent.
|
|
999
|
-
expect(scoped.torent).toBe(100);
|
|
1000
|
-
expect(scoped.milan).toBe(0);
|
|
1001
|
-
expect(scoped['halfhalf-1']).toBeUndefined();
|
|
1002
|
-
// Unscoped, the LAST walker wins — here the top-level torent (200), which
|
|
1003
|
-
// is exactly why the drawer scopes the map for specials.
|
|
1004
|
-
expect((0, order_engine_1.getOptionPriceMapFromItem)(specialItem, PLATFORM).torent).toBe(200);
|
|
1005
|
-
// With the scoped map the pipeline stays correct: the drawn half is raised
|
|
1006
|
-
// to the segment share (100) and top-level prices are never touched.
|
|
1007
|
-
const engine = (0, order_engine_1.resetOrderEngineItemPrices)(buildEngine(specialItem), scoped, {
|
|
1008
|
-
nestedHalfHalfOnly: true,
|
|
1009
|
-
});
|
|
1010
|
-
expect(topLevelPrice(engine, 'torent')).toBe(200);
|
|
1011
|
-
const result = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(selectNested(engine, ['milan', 'torent']), {
|
|
1012
|
-
basePrices: scoped,
|
|
1013
|
-
});
|
|
1014
|
-
expect(nestedPrice(result, 0, 'milan')).toBe(100);
|
|
1015
|
-
expect(nestedPrice(result, 1, 'torent')).toBe(100);
|
|
1016
|
-
expect(topLevelPrice(result, 'torent')).toBe(200);
|
|
1017
|
-
// Default order (half-half LAST): the scoped map is IDENTICAL, while the
|
|
1018
|
-
// unscoped one flips to the segment share — order must not matter.
|
|
1019
|
-
const defaultItem = buildSpecialItem();
|
|
1020
|
-
expect(nestedBasePrices(defaultItem).torent).toBe(100);
|
|
1021
|
-
expect((0, order_engine_1.getOptionPriceMapFromItem)(defaultItem, PLATFORM).torent).toBe(100);
|
|
1022
|
-
});
|
|
1023
|
-
it('user flow: after milan+torent, changing the second half back to milan re-bases the raised half', () => {
|
|
1024
|
-
const basePrices = nestedBasePrices();
|
|
1025
|
-
const engine = selectNested(buildEngine(), ['milan', 'torent']);
|
|
1026
|
-
// Premium pair: milan (0) is raised to torent's segment share (100).
|
|
1027
|
-
const displayed = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(engine, { basePrices });
|
|
1028
|
-
expect(nestedPrice(displayed, 0, 'milan')).toBe(100);
|
|
1029
|
-
expect(nestedPrice(displayed, 1, 'torent')).toBe(100);
|
|
1030
|
-
// The user switches the SECOND half to milan (cheap pair). From the
|
|
1031
|
-
// pristine drawer state AND from the raised display: the artificially
|
|
1032
|
-
// upgraded milan goes back to its own price.
|
|
1033
|
-
for (const source of [engine, displayed]) {
|
|
1034
|
-
const switched = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(selectNested(source, ['milan', 'milan']), {
|
|
1035
|
-
basePrices,
|
|
1036
|
-
});
|
|
1037
|
-
expect(nestedPrice(switched, 0, 'milan')).toBe(0);
|
|
1038
|
-
expect(nestedPrice(switched, 1, 'milan')).toBe(0);
|
|
1039
|
-
// De-selected torent keeps its own segment share everywhere.
|
|
1040
|
-
expect(nestedPrice(switched, 0, 'torent')).toBe(100);
|
|
1041
|
-
expect(nestedPrice(switched, 1, 'torent')).toBe(100);
|
|
1042
|
-
expect(topLevelPrice(switched, 'torent')).toBe(200);
|
|
1043
|
-
}
|
|
1044
|
-
// Switching back to the premium pair raises again.
|
|
1045
|
-
const premiumAgain = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(selectNested(selectNested(displayed, ['milan', 'milan']), ['torent', 'torent']), { basePrices });
|
|
1046
|
-
expect(nestedPrice(premiumAgain, 0, 'torent')).toBe(100);
|
|
1047
|
-
expect(nestedPrice(premiumAgain, 1, 'torent')).toBe(100);
|
|
1048
|
-
});
|
|
1049
|
-
it('full change matrix (nested): every switch recomputes from the scoped pristine prices', () => {
|
|
1050
|
-
const basePrices = nestedBasePrices();
|
|
1051
|
-
const baseValues = { milan: 0, torent: 100 };
|
|
1052
|
-
const combos = [
|
|
1053
|
-
['milan', 'milan'],
|
|
1054
|
-
['milan', 'torent'],
|
|
1055
|
-
['torent', 'milan'],
|
|
1056
|
-
['torent', 'torent'],
|
|
1057
|
-
];
|
|
1058
|
-
const engine = buildEngine();
|
|
1059
|
-
for (const from of combos) {
|
|
1060
|
-
const fromDisplay = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(selectNested(engine, from), { basePrices });
|
|
1061
|
-
for (const to of combos) {
|
|
1062
|
-
const expected = Math.max(baseValues[to[0]], baseValues[to[1]]);
|
|
1063
|
-
for (const source of [engine, fromDisplay]) {
|
|
1064
|
-
const result = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(selectNested(source, to), { basePrices });
|
|
1065
|
-
expect(nestedPrice(result, 0, to[0])).toBe(expected);
|
|
1066
|
-
expect(nestedPrice(result, 1, to[1])).toBe(expected);
|
|
1067
|
-
expect(topLevelPrice(result, 'torent')).toBe(200);
|
|
1068
|
-
}
|
|
1069
|
-
}
|
|
1070
|
-
}
|
|
1071
|
-
});
|
|
1072
|
-
it('is idempotent with basePrices (re-applying never lowers or changes prices)', () => {
|
|
1073
|
-
const basePrices = nestedBasePrices();
|
|
1074
|
-
const once = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(selectNested(buildEngine(), ['milan', 'torent']), {
|
|
1075
|
-
basePrices,
|
|
1076
|
-
});
|
|
1077
|
-
const twice = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(once, { basePrices });
|
|
1078
|
-
expect(twice).toEqual(once);
|
|
1079
|
-
});
|
|
1080
|
-
it('engine memory: nested raises are reversible in place, top-level prices untouched', () => {
|
|
1081
|
-
// No external maps at all — the engine re-bases from its own stamps.
|
|
1082
|
-
let engine = selectNested(buildEngine(), ['milan', 'torent']);
|
|
1083
|
-
engine = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(engine);
|
|
1084
|
-
expect(nestedPrice(engine, 0, 'milan')).toBe(100);
|
|
1085
|
-
expect(nestedPrice(engine, 1, 'torent')).toBe(100);
|
|
1086
|
-
// Stamps are per tree position: the nested segment share (100/0) never
|
|
1087
|
-
// collides with the special's own top-level option price (200).
|
|
1088
|
-
expect(nestedHalfHalf(engine).modifiers[0].options.find((o) => o._id === 'torent').base_price).toBe(100);
|
|
1089
|
-
expect(engine.modifiers[0].options.find((o) => o._id === 'torent').base_price).toBe(200);
|
|
1090
|
-
// The user changes the second half to milan on the RAISED engine.
|
|
1091
|
-
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_halfhalf-1_seg-2_milan', true);
|
|
1092
|
-
engine = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(engine);
|
|
1093
|
-
// Artificially upgraded milan is back to its own price; de-selected torent
|
|
1094
|
-
// keeps its own; the top-level option is never touched.
|
|
1095
|
-
expect(nestedPrice(engine, 0, 'milan')).toBe(0);
|
|
1096
|
-
expect(nestedPrice(engine, 1, 'milan')).toBe(0);
|
|
1097
|
-
expect(nestedPrice(engine, 0, 'torent')).toBe(100);
|
|
1098
|
-
expect(topLevelPrice(engine, 'torent')).toBe(200);
|
|
1099
|
-
});
|
|
1100
|
-
it('edit flow: a persisted nested raise is re-based before the next change', () => {
|
|
1101
|
-
const specialItem = buildSpecialItem();
|
|
1102
|
-
const basePrices = nestedBasePrices(specialItem);
|
|
1103
|
-
// Submit the premium pair: the order item carries the raised segment price.
|
|
1104
|
-
const submitted = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(selectNested(buildEngine(specialItem), ['milan', 'torent']), { basePrices });
|
|
1105
|
-
const orderItem = (0, order_engine_1.convertOrderEngineItemToOrderItem)(submitted, TENANT_ID);
|
|
1106
|
-
const persistedHalfHalf = (orderItem.modifiers ?? [])
|
|
1107
|
-
.find((m) => m._id === 'mod-pizza')
|
|
1108
|
-
.options.find((o) => o._id === 'halfhalf-1');
|
|
1109
|
-
expect(persistedHalfHalf.modifiers[0].options.find((o) => o._id === 'milan').price).toBe(100);
|
|
1110
|
-
// Reopening the drawer for edit reads those raised prices back...
|
|
1111
|
-
const reopened = (0, order_engine_1.convertCatalogItemToOrderEngineItem)({
|
|
1112
|
-
item: specialItem,
|
|
1113
|
-
orderItem,
|
|
1114
|
-
platform: PLATFORM,
|
|
1115
|
-
tenantId: TENANT_ID,
|
|
1116
|
-
orderItemType: constants_1.ORDER_ITEM_TYPE_ENUM.SPECIAL,
|
|
1117
|
-
defaultMenuId: null,
|
|
1118
|
-
soldoutModifiers: [],
|
|
981
|
+
it('references make the nested rule reversible in place (special flow)', () => {
|
|
982
|
+
const state = buildState();
|
|
983
|
+
let engine = state.workingData;
|
|
984
|
+
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_halfhalf-1_seg-1_milan', true, false);
|
|
985
|
+
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_halfhalf-1_seg-2_torent', true, false);
|
|
986
|
+
const premium = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(engine, {
|
|
987
|
+
originalPriceReferences: state.originalPriceReferences,
|
|
1119
988
|
});
|
|
1120
|
-
expect(
|
|
1121
|
-
//
|
|
1122
|
-
//
|
|
1123
|
-
const
|
|
1124
|
-
|
|
1125
|
-
|
|
1126
|
-
// Submitting without changes keeps the premium charging...
|
|
1127
|
-
expect(nestedPrice((0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(rebased, { basePrices }), 0, 'milan')).toBe(100);
|
|
1128
|
-
// ...while switching the second half lowers to the definition prices.
|
|
1129
|
-
const cheap = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(selectNested(rebased, ['milan', 'milan']), {
|
|
1130
|
-
basePrices,
|
|
989
|
+
expect(segmentOptions(premium)[0].find((o) => o.id === 'milan').price).toBe(100);
|
|
990
|
+
// Switch the second half back to MILAN on the RAISED item: the previously
|
|
991
|
+
// upgraded milan returns to its own price (cheap pair)...
|
|
992
|
+
const switched = (0, order_engine_1.setCheckFieldInOrderEngineItem)(premium, 'mod-pizza_halfhalf-1_seg-2_milan', true, false);
|
|
993
|
+
const cheap = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(switched, {
|
|
994
|
+
originalPriceReferences: state.originalPriceReferences,
|
|
1131
995
|
});
|
|
1132
|
-
|
|
1133
|
-
expect(
|
|
996
|
+
const cheapSegments = segmentOptions(cheap);
|
|
997
|
+
expect(cheapSegments[0].find((o) => o.id === 'milan').price).toBe(0);
|
|
998
|
+
expect(cheapSegments[1].find((o) => o.id === 'milan').price).toBe(0);
|
|
999
|
+
// ...and the special's own (top-level) option prices are never re-based.
|
|
1000
|
+
expect(cheap.modifiers[0].options.find((o) => o._id === 'torent').price).toBe(200);
|
|
1134
1001
|
});
|
|
1135
1002
|
});
|
|
1136
1003
|
// ============================================================================
|
|
1137
|
-
// 5) Engine —
|
|
1004
|
+
// 5) Engine — option price references (classic half-half flow)
|
|
1138
1005
|
// ============================================================================
|
|
1139
|
-
describe('choose_expensive_segment_price
|
|
1140
|
-
|
|
1141
|
-
// at most the most expensive SELECTED one, not the setup's global max.
|
|
1142
|
-
const itemsMap4 = {
|
|
1006
|
+
describe('choose_expensive_segment_price — option price references (classic flow)', () => {
|
|
1007
|
+
const itemsMap = {
|
|
1143
1008
|
a: makeItem('a', { price: { BASE_PRICE: 1000 } }),
|
|
1144
1009
|
b: makeItem('b', { price: { BASE_PRICE: 1000 } }),
|
|
1145
1010
|
c: makeItem('c', { price: { BASE_PRICE: 1200 } }),
|
|
1146
1011
|
d: makeItem('d', { price: { BASE_PRICE: 1200 } }),
|
|
1147
1012
|
};
|
|
1148
|
-
const
|
|
1013
|
+
const setup = () => makeHalfHalfSetup({
|
|
1149
1014
|
upsell_price: null,
|
|
1150
1015
|
items: [
|
|
1151
1016
|
{ item_id: 'a', sort_id: 1, upsell_price: null },
|
|
@@ -1154,11 +1019,8 @@ describe('choose_expensive_segment_price: selected-halves max (new semantics)',
|
|
|
1154
1019
|
{ item_id: 'd', sort_id: 4, upsell_price: null },
|
|
1155
1020
|
],
|
|
1156
1021
|
});
|
|
1157
|
-
|
|
1158
|
-
|
|
1159
|
-
// a/b = 1000/2 = 500, c/d = 1200/2 = 600 (the user's $5/$5/$6/$6 example).
|
|
1160
|
-
const baseValues = { a: 500, b: 500, c: 600, d: 600 };
|
|
1161
|
-
function freshEngine(item = converted) {
|
|
1022
|
+
function buildState() {
|
|
1023
|
+
const item = (0, halfhalf_setup_helpers_1.convertHalfHalfToItem)(setup(), itemsMap);
|
|
1162
1024
|
return (0, order_engine_1.convertCatalogItemToOrderEngineItem)({
|
|
1163
1025
|
item,
|
|
1164
1026
|
orderItem: undefined,
|
|
@@ -1169,383 +1031,79 @@ describe('choose_expensive_segment_price: selected-halves max (new semantics)',
|
|
|
1169
1031
|
soldoutModifiers: [],
|
|
1170
1032
|
});
|
|
1171
1033
|
}
|
|
1172
|
-
|
|
1173
|
-
|
|
1174
|
-
|
|
1175
|
-
|
|
1176
|
-
|
|
1177
|
-
|
|
1178
|
-
|
|
1179
|
-
|
|
1180
|
-
|
|
1181
|
-
|
|
1182
|
-
|
|
1183
|
-
|
|
1184
|
-
|
|
1185
|
-
|
|
1186
|
-
return (0, order_engine_1.applyChooseExpensiveSegmentPrice)(engine, { basePrices });
|
|
1187
|
-
}
|
|
1188
|
-
/** Real UI flow: pick one option per segment (the radio group clears the sibling). */
|
|
1189
|
-
function pick(engine, segmentIndex, optionId) {
|
|
1190
|
-
return (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, `seg-${segmentIndex + 1}_${optionId}`, true);
|
|
1191
|
-
}
|
|
1192
|
-
it('A+B stays 5+5 (global max must NOT leak)', () => {
|
|
1193
|
-
const result = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(selectEngine(['a', 'b']));
|
|
1194
|
-
expect(selectedPrices(result)).toEqual([500, 500]);
|
|
1195
|
-
});
|
|
1196
|
-
it('B+C raises B to C (6+6)', () => {
|
|
1197
|
-
const result = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(selectEngine(['b', 'c']));
|
|
1198
|
-
expect(selectedPrices(result)).toEqual([600, 600]);
|
|
1199
|
-
});
|
|
1200
|
-
it('C+B is order independent (6+6)', () => {
|
|
1201
|
-
const result = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(selectEngine(['c', 'b']));
|
|
1202
|
-
expect(selectedPrices(result)).toEqual([600, 600]);
|
|
1203
|
-
});
|
|
1204
|
-
it('C+D needs no raise (6+6)', () => {
|
|
1205
|
-
const result = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(selectEngine(['c', 'd']));
|
|
1206
|
-
expect(selectedPrices(result)).toEqual([600, 600]);
|
|
1207
|
-
});
|
|
1208
|
-
it('A+D raises A to D (6+6)', () => {
|
|
1209
|
-
const result = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(selectEngine(['a', 'd']));
|
|
1210
|
-
expect(selectedPrices(result)).toEqual([600, 600]);
|
|
1211
|
-
});
|
|
1212
|
-
it('unselected options keep their own prices; item-level upsell untouched', () => {
|
|
1213
|
-
const result = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(selectEngine(['a', 'b']));
|
|
1214
|
-
const seg1 = result.modifiers.find((m) => m._id === 'seg-1');
|
|
1215
|
-
expect(seg1.options.find((o) => o._id === 'c').price).toBe(600);
|
|
1216
|
-
expect(seg1.options.find((o) => o._id === 'd').price).toBe(600);
|
|
1217
|
-
// Setup upsell is null -> engine item price 0 (added once, never normalized).
|
|
1218
|
-
expect(result.price).toBe(0);
|
|
1219
|
-
});
|
|
1220
|
-
it('LOWERS again when switching from an expensive pair to a cheap pair (basePrices reset)', () => {
|
|
1221
|
-
// B+C -> B is raised to 600...
|
|
1222
|
-
const expensive = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(selectEngine(['b', 'c']));
|
|
1223
|
-
expect(selectedPrices(expensive)).toEqual([600, 600]);
|
|
1224
|
-
// ...then the user switches BOTH halves to the cheap pair A+B. Re-applying
|
|
1225
|
-
// with pristine basePrices must bring B back down to 500.
|
|
1226
|
-
let engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(expensive, 'seg-1_b', false);
|
|
1034
|
+
const priceAt = (engine, segmentId, optionId) => engine.modifiers.find((m) => m._id === segmentId).options.find((o) => o._id === optionId).price;
|
|
1035
|
+
it('originalPriceReferences: definition prices keyed by the option path', () => {
|
|
1036
|
+
const { originalPriceReferences } = buildState();
|
|
1037
|
+
// a/b = 1000/2 = 500, c/d = 1200/2 = 600 — for BOTH segments.
|
|
1038
|
+
expect(originalPriceReferences['seg-1_a']).toBe(500);
|
|
1039
|
+
expect(originalPriceReferences['seg-1_b']).toBe(500);
|
|
1040
|
+
expect(originalPriceReferences['seg-1_c']).toBe(600);
|
|
1041
|
+
expect(originalPriceReferences['seg-1_d']).toBe(600);
|
|
1042
|
+
expect(originalPriceReferences['seg-2_a']).toBe(500);
|
|
1043
|
+
expect(originalPriceReferences['seg-2_d']).toBe(600);
|
|
1044
|
+
});
|
|
1045
|
+
it('A+B charges 5+5: expensive UNSELECTED options never leak into the max', () => {
|
|
1046
|
+
const { originalPriceReferences, workingData } = buildState();
|
|
1047
|
+
let engine = workingData;
|
|
1227
1048
|
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-1_a', true);
|
|
1228
|
-
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-2_c', false);
|
|
1229
1049
|
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-2_b', true);
|
|
1230
|
-
const
|
|
1231
|
-
expect(
|
|
1232
|
-
|
|
1233
|
-
|
|
1234
|
-
|
|
1235
|
-
|
|
1236
|
-
|
|
1237
|
-
|
|
1238
|
-
|
|
1239
|
-
const engine = selectEngine(['b', 'c']);
|
|
1240
|
-
const displayed = normalize(engine);
|
|
1241
|
-
expect(selectedPrices(displayed)).toEqual([600, 600]);
|
|
1242
|
-
// From the pristine drawer state AND from the raised display alike.
|
|
1243
|
-
for (const source of [engine, displayed]) {
|
|
1244
|
-
const result = normalize(pick(pick(source, 0, 'c'), 1, 'd'));
|
|
1245
|
-
expect(selectedPrices(result)).toEqual([600, 600]);
|
|
1246
|
-
// B is no longer selected anywhere -> back to its own 500.
|
|
1247
|
-
expect(optionPrice(result, 'seg-1', 'b')).toBe(500);
|
|
1248
|
-
expect(optionPrice(result, 'seg-2', 'b')).toBe(500);
|
|
1249
|
-
// D keeps its own 600 and C stays selected at 600.
|
|
1250
|
-
expect(optionPrice(result, 'seg-2', 'd')).toBe(600);
|
|
1251
|
-
expect(optionPrice(result, 'seg-1', 'c')).toBe(600);
|
|
1252
|
-
}
|
|
1253
|
-
});
|
|
1254
|
-
it('user flow: after B+C, switching to C,B keeps 6+6 and de-selected segment-1 B drops to 500', () => {
|
|
1255
|
-
const engine = selectEngine(['b', 'c']);
|
|
1256
|
-
const displayed = normalize(engine);
|
|
1257
|
-
for (const source of [engine, displayed]) {
|
|
1258
|
-
const result = normalize(pick(pick(source, 0, 'c'), 1, 'b'));
|
|
1259
|
-
expect(selectedPrices(result)).toEqual([600, 600]);
|
|
1260
|
-
// Segment 1 now charges C (600); its B is de-selected -> 500.
|
|
1261
|
-
expect(optionPrice(result, 'seg-1', 'c')).toBe(600);
|
|
1262
|
-
expect(optionPrice(result, 'seg-1', 'b')).toBe(500);
|
|
1263
|
-
// Segment 2 charges B raised to C's price.
|
|
1264
|
-
expect(optionPrice(result, 'seg-2', 'b')).toBe(600);
|
|
1265
|
-
}
|
|
1266
|
-
});
|
|
1267
|
-
it('user flow: after B+C, switching to A+B lowers the previously raised B to 500', () => {
|
|
1268
|
-
const engine = selectEngine(['b', 'c']);
|
|
1269
|
-
const displayed = normalize(engine);
|
|
1270
|
-
expect(selectedPrices(displayed)).toEqual([600, 600]);
|
|
1271
|
-
for (const source of [engine, displayed]) {
|
|
1272
|
-
const result = normalize(pick(pick(source, 0, 'a'), 1, 'b'));
|
|
1273
|
-
expect(selectedPrices(result)).toEqual([500, 500]);
|
|
1274
|
-
// The de-selected C keeps its own 600; nothing left over from the old pair.
|
|
1275
|
-
expect(optionPrice(result, 'seg-1', 'c')).toBe(600);
|
|
1276
|
-
expect(optionPrice(result, 'seg-2', 'b')).toBe(500);
|
|
1277
|
-
expect(optionPrice(result, 'seg-2', 'c')).toBe(600);
|
|
1278
|
-
}
|
|
1279
|
-
});
|
|
1280
|
-
it('a full session (B+C -> C,D -> C,B -> A,B) recomputes from pristine prices at every step', () => {
|
|
1281
|
-
const engine = selectEngine(['b', 'c']);
|
|
1282
|
-
expect(selectedPrices(normalize(engine))).toEqual([600, 600]);
|
|
1283
|
-
const step1 = pick(pick(engine, 0, 'c'), 1, 'd');
|
|
1284
|
-
const displayed1 = normalize(step1);
|
|
1285
|
-
expect(selectedPrices(displayed1)).toEqual([600, 600]);
|
|
1286
|
-
expect(optionPrice(displayed1, 'seg-1', 'b')).toBe(500);
|
|
1287
|
-
const step2 = pick(pick(step1, 0, 'c'), 1, 'b');
|
|
1288
|
-
const displayed2 = normalize(step2);
|
|
1289
|
-
expect(selectedPrices(displayed2)).toEqual([600, 600]);
|
|
1290
|
-
const step3 = pick(pick(step2, 0, 'a'), 1, 'b');
|
|
1291
|
-
const displayed3 = normalize(step3);
|
|
1292
|
-
expect(selectedPrices(displayed3)).toEqual([500, 500]);
|
|
1293
|
-
// Every unselected option is its own price again.
|
|
1294
|
-
expect(optionPrice(displayed3, 'seg-1', 'c')).toBe(600);
|
|
1295
|
-
expect(optionPrice(displayed3, 'seg-1', 'd')).toBe(600);
|
|
1296
|
-
expect(optionPrice(displayed3, 'seg-2', 'c')).toBe(600);
|
|
1297
|
-
});
|
|
1298
|
-
it('full change matrix: every ordered pair -> pair switch recomputes from pristine prices', () => {
|
|
1299
|
-
const combos = [
|
|
1300
|
-
['a', 'b'],
|
|
1301
|
-
['b', 'a'],
|
|
1302
|
-
['a', 'c'],
|
|
1303
|
-
['c', 'a'],
|
|
1304
|
-
['a', 'd'],
|
|
1305
|
-
['d', 'a'],
|
|
1306
|
-
['b', 'c'],
|
|
1307
|
-
['c', 'b'],
|
|
1308
|
-
['b', 'd'],
|
|
1309
|
-
['d', 'b'],
|
|
1310
|
-
['c', 'd'],
|
|
1311
|
-
['d', 'c'],
|
|
1312
|
-
];
|
|
1313
|
-
for (const from of combos) {
|
|
1314
|
-
const fromPristine = selectEngine(from);
|
|
1315
|
-
const fromDisplay = normalize(fromPristine);
|
|
1316
|
-
const expectedFrom = Math.max(baseValues[from[0]], baseValues[from[1]]);
|
|
1317
|
-
expect(selectedPrices(fromDisplay)).toEqual([expectedFrom, expectedFrom]);
|
|
1318
|
-
for (const to of combos) {
|
|
1319
|
-
const expectedTo = Math.max(baseValues[to[0]], baseValues[to[1]]);
|
|
1320
|
-
for (const source of [fromPristine, fromDisplay]) {
|
|
1321
|
-
const result = normalize(pick(pick(source, 0, to[0]), 1, to[1]));
|
|
1322
|
-
expect(selectedPrices(result)).toEqual([expectedTo, expectedTo]);
|
|
1323
|
-
// Every half de-selected by the switch is back to its own price.
|
|
1324
|
-
for (const optionId of from) {
|
|
1325
|
-
if (to.includes(optionId))
|
|
1326
|
-
continue;
|
|
1327
|
-
expect(optionPrice(result, 'seg-1', optionId)).toBe(baseValues[optionId]);
|
|
1328
|
-
expect(optionPrice(result, 'seg-2', optionId)).toBe(baseValues[optionId]);
|
|
1329
|
-
}
|
|
1330
|
-
}
|
|
1331
|
-
}
|
|
1332
|
-
}
|
|
1333
|
-
});
|
|
1334
|
-
it('edit flow: persisted raised prices are re-based before the next change', () => {
|
|
1335
|
-
// Submit B+C -> the order item stores segment-1 B at 600.
|
|
1336
|
-
const submitted = normalize(selectEngine(['b', 'c']));
|
|
1337
|
-
const orderItem = (0, order_engine_1.convertOrderEngineItemToOrderItem)(submitted, TENANT_ID);
|
|
1338
|
-
expect((orderItem.modifiers ?? []).find((m) => m._id === 'seg-1').options.find((o) => o._id === 'b').price).toBe(600);
|
|
1339
|
-
// Reopen the drawer for edit: the persisted raise reads back into the engine...
|
|
1340
|
-
const reopened = (0, order_engine_1.convertCatalogItemToOrderEngineItem)({
|
|
1341
|
-
item: converted,
|
|
1342
|
-
orderItem,
|
|
1343
|
-
platform: PLATFORM,
|
|
1344
|
-
tenantId: TENANT_ID,
|
|
1345
|
-
orderItemType: constants_1.ORDER_ITEM_TYPE_ENUM.HALF_HALF,
|
|
1346
|
-
defaultMenuId: null,
|
|
1347
|
-
soldoutModifiers: [],
|
|
1348
|
-
});
|
|
1349
|
-
expect(optionPrice(reopened, 'seg-1', 'b')).toBe(600);
|
|
1350
|
-
// ...and the pristine reset restores the catalog baseline.
|
|
1351
|
-
const rebased = (0, order_engine_1.resetOrderEngineItemPrices)(reopened, basePrices);
|
|
1352
|
-
expect(optionPrice(rebased, 'seg-1', 'b')).toBe(500);
|
|
1353
|
-
// Submitting without changes keeps B+C at 6+6...
|
|
1354
|
-
expect(selectedPrices(normalize(rebased))).toEqual([600, 600]);
|
|
1355
|
-
// ...while switching to A+B lowers B back to 5.
|
|
1356
|
-
const changed = normalize(pick(pick(rebased, 0, 'a'), 1, 'b'));
|
|
1357
|
-
expect(selectedPrices(changed)).toEqual([500, 500]);
|
|
1358
|
-
expect(optionPrice(changed, 'seg-1', 'b')).toBe(500);
|
|
1359
|
-
expect(optionPrice(changed, 'seg-2', 'b')).toBe(500);
|
|
1360
|
-
});
|
|
1361
|
-
it('single selected half: nothing to raise, the other segment stays untouched', () => {
|
|
1362
|
-
const result = normalize(pick(freshEngine(), 0, 'a'));
|
|
1363
|
-
expect(optionPrice(result, 'seg-1', 'a')).toBe(500);
|
|
1364
|
-
expect(optionPrice(result, 'seg-1', 'c')).toBe(600);
|
|
1365
|
-
// Segment 2 has no selection at all — its options keep their own prices.
|
|
1366
|
-
expect(optionPrice(result, 'seg-2', 'a')).toBe(500);
|
|
1367
|
-
expect(optionPrice(result, 'seg-2', 'd')).toBe(600);
|
|
1368
|
-
});
|
|
1369
|
-
it('no selection at all: prices are re-based and nothing is raised or invented', () => {
|
|
1370
|
-
const source = freshEngine();
|
|
1371
|
-
// Legacy call (no basePrices): unchanged item is returned as is.
|
|
1372
|
-
expect((0, order_engine_1.applyChooseExpensiveSegmentPrice)(source)).toBe(source);
|
|
1373
|
-
const result = normalize(source);
|
|
1374
|
-
expect(optionPrice(result, 'seg-1', 'a')).toBe(500);
|
|
1375
|
-
expect(optionPrice(result, 'seg-1', 'c')).toBe(600);
|
|
1376
|
-
expect(optionPrice(result, 'seg-2', 'b')).toBe(500);
|
|
1377
|
-
expect(optionPrice(result, 'seg-2', 'd')).toBe(600);
|
|
1378
|
-
});
|
|
1379
|
-
it('quarters (4 segments): max over the four selected sides; switching sides re-bases', () => {
|
|
1380
|
-
const quarters = (0, halfhalf_setup_helpers_1.convertHalfHalfToItem)(makeHalfHalfSetup({
|
|
1381
|
-
upsell_price: null,
|
|
1382
|
-
segments: [
|
|
1383
|
-
{ _id: 'q-1', name: 'Quarter 1', sort_id: 1 },
|
|
1384
|
-
{ _id: 'q-2', name: 'Quarter 2', sort_id: 2 },
|
|
1385
|
-
{ _id: 'q-3', name: 'Quarter 3', sort_id: 3 },
|
|
1386
|
-
{ _id: 'q-4', name: 'Quarter 4', sort_id: 4 },
|
|
1387
|
-
],
|
|
1388
|
-
items: [
|
|
1389
|
-
{ item_id: 'a', sort_id: 1, upsell_price: null },
|
|
1390
|
-
{ item_id: 'b', sort_id: 2, upsell_price: null },
|
|
1391
|
-
{ item_id: 'c', sort_id: 3, upsell_price: null },
|
|
1392
|
-
{ item_id: 'd', sort_id: 4, upsell_price: null },
|
|
1393
|
-
],
|
|
1394
|
-
}), itemsMap4);
|
|
1395
|
-
const quarterBase = (0, order_engine_1.getOptionPriceMapFromItem)(quarters, PLATFORM);
|
|
1396
|
-
const quarterPrice = (item, segmentId, optionId) => item.modifiers.find((m) => m._id === segmentId).options.find((o) => o._id === optionId).price;
|
|
1397
|
-
let engine = freshEngine(quarters);
|
|
1398
|
-
// a/b = 1000/4 = 250, c/d = 1200/4 = 300.
|
|
1399
|
-
expect(quarterPrice(engine, 'q-1', 'a')).toBe(250);
|
|
1400
|
-
expect(quarterPrice(engine, 'q-1', 'c')).toBe(300);
|
|
1401
|
-
const picks = [
|
|
1402
|
-
['q-1', 'a'],
|
|
1403
|
-
['q-2', 'a'],
|
|
1404
|
-
['q-3', 'd'],
|
|
1405
|
-
['q-4', 'd'],
|
|
1406
|
-
];
|
|
1407
|
-
for (const [segmentId, optionId] of picks) {
|
|
1408
|
-
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, `${segmentId}_${optionId}`, true);
|
|
1409
|
-
}
|
|
1410
|
-
const mixed = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(engine, { basePrices: quarterBase });
|
|
1411
|
-
for (const segmentId of ['q-1', 'q-2']) {
|
|
1412
|
-
expect(quarterPrice(mixed, segmentId, 'a')).toBe(300);
|
|
1413
|
-
}
|
|
1414
|
-
for (const segmentId of ['q-3', 'q-4']) {
|
|
1415
|
-
expect(quarterPrice(mixed, segmentId, 'd')).toBe(300);
|
|
1416
|
-
}
|
|
1417
|
-
// All four sides cheap: everything returns to 250 (from the raised state too).
|
|
1418
|
-
for (const source of [engine, mixed]) {
|
|
1419
|
-
let cheap = source;
|
|
1420
|
-
for (const segmentId of ['q-1', 'q-2', 'q-3', 'q-4']) {
|
|
1421
|
-
cheap = (0, order_engine_1.setCheckFieldInOrderEngineItem)(cheap, `${segmentId}_a`, true);
|
|
1422
|
-
}
|
|
1423
|
-
const result = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(cheap, { basePrices: quarterBase });
|
|
1424
|
-
for (const segmentId of ['q-1', 'q-2', 'q-3', 'q-4']) {
|
|
1425
|
-
expect(quarterPrice(result, segmentId, 'a')).toBe(250);
|
|
1426
|
-
}
|
|
1427
|
-
// De-selected c/d keep their own 300.
|
|
1428
|
-
expect(quarterPrice(result, 'q-1', 'd')).toBe(300);
|
|
1429
|
-
}
|
|
1430
|
-
});
|
|
1431
|
-
});
|
|
1432
|
-
// ============================================================================
|
|
1433
|
-
// 6) Engine memory — `base_price` (reversible normalization without maps)
|
|
1434
|
-
// ============================================================================
|
|
1435
|
-
describe('engine memory: base_price makes choose_expensive reversible in place', () => {
|
|
1436
|
-
const itemsMap = {
|
|
1437
|
-
a: makeItem('a', { price: { BASE_PRICE: 1000 } }),
|
|
1438
|
-
b: makeItem('b', { price: { BASE_PRICE: 1000 } }),
|
|
1439
|
-
c: makeItem('c', { price: { BASE_PRICE: 1200 } }),
|
|
1440
|
-
d: makeItem('d', { price: { BASE_PRICE: 1200 } }),
|
|
1441
|
-
};
|
|
1442
|
-
const setup = () => makeHalfHalfSetup({
|
|
1443
|
-
upsell_price: null,
|
|
1444
|
-
items: [
|
|
1445
|
-
{ item_id: 'a', sort_id: 1, upsell_price: null },
|
|
1446
|
-
{ item_id: 'b', sort_id: 2, upsell_price: null },
|
|
1447
|
-
{ item_id: 'c', sort_id: 3, upsell_price: null },
|
|
1448
|
-
{ item_id: 'd', sort_id: 4, upsell_price: null },
|
|
1449
|
-
],
|
|
1450
|
-
});
|
|
1451
|
-
function buildEngine() {
|
|
1452
|
-
const converted = (0, halfhalf_setup_helpers_1.convertHalfHalfToItem)(setup(), itemsMap);
|
|
1453
|
-
return (0, order_engine_1.convertCatalogItemToOrderEngineItem)({
|
|
1454
|
-
item: converted,
|
|
1455
|
-
orderItem: undefined,
|
|
1456
|
-
platform: PLATFORM,
|
|
1457
|
-
tenantId: TENANT_ID,
|
|
1458
|
-
orderItemType: constants_1.ORDER_ITEM_TYPE_ENUM.HALF_HALF,
|
|
1459
|
-
defaultMenuId: null,
|
|
1460
|
-
soldoutModifiers: [],
|
|
1461
|
-
});
|
|
1462
|
-
}
|
|
1463
|
-
function priceOf(engine, segmentId, optionId, base = false) {
|
|
1464
|
-
const option = engine.modifiers.find((m) => m._id === segmentId).options.find((o) => o._id === optionId);
|
|
1465
|
-
return base ? option.base_price : option.price;
|
|
1466
|
-
}
|
|
1467
|
-
it('conversion stamps the catalog definition on every option', () => {
|
|
1468
|
-
const engine = buildEngine();
|
|
1469
|
-
const expected = [
|
|
1470
|
-
['a', 500],
|
|
1471
|
-
['b', 500],
|
|
1472
|
-
['c', 600],
|
|
1473
|
-
['d', 600],
|
|
1474
|
-
];
|
|
1475
|
-
for (const [optionId, value] of expected) {
|
|
1476
|
-
expect(priceOf(engine, 'seg-1', optionId, true)).toBe(value);
|
|
1477
|
-
expect(priceOf(engine, 'seg-1', optionId)).toBe(value);
|
|
1478
|
-
expect(priceOf(engine, 'seg-2', optionId, true)).toBe(value);
|
|
1479
|
-
}
|
|
1480
|
-
});
|
|
1481
|
-
it('changing the choice on the SAME (raised) engine lowers again — no external map', () => {
|
|
1482
|
-
let engine = buildEngine();
|
|
1050
|
+
const result = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(engine, { originalPriceReferences });
|
|
1051
|
+
expect(priceAt(result, 'seg-1', 'a')).toBe(500);
|
|
1052
|
+
expect(priceAt(result, 'seg-2', 'b')).toBe(500);
|
|
1053
|
+
// Expensive options keep their own (higher) price.
|
|
1054
|
+
expect(priceAt(result, 'seg-1', 'c')).toBe(600);
|
|
1055
|
+
});
|
|
1056
|
+
it('B+C charges 6+6 and every segment previews its OWN switch level (max with the OTHER segment)', () => {
|
|
1057
|
+
const { originalPriceReferences, workingData } = buildState();
|
|
1058
|
+
let engine = workingData;
|
|
1483
1059
|
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-1_b', true);
|
|
1484
1060
|
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-2_c', true);
|
|
1485
|
-
|
|
1486
|
-
|
|
1487
|
-
expect(
|
|
1488
|
-
expect(
|
|
1489
|
-
//
|
|
1490
|
-
|
|
1491
|
-
|
|
1492
|
-
|
|
1493
|
-
|
|
1494
|
-
|
|
1495
|
-
expect(
|
|
1496
|
-
|
|
1497
|
-
expect(
|
|
1498
|
-
|
|
1499
|
-
|
|
1500
|
-
|
|
1501
|
-
let engine =
|
|
1061
|
+
const result = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(engine, { originalPriceReferences });
|
|
1062
|
+
// Selected: B levelled 500 -> 600, C stays 600.
|
|
1063
|
+
expect(priceAt(result, 'seg-1', 'b')).toBe(600);
|
|
1064
|
+
expect(priceAt(result, 'seg-2', 'c')).toBe(600);
|
|
1065
|
+
// SEG-1's alternatives SWITCH to the other segment's level: with C (600)
|
|
1066
|
+
// still picked, choosing any of them keeps the pair at 6+6.
|
|
1067
|
+
expect(priceAt(result, 'seg-1', 'a')).toBe(600);
|
|
1068
|
+
// SEG-2's alternatives REPLACE its own pick (C), so their preview is
|
|
1069
|
+
// max(own 500, the OTHER segment's pick B = 500) = 500 — picking one
|
|
1070
|
+
// makes the pair 5+5.
|
|
1071
|
+
expect(priceAt(result, 'seg-2', 'a')).toBe(500);
|
|
1072
|
+
expect(priceAt(result, 'seg-2', 'b')).toBe(500);
|
|
1073
|
+
expect(priceAt(result, 'seg-2', 'd')).toBe(600); // own (higher)
|
|
1074
|
+
});
|
|
1075
|
+
it('switching B+C -> A+B on the SAME (already levelled) item lowers again', () => {
|
|
1076
|
+
const { originalPriceReferences, workingData } = buildState();
|
|
1077
|
+
let engine = workingData;
|
|
1502
1078
|
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-1_b', true);
|
|
1503
1079
|
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-2_c', true);
|
|
1504
|
-
|
|
1505
|
-
expect(
|
|
1506
|
-
// B
|
|
1507
|
-
|
|
1508
|
-
|
|
1509
|
-
|
|
1510
|
-
expect(
|
|
1511
|
-
expect(
|
|
1512
|
-
|
|
1513
|
-
expect(
|
|
1514
|
-
|
|
1515
|
-
|
|
1516
|
-
|
|
1517
|
-
|
|
1518
|
-
|
|
1519
|
-
const
|
|
1520
|
-
|
|
1521
|
-
|
|
1522
|
-
|
|
1523
|
-
|
|
1524
|
-
|
|
1525
|
-
|
|
1526
|
-
|
|
1527
|
-
|
|
1528
|
-
const
|
|
1529
|
-
// B
|
|
1530
|
-
|
|
1531
|
-
|
|
1532
|
-
halfHalfItem: workable,
|
|
1533
|
-
selectedHalfHalfItems: [segmentB, (0, order_engine_1.convertItemToOrderItem)(workable.items[2], null, PLATFORM, TENANT_ID)],
|
|
1534
|
-
quantity: 1,
|
|
1535
|
-
platform: PLATFORM,
|
|
1536
|
-
chooseExpensiveSegmentPrice: true,
|
|
1537
|
-
});
|
|
1538
|
-
expect(priceOf(premium, 'seg-1', 'b')).toBe(600);
|
|
1539
|
-
expect(priceOf(premium, 'seg-1', 'b', true)).toBe(500);
|
|
1540
|
-
// User changes to A + B: the persisted 600 must drop to the definition 500.
|
|
1541
|
-
const cheap = (0, halfhalf_setup_helpers_1.convertHalfHalfToOrderEngineItem)({
|
|
1542
|
-
halfHalfItem: workable,
|
|
1543
|
-
selectedHalfHalfItems: [(0, order_engine_1.convertItemToOrderItem)(workable.items[0], null, PLATFORM, TENANT_ID), segmentB],
|
|
1544
|
-
quantity: 1,
|
|
1545
|
-
platform: PLATFORM,
|
|
1546
|
-
chooseExpensiveSegmentPrice: true,
|
|
1547
|
-
});
|
|
1548
|
-
expect(priceOf(cheap, 'seg-1', 'a')).toBe(500);
|
|
1549
|
-
expect(priceOf(cheap, 'seg-2', 'b')).toBe(500);
|
|
1080
|
+
const raised = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(engine, { originalPriceReferences });
|
|
1081
|
+
expect(priceAt(raised, 'seg-1', 'b')).toBe(600);
|
|
1082
|
+
// The user changes the choice in place: B -> A, C -> B.
|
|
1083
|
+
let switched = (0, order_engine_1.setCheckFieldInOrderEngineItem)(raised, 'seg-1_a', true);
|
|
1084
|
+
switched = (0, order_engine_1.setCheckFieldInOrderEngineItem)(switched, 'seg-2_b', true);
|
|
1085
|
+
const lowered = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(switched, { originalPriceReferences });
|
|
1086
|
+
expect(priceAt(lowered, 'seg-1', 'a')).toBe(500);
|
|
1087
|
+
expect(priceAt(lowered, 'seg-2', 'b')).toBe(500);
|
|
1088
|
+
// De-selected C is back to its own price: nothing accumulates.
|
|
1089
|
+
expect(priceAt(lowered, 'seg-1', 'c')).toBe(600);
|
|
1090
|
+
expect(priceAt(lowered, 'seg-2', 'c')).toBe(600);
|
|
1091
|
+
});
|
|
1092
|
+
it('edit flow: persisted, already-raised prices are re-based from the definition', () => {
|
|
1093
|
+
const { originalPriceReferences, workingData } = buildState();
|
|
1094
|
+
// Simulate an edit line: B was charged 600 by a previous normalization.
|
|
1095
|
+
const persisted = {
|
|
1096
|
+
...workingData,
|
|
1097
|
+
modifiers: workingData.modifiers.map((modifier) => ({
|
|
1098
|
+
...modifier,
|
|
1099
|
+
options: modifier.options.map((option) => (option._id === 'b' ? { ...option, price: 600 } : option)),
|
|
1100
|
+
})),
|
|
1101
|
+
};
|
|
1102
|
+
let engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(persisted, 'seg-1_b', true);
|
|
1103
|
+
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-2_a', true);
|
|
1104
|
+
const result = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(engine, { originalPriceReferences });
|
|
1105
|
+
// B's persisted 600 is NOT the baseline: A+B is a cheap pair (5+5).
|
|
1106
|
+
expect(priceAt(result, 'seg-1', 'b')).toBe(500);
|
|
1107
|
+
expect(priceAt(result, 'seg-2', 'a')).toBe(500);
|
|
1550
1108
|
});
|
|
1551
1109
|
});
|