Merge pull request #41 from canjs/landscaper/qunit2

cherifGsoul · web-flow · commit 321a7a000985 · 2019-05-24T21:41:12.000+01:00
Landscaper: QUnit2 upgrade
diff --git a/async/async-test.js b/async/async-test.js
@@ -28,24 +28,24 @@ QUnit.test('basics', function(assert){
     });
 
     // Unbound and unobserved behavior
-    QUnit.equal(canReflect.getValue(obs), 'default', 'getValue unbound');
+    assert.equal(canReflect.getValue(obs), 'default', 'getValue unbound');
 
     // Unbound , being observed behavior
     ObservationRecorder.start();
-    QUnit.equal(canReflect.getValue(obs), undefined, "getValue being bound");
+    assert.equal(canReflect.getValue(obs), undefined, "getValue being bound");
     var dependencies = ObservationRecorder.stop();
-    QUnit.ok(!dependencies.valueDependencies.has(value), "did not record value");
-    QUnit.ok(dependencies.valueDependencies.has(obs), "did record observable");
-    QUnit.equal(dependencies.valueDependencies.size, 1, "only one value to listen to");
+    assert.ok(!dependencies.valueDependencies.has(value), "did not record value");
+    assert.ok(dependencies.valueDependencies.has(obs), "did record observable");
+    assert.equal(dependencies.valueDependencies.size, 1, "only one value to listen to");
 
     var changes = 0;
     var handler = function(newValue) {
         changes++;
         if(changes === 1) {
-            QUnit.equal(newValue, 'a', 'onValue a');
+            assert.equal(newValue, 'a', 'onValue a');
             value.set(2);
         } else {
-            QUnit.equal(newValue, 'b', 'onValue b');
+            assert.equal(newValue, 'b', 'onValue b');
             done();
         }
     };
@@ -54,7 +54,7 @@ QUnit.test('basics', function(assert){
 });
 
 
