Невозможно использовать параметризацию плагин для QUnit

Question

Не удается запустить простой параметризированный тест:

qunit.cases([{a: 1, b: 2}]).test("my test", function (params, assert) { 
    var sum = params.a + params.b; 

    assert.equal(3, sum, "correct"); 
}); 

Это говорит о том, что функция обратного вызова имеет нулевое значение, но это не

Согласно параметризации. js docs: parameterize plugin for qunit

Я должен был сделать это:

QUnit 
.cases(testCasesList) 
.test(title, [expect], callback); 

Я проверил код и, если ожидал, равен нулю, второй он инициализируется функцией обратного вызова. Я даже попытался ожидать = 3 и обратный вызов в качестве третьего параметра, но он по-прежнему дает ту же ошибку, функция обратного вызова равна нулю.

Что я могу делать неправильно?

Какой должен быть параметр, функция число?

Answer 1

Я думаю, что этот инструмент был создан для предыдущей версии QUit. Я сделал некоторые отладки и получил решение:

/* 
* Parameterize v 0.4 
* A QUnit Addon For Running Parameterized Tests 
* https://github.com/AStepaniuk/qunit-parameterize 
* Released under the MIT license. 
*/ 
QUnit.extend(QUnit, { 
    cases: (function() { 
    'use strict'; 
    var currentCases = null, 
     clone = function(testCase) { 
      var result = {}, 
       p = null; 

      for (p in testCase) { 
       if (testCase.hasOwnProperty(p)) { 
        result[p] = testCase[p]; 
       } 
      } 

      return result; 
     }, 
     createTest = function(methodName, title, expected, callback, parameters) { 

      QUnit[methodName](title + ", test params: " + JSON.stringify(parameters), function(assert) { 
       return callback.call(this, parameters, assert); 
      }); 
     }, 

     iterateTestCases = function(methodName, title, expected, callback) { 
      var i = 0, 
       parameters = null, 
       testCaseTitle = null; 

      if (!currentCases || currentCases.length === 0) { 
       // setup test which will always fail 
       QUnit.test(title, function(assert) { 
        assert.ok(false, "No test cases are provided"); 
       }); 
       return; 
      } 

      if (!callback) { 
       callback = expected; 
       expected = null; 
      } 

      for (i = 0; i < currentCases.length; i += 1) { 
       parameters = currentCases[i]; 

       testCaseTitle = title; 
       if (parameters.title) { 
        testCaseTitle += "[" + parameters.title + "]"; 
       } 

       createTest(methodName, testCaseTitle, expected, callback, parameters); 
      } 
     }, 

     getLength = function(arr) { 
      return arr ? arr.length : 0; 
     }, 

     getItem = function(arr, idx) { 
      return arr ? arr[idx] : undefined; 
     }, 

     mix = function(testCase, mixData) { 
      var result = null, 
       p = null; 

      if (testCase && mixData) { 
       result = clone(testCase); 

       for (p in mixData) { 
        if (mixData.hasOwnProperty(p)) { 
         if (p !== "title") { 
          if (!(result.hasOwnProperty(p))) { 
           result[p] = mixData[p]; 
          } 
         } else { 
          result[p] = [result[p], mixData[p]].join(""); 
         } 
        } 
       } 

      } else if (testCase) { 
       result = testCase; 
      } else if (mixData) { 
       result = mixData; 
      } else { 
       // return null or undefined whatever testCase is 
       result = testCase; 
      } 

      return result; 
     }; 

    return { 

     init: function(testCasesList) { 
      currentCases = testCasesList; 
      return this; 
     }, 

     sequential: function(addData) { 
      var casesLength = getLength(currentCases), 
       addDataLength = getLength(addData), 
       length = casesLength > addDataLength ? casesLength : addDataLength, 
       newCases = [], 
       i = 0, 
       currentCaseI = null, 
       dataI = null, 
       newCase = null; 

      for (i = 0; i < length; i += 1) { 
       currentCaseI = getItem(currentCases, i); 
       dataI = getItem(addData, i); 
       newCase = mix(currentCaseI, dataI); 

       if (newCase) { 
        newCases.push(newCase); 
       } 
      } 

      currentCases = newCases; 

      return this; 
     }, 

     combinatorial: function(mixData) { 
      var current = (currentCases && currentCases.length > 0) ? currentCases : [null], 
       currentLength = current.length, 
       mixDataLength = 0, 
       newCases = [], 
       i = 0, 
       j = 0, 
       currentCaseI = null, 
       dataJ = null, 
       newCase = null; 

      mixData = (mixData && mixData.length > 0) ? mixData : [null]; 
      mixDataLength = mixData.length; 

      for (i = 0; i < currentLength; i += 1) { 
       for (j = 0; j < mixDataLength; j += 1) { 
        currentCaseI = current[i]; 
        dataJ = mixData[j]; 
        newCase = mix(currentCaseI, dataJ); 

        if (newCase) { 
         newCases.push(newCase); 
        } 
       } 
      } 

      currentCases = newCases; 

      return this; 
     }, 

     test: function(title, expected, callback) { 
      iterateTestCases("test", title, expected, callback); 
      return this; 
     }, 

     getCurrentTestCases: function() { 
      return currentCases; 
     } 
    }; 
    }()) 
}); 

