Publish Vulpes Preview 15 sources for desktop, Android and Tundra

Share Gaia assets and adapters, keep private profiles and development documents local, and update both public READMEs.

gaia/dev_apps/music-oga/test/unit/.jshintrc

@@ -0,0 +1,17 @@
+{
+  "extends": "../../../../.jshintrc",
+  "predef": [
+    "assert",
+    "suite",
+    "test",
+    "setup",
+    "teardown",
+    "suiteSetup",
+    "suiteTeardown",
+    "require",
+    "requireApp",
+    "sinon",
+    "mocha",
+    "loadBodyHTML"
+  ]
+}

gaia/dev_apps/music-oga/test/unit/m3u_test.js

@@ -0,0 +1,165 @@
+/* global Playlist */
+/* jshint multistr: true */
+'use strict';
+
+require('/js/playlist.js');
+
+var sample1 = '#EXTM3U\n' +
+    '#EXTINF:,It\'s Raining Again\n' +
+    'Supertramp/_..Famous Last Words/03 It\'s Raining Again.mp3\n' +
+    '#EXTINF:301,3e Sexe\n' +
+    '/home/hub/Music/Indochine/3/13e_sexe.ogg\n' +
+    '#EXTINF:-1,My Cool Stream\n' +
+    'http://www.site.com:8000/listen.pls\n';
+
+var MockGetDeviceStorage = function() {
+  return {
+    get: function(filepath) {
+      return {
+        set onsuccess(cb) {
+          cb.call(this);
+        },
+        get result() {
+          var file = new Blob([sample1], {});
+          return file;
+        }
+      };
+    },
+  };
+};
+
+suite('m3u playlist', function() {
+  var realNavigatorGetDeviceStorage;
+
+  suiteSetup(function() {
+    realNavigatorGetDeviceStorage = navigator.getDeviceStorage;
+    navigator.getDeviceStorage = MockGetDeviceStorage;
+    this.timeout(1000);
+  });
+
+  suiteTeardown(function() {
+    navigator.getDeviceStorage = realNavigatorGetDeviceStorage;
+  });
+
+  test('url', function() {
+    assert.ok(Playlist.isUrl('file://tmp/foo.mp3'));
+    assert.ok(Playlist.isUrl('http://www.stream.invalid/foo.mp3'));
+    assert.ok(Playlist.isUrl('https://www.stream.invalid/foo.mp3'));
+    assert.ok(Playlist.isUrl('mms://www.stream.invalid/foo.mp3'));
+    assert.ok(Playlist.isUrl('rtmp://www.stream.invalid/foo.mp3'));
+    assert.ok(!Playlist.isUrl('c:/tmp/foo.mp3'));
+    assert.ok(!Playlist.isUrl('/tmp/foo.mp3'));
+  });
+
+  test('load', function() {
+    var pl = new Playlist('/home/hub/Music/my playlist.m3u');
+    pl.fromString(sample1);
+
+    assert.strictEqual(pl.directory, '/home/hub/Music/');
+
+    var n = pl._makeAbsolutePath('ACDC/Thunderstruck.mp3');
+    assert.strictEqual('/home/hub/Music/ACDC/Thunderstruck.mp3', n);
+    n = pl._makeAbsolutePath('/tmp/ACDC/Thunderstruck.mp3');
+    assert.strictEqual('/tmp/ACDC/Thunderstruck.mp3', n);
+
+    var songs = pl.songs;
+
+    assert.strictEqual(songs.length, 3);
+
+    assert.strictEqual(songs[0],
+                       '/home/hub/Music/Supertramp/' +
+                       '_..Famous Last Words/03 It\'s Raining Again.mp3');
+
+    assert.strictEqual(songs[1],
+                       '/home/hub/Music/Indochine/3/13e_sexe.ogg');
+
+    assert.strictEqual(songs[2],
+                       'http://www.site.com:8000/listen.pls');
+  });
+
+  test('parse', function(done) {
+    Playlist.parse('apps/music/test-data/playlists/my_playlist.m3u')
+      .then(function(pl) {
+        done(function() {
+          var songs = pl.songs;
+          assert.strictEqual(songs.length, 3);
+
+          assert.strictEqual(songs[0],
+                             'apps/music/test-data/playlists/Supertramp/' +
+                             '_..Famous Last Words/03 It\'s Raining Again.mp3');
+
+          assert.strictEqual(songs[1],
+                             '/home/hub/Music/Indochine/3/13e_sexe.ogg');
+        });
+      }, function(reason) {
+        console.log('rejected', reason.message);
+      });
+  });
+
+  test('playlist manipulation', function() {
+    var pl = new Playlist('/home/hub/Music/my playlist.m3u');
+
+    // add song.
+    pl.addSong('/home/hub/Music/Stairway to haven.mp3');
+
+    // add song at index.
+    pl.addSong('/home/hub/Music/Communication breakdown.mp3', 0);
+
+    pl.addSong('/home/hub/Music/Kashmir.mp3');
+
+    // add extended format song.
+    pl.addSong('/home/hub/Music/Song Remain the same.mp3');
+    assert.strictEqual(pl.songs.length, 4);
+    assert.strictEqual(pl.songs[0],
+                       '/home/hub/Music/Communication breakdown.mp3');
+    assert.strictEqual(pl.songs[1],
+                       '/home/hub/Music/Stairway to haven.mp3');
+
+    // test remove song
+    pl.removeSong('/home/hub/Music/Kashmir.mp3');
+    assert.strictEqual(pl.songs.length, 3);
+
+    assert.strictEqual(pl.songs[2],
+                      '/home/hub/Music/Song Remain the same.mp3');
+
+    // add duplicate (valid)
+    pl.addSong('/home/hub/Music/Kashmir.mp3', 0);
+    assert.strictEqual(pl.songs.length, 4);
+    pl.addSong('/home/hub/Music/Kashmir.mp3');
+    assert.strictEqual(pl.songs.length, 5);
+    assert.strictEqual(pl.songs[0],
+                       '/home/hub/Music/Kashmir.mp3');
+    assert.strictEqual(pl.songs[4],
+                       '/home/hub/Music/Kashmir.mp3');
+
+    // remove the duplicate
+    pl.removeSong('/home/hub/Music/Kashmir.mp3');
+    assert.strictEqual(pl.songs.length, 4);
+    assert.strictEqual(pl.songs[0],
+                       '/home/hub/Music/Communication breakdown.mp3');
+    assert.strictEqual(pl.songs[3],
+                       '/home/hub/Music/Kashmir.mp3');
+
+    // remove by index
+    pl.removeSongAt(2);
+    assert.strictEqual(pl.songs.length, 3);
+    assert.strictEqual(pl.songs[2],
+                       '/home/hub/Music/Kashmir.mp3');
+  });
+
+  test('save', function() {
+    var pl = new Playlist('/home/hub/Music/my playlist.m3u');
+
+    pl.addSong('Stairway to haven.mp3');
+
+    pl.addSong('/home/hub/Music/Song Remain the same.mp3');
+    assert.strictEqual(pl.songs.length, 2);
+
+    var output =  pl.toString();
+
+    var lines = output.split('\n');
+    assert.strictEqual(lines[0], '#EXTM3U');
+    assert.strictEqual(lines[1], '/home/hub/Music/Stairway to haven.mp3');
+    assert.strictEqual(lines[2], '/home/hub/Music/Song Remain the same.mp3');
+  });
+});

gaia/dev_apps/music-oga/test/unit/metadata/album_art_test.js

@@ -0,0 +1,177 @@
+/* global AlbumArt, MockFileStore, MockGetDeviceStorage, pass, fail */
+'use strict';
+
+require('/test/unit/metadata/utils.js');
+require('/test/unit/metadata/mock_navigator_getdevicestorage.js');
+
+suite('album art', function() {
+
+  var RealGetDeviceStorage;
+
+  setup(function(done) {
+    RealGetDeviceStorage = navigator.getDeviceStorage;
+    navigator.getDeviceStorage = MockGetDeviceStorage;
+
+    require('/js/metadata/album_art.js', function() {
+      done();
+    });
+  });
+
+  teardown(function() {
+    navigator.getDeviceStorage = RealGetDeviceStorage;
+  });
+
+  var songBlob = new Blob();
+  songBlob.name = '/path/to/file.mp3';
+
+  test('embedded art', function(done) {
+    var metadata = {
+      picture: { flavor: 'embedded' }
+    };
+
+    AlbumArt.process(songBlob, metadata)
+      .then(function(metadata) {
+        // Make sure we didn't do anything to the metadata.
+        assert.deepEqual(metadata, {
+          picture: { flavor: 'embedded' }
+        });
+      })
+      .then(pass(done), fail(done));
+  });
+
+  test('unsynced art', function(done) {
+    var imageData = 'an image';
+    var metadata = {
+      artist: 'artist',
+      album: 'album',
+      picture: {
+        flavor: 'unsynced',
+        blob: new Blob([imageData], {type: 'image/jpeg'})
+      }
+    };
+    var pictureFilename = '/path/.music/covers/' + metadata.artist + '.' +
+      metadata.album + '.' + imageData.length + '.jpg';
+
+    AlbumArt.process(songBlob, metadata)
+      .then(function(metadata) {
+        assert.deepEqual(metadata, {
+          artist: 'artist',
+          album: 'album',
+          picture: { flavor: 'unsynced', filename: pictureFilename }
+        });
+
+        return MockFileStore.readAsText('pictures', pictureFilename);
+      })
+      .then(function(text) {
+        assert.strictEqual(imageData, text);
+      })
+      .then(pass(done), fail(done));
+  });
+
+  test('unsynced art (no artist/album)', function(done) {
+    var imageData = 'an image';
+    var metadata = {
+      picture: {
+        flavor: 'unsynced',
+        blob: new Blob([imageData], {type: 'image/jpeg'})
+      }
+    };
+    var pictureFilename = '/path/.music/covers/_path_to_file.mp3.' +
+      imageData.length + '.jpg';
+
+    AlbumArt.process(songBlob, metadata)
+      .then(function(metadata) {
+        assert.deepEqual(metadata, {
+          picture: { flavor: 'unsynced', filename: pictureFilename }
+        });
+
+        return MockFileStore.readAsText('pictures', pictureFilename);
+      })
+      .then(function(text) {
+        assert.strictEqual(imageData, text);
+      })
+      .then(pass(done), fail(done));
+  });
+
+  test('unsynced art (already stored)', function(done) {
+    // These should be the same length!
+    var oldImageData = 'an image';
+    var newImageData = 'diffdata';
+
+    var metadata = {
+      artist: 'artist',
+      album: 'album',
+      picture: {
+        flavor: 'unsynced',
+        blob: new Blob([newImageData], {type: 'image/jpeg'})
+      }
+    };
+    var pictureFilename = '/path/.music/covers/' + metadata.artist + '.' +
+      metadata.album + '.' + newImageData.length + '.jpg';
+
+    // Inject an existing image with slightly different data so we can tell
+    // it from the metadata's "new" image.
+    MockFileStore.set('pictures', pictureFilename, new Blob(
+      [oldImageData], {type: 'image/jpeg'}
+    ));
+
+    AlbumArt.process(songBlob, metadata)
+      .then(function(metadata) {
+        assert.deepEqual(metadata, {
+          artist: 'artist',
+          album: 'album',
+          picture: { flavor: 'unsynced', filename: pictureFilename }
+        });
+
+        return MockFileStore.readAsText('pictures', pictureFilename);
+      })
+      .then(function(text) {
+        assert.strictEqual(oldImageData, text);
+      })
+      .then(pass(done), fail(done));
+  });
+
+  test('external art', function(done) {
+    var imageData = 'an image';
+    var pictureFilename = '/path/to/cover.jpg';
+    // Inject an external image into the same folder as our "file".
+    MockFileStore.set('pictures', pictureFilename, new Blob(
+      [imageData], {type: 'image/jpeg'}
+    ));
+
+    var metadata = {};
+
+    AlbumArt.process(songBlob, metadata)
+      .then(function(metadata) {
+        // Make sure we found the external cover art.
+        assert.deepEqual(metadata, {
+          picture: { flavor: 'external', filename: pictureFilename }
+        });
+      })
+      .then(pass(done), fail(done));
+  });
+
+  test('no art', function(done) {
+    var metadata = {};
+    songBlob.name = '/another/path/to/file.mp3';
+
+    AlbumArt.process(songBlob, metadata)
+      .then(function(metadata) {
+        // Make sure we didn't do anything to the metadata.
+        assert.deepEqual(metadata, {});
+      })
+      .then(pass(done), fail(done));
+  });
+
+  test('temporary file', function(done) {
+    var metadata = {};
+
+    AlbumArt.process(new Blob(), metadata)
+      .then(function(metadata) {
+        // Make sure we didn't do anything to the metadata.
+        assert.deepEqual(metadata, {});
+      })
+      .then(pass(done), fail(done));
+  });
+
+});

gaia/dev_apps/music-oga/test/unit/metadata/core_test.js

@@ -0,0 +1,91 @@
+/* global AudioMetadata, fetchBuffer, MockLazyLoader, readBlob,
+   assertBuffersEqual, pass, fail */
+'use strict';
+
+require('/test/unit/metadata/utils.js');
+require('/shared/js/omadrm/fl.js');
+require('/js/metadata/forward_lock.js');
+require('/js/metadata/id3v1.js');
+require('/js/metadata/id3v2.js');
+require('/js/metadata/ogg.js');
+require('/js/metadata/vorbis_picture.js');
+
+suite('core metadata parsing', function() {
+
+  var RealLazyLoader, expectedPicture;
+
+  setup(function(done) {
+    RealLazyLoader = window.LazyLoader;
+    window.LazyLoader = MockLazyLoader;
+
+    require('/js/metadata/core.js')
+      .then(function() {
+        return fetchBuffer('/test-data/album-art.jpg');
+      })
+      .then(function(data) {
+        expectedPicture = data;
+        done();
+      });
+  });
+
+  teardown(function() {
+    window.LazyLoader = RealLazyLoader;
+  });
+
+  test('3gp video rejected', function(done) {
+    var blob = new Blob([new Uint8Array(256)]);
+    blob.name = 'DCIM/video.3gp';
+    AudioMetadata.parse(blob)
+      .then(fail(done, '3gp video wasn\'t rejected'), pass(done));
+  });
+
+  test('small file rejected', function(done) {
+    var blob = new Blob([]);
+    AudioMetadata.parse(blob)
+      .then(fail(done, 'small file wasn\'t rejected'), pass(done));
+  });
+
+  test('ordinary file', function(done) {
+    fetchBuffer('/test-data/vorbis-c.ogg')
+      .then(function(data) {
+        return AudioMetadata.parse(new Blob([data]));
+      })
+      .then(function(metadata) {
+        assert.strictEqual(metadata.tag_format, 'vorbis');
+        assert.strictEqual(metadata.artist, 'Angra');
+        assert.strictEqual(metadata.album, 'Holy Land');
+        assert.strictEqual(metadata.title, 'Carolina IV');
+        assert.strictEqual(metadata.tracknum, 4);
+        assert.strictEqual(metadata.trackcount, 10);
+        assert.strictEqual(metadata.discnum, 1);
+        assert.strictEqual(metadata.disccount, 1);
+        assert.strictEqual(metadata.picture.flavor, 'unsynced');
+        assert.strictEqual(metadata.picture.blob.type, 'image/jpeg');
+
+        return readBlob(metadata.picture.blob);
+      })
+      .then(function(buffer) {
+        assertBuffersEqual(buffer, expectedPicture);
+      })
+      .then(pass(done), fail(done));
+  });
+
+  test('no metadata', function(done) {
+    var filename = '/test-data/no-tag.mp3';
+    fetchBuffer(filename)
+      .then(function(buffer) {
+        var blob = new Blob([buffer]);
+        blob.name = filename;
+        return blob;
+      })
+      .then(AudioMetadata.parse)
+      .then(function(metadata) {
+        assert.strictEqual(metadata.tag_format, undefined);
+        assert.strictEqual(metadata.artist, '');
+        assert.strictEqual(metadata.album, '');
+        assert.strictEqual(metadata.title, 'no-tag');
+      })
+      .then(pass(done), fail(done));
+  });
+
+});

gaia/dev_apps/music-oga/test/unit/metadata/flac_test.js

