Merge pull request #335 from Dessia-tech/dev

v0.21.0

Author: Tanguylo

.gitignore

@@ -2,7 +2,6 @@ node_modules/
 lib/
 libdev/
 
-
 # CAD files
 *.fcstd
 *.fcstd1
@@ -60,6 +59,12 @@ coverage.xml
 *.cover
 .hypothesis/
 .pytest_cache/
+instrumented/
+coverage/
+libtest/
+.nycrc
+.nyc_output
+.vscode
 
 # Translations
 *.mo

.npmignore

@@ -1,9 +1,11 @@
 “files”: [“lib/**/*”]
 /cypress
 /build
+/instrumented
 /doc
 /lib/cypress
 /libdev
+/libtest
 /plot_data
 /plot_data.egg-info
 /script

.nycrc

@@ -0,0 +1,3 @@
+{
+    "extends": "@istanbuljs/nyc-config-typescript"
+}

CHANGELOG.md

@@ -5,8 +5,13 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.21.0]
+### Add
+- Tests of typescript app
+
 ## [0.20.0]
 ### Add
+- Tests for most of important features
 - Toggle Axes
 - Customable axes names of Draw
 

cypress.config.ts

@@ -2,6 +2,7 @@ import { defineConfig } from "cypress";
 import getCompareSnapshotsPlugin from "cypress-visual-regression/dist/plugin";
 import fs from 'fs'
 import path from 'path'
+import registerCodeCoverageTasks from '@cypress/code-coverage/task'
 
 const HEIGHT: number = 710;
 const WIDTH: number = 1270;
@@ -26,8 +27,11 @@ export default defineConfig({
     type: 'actual' //'base',
   },
   e2e: {
+    specPattern: 'cypress/e2e/*',
     experimentalStudio : true,
     setupNodeEvents(on, config) {
+      registerCodeCoverageTasks(on, config);
+
       getCompareSnapshotsPlugin(on, config);
 
       on('before:browser:launch', (browser, launchOptions) => {
@@ -59,6 +63,8 @@ export default defineConfig({
           })
         })
       });
+
+      return config
     },
   }
 });

cypress/e2e/axes.cy.ts

