ember-cli-custom-assertions-collection - npm Package Compare versions

Comparing version 0.3.0 to 0.4.0

CHANGELOG.md

@@ -11,2 +11,14 @@ # Change Log
 
+## [0.4.0] - 2015-09-29
+
+### Added
+- `largerThan`, `largerThanOrEqual`, `smallerThan`, `smallerThanOrEqual`
+
+### Documentation
+- Adjusted assertions formatting.
+- Added a note that `arraysSameMembers` is safe to compare Ember models.
+
+
+
+
 ## [0.3.0] - 2015-09-25
@@ -13,0 +25,0 @@

package.json

 {
   "name": "ember-cli-custom-assertions-collection",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "An ever growing library of assertions for QUnit in Ember.",
@@ -5,0 +5,0 @@ "directories": {

README.md

@@ -49,73 +49,92 @@ [![Travis](https://travis-ci.org/lolmaus/ember-cli-custom-assertions-collection.svg/)](https://travis-ci.org/lolmaus/ember-cli-custom-assertions-collection)
 
-#### isFalse
+* #### isFalse
 
-    isFalse( obj [, message] )
+  ```
+  isFalse( obj [, message] )
+  ```
 
-Checks if `obj` is exactly `false`.
+  Checks if `obj` is exactly `false`.
 
-```js
-assert.isFalse( false )   // pass
-assert.isFalse( 1 === 2 ) // pass
-assert.isFalse( null )    // fail
-```
+  ```js
+  assert.isFalse( false )   // pass
+  assert.isFalse( 1 === 2 ) // pass
+  assert.isFalse( null )    // fail
+  ```
 
+* #### arrayContains
 
-### arrayContains
+  ```
+  arrayContains( arr, value [, message])
+  ```
+  
+  Checks if array contains value
+  
+  ```js
+  assert.arrayContains(['foo', 'bar'], 'bar')  // pass
+  assert.arrayContains(['foo', 'bar'], 'quux') // fail
+  ```
 
-    arrayContains( arr, value [, message])
+* #### arraysSameMembers
 
-Checks if array contains value
+  ```
+  arraysSameMembers( arr1, arr2 [, message] )
+  ```
+  
+  Checks if both arrays have identical content, in any order.
+  
+  Members are compared via `===`, so it's safe to compare Ember models: will not crash due to circular references like `propEqual` does.
+  
+  ```js
+  assert.arraysSameMembers( ['foo', 'bar'], ['bar', 'foo'] ) // pass
+  assert.arraysSameMembers( ['foo', 'bar'], ['bar', 'baz'] ) // fail
+  assert.arraysSameMembers( ['foo', 'bar'], ['bar']        ) // fail
+  ```
+  
 
-```js
-assert.arrayContains(['foo', 'bar'], 'bar')  // pass
-assert.arrayContains(['foo', 'bar'], 'quux') // fail
-```
+* #### arraysSameMembersOrdered
 
+  ```
+  arraysSameMembersOrdered( arr1, arr2 [, message] )
+  ```
+  
+  Checks if both arrays identical content, in identical order. Members are compared via `===`.
+  
+  ```js
+  assert.arraysSameMembersOrdered( ['foo', 'bar'], ['foo', 'bar'] ) // pass
+  assert.arraysSameMembersOrdered( ['foo', 'bar'], ['bar', 'foo'] ) // fail
+  assert.arraysSameMembersOrdered( ['foo', 'bar'], ['bar', 'baz'] ) // fail
+  assert.arraysSameMembersOrdered( ['foo', 'bar'], ['bar']        ) // fail
+  ```
 
 
-#### arraysSameMembers
+* #### numbersAlmostEqual
 
-    arraysSameMembers( arr1, arr2 [, message] )
+  ```
+  numbersAlmostEqual( number1, number2 [, precision = 6] [, message] )
+  ```
+  
+  You know how `1 - 0.9 === 0.1` is `false` in JS? That's because in JS float-point operations aren't precise.
+  
+  Use this to compare them loosely:
+  
+  ```js
+  assert.numbersAlmostEqual( 1 - 0.9, 1                     ) // pass
+  assert.numbersAlmostEqual( 1 - 1/3, 2/3                   ) // pass
+  assert.numbersAlmostEqual( 1,       0.00001               ) // fail
+  assert.numbersAlmostEqual( 1,       0.00001, precision: 4 ) // pass
+  ```
+  
+  This assertion uses a method [suggested](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/EPSILON#Testing_equality) by MDN. Not sure whether it'll work correctly every time.
 
-Checks if both arrays have identical content, in any order. Members are compared via `===`.
 
-```js
-assert.arraysSameMembers( ['foo', 'bar'], ['bar', 'foo'] ) // pass
-assert.arraysSameMembers( ['foo', 'bar'], ['bar', 'baz'] ) // fail
-assert.arraysSameMembers( ['foo', 'bar'], ['bar']        ) // fail
-```
+* #### largerThan, largerThanOrEqual, smallerThan, smallerThanOrEqual
 
-#### arraysSameMembersOrdered
+  ```
+  largerThan(arg1, arg2 [, message])
+  ```
+  
+  Compares the two arguments using `>`, `>=`, `<` and `<=` respectively.
 
-arraysSameMembersOrdered( arr1, arr2 [, message] )
 
-Checks if both arrays identical content, in identical order. Members are compared via `===`.
 
-```js
-assert.arraysSameMembersOrdered( ['foo', 'bar'], ['foo', 'bar'] ) // pass
-assert.arraysSameMembersOrdered( ['foo', 'bar'], ['bar', 'foo'] ) // fail
-assert.arraysSameMembersOrdered( ['foo', 'bar'], ['bar', 'baz'] ) // fail
-assert.arraysSameMembersOrdered( ['foo', 'bar'], ['bar']        ) // fail
-```
-
-
-#### numbersAlmostEqual
-
-    numbersAlmostEqual( number1, number2 [, precision = 6] [, message] )
-
-You know how `1 - 0.9 === 0.1` is `false` in JS? That's because in JS float-point operations aren't precise.
-
-Use this to compare them loosely:
-
-```js
-assert.numbersAlmostEqual( 1 - 0.9, 1                     ) // pass
-assert.numbersAlmostEqual( 1 - 1/3, 2/3                   ) // pass
-assert.numbersAlmostEqual( 1,       0.00001               ) // fail
-assert.numbersAlmostEqual( 1,       0.00001, precision: 4 ) // pass
-```
-
-This assertion uses a method [suggested](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/EPSILON#Testing_equality) by MDN. Not sure whether it'll work correctly every time.
-
-
-
 ## Plans
@@ -122,0 +141,0 @@

No alert changes

Improved metrics

Total package byte prevSize

100194

increased by11.85%

Number of package files

31

increased by14.81%

Lines of code

119

increased by30.77%

Number of lines in readme file

152

increased by14.29%

No dependency changes