@@ -0,0 +1,54 @@
+/* global FLACMetadata, fetchBuffer, makeBlobView, MockLazyLoader, readPicSlice,
+   assertBuffersEqual, pass, fail */
+'use strict';
+
+require('/test/unit/metadata/utils.js');
+require('/js/metadata/flac.js');
+require('/js/metadata/vorbis_picture.js');
+
+suite('flac tags', function() {
+  var RealLazyLoader;
+
+  var expectedPicture;
+  setup(function(done) {
+    RealLazyLoader = window.LazyLoader;
+    window.LazyLoader = MockLazyLoader;
+
+    fetchBuffer('/test-data/album-art.jpg').then(function(buffer) {
+      expectedPicture = buffer;
+      done();
+    });
+  });
+
+  teardown(function() {
+    window.LazyLoader = RealLazyLoader;
+  });
+
+  test('vorbis comment', function(done) {
+    var blob;
+    fetchBuffer('/test-data/vorbis-c.flac')
+      .then(function(buffer) {
+        return (blob = new Blob([buffer]));
+      })
+      .then(makeBlobView)
+      .then(FLACMetadata.parse)
+      .then(function(metadata) {
+        assert.strictEqual(metadata.tag_format, 'flac');
+        assert.strictEqual(metadata.artist, 'Black Sabbath');
+        assert.strictEqual(metadata.album, 'Master of Reality');
+        assert.strictEqual(metadata.title, 'Children of the Grave');
+        assert.strictEqual(metadata.tracknum, 4);
+        assert.strictEqual(metadata.trackcount, 8);
+        assert.strictEqual(metadata.discnum, 1);
+        assert.strictEqual(metadata.disccount, 1);
+        assert.strictEqual(metadata.picture.flavor, 'embedded');
+        assert.strictEqual(metadata.picture.type, 'image/jpeg');
+
+        return readPicSlice(blob, metadata.picture);
+      })
+      .then(function(buffer) {
+        assertBuffersEqual(buffer, expectedPicture);
+      })
+      .then(pass(done), fail(done));
+  });
+});

gaia/dev_apps/music-oga/test/unit/metadata/formats_test.js

@@ -0,0 +1,59 @@
+/* global FLACMetadata, ForwardLockMetadata, ID3v1Metadata, ID3v2Metadata,
+   MP4Metadata, OggMetadata, MetadataFormats, fetchBlobView, fetchBuffer,
+   ForwardLock, makeBlobView, pass, fail */
+'use strict';
+
+require('/test/unit/metadata/utils.js');
+require('/shared/js/omadrm/fl.js');
+require('/js/metadata/flac.js');
+require('/js/metadata/forward_lock.js');
+require('/js/metadata/id3v1.js');
+require('/js/metadata/id3v2.js');
+require('/js/metadata/mp4.js');
+require('/js/metadata/ogg.js');
+
+suite('format deduction', function() {
+  // Define the tests we want to run; note that `module` is a getter because
+  // the modules won't be loaded by the time this code is run.
+  var formats = [
+    {name: 'flac', file: '/test-data/vorbis-c.flac',
+     get module() { return FLACMetadata; }},
+    {name: 'mp3 (id3v1)', file: '/test-data/id3v1-simple.mp3',
+     get module() { return ID3v1Metadata; }},
+    {name: 'mp3 (id3v2)', file: '/test-data/id3v2.4-simple-latin1.mp3',
+     get module() { return ID3v2Metadata; }},
+    {name: 'mp3 (id3v1+2)', file: '/test-data/id3v1+2-simple.mp3',
+     get module() { return ID3v2Metadata; }},
+    {name: 'flac', file: '/test-data/aac-tags.m4a',
+     get module() { return MP4Metadata; }},
+    {name: 'ogg', file: '/test-data/vorbis-c.ogg',
+     get module() { return OggMetadata; }},
+  ];
+
+  formats.forEach(function(fmt) {
+    test(fmt.name, function(done) {
+      fetchBlobView(fmt.file)
+        .then(MetadataFormats.findParser)
+        .then(function(parser) {
+          assert.strictEqual(parser._formatInfo.module, fmt.module);
+        })
+        .then(pass(done), fail(done));
+    });
+  });
+
+  test('forwardlock', function(done) {
+    fetchBuffer('/test-data/no-tag.mp3')
+      .then(function(buffer) {
+        return ForwardLock.lockBuffer(
+          0xDEADBEEF, buffer, 'audio/mpeg', {}
+        );
+      })
+      .then(makeBlobView)
+      .then(MetadataFormats.findParser)
+      .then(function(parser) {
+        assert.strictEqual(parser._formatInfo.module, ForwardLockMetadata);
+      })
+      .then(pass(done), fail(done));
+  });
+
+});

gaia/dev_apps/music-oga/test/unit/metadata/forward_lock_test.js

@@ -0,0 +1,157 @@
+/* global ForwardLockMetadata, fetchBuffer, ForwardLock, makeBlobView,
+   MockGetDeviceStorage, MockLazyLoader, readBlob, assertBuffersEqual, pass,
+   fail */
+'use strict';
+
+require('/test/unit/metadata/utils.js');
+require('/shared/test/unit/mocks/mock_navigator_getdevicestorage.js');
+require('/shared/js/omadrm/fl.js');
+require('/js/metadata/forward_lock.js');
+require('/js/metadata/id3v1.js');
+require('/js/metadata/id3v2.js');
+
+suite('forwardlock files', function() {
+
+  var RealLazyLoader, RealGetDeviceStorage, RealForwardLockGetKey;
+
+  var secret = 0xDEADBEEF;
+  function mockGetKey(secret, callback) {
+    callback(secret);
+  }
+
+  setup(function(done) {
+    RealLazyLoader = window.LazyLoader;
+    window.LazyLoader = MockLazyLoader;
+
+    RealGetDeviceStorage = navigator.getDeviceStorage;
+    navigator.getDeviceStorage = MockGetDeviceStorage;
+
+    RealForwardLockGetKey = ForwardLock.getKey;
+    ForwardLock.getKey = mockGetKey.bind(this, secret);
+
+    require('/js/metadata/core.js', function() {
+      done();
+    });
+  });
+
+  teardown(function() {
+    window.LazyLoader = RealLazyLoader;
+    navigator.getDeviceStorage = RealGetDeviceStorage;
+    ForwardLock.getKey = RealForwardLockGetKey;
+  });
+
+  test('mp3 with id3v2 tag', function(done) {
+    var vendorMetadata = {vendor: 'Songs for Cool Kids, Inc'};
+    fetchBuffer('/test-data/id3v2.4-simple-latin1.mp3')
+      .then(function(buffer) {
+        return ForwardLock.lockBuffer(
+          secret, buffer, 'audio/mpeg', vendorMetadata
+        );
+      })
+      .then(makeBlobView)
+      .then(ForwardLockMetadata.parse)
+      .then(function(metadata) {
+        assert.strictEqual(metadata.locked, true);
+        assert.strictEqual(metadata.vendor, vendorMetadata.vendor);
+        assert.strictEqual(metadata.tag_format, 'id3v2.4.0');
+        assert.strictEqual(metadata.artist, 'AC/DC');
+        assert.strictEqual(metadata.album, 'Dirty Deeds Done Dirt Cheap');
+        assert.strictEqual(metadata.title, 'Problem Child');
+        assert.strictEqual(metadata.tracknum, 5);
+        assert.strictEqual(metadata.trackcount, 9);
+        assert.strictEqual(metadata.discnum, 1);
+        assert.strictEqual(metadata.disccount, 1);
+      })
+      .then(pass(done), fail(done));
+  });
+
+  test('mp3 with no metadata', function(done) {
+    var vendorMetadata = {vendor: 'Songs for Cool Kids, Inc',
+                          name: 'The Song That Never Ends'};
+    fetchBuffer('/test-data/no-tag.mp3')
+      .then(function(buffer) {
+        return ForwardLock.lockBuffer(
+          secret, buffer, 'audio/mpeg', vendorMetadata
+        );
+      })
+      .then(makeBlobView)
+      .then(ForwardLockMetadata.parse)
+      .then(function(metadata) {
+        done(function() {
+          assert.strictEqual(metadata.locked, true);
+          assert.strictEqual(metadata.vendor, vendorMetadata.vendor);
+          assert.strictEqual(metadata.artist, '');
+          assert.strictEqual(metadata.album, '');
+          assert.strictEqual(metadata.title, vendorMetadata.name);
+        });
+      }).catch(done);
+  });
+
+  test('decrypting forwardlock with no secret key', function(done) {
+    fetchBuffer('/test-data/id3v2.4-simple-latin1.mp3')
+      .then(function(buffer) {
+        return ForwardLock.lockBuffer(
+          secret, buffer, 'audio/mpeg', {vendor: 'vendor'}
+        );
+      })
+      .then(function(blob) {
+        ForwardLock.getKey = mockGetKey.bind(this, null);
+        return blob;
+      })
+      .catch(function(err) {
+        // Make sure we haven't hit an error yet...
+        done(new Error('failed to encrypt our test file'));
+      })
+      .then(makeBlobView)
+      .then(ForwardLockMetadata.parse)
+      .then(fail(done, 'parsing should have failed, but passed'), pass(done));
+  });
+
+  suite('album art', function() {
+    var expectedPicture;
+    setup(function(done) {
+      fetchBuffer('/test-data/album-art.jpg').then(function(buffer) {
+        expectedPicture = buffer;
+        done();
+      });
+    });
+
+    var testInfo = [
+      {test: 'mp3 with non-unsynced album art',
+       filename: '/test-data/id3v2.4-picture.mp3'},
+      {test: 'mp3 with unsynced album art',
+       filename: '/test-data/id3v2.4-framesunsync.mp3'},
+    ];
+    testInfo.forEach(function(info) {
+      test(info.test, function(done) {
+        var vendorMetadata = {vendor: 'Songs for Cool Kids, Inc'}, blob;
+        fetchBuffer(info.filename)
+          .then(function(buffer) {
+            return (blob = ForwardLock.lockBuffer(
+              secret, buffer, 'audio/mpeg', vendorMetadata
+            ));
+          })
+          .then(makeBlobView)
+          .then(ForwardLockMetadata.parse)
+          .then(function(metadata) {
+            assert.strictEqual(metadata.locked, true);
+            assert.strictEqual(metadata.vendor, vendorMetadata.vendor);
+            assert.strictEqual(metadata.artist, 'AC/DC');
+            assert.strictEqual(metadata.album, 'Dirty Deeds Done Dirt Cheap');
+            assert.strictEqual(metadata.title, 'Problem Child');
+            assert.strictEqual(metadata.tracknum, 5);
+            assert.strictEqual(metadata.picture.flavor, 'unsynced');
+            assert.strictEqual(metadata.picture.blob.type, 'image/jpeg');
+
+            return readBlob(metadata.picture.blob);
+          })
+          .then(function(buffer) {
+            assertBuffersEqual(buffer, expectedPicture);
+          })
+          .then(pass(done), fail(done));
+      });
+    });
+
+  });
+
+});

gaia/dev_apps/music-oga/test/unit/metadata/id3v1_test.js

@@ -0,0 +1,32 @@
+/* global ID3v1Metadata, fetchBlobView, pass, fail */
+'use strict';
+
+require('/test/unit/metadata/utils.js');
+require('/js/metadata/id3v1.js');
+
+suite('id3v1 tags', function() {
+
+  test('id3v1', function(done) {
+    fetchBlobView('/test-data/id3v1-simple.mp3')
+      .then(ID3v1Metadata.parse)
+      .then(function(metadata) {
+        assert.strictEqual(metadata.tag_format, 'id3v1');
+        assert.strictEqual(metadata.artist, 'AC/DC');
+        assert.strictEqual(metadata.album, 'Dirty Deeds Done Dirt Cheap');
+        assert.strictEqual(metadata.title, 'Problem Child');
+        assert.strictEqual(metadata.tracknum, 5);
+        assert.strictEqual(metadata.trackcount, undefined);
+      })
+      .then(pass(done), fail(done));
+  });
+
+  test('no metadata', function(done) {
+    fetchBlobView('/test-data/no-tag.mp3')
+      .then(ID3v1Metadata.parse)
+      .then(function(metadata) {
+        assert.deepEqual(metadata, {});
+      })
+      .then(pass(done), fail(done));
+  });
+
+});

gaia/dev_apps/music-oga/test/unit/metadata/id3v2_test.js