@@ -0,0 +1,228 @@
+import { Vertex } from "../../instrumented/baseShape";
+import { Rect } from "../../instrumented/primitives";
+import { Axis, ParallelAxis } from "../../instrumented/axes";
+
+const vector = [1, 2, 3, 4, 5];
+const boundingBox = new Rect(new Vertex(0, 0), new Vertex(500, 500));
+const origin = new Vertex(0, 0);
+const end = new Vertex(0, 100);
+const name = "";
+const initScale = new Vertex(1, 1);
+const nTicks = 5;
+
+describe('Axis', function() {
+  it('should draw the axis on the canvas', function() {
+    const canvas = document.createElement('canvas');
+    const context = canvas.getContext('2d');
+    const axis = new Axis(vector, boundingBox, origin, end, name, initScale, nTicks);
+
+    cy.spy(context, 'fill');
+    cy.spy(context, 'stroke');
+
+    axis.draw(context);
+
+    cy.wrap(context.fill).should('have.been.calledWith', axis.drawPath);
+    cy.wrap(context.stroke).should('have.been.calledWith', axis.drawPath);
+  });
+
+  it('should be well created without vector features', function() {
+    const axis = new Axis(null, boundingBox, origin, end, name, initScale, nTicks);
+    const ticks = [-1, 0, 1, 2]
+    expect(axis.ticks).to.deep.equal(ticks);
+    expect(axis.isDiscrete, `isDiscrete`).to.be.true;
+});
+
+  it('should be well created with empty vector features', function() {
+    const axis = new Axis([], boundingBox, origin, end, name, initScale, nTicks);
+    const ticks = [-1, 0, 1, 2]
+    axis.ticks.forEach((tick, index) => expect(tick, `tick ${index}`).to.equal(ticks[index]));
+    expect(axis.isDiscrete, `isDiscrete`).to.be.true;
+  });
+
+  it('should be well created without only one feature', function() {
+    const axis = new Axis([1], boundingBox, origin, end, name, initScale, nTicks);
+    expect(axis.ticks.length, `length ticks`).to.equal(7);
+  });
+
+  it("should scale axis with another one", function() {
+    const axis = new Axis(vector, boundingBox, origin, end, name, initScale, nTicks);
+    const otherVector = [10, 11, 12, 13, 14, 32.4];
+    const otherAxis = new Axis(otherVector, boundingBox, origin, end, name, initScale, nTicks);
+    axis.otherAxisScaling(otherAxis);
+    expect(axis.minValue, "minValue").to.be.closeTo(-9.3, 0.1);
+    expect(axis.maxValue, "maxValue").to.be.closeTo(15.3, 0.1);
+    expect((axis.maxValue - axis.minValue) / axis.drawLength, "ratio").to.be.closeTo((otherAxis.maxValue - otherAxis.minValue) / otherAxis.drawLength, 0.01);
+  })
+
+  it('should update the origin and end points of the axis', function() {
+    const axis = new Axis(vector, boundingBox, origin, end, name, initScale, nTicks);
+    const newOrigin = new Vertex(100, 100);
+    const newEnd = new Vertex(100, 200);
+    axis.transform(newOrigin, newEnd);
+
+    expect(axis.origin.x, "origin.x").to.equal(newOrigin.x);
+    expect(axis.end.y, "end.y").to.equal(newEnd.y);
+  });
+
+  it('should change axis scale', function() {
+    const axis = new Axis(vector, boundingBox, origin, end, name, initScale, nTicks);
+    const viewPoint = new Vertex(20, 20);
+    const scaling = new Vertex(2, 0.5);
+    const translation = new Vertex();
+    axis.updateScale(viewPoint, scaling, translation);
+
+    expect(axis.minValue, "minValue").to.be.closeTo(-0.08, 0.005);
+    expect(axis.maxValue, "maxValue").to.be.closeTo(8.7, 0.05);
+  });
+
+  it('should update axis with translation and style', function() {
+    const axis = new Axis(vector, boundingBox, origin, end, name, initScale, nTicks);
+    const viewPoint = new Vertex(0, 0);
+    const scaling = new Vertex(1, 1);
+    const translation = new Vertex(4 * axis.transformMatrix.a, 4 * axis.transformMatrix.a);
+    const axisStyle = new Map<string, any>([
+      ["lineWidth", 3],
+      ["strokeStyle", "hsl(12, 45%, 80%)"]
+    ])
+    axis.update(axisStyle, viewPoint, scaling, translation);
+
+    expect(axis.minValue, "minValue").to.be.closeTo(-3.2, 0.1);
+    expect(axis.maxValue, "maxValue").to.be.closeTo(1.2, 0.1);
+    expect(axis.lineWidth, "lineWidth").to.be.equal(3);
+    expect(axis.strokeStyle, "strokeStyle").to.equal("hsl(12, 45%, 80%)")
+  });
+
+  it('should reset scale and translation', function() {
+    const axis = new Axis(vector, boundingBox, origin, end, name, initScale, nTicks);
+    axis.updateScale(new Vertex(20, 20), new Vertex(2, 0.5), new Vertex());
+    axis.updateScale(new Vertex(), new Vertex(1, 1), new Vertex(25, 25));
+    axis.resetScale();
+
+    expect(axis.minValue, "minValue").to.be.equal(0.8);
+    expect(axis.maxValue, "maxValue").to.be.equal(5.2);
+  });
+
+  it("should transform a string array into values array for ticks to be drawn", function() {
+    const stringVector = ["z", "e", "z", "y", "o", "u", "p", "i", "p", "p"];
+    const stringAxis = new Axis(stringVector, boundingBox, origin, end, name, initScale, nTicks);
+    const numberVector = [1, 1, 1, 2, 3, 3, 3, 4, 5, 5, 5, 5];
+    const numberAxis = new Axis(numberVector, boundingBox, origin, end, name, initScale, nTicks);
+    const numericStringVector = stringAxis.stringsToValues(stringVector);
+    const numericNumberVector = numberAxis.stringsToValues(numberVector);
+
+    numericStringVector.forEach((value, index) => expect(stringAxis.labels[value], `string value ${index}`).to.equal(stringVector[index]));
+    numericNumberVector.forEach((value, index) => expect(value, `number value ${index}`).to.equal(numberVector[index]));
+  })
+});
+
+describe("RubberBand", function() {
+  const canvas = document.createElement('canvas');
+  const context = canvas.getContext('2d');
+  const axis = new Axis(vector, boundingBox, origin, end, name, initScale, nTicks);
+  const mouseClick = new Vertex(0, 50);
+  axis.mouseMove(context, mouseClick);
+  axis.mouseDown(mouseClick);
+  axis.mouseMove(context, new Vertex(0, 75));
+  axis.mouseUp(false);
+
+  it("should draw rubberBand", function() {
+    expect(axis.rubberBand.minValue, "rubberBand minValue").to.be.closeTo(3, 0.001);
+    expect(axis.rubberBand.maxValue, "rubberBand maxValue").to.be.closeTo(4.1, 0.001);
+  });
+
+  it("should translate rubberBand", function () {
+    const mouseClickInRubberBand = new Vertex(0, 60);
+    const previousMinValue = axis.rubberBand.minValue;
+    const previousMaxValue = axis.rubberBand.maxValue;
+    axis.mouseMove(context, mouseClickInRubberBand);
+    axis.mouseDown(mouseClickInRubberBand);
+    axis.mouseMove(context, new Vertex(0, 90));
+    axis.mouseUp(false);
+    expect(axis.rubberBand.minValue, "translated rubberBand minValue").to.not.be.equal(previousMinValue);
+    expect(axis.rubberBand.maxValue, "translated rubberBand maxValue").to.not.be.equal(previousMaxValue);
+    expect(axis.rubberBand.length, "translated rubberBand maxValue").to.be.closeTo(Math.abs(previousMaxValue - previousMinValue), 0.00001);
+  });
+
+  it("should reset rubberBand", function () {
+      axis.reset();
+      expect(axis.rubberBand.minValue, "reset rubberBand minValue").to.equal(0);
+      expect(axis.rubberBand.maxValue, "reset rubberBand maxValue").to.equal(0);
+  });
+});
+
+describe('ParallelAxis', function() {
+
+  const vector = [1, 2, 3, 4, 5];
+  const boundingBox = new Rect(new Vertex(-50, 0), new Vertex(50, 150));
+  const origin = new Vertex(0, 0);
+  const end = new Vertex(0, 100);
+  const name = "parallel axis";
+  const initScale = new Vertex(1, 1);
+  const nTicks = 5;
+
+  it('should draw a vertical axis on the canvas', function() {
+    const canvas = document.createElement('canvas');
+    const context = canvas.getContext('2d');
+    const parallelAxis = new ParallelAxis(vector, boundingBox, origin, end, name, initScale, nTicks);
+
+    parallelAxis.computeTitle(0, 1);
+
+    expect(parallelAxis.titleSettings.baseline, "default baseline").to.be.null;
+    expect(parallelAxis.titleSettings.orientation, "default orientation").to.be.null;
+
+    parallelAxis.draw(context);
+
+    expect(parallelAxis.titleSettings.baseline, "updated baseline").to.be.equal("top");
+    expect(parallelAxis.titleSettings.orientation, "updated orientation").to.be.equal(0);
+  });
+
+  it('should draw a horizontal axis on the canvas', function() {
+    const canvas = document.createElement('canvas');
+    const context = canvas.getContext('2d');
+    const parallelAxis = new ParallelAxis(vector, boundingBox, new Vertex(0, 0), new Vertex(100, 0), name, initScale, nTicks);
+
+    parallelAxis.computeTitle(0, 1);
+
+    expect(parallelAxis.titleSettings.baseline, "default baseline").to.be.null;
+
+    parallelAxis.draw(context);
+
+    expect(parallelAxis.titleSettings.baseline, "updated baseline").to.be.equal("bottom");
+  });
+
+  it('should move when title is moved', function() {
+    const canvas = document.createElement('canvas');
+    const context = canvas.getContext('2d');
+    const parallelAxis = new ParallelAxis(vector, boundingBox, new Vertex(0, 0), new Vertex(100, 0), name, initScale, nTicks);
+    const newLocation = new Vertex(25, 25);
+    parallelAxis.computeTitle(0, 1);
+    parallelAxis.draw(context);
+    parallelAxis.mouseMove(context, parallelAxis.title.boundingBox.center);
+    parallelAxis.mouseDown(parallelAxis.title.boundingBox.center);
+    parallelAxis.mouseMove(context, newLocation);
+
+    expect(parallelAxis.origin.x, "origin x").to.be.closeTo(18.15, 0.01);
+    expect(parallelAxis.origin.y, "origin y").to.be.closeTo(55, 0.01);
+
+    parallelAxis.mouseUp(false);
+
+    expect(parallelAxis.isClicked, "isClicked").to.be.false;
+  });
+
+  it('should flip when title is clicked', function() {
+    const canvas = document.createElement('canvas');
+    const context = canvas.getContext('2d');
+    const parallelAxis = new ParallelAxis(vector, boundingBox, new Vertex(0, 0), new Vertex(100, 0), name, initScale, nTicks);
+    let emittedAxis;
+    parallelAxis.emitter.on("axisStateChange", (updatedAxis) =>  emittedAxis = updatedAxis);
+    parallelAxis.computeTitle(0, 1);
+    parallelAxis.draw(context);
+    parallelAxis.mouseMove(context, parallelAxis.title.boundingBox.center);
+    parallelAxis.mouseDown(parallelAxis.title.boundingBox.center);
+    parallelAxis.mouseUp(false);
+
+    expect(parallelAxis.isInverted, "isInverted").to.be.true;
+    expect(emittedAxis).to.deep.equal(parallelAxis);
+  });
+
+});