test_mediaitem.js

Go to the documentation of this file.

/*
//
// BEGIN SONGBIRD GPL
//
// This file is part of the Songbird web player.
//
// Copyright(c) 2005-2008 POTI, Inc.
// http://songbirdnest.com
//
// This file may be licensed under the terms of of the
// GNU General Public License Version 2 (the "GPL").
//
// Software distributed under the License is distributed
// on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either
// express or implied. See the GPL for the specific language
// governing rights and limitations.
//
// You should have received a copy of the GPL along with this
// program. If not, go to http://www.gnu.org/licenses/gpl.html
// or write to the Free Software Foundation, Inc.,
// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
//
// END SONGBIRD GPL
//
*/

var TEST_STRING = "The quick brown fox jumps over the lazy dog.  Bitches."

var gServerPort = getTestServerPortNumber();
var gServer;

function read_stream(stream, count) {
  /* assume stream has non-ASCII data */
  var wrapper =
      Cc["@mozilla.org/binaryinputstream;1"].
      createInstance(Ci.nsIBinaryInputStream);
  wrapper.setInputStream(stream);
  /* JS methods can be called with a maximum of 65535 arguments, and input
     streams don't have to return all the data they make .available() when
     asked to .read() that number of bytes. */
  var data = [];
  while (count > 0) {
    var bytes = wrapper.readByteArray(Math.min(65535, count));
    data.push(String.fromCharCode.apply(null, bytes));
    count -= bytes.length;
    if (bytes.length == 0)
      do_throw("Nothing read from input stream!");
  }
  return data.join('');
}

function newTempURI( name ) {
  var file = Components.classes["@mozilla.org/file/directory_service;1"]
                      .getService(Components.interfaces.nsIProperties)
                      .get("TmpD", Components.interfaces.nsIFile);
  file.append(name);
  file.createUnique(Components.interfaces.nsIFile.NORMAL_FILE_TYPE, 0664);
  var registerFileForDelete = Cc["@mozilla.org/uriloader/external-helper-app-service;1"]
                                .getService(Ci.nsPIExternalAppLauncher);
  registerFileForDelete.deleteTemporaryFileOnExit(file);
  var retval = newFileURI(file);
  log( "newTempURI = " + retval.spec );
  return retval;
}

function createItem( library, url ) {
  return library.createMediaItem(newURI(url));
}

function testGet( item, attrib, value ) {
  var test_value = item[ attrib ];
  // for nsURI return values, you must compare spec?
  if ( test_value.spec )
    test_value = test_value.spec;
  if ( value.spec )
    value = value.spec;
  assertEqual( test_value, value );
}

function testSet( item, attrib, value ) {
  log("testSet: " + attrib + " -> " + value);
  item[ attrib ] = value;
  testGet( item, attrib, value );
}

function testAvailable( library, url, available, completion ) {
  var item = createItem( library, url );

  // Make an observer to receive results of the availability test.
  // This one is complicated because I want to chain tests.
  var is_available_observer = {
    _item: item,
    _available: available,
    _completion: completion,
    observe: function( aSubject, aTopic, aData ) {
      if ( aTopic == "available" ) {
        log( "(sbIMediaItem::TestIsURIAvailable) COMPLETE " + this._item.contentSrc.spec + ": " + aTopic + " == " + aData );
        assertEqual( aData, this._available );
        if ( this._completion != null )
          try {
            this._completion();
          } catch ( e ) {
            assertEqual( e, null ); // Fail the tests on a throw.
          }
        testFinished();
      }
    },
    QueryInterface: function(iid) {
      if (!iid.equals(Components.interfaces.nsIObserver) &&
          !iid.equals(Components.interfaces.nsISupports))
        throw Components.results.NS_ERROR_NO_INTERFACE;
      return this;
    }
  }

  // Start the test, tell the testharness to wait for us.
  item.testIsURIAvailable( is_available_observer );
  testPending();
  log( "(sbIMediaItem::TestIsURIAvailable) START    " + url );
}