@@ -0,0 +1,343 @@
+/* global ID3v2Metadata, fetchBlobView, fetchBuffer, makeBlobView,
+   MockLazyLoader, readBlob, readPicSlice, assertBuffersEqual, pass, fail */
+'use strict';
+
+require('/test/unit/metadata/utils.js');
+require('/js/metadata/id3v1.js');
+require('/js/metadata/id3v2.js');
+
+suite('id3v2 tags', function() {
+
+  // We have a bunch of otherwise-identical mp3 files using different ID3
+  // versions, covering all valid character encodings. Test them all.
+  [2, 3, 4].forEach(function(version) {
+    var tag_format = 'id3v2.' + version + '.0';
+    suite('simple id3v2.' + version, function() {
+
+      test('latin1', function(done) {
+        var filename = '/test-data/id3v2.' + version + '-simple-latin1.mp3';
+        fetchBlobView(filename)
+          .then(ID3v2Metadata.parse)
+          .then(function(metadata) {
+            assert.strictEqual(metadata.tag_format, tag_format);
+            assert.strictEqual(metadata.artist, 'AC/DC');
+            assert.strictEqual(metadata.album, 'Dirty Deeds Done Dirt Cheap');
+            assert.strictEqual(metadata.title, 'Problem Child');
+            assert.strictEqual(metadata.tracknum, 5);
+            assert.strictEqual(metadata.trackcount, 9);
+            assert.strictEqual(metadata.discnum, 1);
+            assert.strictEqual(metadata.disccount, 1);
+          })
+          .then(pass(done), fail(done));
+      });
+
+      test('utf16', function(done) {
+        var filename = '/test-data/id3v2.' + version + '-simple-utf16.mp3';
+        fetchBlobView(filename)
+          .then(ID3v2Metadata.parse)
+          .then(function(metadata) {
+            assert.strictEqual(metadata.tag_format, tag_format);
+            assert.strictEqual(metadata.artist, 'Mötley Crüe');
+            assert.strictEqual(metadata.album, 'Dr. Feelgood');
+            assert.strictEqual(metadata.title, 'Kickstart My Heart');
+            assert.strictEqual(metadata.tracknum, 5);
+            assert.strictEqual(metadata.trackcount, 11);
+            assert.strictEqual(metadata.discnum, 1);
+            assert.strictEqual(metadata.disccount, 1);
+          })
+          .then(pass(done), fail(done));
+      });
+
+      if (version === 4) {
+        test('utf16be', function(done) {
+          var filename = '/test-data/id3v2.' + version + '-simple-utf16be.mp3';
+          fetchBlobView(filename)
+            .then(ID3v2Metadata.parse)
+            .then(function(metadata) {
+              assert.strictEqual(metadata.tag_format, tag_format);
+              assert.strictEqual(metadata.artist, 'Gåte');
+              assert.strictEqual(metadata.album, 'Jygri');
+              assert.strictEqual(metadata.title, 'Bruremarsj frå Jämtland');
+              assert.strictEqual(metadata.tracknum, 8);
+              assert.strictEqual(metadata.trackcount, 12);
+              assert.strictEqual(metadata.discnum, 1);
+              assert.strictEqual(metadata.disccount, 1);
+            })
+            .then(pass(done), fail(done));
+        });
+
+        test('utf8', function(done) {
+          var filename = '/test-data/id3v2.' + version + '-simple-utf8.mp3';
+          fetchBlobView(filename)
+            .then(ID3v2Metadata.parse)
+            .then(function(metadata) {
+              assert.strictEqual(metadata.tag_format, tag_format);
+              assert.strictEqual(metadata.artist, 'Lunar Aurora');
+              assert.strictEqual(metadata.album, 'Hoagascht');
+              assert.strictEqual(metadata.title, 'Håbergoaß');
+              assert.strictEqual(metadata.tracknum, 5);
+              assert.strictEqual(metadata.trackcount, 8);
+              assert.strictEqual(metadata.discnum, 1);
+              assert.strictEqual(metadata.disccount, 1);
+            })
+            .then(pass(done), fail(done));
+        });
+      }
+    });
+
+  });
+
+  suite('simple id3v1+2', function() {
+
+    test('id3v1+2', function(done) {
+      var filename = '/test-data/id3v1+2-simple.mp3';
+      fetchBlobView(filename)
+        .then(ID3v2Metadata.parse)
+        .then(function(metadata) {
+          // Here we should have the v2 tag content.
+          assert.strictEqual(metadata.tag_format, 'id3v2.3.0');
+          assert.strictEqual(metadata.artist, 'AC/DC');
+          assert.strictEqual(metadata.album, 'Dirty Deeds Done Dirt Cheap');
+          assert.strictEqual(metadata.title, 'Problem Child');
+          assert.strictEqual(metadata.tracknum, 5);
+          assert.strictEqual(metadata.trackcount, undefined);
+        })
+        .then(pass(done), fail(done));
+    });
+
+  });
+
+  suite('album art', function() {
+
+    var expectedPicture;
+    setup(function(done) {
+      fetchBuffer('/test-data/album-art.jpg').then(function(buffer) {
+        expectedPicture = buffer;
+        done();
+      });
+    });
+
+    [2, 3, 4].forEach(function(version) {
+      test('id3v2.' + version, function(done) {
+        var blob, filename = '/test-data/id3v2.' + version + '-picture.mp3';
+        fetchBuffer(filename)
+          .then(function(buffer) {
+            return (blob = new Blob([buffer]));
+          })
+          .then(makeBlobView)
+          .then(ID3v2Metadata.parse)
+          .then(function(metadata) {
+            assert.strictEqual(metadata.artist, 'AC/DC');
+            assert.strictEqual(metadata.album, 'Dirty Deeds Done Dirt Cheap');
+            assert.strictEqual(metadata.title, 'Problem Child');
+            assert.strictEqual(metadata.tracknum, 5);
+            assert.strictEqual(metadata.picture.flavor, 'embedded');
+            assert.strictEqual(metadata.picture.type, 'image/jpeg');
+
+            return readPicSlice(blob, metadata.picture);
+          })
+          .then(function(buffer) {
+            assertBuffersEqual(buffer, expectedPicture);
+          })
+          .then(pass(done), fail(done));
+      });
+    });
+
+  });
+
+  suite('extended header', function() {
+
+    [3, 4].forEach(function(version) {
+      var tag_format = 'id3v2.' + version + '.0';
+
+      test('id3v2.' + version, function(done) {
+        var filename = '/test-data/id3v2.' + version + '-extheader.mp3';
+        fetchBlobView(filename)
+          .then(ID3v2Metadata.parse)
+          .then(function(metadata) {
+            assert.strictEqual(metadata.tag_format, tag_format);
+            assert.strictEqual(metadata.artist, 'AC/DC');
+            assert.strictEqual(metadata.album, 'Dirty Deeds Done Dirt Cheap');
+            assert.strictEqual(metadata.title, 'Problem Child');
+            assert.strictEqual(metadata.tracknum, 5);
+            assert.strictEqual(metadata.trackcount, 9);
+          })
+          .then(pass(done), fail(done));
+      });
+    });
+
+  });
+
+  suite('unsynchronized data', function() {
+
+    var expectedPicture;
+    setup(function(done) {
+      fetchBuffer('/test-data/album-art.jpg').then(function(buffer) {
+        expectedPicture = buffer;
+        done();
+      });
+    });
+
+    [3, 4].forEach(function(version) {
+      var tag_format = 'id3v2.' + version + '.0';
+
+      test('id3v2.' + version + ' whole tag', function(done) {
+        var filename = '/test-data/id3v2.' + version + '-allunsync.mp3';
+        fetchBlobView(filename)
+          .then(ID3v2Metadata.parse)
+          .then(function(metadata) {
+            assert.strictEqual(metadata.tag_format, tag_format);
+            assert.strictEqual(metadata.artist, 'AC/DC');
+            assert.strictEqual(metadata.album, 'Dirty Deeds Done Dirt Cheap');
+            assert.strictEqual(metadata.title, 'Problem Child');
+            assert.strictEqual(metadata.tracknum, 5);
+            assert.strictEqual(metadata.trackcount, 9);
+            assert.strictEqual(metadata.picture.flavor, 'unsynced');
+            assert.strictEqual(metadata.picture.blob.type, 'image/jpeg');
+
+            return readBlob(metadata.picture.blob);
+          })
+          .then(function(buffer) {
+            assertBuffersEqual(buffer, expectedPicture);
+          })
+          .then(pass(done), fail(done));
+      });
+    });
+
+    test('id3v2.4 selected frames', function(done) {
+      var filename = '/test-data/id3v2.4-framesunsync.mp3';
+      fetchBlobView(filename)
+        .then(ID3v2Metadata.parse)
+        .then(function(metadata) {
+          assert.strictEqual(metadata.tag_format, 'id3v2.4.0');
+          assert.strictEqual(metadata.artist, 'AC/DC');
+          assert.strictEqual(metadata.album, 'Dirty Deeds Done Dirt Cheap');
+          assert.strictEqual(metadata.title, 'Problem Child');
+          assert.strictEqual(metadata.tracknum, 5);
+          assert.strictEqual(metadata.trackcount, 9);
+          assert.strictEqual(metadata.picture.flavor, 'unsynced');
+          assert.strictEqual(metadata.picture.blob.type, 'image/jpeg');
+
+          return readBlob(metadata.picture.blob);
+        })
+        .then(function(buffer) {
+          assertBuffersEqual(buffer, expectedPicture);
+        })
+        .then(pass(done), fail(done));
+    });
+
+    test('id3v2.4 selected frames with data length indicator', function(done) {
+      var filename = '/test-data/id3v2.4-framesunsync-datalen.mp3';
+      fetchBlobView(filename)
+        .then(ID3v2Metadata.parse)
+        .then(function(metadata) {
+          assert.strictEqual(metadata.tag_format, 'id3v2.4.0');
+          assert.strictEqual(metadata.artist, 'AC/DC');
+          assert.strictEqual(metadata.album, 'Dirty Deeds Done Dirt Cheap');
+          assert.strictEqual(metadata.title, 'Problem Child');
+          assert.strictEqual(metadata.tracknum, 5);
+          assert.strictEqual(metadata.trackcount, 9);
+          assert.strictEqual(metadata.picture.flavor, 'unsynced');
+          assert.strictEqual(metadata.picture.blob.type, 'image/jpeg');
+
+          return readBlob(metadata.picture.blob);
+        })
+        .then(function(buffer) {
+          assertBuffersEqual(buffer, expectedPicture);
+        })
+        .then(pass(done), fail(done));
+    });
+  });
+
+  suite('multivalue frames', function() {
+
+    ['latin1', 'utf16', 'utf16be', 'utf8'].forEach(function(encoding) {
+      test('id3v2.4 ' + encoding, function(done) {
+        var filename = '/test-data/id3v2.4-multivalue-' + encoding + '.mp3';
+        fetchBlobView(filename)
+          .then(ID3v2Metadata.parse)
+          .then(function(metadata) {
+            assert.strictEqual(metadata.tag_format, 'id3v2.4.0');
+            assert.strictEqual(metadata.artist, 'Dynatron / Perturbator');
+            assert.strictEqual(metadata.album, 'I Am the Night');
+            assert.strictEqual(metadata.title, 'Volcanic Machinery');
+            assert.strictEqual(metadata.tracknum, 13);
+            assert.strictEqual(metadata.trackcount, 15);
+          })
+          .then(pass(done), fail(done));
+      });
+    });
+
+  });
+
+  suite('invalid files', function() {
+    var RealLazyLoader;
+
+    setup(function() {
+      RealLazyLoader = window.LazyLoader;
+      window.LazyLoader = MockLazyLoader;
+    });
+
+    teardown(function() {
+      window.LazyLoader = RealLazyLoader;
+    });
+
+    [2, 3, 4].forEach(function(version) {
+      suite('invalid id3v2.' + version, function() {
+
+        test('invalid frame size', function(done) {
+          var filename = '/test-data/id3v2.' + version +
+                         '-invalid-frame-size.mp3';
+          fetchBlobView(filename)
+            .then(ID3v2Metadata.parse)
+            .then(function(metadata) {
+              assert.strictEqual(metadata.tag_format, undefined);
+              assert.strictEqual(metadata.artist, undefined);
+              assert.strictEqual(metadata.album, undefined);
+              assert.strictEqual(metadata.title, undefined);
+              assert.strictEqual(metadata.tracknum, undefined);
+              assert.strictEqual(metadata.trackcount, undefined);
+              assert.strictEqual(metadata.discnum, undefined);
+              assert.strictEqual(metadata.disccount, undefined);
+            })
+            .then(pass(done), fail(done));
+        });
+
+        test('invalid skipped frame', function(done) {
+          var filename = '/test-data/id3v2.' + version +
+                         '-invalid-skipped-frame-size.mp3';
+          fetchBlobView(filename)
+            .then(ID3v2Metadata.parse)
+            .then(function(metadata) {
+              assert.strictEqual(metadata.tag_format, undefined);
+              assert.strictEqual(metadata.artist, undefined);
+              assert.strictEqual(metadata.album, undefined);
+              assert.strictEqual(metadata.title, undefined);
+              assert.strictEqual(metadata.tracknum, undefined);
+              assert.strictEqual(metadata.trackcount, undefined);
+              assert.strictEqual(metadata.discnum, undefined);
+              assert.strictEqual(metadata.disccount, undefined);
+            })
+            .then(pass(done), fail(done));
+        });
+      });
+    });
+
+    test('id3v1+2 with invalid ID3v2 frame size', function(done) {
+      var filename = '/test-data/id3v1+2-invalid-frame-size.mp3';
+      fetchBlobView(filename)
+        .then(ID3v2Metadata.parse)
+        .then(function(metadata) {
+          // Here we should have the v1 tag content.
+          assert.strictEqual(metadata.tag_format, 'id3v1');
+          assert.strictEqual(metadata.artist, 'AC/DC');
+          assert.strictEqual(metadata.album, 'Dirty Deeds Done Dirt Cheap');
+          assert.strictEqual(metadata.title, 'Problem Child OLD');
+          assert.strictEqual(metadata.tracknum, 5);
+          assert.strictEqual(metadata.trackcount, undefined);
+        })
+        .then(pass(done), fail(done));
+    });
+
+  });
+});

gaia/dev_apps/music-oga/test/unit/metadata/mock_album_art_cache.js

@@ -0,0 +1,12 @@
+/* exported MockAlbumArtCache */
+'use strict';
+
+
+var MockAlbumArtCache = {
+  getThumbnailURL: function() {
+    return Promise.resolve();
+  },
+  getThumbnailBlob: function() {
+    return Promise.resolve();
+  }
+};

gaia/dev_apps/music-oga/test/unit/metadata/mock_navigator_getdevicestorage.js

@@ -0,0 +1,90 @@
+'use strict';
+/* globals MockDOMRequest */
+/* exported MockGetDeviceStorage */
+
+var MockFileStore = {
+  _data: {},
+
+  get: function(store, filename) {
+    if (this._data[store]) {
+      return this._data[store][filename];
+    }
+    return undefined;
+  },
+
+  set: function(store, filename, data) {
+    if (!(store in this._data)) {
+      this._data[store] = {};
+    }
+    this._data[store][filename] = data;
+  },
+
+  readAsText: function(store, filename) {
+    var self = this;
+    return new Promise(function(resolve, reject) {
+      var reader = new FileReader();
+      reader.readAsText(self.get(store, filename));
+      reader.onload = function() {
+        resolve(reader.result);
+      };
+      reader.onerror = function() {
+        reject(reader.error);
+      };
+    });
+  }
+};
+
+var MockGetDeviceStorage = function(store) {
+  return {
+    get: function(filename) {
+      return {
+        set onsuccess(cb) {
+          if (MockFileStore.get(store, filename)) {
+            cb.call(this);
+          }
+        },
+        set onerror(cb) {
+          if (!MockFileStore.get(store, filename)) {
+            cb.call(this);
+          }
+        },
+        get result() {
+          return MockFileStore.get(store, filename);
+        }
+      };
+    },
+    addNamed: function(blob, filename) {
+      var file = new Blob([blob], {type: blob.type});
+      file.name = filename;
+      MockFileStore.set(store, filename, file);
+
+      return {
+        set onsuccess(cb) {
+          cb({ target: {result: filename} });
+        }
+      };
+    },
+    addEventListener: function() {
+      // Do nothing
+    },
+    available: function() {
+      return {
+        set onsuccess(cb) {
+          setTimeout(cb);
+        },
+        get result() {
+          return 'available';
+        }
+      };
+    },
+    // need include libraries to test following domrequest functions
+    // * /shared/test/unit/mocks/mock_event_target.js
+    // * /shared/test/unit/mocks/mock_dom_request.js
+    freeSpace: function freeSpace() {
+      return new MockDOMRequest();
+    },
+    usedSpace: function usedSpace() {
+      return new MockDOMRequest();
+    }
+  };
+};

gaia/dev_apps/music-oga/test/unit/metadata/mp4_test.js

@@ -0,0 +1,45 @@
+/* global MP4Metadata, fetchBuffer, makeBlobView, readPicSlice,
+   assertBuffersEqual, pass, fail */
+'use strict';
+
+require('/test/unit/metadata/utils.js');
+require('/js/metadata/mp4.js');
+
+suite('mp4', function () {
+  var expectedPicture;
+  setup(function(done) {
+    fetchBuffer('/test-data/album-art.jpg').then(function(buffer) {
+      expectedPicture = buffer;
+      done();
+    });
+  });
+
+  test('m4a tags', function(done) {
+    var blob;
+    fetchBuffer('/test-data/aac-tags.m4a')
+      .then(function(buffer) {
+        return (blob = new Blob([buffer]));
+      })
+      .then(makeBlobView)
+      .then(MP4Metadata.parse)
+      .then(function(metadata) {
+        assert.strictEqual(metadata.tag_format, 'mp4');
+        assert.strictEqual(metadata.artist, 'The Tragically Hip');
+        assert.strictEqual(metadata.album, 'Trouble At The Henhouse');
+        assert.strictEqual(metadata.title, 'Giftshop');
+        assert.strictEqual(metadata.tracknum, 1);
+        assert.strictEqual(metadata.trackcount, 12);
+        assert.strictEqual(metadata.discnum, 1);
+        assert.strictEqual(metadata.disccount, 1);
+        assert.strictEqual(metadata.picture.flavor, 'embedded');
+        assert.strictEqual(metadata.picture.type, 'image/jpeg');
+
+        return readPicSlice(blob, metadata.picture);
+      })
+      .then(function(buffer) {
+        assertBuffersEqual(buffer, expectedPicture);
+      })
+      .then(pass(done), fail(done));
+  });
+
+});

gaia/dev_apps/music-oga/test/unit/metadata/ogg_test.js

@@ -0,0 +1,49 @@
+/* global OggMetadata, fetchBlobView, fetchBuffer, MockLazyLoader, readBlob,
+   assertBuffersEqual, pass, fail */
+'use strict';
+
+require('/test/unit/metadata/utils.js');
+require('/js/metadata/ogg.js');
+require('/js/metadata/vorbis_picture.js');
+
+suite('ogg tags', function() {
+  var RealLazyLoader;
+  var expectedPicture;
+
+  setup(function(done) {
+    RealLazyLoader = window.LazyLoader;
+    window.LazyLoader = MockLazyLoader;
+
+    fetchBuffer('/test-data/album-art.jpg').then(function(buffer) {
+      expectedPicture = buffer;
+      done();
+    });
+  });
+
+  teardown(function() {
+    window.LazyLoader = RealLazyLoader;
+  });
+
+  test('vorbis comment', function(done) {
+    fetchBlobView('/test-data/vorbis-c.ogg')
+      .then(OggMetadata.parse)
+      .then(function(metadata) {
+        assert.strictEqual(metadata.tag_format, 'vorbis');
+        assert.strictEqual(metadata.artist, 'Angra');
+        assert.strictEqual(metadata.album, 'Holy Land');
+        assert.strictEqual(metadata.title, 'Carolina IV');
+        assert.strictEqual(metadata.tracknum, 4);
+        assert.strictEqual(metadata.trackcount, 10);
+        assert.strictEqual(metadata.discnum, 1);
+        assert.strictEqual(metadata.disccount, 1);
+        assert.strictEqual(metadata.picture.flavor, 'unsynced');
+        assert.strictEqual(metadata.picture.blob.type, 'image/jpeg');
+
+        return readBlob(metadata.picture.blob);
+      })
+      .then(function(buffer) {
+        assertBuffersEqual(buffer, expectedPicture);
+      })
+      .then(pass(done), fail(done));
+  });
+});

