Skip to content

Commit ac41764

Browse files
cnathecnathe
committed
Jest test TODOs
1 parent b3de0d0 commit ac41764

2 files changed

Lines changed: 187 additions & 2 deletions

File tree

‎packages/components/src/internal/components/domainproperties/models.test.ts‎

Lines changed: 152 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -79,6 +79,7 @@ import {
7979
DOMAIN_FIELD_PARTIALLY_LOCKED,
8080
DOMAIN_FIELD_PRIMARY_KEY_LOCKED,
8181
INT_RANGE_URI,
82+
MAX_TEXT_LENGTH,
8283
MULTILINE_RANGE_URI,
8384
PHILEVEL_FULL_PHI,
8485
PHILEVEL_LIMITED_PHI,
@@ -89,6 +90,8 @@ import {
8990
STRING_RANGE_URI,
9091
TEXT_CHOICE_CONCEPT_URI,
9192
TIME_RANGE_URI,
93+
UNLIMITED_TEXT_LENGTH,
94+
USER_RANGE_URI,
9295
} from './constants';
9396

9497
beforeAll(() => {
@@ -1258,7 +1261,155 @@ describe('DomainField', () => {
12581261
expect(fields.get(2).nonUniqueConstraint).toBe(true); // field c
12591262
});
12601263

1261-
// TODO add other test cases for DomainField.serialize code
1264+
test('serialize, lookup fields nullified for non-lookup types', () => {
1265+
// lookupQuery is intentionally omitted so resolveDataType detects TEXT_TYPE via rangeURI
1266+
const textField = DomainField.create({
1267+
name: 'foo',
1268+
rangeURI: TEXT_TYPE.rangeURI,
1269+
lookupContainer: 'myContainer',
1270+
lookupSchema: 'mySchema',
1271+
});
1272+
const serialized = DomainField.serialize(textField);
1273+
expect(serialized.lookupContainer).toBeNull();
1274+
expect(serialized.lookupQuery).toBeNull();
1275+
expect(serialized.lookupSchema).toBeNull();
1276+
});
1277+
1278+
test('serialize, lookup fields preserved for lookup type', () => {
1279+
// rangeURI is required for resolveDataType to detect the explicit dataType on a new field
1280+
const field = DomainField.create({
1281+
name: 'foo',
1282+
rangeURI: INT_RANGE_URI,
1283+
dataType: LOOKUP_TYPE,
1284+
lookupContainer: 'myContainer',
1285+
lookupQuery: 'myQuery',
1286+
lookupSchema: 'mySchema',
1287+
});
1288+
const serialized = DomainField.serialize(field);
1289+
expect(serialized.lookupContainer).toBe('myContainer');
1290+
expect(serialized.lookupQuery).toBe('myQuery');
1291+
expect(serialized.lookupSchema).toBe('mySchema');
1292+
});
1293+
1294+
test('serialize, lookup fields preserved for sample type', () => {
1295+
// rangeURI is required for resolveDataType to detect SAMPLE_TYPE via conceptURI on a new field
1296+
const field = DomainField.create({
1297+
name: 'foo',
1298+
rangeURI: SAMPLE_TYPE.rangeURI,
1299+
conceptURI: SAMPLE_TYPE_CONCEPT_URI,
1300+
lookupContainer: 'myContainer',
1301+
lookupQuery: 'myQuery',
1302+
lookupSchema: 'mySchema',
1303+
});
1304+
const serialized = DomainField.serialize(field);
1305+
expect(serialized.lookupContainer).toBe('myContainer');
1306+
expect(serialized.lookupQuery).toBe('myQuery');
1307+
expect(serialized.lookupSchema).toBe('mySchema');
1308+
});
1309+
1310+
test('serialize, undefined lookupContainer becomes null for lookup type', () => {
1311+
// rangeURI is required for resolveDataType to detect the explicit dataType on a new field
1312+
const field = DomainField.create({ name: 'foo', rangeURI: INT_RANGE_URI, dataType: LOOKUP_TYPE });
1313+
const serialized = DomainField.serialize(field);
1314+
expect(serialized.lookupContainer).toBeNull();
1315+
});
1316+
1317+
test('serialize, isTargetBlank converts to urltarget', () => {
1318+
const blankField = DomainField.create({ name: 'foo', rangeURI: TEXT_TYPE.rangeURI, isTargetBlank: true });
1319+
const blankSerialized = DomainField.serialize(blankField);
1320+
expect(blankSerialized.urltarget).toBe('_blank');
1321+
expect(blankSerialized.isTargetBlank).toBeUndefined();
1322+
1323+
const nonBlankField = DomainField.create({ name: 'foo', rangeURI: TEXT_TYPE.rangeURI, isTargetBlank: false });
1324+
const nonBlankSerialized = DomainField.serialize(nonBlankField);
1325+
expect(nonBlankSerialized.urltarget).toBeNull();
1326+
expect(nonBlankSerialized.isTargetBlank).toBeUndefined();
1327+
});
1328+
1329+
test('serialize, URL and PHI case sensitivity fix', () => {
1330+
const field = DomainField.create({
1331+
name: 'foo',
1332+
rangeURI: TEXT_TYPE.rangeURI,
1333+
URL: 'https://example.com',
1334+
PHI: PHILEVEL_LIMITED_PHI,
1335+
});
1336+
const serialized = DomainField.serialize(field);
1337+
expect(serialized.url).toBe('https://example.com');
1338+
expect(serialized.URL).toBeUndefined();
1339+
expect(serialized.phi).toBe(PHILEVEL_LIMITED_PHI);
1340+
expect(serialized.PHI).toBeUndefined();
1341+
});
1342+
1343+
test('serialize, fixCaseSensitivity=false skips URL and PHI rename', () => {
1344+
const field = DomainField.create({
1345+
name: 'foo',
1346+
rangeURI: TEXT_TYPE.rangeURI,
1347+
URL: 'https://example.com',
1348+
PHI: PHILEVEL_LIMITED_PHI,
1349+
});
1350+
const serialized = DomainField.serialize(field, false);
1351+
expect(serialized.URL).toBe('https://example.com');
1352+
expect(serialized.url).toBeUndefined();
1353+
expect(serialized.PHI).toBe(PHILEVEL_LIMITED_PHI);
1354+
expect(serialized.phi).toBeUndefined();
1355+
});
1356+
1357+
test('serialize, USER_RANGE_URI rewritten to INT_RANGE_URI', () => {
1358+
const field = DomainField.create({ name: 'foo', rangeURI: USER_RANGE_URI });
1359+
const serialized = DomainField.serialize(field);
1360+
expect(serialized.rangeURI).toBe(INT_RANGE_URI);
1361+
});
1362+
1363+
test('serialize, scale > MAX_TEXT_LENGTH becomes UNLIMITED_TEXT_LENGTH', () => {
1364+
const overMax = DomainField.create({ name: 'foo', rangeURI: TEXT_TYPE.rangeURI, scale: MAX_TEXT_LENGTH + 1 });
1365+
expect(DomainField.serialize(overMax).scale).toBe(UNLIMITED_TEXT_LENGTH);
1366+
1367+
const atMax = DomainField.create({ name: 'foo', rangeURI: TEXT_TYPE.rangeURI, scale: MAX_TEXT_LENGTH });
1368+
expect(DomainField.serialize(atMax).scale).toBe(MAX_TEXT_LENGTH);
1369+
});
1370+
1371+
test('serialize, non-serializable fields are removed', () => {
1372+
const field = DomainField.create({ name: 'foo', rangeURI: TEXT_TYPE.rangeURI });
1373+
const serialized = DomainField.serialize(field);
1374+
expect(serialized.dataType).toBeUndefined();
1375+
expect(serialized.lookupQueryValue).toBeUndefined();
1376+
expect(serialized.lookupType).toBeUndefined();
1377+
expect(serialized.original).toBeUndefined();
1378+
expect(serialized.updatedField).toBeUndefined();
1379+
expect(serialized.visible).toBeUndefined();
1380+
expect(serialized.rangeValidators).toBeUndefined();
1381+
expect(serialized.regexValidators).toBeUndefined();
1382+
expect(serialized.textChoiceValidator).toBeUndefined();
1383+
expect(serialized.lookupValidator).toBeUndefined();
1384+
expect(serialized.disablePhiLevel).toBeUndefined();
1385+
expect(serialized.lockExistingField).toBeUndefined();
1386+
expect(serialized.selected).toBeUndefined();
1387+
expect(serialized.lookupIsValid).toBeUndefined();
1388+
expect(serialized.uniqueConstraint).toBeUndefined();
1389+
expect(serialized.nonUniqueConstraint).toBeUndefined();
1390+
});
1391+
1392+
test('serialize, validators collected into propertyValidators', () => {
1393+
const rangeValidatorData = { type: 'Range', name: 'Range Validator 1', rowId: 1 };
1394+
const regexValidatorData = { type: 'RegEx', name: 'RegEx Validator 1', rowId: 2 };
1395+
const lookupValidatorData = { type: 'Lookup', name: 'Lookup Validator', rowId: 3 };
1396+
const textChoiceValidatorData = {
1397+
type: 'TextChoice',
1398+
name: 'Text Choice Validator',
1399+
rowId: 4,
1400+
properties: { validValues: [] },
1401+
};
1402+
const field = DomainField.create({
1403+
name: 'foo',
1404+
rangeURI: TEXT_TYPE.rangeURI,
1405+
propertyValidators: [rangeValidatorData, regexValidatorData, lookupValidatorData, textChoiceValidatorData],
1406+
});
1407+
const serialized = DomainField.serialize(field);
1408+
expect(serialized.propertyValidators).toHaveLength(4);
1409+
expect(serialized.propertyValidators.map(v => v.type)).toEqual(
1410+
expect.arrayContaining(['Range', 'RegEx', 'Lookup', 'TextChoice'])
1411+
);
1412+
});
12621413
});
12631414

12641415
describe('DomainIndex', () => {

‎packages/components/src/public/QueryModel/grid/actions/Filter.test.ts‎

Lines changed: 35 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -27,7 +27,41 @@ import { FilterProps } from '../../../../internal/components/entities/models';
2727
describe('FilterAction::actionValueFromFilter', () => {
2828
const action = new FilterAction();
2929

30-
// TODO add tests for various value options
30+
test('no-value filter (ISBLANK)', () => {
31+
const filter = Filter.create('col', null, Filter.Types.ISBLANK);
32+
const value: ActionValue = action.actionValueFromFilter(filter);
33+
expect(value.displayValue).toBe('col Is Blank');
34+
expect(value.value).toBe('"col" Is Blank null');
35+
});
36+
37+
test('multi-value IN filter with 3 or fewer values shows comma-joined list', () => {
38+
const filter1 = Filter.create('col', ['a'], Filter.Types.IN);
39+
expect(action.actionValueFromFilter(filter1).displayValue).toBe('col Equals One Of a');
40+
41+
const filter3 = Filter.create('col', ['a', 'b', 'c'], Filter.Types.IN);
42+
expect(action.actionValueFromFilter(filter3).displayValue).toBe('col Equals One Of a, b, c');
43+
});
44+
45+
test('multi-value IN filter with more than 3 values shows count', () => {
46+
const filter = Filter.create('col', ['a', 'b', 'c', 'd'], Filter.Types.IN);
47+
const value: ActionValue = action.actionValueFromFilter(filter);
48+
expect(value.displayValue).toBe('col Equals One Of (4 values)');
49+
});
50+
51+
test('custom getFilterDisplayValue callback overrides display', () => {
52+
const actionWithCb = new FilterAction((_colName, rawValue) => `DISPLAY(${rawValue})`);
53+
const filter = Filter.create('myCol', 'rawVal', Filter.Types.EQUAL);
54+
const value: ActionValue = actionWithCb.actionValueFromFilter(filter);
55+
expect(value.displayValue).toBe('myCol = DISPLAY(rawVal)');
56+
expect(value.value).toBe('"myCol" = DISPLAY(rawVal)');
57+
});
58+
59+
test('isReadOnly is propagated to ActionValue', () => {
60+
const filter = Filter.create('col', 'val', Filter.Types.EQUAL);
61+
const value: ActionValue = action.actionValueFromFilter(filter, undefined, 'readonly');
62+
expect(value.isReadOnly).toBe('readonly');
63+
});
64+
3165
test('no label, unencoded column', () => {
3266
const filter = Filter.create('colName', '10', Filter.Types.EQUAL);
3367
const value: ActionValue = action.actionValueFromFilter(filter);

0 commit comments

Comments
 (0)