#fi-51 contour plot fill test case

monfera · monfera · commit e3a80cef19a0 · 2016-05-13T16:17:50.000+02:00
diff --git a/package.json b/package.json
@@ -54,7 +54,7 @@
     "delaunay-triangulate": "^1.1.6",
     "es6-promise": "^3.0.2",
     "fast-isnumeric": "^1.1.1",
-    "gl-contour2d": "^1.0.1",
+    "gl-contour2d": "git://github.com/monfera/gl-contour2d.git#integration",
     "gl-error2d": "^1.0.0",
     "gl-error3d": "^1.0.0",
     "gl-heatmap2d": "^1.0.2",
diff --git a/src/traces/contourgl/convert.js b/src/traces/contourgl/convert.js
@@ -99,6 +99,14 @@ proto.update = function(fullTrace, calcTrace) {
     this.contourOptions.levels = colorOptions.levels;
     this.contourOptions.levelColors = colorOptions.levelColors;
 
+    // pass on fill information
+    if(fullTrace.contours.coloring === 'fill') {
+        // though gl-contour2d automatically defaults to a transparent layer for the last
+        // band color, it's set manually here in case the gl-contour2 API changes
+        this.contourOptions.fillColors = colorOptions.levelColors.concat([0,0,0,0])
+            .map(function(d, i) {return i % 4 === 3 ? d / 2 : d}); // halve the fill alphas
+    }
+
     // convert text from 2D -> 1D
     this.textLabels = [].concat.apply([], fullTrace.text);
 
diff --git a/test/jasmine/assets/fail_test.js b/test/jasmine/assets/fail_test.js
@@ -0,0 +1,22 @@
+'use strict';
+
+/**
+ * Errors thrown in promise 'then'-s fail silently unless handled e.g. this way. A silent failure would probably
+ * make at least some of the test assertions to be bypassed, i.e. a clean jasmine test run could result even if
+ * some assertions were to fail, had the error been removed.
+ *
+ * @example
+ *
+ *       Plotly.plot(...)
+ *           .then(function(gd) {
+ *               assert(...);
+ *               assert(...);
+ *            })
+ *            .catch(failTest)
+ *            .then(done);
+ *
+ *    See ./with_setup_teardown.js for a different example.
+ */
+module.exports = function failTest(error) {
+    expect(error).toBeUndefined();
+};
diff --git a/test/jasmine/assets/with_setup_teardown.js b/test/jasmine/assets/with_setup_teardown.js
@@ -0,0 +1,84 @@
+'use strict';
+
+var Plotly = require('@lib/index');
+
+var createGraphDiv = require('./create_graph_div');
+var destroyGraphDiv = require('./destroy_graph_div');
+
+var failTest = require('./fail_test');
+
+function teardown(gd) {
+
+    Plotly.purge(gd);
+
+    destroyGraphDiv();
+
+}
+
+/**
+ *  Provides a safe means of setting up and tearing down a plot (which may or may not have WebGL elements).
+ *  It is a self-contained alternative to the manual setup/teardown process, which uses:
+ *    - createGraphDiv in the beforeEach, assigning it to global variable gd
+ *    - purg, destroyGraphDiv in the afterEach
+ *
+ *    In theory we could incorporate a .then(done) clause here, as well as a ./failTest but there may be
+ *    test cases that want to call done() manually inside a testing function or somewhere in a .then
+ *
+ *    @param {Function} runner  A function that runs tests, taking two arguments: 'gd' and 'done'
+ *                              withSetupTeardown binds the newly setup graph div to gd and
+ *                              calls the graph div teardown before calling done. Therefore the actual
+ *                              test case doesn't need to know where gd comes from, and can call 'done()'
+ *                              as usual.
+ *    @param {Function} done    The 'done' function that gets passed to the testcase (describe or it)
+ *                              for the purpose of handling asynchronous tests (typically invoked as the
+ *                              last expression in the last .then or window.timeout of the test case
+ *
+ *    @example
+ *
+ *            it('should respond to drag interactions with mock of unset camera', done => {
+ *                       withSetupTeardown(done, (gd, done) => {
+ *                               makePlot(gd, require('@mocks/myMock.json'))
+ *                                   .then(gd => {
+ *                                       expect(...);
+ *                                       expect(...);
+ *                                       expect(...);
+ *                                       done(); // best ignored, as we still do a failTest and then(done)
+ *                                   })
+ *                           }
+ *                       );
+ *                   });
+ *
+ */
+module.exports = function withSetupTeardown(done, runner) {
+
+    var gd = createGraphDiv();
+
+    // Passing a teardown-inducing 'done' as a second, optional argument makes possible those test cases where
+    // the test writer wants to explicitly call 'done', e.g. at the end of a window.setTimeout - cleanup must
+    // happen in this case too.
+    var possibleThenable = runner(gd, function() {
+        teardown(gd);
+        done();
+    });
+
+    // A test case can only be called 'done' after the teardown had been performed.
+    // One way of helping ensure that the destroys are not forgotten is that done() is part of
+    // the teardown, consequently if a test case omits the teardown by accident, the test will
+    // visibly hang. If the teardown receives no proper arguments, it'll also visibly fail.
+
+    if(possibleThenable && possibleThenable.then && typeof possibleThenable.then === 'function') {
+
+        return possibleThenable
+            // needs to catch via failTest otherwise errors inside the .then silently fail (tests may fail to fail)
+            .then(null, failTest) // current linter balks on .catch with 'dot-notation'; fixme a linter
+            .then(function() {
+                teardown(gd);
+            })
+            .then(done);
+
+    } else {
+
+        return possibleThenable;
+
+    }
+};
diff --git a/test/jasmine/tests/gl_plot_interact_basic_test.js b/test/jasmine/tests/gl_plot_interact_basic_test.js
@@ -1,101 +1,68 @@
 'use strict';
 
 var Plotly = require('@lib/index');
-var Plots = require('@src/plots/plots');
 
-var createGraphDiv = require('../assets/create_graph_div');
-var destroyGraphDiv = require('../assets/destroy_graph_div');
+var withSetupTeardown = require('../assets/with_setup_teardown');
 var mouseEvent = require('../assets/mouse_event');
 
-function teardown(gd, done) {
+// Expected shape of projection-related data
+var cameraStructure = {
+    up: {x: jasmine.any(Number), y: jasmine.any(Number), z: jasmine.any(Number)},
+    center: {x: jasmine.any(Number), y: jasmine.any(Number), z: jasmine.any(Number)},
+    eye: {x: jasmine.any(Number), y: jasmine.any(Number), z: jasmine.any(Number)}
+};
 
-    // The teardown function needs information of what to tear down so afterEach can not be used without global vars.
-    // In addition to removing the plot from the DOM it also destroy possibly present 2D or 3D scenes
-
-    // TODO we should figure out something to only rely on public API calls
-    // In other words, how can users themselves properly destroy the plot through the API?
-    // This function is left in this file until the above todo is looked into.
-    var fullLayout = gd._fullLayout;
-
-    Plots.getSubplotIds(fullLayout, 'gl3d').forEach(function(sceneId) {
-        var scene = fullLayout[sceneId]._scene;
-        if(scene.glplot) scene.destroy();
-    });
-
-    Plots.getSubplotIds(fullLayout, 'gl2d').forEach(function(sceneId) {
-        var scene2d = fullLayout._plots[sceneId]._scene2d;
-        if(scene2d.glplot) {
-            scene2d.stopped = true;
-            scene2d.destroy();
-        }
-    });
-
-    destroyGraphDiv();
-
-    // A test case can only be called 'done' when the above destroy methods had been performed.
-    // One way of helping ensure that the destroys are not forgotten is that done() is part of
-    // the teardown, consequently if a test case omits the teardown by accident, the test will
-    // visibly hang. If the teardown receives no proper arguments, it'll also visibly fail.
-    done();
+function makePlot(gd, mock) {
+    return Plotly.plot(gd, mock.data, mock.layout);
 }
 
-describe('Test gl plot interactions', function() {
-
-    describe('gl3d plots', function() {
-
-        // Expected shape of projection-related data
-        var cameraStructure = {
-            up: {x: jasmine.any(Number), y: jasmine.any(Number), z: jasmine.any(Number)},
-            center: {x: jasmine.any(Number), y: jasmine.any(Number), z: jasmine.any(Number)},
-            eye: {x: jasmine.any(Number), y: jasmine.any(Number), z: jasmine.any(Number)}
-        };
-
-        function makePlot(mock) {
-            return Plotly.plot(createGraphDiv(), mock.data, mock.layout);
-        }
+function addEventCallback(graphDiv) {
+    var relayoutCallback = jasmine.createSpy('relayoutCallback');
+    graphDiv.on('plotly_relayout', relayoutCallback);
+    return {graphDiv: graphDiv, relayoutCallback: relayoutCallback};
+}
 
-        function addEventCallback(graphDiv) {
-            var relayoutCallback = jasmine.createSpy('relayoutCallback');
-            graphDiv.on('plotly_relayout', relayoutCallback);
-            return {graphDiv: graphDiv, relayoutCallback: relayoutCallback};
-        }
+function verifyInteractionEffects(tuple) {
 
-        function verifyInteractionEffects(tuple) {
+    // One 'drag': simulating fairly thoroughly as the mouseup event is also needed here
+    mouseEvent('mousemove', 400, 200);
+    mouseEvent('mousedown', 400, 200);
+    mouseEvent('mousemove', 320, 320, {buttons: 1});
+    mouseEvent('mouseup', 320, 320);
 
-            // One 'drag': simulating fairly thoroughly as the mouseup event is also needed here
-            mouseEvent('mousemove', 400, 200);
-            mouseEvent('mousedown', 400, 200);
-            mouseEvent('mousemove', 320, 320, {buttons: 1});
-            mouseEvent('mouseup', 320, 320);
+    // Check event emission count
+    expect(tuple.relayoutCallback).toHaveBeenCalledTimes(1);
 
-            // Check event emission count
-            expect(tuple.relayoutCallback).toHaveBeenCalledTimes(1);
+    // Check structure of event callback value contents
+    expect(tuple.relayoutCallback).toHaveBeenCalledWith(jasmine.objectContaining({scene: cameraStructure}));
 
-            // Check structure of event callback value contents
-            expect(tuple.relayoutCallback).toHaveBeenCalledWith(jasmine.objectContaining({scene: cameraStructure}));
+    // Check camera contents on the DIV layout
+    var divCamera = tuple.graphDiv.layout.scene.camera;
 
-            // Check camera contents on the DIV layout
-            var divCamera = tuple.graphDiv.layout.scene.camera;
+    expect(divCamera).toEqual(cameraStructure);
 
-            expect(divCamera).toEqual(cameraStructure);
+    return tuple.graphDiv;
+}
 
-            return tuple.graphDiv;
-        }
+function testEvents(plot) {
+    return plot
+        .then(function(graphDiv) {
+            var tuple = addEventCallback(graphDiv); // TODO disuse tuple with ES6
+            verifyInteractionEffects(tuple);
+        });
+}
 
-        function testEvents(plot, done) {
-            plot.then(function(graphDiv) {
-                var tuple = addEventCallback(graphDiv); // TODO disuse tuple with ES6
-                verifyInteractionEffects(tuple);
-                teardown(graphDiv, done);
-            });
-        }
+describe('gl3d plots', function() {
 
-        it('should respond to drag interactions with mock of unset camera', function(done) {
-            testEvents(makePlot(require('@mocks/gl3d_scatter3d-connectgaps.json')), done);
+    it('should respond to drag interactions with mock of unset camera', function(done) {
+        withSetupTeardown(done, function(gd) {
+            return testEvents(makePlot(gd, require('@mocks/gl3d_scatter3d-connectgaps.json')));
         });
+    });
 
-        it('should respond to drag interactions with mock of partially set camera', function(done) {
-            testEvents(makePlot(require('@mocks/gl3d_errorbars_zx.json')), done);
+    it('should respond to drag interactions with mock of partially set camera', function(done) {
+        withSetupTeardown(done, function(gd) {
+            return testEvents(makePlot(gd, require('@mocks/gl3d_errorbars_zx.json')));
         });
     });
 });
diff --git a/test/jasmine/tests/gl_scatterplot_contour_test.js b/test/jasmine/tests/gl_scatterplot_contour_test.js
@@ -0,0 +1,100 @@
+'use strict';
+
+var Plotly = require('@lib/index');
+
+// contourgl is not part of the dist plotly.js bundle initially
+Plotly.register(
+    require('@lib/contourgl')
+);
+
+var withSetupTeardown = require('../assets/with_setup_teardown');
+
+var plotData = {
+    "data": [
+        {
+            "type": "contourgl",
+            "z": [
+                [
+                    10,
+                    10.625,
+                    12.5,
+                    15.625,
+                    20
+                ],
+                [
+                    5.625,
+                    6.25,
+                    8.125,
+                    11.25,
+                    15.625
+                ],
+                [
+                    2.5,
+                    3.125,
+                    5,
+                    8.125,
+                    12.5
+                ],
+                [
+                    0.625,
+                    1.25,
+                    3.125,
+                    6.25,
+                    10.625
+                ],
+                [
+                    0,
+                    0.625,
+                    2.5,
+                    5.625,
+                    10
+                ]
+            ],
+            "colorscale": "Jet",
+            "contours": {
+                "start": 2,
+                "end": 10,
+                "size": 1
+            },
+            "uid": "ad5624",
+            "zmin": 0,
+            "zmax": 20
+        }
+    ],
+    "layout": {
+        "xaxis": {
+            "range": [
+                0,
+                4
+            ],
+            "autorange": true
+        },
+        "yaxis": {
+            "range": [
+                0,
+                4
+            ],
+            "autorange": true
+        },
+        "height": 450,
+        "width": 1000,
+        "autosize": true
+    }
+};
+
+function makePlot(gd, mock) {
+    return Plotly.plot(gd, mock.data, mock.layout);
+}
+
+fdescribe('contourgl plots', function() {
+
+    it('render without raising an error', function(done) {
+        withSetupTeardown(done, function(gd) {
+            return makePlot(gd, plotData)
+                .then(function(gd) {
+                    //debugger;
+                })
+        });
+    });
+
+});