gaia/dev_apps/music-oga/test/unit/metadata/utils.js

@@ -0,0 +1,72 @@
+/* global BlobView */
+/* exported fetchBlobView, fetchBuffer, readPicSlice, assertBuffersEqual */
+
+'use strict';
+
+require('/shared/js/blobview.js');
+require('/js/metadata/formats.js');
+require('/test/unit/mock_lazy_loader.js');
+require('/test/unit/utils.js');
+
+function fetchBuffer(url) {
+  return new Promise(function(resolve, reject) {
+    var xhr = new XMLHttpRequest();
+    xhr.open('GET', url);
+    xhr.onload = function() {
+      if (xhr.status !== 200) {
+        reject(new Error('Failed with status: ' + xhr.status));
+      } else {
+        resolve(this.response);
+      }
+    };
+    xhr.onerror = xhr.ontimeout = function() {
+      reject(new Error('Failed'));
+    };
+    xhr.responseType = 'arraybuffer';
+    xhr.send();
+  });
+}
+
+function makeBlobView(blob, size) {
+  if (size === undefined) {
+    size = 64 * 1024;
+  }
+
+  return new Promise(function(resolve, reject) {
+    BlobView.get(blob, 0, size, function(blobview, error) {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve(blobview);
+    });
+  });
+}
+
+function fetchBlobView(url, size) {
+  return fetchBuffer(url).then(function(buffer) {
+    return makeBlobView(new Blob([buffer]), size);
+  });
+}
+
+function readBlob(blob) {
+  return new Promise(function(resolve, reject) {
+    var reader = new FileReader();
+    reader.readAsArrayBuffer(blob);
+    reader.onload = function(event) {
+      resolve(reader.result);
+    };
+    reader.onerror = function(event) {
+      reject(event.target.error);
+    };
+  });
+}
+
+function readPicSlice(blob, picture) {
+  var slice = blob.slice(picture.start, picture.end, picture.type);
+  return readBlob(slice);
+}
+
+function assertBuffersEqual(a, b) {
+  return assert.deepEqual(new Uint8Array(a), new Uint8Array(b));
+}

gaia/dev_apps/music-oga/test/unit/mock_async_storage.js

@@ -0,0 +1,17 @@
+/* exported MockAsyncStorage */
+'use strict';
+var MockAsyncStorage = {
+  user_data: {},
+
+  getItem: function(key, callback) {
+    callback(this.user_data[key]);
+  },
+
+  setItem: function(key, value) {
+    this.user_data[key] = value;
+  },
+
+  clear: function() {
+    this.user_data = {};
+  }
+};

gaia/dev_apps/music-oga/test/unit/mock_db.js

@@ -0,0 +1,79 @@
+/* exported MockDatabase */
+'use strict';
+
+var MockDatabase = {
+
+  cancelEnumeration: function() {},
+
+  _mockResultsMetadataAlbum: [
+    {
+      metadata: {
+        album: 'Crime of the Century',
+        artist: 'Supertramp',
+        title: 'School'
+      }
+    },
+    {
+      metadata: {
+        album: 'Crisis? What Crisis?',
+        artist: 'Supertramp',
+        title: 'Lady'
+      }
+    },
+    {
+      metadata: {
+        album: 'Even in the Quietests Moments...',
+        artist: 'Supertramp',
+        title: 'Fool\'s Overture'
+      }
+    },
+    {
+      metadata: {
+        album: 'Breakfast in America',
+        artist: 'Supertramp',
+        title: 'Goodbye Stranger'
+      }
+    }
+  ],
+
+  enumerate: function(key, range, direction, callback) {
+
+    switch (key) {
+    case 'metadata.album':
+      this._mockResultsMetadataAlbum.forEach((entry) => callback(entry));
+      // the end
+      callback(null);
+      break;
+    }
+    return 1;
+  },
+
+  enumerateAll: function(key, range, direction, callback) {
+    var results = [];
+
+    switch (key) {
+    case 'metadata.album':
+      results = results.concat(this._mockResultsMetadataAlbum);
+      break;
+    }
+
+    callback(results);
+  },
+
+  advancedEnumerate: function(key, range, direction, index, callback) {
+    // XXX: This assumes that the callback immediately calls cancelEnumeration!
+    callback(this._mockResultsMetadataAlbum[index]);
+  },
+
+  count: function(key, range, callback) {
+    var result = 0;
+
+    switch (key) {
+    case 'metadata.album':
+      result = this._mockResultsMetadataAlbum.length;
+      break;
+    }
+
+    callback(result);
+  }
+};

gaia/dev_apps/music-oga/test/unit/mock_lazy_loader.js

@@ -0,0 +1,19 @@
+'use strict';
+/* exported MockLazyLoader */
+
+// Our MockLazyLoader is better than the shared one because we actually use a
+// Promise for load(). However, trying to do that with the shared version breaks
+// all the system app's tests. Oh well.
+var MockLazyLoader = {
+  load: function(fileArray, callback) {
+    if (callback) {
+      callback();
+    } else {
+      return Promise.resolve();
+    }
+  },
+
+  getJSON: function(file) {
+    return Promise.resolve({});
+  }
+};

gaia/dev_apps/music-oga/test/unit/mock_music.js

@@ -0,0 +1,14 @@
+/* exported MockApp */
+'use strict';
+
+var MockApp = {
+  pendingPick: null,
+  currentOverlay: null,
+  knownSongs: [],
+  // Exported functions
+  showOverlay: function() {},
+  showCorrectOverlay: function() {},
+  dbEnumerable: function() {},
+  dbReady: function() {},
+  refreshViews: function() {}
+};

gaia/dev_apps/music-oga/test/unit/queue_test.js

@@ -0,0 +1,254 @@
+/* global MockAsyncStorage, MockDatabase, PlaybackQueue, pass, fail */
+'use strict';
+
+require('/test/unit/mock_async_storage.js');
+require('/test/unit/mock_db.js');
+require('/test/unit/utils.js');
+require('/js/queue.js');
+
+suite('playback queues', () => {
+  var RealAsyncStorage, RealDatabase;
+
+  setup(() => {
+    RealAsyncStorage = window.asyncStorage;
+    window.asyncStorage = MockAsyncStorage;
+    window.asyncStorage.clear();
+
+    RealDatabase = window.Database;
+    window.Database = MockDatabase;
+  });
+
+  teardown(() => {
+    window.asyncStorage = RealAsyncStorage;
+    window.Database = RealDatabase;
+  });
+
+  suite('settings', () => {
+
+    test('load default settings', (done) => {
+      PlaybackQueue.loadSettings().then(() => {
+        assert.strictEqual(PlaybackQueue.repeat, PlaybackQueue.Repeat.OFF);
+        assert.strictEqual(PlaybackQueue.shuffle, false);
+      }).then(pass(done), fail(done));
+    });
+
+    test('save settings', (done) => {
+      PlaybackQueue.loadSettings().then(() => {
+        PlaybackQueue.repeat = PlaybackQueue.Repeat.SONG;
+        PlaybackQueue.shuffle = true;
+        return PlaybackQueue.loadSettings();
+      }).then(() => {
+        assert.strictEqual(PlaybackQueue.repeat, PlaybackQueue.Repeat.SONG);
+        assert.strictEqual(PlaybackQueue.shuffle, true);
+      }).then(pass(done), fail(done));
+    });
+
+  });
+
+  var infos = [
+    {name: 'static queue', creator: (fileinfos, index) => {
+      return new PlaybackQueue.StaticQueue(fileinfos, index);
+    }},
+    {name: 'dynamic queue', creator: (fileinfos, index) => {
+      return new PlaybackQueue.DynamicQueue({count: fileinfos.length}, index);
+    }},
+  ];
+
+  infos.forEach(({name: name, creator: creator}) => {
+
+    suite(name, () => {
+      var fileinfos;
+
+      function checkCurrent(queue, rawIndex, shuffledIndices = null) {
+        var index = shuffledIndices ? shuffledIndices[rawIndex] : rawIndex;
+
+        assert.strictEqual(queue.rawIndex, rawIndex);
+        assert.strictEqual(queue.index, index);
+        return queue.current().then((info) => {
+          assert.deepEqual(info, fileinfos[index]);
+        });
+      }
+
+      setup((done) => {
+        fileinfos = MockDatabase._mockResultsMetadataAlbum;
+        PlaybackQueue.loadSettings().then(pass(done), fail(done));
+      });
+
+      suite('basic', () => {
+        var queue;
+
+        setup(() => {
+          queue = creator(fileinfos);
+        });
+
+        test('length', () => {
+          assert.strictEqual(queue.length, fileinfos.length);
+        });
+
+        test('index', () => {
+          assert.strictEqual(queue.index, 0);
+        });
+
+        test('rawIndex', () => {
+          assert.strictEqual(queue.rawIndex, 0);
+        });
+
+        test('current()', (done) => {
+          checkCurrent(queue, 0).then(pass(done), fail(done));
+        });
+
+        test('next()', (done) => {
+          queue.next();
+          checkCurrent(queue, 1).then(pass(done), fail(done));
+        });
+
+        test('previous()', (done) => {
+          queue.next();
+          queue.previous();
+          checkCurrent(queue, 0).then(() => {
+            queue.previous();
+            return checkCurrent(queue, 0);
+          }).then(pass(done), fail(done));
+        });
+
+        test('start at known index', (done) => {
+          queue = creator(fileinfos, 1);
+          checkCurrent(queue, 1).then(pass(done), fail(done));
+        });
+      });
+
+      suite('repeat list', () => {
+        var queue;
+
+        setup(() => {
+          PlaybackQueue.repeat = PlaybackQueue.Repeat.LIST;
+          queue = creator(fileinfos);
+        });
+
+        test('next()', (done) => {
+          queue.next();
+          queue.next();
+          queue.next();
+          queue.next();
+
+          checkCurrent(queue, 0).then(pass(done), fail(done));
+        });
+
+        test('previous()', (done) => {
+          queue.previous();
+          checkCurrent(queue, 3).then(pass(done), fail(done));
+        });
+
+        test('start at known index', (done) => {
+          queue = creator(fileinfos, 3);
+          checkCurrent(queue, 3).then(() => {
+            queue.next();
+            return checkCurrent(queue, 0);
+          }).then(pass(done), fail(done));
+        });
+      });
+
+      suite('repeat song', () => {
+        var queue;
+
+        setup(() => {
+          PlaybackQueue.repeat = PlaybackQueue.Repeat.SONG;
+          queue = creator(fileinfos);
+        });
+
+        test('next(false)', (done) => {
+          queue.next();
+          checkCurrent(queue, 1).then(pass(done), fail(done));
+        });
+
+        test('next(true)', (done) => {
+          queue.next(true);
+          checkCurrent(queue, 0).then(pass(done), fail(done));
+        });
+
+        test('previous()', (done) => {
+          queue.previous();
+          checkCurrent(queue, 0).then(pass(done), fail(done));
+        });
+      });
+
+      suite('shuffle', () => {
+        var queue, RealRandom, seed;
+
+        function MockRandom() {
+          var x = Math.sin(seed++) * 1000;
+          return x - Math.floor(x);
+        }
+
+        setup(() => {
+          seed = 1;
+          RealRandom = Math.random;
+          Math.random = MockRandom;
+
+          PlaybackQueue.shuffle = true;
+
+          queue = creator(fileinfos);
+        });
+
+        teardown(() => {
+          Math.random = RealRandom;
+        });
+
+        test('shuffled order', (done) => {
+          var expectedIndices = [3, 2, 0, 1];
+
+          checkCurrent(queue, 0, expectedIndices).then(() => {
+            queue.next();
+            return checkCurrent(queue, 1, expectedIndices);
+          }).then(() => {
+            queue.next();
+            return checkCurrent(queue, 2, expectedIndices);
+          }).then(() => {
+            queue.next();
+            return checkCurrent(queue, 3, expectedIndices);
+          }).then(pass(done), fail(done));
+        });
+
+        test('repeat list', (done) => {
+          PlaybackQueue.repeat = PlaybackQueue.Repeat.LIST;
+          var expectedIndices = [3, 1, 2, 0];
+
+          queue.next();
+          queue.next();
+          queue.next();
+          queue.next();
+
+          checkCurrent(queue, 0, expectedIndices).then(() => {
+            queue.next();
+            return checkCurrent(queue, 1, expectedIndices);
+          }).then(() => {
+            queue.next();
+            return checkCurrent(queue, 2, expectedIndices);
+          }).then(() => {
+            queue.next();
+            return checkCurrent(queue, 3, expectedIndices);
+          }).then(pass(done), fail(done));
+        });
+
+        test('start at known index', (done) => {
+          var expectedIndices = [1, 2, 3, 0];
+          queue = creator(fileinfos, 1);
+
+          checkCurrent(queue, 0, expectedIndices).then(() => {
+            queue.next();
+            return checkCurrent(queue, 1, expectedIndices);
+          }).then(() => {
+            queue.next();
+            return checkCurrent(queue, 2, expectedIndices);
+          }).then(() => {
+            queue.next();
+            return checkCurrent(queue, 3, expectedIndices);
+          }).then(pass(done), fail(done));
+        });
+
+      });
+
+    });
+  });
+
+});

gaia/dev_apps/music-oga/test/unit/remote_controls_test.js

