Unit testing examples

player-class.js

class Player {
  play(song) {
    this.currentlyPlayingSong = song;
    this.isPlaying = true;
  }

  pause() {
    this.isPlaying = false;
  }

  resume() {
    if (this.isPlaying) {
      throw new Error('song is already playing');
    }
  }

  makeFavorite() {
    this.currentlyPlayingSong.persistFavoriteStatus(true);
  }
}

player.js

function Player() {}

Player.prototype.play = function(song) {
  this.currentlyPlayingSong = song;
  this.isPlaying = true;
};

Player.prototype.pause = function() {
  this.isPlaying = false;
};

Player.prototype.resume = function() {
  if (this.isPlaying) {
    throw new Error('song is already playing');
  }

  this.isPlaying = true;
};

Player.prototype.makeFavorite = function() {
  this.currentlyPlayingSong.persistFavoriteStatus(true);
};

player.spec.js

describe('Player', function() {
  let player;
  let song;

  beforeEach(function() {
    player = new Player();
    song = new Song();
  });

  it('should be able to play a Song', function() {
    player.play(song);
    expect(player.currentlyPlayingSong).toEqual(song);

    // demonstrates use of custom matcher
    expect(player).toBePlaying(song);
  });

  describe('when song has been paused', function() {
    beforeEach(function() {
      player.play(song);
      player.pause();
    });

    it('should indicate that the song is currently paused', function() {
      expect(player.isPlaying).toBeFalsy();

      // demonstrates use of 'not' with a custom matcher
      expect(player).not.toBePlaying(song);
    });

    it('should be possible to resume', function() {
      player.resume();
      expect(player.isPlaying).toBeTruthy();
      expect(player.currentlyPlayingSong).toEqual(song);
    });
  });

  // demonstrates use of spies to intercept and test method calls
  it('tells the current song if the user has made it a favorite', function() {
    spyOn(song, 'persistFavoriteStatus');

    player.play(song);
    player.makeFavorite();

    expect(song.persistFavoriteStatus).toHaveBeenCalledWith(true);
  });

  // demonstrates use of expected exceptions
  describe('#resume', function() {
    it('should throw an exception if song is already playing', function() {
      player.play(song);

      expect(function() {
        player.resume();
      }).toThrowError('song is already playing');
    });
  });
});

song.js

function Song() {}

Song.prototype.persistFavoriteStatus = function(value) {
  // something complicated
  throw new Error('not yet implemented');
};

spec-helper.js

beforeEach(function() {
  jasmine.addMatchers({
    toBePlaying: function() {
      return {
        compare: function(actual, expected) {
          const player = actual;

          return {
            pass: player.currentlyPlayingSong === expected && player.isPlaying
          };
        }
      };
    }
  });
});