tests/rygel-item-creator-test.vala

   1 /*
   2  * Copyright (C) 2012 Nokia Corporation.
   3  *
   4  * Author: Jens Georg <jensg@openismus.com>
   5  *
   6  * This file is part of Rygel.
   7  *
   8  * Rygel is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU Lesser General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * Rygel is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public License
  19  * along with this program; if not, write to the Free Software Foundation,
  20  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  21  */
  22
  23 [CCode (cname = "uuid_generate", cheader_filename = "uuid/uuid.h")]
  24 internal extern static void uuid_generate ([CCode (array_length = false)]
  25                                            uchar[] uuid);
  26 [CCode (cname = "uuid_unparse", cheader_filename = "uuid/uuid.h")]
  27 internal extern static void uuid_unparse ([CCode (array_length = false)]
  28                                           uchar[] uuid,
  29                                           [CCode (array_length = false)]
  30                                           uchar[] output);
  31
  32 public const string DIDL_ITEM = """<?xml version="1.0" encoding="UTF-8"?>
  33 <DIDL-Lite
  34     xmlns:dc="http://purl.org/dc/elements/1.1/"
  35     xmlns="urn:schemas-upnp-org:metadata-1-0/DIDL-Lite/"
  36     xmlns:upnp="urn:schemas-upnp-org:metadata-1-0/upnp/"
  37     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  38     xsi:schemaLocation="urn:schemas-upnp-org:metadata-1-0/DIDL-Lite/
  39         http://www.upnp.org/schemas/av/didl-lite-v2-20060531.xsd
  40       urn:schemas-upnp-org:metadata-1-0/upnp/
  41         http://www.upnp.org/schemas/av/upnp-v2-20060531.xsd">
  42     <item id="" parentID="0" restricted="0">
  43         <dc:title>New Song</dc:title>
  44         <upnp:class>object.item.audioItem</upnp:class>
  45         <res protocolInfo="*:*:*:*" />
  46     </item>
  47 </DIDL-Lite>""";
  48
  49 public class Rygel.ServiceAction : GLib.Object {
  50     public int error_code;
  51     public string error_message;
  52     public string id;
  53     public string elements;
  54
  55     public ServiceAction (string? container_id,
  56                           string? elements) {
  57         this.id = container_id;
  58         this.elements = elements;
  59     }
  60
  61     public void @return() {}
  62     public void return_error (int code, string message) {
  63         this.error_code = code;
  64         this.error_message = message;
  65     }
  66
  67     public new void @get (string arg1_name,
  68                           Type arg1_type,
  69                           out string arg1_val,
  70                           string arg2_name,
  71                           Type arg2_type,
  72                           out string arg2_val) {
  73         assert (arg1_name == "ContainerID");
  74         assert (arg1_type == typeof (string));
  75         arg1_val = id;
  76
  77         assert (arg2_name == "Elements");
  78         assert (arg2_type == typeof (string));
  79         arg2_val = elements;
  80     }
  81
  82     public new void @set (string arg1_name,
  83                           Type arg1_type,
  84                           string arg1_val,
  85                           string arg2_name,
  86                           Type arg2_type,
  87                           string arg2_val) {
  88         assert (arg1_name == "ObjectID");
  89         assert (arg1_type == typeof (string));
  90
  91         assert (arg2_name == "Result");
  92         assert (arg2_type == typeof (string));
  93     }
  94 }
  95
  96 public class Rygel.HTTPServer : GLib.Object {
  97 }
  98
  99 public class Rygel.ItemRemovalQueue : GLib.Object {
 100     public static ItemRemovalQueue get_default () {
 101         return new ItemRemovalQueue ();
 102     }
 103
 104     public void queue (MediaItem item, Cancellable? cancellable) {
 105     }
 106 }
 107
 108 public class Rygel.MediaObject : GLib.Object {
 109     public string id;
 110     public string ref_id;
 111     public unowned MediaContainer parent;
 112     public string upnp_class;
 113     public string title;
 114     public GUPnP.OCMFlags ocm_flags;
 115     public Gee.ArrayList<string> uris;
 116
 117     public void add_uri (string uri) {
 118         this.uris.add (uri);
 119     }
 120 }
 121
 122 public class Rygel.MediaItem : Rygel.MediaObject {
 123     public string dlna_profile;
 124     public string mime_type;
 125     public long size;
 126     public bool place_holder;
 127
 128     public MediaItem (string id, MediaContainer parent, string title) {
 129         this.id = id;
 130         this.parent = parent;
 131         this.title = title;
 132     }
 133
 134     public void serialize (GUPnP.DIDLLiteWriter writer, HTTPServer server) {
 135     }
 136 }
 137
 138 public class Rygel.MusicItem : Rygel.AudioItem {
 139     public const string UPNP_CLASS = "object.item.audioItem.musicTrack";
 140
 141     public MusicItem (string id, MediaContainer parent, string title) {
 142         base (id, parent, title);
 143     }
 144 }
 145
 146 public class Rygel.AudioItem : Rygel.MediaItem {
 147     public const string UPNP_CLASS = "object.item.audioItem";
 148     public string artist;
 149     public string album;
 150
 151     public AudioItem (string id, MediaContainer parent, string title) {
 152         base (id, parent, title);
 153     }
 154 }
 155 public class Rygel.ImageItem : Rygel.MediaItem {
 156     public const string UPNP_CLASS = "object.item.imageItem";
 157     public ImageItem (string id, MediaContainer parent, string title) {
 158         base (id, parent, title);
 159     }
 160 }
 161
 162 public class Rygel.VideoItem : Rygel.MediaItem {
 163     public const string UPNP_CLASS = "object.item.videoItem";
 164     public VideoItem (string id, MediaContainer parent, string title) {
 165         base (id, parent, title);
 166     }
 167 }
 168
 169 public class Rygel.PhotoItem : Rygel.MediaItem {
 170     public const string UPNP_CLASS = "object.item.imageItem.photo";
 171     public string creator;
 172
 173     public PhotoItem (string id, MediaContainer parent, string title) {
 174         base (id, parent, title);
 175     }
 176 }
 177 public class Rygel.ContentDirectory : GLib.Object {
 178     public Cancellable cancellable;
 179     public MediaContainer root_container;
 180     public HTTPServer http_server;
 181 }
 182
 183 public class Rygel.MediaContainer : Rygel.MediaObject {
 184     public Gee.ArrayList<string> create_classes = new Gee.ArrayList<string> ();
 185     public int child_count;
 186
 187     // mockable elements
 188     public MediaObject found_object = null;
 189
 190     public async MediaObject? find_object (string       id,
 191                                            Cancellable? cancellable = null) {
 192         Idle.add (() => { find_object.callback (); return false; });
 193         yield;
 194
 195         return found_object;
 196     }
 197
 198     public signal void container_updated (MediaContainer container);
 199 }
 200
 201 public class Rygel.MediaObjects : Gee.ArrayList<MediaObject> {
 202 }
 203
 204 public class Rygel.WritableContainer : Rygel.MediaContainer {
 205     public bool can_create (string upnp_class) {
 206         return this.create_classes.contains (upnp_class);
 207     }
 208
 209     public async File? get_writable (Cancellable? cancellable = null) {
 210         return File.new_for_commandline_arg ("/tmp");
 211     }
 212
 213     public async void add_item (MediaItem    item,
 214                                 Cancellable? cancellable = null) {
 215     }
 216 }
 217
 218 public class Rygel.SearchableContainer : Rygel.MediaContainer {
 219     public MediaObjects result = new MediaObjects ();
 220
 221     public async MediaObjects search (SearchExpression expression,
 222                                       int              offset,
 223                                       int              count,
 224                                       out int          total_matches,
 225                                       Cancellable?     cancellable = null) {
 226         Idle.add (() => { search.callback (); return false; });
 227         yield;
 228
 229         return result;
 230     }
 231 }
 232
 233 public errordomain Rygel.ContentDirectoryError {
 234     BAD_METADATA,
 235     NO_SUCH_OBJECT,
 236     INVALID_ARGS,
 237     RESTRICTED_PARENT,
 238     ERROR
 239 }
 240
 241 public class Rygel.HTTPItemCreatorTest : GLib.Object {
 242
 243     public static int main (string[] args) {
 244         var test = new HTTPItemCreatorTest ();
 245         test.test_parse_args ();
 246         test.test_didl_parsing ();
 247         test.test_fetch_container ();
 248
 249         return 0;
 250     }
 251
 252     // expected errors
 253     Error no_such_object;
 254     Error restricted_parent;
 255     Error bad_metadata;
 256     Error invalid_args;
 257
 258     public HTTPItemCreatorTest () {
 259         this.no_such_object = new ContentDirectoryError.NO_SUCH_OBJECT("");
 260         this.restricted_parent = new ContentDirectoryError.RESTRICTED_PARENT("");
 261         this.bad_metadata = new ContentDirectoryError.BAD_METADATA("");
 262         this.invalid_args = new ContentDirectoryError.INVALID_ARGS("");
 263     }
 264
 265     private void test_parse_args () {
 266         // check null container id
 267         var content_directory = new ContentDirectory ();
 268
 269         var action = new ServiceAction (null, "");
 270         var creator = new ItemCreator (content_directory, action);
 271         creator.run ();
 272         assert (action.error_code == no_such_object.code);
 273
 274         // check elements containing a comment
 275         action = new ServiceAction ("0", "<!-- This is an XML comment -->");
 276         creator = new ItemCreator (content_directory, action);
 277         creator.run ();
 278         assert (action.error_code == bad_metadata.code);
 279
 280         // check null elements
 281         action = new ServiceAction ("0", null);
 282         creator = new ItemCreator (content_directory, action);
 283         creator.run ();
 284         assert (action.error_code == bad_metadata.code);
 285     }
 286
 287     private void test_didl_parsing_step (Xml.Doc *doc, int expected_code) {
 288         string xml;
 289
 290         doc->dump_memory_enc (out xml);
 291         var action = new ServiceAction ("0", xml);
 292         var content_directory = new ContentDirectory ();
 293         var creator = new ItemCreator (content_directory, action);
 294         creator.run ();
 295         assert (action.error_code == expected_code);
 296     }
 297
 298     private void test_didl_parsing () {
 299         var xml = Xml.Parser.read_memory (DIDL_ITEM,
 300                                           DIDL_ITEM.length,
 301                                           null,
 302                                           null,
 303                                           Xml.ParserOption.RECOVER |
 304                                           Xml.ParserOption.NOBLANKS);
 305         var didl_node = xml->children;
 306         var item_node = didl_node->children;
 307         var content_directory = new ContentDirectory ();
 308
 309         // test no DIDL
 310         var action = new ServiceAction ("0", "");
 311         var creator = new ItemCreator (content_directory, action);
 312         creator.run ();
 313         assert (action.error_code == bad_metadata.code);
 314         assert (action.error_message == "Bad metadata");
 315
 316         // test empty DIDL
 317         item_node->unlink ();
 318         didl_node->set_content ("  ");
 319         this.test_didl_parsing_step (xml, 701);
 320
 321         // test item node with missing restricted attribute
 322         var tmp = item_node->copy (1);
 323         tmp->unset_prop ("restricted");
 324         didl_node->add_child (tmp);
 325         this.test_didl_parsing_step (xml, bad_metadata.code);
 326
 327         // test item node with restricted=1
 328         tmp->set_prop ("restricted", "1");
 329         this.test_didl_parsing_step (xml, invalid_args.code);
 330
 331         // test item node with invalid id
 332         tmp->unlink ();
 333         tmp = item_node->copy (1);
 334         tmp->set_prop ("id", "InvalidItemId");
 335         didl_node->add_child (tmp);
 336         this.test_didl_parsing_step (xml, bad_metadata.code);
 337
 338         // test item node with missing id
 339         tmp->unset_prop ("id");
 340         this.test_didl_parsing_step (xml, bad_metadata.code);
 341
 342         // test item node with missing title
 343         tmp->unlink ();
 344         tmp = item_node->copy (1);
 345         var title_node = tmp->children;
 346         title_node->unlink ();
 347         didl_node->add_child (tmp);
 348         this.test_didl_parsing_step (xml, bad_metadata.code);
 349
 350         // test missing, empty or non-item upnp class
 351         tmp->unlink ();
 352         tmp = item_node->copy (1);
 353         var class_node = tmp->children->next;
 354         class_node->set_content ("object.container");
 355         didl_node->add_child (tmp);
 356         this.test_didl_parsing_step (xml, bad_metadata.code);
 357
 358         class_node->set_content ("");
 359         this.test_didl_parsing_step (xml, bad_metadata.code);
 360
 361         class_node->unlink ();
 362         this.test_didl_parsing_step (xml, bad_metadata.code);
 363     }
 364
 365     private void test_fetch_container_run (ItemCreator creator) {
 366         var main_loop = new MainLoop (null, false);
 367         creator.run.begin ( () => { main_loop.quit (); });
 368         main_loop.run ();
 369     }
 370
 371     private void test_fetch_container () {
 372         // check case when object is not found
 373         var content_directory = new ContentDirectory ();
 374         var root_container = new SearchableContainer ();
 375         content_directory.root_container = root_container;
 376         var action = new ServiceAction ("0", DIDL_ITEM);
 377         var creator = new ItemCreator (content_directory, action);
 378         this.test_fetch_container_run (creator);
 379         assert (action.error_code == no_such_object.code);
 380
 381         // check case when found object is not a container → Error 710
 382         // cf. ContentDirectory:2 spec, Table 2-22
 383         root_container.found_object = new MediaObject ();
 384         this.test_fetch_container_run (creator);
 385         assert (action.error_code == no_such_object.code);
 386
 387         // check case when found container does not have OCMUpload set
 388         root_container.found_object = new MediaContainer ();
 389         this.test_fetch_container_run (creator);
 390         assert (action.error_code == restricted_parent.code);
 391
 392         // check case when found container is not a writable container
 393         root_container.found_object.ocm_flags |= GUPnP.OCMFlags.UPLOAD;
 394         this.test_fetch_container_run (creator);
 395         assert (action.error_code == restricted_parent.code);
 396
 397         // check when found container does not have the correct create class
 398         var container = new WritableContainer ();
 399         container.create_classes.add ("object.item.imageItem.musicTrack");
 400         container.ocm_flags |= GUPnP.OCMFlags.UPLOAD;
 401         root_container.found_object = container;
 402         this.test_fetch_container_run (creator);
 403         assert (action.error_code == bad_metadata.code);
 404
 405         // check DLNA.ORG_AnyContainer when root container is not searchable
 406         content_directory.root_container = new MediaContainer ();
 407         action.id = "DLNA.ORG_AnyContainer";
 408         this.test_fetch_container_run (creator);
 409         assert (action.error_code == no_such_object.code);
 410
 411         // check DLNA.ORG_AnyContainer when no writable container is found
 412         content_directory.root_container = new SearchableContainer ();
 413         this.test_fetch_container_run (creator);
 414         // We cannot distinguish this case from the "create-class doesn't match"
 415         // case
 416         assert (action.error_code == bad_metadata.code);
 417     }
 418 }