@@ -0,0 +1,524 @@
+/* global MediaRemoteControls, REMOTE_CONTROLS, AVRCP, IAC,
+          MockBluetoothHelper, MockBluetoothHelperInstance,
+          MockNavigatormozSetMessageHandler */
+'use strict';
+
+require('/shared/js/media/remote_controls.js');
+require('/shared/test/unit/mocks/mock_navigator_moz_set_message_handler.js');
+require('/shared/test/unit/mocks/mock_bluetooth_helper.js');
+
+suite('Media Remote Controls', function() {
+  var mrc;
+  var realSetMessageHandler;
+  var realBluetoothHelper;
+
+  setup(function() {
+    realSetMessageHandler = navigator.mozSetMessageHandler;
+    navigator.mozSetMessageHandler = MockNavigatormozSetMessageHandler;
+    MockNavigatormozSetMessageHandler.mSetup();
+
+    realBluetoothHelper = window.BluetoothHelper;
+    window.BluetoothHelper = MockBluetoothHelper;
+    mrc = new MediaRemoteControls();
+  });
+
+  teardown(function() {
+    MockNavigatormozSetMessageHandler.mTeardown();
+    navigator.mozSetMessageHandler = realSetMessageHandler;
+
+    window.BluetoothHelper = realBluetoothHelper;
+  });
+
+  suite('AVRCP commands', function() {
+    test('AVRCP.PLAY_PRESS', function() {
+      var playListener = this.sinon.spy(function(event) {
+        var command = event.detail.command;
+        assert.equal(command, REMOTE_CONTROLS.PLAY);
+        var isSCOConnected = event.detail.isSCOConnected;
+        assert.equal(isSCOConnected, false);
+        mrc.removeCommandListener(REMOTE_CONTROLS.PLAY, playListener);
+        assert.equal(mrc._commandListeners[REMOTE_CONTROLS.PLAY].length, 0);
+      });
+      mrc.addCommandListener(REMOTE_CONTROLS.PLAY, playListener);
+      mrc._commandHandler(AVRCP.PLAY_PRESS);
+      assert.ok(playListener.calledOnce);
+    });
+
+    test('AVRCP.PLAY_PAUSE_PRESS', function() {
+      var playpauseListener = this.sinon.spy(function(event) {
+        var command = event.detail.command;
+        assert.equal(command, REMOTE_CONTROLS.PLAY_PAUSE);
+        var isSCOConnected = event.detail.isSCOConnected;
+        assert.equal(isSCOConnected, false);
+        mrc.removeCommandListener(
+          REMOTE_CONTROLS.PLAY_PAUSE, playpauseListener
+        );
+        assert.equal(
+          mrc._commandListeners[REMOTE_CONTROLS.PLAY_PAUSE].length, 0
+        );
+      });
+      mrc.addCommandListener(REMOTE_CONTROLS.PLAY_PAUSE, playpauseListener);
+      mrc._commandHandler(AVRCP.PLAY_PAUSE_PRESS);
+      assert.ok(playpauseListener.calledOnce);
+    });
+
+    test('AVRCP.PAUSE_PRESS', function() {
+      var pauseListener = this.sinon.spy(function(event) {
+        var command = event.detail.command;
+        assert.equal(command, REMOTE_CONTROLS.PAUSE);
+        var isSCOConnected = event.detail.isSCOConnected;
+        assert.equal(isSCOConnected, false);
+        mrc.removeCommandListener(REMOTE_CONTROLS.PAUSE, pauseListener);
+        assert.equal(mrc._commandListeners[REMOTE_CONTROLS.PAUSE].length, 0);
+      });
+      mrc.addCommandListener(REMOTE_CONTROLS.PAUSE, pauseListener);
+      mrc._commandHandler(AVRCP.PAUSE_PRESS);
+      assert.ok(pauseListener.calledOnce);
+    });
+
+    test('AVRCP.STOP_PRESS', function() {
+      var stopListener = this.sinon.spy(function(event) {
+        var command = event.detail.command;
+        assert.equal(command, REMOTE_CONTROLS.STOP);
+        mrc.removeCommandListener(REMOTE_CONTROLS.STOP, stopListener);
+        assert.equal(mrc._commandListeners[REMOTE_CONTROLS.STOP].length, 0);
+      });
+      mrc.addCommandListener(REMOTE_CONTROLS.STOP, stopListener);
+      mrc._commandHandler(AVRCP.STOP_PRESS);
+      assert.ok(stopListener.calledOnce);
+    });
+
+    test('AVRCP.NEXT_PRESS', function() {
+      var nextListener = this.sinon.spy(function(event) {
+        var command = event.detail.command;
+        assert.equal(command, REMOTE_CONTROLS.NEXT);
+        mrc.removeCommandListener(REMOTE_CONTROLS.NEXT, nextListener);
+        assert.equal(mrc._commandListeners[REMOTE_CONTROLS.NEXT].length, 0);
+      });
+      mrc.addCommandListener(REMOTE_CONTROLS.NEXT, nextListener);
+      mrc._commandHandler(AVRCP.NEXT_PRESS);
+      assert.ok(nextListener.calledOnce);
+    });
+
+    test('AVRCP.PREVIOUS_PRESS', function() {
+      var previousListener = this.sinon.spy(function(event) {
+        var command = event.detail.command;
+        assert.equal(command, REMOTE_CONTROLS.PREVIOUS);
+        mrc.removeCommandListener(REMOTE_CONTROLS.PREVIOUS, previousListener);
+        assert.equal(mrc._commandListeners[REMOTE_CONTROLS.PREVIOUS].length, 0);
+      });
+      mrc.addCommandListener(REMOTE_CONTROLS.PREVIOUS, previousListener);
+      mrc._commandHandler(AVRCP.PREVIOUS_PRESS);
+      assert.ok(previousListener.calledOnce);
+    });
+
+    test('AVRCP.FAST_FORWARD_PRESS', function() {
+      var seekpressListener = this.sinon.spy(function(event) {
+        var command = event.detail.command;
+        var direction = event.detail.direction;
+        assert.equal(command, REMOTE_CONTROLS.SEEK_PRESS);
+        assert.strictEqual(direction, 1);
+        mrc.removeCommandListener(
+          REMOTE_CONTROLS.SEEK_PRESS, seekpressListener
+        );
+        assert.equal(
+          mrc._commandListeners[REMOTE_CONTROLS.SEEK_PRESS].length, 0
+        );
+      });
+      mrc.addCommandListener(REMOTE_CONTROLS.SEEK_PRESS, seekpressListener);
+      mrc._commandHandler(AVRCP.FAST_FORWARD_PRESS);
+      assert.ok(seekpressListener.calledOnce);
+    });
+
+    test('AVRCP.REWIND_PRESS', function() {
+      var seekpressListener = this.sinon.spy(function(event) {
+        var command = event.detail.command;
+        var direction = event.detail.direction;
+        assert.equal(command, REMOTE_CONTROLS.SEEK_PRESS);
+        assert.strictEqual(direction, -1);
+        mrc.removeCommandListener(
+          REMOTE_CONTROLS.SEEK_PRESS, seekpressListener
+        );
+        assert.equal(
+          mrc._commandListeners[REMOTE_CONTROLS.SEEK_PRESS].length, 0
+        );
+      });
+      mrc.addCommandListener(REMOTE_CONTROLS.SEEK_PRESS, seekpressListener);
+      mrc._commandHandler(AVRCP.REWIND_PRESS);
+      assert.ok(seekpressListener.calledOnce);
+    });
+
+    test('AVRCP.FAST_FORWARD_RELEASE', function() {
+      var seekreleaseListener = this.sinon.spy(function(event) {
+        var command = event.detail.command;
+        assert.equal(command, REMOTE_CONTROLS.SEEK_RELEASE);
+        mrc.removeCommandListener(
+          REMOTE_CONTROLS.SEEK_RELEASE, seekreleaseListener
+        );
+        assert.equal(
+          mrc._commandListeners[REMOTE_CONTROLS.SEEK_RELEASE].length, 0
+        );
+      });
+      mrc.addCommandListener(REMOTE_CONTROLS.SEEK_RELEASE, seekreleaseListener);
+      mrc._commandHandler(AVRCP.FAST_FORWARD_RELEASE);
+      assert.ok(seekreleaseListener.calledOnce);
+    });
+
+    test('AVRCP.REWIND_RELEASE', function() {
+      var seekreleaseListener = this.sinon.spy(function(event) {
+        var command = event.detail.command;
+        assert.equal(command, REMOTE_CONTROLS.SEEK_RELEASE);
+        mrc.removeCommandListener(
+          REMOTE_CONTROLS.SEEK_RELEASE, seekreleaseListener
+        );
+        assert.equal(
+          mrc._commandListeners[REMOTE_CONTROLS.SEEK_RELEASE].length, 0
+        );
+      });
+      mrc.addCommandListener(REMOTE_CONTROLS.SEEK_RELEASE, seekreleaseListener);
+      mrc._commandHandler(AVRCP.REWIND_RELEASE);
+      assert.ok(seekreleaseListener.calledOnce);
+    });
+  });
+
+  suite('AVRCP commands(SCO is enabled)', function() {
+    setup(function() {
+      mrc._isSCOConnected = true;
+    });
+
+    test('AVRCP.PLAY_PRESS', function() {
+      var playListener = this.sinon.spy(function(event) {
+        var command = event.detail.command;
+        assert.equal(command, REMOTE_CONTROLS.PLAY);
+        var isSCOConnected = event.detail.isSCOConnected;
+        assert.equal(isSCOConnected, true);
+        mrc.removeCommandListener(REMOTE_CONTROLS.PLAY, playListener);
+        assert.equal(mrc._commandListeners[REMOTE_CONTROLS.PLAY].length, 0);
+      });
+      mrc.addCommandListener(REMOTE_CONTROLS.PLAY, playListener);
+      mrc._commandHandler(AVRCP.PLAY_PRESS);
+      assert.ok(playListener.calledOnce);
+    });
+
+    test('AVRCP.PLAY_PAUSE_PRESS', function() {
+      var playpauseListener = this.sinon.spy(function(event) {
+        var command = event.detail.command;
+        assert.equal(command, REMOTE_CONTROLS.PLAY_PAUSE);
+        var isSCOConnected = event.detail.isSCOConnected;
+        assert.equal(isSCOConnected, true);
+        mrc.removeCommandListener(
+          REMOTE_CONTROLS.PLAY_PAUSE, playpauseListener
+        );
+        assert.equal(
+          mrc._commandListeners[REMOTE_CONTROLS.PLAY_PAUSE].length, 0
+        );
+      });
+      mrc.addCommandListener(REMOTE_CONTROLS.PLAY_PAUSE, playpauseListener);
+      mrc._commandHandler(AVRCP.PLAY_PAUSE_PRESS);
+      assert.ok(playpauseListener.calledOnce);
+    });
+
+    test('AVRCP.PAUSE_PRESS', function() {
+      var pauseListener = this.sinon.spy(function(event) {
+        var command = event.detail.command;
+        assert.equal(command, REMOTE_CONTROLS.PAUSE);
+        var isSCOConnected = event.detail.isSCOConnected;
+        assert.equal(isSCOConnected, true);
+        mrc.removeCommandListener(REMOTE_CONTROLS.PAUSE, pauseListener);
+        assert.equal(mrc._commandListeners[REMOTE_CONTROLS.PAUSE].length, 0);
+      });
+      mrc.addCommandListener(REMOTE_CONTROLS.PAUSE, pauseListener);
+      mrc._commandHandler(AVRCP.PAUSE_PRESS);
+      assert.ok(pauseListener.calledOnce);
+    });
+  });
+
+  suite('IAC commands', function() {
+    test('IAC.PLAY_PRESS', function() {
+      var playListener = this.sinon.spy(function(event) {
+        var command = event.detail.command;
+        assert.equal(command, REMOTE_CONTROLS.PLAY);
+        var isSCOConnected = event.detail.isSCOConnected;
+        assert.equal(isSCOConnected, false);
+        mrc.removeCommandListener(REMOTE_CONTROLS.PLAY, playListener);
+        assert.equal(mrc._commandListeners[REMOTE_CONTROLS.PLAY].length, 0);
+      });
+      mrc.addCommandListener(REMOTE_CONTROLS.PLAY, playListener);
+      mrc._commandHandler(IAC.PLAY_PRESS);
+      assert.ok(playListener.calledOnce);
+    });
+
+    test('IAC.PLAY_PAUSE_PRESS', function() {
+      var playpauseListener = this.sinon.spy(function(event) {
+        var command = event.detail.command;
+        assert.equal(command, REMOTE_CONTROLS.PLAY_PAUSE);
+        var isSCOConnected = event.detail.isSCOConnected;
+        assert.equal(isSCOConnected, false);
+        mrc.removeCommandListener(
+          REMOTE_CONTROLS.PLAY_PAUSE, playpauseListener
+        );
+        assert.equal(
+          mrc._commandListeners[REMOTE_CONTROLS.PLAY_PAUSE].length, 0
+        );
+      });
+      mrc.addCommandListener(REMOTE_CONTROLS.PLAY_PAUSE, playpauseListener);
+      mrc._commandHandler(IAC.PLAY_PAUSE_PRESS);
+      assert.ok(playpauseListener.calledOnce);
+    });
+
+    test('IAC.PAUSE_PRESS', function() {
+      var pauseListener = this.sinon.spy(function(event) {
+        var command = event.detail.command;
+        assert.equal(command, REMOTE_CONTROLS.PAUSE);
+        var isSCOConnected = event.detail.isSCOConnected;
+        assert.equal(isSCOConnected, false);
+        mrc.removeCommandListener(REMOTE_CONTROLS.PAUSE, pauseListener);
+        assert.equal(mrc._commandListeners[REMOTE_CONTROLS.PAUSE].length, 0);
+      });
+      mrc.addCommandListener(REMOTE_CONTROLS.PAUSE, pauseListener);
+      mrc._commandHandler(IAC.PAUSE_PRESS);
+      assert.ok(pauseListener.calledOnce);
+    });
+
+    test('IAC.STOP_PRESS', function() {
+      var stopListener = this.sinon.spy(function(event) {
+        var command = event.detail.command;
+        assert.equal(command, REMOTE_CONTROLS.STOP);
+        mrc.removeCommandListener(REMOTE_CONTROLS.STOP, stopListener);
+        assert.equal(mrc._commandListeners[REMOTE_CONTROLS.STOP].length, 0);
+      });
+      mrc.addCommandListener(REMOTE_CONTROLS.STOP, stopListener);
+      mrc._commandHandler(IAC.STOP_PRESS);
+      assert.ok(stopListener.calledOnce);
+    });
+
+    test('IAC.NEXT_PRESS', function() {
+      var nextListener = this.sinon.spy(function(event) {
+        var command = event.detail.command;
+        assert.equal(command, REMOTE_CONTROLS.NEXT);
+        mrc.removeCommandListener(REMOTE_CONTROLS.NEXT, nextListener);
+        assert.equal(mrc._commandListeners[REMOTE_CONTROLS.NEXT].length, 0);
+      });
+      mrc.addCommandListener(REMOTE_CONTROLS.NEXT, nextListener);
+      mrc._commandHandler(IAC.NEXT_PRESS);
+      assert.ok(nextListener.calledOnce);
+    });
+
+    test('IAC.PREVIOUS_PRESS', function() {
+      var previousListener = this.sinon.spy(function(event) {
+        var command = event.detail.command;
+        assert.equal(command, REMOTE_CONTROLS.PREVIOUS);
+        mrc.removeCommandListener(REMOTE_CONTROLS.PREVIOUS, previousListener);
+        assert.equal(mrc._commandListeners[REMOTE_CONTROLS.PREVIOUS].length, 0);
+      });
+      mrc.addCommandListener(REMOTE_CONTROLS.PREVIOUS, previousListener);
+      mrc._commandHandler(IAC.PREVIOUS_PRESS);
+      assert.ok(previousListener.calledOnce);
+    });
+
+    test('IAC.FAST_FORWARD_PRESS', function() {
+      var seekpressListener = this.sinon.spy(function(event) {
+        var command = event.detail.command;
+        var direction = event.detail.direction;
+        assert.equal(command, REMOTE_CONTROLS.SEEK_PRESS);
+        assert.strictEqual(direction, 1);
+        mrc.removeCommandListener(
+          REMOTE_CONTROLS.SEEK_PRESS, seekpressListener
+        );
+        assert.equal(
+          mrc._commandListeners[REMOTE_CONTROLS.SEEK_PRESS].length, 0
+        );
+      });
+      mrc.addCommandListener(REMOTE_CONTROLS.SEEK_PRESS, seekpressListener);
+      mrc._commandHandler(IAC.FAST_FORWARD_PRESS);
+      assert.ok(seekpressListener.calledOnce);
+    });
+
+    test('IAC.REWIND_PRESS', function() {
+      var seekpressListener = this.sinon.spy(function(event) {
+        var command = event.detail.command;
+        var direction = event.detail.direction;
+        assert.equal(command, REMOTE_CONTROLS.SEEK_PRESS);
+        assert.strictEqual(direction, -1);
+        mrc.removeCommandListener(
+          REMOTE_CONTROLS.SEEK_PRESS, seekpressListener
+        );
+        assert.equal(
+          mrc._commandListeners[REMOTE_CONTROLS.SEEK_PRESS].length, 0
+        );
+      });
+      mrc.addCommandListener(REMOTE_CONTROLS.SEEK_PRESS, seekpressListener);
+      mrc._commandHandler(IAC.REWIND_PRESS);
+      assert.ok(seekpressListener.calledOnce);
+    });
+
+    test('IAC.FAST_FORWARD_RELEASE', function() {
+      var seekreleaseListener = this.sinon.spy(function(event) {
+        var command = event.detail.command;
+        assert.equal(command, REMOTE_CONTROLS.SEEK_RELEASE);
+        mrc.removeCommandListener(
+          REMOTE_CONTROLS.SEEK_RELEASE, seekreleaseListener
+        );
+        assert.equal(
+          mrc._commandListeners[REMOTE_CONTROLS.SEEK_RELEASE].length, 0
+        );
+      });
+      mrc.addCommandListener(REMOTE_CONTROLS.SEEK_RELEASE, seekreleaseListener);
+      mrc._commandHandler(IAC.FAST_FORWARD_RELEASE);
+      assert.ok(seekreleaseListener.calledOnce);
+    });
+
+    test('IAC.REWIND_RELEASE', function() {
+      var seekreleaseListener = this.sinon.spy(function(event) {
+        var command = event.detail.command;
+        assert.equal(command, REMOTE_CONTROLS.SEEK_RELEASE);
+        mrc.removeCommandListener(
+          REMOTE_CONTROLS.SEEK_RELEASE, seekreleaseListener
+        );
+        assert.equal(
+          mrc._commandListeners[REMOTE_CONTROLS.SEEK_RELEASE].length, 0
+        );
+      });
+      mrc.addCommandListener(REMOTE_CONTROLS.SEEK_RELEASE, seekreleaseListener);
+      mrc._commandHandler(IAC.REWIND_RELEASE);
+      assert.ok(seekreleaseListener.calledOnce);
+    });
+  });
+
+  suite('IAC commands(SCO is enabled)', function() {
+    setup(function() {
+      mrc._isSCOConnected = true;
+    });
+
+    test('IAC.PLAY_PRESS', function() {
+      var playListener = this.sinon.spy(function(event) {
+        var command = event.detail.command;
+        assert.equal(command, REMOTE_CONTROLS.PLAY);
+        var isSCOConnected = event.detail.isSCOConnected;
+        assert.equal(isSCOConnected, true);
+        mrc.removeCommandListener(REMOTE_CONTROLS.PLAY, playListener);
+        assert.equal(mrc._commandListeners[REMOTE_CONTROLS.PLAY].length, 0);
+      });
+      mrc.addCommandListener(REMOTE_CONTROLS.PLAY, playListener);
+      mrc._commandHandler(IAC.PLAY_PRESS);
+      assert.ok(playListener.calledOnce);
+    });
+
+    test('IAC.PLAY_PAUSE_PRESS', function() {
+      var playpauseListener = this.sinon.spy(function(event) {
+        var command = event.detail.command;
+        assert.equal(command, REMOTE_CONTROLS.PLAY_PAUSE);
+        var isSCOConnected = event.detail.isSCOConnected;
+        assert.equal(isSCOConnected, true);
+        mrc.removeCommandListener(
+          REMOTE_CONTROLS.PLAY_PAUSE, playpauseListener
+        );
+        assert.equal(
+          mrc._commandListeners[REMOTE_CONTROLS.PLAY_PAUSE].length, 0
+        );
+      });
+      mrc.addCommandListener(REMOTE_CONTROLS.PLAY_PAUSE, playpauseListener);
+      mrc._commandHandler(IAC.PLAY_PAUSE_PRESS);
+      assert.ok(playpauseListener.calledOnce);
+    });
+
+    test('IAC.PAUSE_PRESS', function() {
+      var pauseListener = this.sinon.spy(function(event) {
+        var command = event.detail.command;
+        assert.equal(command, REMOTE_CONTROLS.PAUSE);
+        var isSCOConnected = event.detail.isSCOConnected;
+        assert.equal(isSCOConnected, true);
+        mrc.removeCommandListener(REMOTE_CONTROLS.PAUSE, pauseListener);
+        assert.equal(mrc._commandListeners[REMOTE_CONTROLS.PAUSE].length, 0);
+      });
+      mrc.addCommandListener(REMOTE_CONTROLS.PAUSE, pauseListener);
+      mrc._commandHandler(IAC.PAUSE_PRESS);
+      assert.ok(pauseListener.calledOnce);
+    });
+  });
+
+  suite('UPDATE commands', function() {
+    test('REMOTE_CONTROLS.UPDATE_METADATA', function() {
+      var updatemetadataListener = this.sinon.spy(function(event) {
+        var command = event.detail.command;
+        assert.equal(command, REMOTE_CONTROLS.UPDATE_METADATA);
+        mrc.removeCommandListener(
+          REMOTE_CONTROLS.UPDATE_METADATA, updatemetadataListener
+        );
+        assert.equal(
+          mrc._commandListeners[REMOTE_CONTROLS.UPDATE_METADATA].length, 0
+        );
+      });
+      mrc.addCommandListener(
+        REMOTE_CONTROLS.UPDATE_METADATA, updatemetadataListener
+      );
+      mrc._commandHandler(REMOTE_CONTROLS.UPDATE_METADATA);
+      assert.ok(updatemetadataListener.calledOnce);
+    });
+
+    test('REMOTE_CONTROLS.UPDATE_PLAYSTATUS', function() {
+      var updateplaystatusListener = this.sinon.spy(function(event) {
+        var command = event.detail.command;
+        assert.equal(command, REMOTE_CONTROLS.UPDATE_PLAYSTATUS);
+        mrc.removeCommandListener(
+          REMOTE_CONTROLS.UPDATE_PLAYSTATUS, updateplaystatusListener
+        );
+        assert.equal(
+          mrc._commandListeners[REMOTE_CONTROLS.UPDATE_PLAYSTATUS].length, 0
+        );
+      });
+      mrc.addCommandListener(
+        REMOTE_CONTROLS.UPDATE_PLAYSTATUS, updateplaystatusListener
+      );
+      mrc._commandHandler(REMOTE_CONTROLS.UPDATE_PLAYSTATUS);
+      assert.ok(updateplaystatusListener.calledOnce);
+    });
+  });
+
+  suite('Setup Bluetooth', function() {
+    test('_bluetoothHelper is ready', function() {
+      mrc._setupBluetooth();
+
+      assert.equal(mrc._bluetoothHelper, MockBluetoothHelperInstance);
+    });
+  });
+
+  suite('Bluetooth commands', function() {
+    setup(function() {
+      mrc._bluetoothHelper = new MockBluetoothHelper();
+    });
+
+    test('notifyMetadataChanged', function() {
+      this.sinon.spy(MockBluetoothHelperInstance, 'sendMediaMetaData');
+      this.sinon.spy(mrc, '_postMessage');
+      var metadata = this.sinon.stub();
+      mrc.notifyMetadataChanged(metadata);
+
+      assert.ok(MockBluetoothHelperInstance.sendMediaMetaData
+        .calledWith(metadata));
+      assert.ok(mrc._postMessage.called);
+    });
+
+    test('notifyStatusChanged', function() {
+      this.sinon.spy(MockBluetoothHelperInstance, 'sendMediaPlayStatus');
+      this.sinon.spy(mrc, '_postMessage');
+      var status = 'good';
+      mrc.notifyStatusChanged(status);
+
+      assert.ok(MockBluetoothHelperInstance.sendMediaPlayStatus
+        .calledWith(status));
+      assert.ok(mrc._postMessage.called);
+    });
+
+    test('notifyStatusChanged not called when status is mozinterruptbegin',
+      function() {
+      this.sinon.spy(MockBluetoothHelperInstance, 'sendMediaPlayStatus');
+      this.sinon.spy(mrc, '_postMessage');
+      var status = 'mozinterruptbegin';
+      mrc.notifyStatusChanged(status);
+
+      assert.ok(!MockBluetoothHelperInstance.sendMediaPlayStatus.called);
+      assert.ok(!mrc._postMessage.called);
+    });
+  });
+});

