GNOME.org
 

[gnome-music] Tests

commit 3da53fd9fac0d8df636e59728f56397a1d2e20be
Author: Vadim Rutkovsky <vrutkovs redhat com>
Date:   Mon May 6 11:50:29 2013 +0200

    Tests

 Makefile.am             |    2 +-
 configure.ac            |    1 +
 src/view.js             |    2 +
 src/widgets.js          |    4 +
 tests/Makefile.am       |   14 +++
 tests/tests_albumArt.js |  224 +++++++++++++++++++++++++++++++++++++++++++++++
 6 files changed, 246 insertions(+), 1 deletions(-)
---
diff --git a/Makefile.am b/Makefile.am
index 86d3bb0..987dab2 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -1,6 +1,6 @@
 ACLOCAL_AMFLAGS = -I m4 -I libgd
 
-SUBDIRS = po libgd src data
+SUBDIRS = po libgd src data tests
 
 MAINTAINERCLEANFILES = \
        $(srcdir)/INSTALL \
diff --git a/configure.ac b/configure.ac
index 36c01de..1da5a0b 100644
--- a/configure.ac
+++ b/configure.ac
@@ -39,5 +39,6 @@ AC_CONFIG_FILES([
   libgd/Makefile
   src/Makefile
   po/Makefile.in
+  tests/Makefile
 ])
 AC_OUTPUT
diff --git a/src/view.js b/src/view.js
index f990c82..8d35d42 100644
--- a/src/view.js
+++ b/src/view.js
@@ -265,6 +265,7 @@ const ViewContainer = new Lang.Class({
                             this._model.set_value(iter, 4, icon);
                         }))
             }));
+        this.emit("album-art-updated");
         return false;
     },
 
@@ -275,6 +276,7 @@ const ViewContainer = new Lang.Class({
     }
 
 });
+Signals.addSignalMethods(ViewContainer.prototype);
 
 const Albums = new Lang.Class({
     Name: "AlbumsView",
diff --git a/src/widgets.js b/src/widgets.js
index 76260a8..4a4ee35 100644
--- a/src/widgets.js
+++ b/src/widgets.js
@@ -29,6 +29,7 @@ const Lang = imports.lang;
 const Grl = imports.gi.Grl;
 const Query = imports.query;
 const Grilo = imports.grilo;
+const Signals = imports.signals;
 
 const grilo = Grilo.grilo;
 const AlbumArtCache = imports.albumArtCache;
@@ -172,6 +173,7 @@ const AlbumWidget = new Lang.Class({
                     [ escapedTitle, "", "", false, nowPlayingPixbuf, track ]);
                 this.ui.get_object("running_length_label_info").set_text(
                     (parseInt(duration/60) + 1) + " min");
+                this.emit("track-added")
             }
         }));
     }
