Update Jasmine cheatsheet

jasmine.md

@@ -1,138 +1,206 @@
 ---
 title: Jasmine
 category: JavaScript libraries
-layout: default-ad
+layout: 2017/sheet
+weight: -1
 ---
 
-    describe("A suite", function() {
+## Tests
-      it("contains spec with an expectation", function() {
+
-        expect(true).toBe(true);
+### Writing tests
-      });
+
-    });
+```js
+describe('A suite', () => {
+  it('works', () => {
+    expect(true).toBe(true)
+  })
+})
+```
+
+Note: This cheatsheet may be a little outdated. Also see the [Jest cheatsheet](./jest). Jest uses Jasmine, and therefore has similar API.
 
 ### Expectations
 
+```js
 expect(true).toBe(true)
 expect(true).not.toBe(true)
+```
 
+```js
 expect(a).toEqual(bar)
+```
 
+```js
 expect(message).toMatch(/bar/)
 expect(message).toMatch('bar')
+```
 
+```js
 expect(a.foo).toBeDefined()
 expect(a.foo).toBeUndefined()
 expect(a.foo).toBeNull()
+```
 
+```js
 expect(a.foo).toBeTruthy()
 expect(a.foo).toBeFalsy()
+```
 
+```js
 expect(message).toContain('hello')
+```
 
+```js
 expect(pi).toBeGreaterThan(3)
 expect(pi).toBeLessThan(4)
 expect(pi).toBeCloseTo(3.1415, 0.1)
+```
 
+```js
 expect(func).toThrow()
+```
 
-### Blocks
+### Hooks
 
-    beforeEach(function() { ... });
+```js
-    afterEach(function() { ... });
+beforeEach(() => {
+  ···
+})
+```
+
+```js
+afterEach(() => {
+  ···
+})
+```
 
 ### Pending
 
-    xit("this is a pending test", function() { ... })
+```js
-    xdescribe("this is a pending block", function() { ... })
+xit('this is a pending test', () => {
+  ···
+})
+```
+
+```js
+xdescribe('this is a pending block', () => {
+  ···
+})
+```
 
 ### Spies
 
+```js
 spyOn(foo, 'setBar')
 spyOn(foo, 'setBar').andReturn(123)
 spyOn(foo, 'getBar').andCallFake(function() { return 1001; })
 foo.setBar(123)
+```
 
+```js
 expect(foo.setBar).toHaveBeenCalled()
 expect(foo.setBar).toHaveBeenCalledWith(123)
 expect(foo.setBar.calls.length).toEqual(2)
 expect(foo.setBar.calls[0].args[0]).toEqual(123)
+```
 
 ### Creating spies
 
+```js
 stub = jasmine.createSpy('stub')
-    stub("hello")
+stub('hello')
+```
 
-    expect(stub.identity).toEqual("stub")
+```js
+expect(stub.identity).toEqual('stub')
 expect(stub).toHaveBeenCalled()
+```
 
 ### Async
 
-    it("should run async", function() {
+```js
-      var flag = false, value = 0;
+test('works with promises', () => {
+  return new Promise((resolve, reject) => {
+    ···
+  })
+})
+```
 
-      runs(function() {
+Make your test return a promise.
-        setTimeout(function() { flag = true; }, 500);
-      });
-
-      waitsFor(function() {
-        value++;
-        return flag;
-      }, "increment", 750);
-
-      runs(function() {
-        expect(value).toBeGreaterThan(0);
-      });
-    });
 
 ### HTML runner
 
-    var jasmineEnv = jasmine.getEnv();
+```js
-    jasmineEnv.updateInterval = 250;
+var jasmineEnv = jasmine.getEnv()
+jasmineEnv.updateInterval = 250
 
-    var htmlReporter = new jasmine.HtmlReporter();
+var htmlReporter = new jasmine.HtmlReporter()
-    jasmineEnv.addReporter(htmlReporter);
+jasmineEnv.addReporter(htmlReporter)
 
-    $(function() { jasmineEnv.execute(); });
+$(function() { jasmineEnv.execute() })
+```
 
 Jasmine jQuery
-==============
+--------------
 
-[Jasmin jQuery](https://github.com/velesin/jasmine-jquery).
+### Expectations
 
+```js
 expect($('#id')).toBe('div')
 expect($('input[type=checkbox]')).toBeChecked()
 expect($('input[type=checkbox]')).toBeDisabled()
 expect($('input[type=checkbox]')).toBeFocused()
 expect($('#menu ul')).toBeEmpty()
+```
 
+```js
 expect($('#toolbar')).toBeHidden()
 expect($('#toolbar')).toBeVisible()
+```
 
+```js
 expect($('#popup')).toHaveCss({ margin: "10px" })
 expect($('option')).toBeSelected()
+```
 
+```js
 expect($('.foo')).toExist()
+```
 
+```js
 expect($('a')).toHaveAttr('rel')
 expect($('a')).toHaveAttr('rel', 'nofollow')
+```
 
+```js
 expect($('a')).toHaveClass('rel')
 expect($('a')).toHaveId('home')
+```
 
+```js
 expect($('a')).toHaveHtml('<span></span>')
 expect($('a')).toContainHtml('<span></span>')
 expect($('a')).toHaveText('hi')
+```
 
+```js
 expect($form).toHandle('submit') // event
 expect($form).toHandleWith('submit', onSumbit)
+```
+
+See: [jasmine-jquery](https://github.com/velesin/jasmine-jquery)
 
 ### Event spies
 
-    spyOnEvent($('#some_element'), 'click');
+```js
-    $('#some_element').click();
+spyOnEvent($('#some_element'), 'click')
-    expect('click').toHaveBeenPreventedOn($('#some_element'));
+$('#some_element').click()
-    expect('click').toHaveBeenTriggeredOn($('#some_element'));
+expect('click').toHaveBeenPreventedOn($('#some_element'))
+expect('click').toHaveBeenTriggeredOn($('#some_element'))
+```
 
-### Reference
+## References
+{: .-one-column}
 
- * http://pivotal.github.com/jasmine/
+* Also see the [Jest cheatsheet](./jest). Jest uses Jasmine, and therefore has similar API.
+* <https://jasmine.github.io>

jest.md

@@ -23,13 +23,11 @@ npm install --save-dev jest babel-jest
   "test": "jest"
 }
 ```
-{: .-setup}
 
 ```bash
 # Run your tests
 npm test -- --watch
 ```
-{: .-setup}
 
 See: [Getting started](http://facebook.github.io/jest/docs/en/getting-started.html)
 
@@ -120,8 +118,10 @@ expect(value)
   .not
   .toBe(value)
   .toEqual(value)
+  .toBeTruthy()
 ```
 
+Note that `toEqual` is a deep equality check.
 See: [expect()](http://facebook.github.io/jest/docs/en/expect.html#expectvalue)
 
 ### Snapshots