gaia/dev_apps/music-oga/test/unit/setup.js

@@ -0,0 +1,3 @@
+'use strict';
+
+require('/shared/test/unit/mocks/mocks_helper.js');

gaia/dev_apps/music-oga/test/unit/tabbar_test.js

@@ -0,0 +1,94 @@
+/* global TabBar, Sanitizer, MocksHelper */
+/* exported ListView, TilesView */
+'use strict';
+
+require('/shared/js/sanitizer.js');
+
+require('/shared/js/accessibility_helper.js');
+require('/js/ui/tab_bar.js');
+
+require('/test/unit/ui/views/mock_modemanager.js');
+require('/test/unit/ui/views/mock_list_view.js');
+require('/test/unit/ui/views/mock_tiles_view.js');
+
+var mocksForTabBarHelper = new MocksHelper([
+  'ListView',
+  'TilesView',
+  'ModeManager'
+]).init();
+
+suite('TabBar', function() {
+
+  mocksForTabBarHelper.attachTestHelpers();
+
+  suiteSetup(function() {
+    this.element = document.createElement('div');
+    this.element.setAttribute('id', 'tabs');
+    this.element.innerHTML = Sanitizer.unwrapSafeHTML(
+      Sanitizer.createSafeHTML(
+      `<ul role="tablist" class="bb-tablist skin-dark">
+        <li id="mix" role="presentation">
+          <a id="tabs-mix" data-option="mix" role="tab"
+      aria-selected="false" aria-controls="views-tiles"></a>
+        </li>
+        <li id="playlists" role="presentation">
+          <a id="tabs-playlists" data-option="playlist" role="tab"
+      aria-selected="false" aria-controls="views-list"></a>
+        </li>
+        <li id="artists" role="presentation">
+          <a id="tabs-artists" data-option="artist" role="tab"
+      aria-selected="false" aria-controls="views-list"></a>
+        </li>
+        <li id="albums" role="presentation">
+          <a id="tabs-albums" data-option="album" role="tab"
+      aria-selected="false" aria-controls="views-list"></a>
+        </li>
+        <li id="songs" role="presentation">
+          <a id="tabs-songs" data-option="title" role="tab"
+      aria-selected="false" aria-controls="views-list"></a>
+        </li>
+      </ul>`
+      ));
+    document.body.appendChild(this.element);
+    this.links = this.element.querySelectorAll('a');
+    this.tabs = TabBar;
+    this.tabs.init();
+  });
+
+  suiteTeardown(function() {
+    document.body.removeChild(this.element);
+    this.element = null;
+    this.links = null;
+  });
+
+  // send a fake touchend event to el
+  function sendTouch(el) {
+    var touchendEvent = document.createEvent('TouchEvent');
+    touchendEvent.initTouchEvent('touchend', true, true, window,
+                                 0, false, false, false, false,
+                                 null, null, null);
+    el.dispatchEvent(touchendEvent);
+  }
+
+  // This are hardcoded based on tab_bar.js
+  var tabOptions = ['mix', 'playlist', 'artist', 'album', 'title'];
+
+  [0, 1, 2, 3, 4].forEach(function(index) {
+    var ariaStates = ['false', 'false', 'false', 'false', 'false'];
+    ariaStates[index] = 'true';
+
+    suite('test click link ' + (index + 1), function() {
+      setup(function() {
+        sendTouch(this.links[index]);
+      });
+      test('test aria-selected set', function() {
+        assert.equal(TabBar.option, tabOptions[index]);
+        ariaStates.forEach(function(value, index) {
+          assert.equal(this.links[index].getAttribute('aria-selected'), value);
+        }, this);
+      });
+    });
+
+  });
+
+});

gaia/dev_apps/music-oga/test/unit/titlebar_test.js

@@ -0,0 +1,76 @@
+/* global App, TitleBar, Sanitizer, MocksHelper, ModeManager, LazyLoader */
+'use strict';
+
+require('/shared/js/sanitizer.js');
+
+require('/shared/js/accessibility_helper.js');
+require('/js/ui/title_bar.js');
+
+require('/test/unit/mock_music.js');
+require('/test/unit/ui/views/mock_modemanager.js');
+require('/test/unit/ui/views/mock_player_view.js');
+require('/test/unit/metadata/mock_album_art_cache.js');
+require('/test/unit/mock_lazy_loader.js');
+
+var mocksForTitleBarHelper = new MocksHelper([
+  'App',
+  'LazyLoader',
+  'AlbumArtCache',
+  'ModeManager',
+  'PlayerView'
+]).init();
+
+suite('TitleBar', function() {
+
+  mocksForTitleBarHelper.attachTestHelpers();
+
+  suiteSetup(function() {
+
+    this.element = document.createElement('div');
+    this.element.setAttribute('id', 'title');
+    this.element.setAttribute('action', 'back');
+    this.element.setAttribute('no-font-fit', null);
+    this.element.innerHTML = Sanitizer.unwrapSafeHTML(
+      Sanitizer.createSafeHTML(
+        `<h1 id="title-text"><bdi data-l10n-id="music"></bdi></h1>
+          <button id="title-player" data-icon="play-circle"
+          data-l10n-id="go-to-player-view"></button>
+          <button id="title-done" data-l10n-id="done">Done</button>`
+      ));
+    document.body.appendChild(this.element);
+    this.titleBar = TitleBar;
+    this.titleBar.init();
+  });
+
+  suiteTeardown(function() {
+    document.body.removeChild(this.element);
+    this.element = null;
+  });
+
+  suite('test player icon', function() {
+    var spy;
+
+    setup(function() {
+      spy = this.sinon.spy(ModeManager, 'push');
+      var titlePlayer = document.getElementById('title-player');
+      titlePlayer.click();
+    });
+    test('test modemanager push called', function() {
+      assert.ok(spy.called);
+    }, this);
+  });
+
+  suite('test done button', function() {
+    var spy;
+
+    setup(function() {
+      App.pendingPick = { postResult: function() {} };
+      spy = this.sinon.spy(LazyLoader, 'load');
+      var titleDone = document.getElementById('title-done');
+      titleDone.click();
+    });
+    test('test album art fetching triggered', function() {
+      assert.ok(spy.called);
+    });
+  });
+});

gaia/dev_apps/music-oga/test/unit/ui/mock_tab_bar.js

@@ -0,0 +1,18 @@
+/* exported MockTabBar */
+'use strict';
+
+var MockTabBar = {
+  init: function() {},
+
+  playlistArray: {
+    indexOf: function() {
+      return -1;
+    }
+  },
+
+  view: {
+    classList: {
+      toggle: function() {}
+    }
+  }
+};

gaia/dev_apps/music-oga/test/unit/ui/mock_title_bar.js

@@ -0,0 +1,18 @@
+/* exported MockTitleBar */
+'use strict';
+
+var MockTitleBar = {
+  init: function() {},
+
+  view: function() {
+    return document.getElementById('title');
+  },
+
+  playerIcon: function() {
+    return document.getElementById('title-player');
+  },
+
+  showBackArrow: function() {},
+
+  changeTitleText: function() {}
+};

gaia/dev_apps/music-oga/test/unit/ui/views/list_view_test.js

@@ -0,0 +1,130 @@
+/* global ListView, Sanitizer, MocksHelper, ModeManager, FocusEvent,
+   MODE_LIST */
+'use strict';
+
+require('/shared/js/sanitizer.js');
+
+require('/js/utils.js');
+require('/js/ui/views/list_view.js');
+
+require('/test/unit/mock_db.js');
+require('/test/unit/mock_music.js');
+require('/test/unit/metadata/mock_album_art_cache.js');
+require('/test/unit/ui/views/mock_modemanager.js');
+require('/test/unit/ui/views/mock_subList_view.js');
+require('/test/unit/mock_lazy_loader.js');
+
+var mocksForListViewHelper = new MocksHelper([
+  'LazyLoader',
+  'AlbumArtCache',
+  'ModeManager',
+  'SubListView',
+  'App',
+  'Database'
+]).init();
+
+suite('ListView test', function() {
+
+  mocksForListViewHelper.attachTestHelpers();
+
+  suiteSetup(function() {
+
+    ModeManager._view = ListView;
+
+    this.element = document.createElement('div');
+    this.element.id = 'views-list';
+    document.body.appendChild(this.element);
+    this.element.innerHTML = Sanitizer.unwrapSafeHTML(
+      Sanitizer.createSafeHTML(
+        `<form id="views-list-search" role="search" class="skin-dark">
+          <button id="views-list-search-close" data-l10n-id="search-close"
+        type="submit">close</button>
+          <p>
+          <input id="views-list-search-input" type="search"
+        x-inputmode="verbatim"
+        data-l10n-id="search-music" placeholder="SearcH MusiC">
+          <button id="views-list-search-clear" type="reset">Clear</button>
+          </p>
+          </form>
+          <div id="views-list-anchor" role="listbox"></div>`
+      ));
+
+    this.listView = ListView;
+
+    this.listView.init();
+
+    this.listView.activate( {
+      key: 'metadata.album',
+      range: null,
+      direction: 'nextunique',
+      option: 'album'
+    });
+  });
+
+  suiteTeardown(function() {
+    document.body.removeChild(this.element);
+    this.element = null;
+  });
+
+  suite('activate', function() {
+
+    test('content', function() {
+      // Mock data has 4 albums, with 3 different letters. So, 7 list items
+      var children = this.listView.anchor.children;
+      var count = children.length;
+      assert.equal(count, 7);
+
+      children = this.listView.anchor.querySelectorAll('.list-item');
+      count = children.length;
+      assert.equal(count, 4);
+
+      var first = this.listView.anchor.firstChild;
+      assert.equal(first.tagName, 'LI');
+      assert.ok(first.classList.contains('list-header'));
+      assert.equal(first.getAttribute('role'), 'heading');
+      assert.equal(first.textContent, 'C');
+
+      first = this.listView.anchor.querySelector('.list-item');
+      assert.equal(first.tagName, 'LI');
+      assert.equal(first.getAttribute('role'), 'presentation');
+      assert.equal(first.textContent, 'Crime of the CenturySupertramp');
+
+      var second = children[1];
+      assert.equal(second.tagName, 'LI');
+      assert.equal(first.getAttribute('role'), 'presentation');
+      assert.equal(second.textContent, 'Crisis? What Crisis?Supertramp');
+    });
+  });
+
+  suite('events', function() {
+    var spy;
+
+    test('click tile', function() {
+      spy = this.sinon.spy(ListView, 'activateSubListView');
+      var listItem = document.querySelector('.list-item > [role="option"]');
+      assert.ok(listItem);
+      listItem.click();
+      assert.ok(spy.called,
+                'ListView.activateSubListView() should have been called');
+    });
+
+    test('click search close', function() {
+      spy = this.sinon.spy(ListView, 'hideSearch');
+
+      document.getElementById('views-list-search-close').click();
+      assert.ok(spy.called, 'ListView.hideSearch() should have been called');
+    });
+
+    test('focus on search', function() {
+      // make sure this return the right value
+      this.sinon.stub(ModeManager, 'currentMode', () => MODE_LIST );
+      var spy = this.sinon.spy(ModeManager, 'start');
+      var input = document.getElementById('views-list-search-input');
+      input.dispatchEvent(new FocusEvent('focus'));
+
+      assert.ok(spy.called, 'ModeManager.start() should have been called');
+    });
+  });
+
+});
+

