Test the selection interpreter

Author: darkriszty

test/unitTests/modelFactory/selectionInterpreter.test.ts

@@ -0,0 +1,61 @@
+import * as assert from 'assert';
+import { SelectionInterpreter } from '../../../src/modelFactory/selectionInterpreter';
+
+suite("SelectionInterpreter tests", () => {
+
+    test("allRows() splits text by windows-style line endings", () => {
+        const text = "line1\r\nline2";
+        const sut = createSut();
+
+        const rows = sut.allRows(text);
+
+        assert.equal(rows.length, 2);
+        assert.equal(rows[0].length, 1);
+        assert.equal(rows[1].length, 1);
+        assert.equal(rows[0][0], "line1");
+        assert.equal(rows[1][0], "line2");
+    });
+
+    test("allRows() splits text by linux-style line endings", () => {
+        const text = "foo\nbar";
+        const sut = createSut();
+
+        const rows = sut.allRows(text);
+
+        assert.equal(rows.length, 2);
+        assert.equal(rows[0].length, 1);
+        assert.equal(rows[1].length, 1);
+        assert.equal(rows[0][0], "foo");
+        assert.equal(rows[1][0], "bar");
+    });
+
+    test("allRows() splits each line by | cell separator", () => {
+        const text = "h1|h2\nv1|v2";
+        const sut = createSut();
+
+        const rows = sut.allRows(text);
+
+        assert.equal(rows.length, 2);
+        assert.equal(rows[0].length, 2);
+        assert.equal(rows[1].length, 2);
+        assert.equal(rows[0][0], "h1");
+        assert.equal(rows[0][1], "h2");
+        assert.equal(rows[1][0], "v1");
+        assert.equal(rows[1][1], "v2");
+    });
+
+    test("separator() returns the first row", () => {
+        const text = "h1|h2\r\n:-|-\r\nv1|v2";
+        const sut = createSut();
+
+        const separator = sut.separator(text);
+
+        assert.equal(separator.length, 2);
+        assert.equal(separator[0], ":-");
+        assert.equal(separator[1], "-");
+    });
+
+    function createSut(): SelectionInterpreter {
+        return new SelectionInterpreter();
+    }
+});

test/unitTests/modelFactory/tableFactory.test.ts

@@ -101,7 +101,26 @@ suite("TableFactory tests", () => {
         assert.equal(result, transformedTable);
     });
 
-    function createFactory(): TableFactory {
-        return new TableFactory(_alignmentFactoryMock.object, new SelectionInterpreter(), _transformer.object);
+    test("getModel() calls selection interpreter to get rows", () => {
+        const expectedAlignmets: Alignment[] = [ Alignment.Left, Alignment.Left, Alignment.Left, Alignment.Left ];
+        const transformedTable = new Table([["c1", "c2", "", "c4"], ["a", "b", "", "d"]].map(row => row.map(c  => new Cell(c))), expectedAlignmets);
+        _alignmentFactoryMock.setup(m => m.createAlignments(It.isAny())).returns(() => expectedAlignmets);
+        _transformer.setup(_ => _.process(It.isAny())).returns(() => transformedTable);
+        let selectionInterpreter: IMock<SelectionInterpreter> = Mock.ofType<SelectionInterpreter>();
+        selectionInterpreter
+            .setup(_ => _.allRows(It.isAny()))
+            .returns(() => [["c1", "c2", "", "c4"], ["-","-","-","-"], ["a", "b", "", "d"]])
+            .verifiable(Times.once());
+        const sut = createFactory(selectionInterpreter.object);
+
+        sut.getModel("test");
+
+        selectionInterpreter.verifyAll();
+    });
+
+    function createFactory(selectionInterpreter: SelectionInterpreter = null): TableFactory {
+        return new TableFactory(_alignmentFactoryMock.object, 
+            selectionInterpreter == null ? new SelectionInterpreter() : selectionInterpreter, 
+            _transformer.object);
     }
 });

test/unitTests/modelFactory/tableValidator.test.ts

@@ -1,4 +1,5 @@
 import * as assert from 'assert';
+import { IMock, Mock, It, Times } from 'typemoq';
 import { Table } from "../../../src/models/table";
 import { TableValidator } from "../../../src/modelFactory/tableValidator";
 import { Alignment } from "../../../src/models/alignment";
@@ -140,7 +141,24 @@ suite("TableValidator tests", () => {
         assert.equal(isValid, true);
     });
 
-    function createSut(): TableValidator {
-        return new TableValidator(new SelectionInterpreter());
+    test("isValid() uses selection interpreter to get rows and separator", () => {
+        let selectionInterpreter: IMock<SelectionInterpreter> = Mock.ofType<SelectionInterpreter>();
+        selectionInterpreter
+            .setup(_ => _.allRows(It.isAny()))
+            .returns(() => [ ["a", "b"], ["-", "-"], ["c", "d"] ])
+            .verifiable(Times.once());
+        selectionInterpreter
+            .setup(_ => _.separator(It.isAny()))
+            .returns(() => ["-", "-"])
+            .verifiable(Times.once());
+        const sut = createSut(selectionInterpreter.object);
+
+        const isValid: boolean = sut.isValid("test");
+
+        selectionInterpreter.verifyAll();
+    });
+
+    function createSut(selectionInterpreter: SelectionInterpreter = null): TableValidator {
+        return new TableValidator(selectionInterpreter == null ? new SelectionInterpreter(): selectionInterpreter);
     }
 });