-QUnit.test("get and set Priority", function(){
+QUnit.test("get and set Priority", function(assert) {
     var value = new SimpleObservable(1);
 
     var obs = new AsyncObservable(function(lastSet, resolve){
@@ -74,10 +74,10 @@ QUnit.test("get and set Priority", function(){
 
     canReflect.setPriority(obs, 5);
 
-    QUnit.equal(canReflect.getPriority(obs), 5, "set priority");
+    assert.equal(canReflect.getPriority(obs), 5, "set priority");
 });
 
-QUnit.test("prevent a getter returning undefined from overwriting last resolved value", function(){
+QUnit.test("prevent a getter returning undefined from overwriting last resolved value", function(assert) {
     var value = new SimpleObservable(1);
 
     var obs = new AsyncObservable(function(lastSet, resolve){
@@ -89,24 +89,24 @@ QUnit.test("prevent a getter returning undefined from overwriting last resolved
 
     });
     obs.on(function(){});
-    QUnit.equal( obs.get(), null );
+    assert.equal( obs.get(), null );
     value.set(2);
 
-    QUnit.equal( obs.get(), 4 );
+    assert.equal( obs.get(), 4 );
 
 });
 
-QUnit.test("prevent a getter returning undefined from overwriting last resolved value at the start", function(){
+QUnit.test("prevent a getter returning undefined from overwriting last resolved value at the start", function(assert) {
     var value = new SimpleObservable(1);
 
     var obs = new AsyncObservable(function(lastSet, resolve){
         resolve(value.get()*2);
     });
     obs.on(function(){});
-    QUnit.equal( obs.get(), 2 );
+    assert.equal( obs.get(), 2 );
     value.set(2);
 
-    QUnit.equal( obs.get(), 4 );
+    assert.equal( obs.get(), 4 );
 
 });
 
@@ -268,7 +268,7 @@ QUnit.test("resolving, then later returning should not cause duplicate events (#
 	assert.equal(count, 2, "2 change events");
 });
 
-QUnit.test("proactive binding doesn't last past binding (can-stache#486)", function(){
+QUnit.test("proactive binding doesn't last past binding (can-stache#486)", function(assert) {
     var value = new SimpleObservable(2);
 
     var readCount = 0;
@@ -303,6 +303,6 @@ QUnit.test("proactive binding doesn't last past binding (can-stache#486)", funct
 
     value.set(3);
 
-    QUnit.equal(readCount, 1, "internal observation only updated once");
+    assert.equal(readCount, 1, "internal observation only updated once");
 
 });
diff --git a/can-simple-observable-test.js b/can-simple-observable-test.js
@@ -10,52 +10,52 @@ var skipProduction = steal.isEnv("production") ? QUnit.skip : QUnit.test;
 
 QUnit.module('can-simple-observable');
 
-QUnit.test('basics', function(){
-    expect(5);
+QUnit.test('basics', function(assert) {
+    assert.expect(5);
     var obs = new SimpleObservable('one');
 
-    QUnit.equal(canReflect.getValue(obs), 'one', 'getValue');
+    assert.equal(canReflect.getValue(obs), 'one', 'getValue');
 
     canReflect.setValue(obs, 'two');
     ObservationRecorder.start();
-    QUnit.equal(canReflect.getValue(obs), 'two', 'setValue');
+    assert.equal(canReflect.getValue(obs), 'two', 'setValue');
     var dependencies = ObservationRecorder.stop();
-    QUnit.ok(dependencies.valueDependencies.has(obs), "was recorded");
+    assert.ok(dependencies.valueDependencies.has(obs), "was recorded");
 
     var handler = function(newValue) {
-        QUnit.equal(newValue, 'three', 'onValue');
+        assert.equal(newValue, 'three', 'onValue');
     };
     canReflect.onValue(obs, handler);
     canReflect.setValue(obs, 'three');
 
     canReflect.offValue(obs, handler);
     canReflect.setValue(obs, 'four');
 
-    QUnit.equal(canReflect.getValue(obs), 'four', 'getValue after offValue');
+    assert.equal(canReflect.getValue(obs), 'four', 'getValue after offValue');
 });
 
-QUnit.test('basics with .value', function(){
-    expect(5);
+QUnit.test('basics with .value', function(assert) {
+    assert.expect(5);
     var obs = new SimpleObservable('one');
 	
-    QUnit.equal(obs.value, 'one', 'getValue');
+    assert.equal(obs.value, 'one', 'getValue');
 
     obs.value = 'two';
     ObservationRecorder.start();
-    QUnit.equal(obs.value, 'two', 'setValue');
+    assert.equal(obs.value, 'two', 'setValue');
     var dependencies = ObservationRecorder.stop();
-    QUnit.ok(dependencies.valueDependencies.has(obs), "was recorded");
+    assert.ok(dependencies.valueDependencies.has(obs), "was recorded");
 
     var handler = function(newValue) {
-        QUnit.equal(newValue, 'three', 'onValue');
+        assert.equal(newValue, 'three', 'onValue');
     };
     canReflect.onValue(obs, handler);
     obs.value = 'three';
 
     canReflect.offValue(obs, handler);
     obs.value = 'four';
 
-    QUnit.equal(obs.value, 'four', 'getValue after offValue');
+    assert.equal(obs.value, 'four', 'getValue after offValue');
 });
 
 skipProduction("log observable changes", function(assert) {
diff --git a/key/key-test.js b/key/key-test.js
@@ -47,10 +47,10 @@ QUnit.test("get and set Priority", function(assert) {
 });
 
 if (supportsFunctionNames) {
-	onlyDevTest("observable has a helpful name", function() {
+	onlyDevTest("observable has a helpful name", function(assert) {
 		var outer = {inner: {key: "hello"}};
 		var observable = keyObservable(outer, "inner.key");
-		QUnit.equal(
+		assert.equal(
 			canReflect.getName(observable),
 			"keyObservable<Object{}.inner.key>",
 			"observable has the correct name"
diff --git a/make-compute/make-compute-test.js b/make-compute/make-compute-test.js
@@ -5,25 +5,26 @@ var makeCompute = require("./make-compute");
 
 QUnit.module('can-simple-observable/make-compute');
 
-QUnit.test('basics', 4, function(){
+QUnit.test('basics', function(assert) {
+    assert.expect(4);
     var compute = makeCompute(new SimpleObservable(5));
-    QUnit.equal( compute(), 5, "read");
+    assert.equal( compute(), 5, "read");
     compute(6);
-    QUnit.equal( compute(), 6, "write");
+    assert.equal( compute(), 6, "write");
 
     compute.on("change", function(ev, newVal, oldVal){
-        QUnit.equal(newVal, 7, "bound newVal");
-        QUnit.equal(oldVal, 6, "bound newVal");
+        assert.equal(newVal, 7, "bound newVal");
+        assert.equal(oldVal, 6, "bound newVal");
     });
     compute(7);
 });
 
-QUnit.test("unbind('change')", function(){
+QUnit.test("unbind('change')", function(assert) {
     var observable = new SimpleObservable(5);
     var compute = makeCompute(observable);
     compute.on('change', function(){});
     compute.on('change', function(){});
-    QUnit.equal(observable.handlers.get([]).length, 2, "2 observables");
+    assert.equal(observable.handlers.get([]).length, 2, "2 observables");
     compute.unbind("change");
-    QUnit.equal(observable.handlers.get([]).length, 0, "2 observables");
+    assert.equal(observable.handlers.get([]).length, 0, "2 observables");
 });
diff --git a/package.json b/package.json
@@ -54,7 +54,7 @@
     "detect-cyclic-packages": "^1.1.0",
     "jshint": "^2.9.1",
     "steal": "^2.2.1",
-    "steal-qunit": "^1.0.1",
+    "steal-qunit": "^2.0.0",
     "steal-tools": "^2.2.1",
     "testee": "^0.9.0"
   },
diff --git a/resolver/resolver-test.js b/resolver/resolver-test.js
@@ -9,8 +9,8 @@ var ObservationRecorder = require("can-observation-recorder");
 
 QUnit.module('can-simple-observable/resolver');
 
-QUnit.test("timer with teardown", function(){
-    QUnit.stop();
+QUnit.test("timer with teardown", function(assert) {
+    var done = assert.async();
 
     var CALLS = [];
 
@@ -29,64 +29,66 @@ QUnit.test("timer with teardown", function(){
         };
     }, {});
 
-    QUnit.equal( obs.get(), 0, "got initial value unbound");
-    QUnit.deepEqual(CALLS,["GENERATOR","TEARDOWN"], "initial unbound read");
+    assert.equal( obs.get(), 0, "got initial value unbound");
+    assert.deepEqual(CALLS,["GENERATOR","TEARDOWN"], "initial unbound read");
     CALLS = [];
 
     var handler = function(newVal){
-        QUnit.equal( newVal, 1, "got first emitted value");
-        QUnit.equal( obs.get(), 1, "got first emitted value");
-        QUnit.deepEqual(CALLS,["INTERVAL"], "emitted value");
+        assert.equal( newVal, 1, "got first emitted value");
+        assert.equal( obs.get(), 1, "got first emitted value");
+        assert.deepEqual(CALLS,["INTERVAL"], "emitted value");
         CALLS = [];
         obs.off(handler);
-        QUnit.deepEqual(CALLS,["TEARDOWN"], "emitted value");
-        QUnit.start();
+        assert.deepEqual(CALLS,["TEARDOWN"], "emitted value");
+        done();
     };
 
     obs.on(handler);
-    QUnit.equal( obs.get(), 0, "got initial value after bind");
-    QUnit.deepEqual(CALLS,["GENERATOR"], "initial bind");
+    assert.equal( obs.get(), 0, "got initial value after bind");
+    assert.deepEqual(CALLS,["GENERATOR"], "initial bind");
     CALLS = [];
 
 });
 var queues = require("can-queues");
-QUnit.test('basics listenTo', 14, function(assert){
+QUnit.test('basics listenTo', function(assert){
+    assert.expect(14);
     var number = new SimpleObservable(1);
 
     var map = mapEventMixin({
         property: 1
     });
 
     var obs = new ResolverObservable(function testee(value){
-        QUnit.equal( value.resolve(6), 6, "resolve returns passed value");
+        assert.equal( value.resolve(6), 6, "resolve returns passed value");
 
 
         value.listenTo(number, function(newNumber){
             assert.equal(newNumber,2, "got the new number");
             assert.equal(this, map, "listenTo this is the context");
-            QUnit.equal( value.resolve(5), 5, "resolve returns passed value");
+            assert.equal( value.resolve(5), 5, "resolve returns passed value");
         });
 
     }, map);
 
     assert.equal(obs.get(), 6, "got unbound value");
     assert.equal(canReflect.getValue(obs), 6, "got unbound value");
     var listenHandlers = obs.binder[ canSymbol.for("can.meta") ].listenHandlers;
-    QUnit.equal(listenHandlers.size(), 0, "0 handlers after read");
+    assert.equal(listenHandlers.size(), 0, "0 handlers after read");
 
     obs.on(function(newVal){
-        QUnit.equal(newVal, 5, "got the new value");
+        assert.equal(newVal, 5, "got the new value");
     });
     assert.equal(obs.get(), 6, "got unbound value");
     listenHandlers = obs.binder[ canSymbol.for("can.meta") ].listenHandlers;
-    QUnit.equal(listenHandlers.size(), 1, "1 handlers after bind");
+    assert.equal(listenHandlers.size(), 1, "1 handlers after bind");
     number.set(2);
 
     assert.equal(obs.get(), 5, "got updated value");
     assert.equal(canReflect.getValue(obs), 5, "got updated value");
 });
 
-QUnit.test("setter", 6, function(){
+QUnit.test("setter",function(assert) {
+    assert.expect(6);
     var state = new SimpleObservable("IL");
 
     var city = new ResolverObservable(function fullName(value){
@@ -100,27 +102,27 @@ QUnit.test("setter", 6, function(){
     }, mapEventMixin({}) );
 
     city.set("Chicago");
-    QUnit.equal(city.get(), "Chicago", "got unbound value");
+    assert.equal(city.get(), "Chicago", "got unbound value");
 
     city.set("Rockford");
-    QUnit.equal(city.get(), "Rockford", "got unbound value after another set");
+    assert.equal(city.get(), "Rockford", "got unbound value after another set");
 
     var CITIES = [];
     city.on(function(city){
         CITIES.push(city);
     });
 
-    QUnit.equal(city.get(), "Rockford", "got bound value after binding");
+    assert.equal(city.get(), "Rockford", "got bound value after binding");
 
     state.set("CA");
 
-    QUnit.equal(city.get(), null, "updated city after state set");
+    assert.equal(city.get(), null, "updated city after state set");
 
     city.set("San Jose");
 
-    QUnit.equal(city.get(), "San Jose", "updated city after state set");
+    assert.equal(city.get(), "San Jose", "updated city after state set");
 
-    QUnit.deepEqual(CITIES,[null,"San Jose"], "events right");
+    assert.deepEqual(CITIES,[null,"San Jose"], "events right");
 });
 
 QUnit.test("getValueDependencies and value dependencies", function(assert) {
@@ -222,7 +224,7 @@ QUnit.test("getWhatIChange", function(assert) {
 	assert.ok(canReflect.getWhatIChange(dep).derive.valueDependencies.has(obs));
 });
 
-QUnit.test("proactive binding doesn't last past binding (can-stache#486)", function(){
+QUnit.test("proactive binding doesn't last past binding (can-stache#486)", function(assert) {
     var v = new SimpleObservable(2);
 
     var readCount = 0;
@@ -246,11 +248,11 @@ QUnit.test("proactive binding doesn't last past binding (can-stache#486)", funct
 
     v.set(3);
 
-    QUnit.equal(readCount, 0, "internal observation only updated once");
+    assert.equal(readCount, 0, "internal observation only updated once");
 
 });
 
-QUnit.test("reading observables does not leak the observable read", function(){
+QUnit.test("reading observables does not leak the observable read", function(assert) {
     // if an observation is listening is reading this value, the value
     // should not ObservationRecorder.add its deps
     // there is a similar test in can-define
@@ -267,13 +269,13 @@ QUnit.test("reading observables does not leak the observable read", function(){
 
     var records = ObservationRecorder.stop();
 
-    QUnit.equal(records.keyDependencies.size, 0, "there are no key dependencies");
-    QUnit.equal(records.valueDependencies.size, 0, "there are no valueDependencies");
+    assert.equal(records.keyDependencies.size, 0, "there are no key dependencies");
+    assert.equal(records.valueDependencies.size, 0, "there are no valueDependencies");
 });
 
-QUnit.test("initial value on lastSet can be set (can-define#397)", function () {
+QUnit.test("initial value on lastSet can be set (can-define#397)", function(assert) {
     var defaulted = new ResolverObservable(function(props) {
-        QUnit.equal(props.lastSet.get(), 5, "observable has default value");
+        assert.equal(props.lastSet.get(), 5, "observable has default value");
     }, {}, 5);
     defaulted.get();
 });
diff --git a/settable/settable-test.js b/settable/settable-test.js
