Subversion Repositories SmartDukaan

package com.spice.profitmandi.web.offercircular;

import static org.junit.Assert.assertEquals;

import java.util.Arrays;
import java.util.LinkedHashSet;
import java.util.Set;

import org.junit.Test;

/**
 * Guards the product-name parsing, which decides which SKU an offer's money lands on.
 *
 * Every case here corresponds to a real mis-parse found against the Aug'26 circular.
 * They all share one root cause worth remembering: **characters and digits belonging to
 * the model name being consumed as memory or stripped as punctuation.** If a change
 * here breaks a test, the fix is almost certainly to add a word-boundary guard rather
 * than to relax the expectation.
 */
public class ProductNamesTest {

    private static Set<String> memory(String... tokens) {
        return new LinkedHashSet<>(Arrays.asList(tokens));
    }

    private static void check(String input, Set<String> expectedMemory, String expectedKey) {
        assertEquals("memory for " + input, expectedMemory, ProductNames.variantTokens(input));
        assertEquals("modelKey for " + input, expectedKey, ProductNames.modelKey(input));
    }

    /**
     * The rule: memory stated -> variant-specific; memory absent -> all variants.
     * So detecting memory correctly is what separates "this exact SKU" from
     * "every size of this model", and the OEMs use three different notations.
     */
    @Test
    public void detectsAllThreeMemoryNotations() {
        // Motorola: no unit at all. Missed before, which put a Rs.1,000 8+256 offer
        // and a Rs.2,000 12+256 offer on the SAME SKU.
        check("Edge 60 Pro (8+256)", memory("8X", "256X"), "EDGE60PRO");
        check("Edge 60) Pro (12+256", memory("12X", "256X"), "EDGE60PRO");
        // vivo: single-letter unit
        check("V60(12+256G)", memory("12X", "256X"), "V60");
        check("X300 Pro(16+512G)", memory("16X", "512X"), "X300PRO");
        // Oppo: explicit unit, and unit on both sides
        check("RENO16C 12+256GB", memory("12X", "256X"), "RENO16C");
        check("A5X(4GB+128GB)", memory("4X", "128X"), "A5X");
    }

    /** A bare 4G/5G is a network marker, never a capacity - but 4 GB of RAM is real. */
    @Test
    public void doesNotConfuseNetworkMarkerWithCapacity() {
        check("Y05(4+64G)", memory("4X", "64X"), "Y05");
        check("Reno 16C 5G (12GB 256GB)", memory("12X", "256X"), "RENO16C");
        check("Redmi Note 15 Pro 5G", memory(), "REDMINOTE15PRO");
    }

    /** Terabyte capacities must stay distinct from gigabyte ones. */
    @Test
    public void handlesTerabytes() {
        check("S26 Ultra (16/1TB)", memory("16X", "1Y"), "S26ULTRA");
        check("iPhone 17 Pro (1 TB)", memory("1Y"), "IPHONE17PRO");
        check("iPhone 17 Pro (256 GB)", memory("256X"), "IPHONE17PRO");
    }

    /**
     * A digit glued to letters is part of the name. Without word-boundary guards the
     * "5X" inside A5X read as 5 GB and collapsed the key to "A", making Oppo A5X and
     * A6X indistinguishable.
     */
    @Test
    public void doesNotEatDigitsOutOfModelNames() {
        assertEquals("A5X", ProductNames.modelKey("A5X(4GB+128GB)"));
        assertEquals("A6X", ProductNames.modelKey("A6X(6GB+128GB)"));
        assertEquals("XFOLD5", ProductNames.modelKey("X Fold5(16+512G)"));
    }

    /**
     * '+' in a model name is significant. Stripping it as punctuation made
     * "Realme 16 Pro" and "Realme 16 Pro+" the same key and cross-matched 6 SKUs
     * across 12 offers - 1,188 false collisions from one character.
     */
    @Test
    public void keepsModelNamePlusSignificant() {
        assertEquals("16PRO", ProductNames.modelKey("Realme 16 Pro"));
        assertEquals("16PROPLUS", ProductNames.modelKey("Realme 16 Pro+"));
        assertEquals("16PRO", ProductNames.modelKey("Realme 16 Pro 5G (8GB 256GB)"));
        assertEquals("16PROPLUS", ProductNames.modelKey("Realme 16 Pro+ 5G (8GB 256GB)"));
        assertEquals("REDMINOTE15PRO", ProductNames.modelKey("Redmi Note 15 Pro 5G"));
        assertEquals("REDMINOTE15PROPLUS", ProductNames.modelKey("Redmi Note 15 Pro+ 5G"));
    }

