Merge pull request #60 from notmessenger/Issue49

Closes #49

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
 
 
 ---

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 );
 }

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
 };

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'] );
+        }
+    }
+}

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 );
 };

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' );
+});