@@ -188,6 +190,7 @@ const AlbumWidget = new Lang.Class({
         else
             this.ui.get_object("released_label_info").set_text("----");
         this.player.connect('playlist-item-changed', Lang.bind(this, this.updateModel));
+        this.emit('loaded')
     },
 
     updateModel: function(player, playlist, currentIter){
@@ -223,6 +226,7 @@ const AlbumWidget = new Lang.Class({
         return true;
     },
 });
+Signals.addSignalMethods(AlbumWidget.prototype);
 
 const ArtistAlbums = new Lang.Class({
     Name: "ArtistAlbumsWidget",
diff --git a/tests/Makefile.am b/tests/Makefile.am
new file mode 100644
index 0000000..ee72da3
--- /dev/null
+++ b/tests/Makefile.am
@@ -0,0 +1,14 @@
+TESTS = \
+    tests_albumArt.js \
+    $(NULL)
+
+check-TESTS:
+       @RUN_TESTS_ENV_VARS= \
+            LD_LIBRARY_PATH=$(top_srcdir)/libgd/.libs:$$LD_LIBRARY_PATH \
+            GI_TYPELIB_PATH=$(top_srcdir)/libgd:$$GI_TYPELIB_PATH ; \
+        for test in $(TESTS) ; do \
+          echo "Running suite $$test" ; \
+          $(RUN_TESTS_ENV_VARS) gjs $$test ; \
+        done
+
+-include $(top_srcdir)/git.mk
diff --git a/tests/tests_albumArt.js b/tests/tests_albumArt.js
new file mode 100755
index 0000000..9740f48
--- /dev/null
+++ b/tests/tests_albumArt.js
@@ -0,0 +1,224 @@
+// application/javascript;version=1.8
+if (!('assertEquals' in this)) { /* allow running this test standalone */
+    imports.lang.copyPublicProperties(imports.jsUnit, this);
+    gjstestRun = function() { return imports.jsUnit.gjstestRun(window); };
+}
+
+imports.searchPath.unshift('..');
+imports.searchPath.unshift('../src');
+imports.searchPath.unshift('../libgd');
+imports.searchPath.unshift('../data');
+const AlbumArtCache = imports.src.albumArtCache.AlbumArtCache
+const GLib = imports.gi.GLib;
+const Gio = imports.gi.Gio;
+const Gtk = imports.gi.Gtk;
+const Gdk = imports.gi.Gdk;
+const Lang = imports.lang;
+
+
+function _hash(input) {
+    return GLib.compute_checksum_for_string(GLib.ChecksumType.MD5, input, -1);
+}
+
+function testNormalizeAndHash_SmokeTest() {
+    let albumArtCache = new AlbumArtCache();
+    assertEquals(_hash("test"), albumArtCache.normalizeAndHash("test"))
+}
+
+function testNormalizeAndHash_NullInput() {
+    let albumArtCache = new AlbumArtCache();
+    assertEquals(_hash(" "), albumArtCache.normalizeAndHash(""))
+    assertEquals(_hash(" "), albumArtCache.normalizeAndHash(null))
+    assertEquals(_hash(" "), albumArtCache.normalizeAndHash(undefined))
+}
+
+function testNormalizeAndHash_Lowercased() {
+    let albumArtCache = new AlbumArtCache();
+    assertEquals(_hash("test"), albumArtCache.normalizeAndHash("TEST"))
+}
+
+function testNormalizeAndHash_UTF8() {
+    let albumArtCache = new AlbumArtCache();
+    assertEquals(_hash("Неизвестный артист"),
+                 albumArtCache.normalizeAndHash("Неизвестный артист", true))
+}
+
+function testStripInvalidEntries_SmokeTest() {
+    let albumArtCache = new AlbumArtCache();
+    assertEquals('Unknown Artist', albumArtCache.stripInvalidEntities("Unknown Artist"))
+}
+
+function testStripInvalidEntries_Symbols() {
+    let albumArtCache = new AlbumArtCache();
+    //Percent and semicolon are not filtered, why?
+    assertEquals('Unknown Artist', albumArtCache.stripInvalidEntities("Unknown_! #$^&*+=| Artist"))
+}
+
+function testStripInvalidEntries_Slashes() {
+    let albumArtCache = new AlbumArtCache();
+    assertEquals('Unknown Artist', albumArtCache.stripInvalidEntities("Unknown\\ Artist"))
+    assertEquals('Unknown Artist', albumArtCache.stripInvalidEntities("Unknown\ Artist"))
+    assertEquals('Unknown Artist', albumArtCache.stripInvalidEntities("Unk//nown Artist"))
+    assertEquals('Unknown Artist', albumArtCache.stripInvalidEntities("Unk/nown Artist"))
+    assertEquals('Unknown Artist', albumArtCache.stripInvalidEntities("Unk\/nown Artist"))
+}
+
+function testStripInvalidEntries_Brackets() {
+    let albumArtCache = new AlbumArtCache();
+    assertEquals('Unknown Artist', albumArtCache.stripInvalidEntities("Un(known) Artist"))
+    assertEquals('Unknown Artist', albumArtCache.stripInvalidEntities("[Un]known Artist"))
+    assertEquals('Unknown Artist', albumArtCache.stripInvalidEntities("<Un>known Artist"))
+    assertEquals('Unknown Artist', albumArtCache.stripInvalidEntities("{Un}known Artist"))
+}
+
+function testStripInvalidEntries_Spaces() {
+    let albumArtCache = new AlbumArtCache();
+    assertEquals('Unknown Artist', albumArtCache.stripInvalidEntities("Unknown  Artist"))
+    assertEquals('Unknown Artist', albumArtCache.stripInvalidEntities("Unknown   Artist"))
+    assertEquals('Unknown Artist', albumArtCache.stripInvalidEntities("<Unknown>  Artist"))
+    assertEquals('Unknown Artist', albumArtCache.stripInvalidEntities("Unknown^^@(*  ) Artist"))
+}
+
+function registerResources() {
+    let resource = Gio.Resource.load('../data/gnome-music.gresource');
+    resource._register();
+
+    let cssFile = Gio.File.new_for_uri('resource:///org/gnome/music/application.css');
+    let provider = new Gtk.CssProvider();
+    provider.load_from_file(cssFile);
+    Gtk.init(null, 0);
+    Gtk.StyleContext.add_provider_for_screen(Gdk.Screen.get_default(),
+                                             provider,
+                                             Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION);
+}
+
+function getAlbumView() {
+    registerResources();
+
+    const AlbumView = imports.view.Albums;
+    const Toolbar = imports.toolbar;
+    const Player = imports.player;
+    let toolbar = new Toolbar.Toolbar();
+    let player = new Player.Player();
+    return new AlbumView(toolbar, player);
+}
+
+function testAlbumViewCountIsNotEmpty() {
+    var Mainloop = imports.mainloop;
+    const View = imports.view;
+    const Widgets = imports.widgets;
+    let albumView = getAlbumView();
+    // Wait for albums to load, run mainloop
+    albumView.connect("album-art-updated", Lang.bind(this, function(){
+        //FIXME: Here we try to quit the mainloop for each album
+        //this causes exceptions and should be handled correctly
+        try {
+            Mainloop.quit('testMainloop');
+        } catch(Exception) {}
+    }));
+    Mainloop.run('testMainloop');
+    // Loaded, ready to go
+
+    // Check that no more than 50 and no less than 0 albums were loaded
+    if (!(albumView._offset > 0 && albumView._offset < 51))
+        fail('albumView._offset="'+albumView._offset +'"')
+
+    // The album has title and artist displayed (not null values)
+    let firstAlbumIter = albumView._model.get_iter_first()[1];
+    let firstAlbumPath = albumView._model.get_path(firstAlbumIter);
+    let album = albumView._model.get_value(firstAlbumIter, 2);
+    let artist = albumView._model.get_value(firstAlbumIter, 3);
+    log("  First album is '"+album+"' by '"+artist+"'")
+    assertNotNull(album)
+    assertNotNull(artist)
+
+    // Select first album
+    let albumWidget = albumView._albumWidget;
+    albumWidget.connect("loaded", Lang.bind(this, function(){
+        Mainloop.quit('testMainloop');
+    }));
+    Mainloop.idle_add(function() {
+        albumView.view.emit('item-activated', "0", firstAlbumPath);
+    })
+    Mainloop.run('testMainloop');
+    // Album view loaded
+
+    // Make sure that the same artist and album are displayed
+    let artist2 = albumWidget.ui.get_object("artist_label").label;
+    assertEquals(artist, artist2)
+    let album2 = albumWidget.ui.get_object("title_label").label;
+    assertEquals(album, album2)
+
+    // Make sure that year is either ---- or more that 1000 (at least)
+    let year = albumWidget.ui.get_object("released_label_info").label;
+    if (year != '----')
+        assertTrue(year > 1000)
+
+    // Wait for tracks to be added
+    albumWidget.connect('track-added', Lang.bind(this, function(){
+        Mainloop.quit('testMainloop');
+    }))
+    Mainloop.run('testMainloop');
+
+    // FIXME: wait for all tracks to be added, for now operate on the first one
+    let model = albumWidget.model;
+    let iter = model.get_iter_first()[1];
+    let title = model.get_value(iter, 0);
+    assertNotNull(title)
+    assertEquals(title, model.get_value(iter, 5).get_title())
+    log("  First track is '"+title+"'")
+
+    // Buttons are disabled
+    let player = albumWidget.player;
+    assertFalse(player.prevBtn.get_sensitive())
+    assertFalse(player.playBtn.get_sensitive())
+    assertFalse(player.nextBtn.get_sensitive())
+
+    // Artist and track labels are empty
+    assertEquals(player.artistLabel.get_label(), "")
+    assertEquals(player.titleLabel.get_label(), "")
+
+    // Progress scale is not initialized (undefined range)
+    assertEquals(player.progressScale.range, undefined)
+
+    // Duration labels are set to "00:00"
+    assertEquals(player.songTotalTimeLabel.get_label(), "00:00")
+    assertEquals(player.songPlaybackTimeLabel.get_label(), "00:00")
+
+    // Select the first song and remember its markup
+    let firstTrackIter = albumWidget.model.get_iter_first()[1];
+    let firstTrackMarkup = albumWidget.model.get_value(firstTrackIter, 0);
+    let firstTrackPath = albumWidget.model.get_path(firstTrackIter);
+    albumWidget.view.emit("item-activated", "0", firstTrackPath);
+
+    // Buttons become enabled
+    assertTrue(player.prevBtn.get_sensitive())
+    assertTrue(player.playBtn.get_sensitive())
+    assertTrue(player.nextBtn.get_sensitive())
+
+    // Scale value is set to 0
+    assertEquals(player.progressScale.get_value(), 0)
+
+    // Track markup is updated
+    let newTrackMarkup = albumWidget.model.get_value(firstTrackIter, 0);
+    assertEquals(newTrackMarkup, "<b>" + firstTrackMarkup + "</b>");
+
+    // Nowplaying icon is displayed for this track
+    assertTrue(albumWidget.model.get_value(firstTrackIter, 3))
+
+    // Artist and track labels are updated
+    assertEquals(player.artistLabel.get_label(), artist)
+    assertEquals(player.titleLabel.get_label(), title)
+
+    // Other tracks don't contain <b> or <span> and don't display now playing icon
+    let tracksIter = firstTrackIter.copy();
+    while(albumWidget.model.iter_next(tracksIter)) {
+        let trackMarkup = albumWidget.model.get_value(tracksIter, 0);
+        assertTrue(trackMarkup.indexOf("<b>") == -1)
+        assertTrue(trackMarkup.indexOf("<span>") == -1)
+        assertFalse(albumWidget.model.get_value(tracksIter, 3))
+    }
+}
+
+gjstestRun();
+
[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]