@managesome/eposmatic-toolkit 0.2.719 → 0.2.721
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 +25 -0
- package/lib/helpers/utils/halfhalf-setup-helpers.js +29 -6
- package/lib/helpers/utils/order-engine.d.ts +42 -75
- package/lib/helpers/utils/order-engine.js +182 -156
- package/lib/tests/nested-halfhalf-segment-price.test.js +0 -190
- package/lib/tests/specials-halfhalf-pricing.test.js +117 -440
- 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,57 +859,37 @@ 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
|
|
869
|
+
it('basic + premium selection levels the cheap half to the premium one (special-derived prices)', () => {
|
|
893
870
|
let engine = buildEngine();
|
|
894
871
|
// Real UI flow: selection happens through the special's engine item, so
|
|
895
872
|
// the identifier is the FULL path (group -> half-half option -> segment
|
|
896
|
-
// -> option)
|
|
897
|
-
|
|
898
|
-
|
|
873
|
+
// -> option) and setCheckField auto-normalizes via its SPECIAL branch.
|
|
874
|
+
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_halfhalf-1_seg-1_milan', true, false);
|
|
875
|
+
// Only the cheap half is picked so far — it IS the most expensive selected
|
|
876
|
+
// half, so nothing is raised yet.
|
|
899
877
|
expect(segmentOptions(engine)[0].find((o) => o.id === 'milan').price).toBe(0);
|
|
900
|
-
|
|
901
|
-
|
|
902
|
-
//
|
|
903
|
-
|
|
878
|
+
// Picking the premium half (100) makes it drive the rule: every cheaper
|
|
879
|
+
// option — selected or not — is levelled to it, so the drawer can show
|
|
880
|
+
// what picking it would cost. NO 575 from Pizza Size anywhere.
|
|
881
|
+
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_halfhalf-1_seg-2_torent', true, false);
|
|
882
|
+
const after = segmentOptions(engine);
|
|
904
883
|
expect(after[0].find((o) => o.id === 'milan').price).toBe(100);
|
|
905
884
|
expect(after[1].find((o) => o.id === 'torent').price).toBe(100);
|
|
906
|
-
|
|
907
|
-
expect(flat.every((o) => o.price === 0 || o.price === 100)).toBe(true);
|
|
885
|
+
expect(after.flat().every((o) => o.price === 100)).toBe(true);
|
|
908
886
|
});
|
|
909
887
|
it('is idempotent (re-applying never lowers or changes prices)', () => {
|
|
910
888
|
let engine = buildEngine();
|
|
911
|
-
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_halfhalf-1_seg-1_milan', true);
|
|
912
|
-
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_halfhalf-1_seg-2_torent', true);
|
|
913
|
-
const once = segmentOptions(
|
|
914
|
-
const twice = segmentOptions((0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(
|
|
889
|
+
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_halfhalf-1_seg-1_milan', true, false);
|
|
890
|
+
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_halfhalf-1_seg-2_torent', true, false);
|
|
891
|
+
const once = segmentOptions(engine);
|
|
892
|
+
const twice = segmentOptions((0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(engine));
|
|
915
893
|
expect(twice).toEqual(once);
|
|
916
894
|
});
|
|
917
895
|
it('does nothing when the half-half flag is off', () => {
|
|
@@ -924,7 +902,7 @@ describe('choose_expensive_segment_price end-to-end (specials with half-half)',
|
|
|
924
902
|
orderItemType: constants_1.ORDER_ITEM_TYPE_ENUM.SPECIAL,
|
|
925
903
|
defaultMenuId: null,
|
|
926
904
|
soldoutModifiers: [],
|
|
927
|
-
});
|
|
905
|
+
}).workingData;
|
|
928
906
|
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_halfhalf-1_seg-1_milan', true, false);
|
|
929
907
|
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_halfhalf-1_seg-2_torent', true, false);
|
|
930
908
|
const after = segmentOptions(engine);
|
|
@@ -944,7 +922,7 @@ describe('choose_expensive_segment_price end-to-end (specials with half-half)',
|
|
|
944
922
|
orderItemType: constants_1.ORDER_ITEM_TYPE_ENUM.HALF_HALF,
|
|
945
923
|
defaultMenuId: null,
|
|
946
924
|
soldoutModifiers: [],
|
|
947
|
-
});
|
|
925
|
+
}).workingData;
|
|
948
926
|
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-1_milan', true, false);
|
|
949
927
|
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-2_torent', true, false);
|
|
950
928
|
const result = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(engine);
|
|
@@ -972,160 +950,51 @@ describe('choose_expensive_segment_price end-to-end (specials with half-half)',
|
|
|
972
950
|
orderItemType: constants_1.ORDER_ITEM_TYPE_ENUM.SPECIAL,
|
|
973
951
|
defaultMenuId: null,
|
|
974
952
|
soldoutModifiers: [],
|
|
975
|
-
});
|
|
976
|
-
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_hh-flag_seg-1_milan', true);
|
|
977
|
-
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_hh-flag_seg-2_torent', true);
|
|
978
|
-
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_hh-no-flag_seg-1_milan', true);
|
|
979
|
-
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_hh-no-flag_seg-2_torent', true);
|
|
980
|
-
const
|
|
981
|
-
const
|
|
982
|
-
|
|
983
|
-
// Flagged: selected free milan raised to the selected expensive half (+100);
|
|
953
|
+
}).workingData;
|
|
954
|
+
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_hh-flag_seg-1_milan', true, false);
|
|
955
|
+
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_hh-flag_seg-2_torent', true, false);
|
|
956
|
+
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_hh-no-flag_seg-1_milan', true, false);
|
|
957
|
+
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_hh-no-flag_seg-2_torent', true, false);
|
|
958
|
+
const hhFlag = engine.modifiers[0].options.find((o) => o._id === 'hh-flag');
|
|
959
|
+
const hhNoFlag = engine.modifiers[0].options.find((o) => o._id === 'hh-no-flag');
|
|
960
|
+
// Flagged: the cheap half is levelled to the selected expensive half;
|
|
984
961
|
// un-flagged: stays free.
|
|
985
962
|
expect(hhFlag.modifiers[0].options.find((o) => o._id === 'milan').price).toBe(100);
|
|
986
963
|
expect(hhNoFlag.modifiers[0].options.find((o) => o._id === 'milan').price).toBe(0);
|
|
987
964
|
});
|
|
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('edit flow: a persisted nested raise is re-based before the next change', () => {
|
|
1081
|
-
const specialItem = buildSpecialItem();
|
|
1082
|
-
const basePrices = nestedBasePrices(specialItem);
|
|
1083
|
-
// Submit the premium pair: the order item carries the raised segment price.
|
|
1084
|
-
const submitted = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(selectNested(buildEngine(specialItem), ['milan', 'torent']), { basePrices });
|
|
1085
|
-
const orderItem = (0, order_engine_1.convertOrderEngineItemToOrderItem)(submitted, TENANT_ID);
|
|
1086
|
-
const persistedHalfHalf = (orderItem.modifiers ?? [])
|
|
1087
|
-
.find((m) => m._id === 'mod-pizza')
|
|
1088
|
-
.options.find((o) => o._id === 'halfhalf-1');
|
|
1089
|
-
expect(persistedHalfHalf.modifiers[0].options.find((o) => o._id === 'milan').price).toBe(100);
|
|
1090
|
-
// Reopening the drawer for edit reads those raised prices back...
|
|
1091
|
-
const reopened = (0, order_engine_1.convertCatalogItemToOrderEngineItem)({
|
|
1092
|
-
item: specialItem,
|
|
1093
|
-
orderItem,
|
|
1094
|
-
platform: PLATFORM,
|
|
1095
|
-
tenantId: TENANT_ID,
|
|
1096
|
-
orderItemType: constants_1.ORDER_ITEM_TYPE_ENUM.SPECIAL,
|
|
1097
|
-
defaultMenuId: null,
|
|
1098
|
-
soldoutModifiers: [],
|
|
965
|
+
it('references make the nested rule reversible in place (special flow)', () => {
|
|
966
|
+
const state = buildState();
|
|
967
|
+
let engine = state.workingData;
|
|
968
|
+
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_halfhalf-1_seg-1_milan', true, false);
|
|
969
|
+
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_halfhalf-1_seg-2_torent', true, false);
|
|
970
|
+
const premium = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(engine, {
|
|
971
|
+
originalPriceReferences: state.originalPriceReferences,
|
|
1099
972
|
});
|
|
1100
|
-
expect(
|
|
1101
|
-
//
|
|
1102
|
-
//
|
|
1103
|
-
const
|
|
1104
|
-
|
|
1105
|
-
|
|
1106
|
-
// Submitting without changes keeps the premium charging...
|
|
1107
|
-
expect(nestedPrice((0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(rebased, { basePrices }), 0, 'milan')).toBe(100);
|
|
1108
|
-
// ...while switching the second half lowers to the definition prices.
|
|
1109
|
-
const cheap = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(selectNested(rebased, ['milan', 'milan']), {
|
|
1110
|
-
basePrices,
|
|
973
|
+
expect(segmentOptions(premium)[0].find((o) => o.id === 'milan').price).toBe(100);
|
|
974
|
+
// Switch the second half back to MILAN on the RAISED item: the previously
|
|
975
|
+
// upgraded milan returns to its own price (cheap pair)...
|
|
976
|
+
const switched = (0, order_engine_1.setCheckFieldInOrderEngineItem)(premium, 'mod-pizza_halfhalf-1_seg-2_milan', true, false);
|
|
977
|
+
const cheap = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(switched, {
|
|
978
|
+
originalPriceReferences: state.originalPriceReferences,
|
|
1111
979
|
});
|
|
1112
|
-
|
|
1113
|
-
expect(
|
|
980
|
+
const cheapSegments = segmentOptions(cheap);
|
|
981
|
+
expect(cheapSegments[0].find((o) => o.id === 'milan').price).toBe(0);
|
|
982
|
+
expect(cheapSegments[1].find((o) => o.id === 'milan').price).toBe(0);
|
|
983
|
+
// ...and the special's own (top-level) option prices are never re-based.
|
|
984
|
+
expect(cheap.modifiers[0].options.find((o) => o._id === 'torent').price).toBe(200);
|
|
1114
985
|
});
|
|
1115
986
|
});
|
|
1116
987
|
// ============================================================================
|
|
1117
|
-
// 5) Engine —
|
|
988
|
+
// 5) Engine — option price references (classic half-half flow)
|
|
1118
989
|
// ============================================================================
|
|
1119
|
-
describe('choose_expensive_segment_price
|
|
1120
|
-
|
|
1121
|
-
// at most the most expensive SELECTED one, not the setup's global max.
|
|
1122
|
-
const itemsMap4 = {
|
|
990
|
+
describe('choose_expensive_segment_price — option price references (classic flow)', () => {
|
|
991
|
+
const itemsMap = {
|
|
1123
992
|
a: makeItem('a', { price: { BASE_PRICE: 1000 } }),
|
|
1124
993
|
b: makeItem('b', { price: { BASE_PRICE: 1000 } }),
|
|
1125
994
|
c: makeItem('c', { price: { BASE_PRICE: 1200 } }),
|
|
1126
995
|
d: makeItem('d', { price: { BASE_PRICE: 1200 } }),
|
|
1127
996
|
};
|
|
1128
|
-
const
|
|
997
|
+
const setup = () => makeHalfHalfSetup({
|
|
1129
998
|
upsell_price: null,
|
|
1130
999
|
items: [
|
|
1131
1000
|
{ item_id: 'a', sort_id: 1, upsell_price: null },
|
|
@@ -1134,11 +1003,8 @@ describe('choose_expensive_segment_price: selected-halves max (new semantics)',
|
|
|
1134
1003
|
{ item_id: 'd', sort_id: 4, upsell_price: null },
|
|
1135
1004
|
],
|
|
1136
1005
|
});
|
|
1137
|
-
|
|
1138
|
-
|
|
1139
|
-
// a/b = 1000/2 = 500, c/d = 1200/2 = 600 (the user's $5/$5/$6/$6 example).
|
|
1140
|
-
const baseValues = { a: 500, b: 500, c: 600, d: 600 };
|
|
1141
|
-
function freshEngine(item = converted) {
|
|
1006
|
+
function buildState() {
|
|
1007
|
+
const item = (0, halfhalf_setup_helpers_1.convertHalfHalfToItem)(setup(), itemsMap);
|
|
1142
1008
|
return (0, order_engine_1.convertCatalogItemToOrderEngineItem)({
|
|
1143
1009
|
item,
|
|
1144
1010
|
orderItem: undefined,
|
|
@@ -1149,263 +1015,74 @@ describe('choose_expensive_segment_price: selected-halves max (new semantics)',
|
|
|
1149
1015
|
soldoutModifiers: [],
|
|
1150
1016
|
});
|
|
1151
1017
|
}
|
|
1152
|
-
|
|
1153
|
-
|
|
1154
|
-
|
|
1155
|
-
|
|
1156
|
-
|
|
1157
|
-
|
|
1158
|
-
|
|
1159
|
-
|
|
1160
|
-
|
|
1161
|
-
|
|
1162
|
-
return engine.modifiers.find((m) => m._id === segmentId).options.find((o) => o._id === optionId).price;
|
|
1163
|
-
}
|
|
1164
|
-
/** The drawer's display/submit pass: recompute on a copy from pristine prices. */
|
|
1165
|
-
function normalize(engine) {
|
|
1166
|
-
return (0, order_engine_1.applyChooseExpensiveSegmentPrice)(engine, { basePrices });
|
|
1167
|
-
}
|
|
1168
|
-
/** Real UI flow: pick one option per segment (the radio group clears the sibling). */
|
|
1169
|
-
function pick(engine, segmentIndex, optionId) {
|
|
1170
|
-
return (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, `seg-${segmentIndex + 1}_${optionId}`, true);
|
|
1171
|
-
}
|
|
1172
|
-
it('A+B stays 5+5 (global max must NOT leak)', () => {
|
|
1173
|
-
const result = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(selectEngine(['a', 'b']));
|
|
1174
|
-
expect(selectedPrices(result)).toEqual([500, 500]);
|
|
1018
|
+
const priceAt = (engine, segmentId, optionId) => engine.modifiers.find((m) => m._id === segmentId).options.find((o) => o._id === optionId).price;
|
|
1019
|
+
it('originalPriceReferences: definition prices keyed by the option path', () => {
|
|
1020
|
+
const { originalPriceReferences } = buildState();
|
|
1021
|
+
// a/b = 1000/2 = 500, c/d = 1200/2 = 600 — for BOTH segments.
|
|
1022
|
+
expect(originalPriceReferences['seg-1_a']).toBe(500);
|
|
1023
|
+
expect(originalPriceReferences['seg-1_b']).toBe(500);
|
|
1024
|
+
expect(originalPriceReferences['seg-1_c']).toBe(600);
|
|
1025
|
+
expect(originalPriceReferences['seg-1_d']).toBe(600);
|
|
1026
|
+
expect(originalPriceReferences['seg-2_a']).toBe(500);
|
|
1027
|
+
expect(originalPriceReferences['seg-2_d']).toBe(600);
|
|
1175
1028
|
});
|
|
1176
|
-
it('B+
|
|
1177
|
-
const
|
|
1178
|
-
|
|
1179
|
-
});
|
|
1180
|
-
it('C+B is order independent (6+6)', () => {
|
|
1181
|
-
const result = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(selectEngine(['c', 'b']));
|
|
1182
|
-
expect(selectedPrices(result)).toEqual([600, 600]);
|
|
1183
|
-
});
|
|
1184
|
-
it('C+D needs no raise (6+6)', () => {
|
|
1185
|
-
const result = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(selectEngine(['c', 'd']));
|
|
1186
|
-
expect(selectedPrices(result)).toEqual([600, 600]);
|
|
1187
|
-
});
|
|
1188
|
-
it('A+D raises A to D (6+6)', () => {
|
|
1189
|
-
const result = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(selectEngine(['a', 'd']));
|
|
1190
|
-
expect(selectedPrices(result)).toEqual([600, 600]);
|
|
1191
|
-
});
|
|
1192
|
-
it('unselected options keep their own prices; item-level upsell untouched', () => {
|
|
1193
|
-
const result = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(selectEngine(['a', 'b']));
|
|
1194
|
-
const seg1 = result.modifiers.find((m) => m._id === 'seg-1');
|
|
1195
|
-
expect(seg1.options.find((o) => o._id === 'c').price).toBe(600);
|
|
1196
|
-
expect(seg1.options.find((o) => o._id === 'd').price).toBe(600);
|
|
1197
|
-
// Setup upsell is null -> engine item price 0 (added once, never normalized).
|
|
1198
|
-
expect(result.price).toBe(0);
|
|
1199
|
-
});
|
|
1200
|
-
it('LOWERS again when switching from an expensive pair to a cheap pair (basePrices reset)', () => {
|
|
1201
|
-
// B+C -> B is raised to 600...
|
|
1202
|
-
const expensive = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(selectEngine(['b', 'c']));
|
|
1203
|
-
expect(selectedPrices(expensive)).toEqual([600, 600]);
|
|
1204
|
-
// ...then the user switches BOTH halves to the cheap pair A+B. Re-applying
|
|
1205
|
-
// with pristine basePrices must bring B back down to 500.
|
|
1206
|
-
let engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(expensive, 'seg-1_b', false);
|
|
1029
|
+
it('A+B charges 5+5: expensive UNSELECTED options never leak into the max', () => {
|
|
1030
|
+
const { originalPriceReferences, workingData } = buildState();
|
|
1031
|
+
let engine = workingData;
|
|
1207
1032
|
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-1_a', true);
|
|
1208
|
-
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-2_c', false);
|
|
1209
1033
|
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-2_b', true);
|
|
1210
|
-
const
|
|
1211
|
-
expect(
|
|
1212
|
-
|
|
1213
|
-
|
|
1214
|
-
|
|
1215
|
-
// a/b stay 500, c/d stay 600 — NOT all raised to 600 at conversion.
|
|
1216
|
-
expect(workable[0].items.map((i) => priceOf(i.price))).toEqual([500, 500, 600, 600]);
|
|
1217
|
-
});
|
|
1218
|
-
it('user flow: after B+C, switching to C+D returns the de-selected B to 500', () => {
|
|
1219
|
-
const engine = selectEngine(['b', 'c']);
|
|
1220
|
-
const displayed = normalize(engine);
|
|
1221
|
-
expect(selectedPrices(displayed)).toEqual([600, 600]);
|
|
1222
|
-
// From the pristine drawer state AND from the raised display alike.
|
|
1223
|
-
for (const source of [engine, displayed]) {
|
|
1224
|
-
const result = normalize(pick(pick(source, 0, 'c'), 1, 'd'));
|
|
1225
|
-
expect(selectedPrices(result)).toEqual([600, 600]);
|
|
1226
|
-
// B is no longer selected anywhere -> back to its own 500.
|
|
1227
|
-
expect(optionPrice(result, 'seg-1', 'b')).toBe(500);
|
|
1228
|
-
expect(optionPrice(result, 'seg-2', 'b')).toBe(500);
|
|
1229
|
-
// D keeps its own 600 and C stays selected at 600.
|
|
1230
|
-
expect(optionPrice(result, 'seg-2', 'd')).toBe(600);
|
|
1231
|
-
expect(optionPrice(result, 'seg-1', 'c')).toBe(600);
|
|
1232
|
-
}
|
|
1233
|
-
});
|
|
1234
|
-
it('user flow: after B+C, switching to C,B keeps 6+6 and de-selected segment-1 B drops to 500', () => {
|
|
1235
|
-
const engine = selectEngine(['b', 'c']);
|
|
1236
|
-
const displayed = normalize(engine);
|
|
1237
|
-
for (const source of [engine, displayed]) {
|
|
1238
|
-
const result = normalize(pick(pick(source, 0, 'c'), 1, 'b'));
|
|
1239
|
-
expect(selectedPrices(result)).toEqual([600, 600]);
|
|
1240
|
-
// Segment 1 now charges C (600); its B is de-selected -> 500.
|
|
1241
|
-
expect(optionPrice(result, 'seg-1', 'c')).toBe(600);
|
|
1242
|
-
expect(optionPrice(result, 'seg-1', 'b')).toBe(500);
|
|
1243
|
-
// Segment 2 charges B raised to C's price.
|
|
1244
|
-
expect(optionPrice(result, 'seg-2', 'b')).toBe(600);
|
|
1245
|
-
}
|
|
1246
|
-
});
|
|
1247
|
-
it('user flow: after B+C, switching to A+B lowers the previously raised B to 500', () => {
|
|
1248
|
-
const engine = selectEngine(['b', 'c']);
|
|
1249
|
-
const displayed = normalize(engine);
|
|
1250
|
-
expect(selectedPrices(displayed)).toEqual([600, 600]);
|
|
1251
|
-
for (const source of [engine, displayed]) {
|
|
1252
|
-
const result = normalize(pick(pick(source, 0, 'a'), 1, 'b'));
|
|
1253
|
-
expect(selectedPrices(result)).toEqual([500, 500]);
|
|
1254
|
-
// The de-selected C keeps its own 600; nothing left over from the old pair.
|
|
1255
|
-
expect(optionPrice(result, 'seg-1', 'c')).toBe(600);
|
|
1256
|
-
expect(optionPrice(result, 'seg-2', 'b')).toBe(500);
|
|
1257
|
-
expect(optionPrice(result, 'seg-2', 'c')).toBe(600);
|
|
1258
|
-
}
|
|
1034
|
+
const result = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(engine, { originalPriceReferences });
|
|
1035
|
+
expect(priceAt(result, 'seg-1', 'a')).toBe(500);
|
|
1036
|
+
expect(priceAt(result, 'seg-2', 'b')).toBe(500);
|
|
1037
|
+
// Expensive options keep their own (higher) price.
|
|
1038
|
+
expect(priceAt(result, 'seg-1', 'c')).toBe(600);
|
|
1259
1039
|
});
|
|
1260
|
-
it('
|
|
1261
|
-
const
|
|
1262
|
-
|
|
1263
|
-
|
|
1264
|
-
|
|
1265
|
-
|
|
1266
|
-
|
|
1267
|
-
|
|
1268
|
-
|
|
1269
|
-
|
|
1270
|
-
|
|
1271
|
-
|
|
1272
|
-
expect(
|
|
1273
|
-
// Every unselected option is its own price again.
|
|
1274
|
-
expect(optionPrice(displayed3, 'seg-1', 'c')).toBe(600);
|
|
1275
|
-
expect(optionPrice(displayed3, 'seg-1', 'd')).toBe(600);
|
|
1276
|
-
expect(optionPrice(displayed3, 'seg-2', 'c')).toBe(600);
|
|
1040
|
+
it('B+C charges 6+6 and levels the cheaper options before they are picked', () => {
|
|
1041
|
+
const { originalPriceReferences, workingData } = buildState();
|
|
1042
|
+
let engine = workingData;
|
|
1043
|
+
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-1_b', true);
|
|
1044
|
+
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-2_c', true);
|
|
1045
|
+
const result = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(engine, { originalPriceReferences });
|
|
1046
|
+
// Selected: B levelled 500 -> 600, C stays 600.
|
|
1047
|
+
expect(priceAt(result, 'seg-1', 'b')).toBe(600);
|
|
1048
|
+
expect(priceAt(result, 'seg-2', 'c')).toBe(600);
|
|
1049
|
+
// Unselected cheap options SHOW what picking them would cost.
|
|
1050
|
+
expect(priceAt(result, 'seg-1', 'a')).toBe(600);
|
|
1051
|
+
expect(priceAt(result, 'seg-2', 'a')).toBe(600);
|
|
1052
|
+
expect(priceAt(result, 'seg-2', 'b')).toBe(600);
|
|
1277
1053
|
});
|
|
1278
|
-
it('
|
|
1279
|
-
const
|
|
1280
|
-
|
|
1281
|
-
|
|
1282
|
-
|
|
1283
|
-
|
|
1284
|
-
|
|
1285
|
-
|
|
1286
|
-
|
|
1287
|
-
|
|
1288
|
-
|
|
1289
|
-
|
|
1290
|
-
|
|
1291
|
-
|
|
1292
|
-
|
|
1293
|
-
|
|
1294
|
-
const fromPristine = selectEngine(from);
|
|
1295
|
-
const fromDisplay = normalize(fromPristine);
|
|
1296
|
-
const expectedFrom = Math.max(baseValues[from[0]], baseValues[from[1]]);
|
|
1297
|
-
expect(selectedPrices(fromDisplay)).toEqual([expectedFrom, expectedFrom]);
|
|
1298
|
-
for (const to of combos) {
|
|
1299
|
-
const expectedTo = Math.max(baseValues[to[0]], baseValues[to[1]]);
|
|
1300
|
-
for (const source of [fromPristine, fromDisplay]) {
|
|
1301
|
-
const result = normalize(pick(pick(source, 0, to[0]), 1, to[1]));
|
|
1302
|
-
expect(selectedPrices(result)).toEqual([expectedTo, expectedTo]);
|
|
1303
|
-
// Every half de-selected by the switch is back to its own price.
|
|
1304
|
-
for (const optionId of from) {
|
|
1305
|
-
if (to.includes(optionId))
|
|
1306
|
-
continue;
|
|
1307
|
-
expect(optionPrice(result, 'seg-1', optionId)).toBe(baseValues[optionId]);
|
|
1308
|
-
expect(optionPrice(result, 'seg-2', optionId)).toBe(baseValues[optionId]);
|
|
1309
|
-
}
|
|
1310
|
-
}
|
|
1311
|
-
}
|
|
1312
|
-
}
|
|
1054
|
+
it('switching B+C -> A+B on the SAME (already levelled) item lowers again', () => {
|
|
1055
|
+
const { originalPriceReferences, workingData } = buildState();
|
|
1056
|
+
let engine = workingData;
|
|
1057
|
+
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-1_b', true);
|
|
1058
|
+
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-2_c', true);
|
|
1059
|
+
const raised = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(engine, { originalPriceReferences });
|
|
1060
|
+
expect(priceAt(raised, 'seg-1', 'b')).toBe(600);
|
|
1061
|
+
// The user changes the choice in place: B -> A, C -> B.
|
|
1062
|
+
let switched = (0, order_engine_1.setCheckFieldInOrderEngineItem)(raised, 'seg-1_a', true);
|
|
1063
|
+
switched = (0, order_engine_1.setCheckFieldInOrderEngineItem)(switched, 'seg-2_b', true);
|
|
1064
|
+
const lowered = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(switched, { originalPriceReferences });
|
|
1065
|
+
expect(priceAt(lowered, 'seg-1', 'a')).toBe(500);
|
|
1066
|
+
expect(priceAt(lowered, 'seg-2', 'b')).toBe(500);
|
|
1067
|
+
// De-selected C is back to its own price: nothing accumulates.
|
|
1068
|
+
expect(priceAt(lowered, 'seg-1', 'c')).toBe(600);
|
|
1069
|
+
expect(priceAt(lowered, 'seg-2', 'c')).toBe(600);
|
|
1313
1070
|
});
|
|
1314
|
-
it('edit flow: persisted raised prices are re-based
|
|
1315
|
-
|
|
1316
|
-
|
|
1317
|
-
const
|
|
1318
|
-
|
|
1319
|
-
|
|
1320
|
-
|
|
1321
|
-
|
|
1322
|
-
|
|
1323
|
-
|
|
1324
|
-
|
|
1325
|
-
|
|
1326
|
-
|
|
1327
|
-
|
|
1328
|
-
|
|
1329
|
-
expect(
|
|
1330
|
-
// ...and the pristine reset restores the catalog baseline.
|
|
1331
|
-
const rebased = (0, order_engine_1.resetOrderEngineItemPrices)(reopened, basePrices);
|
|
1332
|
-
expect(optionPrice(rebased, 'seg-1', 'b')).toBe(500);
|
|
1333
|
-
// Submitting without changes keeps B+C at 6+6...
|
|
1334
|
-
expect(selectedPrices(normalize(rebased))).toEqual([600, 600]);
|
|
1335
|
-
// ...while switching to A+B lowers B back to 5.
|
|
1336
|
-
const changed = normalize(pick(pick(rebased, 0, 'a'), 1, 'b'));
|
|
1337
|
-
expect(selectedPrices(changed)).toEqual([500, 500]);
|
|
1338
|
-
expect(optionPrice(changed, 'seg-1', 'b')).toBe(500);
|
|
1339
|
-
expect(optionPrice(changed, 'seg-2', 'b')).toBe(500);
|
|
1340
|
-
});
|
|
1341
|
-
it('single selected half: nothing to raise, the other segment stays untouched', () => {
|
|
1342
|
-
const result = normalize(pick(freshEngine(), 0, 'a'));
|
|
1343
|
-
expect(optionPrice(result, 'seg-1', 'a')).toBe(500);
|
|
1344
|
-
expect(optionPrice(result, 'seg-1', 'c')).toBe(600);
|
|
1345
|
-
// Segment 2 has no selection at all — its options keep their own prices.
|
|
1346
|
-
expect(optionPrice(result, 'seg-2', 'a')).toBe(500);
|
|
1347
|
-
expect(optionPrice(result, 'seg-2', 'd')).toBe(600);
|
|
1348
|
-
});
|
|
1349
|
-
it('no selection at all: prices are re-based and nothing is raised or invented', () => {
|
|
1350
|
-
const source = freshEngine();
|
|
1351
|
-
// Legacy call (no basePrices): unchanged item is returned as is.
|
|
1352
|
-
expect((0, order_engine_1.applyChooseExpensiveSegmentPrice)(source)).toBe(source);
|
|
1353
|
-
const result = normalize(source);
|
|
1354
|
-
expect(optionPrice(result, 'seg-1', 'a')).toBe(500);
|
|
1355
|
-
expect(optionPrice(result, 'seg-1', 'c')).toBe(600);
|
|
1356
|
-
expect(optionPrice(result, 'seg-2', 'b')).toBe(500);
|
|
1357
|
-
expect(optionPrice(result, 'seg-2', 'd')).toBe(600);
|
|
1358
|
-
});
|
|
1359
|
-
it('quarters (4 segments): max over the four selected sides; switching sides re-bases', () => {
|
|
1360
|
-
const quarters = (0, halfhalf_setup_helpers_1.convertHalfHalfToItem)(makeHalfHalfSetup({
|
|
1361
|
-
upsell_price: null,
|
|
1362
|
-
segments: [
|
|
1363
|
-
{ _id: 'q-1', name: 'Quarter 1', sort_id: 1 },
|
|
1364
|
-
{ _id: 'q-2', name: 'Quarter 2', sort_id: 2 },
|
|
1365
|
-
{ _id: 'q-3', name: 'Quarter 3', sort_id: 3 },
|
|
1366
|
-
{ _id: 'q-4', name: 'Quarter 4', sort_id: 4 },
|
|
1367
|
-
],
|
|
1368
|
-
items: [
|
|
1369
|
-
{ item_id: 'a', sort_id: 1, upsell_price: null },
|
|
1370
|
-
{ item_id: 'b', sort_id: 2, upsell_price: null },
|
|
1371
|
-
{ item_id: 'c', sort_id: 3, upsell_price: null },
|
|
1372
|
-
{ item_id: 'd', sort_id: 4, upsell_price: null },
|
|
1373
|
-
],
|
|
1374
|
-
}), itemsMap4);
|
|
1375
|
-
const quarterBase = (0, order_engine_1.getOptionPriceMapFromItem)(quarters, PLATFORM);
|
|
1376
|
-
const quarterPrice = (item, segmentId, optionId) => item.modifiers.find((m) => m._id === segmentId).options.find((o) => o._id === optionId).price;
|
|
1377
|
-
let engine = freshEngine(quarters);
|
|
1378
|
-
// a/b = 1000/4 = 250, c/d = 1200/4 = 300.
|
|
1379
|
-
expect(quarterPrice(engine, 'q-1', 'a')).toBe(250);
|
|
1380
|
-
expect(quarterPrice(engine, 'q-1', 'c')).toBe(300);
|
|
1381
|
-
const picks = [
|
|
1382
|
-
['q-1', 'a'],
|
|
1383
|
-
['q-2', 'a'],
|
|
1384
|
-
['q-3', 'd'],
|
|
1385
|
-
['q-4', 'd'],
|
|
1386
|
-
];
|
|
1387
|
-
for (const [segmentId, optionId] of picks) {
|
|
1388
|
-
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, `${segmentId}_${optionId}`, true);
|
|
1389
|
-
}
|
|
1390
|
-
const mixed = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(engine, { basePrices: quarterBase });
|
|
1391
|
-
for (const segmentId of ['q-1', 'q-2']) {
|
|
1392
|
-
expect(quarterPrice(mixed, segmentId, 'a')).toBe(300);
|
|
1393
|
-
}
|
|
1394
|
-
for (const segmentId of ['q-3', 'q-4']) {
|
|
1395
|
-
expect(quarterPrice(mixed, segmentId, 'd')).toBe(300);
|
|
1396
|
-
}
|
|
1397
|
-
// All four sides cheap: everything returns to 250 (from the raised state too).
|
|
1398
|
-
for (const source of [engine, mixed]) {
|
|
1399
|
-
let cheap = source;
|
|
1400
|
-
for (const segmentId of ['q-1', 'q-2', 'q-3', 'q-4']) {
|
|
1401
|
-
cheap = (0, order_engine_1.setCheckFieldInOrderEngineItem)(cheap, `${segmentId}_a`, true);
|
|
1402
|
-
}
|
|
1403
|
-
const result = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(cheap, { basePrices: quarterBase });
|
|
1404
|
-
for (const segmentId of ['q-1', 'q-2', 'q-3', 'q-4']) {
|
|
1405
|
-
expect(quarterPrice(result, segmentId, 'a')).toBe(250);
|
|
1406
|
-
}
|
|
1407
|
-
// De-selected c/d keep their own 300.
|
|
1408
|
-
expect(quarterPrice(result, 'q-1', 'd')).toBe(300);
|
|
1409
|
-
}
|
|
1071
|
+
it('edit flow: persisted, already-raised prices are re-based from the definition', () => {
|
|
1072
|
+
const { originalPriceReferences, workingData } = buildState();
|
|
1073
|
+
// Simulate an edit line: B was charged 600 by a previous normalization.
|
|
1074
|
+
const persisted = {
|
|
1075
|
+
...workingData,
|
|
1076
|
+
modifiers: workingData.modifiers.map((modifier) => ({
|
|
1077
|
+
...modifier,
|
|
1078
|
+
options: modifier.options.map((option) => (option._id === 'b' ? { ...option, price: 600 } : option)),
|
|
1079
|
+
})),
|
|
1080
|
+
};
|
|
1081
|
+
let engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(persisted, 'seg-1_b', true);
|
|
1082
|
+
engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-2_a', true);
|
|
1083
|
+
const result = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(engine, { originalPriceReferences });
|
|
1084
|
+
// B's persisted 600 is NOT the baseline: A+B is a cheap pair (5+5).
|
|
1085
|
+
expect(priceAt(result, 'seg-1', 'b')).toBe(500);
|
|
1086
|
+
expect(priceAt(result, 'seg-2', 'a')).toBe(500);
|
|
1410
1087
|
});
|
|
1411
1088
|
});
|