diff --git a/README.md b/README.md index 8652b5f..6574a31 100755 --- a/README.md +++ b/README.md @@ -50,6 +50,25 @@ This test would pass because the Array being tested contains the value of "b": contains( [ 'a', 'b' ], 'b', 'Contains expected values' ); ``` +### requires + +Use this helper to test that an argument passed to a function is of the required type(s). The first argumens is the function under test and the second argument is an array of types to test for. + +``` +requires( functionUnderTest, [ 'string', 'object', 'function' ] ); +``` + +#### Types + +* number +* string +* array +* object +* function +* undefined +* boolean + + ## Asynchronous ### ajax @@ -60,6 +79,9 @@ See description in *Synchronous* section See description in *Synchronous* section +### requires + +See description in *Synchronous* section --- diff --git a/test-support/helpers/sl/register-test-helpers.js b/test-support/helpers/sl/register-test-helpers.js index 571814f..369f09d 100755 --- a/test-support/helpers/sl/register-test-helpers.js +++ b/test-support/helpers/sl/register-test-helpers.js @@ -1,10 +1,12 @@ import Ember from 'ember'; import { contains, - ajax + ajax, + requires } from './synchronous'; export default function() { Ember.Test.registerHelper( 'contains', contains ); Ember.Test.registerHelper( 'ajax', ajax ); + Ember.Test.registerHelper( 'requires', requires ); } \ No newline at end of file diff --git a/test-support/helpers/sl/synchronous.js b/test-support/helpers/sl/synchronous.js index 2eafb3f..be9e8ee 100755 --- a/test-support/helpers/sl/synchronous.js +++ b/test-support/helpers/sl/synchronous.js @@ -1,7 +1,9 @@ import contains from './synchronous/contains'; import ajax from './synchronous/ajax'; +import requires from './synchronous/requires'; export { contains, - ajax + ajax, + requires }; \ No newline at end of file diff --git a/test-support/helpers/sl/synchronous/requires.js b/test-support/helpers/sl/synchronous/requires.js new file mode 100644 index 0000000..49e0b07 --- /dev/null +++ b/test-support/helpers/sl/synchronous/requires.js @@ -0,0 +1,78 @@ +import Ember from 'ember'; + +// @TODO Return result of assertions rather than calling ok() - see https://github.com/softlayer/sl-ember-test-helpers/issues/59 + +export default function( methodUnderTest, requiredTypes ) { + var typesToTest = { + 'number' : { + required : false, + testValue : 123987465, + message : 'Parameter was a number' + }, + 'string' : { + required : false, + testValue : 'testString', + message : 'Parameter was a string' + }, + 'array' : { + required : false, + testValue : [], + message : 'Parameter was an array' + }, + 'object' : { + required : false, + testValue : {}, + message : 'Parameter was an object' + }, + 'function' : { + required : false, + testValue : function(){}, + message : 'Parameter was a function' + }, + 'undefined' : { + required : false, + testValue : undefined, + message : 'Parameter was empty' + }, + 'boolean' : { + required : false, + testValue : true, + message : 'Parameter was a boolean' + } + }, + assertionThrown, + assertionState, + property, + parameter; + + Ember.assert( 'First argument must be a function', 'function' === typeof methodUnderTest ); + Ember.assert( 'Second argument must be an array', Array.isArray( requiredTypes ) ); + + // Set required parameter types + requiredTypes.forEach( function( item ) { + typesToTest[item]['required'] = true; + }); + + // Test each parameter type + for ( property in typesToTest ) { + if ( typesToTest.hasOwnProperty( property ) ) { + + // Reset flag + assertionThrown = false; + + // Assign cleaner object reference + parameter = typesToTest[property]; + + // Test parameter + try { + methodUnderTest( parameter['testValue'] ); + } catch( error ) { + assertionThrown = true; + } + + assertionState = ( parameter['required'] ) ? !assertionThrown : assertionThrown; + + ok( assertionState, parameter['message'] ); + } + } +} \ No newline at end of file diff --git a/test-support/helpers/sl/utils/utils.js b/test-support/helpers/sl/utils/utils.js index 43eac3f..553387a 100755 --- a/test-support/helpers/sl/utils/utils.js +++ b/test-support/helpers/sl/utils/utils.js @@ -60,7 +60,7 @@ var convertStringToArray = function( underTest ) { */ var convertObjectKeysToArray = function( underTest ) { - Ember.assert( 'Object must be supplied', 'object' === typeof underTest ); + Ember.assert( 'Object must be supplied', 'object' === typeof underTest && !Array.isArray( underTest ) ); return Object.keys( underTest ); }; diff --git a/tests/unit/helpers/sl/synchronous/requires-test.js b/tests/unit/helpers/sl/synchronous/requires-test.js new file mode 100644 index 0000000..aa2da09 --- /dev/null +++ b/tests/unit/helpers/sl/synchronous/requires-test.js @@ -0,0 +1,187 @@ +import Ember from 'ember'; +import { test } from 'ember-qunit'; +import requires from '../../../../helpers/sl/synchronous/requires'; + +module( 'Unit - helpers:sl/synchronous/requires' ); + +test( 'it exists', function() { + ok( requires, 'it exists' ); +}); + +test( 'First argument must be a function', function() { + + // Number + var assertionThrown = false; + + try { + requires( 12, false ); + } catch( error ) { + assertionThrown = true; + } + + ok( assertionThrown, 'First parameter was a number' ); + + // String + assertionThrown = false; + + try { + requires( 'testString', false ); + } catch( error ) { + assertionThrown = true; + } + + ok( assertionThrown, 'First parameter was a string' ); + + // Array + assertionThrown = false; + + try { + requires( [], false ); + } catch( error ) { + assertionThrown = true; + } + + ok( assertionThrown, 'First parameter was an array' ); + + // Object + assertionThrown = false; + + try { + requires( {}, false ); + } catch( error ) { + assertionThrown = true; + } + + ok( assertionThrown, 'First parameter was an object' ); + + // Function + assertionThrown = false; + + try { + requires( function(){}, false ); + } catch( error ) { + assertionThrown = true; + } + + ok( assertionThrown, 'First parameter was a function' ); + + // Undefined + assertionThrown = false; + + try { + requires( undefined, false ); + } catch( error ) { + assertionThrown = true; + } + + ok( assertionThrown, 'First parameter was undefined' ); + + // Boolean + assertionThrown = false; + + try { + requires( true, false ); + } catch( error ) { + assertionThrown = true; + } + + ok( assertionThrown, 'First parameter was a boolean' ); + +}); + +test( 'Second argument must be an array', function() { + + // Number + var assertionThrown = false; + + try { + requires( 12, 12 ); + } catch( error ) { + assertionThrown = true; + } + + ok( assertionThrown, 'Second parameter was a number' ); + + // String + assertionThrown = false; + + try { + requires( 'testString', 'testString' ); + } catch( error ) { + assertionThrown = true; + } + + ok( assertionThrown, 'Second parameter was a string' ); + + // Array + assertionThrown = false; + + try { + requires( [], [] ); + } catch( error ) { + assertionThrown = true; + } + + ok( assertionThrown, 'Second parameter was an array' ); + + // Object + assertionThrown = false; + + try { + requires( {}, {} ); + } catch( error ) { + assertionThrown = true; + } + + ok( assertionThrown, 'Second parameter was an object' ); + + // Function + assertionThrown = false; + + try { + requires( function(){}, function(){} ); + } catch( error ) { + assertionThrown = true; + } + + ok( assertionThrown, 'Second parameter was a function' ); + + // Undefined + assertionThrown = false; + + try { + requires( undefined, undefined ); + } catch( error ) { + assertionThrown = true; + } + + ok( assertionThrown, 'Second parameter was undefined' ); + + // Boolean + assertionThrown = false; + + try { + requires( true, false ); + } catch( error ) { + assertionThrown = true; + } + + ok( assertionThrown, 'Second parameter was a boolean' ); + +}); + +// @TODO Needs better test support. See https://github.com/softlayer/sl-ember-test-helpers/issues/59 +test( 'Functions as expected', function() { + var testFunction = function( first ) { + Ember.assert( 'Test argument must be a function', 'function' === typeof first || 'boolean' === typeof first ); + }, + assertionThrown = false; + + try { + requires( testFunction, [ 'function', 'boolean' ] ); + } catch( error ) { + assertionThrown = true; + } + + ok( !assertionThrown, 'Functioned as expected when passed desired argument types' ); +}); diff --git a/tests/unit/helpers/sl/utils/utils-test.js b/tests/unit/helpers/sl/utils/utils-test.js index 555b4ef..d7d7c1e 100755 --- a/tests/unit/helpers/sl/utils/utils-test.js +++ b/tests/unit/helpers/sl/utils/utils-test.js @@ -9,84 +9,28 @@ import { doArraysIntersect } from '../../../../helpers/sl/utils/utils'; +import requires from '../../../../helpers/sl/synchronous/requires'; + module( 'Unit - utils:sl/utils/utils' ); test( 'convertToArray() exists', function() { - ok( convertToArray, 'it exists' ); + ok( convertToArray, 'it exists' ); }); test( 'convertStringToArray() exists', function() { - ok( convertStringToArray, 'it exists' ); + ok( convertStringToArray, 'it exists' ); }); test( 'convertObjectKeysToArray() exists', function() { - ok( convertObjectKeysToArray, 'it exists' ); + ok( convertObjectKeysToArray, 'it exists' ); }); test( 'doArraysIntersect() exists', function() { - ok( doArraysIntersect, 'it exists' ); + ok( doArraysIntersect, 'it exists' ); }); test( 'convertToArray() requires either an Array, String, or Object to be provided', function() { - // Empty parameter - - var assertionThrown = false; - - try { - convertToArray(); - } catch( error ) { - assertionThrown = true; - } - - ok( assertionThrown, 'Parameter was empty' ); - - // Number parameter - - assertionThrown = false; - - try { - convertToArray( 4 ); - } catch( error ) { - assertionThrown = true; - } - - ok( assertionThrown, 'Parameter was not an Array, String, or Object' ); - - // Array Parameter - - assertionThrown = false; - - try { - convertToArray( [] ); - } catch( error ) { - assertionThrown = true; - } - - ok( !assertionThrown, 'Parameter was an Array' ); - - // String Parameter - - assertionThrown = false; - - try { - convertToArray( 'test' ); - } catch( error ) { - assertionThrown = true; - } - - ok( !assertionThrown, 'Parameter was a String' ); - - // Object Parameter - - assertionThrown = false; - - try { - convertToArray( {} ); - } catch( error ) { - assertionThrown = true; - } - - ok( !assertionThrown, 'Parameter was an Object' ); + requires( convertToArray, [ 'array', 'string', 'object' ] ); }); test( 'convertToArray() returns expected result', function() { @@ -105,87 +49,19 @@ test( 'convertToArray() returns expected result', function() { }); test( 'convertStringToArray() requires a string to be provided', function() { - // Empty argument - - var assertionThrown = false; - - try { - convertStringToArray(); - } catch( error ) { - assertionThrown = true; - } - - ok( assertionThrown, 'Argument was empty' ); - - // Non-string argument - - assertionThrown = false; - - try { - convertStringToArray({test:true}); - } catch( error ) { - assertionThrown = true; - } - - ok( assertionThrown, 'Argument was not a string' ); - - // String argument - - assertionThrown = false; - - try { - convertStringToArray('test'); - } catch( error ) { - assertionThrown = true; - } - - ok( !assertionThrown, 'Argument was a string' ); + requires( convertStringToArray, [ 'string' ] ); }); test( 'convertStringToArray() returns an array with a single element when passed a string without spaces', function() { deepEqual( convertStringToArray( 'testString' ), [ 'testString' ] ); }); -test( 'convertStringToArray() returns an array with as many arguments as there are "words" represented in a string passed to it containing spaces', function() { +test( 'convertStringToArray() returns an array with as many elements as there are "words" represented in a string passed to it containing spaces', function() { deepEqual( convertStringToArray( 'the test string' ), [ 'the', 'test', 'string' ] ); }); test( 'convertObjectKeysToArray() requires an object to be provided', function() { - // Empty argument - - var assertionThrown = false; - - try { - convertObjectKeysToArray(); - } catch( error ) { - assertionThrown = true; - } - - ok( assertionThrown, 'Argument was empty' ); - - // Non-object argument - - assertionThrown = false; - - try { - convertObjectKeysToArray('test'); - } catch( error ) { - assertionThrown = true; - } - - ok( assertionThrown, 'Argument was not an object' ); - - // Object argument - - assertionThrown = false; - - try { - convertObjectKeysToArray({test:true}); - } catch( error ) { - assertionThrown = true; - } - - ok( !assertionThrown, 'Argument was an object' ); + requires( convertObjectKeysToArray, [ 'object' ] ); }); test( 'convertObjectKeysToArray() returns an array of object properties', function() {