iss1757 - extractor tests

Author: EJMFarrow

corsscripts/ascii/extractors/lastblock.js

@@ -1,5 +1,5 @@
 // Extractor: lastblock
-// Returns the raw content of the last code_inline, or the full trimmed content
+// Returns the raw content of the last code_inline, or the full content
 // of the last asciimath_block, in document order.
 // Falls back to the final non-empty line of raw when no blocks are available.
 export default function lastblock(raw, blocks) {
@@ -21,7 +21,7 @@ export default function lastblock(raw, blocks) {
     for (let i = lines.length - 1; i >= 0; i--) {
         const trimmed = lines[i].trim();
         if (trimmed !== '') {
-            return trimmed;
+            return lines[i];
         }
     }
     return 'ERROR';

corsscripts/ascii/extractors/lastcalc.js

@@ -1,10 +1,10 @@
 // Extractor: lastcalc
-// Returns the raw content of the last calculation block.
+// Returns the trimmed content of the last calculation block.
 export default function lastcalc(raw, blocks) {
     if (blocks) {
         for (let i = blocks.length - 1; i >= 0; i--) {
             if (blocks[i].type === 'calculation') {
-                return blocks[i].raw;
+                return blocks[i].raw.trim();
             }
         }
     }

corsscripts/ascii/extractors/lastexpr.js

@@ -1,13 +1,13 @@
 // Extractor: lastexpr
-// Returns the raw content of the last code_inline, or the last non-empty line
+// Returns the trimmed content of the last code_inline, or the last non-empty line
 // of the last asciimath_block, in document order.
 // Falls back to the final non-empty line of raw when no blocks are available.
 export default function lastexpr(raw, blocks) {
     if (blocks && blocks.length > 0) {
         for (let i = blocks.length - 1; i >= 0; i--) {
             const block = blocks[i];
             if (block.type === 'code_inline') {
-                return block.raw;
+                return block.raw.trim();
             }
             if (block.type === 'asciimath_block') {
                 const lines = block.raw.split(/\r?\n/);

corsscripts/ascii/extractors/regexall.js

@@ -1,12 +1,12 @@
 // Extractor: regexall
 // [[extractor targetinput="ans2" type="regexall" regex="^f\\(x\\)\\s*=\\s*" /]]
-// Searches the entire raw input for all lines matching entry.regex and returns
+// Searches the entire raw input for all lines matching operation.regex and returns
 // a JSON object of the form {"matches":[...]} set as answerEl.value.
-export default function regexall(raw, blocks, entry) {
-    if (!entry || !entry.regex) {
-        return;
+export default function regexall(raw, blocks, operation) {
+    if (!operation || !operation.regex) {
+        return 'ERROR';
     }
-    const pattern = new RegExp(entry.regex);
+    const pattern = new RegExp(operation.regex);
     const matches = [];
 
     for (const line of raw.split('\n')) {

corsscripts/ascii/extractors/regexmatch.js

@@ -3,12 +3,12 @@
 // Note the scaped backslashes. Searches for a trimmed line beginning 'f(x) = ' where
 // there can be any amount of whitespace around the equals. Returns 'f(x) = expr'.
 // Scans blocks (bottom-up) for the last code_inline or asciimath_block line
-// matching entry.regex, then sets answerEl.value to the matched string.
-export default function regexmatch(raw, blocks, entry) {
-    if (!entry || !entry.regex) {
-        return;
+// matching operation.regex, then sets answerEl.value to the matched string.
+export default function regexmatch(raw, blocks, operation) {
+    if (!operation || !operation.regex) {
+        return 'ERROR';
     }
-    const pattern = new RegExp(entry.regex);
+    const pattern = new RegExp(operation.regex);
 
     if (blocks && blocks.length > 0) {
         for (let i = blocks.length - 1; i >= 0; i--) {

corsscripts/ascii/filters/calculation.js

@@ -1,4 +1,4 @@
-// Filter: calculation
+// Filter: calculation - Currently for testing purposes.
 // Finds text enclosed in @ characters on a single line and wraps it in double stars.
 // e.g. "The answer is @x^2 + 1@ here" → "The answer is **x^2 + 1** here"
 

tests/jest/.gitignore

@@ -0,0 +1 @@
+node_modules/

tests/jest/ascii.extractors.finalfunction.test.js

@@ -0,0 +1,109 @@
+import finalfunction from '../../corsscripts/ascii/extractors/finalfunction.js';
+
+describe('finalfunction extractor', () => {
+
+    // ── Block-mode tests ──────────────────────────────────────────────────────
+
+    describe('with blocks', () => {
+        test('returns expression from a matching code_inline block', () => {
+            const blocks = [{ type: 'code_inline', raw: 'f(x) = x^2' }];
+            expect(finalfunction('', blocks)).toBe('x^2');
+        });
+
+        test('strips leading/trailing whitespace from code_inline before matching', () => {
+            const blocks = [{ type: 'code_inline', raw: '  f(x) = sin(x)  ' }];
+            expect(finalfunction('', blocks)).toBe('sin(x)');
+        });
+
+        test('returns last matching line from an asciimath_block', () => {
+            const blocks = [{
+                type: 'asciimath_block',
+                raw: 'y = 3\nf(x) = x + 1'
+            }];
+            expect(finalfunction('', blocks)).toBe('x + 1');
+        });
+
+        test('scans asciimath_block lines bottom-up and returns last match', () => {
+            const blocks = [{
+                type: 'asciimath_block',
+                raw: 'f(x) = x\nf(x) = x^2\nsome other line'
+            }];
+            expect(finalfunction('', blocks)).toBe('x^2');
+        });
+
+        test('scans blocks bottom-up, returning last block with a match', () => {
+            const blocks = [
+                { type: 'code_inline', raw: 'f(x) = first' },
+                { type: 'code_inline', raw: 'f(x) = last' }
+            ];
+            expect(finalfunction('', blocks)).toBe('last');
+        });
+
+        test('skips non-matching code_inline blocks and finds earlier match', () => {
+            const blocks = [
+                { type: 'code_inline', raw: 'f(x) = found' },
+                { type: 'code_inline', raw: 'y = x' }
+            ];
+            expect(finalfunction('', blocks)).toBe('found');
+        });
+
+        test('returns ERROR when no block line matches f(x) = pattern', () => {
+            const blocks = [
+                { type: 'code_inline', raw: 'y = x' },
+                { type: 'asciimath_block', raw: 'a = 1\nb = 2' }
+            ];
+            expect(finalfunction('', blocks)).toBe('ERROR');
+        });
+
+        test('ignores blocks that are not code_inline or asciimath_block', () => {
+            const blocks = [
+                { type: 'paragraph', raw: 'f(x) = ignored' },
+                { type: 'code_inline', raw: 'f(x) = found' },
+                { type: 'paragraph', raw: 'f(x) = ignored' },
+            ];
+            expect(finalfunction('', blocks)).toBe('found');
+        });
+
+        test('returns ERROR for an empty blocks array (falls back to raw, no match)', () => {
+            expect(finalfunction('no match here', [])).toBe('ERROR');
+        });
+
+        test('handles windows-style line endings in asciimath_block', () => {
+            const blocks = [{
+                type: 'asciimath_block',
+                raw: 'y = 1\r\nf(x) = x^3'
+            }];
+            expect(finalfunction('', blocks)).toBe('x^3');
+        });
+    });
+
+    // ── Raw-fallback tests ────────────────────────────────────────────────────
+
+    describe('without blocks (raw fallback)', () => {
+        test('returns expression from a plain raw line', () => {
+            expect(finalfunction('f(x) = x + 2', null)).toBe('x + 2');
+        });
+
+        test('strips backtick delimiters from raw input', () => {
+            expect(finalfunction('`f(x) = x^2`', null)).toBe('x^2');
+        });
+
+        test('scans raw lines bottom-up and returns last match', () => {
+            const raw = 'f(x) = first\nsome text\nf(x) = last';
+            expect(finalfunction(raw, null)).toBe('last');
+        });
+
+        test('ignores non-matching lines in raw', () => {
+            const raw = 'a = 1\nb = 2\nf(x) = expr\nb = 2';
+            expect(finalfunction(raw, null)).toBe('expr');
+        });
+
+        test('returns ERROR when no raw line matches', () => {
+            expect(finalfunction('a = 1\nb = 2', null)).toBe('ERROR');
+        });
+
+        test('returns ERROR for empty raw string with null blocks', () => {
+            expect(finalfunction('', null)).toBe('ERROR');
+        });
+    });
+});

tests/jest/ascii.extractors.lastblock.test.js

@@ -0,0 +1,94 @@
+import lastblock from '../../corsscripts/ascii/extractors/lastblock.js';
+
+describe('lastblock extractor', () => {
+
+    // ── Block-mode tests ──────────────────────────────────────────────────────
+
+    describe('with blocks', () => {
+        test('returns raw of a single code_inline block', () => {
+            const blocks = [{ type: 'code_inline', raw: 'x^2' }];
+            expect(lastblock('', blocks)).toBe('x^2');
+        });
+
+        test('returns raw of a single asciimath_block', () => {
+            const blocks = [{ type: 'asciimath_block', raw: 'x + 1\ny = 2' }];
+            expect(lastblock('', blocks)).toBe('x + 1\ny = 2');
+        });
+
+        test('returns raw of the last code_inline when multiple blocks exist', () => {
+            const blocks = [
+                { type: 'code_inline', raw: 'first' },
+                { type: 'code_inline', raw: 'last' }
+            ];
+            expect(lastblock('', blocks)).toBe('last');
+        });
+
+        test('returns raw of the last asciimath_block when it is the last relevant block', () => {
+            const blocks = [
+                { type: 'code_inline', raw: 'first' },
+                { type: 'asciimath_block', raw: 'second block' }
+            ];
+            expect(lastblock('', blocks)).toBe('second block');
+        });
+
+        test('scans bottom-up: last code_inline after an asciimath_block wins', () => {
+            const blocks = [
+                { type: 'asciimath_block', raw: 'math block' },
+                { type: 'code_inline', raw: 'inline after' }
+            ];
+            expect(lastblock('', blocks)).toBe('inline after');
+        });
+
+        test('ignores blocks that are not code_inline or asciimath_block', () => {
+            const blocks = [
+                { type: 'paragraph', raw: 'ignored' },
+                { type: 'heading', raw: 'also ignored' },
+            ];
+            expect(lastblock('', blocks)).toBe('ERROR');
+        });
+
+        test('mixes eligible and non-eligible blocks, returns last eligible', () => {
+            const blocks = [
+                { type: 'code_inline', raw: 'inline' },
+                { type: 'paragraph', raw: 'para' }
+            ];
+            expect(lastblock('', blocks)).toBe('inline');
+        });
+    });
+
+    // ── Raw-fallback tests ────────────────────────────────────────────────────
+
+    describe('without blocks (raw fallback)', () => {
+        test('returns last non-empty line of raw', () => {
+            expect(lastblock('line one\nline two', null)).toBe('line two');
+        });
+
+        test('skips trailing empty lines in raw', () => {
+            expect(lastblock('line one\nline two\n\n', null)).toBe('line two');
+        });
+
+        test('returns the only non-empty line', () => {
+            expect(lastblock('\n\n hello world \n', null)).toBe(' hello world ');
+        });
+
+        test('returns line as-is (untrimmed) from raw', () => {
+            expect(lastblock('  trimmed  ', null)).toBe('  trimmed  ');
+        });
+
+        test('returns ERROR when raw is all empty lines', () => {
+            expect(lastblock('\n\n\n', null)).toBe('ERROR');
+        });
+
+        test('returns ERROR for empty raw string', () => {
+            expect(lastblock('', null)).toBe('ERROR');
+        });
+
+        test('handles windows-style line endings in raw', () => {
+            expect(lastblock('first\r\nsecond', null)).toBe('second');
+        });
+
+        test('falls back to raw when blocks is an empty array', () => {
+            expect(lastblock('fallback line', [])).toBe('fallback line');
+        });
+    });
+});

tests/jest/ascii.extractors.lastcalc.test.js

@@ -0,0 +1,62 @@
+import lastcalc from '../../corsscripts/ascii/extractors/lastcalc.js';
+
+describe('lastcalc extractor', () => {
+
+    describe('with blocks', () => {
+        test('returns trimmed content of a single calculation block', () => {
+            const blocks = [{ type: 'calculation', raw: '1 + 1' }];
+            expect(lastcalc('', blocks)).toBe('1 + 1');
+        });
+
+        test('trims whitespace from the calculation block raw', () => {
+            const blocks = [{ type: 'calculation', raw: '  x^2  ' }];
+            expect(lastcalc('', blocks)).toBe('x^2');
+        });
+
+        test('returns trimmed content of the last calculation block when multiple exist', () => {
+            const blocks = [
+                { type: 'calculation', raw: 'first calc' },
+                { type: 'calculation', raw: 'last calc' }
+            ];
+            expect(lastcalc('', blocks)).toBe('last calc');
+        });
+
+        test('scans bottom-up: last calculation block wins over earlier ones', () => {
+            const blocks = [
+                { type: 'code_inline', raw: 'irrelevant' },
+                { type: 'calculation', raw: 'calc one' },
+                { type: 'code_inline', raw: 'also irrelevant' },
+                { type: 'calculation', raw: 'calc two' }
+            ];
+            expect(lastcalc('', blocks)).toBe('calc two');
+        });
+
+        test('ignores non-calculation blocks', () => {
+            const blocks = [
+                { type: 'code_inline', raw: 'not a calc' },
+                { type: 'calculation', raw: 'calc one' },
+                { type: 'asciimath_block', raw: 'also not a calc' }
+            ];
+            expect(lastcalc('', blocks)).toBe('calc one');
+        });
+
+        test('returns ERROR when blocks array contains no calculation blocks', () => {
+            const blocks = [{ type: 'paragraph', raw: 'some text' }];
+            expect(lastcalc('', blocks)).toBe('ERROR');
+        });
+
+        test('returns ERROR for an empty blocks array', () => {
+            expect(lastcalc('', [])).toBe('ERROR');
+        });
+    });
+
+    describe('without blocks', () => {
+        test('returns ERROR when blocks is null', () => {
+            expect(lastcalc('anything', null)).toBe('ERROR');
+        });
+
+        test('returns ERROR when blocks is undefined', () => {
+            expect(lastcalc('anything', undefined)).toBe('ERROR');
+        });
+    });
+});