gaia/dev_apps/music-oga/test/unit/ui/views/mock_list_view.js

@@ -0,0 +1,9 @@
+/* exported MockListView */
+'use strict';
+
+var MockListView = {
+  init: function() {},
+  activate: function() {},
+  cancelEnumeration: function () {},
+  update: function() {}
+};

gaia/dev_apps/music-oga/test/unit/ui/views/mock_modemanager.js

@@ -0,0 +1,31 @@
+/* exported MockModeManager, MODE_LIST, MODE_SUBLIST, MODE_TILES, MODE_PLAYER,
+   MODE_PICKER, MODE_SEARCH_FROM_TILES, MODE_SEARCH_FROM_LIST,
+   SETTINGS_OPTION_KEY */
+'use strict';
+
+var MODE_LIST = 0;
+var MODE_TILES = 1;
+var MODE_PLAYER = 2;
+var MODE_SUBLIST = 3;
+var MODE_SEARCH_FROM_TILES = 5;
+var MODE_SEARCH_FROM_LIST = 6;
+var MODE_PICKER = 7;
+
+var SETTINGS_OPTION_KEY = 'settings_option_key';
+
+var MockModeManager = {
+
+  _view: null,
+
+  get currentMode() {
+    return 0;
+  },
+  start: function() {},
+  push: function() {},
+  waitForView: function(mode, callback) {
+    assert.ok(this._view, 'You didn\'t set MockModeManager._view');
+    callback(this._view);
+  }
+};
+
+

gaia/dev_apps/music-oga/test/unit/ui/views/mock_player_view.js

@@ -0,0 +1,11 @@
+/* exported MockPlayerView */
+'use strict';
+
+var MockPlayerView = {
+  get isQueued() { return true; },
+  currentFileInfo: { metadata: {} },
+  playingBlob: { type: null },
+
+  init: function() {},
+  stop: function() {},
+};

gaia/dev_apps/music-oga/test/unit/ui/views/mock_search_view.js

@@ -0,0 +1,6 @@
+/* exported MockSearchView */
+'use strict';
+
+var MockSearchView = {
+  init: function() {}
+};

gaia/dev_apps/music-oga/test/unit/ui/views/mock_subList_view.js

@@ -0,0 +1,10 @@
+/* exported MockSubListView */
+'use strict';
+
+var MockSubListView = {
+  init: function() {},
+
+  activate: function(option, data, index, keyRange, direction, callback) {
+    callback();
+  }
+};

gaia/dev_apps/music-oga/test/unit/ui/views/mock_tiles_view.js

@@ -0,0 +1,7 @@
+/* exported MockTilesView */
+'use strict';
+
+var MockTilesView = {
+  init: function() {},
+  hideSearch: function() {}
+};

gaia/dev_apps/music-oga/test/unit/ui/views/mode_manager_test.js

@@ -0,0 +1,300 @@
+/* global MockL10n, ModeManager, MocksHelper, loadBodyHTML,
+          MODE_TILES, MODE_LIST, MODE_SUBLIST, MODE_PLAYER,
+          MODE_SEARCH_FROM_TILES, MODE_SEARCH_FROM_LIST, MODE_PICKER,
+          TilesView, ListView, SubListView, PlayerView, SearchView */
+'use strict';
+
+require('/shared/test/unit/mocks/mock_l10n.js');
+require('/shared/test/unit/mocks/mock_async_storage.js');
+require('/shared/test/unit/load_body_html_helper.js');
+require('/test/unit/mock_lazy_loader.js');
+require('/test/unit/mock_music.js');
+require('/test/unit/ui/mock_title_bar.js');
+require('/test/unit/ui/mock_tab_bar.js');
+require('/test/unit/ui/views/mock_tiles_view.js');
+require('/test/unit/ui/views/mock_list_view.js');
+require('/test/unit/ui/views/mock_subList_view.js');
+require('/test/unit/ui/views/mock_player_view.js');
+require('/test/unit/ui/views/mock_search_view.js');
+require('/js/ui/views/mode_manager.js');
+
+var mocksForModeManagerHelper = new MocksHelper([
+  'LazyLoader',
+  'asyncStorage',
+  'App',
+  'TitleBar',
+  'TabBar',
+  'TilesView',
+  'ListView',
+  'SubListView',
+  'PlayerView',
+  'SearchView'
+]).init();
+
+suite('Mode Manager Test', function() {
+  var realL10n;
+  var mm;
+
+  mocksForModeManagerHelper.attachTestHelpers();
+
+  suiteSetup(function() {
+    realL10n = navigator.mozL10n;
+    navigator.mozL10n = MockL10n;
+
+    loadBodyHTML('/index.html');
+
+    mm = ModeManager;
+  });
+
+  suiteTeardown(function() {
+    navigator.mozL10n = realL10n;
+  });
+
+  suite('Start some views', function() {
+    test('Start TILES', function() {
+      mm.start(MODE_TILES, function() {
+        assert.equal(mm.currentMode, MODE_TILES);
+      });
+    });
+
+    test('Start LIST', function() {
+      mm.start(MODE_LIST, function() {
+        assert.equal(mm.currentMode, MODE_LIST);
+      });
+    });
+
+    test('Start PICKER', function() {
+      mm.start(MODE_PICKER, function() {
+        assert.equal(mm.currentMode, MODE_PICKER);
+      });
+    });
+
+    test('Start SEARCH(From Tiles)', function() {
+      mm.start(MODE_SEARCH_FROM_TILES, function() {
+        assert.equal(mm.currentMode, MODE_SEARCH_FROM_TILES);
+      });
+    });
+
+    test('Start SEARCH(From List)', function() {
+      mm.start(MODE_SEARCH_FROM_LIST, function() {
+        assert.equal(mm.currentMode, MODE_SEARCH_FROM_LIST);
+      });
+    });
+  });
+
+  suite('Start then push some views', function() {
+    test('TILES > PLAYER', function() {
+      mm.start(MODE_TILES, function() {
+        mm.push(MODE_PLAYER, function() {
+          assert.equal(mm.currentMode, MODE_PLAYER);
+        });
+      });
+    });
+
+    test('LIST > SUBLIST', function() {
+      mm.start(MODE_LIST, function() {
+        mm.push(MODE_SUBLIST, function() {
+          assert.equal(mm.currentMode, MODE_SUBLIST);
+        });
+      });
+    });
+
+    test('LIST > PLAYER', function() {
+      mm.start(MODE_LIST, function() {
+        mm.push(MODE_PLAYER, function() {
+          assert.equal(mm.currentMode, MODE_PLAYER);
+        });
+      });
+    });
+
+    test('PICKER > PLAYER', function() {
+      mm.start(MODE_PICKER, function() {
+        mm.push(MODE_PLAYER, function() {
+          assert.equal(mm.currentMode, MODE_PLAYER);
+        });
+      });
+    });
+
+    test('SEARCH(From Tiles) > PLAYER', function() {
+      mm.start(MODE_SEARCH_FROM_TILES, function() {
+        mm.push(MODE_PLAYER, function() {
+          assert.equal(mm.currentMode, MODE_PLAYER);
+        });
+      });
+    });
+
+    test('SEARCH(From List) > PLAYER', function() {
+      mm.start(MODE_SEARCH_FROM_LIST, function() {
+        mm.push(MODE_PLAYER, function() {
+          assert.equal(mm.currentMode, MODE_PLAYER);
+        });
+      });
+    });
+
+    test('LIST > SUBLIST > PLAYER', function() {
+      mm.start(MODE_LIST, function() {
+        mm.push(MODE_SUBLIST, function() {
+          mm.push(MODE_PLAYER, function() {
+            assert.equal(mm.currentMode, MODE_PLAYER);
+          });
+        });
+      });
+    });
+
+    test('SEARCH(From Tiles) > SUBLIST > PLAYER', function() {
+      mm.start(MODE_SEARCH_FROM_TILES, function() {
+        mm.push(MODE_SUBLIST, function() {
+          mm.push(MODE_PLAYER, function() {
+            assert.equal(mm.currentMode, MODE_PLAYER);
+          });
+        });
+      });
+    });
+
+    test('SEARCH(From List) > SUBLIST > PLAYER', function() {
+      mm.start(MODE_SEARCH_FROM_LIST, function() {
+        mm.push(MODE_SUBLIST, function() {
+          mm.push(MODE_PLAYER, function() {
+            assert.equal(mm.currentMode, MODE_PLAYER);
+          });
+        });
+      });
+    });
+  });
+
+  suite('Start then pop some views', function() {
+    test('TILES > PLAYER > TILES', function() {
+      mm.start(MODE_TILES, function() {
+        mm.push(MODE_PLAYER, function() {
+          mm.pop();
+          assert.equal(mm.currentMode, MODE_TILES);
+        });
+      });
+    });
+
+    test('LIST > PLAYER > LIST', function() {
+      mm.start(MODE_LIST, function() {
+        mm.push(MODE_PLAYER, function() {
+          mm.pop();
+          assert.equal(mm.currentMode, MODE_LIST);
+        });
+      });
+    });
+
+    test('LIST > SUBLIST > LIST', function() {
+      mm.start(MODE_LIST, function() {
+        mm.push(MODE_SUBLIST, function() {
+          mm.pop();
+          assert.equal(mm.currentMode, MODE_LIST);
+        });
+      });
+    });
+
+    test('PICKER > PLAYER > PICKER', function() {
+      mm.start(MODE_PICKER, function() {
+        mm.push(MODE_PLAYER, function() {
+          mm.pop();
+          assert.equal(mm.currentMode, MODE_PICKER);
+        });
+      });
+    });
+
+    test('LIST > SUBLIST > PLAYER > SUBLIST > LIST', function() {
+      mm.start(MODE_LIST, function() {
+        mm.push(MODE_SUBLIST, function() {
+          mm.push(MODE_PLAYER, function() {
+            mm.pop();
+            mm.pop();
+            assert.equal(mm.currentMode, MODE_LIST);
+          });
+        });
+      });
+    });
+
+    test('SEARCH(Tiles) > SUBLIST > PLAYER > SUBLIST > SEARCH', function() {
+      mm.start(MODE_SEARCH_FROM_TILES, function() {
+        mm.push(MODE_SUBLIST, function() {
+          mm.push(MODE_PLAYER, function() {
+            mm.pop();
+            mm.pop();
+            assert.equal(mm.currentMode, MODE_SEARCH_FROM_TILES);
+          });
+        });
+      });
+    });
+
+    test('SEARCH(List) > SUBLIST > PLAYER > SUBLIST > SEARCH', function() {
+      mm.start(MODE_SEARCH_FROM_LIST, function() {
+        mm.push(MODE_SUBLIST, function() {
+          mm.push(MODE_PLAYER, function() {
+            mm.pop();
+            mm.pop();
+            assert.equal(mm.currentMode, MODE_SEARCH_FROM_LIST);
+          });
+        });
+      });
+    });
+  });
+
+  suite('Initialize some views', function() {
+    setup(function() {
+      for (var mode in mm.views) {
+        mm.views[mode].isLoaded = false;
+      }
+    });
+
+    test('Initialize TILES', function() {
+      var spy = this.sinon.spy(TilesView, 'init');
+
+      mm.waitForView(MODE_TILES, (view) => {
+        assert.ok(spy.calledOnce);
+        assert.equal(view.isLoaded, true);
+      });
+    });
+
+    test('Initialize LIST', function() {
+      var spy = this.sinon.spy(ListView, 'init');
+
+      mm.waitForView(MODE_LIST, (view) => {
+        assert.ok(spy.calledOnce);
+        assert.equal(view.isLoaded, true);
+      });
+    });
+
+    test('Initialize SUBLIST', function() {
+      var spy = this.sinon.spy(SubListView, 'init');
+
+      mm.waitForView(MODE_SUBLIST, (view) => {
+        assert.ok(spy.calledOnce);
+        assert.equal(view.isLoaded, true);
+      });
+    });
+
+    test('Initialize PLAYER', function() {
+      var spy = this.sinon.spy(PlayerView, 'init');
+
+      mm.waitForView(MODE_PLAYER, (view) => {
+        assert.ok(spy.calledOnce);
+        assert.equal(view.isLoaded, true);
+      });
+    });
+
+    test('Initialize SEARCH(Tiles)', function() {
+      var spy = this.sinon.spy(SearchView, 'init');
+
+      mm.waitForView(MODE_SEARCH_FROM_TILES, (view) => {
+        assert.ok(spy.calledOnce);
+        assert.equal(view.isLoaded, true);
+      });
+    });
+
+    test('Initialize SEARCH(List)', function() {
+      var spy = this.sinon.spy(SearchView, 'init');
+
+      mm.waitForView(MODE_SEARCH_FROM_LIST, (view) => {
+        assert.ok(spy.calledOnce);
+        assert.equal(view.isLoaded, true);
+      });
+    });
+  });
+});

gaia/dev_apps/music-oga/test/unit/ui/views/player_view_test.js

