migrated Canvas, DragAndDrop, Global, and Tween tests to mocha

test/runner.html

@@ -38,8 +38,14 @@
     <script src="assets/worldMap.js"></script>
 
     <!-- core -->
-    <script src="unit/Node-test.js"></script>
+    <script src="unit/Global-test.js"></script>
     <script src="unit/Util-test.js"></script>
+    <script src="unit/Canvas-test.js"></script>
+    <script src="unit/Node-test.js"></script>
+
+    <!-- extensions -->
+    <script src="unit/DragAndDrop-test.js"></script>
+    <script src="unit/Tween-test.js"></script>
 
     <!-- shapes -->
     <script src="unit/shapes/Rect-test.js"></script>

test/unit/Canvas-test.js

@@ -0,0 +1,39 @@
+suite('Canvas', function() {
+    // ======================================================
+    test('pixel ratio', function() {
+        var stage = addStage();
+
+        var layer = new Kinetic.Layer();
+
+        var circle = new Kinetic.Circle({
+            x: 578/2,
+            y: 100,
+            radius: 70,
+            fill: 'green',
+            stroke: 'blue',
+            strokeWidth: 4
+        });
+
+        layer.add(circle);
+        stage.add(layer);
+
+
+        stage.setWidth(578/2);
+        stage.setHeight(100);
+
+        stage.draw();
+
+        layer.getCanvas().setPixelRatio(1);
+        assert.equal(layer.getCanvas().getPixelRatio(), 1);
+        assert.equal(layer.getCanvas().width, 289);
+        assert.equal(layer.getCanvas().height, 100);
+
+        layer.getCanvas().setPixelRatio(2);
+        assert.equal(layer.getCanvas().getPixelRatio(), 2);
+        assert.equal(layer.getCanvas().width, 578);
+        assert.equal(layer.getCanvas().height, 200);
+
+        layer.draw();
+
+    });
+});

test/unit/DragAndDrop-test.js

@@ -0,0 +1,55 @@
+suite('DragAndDrop', function() {
+
+    // ======================================================
+    test('test drag and drop properties and methods', function() {
+        var stage = addStage();
+        var layer = new Kinetic.Layer();
+        var circle = new Kinetic.Circle({
+            x: stage.getWidth() / 2,
+            y: stage.getHeight() / 2,
+            radius: 70,
+            fill: 'green',
+            stroke: 'black',
+            strokeWidth: 4,
+            name: 'myCircle'
+        });
+
+        stage.add(layer);
+        layer.add(circle);
+        layer.draw();
+
+        // test defaults
+        assert.equal(circle.isDraggable(), false);
+
+        //change properties
+        circle.setDraggable(true);
+
+        // test new properties
+        assert.equal(circle.getDraggable(), true);
+    });
+
+    // ======================================================
+    test('multiple drag and drop sets with setDraggable()', function() {
+        var stage = addStage();
+        var layer = new Kinetic.Layer();
+        var circle = new Kinetic.Circle({
+            x: 380,
+            y: stage.getHeight() / 2,
+            radius: 70,
+            strokeWidth: 4,
+            fill: 'red',
+            stroke: 'black'
+        });
+
+        circle.setDraggable(true);
+        assert.equal(circle.getDraggable(), true);
+        circle.setDraggable(true);
+        assert.equal(circle.getDraggable(), true);
+        circle.setDraggable(false);
+        assert.equal(!circle.getDraggable(), true);
+
+        layer.add(circle);
+        stage.add(layer);
+
+    });
+});

test/unit/Global-test.js

@@ -0,0 +1,7 @@
+suite('Global', function() {
+
+    // ======================================================
+    test('test Kinetic version number', function() {
+        assert.equal(Kinetic.version, 'dev');
+    });
+});

test/unit/Tween-test.js

@@ -0,0 +1,105 @@
+suite('Tween', function() {
+
+    // ======================================================
+    test('tween node', function(done) {
+        var stage = addStage();
+
+        var layer = new Kinetic.Layer();
+
+        var circle = new Kinetic.Circle({
+            x: 100,
+            y: stage.getHeight() / 2,
+            radius: 70,
+            fill: 'green',
+            stroke: 'blue',
+            strokeWidth: 4
+        });
+
+        layer.add(circle);
+        stage.add(layer);
+
+        var finishCount = 0;
+        var onFinish = function() {
+            assert(++finishCount <= 1, 'finishCount should not exceed 1');
+            done();
+        }
+
+        var tweens = 0;
+        var attrs = 0;
+
+        for (var key in Kinetic.Tween.tweens) {
+            tweens++;
+        }
+        for (var key in Kinetic.Tween.attrs) {
+            attrs++;
+        }
+
+        assert.equal(tweens, 0);
+        assert.equal(attrs, 0);
+
+        var tween = new Kinetic.Tween({
+            node: circle,
+            duration: 0.2,
+            x: 200,
+            y: 100,
+            onFinish: onFinish
+        }).play();
+
+        var tweens = 0;
+        var attrs = 0;
+        for (var key in Kinetic.Tween.tweens) {
+            tweens++;
+        }
+        for (var key in Kinetic.Tween.attrs[circle._id][tween._id]) {
+            attrs++;
+        }
+
+        assert.equal(tweens, 1);
+        assert.equal(attrs, 2);
+
+        assert.notEqual(Kinetic.Tween.attrs[circle._id][tween._id].x, undefined);
+        assert.notEqual(Kinetic.Tween.attrs[circle._id][tween._id].y, undefined);
+
+    });
+
+    // ======================================================
+    test('tween node', function() {
+        var stage = addStage();
+
+        var layer = new Kinetic.Layer();
+
+        var circle = new Kinetic.Circle({
+            x: 100,
+            y: stage.getHeight() / 2,
+            radius: 70,
+            fill: 'green',
+            stroke: 'blue',
+            strokeWidth: 4
+        });
+
+        layer.add(circle);
+        stage.add(layer);
+
+
+        var tween = new Kinetic.Tween({
+            node: circle,
+            duration: 0.2,
+            x: 200,
+            y: 100
+        }).play();
+
+        // start/diff object = attrs.nodeId.tweenId.attr
+        // tweenId = tweens.nodeId.attr
+
+        assert.notEqual(tween._id, undefined);
+        assert.equal(Kinetic.Tween.tweens[circle._id].x, tween._id);
+        assert.notEqual(Kinetic.Tween.attrs[circle._id][tween._id], undefined);
+
+        tween.destroy();
+
+        assert.equal(Kinetic.Tween.tweens[circle._id].x, undefined);
+        assert.equal(Kinetic.Tween.attrs[circle._id][tween._id], undefined);
+
+
+    });
+});