Прежде всего, я думаю, автор хотел продлить QUnit с 4 дополнительными функциями:

sequential(addData); 
combinatorial(mixData); 
test(title, expected, callback); 
asyncTest(title, expected, callback); 

, но не смог сделать это. То, что я сделал, я превратил «случаи» в объект вместо функции и добавил функцию init(), которая инициализирует массив тестовых случаев внутри.

Я также изменил функцию createTest() для:

createTest = function(methodName, title, expected, callback, parameters) { 
    QUnit[methodName](title + ", test params: " + JSON.stringify(parameters), function(assert) { 
     return callback.call(this, parameters, assert); 
    }); 
} 

который вызывает QUnit.test (название, обратный вызов) непосредственно без прохождения "ожидаемого" параметра. Не уверен, что было предназначено для этого «ожидаемого» параметра, но вы можете добавить свои собственные параметры в массив тестовых случаев и по-прежнему покрывать то, что следует ожидать.

Вот пример того, как создать 3 параметризованные тесты:

QUnit.cases 
     .init([{a: 1, b: 2, expected: 3}, {a: 4, b: 5, expected: 9}, {a: -5, b: 5, expected: 0}]) 
     .test("test sum(a, b)", function (parameters, assert) { 
      var sum = parameters.a + parameters.b; 

      assert.equal(sum, parameters.expected, "expected: " + parameters.expected + ", calculated: " + sum); 
     }); 

Текущий сценарий охватывает последовательное тестирование, но я оставил эту функцию в любом случае:

qunit 
    .cases 
    .init([ 
     {param1: 50}, 
     {param1: 200}, 
     {param1: 300} 
    ]) 
    .sequential([ 
     {param2: 100}, 
     null, 
     {param2: 150} 
    ]) 
    .test("Meta tests for QUnit Parametrize plugin", function (params, assert) { 
     console.dir(params); 
     assert.equal(params.param1, params.param2,""); 
    }); 

Вы также можете создавать комбинаторные тесты, которые создают комбинации тестов в параметрах init() и в комбинаторном() параметрах

qunit 
    .cases 
    .init([ 
     {param1: 50} 
    ]) 
    .combinatorial([ 
     {param2: 100}, 
     {param2: 150}, 
     {param2: 50} 
    ]) 
    .test("Meta tests for QUnit Parametrize plugin", function (params, assert) { 
     assert.equal(params.param1, params.param2,""); 
    }); 

QUnit.async() не поддерживается в последней версии. Вы должны использовать QUnit.test() для асинхронного тестирования. Проконсультируйтесь: qunit 2.x upgrade Я удалил async из QUnit Parameteize. Спасибо за чтение :)