@@ -0,0 +1,197 @@
+/* global INTERRUPT_BEGIN, KeyboardEvent, KeyEvent, loadBodyHTML, MockL10n,
+          MocksHelper, PlaybackQueue, PlayerView, PLAYSTATUS_PAUSED,
+          PLAYSTATUS_PLAYING */
+
+'use strict';
+
+require('/js/ui/views/player_view.js');
+require('/js/queue.js');
+require('/shared/test/unit/mocks/mock_l10n.js');
+require('/shared/test/unit/mocks/mock_async_storage.js');
+require('/shared/test/unit/load_body_html_helper.js');
+require('/test/unit/ui/views/mock_modemanager.js');
+
+var mocksForPlayerViewHelper = new MocksHelper([
+  'asyncStorage'
+]).init();
+
+function mockAudioElement() {
+  // we need to replace the audio element
+  var audioNode = document.getElementById('player-audio');
+  var parent = audioNode.parentNode;
+  parent.removeChild(audioNode);
+  audioNode = document.createElement('div');
+  audioNode.id = 'player-audio';
+  audioNode.currentTime = 100;
+  parent.appendChild(audioNode);
+}
+
+suite('Player View Test', function() {
+  var pv, ratings;
+  var realL10n = navigator.mozL10n;
+
+  mocksForPlayerViewHelper.attachTestHelpers();
+
+  function testRatingsAriaChecked(checkedIndex) {
+    pv.setRatings(checkedIndex);
+    Array.prototype.forEach.call(ratings, function(rating, index) {
+      assert.equal(checkedIndex - 1 === index ? 'true' : 'false',
+        rating.getAttribute('aria-checked'));
+    });
+  }
+
+  suiteSetup(function(done) {
+    navigator.mozL10n = MockL10n;
+    //Insert the star-rating bar into the dom
+    loadBodyHTML('/index.html');
+
+    //Initialize the Player View
+    pv = PlayerView;
+
+    //Override #setSeekBar with stub to avoid excess work in init()
+    sinon.stub(pv, 'setSeekBar');
+    PlaybackQueue.loadSettings().then(() => {
+      pv.init();
+      ratings = pv.ratings;
+      done();
+    });
+  });
+
+  suiteTeardown(function() {
+    navigator.mozL10n = realL10n;
+  });
+
+  suite('#setRating accessibility', function() {
+    test('aria-checked="true" when star matches star-rating. false otherwise',
+      function() {
+        [0, 1, 2, 3, 4, 5].forEach(testRatingsAriaChecked);
+      });
+  });
+
+  suite('show info', function() {
+    var spy;
+
+    setup(function() {
+      spy = this.sinon.spy(PlayerView, 'showInfo');
+    });
+
+    test('on player cover', function() {
+      ['player-cover', 'player-cover-image-1',
+       'player-cover-image-2'].forEach(function(id) {
+         document.getElementById(id).click();
+         assert.ok(spy.called,
+                   'PlayerView.showInfo should be called by click on ' + id);
+       });
+    });
+
+    test('on repeat', function() {
+      document.getElementById('player-album-repeat').click();
+      assert.ok(spy.called,
+                'PlayerView.showInfo should be called by click on repeat');
+    });
+  });
+
+  suite('update remote play status on audio event', function() {
+
+    var spy;
+
+    setup(function() {
+      spy = this.sinon.spy(PlayerView, 'updateRemotePlayStatus');
+    });
+
+    function sendEventAndTest(event, status) {
+      PlayerView.audio.dispatchEvent(new CustomEvent(event));
+      assert.ok(spy.called);
+      if (status) {
+        assert.equal(PlayerView.playStatus, status);
+      }
+    }
+
+    test('on play', function() {
+      sendEventAndTest('play', PLAYSTATUS_PLAYING);
+    });
+
+    test('on pause', function() {
+      sendEventAndTest('pause', PLAYSTATUS_PAUSED);
+    });
+
+    test('on interrupt begin', function() {
+      sendEventAndTest('mozinterruptbegin', INTERRUPT_BEGIN);
+    });
+
+    test('on interrupt end', function() {
+      sendEventAndTest('mozinterruptend', PLAYSTATUS_PLAYING);
+    });
+  });
+
+  suite('update seekbar', function() {
+    var spy;
+
+    setup(function() {
+      spy = this.sinon.spy(PlayerView, 'updateSeekBar');
+    });
+
+    test('on duration change', function() {
+      PlayerView.audio.dispatchEvent(new CustomEvent('durationchange'));
+      assert.ok(spy.called);
+    });
+
+    test('on timeupdate', function() {
+      PlayerView.audio.dispatchEvent(new CustomEvent('timeupdate'));
+      assert.ok(spy.called);
+    });
+
+    test('on visibilitychange', function() {
+      window.dispatchEvent(new CustomEvent('visibilitychange'));
+      assert.ok(spy.called);
+    });
+  });
+
+  suite('context menu', function() {
+    var spy;
+    setup(function() {
+      mockAudioElement();
+      spy = this.sinon.spy(PlayerView, 'startFastSeeking');
+    });
+
+    function sendEvent(id) {
+      var el = document.getElementById(id);
+      var ev = document.createEvent('MouseEvents');
+      ev.initMouseEvent('contextmenu', true, false, window, 0, 0, 0, 0, 0,
+                        false, false, false, false, 2, null);
+      el.dispatchEvent(ev);
+    }
+
+    test('previous button', function() {
+      sendEvent('player-controls-previous');
+      assert.ok(spy.called);
+    });
+
+    test('next button', function() {
+      sendEvent('player-controls-next');
+      assert.ok(spy.called);
+    });
+  });
+
+  suite('keyboard seek', function() {
+    var spy;
+    setup(function() {
+      mockAudioElement();
+      spy = this.sinon.spy(PlayerView, 'seekAudio');
+    });
+
+    function sendEventAndTest(key) {
+      PlayerView.seekSlider.dispatchEvent(new KeyboardEvent('keypress',
+                                                            { keyCode: key }));
+      assert.ok(spy.called);
+    }
+
+    test('key up seek', function() {
+      sendEventAndTest(KeyEvent.DOM_VK_UP);
+    });
+
+    test('key down seek', function() {
+      sendEventAndTest(KeyEvent.DOM_VK_DOWN);
+    });
+  });
+});

gaia/dev_apps/music-oga/test/unit/ui/views/searchview_test.js

@@ -0,0 +1,138 @@
+/* global SearchView, Sanitizer, MocksHelper, FocusEvent */
+'use strict';
+
+require('/shared/js/sanitizer.js');
+
+require('/js/ui/views/search_view.js');
+
+require('/test/unit/mock_music.js');
+require('/test/unit/ui/views/mock_modemanager.js');
+require('/test/unit/ui/mock_tab_bar.js');
+
+var mocksForSearchViewHelper = new MocksHelper([
+  'App',
+  'ModeManager',
+  'TabBar'
+]).init();
+
+
+suite('SearchView', function() {
+
+  mocksForSearchViewHelper.attachTestHelpers();
+
+  suiteSetup(function() {
+
+    this.element = document.createElement('div');
+    this.element.setAttribute('id', 'views-search');
+    this.element.setAttribute('action', 'back');
+    this.element.setAttribute('no-font-fit', null);
+    this.element.innerHTML = Sanitizer.unwrapSafeHTML(
+      Sanitizer.createSafeHTML(
+        `<form id="views-search-form" role="search" class="skin-dark">
+          <button id="views-search-close" data-l10n-id="search-close"
+          type="submit">close</button>
+          <p>
+            <input id="views-search-input" type="search" dir="auto"
+                   x-inputmode="verbatim"
+                   data-l10n-id="search-music" placeholder="SearcH MusiC">
+            <button id="views-search-clear" type="reset">Clear</button>
+          </p>
+        </form>
+        <div id="views-search-no-result" class="search-category hidden">
+          <p id="search-no-result" data-l10n-id="search-no-result">No
+          musiC founD</p>
+        </div>
+        <div id="views-search-anchor">
+          <div id="views-search-artists" class="search-category hidden">
+            <gaia-subheader skin="dark">
+              <span data-l10n-id="search-artists">ArtistS</span>
+                (<span class="search-result-count"></span>)
+            </gaia-subheader>
+            <div class="search-results" role="listbox"></div>
+          </div>
+          <div id="views-search-albums" class="search-category hidden">
+            <gaia-subheader skin="dark">
+              <span data-l10n-id="search-albums">AlbumS</span>
+                (<span class="search-result-count"></span>)
+            </gaia-subheader>
+            <div class="search-results" role="listbox"></div>
+          </div>
+          <div id="views-search-titles" class="search-category hidden">
+            <gaia-subheader skin="dark">
+              <span data-l10n-id="search-titles">TrackS</span>
+                (<span class="search-result-count"></span>)
+            </gaia-subheader>
+            <div class="search-results" role="listbox"></div>
+          </div>
+        </div>`
+      ));
+    document.body.appendChild(this.element);
+    this.searchView = SearchView;
+    this.searchView.init();
+  });
+
+  suiteTeardown(function() {
+    document.body.removeChild(this.element);
+    this.element = null;
+  });
+
+  // send a fake touchend event to el
+  function sendTouch(el) {
+    var touchendEvent = document.createEvent('TouchEvent');
+    touchendEvent.initTouchEvent('touchend', true, true, window,
+                                 0, false, false, false, false,
+                                 null, null, null);
+    el.dispatchEvent(touchendEvent);
+  }
+
+  suite('test focus', function() {
+    var spy;
+
+    setup(function() {
+      spy = this.sinon.spy(SearchView, 'switchContext');
+      var searchInput = document.getElementById('views-search-input');
+      searchInput.dispatchEvent(new FocusEvent('focus'));
+    });
+
+    test('test context switched', function() {
+      assert.ok(spy.called, 'SearchView.switchContext() should be called');
+      assert.equal(SearchView.searchContext, SearchView.context.ALL);
+    }, this);
+  });
+
+
+  suite('test tap clear', function() {
+    var spy;
+    var searchInput;
+
+    setup(function() {
+      spy = this.sinon.spy(SearchView, 'clear');
+      searchInput = document.getElementById('views-search-input');
+      searchInput.value = 'this is not the search you are looking for';
+      var searchClear = document.getElementById('views-search-clear');
+      sendTouch(searchClear);
+    });
+
+    test('test that search is now empty', function() {
+      assert.ok(spy.called, 'SearchView.clear() should be called');
+      assert.equal(searchInput.value, '');
+    });
+  });
+
+  suite('test close', function() {
+    var spy, spy2;
+
+    setup(function() {
+      spy = this.sinon.spy(SearchView, 'hide');
+      spy2 = this.sinon.spy(SearchView, 'openResult');
+      var searchClose = document.getElementById('views-search-close');
+      searchClose.click();
+    });
+
+    test('test search is hidden', function() {
+      assert.ok(spy.called, 'SearchView.hide() should be called');
+      assert.ok(!spy2.called, 'SearchVie.openResult() should not be called');
+    }, this);
+  });
+
+});

gaia/dev_apps/music-oga/test/unit/ui/views/subList_view_test.js

@@ -0,0 +1,121 @@
+/* global SubListView, Sanitizer, MocksHelper, ModeManager, MockL10n */
+'use strict';
+
+require('/shared/js/sanitizer.js');
+
+require('/js/utils.js');
+require('/js/ui/views/subList_view.js');
+
+require('/test/unit/mock_db.js');
+require('/test/unit/metadata/mock_album_art_cache.js');
+require('/test/unit/ui/mock_tab_bar.js');
+require('/test/unit/ui/views/mock_modemanager.js');
+require('/test/unit/mock_lazy_loader.js');
+require('/shared/test/unit/mocks/mock_l10n.js');
+
+var mocksForSubListViewHelper = new MocksHelper([
+  'LazyLoader',
+  'AlbumArtCache',
+  'ModeManager',
+  'TabBar',
+  'Database'
+]).init();
+
+suite('SubListView test', function() {
+  var realL10n = navigator.mozL10n;
+
+  mocksForSubListViewHelper.attachTestHelpers();
+
+  suiteSetup(function(done) {
+    navigator.mozL10n = MockL10n;
+
+    ModeManager._view = SubListView;
+
+    this.element = document.createElement('div');
+    this.element.id = 'views-sublist';
+    document.body.appendChild(this.element);
+    this.element.innerHTML = Sanitizer.unwrapSafeHTML(
+      Sanitizer.createSafeHTML(
+        `<div id="views-sublist-header">
+          <img id="views-sublist-header-image">
+          <div id="views-sublist-header-controls">
+            <bdi id="views-sublist-header-name">Name</bdi>
+          <button id="views-sublist-controls-play"
+        class="album-controls-button" data-icon="play"
+        data-l10n-id="playbackPlay"></button>
+          <button id="views-sublist-controls-shuffle"
+        class="album-controls-button" data-icon="shuffle"
+        data-l10n-id="shuffle-toggle"></button>
+          </div>
+        </div>
+        <div id="views-scrollable-sublist-anchor">
+          <div id="views-sublist-anchor" role="listbox">
+          </div>
+        </div>`
+      ));
+
+    this.subListView = SubListView;
+
+    this.subListView.init();
+    var data = {
+      metadata: {
+        album: 'Crime of the Century',
+        artist: 'Supertramp',
+        title: 'School'
+      }
+    };
+    this.subListView.activate('album', data, 0, null, 'next',
+                              () => done() );
+  });
+
+  suiteTeardown(function() {
+    document.body.removeChild(this.element);
+    this.element = null;
+
+    navigator.mozL10n = realL10n;
+  });
+
+  suite('activate', function() {
+
+    test('content', function() {
+      var children = this.subListView.anchor.children;
+      var count = children.length;
+      assert.equal(count, 4);
+
+      children = this.subListView.anchor.querySelectorAll('.list-item');
+      count = children.length;
+      assert.equal(count, 4);
+
+      var first = this.subListView.anchor.firstChild;
+      assert.equal(first.tagName, 'LI');
+      assert.equal(first.getAttribute('role'), 'presentation');
+      assert.equal(first.textContent, 'School');
+
+      var second = children[1];
+      assert.equal(second.tagName, 'LI');
+      assert.equal(first.getAttribute('role'), 'presentation');
+      assert.equal(second.textContent, 'Lady');
+    });
+  });
+
+  suite('events', function() {
+    var spy;
+
+    test('click tile', function() {
+      spy = this.sinon.spy(ModeManager, 'push');
+      var listItem = document.querySelector('.list-item > [role="option"]');
+      assert.ok(listItem);
+      listItem.click();
+      assert.ok(spy.called, 'ModeManager.push() should have been called');
+    });
+
+    test('click shuffle', function() {
+      spy = this.sinon.spy(ModeManager, 'push');
+
+      document.getElementById('views-sublist-controls-shuffle').click();
+      assert.ok(spy.called, 'ModeManager.push() should have been called');
+    });
+  });
+
+});
+

gaia/dev_apps/music-oga/test/unit/ui/views/tiles_view_test.js

@@ -0,0 +1,115 @@
+/* global TilesView, Sanitizer, MocksHelper, ModeManager, FocusEvent,
+   MODE_TILES */
+'use strict';
+
+require('/shared/js/sanitizer.js');
+
+require('/js/ui/views/tiles_view.js');
+
+require('/test/unit/mock_db.js');
+require('/test/unit/metadata/mock_album_art_cache.js');
+require('/test/unit/ui/views/mock_modemanager.js');
+require('/shared/test/unit/mocks/mock_lazy_loader.js');
+
+var mocksForTilesViewHelper = new MocksHelper([
+  'LazyLoader',
+  'AlbumArtCache',
+  'ModeManager',
+  'Database'
+]).init();
+
+
+suite('Tiles view test', function() {
+
+  mocksForTilesViewHelper.attachTestHelpers();
+
+  suiteSetup(function() {
+
+    this.element = document.createElement('div');
+    this.element.id = 'views-tiles';
+    document.body.appendChild(this.element);
+    this.element.innerHTML = Sanitizer.unwrapSafeHTML(
+      Sanitizer.createSafeHTML(
+        `<form id="views-tiles-search" role="search" class="skin-dark">
+          <button id="views-tiles-search-close" data-l10n-id="search-close"
+        type="submit">close</button>
+          <p>
+          <input id="views-tiles-search-input" type="search" dir="auto"
+        x-inputmode="verbatim"
+        data-l10n-id="search-music" placeholder="SearcH MusiC">
+          <button id="views-tiles-search-clear" type="reset">Clear</button>
+          </p>
+          </form>
+          <div id="views-tiles-anchor"></div>`
+      ));
+
+    this.tilesView = TilesView;
+
+    this.tilesView.init();
+  });
+
+  suiteTeardown(function() {
+    document.body.removeChild(this.element);
+    this.element = null;
+  });
+
+  suite('activate', function() {
+    setup(function(done) {
+      this.tilesView.activate(() => done());
+    });
+
+    test('content', function() {
+      var children = this.tilesView.anchor.childNodes;
+      var count = children.length;
+      assert.equal(count, 4);
+
+      var first = this.tilesView.anchor.firstChild;
+      assert.equal(first.tagName, 'DIV');
+      assert.ok(first.classList.contains('main-tile'));
+      assert.ok(first.classList.contains('tile'));
+      assert.equal(first.textContent, 'SupertrampCrime of the Century');
+
+      var second = children[1];
+      assert.equal(second.tagName, 'DIV');
+      assert.ok(second.classList.contains('sub-tile'));
+      assert.ok(second.classList.contains('tile'));
+      assert.equal(second.textContent, 'Supertramp');
+    });
+  });
+
+  suite('events', function() {
+    var spy;
+
+    setup(function(done) {
+      this.tilesView.activate(() => done());
+    });
+
+    test('click tile', function() {
+      spy = this.sinon.spy(ModeManager, 'push');
+      var tile = document.querySelector('.tile > [role="button"]');
+      assert.ok(tile);
+      tile.click();
+      assert.ok(spy.called, 'ModeManager.push() should be called');
+    });
+
+    test('click search close', function() {
+      spy = this.sinon.spy(TilesView, 'hideSearch');
+
+      document.getElementById('views-tiles-search-close').click();
+      assert.ok(spy.called, 'TilesView.hideSearch() should have been called');
+    });
+
+    test('focus on search', function() {
+      // make sure this return the right value
+      this.sinon.stub(ModeManager, 'currentMode', () => MODE_TILES );
+      var spy = this.sinon.spy(ModeManager, 'start');
+      var input = document.getElementById('views-tiles-search-input');
+      input.dispatchEvent(new FocusEvent('focus'));
+
+      assert.ok(spy.called, 'ModeManager.start should have been called');
+    });
+  });
+
+
+});
+

gaia/dev_apps/music-oga/test/unit/utils.js

@@ -0,0 +1,14 @@
+/* exported pass, fail */
+'use strict';
+
+function pass(done) {
+  return function() { done(); };
+}
+
+function fail(done, desc) {
+  if (!desc) {
+    desc = 'unknown error';
+  }
+  return function(err) { done(err || new Error(desc)); };
+}
+