@adtrackify/at-service-common 4.0.4 → 4.0.5

package/dist/esm/__tests__/services/cost/cost-filter-service.spec.js

@@ -1,467 +1,467 @@
-import { COST_FILTER_MODE } from '@adtrackify/at-tracking-event-types';
-import { CostFilterService } from '../../../services/cost/cost-filter-service';
-jest.mock('../../../helpers/logging-helper', () => ({
-    Logger: { debug: jest.fn(), info: jest.fn(), warn: jest.fn(), error: jest.fn() },
-}));
-const createOrderContext = (overrides = {}) => ({
-    tags: [],
-    paymentGateways: [],
-    shippingTitles: [],
-    ...overrides,
-});
-const createLineItemContext = (overrides = {}) => ({
-    tags: [],
-    productId: '123',
-    variantId: '456',
-    ...overrides,
-});
-describe('CostFilterService', () => {
-    describe('matchSingleFilter', () => {
-        it('should return true for ALL mode regardless of value', () => {
-            const filter = { mode: COST_FILTER_MODE.ALL, values: ['a'] };
-            expect(CostFilterService.matchSingleFilter(filter, 'anything')).toBe(true);
-            expect(CostFilterService.matchSingleFilter(filter, undefined)).toBe(true);
-        });
-        it('should return true for INCLUDE when value matches', () => {
-            const filter = { mode: COST_FILTER_MODE.INCLUDE, values: ['stripe', 'paypal'] };
-            expect(CostFilterService.matchSingleFilter(filter, 'stripe')).toBe(true);
-        });
-        it('should return false for INCLUDE when value does not match', () => {
-            const filter = { mode: COST_FILTER_MODE.INCLUDE, values: ['stripe', 'paypal'] };
-            expect(CostFilterService.matchSingleFilter(filter, 'braintree')).toBe(false);
-        });
-        it('should return false for INCLUDE when value is undefined', () => {
-            const filter = { mode: COST_FILTER_MODE.INCLUDE, values: ['stripe'] };
-            expect(CostFilterService.matchSingleFilter(filter, undefined)).toBe(false);
-        });
-        it('should return true for EXCLUDE when value does not match', () => {
-            const filter = { mode: COST_FILTER_MODE.EXCLUDE, values: ['stripe'] };
-            expect(CostFilterService.matchSingleFilter(filter, 'paypal')).toBe(true);
-        });
-        it('should return false for EXCLUDE when value matches', () => {
-            const filter = { mode: COST_FILTER_MODE.EXCLUDE, values: ['stripe'] };
-            expect(CostFilterService.matchSingleFilter(filter, 'stripe')).toBe(false);
-        });
-        it('should return true for EXCLUDE when value is undefined', () => {
-            const filter = { mode: COST_FILTER_MODE.EXCLUDE, values: ['stripe'] };
-            expect(CostFilterService.matchSingleFilter(filter, undefined)).toBe(true);
-        });
-        it('should be case-insensitive', () => {
-            const filter = { mode: COST_FILTER_MODE.INCLUDE, values: ['Stripe'] };
-            expect(CostFilterService.matchSingleFilter(filter, 'STRIPE')).toBe(true);
-            expect(CostFilterService.matchSingleFilter(filter, 'stripe')).toBe(true);
-        });
-    });
-    describe('matchArrayFilter', () => {
-        it('should return true for ALL mode', () => {
-            const filter = { mode: COST_FILTER_MODE.ALL, values: ['a'] };
-            expect(CostFilterService.matchArrayFilter(filter, ['anything'])).toBe(true);
-            expect(CostFilterService.matchArrayFilter(filter, undefined)).toBe(true);
-        });
-        it('should return true for INCLUDE when any value matches', () => {
-            const filter = { mode: COST_FILTER_MODE.INCLUDE, values: ['vip', 'priority'] };
-            expect(CostFilterService.matchArrayFilter(filter, ['vip', 'other'])).toBe(true);
-        });
-        it('should return false for INCLUDE when no value matches', () => {
-            const filter = { mode: COST_FILTER_MODE.INCLUDE, values: ['vip', 'priority'] };
-            expect(CostFilterService.matchArrayFilter(filter, ['regular', 'other'])).toBe(false);
-        });
-        it('should return false for INCLUDE when values is empty', () => {
-            const filter = { mode: COST_FILTER_MODE.INCLUDE, values: ['vip'] };
-            expect(CostFilterService.matchArrayFilter(filter, [])).toBe(false);
-        });
-        it('should return false for INCLUDE when values is undefined', () => {
-            const filter = { mode: COST_FILTER_MODE.INCLUDE, values: ['vip'] };
-            expect(CostFilterService.matchArrayFilter(filter, undefined)).toBe(false);
-        });
-        it('should return true for EXCLUDE when no value matches', () => {
-            const filter = { mode: COST_FILTER_MODE.EXCLUDE, values: ['vip'] };
-            expect(CostFilterService.matchArrayFilter(filter, ['regular'])).toBe(true);
-        });
-        it('should return false for EXCLUDE when any value matches', () => {
-            const filter = { mode: COST_FILTER_MODE.EXCLUDE, values: ['vip'] };
-            expect(CostFilterService.matchArrayFilter(filter, ['vip', 'regular'])).toBe(false);
-        });
-        it('should return true for EXCLUDE when values is empty', () => {
-            const filter = { mode: COST_FILTER_MODE.EXCLUDE, values: ['vip'] };
-            expect(CostFilterService.matchArrayFilter(filter, [])).toBe(true);
-        });
-        it('should return true for EXCLUDE when values is undefined', () => {
-            const filter = { mode: COST_FILTER_MODE.EXCLUDE, values: ['vip'] };
-            expect(CostFilterService.matchArrayFilter(filter, undefined)).toBe(true);
-        });
-        it('should be case-insensitive', () => {
-            const filter = { mode: COST_FILTER_MODE.INCLUDE, values: ['VIP'] };
-            expect(CostFilterService.matchArrayFilter(filter, ['vip'])).toBe(true);
-        });
-    });
-    describe('matchProductFilter', () => {
-        it('should return true for ALL mode', () => {
-            const filter = { mode: COST_FILTER_MODE.ALL, values: ['123'] };
-            expect(CostFilterService.matchProductFilter(filter, '999', '888')).toBe(true);
-        });
-        it('should match by productId only', () => {
-            const filter = { mode: COST_FILTER_MODE.INCLUDE, values: ['123'] };
-            expect(CostFilterService.matchProductFilter(filter, '123', '456')).toBe(true);
-        });
-        it('should match by productId_variantId', () => {
-            const filter = { mode: COST_FILTER_MODE.INCLUDE, values: ['123_456'] };
-            expect(CostFilterService.matchProductFilter(filter, '123', '456')).toBe(true);
-        });
-        it('should not match wrong productId_variantId', () => {
-            const filter = { mode: COST_FILTER_MODE.INCLUDE, values: ['123_789'] };
-            expect(CostFilterService.matchProductFilter(filter, '123', '456')).toBe(false);
-        });
-        it('should return false for INCLUDE when productId is empty', () => {
-            const filter = { mode: COST_FILTER_MODE.INCLUDE, values: ['123'] };
-            expect(CostFilterService.matchProductFilter(filter, '', '456')).toBe(false);
-        });
-        it('should return true for EXCLUDE when productId is empty', () => {
-            const filter = { mode: COST_FILTER_MODE.EXCLUDE, values: ['123'] };
-            expect(CostFilterService.matchProductFilter(filter, '', '456')).toBe(true);
-        });
-        it('should return true for EXCLUDE when product does not match', () => {
-            const filter = { mode: COST_FILTER_MODE.EXCLUDE, values: ['123'] };
-            expect(CostFilterService.matchProductFilter(filter, '999', '456')).toBe(true);
-        });
-        it('should return false for EXCLUDE when product matches', () => {
-            const filter = { mode: COST_FILTER_MODE.EXCLUDE, values: ['123'] };
-            expect(CostFilterService.matchProductFilter(filter, '123', '456')).toBe(false);
-        });
-        it('should handle mixed productId and productId_variantId filter values', () => {
-            const filter = { mode: COST_FILTER_MODE.INCLUDE, values: ['100', '200_300'] };
-            expect(CostFilterService.matchProductFilter(filter, '100', '999')).toBe(true);
-            expect(CostFilterService.matchProductFilter(filter, '200', '300')).toBe(true);
-            expect(CostFilterService.matchProductFilter(filter, '200', '999')).toBe(false);
-        });
-    });
-    describe('matchesFilters', () => {
-        it('should return true when filters is undefined', () => {
-            expect(CostFilterService.matchesFilters(undefined, createOrderContext(), null)).toBe(true);
-        });
-        it('should return true when filters is empty object', () => {
-            expect(CostFilterService.matchesFilters({}, createOrderContext(), null)).toBe(true);
-        });
-        it('should check orderTags filter', () => {
-            const filters = {
-                orderTags: { mode: COST_FILTER_MODE.INCLUDE, values: ['vip'] },
-            };
-            expect(CostFilterService.matchesFilters(filters, createOrderContext({ tags: ['vip', 'sale'] }), null)).toBe(true);
-            expect(CostFilterService.matchesFilters(filters, createOrderContext({ tags: ['regular'] }), null)).toBe(false);
-        });
-        it('should check orderSourceNames filter', () => {
-            const filters = {
-                orderSourceNames: { mode: COST_FILTER_MODE.INCLUDE, values: ['web'] },
-            };
-            expect(CostFilterService.matchesFilters(filters, createOrderContext({ sourceName: 'web' }), null)).toBe(true);
-            expect(CostFilterService.matchesFilters(filters, createOrderContext({ sourceName: 'pos' }), null)).toBe(false);
-        });
-        it('should check orderPaymentGateways filter', () => {
-            const filters = {
-                orderPaymentGateways: { mode: COST_FILTER_MODE.INCLUDE, values: ['stripe'] },
-            };
-            expect(CostFilterService.matchesFilters(filters, createOrderContext({ paymentGateways: ['stripe', 'shop_pay'] }), null)).toBe(true);
-            expect(CostFilterService.matchesFilters(filters, createOrderContext({ paymentGateways: ['paypal'] }), null)).toBe(false);
-        });
-        it('should check orderShippingTitles filter', () => {
-            const filters = {
-                orderShippingTitles: { mode: COST_FILTER_MODE.INCLUDE, values: ['Standard'] },
-            };
-            expect(CostFilterService.matchesFilters(filters, createOrderContext({ shippingTitles: ['Standard'] }), null)).toBe(true);
-            expect(CostFilterService.matchesFilters(filters, createOrderContext({ shippingTitles: ['Express'] }), null)).toBe(false);
-        });
-        it('should check countries filter', () => {
-            const filters = {
-                countries: { mode: COST_FILTER_MODE.INCLUDE, values: ['US', 'CA'] },
-            };
-            expect(CostFilterService.matchesFilters(filters, createOrderContext({ shipCountryCode: 'US' }), null)).toBe(true);
-            expect(CostFilterService.matchesFilters(filters, createOrderContext({ shipCountryCode: 'GB' }), null)).toBe(false);
-        });
-        it('should use AND logic between multiple order filters', () => {
-            const filters = {
-                orderTags: { mode: COST_FILTER_MODE.INCLUDE, values: ['vip'] },
-                countries: { mode: COST_FILTER_MODE.INCLUDE, values: ['US'] },
-            };
-            expect(CostFilterService.matchesFilters(filters, createOrderContext({ tags: ['vip'], shipCountryCode: 'US' }), null)).toBe(true);
-            expect(CostFilterService.matchesFilters(filters, createOrderContext({ tags: ['vip'], shipCountryCode: 'GB' }), null)).toBe(false);
-            expect(CostFilterService.matchesFilters(filters, createOrderContext({ tags: ['regular'], shipCountryCode: 'US' }), null)).toBe(false);
-        });
-        it('should skip product filters when lineItem is null and no lineItems array provided', () => {
-            const filters = {
-                productVendors: { mode: COST_FILTER_MODE.INCLUDE, values: ['Nike'] },
-            };
-            expect(CostFilterService.matchesFilters(filters, createOrderContext(), null)).toBe(true);
-        });
-        it('should check productVendors filter', () => {
-            const filters = {
-                productVendors: { mode: COST_FILTER_MODE.INCLUDE, values: ['Nike'] },
-            };
-            expect(CostFilterService.matchesFilters(filters, createOrderContext(), createLineItemContext({ vendor: 'Nike' }))).toBe(true);
-            expect(CostFilterService.matchesFilters(filters, createOrderContext(), createLineItemContext({ vendor: 'Adidas' }))).toBe(false);
-        });
-        it('should check productTypes filter', () => {
-            const filters = {
-                productTypes: { mode: COST_FILTER_MODE.INCLUDE, values: ['Shoes'] },
-            };
-            expect(CostFilterService.matchesFilters(filters, createOrderContext(), createLineItemContext({ productType: 'Shoes' }))).toBe(true);
-            expect(CostFilterService.matchesFilters(filters, createOrderContext(), createLineItemContext({ productType: 'Hats' }))).toBe(false);
-        });
-        it('should check productTags filter', () => {
-            const filters = {
-                productTags: { mode: COST_FILTER_MODE.INCLUDE, values: ['sale'] },
-            };
-            expect(CostFilterService.matchesFilters(filters, createOrderContext(), createLineItemContext({ tags: ['sale', 'new'] }))).toBe(true);
-            expect(CostFilterService.matchesFilters(filters, createOrderContext(), createLineItemContext({ tags: ['clearance'] }))).toBe(false);
-        });
-        it('should check productCategories filter', () => {
-            const filters = {
-                productCategories: { mode: COST_FILTER_MODE.INCLUDE, values: ['Apparel > Shoes'] },
-            };
-            expect(CostFilterService.matchesFilters(filters, createOrderContext(), createLineItemContext({ category: 'Apparel > Shoes' }))).toBe(true);
-            expect(CostFilterService.matchesFilters(filters, createOrderContext(), createLineItemContext({ category: 'Electronics' }))).toBe(false);
-        });
-        it('should check products filter', () => {
-            const filters = {
-                products: { mode: COST_FILTER_MODE.INCLUDE, values: ['123'] },
-            };
-            expect(CostFilterService.matchesFilters(filters, createOrderContext(), createLineItemContext({ productId: '123', variantId: '456' }))).toBe(true);
-            expect(CostFilterService.matchesFilters(filters, createOrderContext(), createLineItemContext({ productId: '999', variantId: '456' }))).toBe(false);
-        });
-        it('should require both order and line-item filters to pass', () => {
-            const filters = {
-                countries: { mode: COST_FILTER_MODE.INCLUDE, values: ['US'] },
-                productVendors: { mode: COST_FILTER_MODE.INCLUDE, values: ['Nike'] },
-            };
-            expect(CostFilterService.matchesFilters(filters, createOrderContext({ shipCountryCode: 'US' }), createLineItemContext({ vendor: 'Nike' }))).toBe(true);
-            expect(CostFilterService.matchesFilters(filters, createOrderContext({ shipCountryCode: 'US' }), createLineItemContext({ vendor: 'Adidas' }))).toBe(false);
-            expect(CostFilterService.matchesFilters(filters, createOrderContext({ shipCountryCode: 'GB' }), createLineItemContext({ vendor: 'Nike' }))).toBe(false);
-        });
-        it('should handle all 5 order + all 5 line-item filters passing', () => {
-            const filters = {
-                orderTags: { mode: COST_FILTER_MODE.INCLUDE, values: ['vip'] },
-                orderSourceNames: { mode: COST_FILTER_MODE.INCLUDE, values: ['web'] },
-                orderPaymentGateways: { mode: COST_FILTER_MODE.INCLUDE, values: ['stripe'] },
-                orderShippingTitles: { mode: COST_FILTER_MODE.INCLUDE, values: ['Standard'] },
-                countries: { mode: COST_FILTER_MODE.INCLUDE, values: ['US'] },
-                productVendors: { mode: COST_FILTER_MODE.INCLUDE, values: ['Nike'] },
-                productTypes: { mode: COST_FILTER_MODE.INCLUDE, values: ['Shoes'] },
-                productTags: { mode: COST_FILTER_MODE.INCLUDE, values: ['sale'] },
-                productCategories: { mode: COST_FILTER_MODE.INCLUDE, values: ['Apparel'] },
-                products: { mode: COST_FILTER_MODE.INCLUDE, values: ['123'] },
-            };
-            const order = createOrderContext({
-                tags: ['vip'],
-                sourceName: 'web',
-                paymentGateways: ['stripe'],
-                shippingTitles: ['Standard'],
-                shipCountryCode: 'US',
-            });
-            const lineItem = createLineItemContext({
-                vendor: 'Nike',
-                productType: 'Shoes',
-                tags: ['sale'],
-                category: 'Apparel',
-                productId: '123',
-                variantId: '456',
-            });
-            expect(CostFilterService.matchesFilters(filters, order, lineItem)).toBe(true);
-        });
-        it('should handle EXCLUDE mode for order tags', () => {
-            const filters = {
-                orderTags: { mode: COST_FILTER_MODE.EXCLUDE, values: ['test'] },
-            };
-            expect(CostFilterService.matchesFilters(filters, createOrderContext({ tags: ['vip'] }), null)).toBe(true);
-            expect(CostFilterService.matchesFilters(filters, createOrderContext({ tags: ['test'] }), null)).toBe(false);
-        });
-        it('should handle mixed INCLUDE and EXCLUDE filters', () => {
-            const filters = {
-                countries: { mode: COST_FILTER_MODE.INCLUDE, values: ['US'] },
-                orderTags: { mode: COST_FILTER_MODE.EXCLUDE, values: ['test'] },
-            };
-            expect(CostFilterService.matchesFilters(filters, createOrderContext({ shipCountryCode: 'US', tags: ['vip'] }), null)).toBe(true);
-            expect(CostFilterService.matchesFilters(filters, createOrderContext({ shipCountryCode: 'US', tags: ['test'] }), null)).toBe(false);
-            expect(CostFilterService.matchesFilters(filters, createOrderContext({ shipCountryCode: 'GB', tags: ['vip'] }), null)).toBe(false);
-        });
-        it('should evaluate product filters against lineItems array when lineItem is null', () => {
-            const filters = {
-                productVendors: { mode: COST_FILTER_MODE.INCLUDE, values: ['Nike'] },
-            };
-            const lineItems = [
-                createLineItemContext({ vendor: 'Adidas' }),
-                createLineItemContext({ vendor: 'Nike' }),
-            ];
-            expect(CostFilterService.matchesFilters(filters, createOrderContext(), null, lineItems)).toBe(true);
-        });
-        it('should return false when no lineItem matches product filters via lineItems array', () => {
-            const filters = {
-                productVendors: { mode: COST_FILTER_MODE.INCLUDE, values: ['Nike'] },
-            };
-            const lineItems = [
-                createLineItemContext({ vendor: 'Adidas' }),
-                createLineItemContext({ vendor: 'Puma' }),
-            ];
-            expect(CostFilterService.matchesFilters(filters, createOrderContext(), null, lineItems)).toBe(false);
-        });
-        it('should evaluate products filter against lineItems array', () => {
-            const filters = {
-                products: { mode: COST_FILTER_MODE.INCLUDE, values: ['P100'] },
-            };
-            const matching = [createLineItemContext({ productId: 'P100', variantId: 'V1' })];
-            const nonMatching = [createLineItemContext({ productId: 'P999', variantId: 'V1' })];
-            expect(CostFilterService.matchesFilters(filters, createOrderContext(), null, matching)).toBe(true);
-            expect(CostFilterService.matchesFilters(filters, createOrderContext(), null, nonMatching)).toBe(false);
-        });
-        it('should evaluate productTags filter against lineItems array', () => {
-            const filters = {
-                productTags: { mode: COST_FILTER_MODE.INCLUDE, values: ['fragile'] },
-            };
-            const matching = [createLineItemContext({ tags: ['fragile', 'heavy'] })];
-            const nonMatching = [createLineItemContext({ tags: ['lightweight'] })];
-            expect(CostFilterService.matchesFilters(filters, createOrderContext(), null, matching)).toBe(true);
-            expect(CostFilterService.matchesFilters(filters, createOrderContext(), null, nonMatching)).toBe(false);
-        });
-        it('should evaluate productTypes filter against lineItems array', () => {
-            const filters = {
-                productTypes: { mode: COST_FILTER_MODE.INCLUDE, values: ['Electronics'] },
-            };
-            const matching = [createLineItemContext({ productType: 'Electronics' })];
-            const nonMatching = [createLineItemContext({ productType: 'Clothing' })];
-            expect(CostFilterService.matchesFilters(filters, createOrderContext(), null, matching)).toBe(true);
-            expect(CostFilterService.matchesFilters(filters, createOrderContext(), null, nonMatching)).toBe(false);
-        });
-        it('should evaluate productCategories filter against lineItems array', () => {
-            const filters = {
-                productCategories: { mode: COST_FILTER_MODE.INCLUDE, values: ['Home > Kitchen'] },
-            };
-            const matching = [createLineItemContext({ category: 'Home > Kitchen' })];
-            const nonMatching = [createLineItemContext({ category: 'Sports' })];
-            expect(CostFilterService.matchesFilters(filters, createOrderContext(), null, matching)).toBe(true);
-            expect(CostFilterService.matchesFilters(filters, createOrderContext(), null, nonMatching)).toBe(false);
-        });
-        it('should evaluate EXCLUDE product filters against lineItems array', () => {
-            const filters = {
-                productVendors: { mode: COST_FILTER_MODE.EXCLUDE, values: ['Nike'] },
-            };
-            const mixed = [
-                createLineItemContext({ vendor: 'Adidas' }),
-                createLineItemContext({ vendor: 'Nike' }),
-            ];
-            expect(CostFilterService.matchesFilters(filters, createOrderContext(), null, mixed)).toBe(true);
-            const allNike = [
-                createLineItemContext({ vendor: 'Nike' }),
-                createLineItemContext({ vendor: 'Nike' }),
-            ];
-            expect(CostFilterService.matchesFilters(filters, createOrderContext(), null, allNike)).toBe(false);
-        });
-        it('should combine order filters + product filters via lineItems array', () => {
-            const filters = {
-                countries: { mode: COST_FILTER_MODE.INCLUDE, values: ['US'] },
-                productVendors: { mode: COST_FILTER_MODE.INCLUDE, values: ['Nike'] },
-            };
-            const lineItems = [createLineItemContext({ vendor: 'Nike' })];
-            expect(CostFilterService.matchesFilters(filters, createOrderContext({ shipCountryCode: 'US' }), null, lineItems)).toBe(true);
-            expect(CostFilterService.matchesFilters(filters, createOrderContext({ shipCountryCode: 'GB' }), null, lineItems)).toBe(false);
-            const noMatch = [createLineItemContext({ vendor: 'Adidas' })];
-            expect(CostFilterService.matchesFilters(filters, createOrderContext({ shipCountryCode: 'US' }), null, noMatch)).toBe(false);
-        });
-        it('should combine multiple product filters with AND logic via lineItems array', () => {
-            const filters = {
-                productVendors: { mode: COST_FILTER_MODE.INCLUDE, values: ['Nike'] },
-                productTypes: { mode: COST_FILTER_MODE.INCLUDE, values: ['Shoes'] },
-            };
-            const bothMatch = [createLineItemContext({ vendor: 'Nike', productType: 'Shoes' })];
-            expect(CostFilterService.matchesFilters(filters, createOrderContext(), null, bothMatch)).toBe(true);
-            const partialMatch = [createLineItemContext({ vendor: 'Nike', productType: 'Hats' })];
-            expect(CostFilterService.matchesFilters(filters, createOrderContext(), null, partialMatch)).toBe(false);
-            const mixed = [
-                createLineItemContext({ vendor: 'Adidas', productType: 'Hats' }),
-                createLineItemContext({ vendor: 'Nike', productType: 'Shoes' }),
-            ];
-            expect(CostFilterService.matchesFilters(filters, createOrderContext(), null, mixed)).toBe(true);
-        });
-        it('should return true when lineItems array is empty and product filters exist', () => {
-            const filters = {
-                productVendors: { mode: COST_FILTER_MODE.INCLUDE, values: ['Nike'] },
-            };
-            expect(CostFilterService.matchesFilters(filters, createOrderContext(), null, [])).toBe(true);
-        });
-        it('should not use lineItems array when lineItem is provided (single lineItem takes precedence)', () => {
-            const filters = {
-                productVendors: { mode: COST_FILTER_MODE.INCLUDE, values: ['Nike'] },
-            };
-            const lineItem = createLineItemContext({ vendor: 'Adidas' });
-            const lineItems = [createLineItemContext({ vendor: 'Nike' })];
-            expect(CostFilterService.matchesFilters(filters, createOrderContext(), lineItem, lineItems)).toBe(false);
-        });
-    });
-    describe('hasProductFilters', () => {
-        it('should return false for undefined filters', () => {
-            expect(CostFilterService.hasProductFilters(undefined)).toBe(false);
-        });
-        it('should return false for empty filters', () => {
-            expect(CostFilterService.hasProductFilters({})).toBe(false);
-        });
-        it('should return false for order-only filters', () => {
-            const filters = {
-                orderTags: { mode: COST_FILTER_MODE.INCLUDE, values: ['vip'] },
-                countries: { mode: COST_FILTER_MODE.INCLUDE, values: ['US'] },
-            };
-            expect(CostFilterService.hasProductFilters(filters)).toBe(false);
-        });
-        it('should return true for productVendors', () => {
-            expect(CostFilterService.hasProductFilters({ productVendors: { mode: COST_FILTER_MODE.INCLUDE, values: ['Nike'] } })).toBe(true);
-        });
-        it('should return true for productTypes', () => {
-            expect(CostFilterService.hasProductFilters({ productTypes: { mode: COST_FILTER_MODE.INCLUDE, values: ['Shoes'] } })).toBe(true);
-        });
-        it('should return true for productTags', () => {
-            expect(CostFilterService.hasProductFilters({ productTags: { mode: COST_FILTER_MODE.INCLUDE, values: ['sale'] } })).toBe(true);
-        });
-        it('should return true for productCategories', () => {
-            expect(CostFilterService.hasProductFilters({ productCategories: { mode: COST_FILTER_MODE.INCLUDE, values: ['Apparel'] } })).toBe(true);
-        });
-        it('should return true for products', () => {
-            expect(CostFilterService.hasProductFilters({ products: { mode: COST_FILTER_MODE.INCLUDE, values: ['123'] } })).toBe(true);
-        });
-    });
-    describe('matchLineItemFilters', () => {
-        it('should return true when no product filters defined', () => {
-            expect(CostFilterService.matchLineItemFilters({}, createLineItemContext())).toBe(true);
-        });
-        it('should check productVendors', () => {
-            const filters = { productVendors: { mode: COST_FILTER_MODE.INCLUDE, values: ['Nike'] } };
-            expect(CostFilterService.matchLineItemFilters(filters, createLineItemContext({ vendor: 'Nike' }))).toBe(true);
-            expect(CostFilterService.matchLineItemFilters(filters, createLineItemContext({ vendor: 'Adidas' }))).toBe(false);
-        });
-        it('should check productTypes', () => {
-            const filters = { productTypes: { mode: COST_FILTER_MODE.INCLUDE, values: ['Shoes'] } };
-            expect(CostFilterService.matchLineItemFilters(filters, createLineItemContext({ productType: 'Shoes' }))).toBe(true);
-            expect(CostFilterService.matchLineItemFilters(filters, createLineItemContext({ productType: 'Hats' }))).toBe(false);
-        });
-        it('should check productTags', () => {
-            const filters = { productTags: { mode: COST_FILTER_MODE.INCLUDE, values: ['sale'] } };
-            expect(CostFilterService.matchLineItemFilters(filters, createLineItemContext({ tags: ['sale'] }))).toBe(true);
-            expect(CostFilterService.matchLineItemFilters(filters, createLineItemContext({ tags: ['clearance'] }))).toBe(false);
-        });
-        it('should check productCategories', () => {
-            const filters = { productCategories: { mode: COST_FILTER_MODE.INCLUDE, values: ['Apparel'] } };
-            expect(CostFilterService.matchLineItemFilters(filters, createLineItemContext({ category: 'Apparel' }))).toBe(true);
-            expect(CostFilterService.matchLineItemFilters(filters, createLineItemContext({ category: 'Electronics' }))).toBe(false);
-        });
-        it('should check products', () => {
-            const filters = { products: { mode: COST_FILTER_MODE.INCLUDE, values: ['123'] } };
-            expect(CostFilterService.matchLineItemFilters(filters, createLineItemContext({ productId: '123' }))).toBe(true);
-            expect(CostFilterService.matchLineItemFilters(filters, createLineItemContext({ productId: '999' }))).toBe(false);
-        });
-        it('should use AND logic across all product filters', () => {
-            const filters = {
-                productVendors: { mode: COST_FILTER_MODE.INCLUDE, values: ['Nike'] },
-                productTypes: { mode: COST_FILTER_MODE.INCLUDE, values: ['Shoes'] },
-                productTags: { mode: COST_FILTER_MODE.INCLUDE, values: ['sale'] },
-            };
-            expect(CostFilterService.matchLineItemFilters(filters, createLineItemContext({ vendor: 'Nike', productType: 'Shoes', tags: ['sale'] }))).toBe(true);
-            expect(CostFilterService.matchLineItemFilters(filters, createLineItemContext({ vendor: 'Nike', productType: 'Hats', tags: ['sale'] }))).toBe(false);
-        });
-    });
-});
+import { COST_FILTER_MODE } from '@adtrackify/at-tracking-event-types';
+import { CostFilterService } from '../../../services/cost/cost-filter-service';
+jest.mock('../../../helpers/logging-helper', () => ({
+    Logger: { debug: jest.fn(), info: jest.fn(), warn: jest.fn(), error: jest.fn() },
+}));
+const createOrderContext = (overrides = {}) => ({
+    tags: [],
+    paymentGateways: [],
+    shippingTitles: [],
+    ...overrides,
+});
+const createLineItemContext = (overrides = {}) => ({
+    tags: [],
+    productId: '123',
+    variantId: '456',
+    ...overrides,
+});
+describe('CostFilterService', () => {
+    describe('matchSingleFilter', () => {
+        it('should return true for ALL mode regardless of value', () => {
+            const filter = { mode: COST_FILTER_MODE.ALL, values: ['a'] };
+            expect(CostFilterService.matchSingleFilter(filter, 'anything')).toBe(true);
+            expect(CostFilterService.matchSingleFilter(filter, undefined)).toBe(true);
+        });
+        it('should return true for INCLUDE when value matches', () => {
+            const filter = { mode: COST_FILTER_MODE.INCLUDE, values: ['stripe', 'paypal'] };
+            expect(CostFilterService.matchSingleFilter(filter, 'stripe')).toBe(true);
+        });
+        it('should return false for INCLUDE when value does not match', () => {
+            const filter = { mode: COST_FILTER_MODE.INCLUDE, values: ['stripe', 'paypal'] };
+            expect(CostFilterService.matchSingleFilter(filter, 'braintree')).toBe(false);
+        });
+        it('should return false for INCLUDE when value is undefined', () => {
+            const filter = { mode: COST_FILTER_MODE.INCLUDE, values: ['stripe'] };
+            expect(CostFilterService.matchSingleFilter(filter, undefined)).toBe(false);
+        });
+        it('should return true for EXCLUDE when value does not match', () => {
+            const filter = { mode: COST_FILTER_MODE.EXCLUDE, values: ['stripe'] };
+            expect(CostFilterService.matchSingleFilter(filter, 'paypal')).toBe(true);
+        });
+        it('should return false for EXCLUDE when value matches', () => {
+            const filter = { mode: COST_FILTER_MODE.EXCLUDE, values: ['stripe'] };
+            expect(CostFilterService.matchSingleFilter(filter, 'stripe')).toBe(false);
+        });
+        it('should return true for EXCLUDE when value is undefined', () => {
+            const filter = { mode: COST_FILTER_MODE.EXCLUDE, values: ['stripe'] };
+            expect(CostFilterService.matchSingleFilter(filter, undefined)).toBe(true);
+        });
+        it('should be case-insensitive', () => {
+            const filter = { mode: COST_FILTER_MODE.INCLUDE, values: ['Stripe'] };
+            expect(CostFilterService.matchSingleFilter(filter, 'STRIPE')).toBe(true);
+            expect(CostFilterService.matchSingleFilter(filter, 'stripe')).toBe(true);
+        });
+    });
+    describe('matchArrayFilter', () => {
+        it('should return true for ALL mode', () => {
+            const filter = { mode: COST_FILTER_MODE.ALL, values: ['a'] };
+            expect(CostFilterService.matchArrayFilter(filter, ['anything'])).toBe(true);
+            expect(CostFilterService.matchArrayFilter(filter, undefined)).toBe(true);
+        });
+        it('should return true for INCLUDE when any value matches', () => {
+            const filter = { mode: COST_FILTER_MODE.INCLUDE, values: ['vip', 'priority'] };
+            expect(CostFilterService.matchArrayFilter(filter, ['vip', 'other'])).toBe(true);
+        });
+        it('should return false for INCLUDE when no value matches', () => {
+            const filter = { mode: COST_FILTER_MODE.INCLUDE, values: ['vip', 'priority'] };
+            expect(CostFilterService.matchArrayFilter(filter, ['regular', 'other'])).toBe(false);
+        });
+        it('should return false for INCLUDE when values is empty', () => {
+            const filter = { mode: COST_FILTER_MODE.INCLUDE, values: ['vip'] };
+            expect(CostFilterService.matchArrayFilter(filter, [])).toBe(false);
+        });
+        it('should return false for INCLUDE when values is undefined', () => {
+            const filter = { mode: COST_FILTER_MODE.INCLUDE, values: ['vip'] };
+            expect(CostFilterService.matchArrayFilter(filter, undefined)).toBe(false);
+        });
+        it('should return true for EXCLUDE when no value matches', () => {
+            const filter = { mode: COST_FILTER_MODE.EXCLUDE, values: ['vip'] };
+            expect(CostFilterService.matchArrayFilter(filter, ['regular'])).toBe(true);
+        });
+        it('should return false for EXCLUDE when any value matches', () => {
+            const filter = { mode: COST_FILTER_MODE.EXCLUDE, values: ['vip'] };
+            expect(CostFilterService.matchArrayFilter(filter, ['vip', 'regular'])).toBe(false);
+        });
+        it('should return true for EXCLUDE when values is empty', () => {
+            const filter = { mode: COST_FILTER_MODE.EXCLUDE, values: ['vip'] };
+            expect(CostFilterService.matchArrayFilter(filter, [])).toBe(true);
+        });
+        it('should return true for EXCLUDE when values is undefined', () => {
+            const filter = { mode: COST_FILTER_MODE.EXCLUDE, values: ['vip'] };
+            expect(CostFilterService.matchArrayFilter(filter, undefined)).toBe(true);
+        });
+        it('should be case-insensitive', () => {
+            const filter = { mode: COST_FILTER_MODE.INCLUDE, values: ['VIP'] };
+            expect(CostFilterService.matchArrayFilter(filter, ['vip'])).toBe(true);
+        });
+    });
+    describe('matchProductFilter', () => {
+        it('should return true for ALL mode', () => {
+            const filter = { mode: COST_FILTER_MODE.ALL, values: ['123'] };
+            expect(CostFilterService.matchProductFilter(filter, '999', '888')).toBe(true);
+        });
+        it('should match by productId only', () => {
+            const filter = { mode: COST_FILTER_MODE.INCLUDE, values: ['123'] };
+            expect(CostFilterService.matchProductFilter(filter, '123', '456')).toBe(true);
+        });
+        it('should match by productId_variantId', () => {
+            const filter = { mode: COST_FILTER_MODE.INCLUDE, values: ['123_456'] };
+            expect(CostFilterService.matchProductFilter(filter, '123', '456')).toBe(true);
+        });
+        it('should not match wrong productId_variantId', () => {
+            const filter = { mode: COST_FILTER_MODE.INCLUDE, values: ['123_789'] };
+            expect(CostFilterService.matchProductFilter(filter, '123', '456')).toBe(false);
+        });
+        it('should return false for INCLUDE when productId is empty', () => {
+            const filter = { mode: COST_FILTER_MODE.INCLUDE, values: ['123'] };
+            expect(CostFilterService.matchProductFilter(filter, '', '456')).toBe(false);
+        });
+        it('should return true for EXCLUDE when productId is empty', () => {
+            const filter = { mode: COST_FILTER_MODE.EXCLUDE, values: ['123'] };
+            expect(CostFilterService.matchProductFilter(filter, '', '456')).toBe(true);
+        });
+        it('should return true for EXCLUDE when product does not match', () => {
+            const filter = { mode: COST_FILTER_MODE.EXCLUDE, values: ['123'] };
+            expect(CostFilterService.matchProductFilter(filter, '999', '456')).toBe(true);
+        });
+        it('should return false for EXCLUDE when product matches', () => {
+            const filter = { mode: COST_FILTER_MODE.EXCLUDE, values: ['123'] };
+            expect(CostFilterService.matchProductFilter(filter, '123', '456')).toBe(false);
+        });
+        it('should handle mixed productId and productId_variantId filter values', () => {
+            const filter = { mode: COST_FILTER_MODE.INCLUDE, values: ['100', '200_300'] };
+            expect(CostFilterService.matchProductFilter(filter, '100', '999')).toBe(true);
+            expect(CostFilterService.matchProductFilter(filter, '200', '300')).toBe(true);
+            expect(CostFilterService.matchProductFilter(filter, '200', '999')).toBe(false);
+        });
+    });
+    describe('matchesFilters', () => {
+        it('should return true when filters is undefined', () => {
+            expect(CostFilterService.matchesFilters(undefined, createOrderContext(), null)).toBe(true);
+        });
+        it('should return true when filters is empty object', () => {
+            expect(CostFilterService.matchesFilters({}, createOrderContext(), null)).toBe(true);
+        });
+        it('should check orderTags filter', () => {
+            const filters = {
+                orderTags: { mode: COST_FILTER_MODE.INCLUDE, values: ['vip'] },
+            };
+            expect(CostFilterService.matchesFilters(filters, createOrderContext({ tags: ['vip', 'sale'] }), null)).toBe(true);
+            expect(CostFilterService.matchesFilters(filters, createOrderContext({ tags: ['regular'] }), null)).toBe(false);
+        });
+        it('should check orderSourceNames filter', () => {
+            const filters = {
+                orderSourceNames: { mode: COST_FILTER_MODE.INCLUDE, values: ['web'] },
+            };
+            expect(CostFilterService.matchesFilters(filters, createOrderContext({ sourceName: 'web' }), null)).toBe(true);
+            expect(CostFilterService.matchesFilters(filters, createOrderContext({ sourceName: 'pos' }), null)).toBe(false);
+        });
+        it('should check orderPaymentGateways filter', () => {
+            const filters = {
+                orderPaymentGateways: { mode: COST_FILTER_MODE.INCLUDE, values: ['stripe'] },
+            };
+            expect(CostFilterService.matchesFilters(filters, createOrderContext({ paymentGateways: ['stripe', 'shop_pay'] }), null)).toBe(true);
+            expect(CostFilterService.matchesFilters(filters, createOrderContext({ paymentGateways: ['paypal'] }), null)).toBe(false);
+        });
+        it('should check orderShippingTitles filter', () => {
+            const filters = {
+                orderShippingTitles: { mode: COST_FILTER_MODE.INCLUDE, values: ['Standard'] },
+            };
+            expect(CostFilterService.matchesFilters(filters, createOrderContext({ shippingTitles: ['Standard'] }), null)).toBe(true);
+            expect(CostFilterService.matchesFilters(filters, createOrderContext({ shippingTitles: ['Express'] }), null)).toBe(false);
+        });
+        it('should check countries filter', () => {
+            const filters = {
+                countries: { mode: COST_FILTER_MODE.INCLUDE, values: ['US', 'CA'] },
+            };
+            expect(CostFilterService.matchesFilters(filters, createOrderContext({ shipCountryCode: 'US' }), null)).toBe(true);
+            expect(CostFilterService.matchesFilters(filters, createOrderContext({ shipCountryCode: 'GB' }), null)).toBe(false);
+        });
+        it('should use AND logic between multiple order filters', () => {
+            const filters = {
+                orderTags: { mode: COST_FILTER_MODE.INCLUDE, values: ['vip'] },
+                countries: { mode: COST_FILTER_MODE.INCLUDE, values: ['US'] },
+            };
+            expect(CostFilterService.matchesFilters(filters, createOrderContext({ tags: ['vip'], shipCountryCode: 'US' }), null)).toBe(true);
+            expect(CostFilterService.matchesFilters(filters, createOrderContext({ tags: ['vip'], shipCountryCode: 'GB' }), null)).toBe(false);
+            expect(CostFilterService.matchesFilters(filters, createOrderContext({ tags: ['regular'], shipCountryCode: 'US' }), null)).toBe(false);
+        });
+        it('should skip product filters when lineItem is null and no lineItems array provided', () => {
+            const filters = {
+                productVendors: { mode: COST_FILTER_MODE.INCLUDE, values: ['Nike'] },
+            };
+            expect(CostFilterService.matchesFilters(filters, createOrderContext(), null)).toBe(true);
+        });
+        it('should check productVendors filter', () => {
+            const filters = {
+                productVendors: { mode: COST_FILTER_MODE.INCLUDE, values: ['Nike'] },
+            };
+            expect(CostFilterService.matchesFilters(filters, createOrderContext(), createLineItemContext({ vendor: 'Nike' }))).toBe(true);
+            expect(CostFilterService.matchesFilters(filters, createOrderContext(), createLineItemContext({ vendor: 'Adidas' }))).toBe(false);
+        });
+        it('should check productTypes filter', () => {
+            const filters = {
+                productTypes: { mode: COST_FILTER_MODE.INCLUDE, values: ['Shoes'] },
+            };
+            expect(CostFilterService.matchesFilters(filters, createOrderContext(), createLineItemContext({ productType: 'Shoes' }))).toBe(true);
+            expect(CostFilterService.matchesFilters(filters, createOrderContext(), createLineItemContext({ productType: 'Hats' }))).toBe(false);
+        });
+        it('should check productTags filter', () => {
+            const filters = {
+                productTags: { mode: COST_FILTER_MODE.INCLUDE, values: ['sale'] },
+            };
+            expect(CostFilterService.matchesFilters(filters, createOrderContext(), createLineItemContext({ tags: ['sale', 'new'] }))).toBe(true);
+            expect(CostFilterService.matchesFilters(filters, createOrderContext(), createLineItemContext({ tags: ['clearance'] }))).toBe(false);
+        });
+        it('should check productCategories filter', () => {
+            const filters = {
+                productCategories: { mode: COST_FILTER_MODE.INCLUDE, values: ['Apparel > Shoes'] },
+            };
+            expect(CostFilterService.matchesFilters(filters, createOrderContext(), createLineItemContext({ category: 'Apparel > Shoes' }))).toBe(true);
+            expect(CostFilterService.matchesFilters(filters, createOrderContext(), createLineItemContext({ category: 'Electronics' }))).toBe(false);
+        });
+        it('should check products filter', () => {
+            const filters = {
+                products: { mode: COST_FILTER_MODE.INCLUDE, values: ['123'] },
+            };
+            expect(CostFilterService.matchesFilters(filters, createOrderContext(), createLineItemContext({ productId: '123', variantId: '456' }))).toBe(true);
+            expect(CostFilterService.matchesFilters(filters, createOrderContext(), createLineItemContext({ productId: '999', variantId: '456' }))).toBe(false);
+        });
+        it('should require both order and line-item filters to pass', () => {
+            const filters = {
+                countries: { mode: COST_FILTER_MODE.INCLUDE, values: ['US'] },
+                productVendors: { mode: COST_FILTER_MODE.INCLUDE, values: ['Nike'] },
+            };
+            expect(CostFilterService.matchesFilters(filters, createOrderContext({ shipCountryCode: 'US' }), createLineItemContext({ vendor: 'Nike' }))).toBe(true);
+            expect(CostFilterService.matchesFilters(filters, createOrderContext({ shipCountryCode: 'US' }), createLineItemContext({ vendor: 'Adidas' }))).toBe(false);
+            expect(CostFilterService.matchesFilters(filters, createOrderContext({ shipCountryCode: 'GB' }), createLineItemContext({ vendor: 'Nike' }))).toBe(false);
+        });
+        it('should handle all 5 order + all 5 line-item filters passing', () => {
+            const filters = {
+                orderTags: { mode: COST_FILTER_MODE.INCLUDE, values: ['vip'] },
+                orderSourceNames: { mode: COST_FILTER_MODE.INCLUDE, values: ['web'] },
+                orderPaymentGateways: { mode: COST_FILTER_MODE.INCLUDE, values: ['stripe'] },
+                orderShippingTitles: { mode: COST_FILTER_MODE.INCLUDE, values: ['Standard'] },
+                countries: { mode: COST_FILTER_MODE.INCLUDE, values: ['US'] },
+                productVendors: { mode: COST_FILTER_MODE.INCLUDE, values: ['Nike'] },
+                productTypes: { mode: COST_FILTER_MODE.INCLUDE, values: ['Shoes'] },
+                productTags: { mode: COST_FILTER_MODE.INCLUDE, values: ['sale'] },
+                productCategories: { mode: COST_FILTER_MODE.INCLUDE, values: ['Apparel'] },
+                products: { mode: COST_FILTER_MODE.INCLUDE, values: ['123'] },
+            };
+            const order = createOrderContext({
+                tags: ['vip'],
+                sourceName: 'web',
+                paymentGateways: ['stripe'],
+                shippingTitles: ['Standard'],
+                shipCountryCode: 'US',
+            });
+            const lineItem = createLineItemContext({
+                vendor: 'Nike',
+                productType: 'Shoes',
+                tags: ['sale'],
+                category: 'Apparel',
+                productId: '123',
+                variantId: '456',
+            });
+            expect(CostFilterService.matchesFilters(filters, order, lineItem)).toBe(true);
+        });
+        it('should handle EXCLUDE mode for order tags', () => {
+            const filters = {
+                orderTags: { mode: COST_FILTER_MODE.EXCLUDE, values: ['test'] },
+            };
+            expect(CostFilterService.matchesFilters(filters, createOrderContext({ tags: ['vip'] }), null)).toBe(true);
+            expect(CostFilterService.matchesFilters(filters, createOrderContext({ tags: ['test'] }), null)).toBe(false);
+        });
+        it('should handle mixed INCLUDE and EXCLUDE filters', () => {
+            const filters = {
+                countries: { mode: COST_FILTER_MODE.INCLUDE, values: ['US'] },
+                orderTags: { mode: COST_FILTER_MODE.EXCLUDE, values: ['test'] },
+            };
+            expect(CostFilterService.matchesFilters(filters, createOrderContext({ shipCountryCode: 'US', tags: ['vip'] }), null)).toBe(true);
+            expect(CostFilterService.matchesFilters(filters, createOrderContext({ shipCountryCode: 'US', tags: ['test'] }), null)).toBe(false);
+            expect(CostFilterService.matchesFilters(filters, createOrderContext({ shipCountryCode: 'GB', tags: ['vip'] }), null)).toBe(false);
+        });
+        it('should evaluate product filters against lineItems array when lineItem is null', () => {
+            const filters = {
+                productVendors: { mode: COST_FILTER_MODE.INCLUDE, values: ['Nike'] },
+            };
+            const lineItems = [
+                createLineItemContext({ vendor: 'Adidas' }),
+                createLineItemContext({ vendor: 'Nike' }),
+            ];
+            expect(CostFilterService.matchesFilters(filters, createOrderContext(), null, lineItems)).toBe(true);
+        });
+        it('should return false when no lineItem matches product filters via lineItems array', () => {
+            const filters = {
+                productVendors: { mode: COST_FILTER_MODE.INCLUDE, values: ['Nike'] },
+            };
+            const lineItems = [
+                createLineItemContext({ vendor: 'Adidas' }),
+                createLineItemContext({ vendor: 'Puma' }),
+            ];
+            expect(CostFilterService.matchesFilters(filters, createOrderContext(), null, lineItems)).toBe(false);
+        });
+        it('should evaluate products filter against lineItems array', () => {
+            const filters = {
+                products: { mode: COST_FILTER_MODE.INCLUDE, values: ['P100'] },
+            };
+            const matching = [createLineItemContext({ productId: 'P100', variantId: 'V1' })];
+            const nonMatching = [createLineItemContext({ productId: 'P999', variantId: 'V1' })];
+            expect(CostFilterService.matchesFilters(filters, createOrderContext(), null, matching)).toBe(true);
+            expect(CostFilterService.matchesFilters(filters, createOrderContext(), null, nonMatching)).toBe(false);
+        });
+        it('should evaluate productTags filter against lineItems array', () => {
+            const filters = {
+                productTags: { mode: COST_FILTER_MODE.INCLUDE, values: ['fragile'] },
+            };
+            const matching = [createLineItemContext({ tags: ['fragile', 'heavy'] })];
+            const nonMatching = [createLineItemContext({ tags: ['lightweight'] })];
+            expect(CostFilterService.matchesFilters(filters, createOrderContext(), null, matching)).toBe(true);
+            expect(CostFilterService.matchesFilters(filters, createOrderContext(), null, nonMatching)).toBe(false);
+        });
+        it('should evaluate productTypes filter against lineItems array', () => {
+            const filters = {
+                productTypes: { mode: COST_FILTER_MODE.INCLUDE, values: ['Electronics'] },
+            };
+            const matching = [createLineItemContext({ productType: 'Electronics' })];
+            const nonMatching = [createLineItemContext({ productType: 'Clothing' })];
+            expect(CostFilterService.matchesFilters(filters, createOrderContext(), null, matching)).toBe(true);
+            expect(CostFilterService.matchesFilters(filters, createOrderContext(), null, nonMatching)).toBe(false);
+        });
+        it('should evaluate productCategories filter against lineItems array', () => {
+            const filters = {
+                productCategories: { mode: COST_FILTER_MODE.INCLUDE, values: ['Home > Kitchen'] },
+            };
+            const matching = [createLineItemContext({ category: 'Home > Kitchen' })];
+            const nonMatching = [createLineItemContext({ category: 'Sports' })];
+            expect(CostFilterService.matchesFilters(filters, createOrderContext(), null, matching)).toBe(true);
+            expect(CostFilterService.matchesFilters(filters, createOrderContext(), null, nonMatching)).toBe(false);
+        });
+        it('should evaluate EXCLUDE product filters against lineItems array', () => {
+            const filters = {
+                productVendors: { mode: COST_FILTER_MODE.EXCLUDE, values: ['Nike'] },
+            };
+            const mixed = [
+                createLineItemContext({ vendor: 'Adidas' }),
+                createLineItemContext({ vendor: 'Nike' }),
+            ];
+            expect(CostFilterService.matchesFilters(filters, createOrderContext(), null, mixed)).toBe(true);
+            const allNike = [
+                createLineItemContext({ vendor: 'Nike' }),
+                createLineItemContext({ vendor: 'Nike' }),
+            ];
+            expect(CostFilterService.matchesFilters(filters, createOrderContext(), null, allNike)).toBe(false);
+        });
+        it('should combine order filters + product filters via lineItems array', () => {
+            const filters = {
+                countries: { mode: COST_FILTER_MODE.INCLUDE, values: ['US'] },
+                productVendors: { mode: COST_FILTER_MODE.INCLUDE, values: ['Nike'] },
+            };
+            const lineItems = [createLineItemContext({ vendor: 'Nike' })];
+            expect(CostFilterService.matchesFilters(filters, createOrderContext({ shipCountryCode: 'US' }), null, lineItems)).toBe(true);
+            expect(CostFilterService.matchesFilters(filters, createOrderContext({ shipCountryCode: 'GB' }), null, lineItems)).toBe(false);
+            const noMatch = [createLineItemContext({ vendor: 'Adidas' })];
+            expect(CostFilterService.matchesFilters(filters, createOrderContext({ shipCountryCode: 'US' }), null, noMatch)).toBe(false);
+        });
+        it('should combine multiple product filters with AND logic via lineItems array', () => {
+            const filters = {
+                productVendors: { mode: COST_FILTER_MODE.INCLUDE, values: ['Nike'] },
+                productTypes: { mode: COST_FILTER_MODE.INCLUDE, values: ['Shoes'] },
+            };
+            const bothMatch = [createLineItemContext({ vendor: 'Nike', productType: 'Shoes' })];
+            expect(CostFilterService.matchesFilters(filters, createOrderContext(), null, bothMatch)).toBe(true);
+            const partialMatch = [createLineItemContext({ vendor: 'Nike', productType: 'Hats' })];
+            expect(CostFilterService.matchesFilters(filters, createOrderContext(), null, partialMatch)).toBe(false);
+            const mixed = [
+                createLineItemContext({ vendor: 'Adidas', productType: 'Hats' }),
+                createLineItemContext({ vendor: 'Nike', productType: 'Shoes' }),
+            ];
+            expect(CostFilterService.matchesFilters(filters, createOrderContext(), null, mixed)).toBe(true);
+        });
+        it('should return true when lineItems array is empty and product filters exist', () => {
+            const filters = {
+                productVendors: { mode: COST_FILTER_MODE.INCLUDE, values: ['Nike'] },
+            };
+            expect(CostFilterService.matchesFilters(filters, createOrderContext(), null, [])).toBe(true);
+        });
+        it('should not use lineItems array when lineItem is provided (single lineItem takes precedence)', () => {
+            const filters = {
+                productVendors: { mode: COST_FILTER_MODE.INCLUDE, values: ['Nike'] },
+            };
+            const lineItem = createLineItemContext({ vendor: 'Adidas' });
+            const lineItems = [createLineItemContext({ vendor: 'Nike' })];
+            expect(CostFilterService.matchesFilters(filters, createOrderContext(), lineItem, lineItems)).toBe(false);
+        });
+    });
+    describe('hasProductFilters', () => {
+        it('should return false for undefined filters', () => {
+            expect(CostFilterService.hasProductFilters(undefined)).toBe(false);
+        });
+        it('should return false for empty filters', () => {
+            expect(CostFilterService.hasProductFilters({})).toBe(false);
+        });
+        it('should return false for order-only filters', () => {
+            const filters = {
+                orderTags: { mode: COST_FILTER_MODE.INCLUDE, values: ['vip'] },
+                countries: { mode: COST_FILTER_MODE.INCLUDE, values: ['US'] },
+            };
+            expect(CostFilterService.hasProductFilters(filters)).toBe(false);
+        });
+        it('should return true for productVendors', () => {
+            expect(CostFilterService.hasProductFilters({ productVendors: { mode: COST_FILTER_MODE.INCLUDE, values: ['Nike'] } })).toBe(true);
+        });
+        it('should return true for productTypes', () => {
+            expect(CostFilterService.hasProductFilters({ productTypes: { mode: COST_FILTER_MODE.INCLUDE, values: ['Shoes'] } })).toBe(true);
+        });
+        it('should return true for productTags', () => {
+            expect(CostFilterService.hasProductFilters({ productTags: { mode: COST_FILTER_MODE.INCLUDE, values: ['sale'] } })).toBe(true);
+        });
+        it('should return true for productCategories', () => {
+            expect(CostFilterService.hasProductFilters({ productCategories: { mode: COST_FILTER_MODE.INCLUDE, values: ['Apparel'] } })).toBe(true);
+        });
+        it('should return true for products', () => {
+            expect(CostFilterService.hasProductFilters({ products: { mode: COST_FILTER_MODE.INCLUDE, values: ['123'] } })).toBe(true);
+        });
+    });
+    describe('matchLineItemFilters', () => {
+        it('should return true when no product filters defined', () => {
+            expect(CostFilterService.matchLineItemFilters({}, createLineItemContext())).toBe(true);
+        });
+        it('should check productVendors', () => {
+            const filters = { productVendors: { mode: COST_FILTER_MODE.INCLUDE, values: ['Nike'] } };
+            expect(CostFilterService.matchLineItemFilters(filters, createLineItemContext({ vendor: 'Nike' }))).toBe(true);
+            expect(CostFilterService.matchLineItemFilters(filters, createLineItemContext({ vendor: 'Adidas' }))).toBe(false);
+        });
+        it('should check productTypes', () => {
+            const filters = { productTypes: { mode: COST_FILTER_MODE.INCLUDE, values: ['Shoes'] } };
+            expect(CostFilterService.matchLineItemFilters(filters, createLineItemContext({ productType: 'Shoes' }))).toBe(true);
+            expect(CostFilterService.matchLineItemFilters(filters, createLineItemContext({ productType: 'Hats' }))).toBe(false);
+        });
+        it('should check productTags', () => {
+            const filters = { productTags: { mode: COST_FILTER_MODE.INCLUDE, values: ['sale'] } };
+            expect(CostFilterService.matchLineItemFilters(filters, createLineItemContext({ tags: ['sale'] }))).toBe(true);
+            expect(CostFilterService.matchLineItemFilters(filters, createLineItemContext({ tags: ['clearance'] }))).toBe(false);
+        });
+        it('should check productCategories', () => {
+            const filters = { productCategories: { mode: COST_FILTER_MODE.INCLUDE, values: ['Apparel'] } };
+            expect(CostFilterService.matchLineItemFilters(filters, createLineItemContext({ category: 'Apparel' }))).toBe(true);
+            expect(CostFilterService.matchLineItemFilters(filters, createLineItemContext({ category: 'Electronics' }))).toBe(false);
+        });
+        it('should check products', () => {
+            const filters = { products: { mode: COST_FILTER_MODE.INCLUDE, values: ['123'] } };
+            expect(CostFilterService.matchLineItemFilters(filters, createLineItemContext({ productId: '123' }))).toBe(true);
+            expect(CostFilterService.matchLineItemFilters(filters, createLineItemContext({ productId: '999' }))).toBe(false);
+        });
+        it('should use AND logic across all product filters', () => {
+            const filters = {
+                productVendors: { mode: COST_FILTER_MODE.INCLUDE, values: ['Nike'] },
+                productTypes: { mode: COST_FILTER_MODE.INCLUDE, values: ['Shoes'] },
+                productTags: { mode: COST_FILTER_MODE.INCLUDE, values: ['sale'] },
+            };
+            expect(CostFilterService.matchLineItemFilters(filters, createLineItemContext({ vendor: 'Nike', productType: 'Shoes', tags: ['sale'] }))).toBe(true);
+            expect(CostFilterService.matchLineItemFilters(filters, createLineItemContext({ vendor: 'Nike', productType: 'Hats', tags: ['sale'] }))).toBe(false);
+        });
+    });
+});
 //# sourceMappingURL=cost-filter-service.spec.js.map