    /**
     * The circular writes "S25+" while the catalog writes "S25 Plus" - the same phone,
     * so they MUST converge. And all three must stay distinct from plain S25.
     * "S25+ 5G" once keyed as "S25X" and then "SG" while these guards were incomplete.
     */
    @Test
    public void s25PlusAndS25PlusSpelledOutAreTheSamePhone() {
        assertEquals("S25PLUS", ProductNames.modelKey("S25+ (12/256GB)"));
        assertEquals("S25PLUS", ProductNames.modelKey("S25 Plus (12GB 256GB)"));
        assertEquals("S25PLUS", ProductNames.modelKey("S25+ 5G (12GB 256GB)"));

        assertEquals("S25", ProductNames.modelKey("S25 (12/128 GB)"));
        assertEquals("S25ULTRA", ProductNames.modelKey("S25 Ultra (12/512GB)"));
        assertEquals("S25FE", ProductNames.modelKey("S25 FE (128GB)"));
        assertEquals("S25EDGE", ProductNames.modelKey("S25 Edge (12/256GB)"));
    }

    /**
     * Spaces are insignificant so the circular's "RENO16C" matches the catalog's
     * "Reno 16C 5G"; digits are significant so a one-token difference never matches.
     */
    @Test
    public void spacesInsignificantDigitsSignificant() {
        assertEquals(ProductNames.modelKey("RENO16C 12+256GB"),
                ProductNames.modelKey("Reno 16C 5G (12GB 256GB)"));
        assertEquals("IPHONE17E", ProductNames.modelKey("iPhone 17e"));
        assertEquals("IPHONE7", ProductNames.modelKey("iPhone 7"));
    }

    /** WIFI/LTE are NOT noise: for tablets they are the only variant discriminator. */
    @Test
    public void keepsConnectivityDistinctForTablets() {
        assertEquals("TABS11ULTRAWIFI",
                ProductNames.modelKey("Tab S11 Ultra Wifi (12/256GB)"));
        assertEquals("TABS11ULTRALTE",
                ProductNames.modelKey("Tab S11 Ultra LTE (12/256GB)"));
    }

    /**
     * Splitting must never cut through a variant spec - doing so invented a phantom
     * product literally called "256GB" - and trailing variant-only fragments inherit
     * the preceding model name.
     */
    @Test
    public void splitsMultiProductCellsWithoutCuttingVariants() {
        assertEquals(Arrays.asList("Tab S11 Ultra Wifi (12/256GB)",
                        "Tab S11 Ultra Wifi (12/512GB)"),
                ProductNames.split(
                        "Tab S11 Ultra Wifi (12/256GB)/Tab S11 Ultra Wifi (12/512GB)"));

        assertEquals(Arrays.asList("RENO16C 12+256GB", "RENO16C 8+256GB", "RENO16C 8+128GB"),
                ProductNames.split("RENO16C 12+256GB, 8+256GB, 8+128GB"));

        // two products run together with no delimiter at all
        assertEquals(Arrays.asList("A37 5G (8GB/128GB)", "A37 5G (12GB/256GB)"),
                ProductNames.split("A37 5G (8GB/128GB)A37 5G (12GB/256GB)"));
    }