function testIsURIAvailable( ioItem ) {
  var databaseGUID = "test_mediaitem_isuriavailable";
  var testlib = createLibrary(databaseGUID);
  // Async tests of availability for a (supposedly!) known url.
  testAvailable( testlib, ioItem.contentSrc.spec, "true",
    function() {
      testAvailable( testlib, "http://localhost:" + gServerPort + "/test_not_available.mp3", "false",
        function() {
          testAvailable( testlib, "http://localhost:" + gServerPort + "/test1.mp3", "true", null);
        }
      );
    }
  );
}

function testAsyncRead(ioItem) {
  var listener = {
    _item: ioItem,

    onDataAvailable: function LLL_onDataAvailable(request, context, inputStream,
                                                  sourceOffset, count) {
      // Once we have enough bytes, read it.
      if ((count + sourceOffset) >= TEST_STRING.length) {
        this._value = read_stream(inputStream, (count + sourceOffset));
      }
    },

    onStartRequest: function LLL_onStartRequest(request, context) {
    },

    onStopRequest: function LLL_onStopReqeust(request, context, status) {
      // Test this and go on to the next tests.
      assertEqual( this._value, TEST_STRING );
      testIsURIAvailable( this._item );
      testFinished();
    },
    QueryInterface: function LLL_QueryInterface(iid) {
      if (iid.equals(Ci.nsIStreamListener) ||
          iid.equals(Ci.nsIRequestObserver)||
          iid.equals(Ci.nsISupports))
        return this;
      throw Cr.NS_ERROR_NO_INTERFACE;
    }
  }
  var inputChannel = ioItem.openInputStreamAsync(listener, null);
  assertNotEqual(inputChannel, null);
  listener._inputChannel = inputChannel;
  testPending();
}

function runTest () {

  gServer = Cc["@mozilla.org/server/jshttp;1"]
                 .createInstance(Ci.nsIHttpServer);

  var databaseGUID = "test_mediaitem";
  var testlib = createLibrary(databaseGUID);

  // Get an item
  var item = testlib.getMediaItem("3E586C1A-AD99-11DB-9321-C22AB7121F49");

  // Basic tests on retrieving its info...
  testGet( item, "library", testlib );
  testGet( item, "isMutable", true );
  testGet( item, "mediaCreated", 1169855962000 );
  testGet( item, "mediaUpdated", 1169855962000 );
  testGet( item, "contentSrc", "file:///home/steve/Hells%20Bells.mp3" );
  testGet( item, "contentLength", 0x21C );
  testGet( item, "contentType", "audio/mpeg" );

  // Slightly more complicated tests for setting its info
  testSet( item, "mediaCreated", 0x1337baadf00d );
  testSet( item, "mediaUpdated", 0x1337baadf00d );
  var newSrc = newURI("file:///poo/MyTrack.mp3");
  testSet( item, "contentSrc", newSrc);
  testSet( item, "contentLength", 0xbaadf00d );
  testSet( item, "contentType", "x-media/x-poo" );

  item.setProperty("newpropertyneverseenever", "valuevalue");

  // Open up a temp file through this interface
  var ioItem = testlib.createMediaItem( newTempURI("test_mediaitem") );
  assertNotEqual(ioItem, null);
  var outputStream = ioItem.openOutputStream();
  assertNotEqual(outputStream, null);

  // Write some junk to it and close.
  var count = outputStream.write( TEST_STRING, TEST_STRING.length );
  assertEqual(count, TEST_STRING.length);
  outputStream.flush();
  outputStream.close();

  // Reopen it for input, and see if we read the same junk back.
  var inputStream = ioItem.openInputStream().QueryInterface(Components.interfaces.nsILineInputStream);
  assertNotEqual(inputStream, null);
  var out = {};
  inputStream.readLine( out );
  assertEqual(out.value, TEST_STRING);
  inputStream.close();

  try {
    gServer.start(gServerPort);
    gServer.registerDirectory("/", getFile("."));

    // Async test, pauses the test system.
    // This passes control to testIsURIAvailable() when it completes.
    testAsyncRead(ioItem);

    // Shouldn't take more than 5 seconds to test all files.
    sleep(5000);
  }
  finally {
    gServer.stop(function() {});
  }
}