    /**
     * A comma-separated part that starts with a LETTER is a product, never a memory
     * spec, however many digits and G/T characters follow it.
     *
     * VARIANT_ONLY's unit group used to be reachable at position 0, so the "G" of a
     * Motorola G-series name read as the unit and "06"/"37" fell through the trailing
     * class. "G06, G37 , G37 Power" then collapsed to two entities - "G06" and
     * "G06 G37" - and G37, a real catalog SKU, lost its cashback on five offers.
     * Realme "GT 7" matched identically and escaped only by never following a comma.
     */
    @Test
    public void keepsLetterLedModelNamesOutOfVariantInheritance() {
        assertEquals(Arrays.asList("G06", "G37", "G37 Power"),
                ProductNames.split("G06, G37 , G37 Power"));

        assertEquals(Arrays.asList("GT 7T", "GT 7"),
                ProductNames.split("GT 7T, GT 7"));

        assertEquals(Arrays.asList("G06", "G37", "G37 Power", "G77 Power", "G Max",
                        "Edge 70 Fusion (12/256)", "Edge 60 Pro (8+256)"),
                ProductNames.split("G06, G37, G37 Power , G77 Power, G Max ,"
                        + " Edge 70 Fusion (12/256) , Edge 60 Pro (8+256)"));

        // and the inheritance it guards must still fire for genuine memory specs
        assertEquals(Arrays.asList("RENO 15 PRO 256GB", "RENO 15 PRO 512GB"),
                ProductNames.split("RENO 15 PRO 256GB, 512GB"));
        assertEquals(Arrays.asList("F33 6+128GB", "F33 8+128GB", "F33 8+256GB"),
                ProductNames.split("F33 6+128GB, 8+128GB, 8+256GB"));
    }

    /**
     * Two variant groups written back-to-back are two variants of one model. Merged,
     * their memory tokens ran together and the offer bound to one arbitrary SKU while
     * the other variant silently got nothing - money on the wrong SKU, same failure
     * class as the missing-unit bug.
     */
    @Test
    public void splitsAdjacentVariantGroupsIntoSeparateProducts() {
        assertEquals(Arrays.asList("Edge 70 Pro (8+256)", "Edge 70 Pro 12+256"),
                ProductNames.split("Edge 70 Pro (8+256)(12+256)"));
        assertEquals(Arrays.asList("G37 Power (4+64)", "G37 Power 4+128"),
                ProductNames.split("G37 Power (4+64)(4+128)"));
        assertEquals(Arrays.asList("A6 (6+128GB)", "A6 4+128GB"),
                ProductNames.split("A6 (6+128GB)(4+128GB)"));

        // a '/' between the groups is already a split point and must stay one
        assertEquals(Arrays.asList("X300 FE(12+512G)", "X300 FE 12+256G"),
                ProductNames.split("X300 FE(12+512G)/(12+256G)"));
    }

    /**
     * A bundled accessory suffix must SURVIVE splitting, so the bundle stays a distinct
     * product from the bare phone.
     *
     * Stripping it was implemented and reverted: it resolved 30 CATALOG_GAP rows, but on
     * Aug'26 vivo caps X300 Pro(16+512G) at Rs.10,000 on its own row and Rs.11,000 on the
     * "+Extender" row - the difference being the Extender. Merging them lets the bundle's
     * cap be claimed on a phone sold without the accessory, which is money on the wrong
     * SKU. Whether a bundle offer transfers to the bare SKU is a commercial question the
     * PDF does not answer, so it is a manual coverage decision, not a parsing rule.
     */
    @Test
    public void keepsBundledAccessoryDistinctFromTheBarePhone() {
        assertEquals(Arrays.asList("RENO16C 12+256GB +Bubble"),
                ProductNames.split("RENO16C 12+256GB +Bubble"));
        assertEquals(Arrays.asList("X300 Pro(16+512G)+Extender"),
                ProductNames.split("X300 Pro(16+512G)+Extender"));

        // and the bare phone in the same cell stays separate from the bundled one
        assertEquals(Arrays.asList("X300 Pro(16+512G)", "X300 Pro(16+512G)+Extender"),
                ProductNames.split("X300 Pro(16+512G), X300 Pro(16+512G)+Extender"));

        // standalone accessories are whole product names, never truncated to a phone;
        // they are removed as IGNORE aliases instead
        assertEquals(Arrays.asList("X300 FE Telephoto Extender"),
                ProductNames.split("X300 FE Telephoto Extender"));
        assertEquals(Arrays.asList("Moto Buds 2"), ProductNames.split("Moto Buds 2"));
    }
}