m3u8 0.7.1 → 0.8.0

data/spec/lib/m3u8/playlist_spec.rb

@@ -8,233 +8,254 @@ describe M3u8::Playlist do
     it 'initializes with defaults' do
       expect(playlist.version).to be_nil
       expect(playlist.cache).to be_nil
-      expect(playlist.target).to be 10
-      expect(playlist.sequence).to be 0
+      expect(playlist.target).to eq(10)
+      expect(playlist.sequence).to eq(0)
+      expect(playlist.discontinuity_sequence).to be_nil
       expect(playlist.type).to be_nil
       expect(playlist.iframes_only).to be false
       expect(playlist.independent_segments).to be false
     end
 
-    it 'initializes from hash' do
+    it 'initializes from options' do
       options = { version: 7, cache: false, target: 12, sequence: 1,
-                  type: 'VOD', independent_segments: true }
-      playlist = M3u8::Playlist.new(options)
-      expect(playlist.version).to be 7
+                  discontinuity_sequence: 2, type: 'VOD',
+                  independent_segments: true }
+      playlist = described_class.new(options)
+      expect(playlist.version).to eq(7)
       expect(playlist.cache).to be false
-      expect(playlist.target).to be 12
-      expect(playlist.sequence).to be 1
+      expect(playlist.target).to eq(12)
+      expect(playlist.sequence).to eq(1)
+      expect(playlist.discontinuity_sequence).to eq(2)
       expect(playlist.type).to eq('VOD')
       expect(playlist.iframes_only).to be false
       expect(playlist.independent_segments).to be true
     end
+
+    it 'initializes as master playlist' do
+      playlist = described_class.new(master: true)
+      expect(playlist.master?).to be true
+    end
   end
 
-  it 'should generate codecs string' do
-    options = { profile: 'baseline', level: 3.0, audio_codec: 'aac-lc' }
-    codecs = M3u8::Playlist.codecs options
-    expect(codecs).to eq 'avc1.66.30,mp4a.40.2'
+  describe '.codecs' do
+    it 'generates codecs string' do
+      options = { profile: 'baseline', level: 3.0, audio_codec: 'aac-lc' }
+      codecs = described_class.codecs(options)
+      expect(codecs).to eq('avc1.66.30,mp4a.40.2')
+    end
   end
 
-  it 'should render master playlist' do
-    options = { uri: 'playlist_url', bandwidth: 6400,
-                audio_codec: 'mp3' }
-    item = M3u8::PlaylistItem.new options
-    playlist = M3u8::Playlist.new(independent_segments: true)
-    playlist.items << item
-
-    output = "#EXTM3U\n" \
-             "#EXT-X-INDEPENDENT-SEGMENTS\n" +
-             %(#EXT-X-STREAM-INF:CODECS="mp4a.40.34") +
-             ",BANDWIDTH=6400\nplaylist_url\n"
-    expect(playlist.to_s).to eq output
-
-    options = { program_id: '1', uri: 'playlist_url', bandwidth: 6400,
-                audio_codec: 'mp3' }
-    item = M3u8::PlaylistItem.new options
-    playlist = M3u8::Playlist.new
-    playlist.items << item
-
-    output = "#EXTM3U\n" +
-             %(#EXT-X-STREAM-INF:PROGRAM-ID=1,CODECS="mp4a.40.34") +
-             ",BANDWIDTH=6400\nplaylist_url\n"
-    expect(playlist.to_s).to eq output
-
-    options = { program_id: '2', uri: 'playlist_url', bandwidth: 50_000,
-                width: 1920, height: 1080, profile: 'high', level: 4.1,
-                audio_codec: 'aac-lc' }
-    item = M3u8::PlaylistItem.new options
-    playlist = M3u8::Playlist.new
-    playlist.items << item
-
-    output = "#EXTM3U\n" \
-             '#EXT-X-STREAM-INF:PROGRAM-ID=2,RESOLUTION=1920x1080,' +
-             %(CODECS="avc1.640029,mp4a.40.2",BANDWIDTH=50000\n) +
-             "playlist_url\n"
-
-    expect(playlist.to_s).to eq output
-
-    playlist = M3u8::Playlist.new
-    options = { program_id: '1', uri: 'playlist_url', bandwidth: 6400,
-                audio_codec: 'mp3' }
-    item = M3u8::PlaylistItem.new options
-    playlist.items << item
-    options = { program_id: '2', uri: 'playlist_url', bandwidth: 50_000,
-                width: 1920, height: 1080, profile: 'high', level: 4.1,
-                audio_codec: 'aac-lc' }
-    item = M3u8::PlaylistItem.new options
-    playlist.items << item
-
-    output = "#EXTM3U\n" +
-             %(#EXT-X-STREAM-INF:PROGRAM-ID=1,CODECS="mp4a.40.34") +
-             ",BANDWIDTH=6400\nplaylist_url\n#EXT-X-STREAM-INF:PROGRAM-ID=2," +
-             %(RESOLUTION=1920x1080,CODECS="avc1.640029,mp4a.40.2") +
-             ",BANDWIDTH=50000\nplaylist_url\n"
-    expect(playlist.to_s).to eq output
+  describe '.read' do
+    it 'returns new playlist from content' do
+      file = File.open('spec/fixtures/master.m3u8')
+      playlist = described_class.read(file)
+      expect(playlist.master?).to be true
+      expect(playlist.items.size).to eq(8)
+    end
   end
 
-  it 'should render playlist' do
-    options = { duration: 11.344644, segment: '1080-7mbps00000.ts' }
-    item =  M3u8::SegmentItem.new(options)
-    playlist = M3u8::Playlist.new
-    playlist.items << item
-
-    output = "#EXTM3U\n" \
-      "#EXT-X-MEDIA-SEQUENCE:0\n" \
-      "#EXT-X-TARGETDURATION:10\n" \
-      "#EXTINF:11.344644,\n" \
-      "1080-7mbps00000.ts\n" \
-      "#EXT-X-ENDLIST\n"
-    expect(playlist.to_s).to eq output
-
-    options = { duration: 11.261233, segment: '1080-7mbps00001.ts' }
-    item =  M3u8::SegmentItem.new(options)
-    playlist.items << item
-
-    output = "#EXTM3U\n" \
-      "#EXT-X-MEDIA-SEQUENCE:0\n" \
-      "#EXT-X-TARGETDURATION:10\n" \
-      "#EXTINF:11.344644,\n" \
-      "1080-7mbps00000.ts\n" \
-      "#EXTINF:11.261233,\n" \
-      "1080-7mbps00001.ts\n" \
-      "#EXT-X-ENDLIST\n"
-    expect(playlist.to_s).to eq output
-
-    options = { version: 7, cache: false, target: 12, sequence: 1,
-                type: 'VOD' }
-    playlist = M3u8::Playlist.new options
-    options = { duration: 11.344644, segment: '1080-7mbps00000.ts' }
-    item =  M3u8::SegmentItem.new options
-    playlist.items << item
-
-    output = "#EXTM3U\n" \
-      "#EXT-X-PLAYLIST-TYPE:VOD\n" \
-      "#EXT-X-VERSION:7\n" \
-      "#EXT-X-MEDIA-SEQUENCE:1\n" \
-      "#EXT-X-ALLOW-CACHE:NO\n" \
-      "#EXT-X-TARGETDURATION:12\n" \
-      "#EXTINF:11.344644,\n" \
-      "1080-7mbps00000.ts\n" \
-      "#EXT-X-ENDLIST\n"
-
-    expect(playlist.to_s).to eq output
+  describe '#duration' do
+    it 'should return the total duration of a playlist' do
+      item = M3u8::SegmentItem.new(duration: 10.991, segment: 'test_01.ts')
+      playlist.items << item
+      item = M3u8::SegmentItem.new(duration: 9.891, segment: 'test_02.ts')
+      playlist.items << item
+      item = M3u8::SegmentItem.new(duration: 10.556, segment: 'test_03.ts')
+      playlist.items << item
+      item = M3u8::SegmentItem.new(duration: 8.790, segment: 'test_04.ts')
+      playlist.items << item
+
+      expect(playlist.duration.round(3)).to eq(40.228)
+    end
   end
 
-  it 'should write playlist to io' do
-    test_io = StringIO.new
-    playlist = M3u8::Playlist.new
-    options = { program_id: '1', uri: 'playlist_url', bandwidth: 6400,
-                audio_codec: 'mp3' }
-    item = M3u8::PlaylistItem.new options
-    playlist.items << item
-    playlist.write test_io
+  describe '#master?' do
+    context 'when playlist is a master playlist' do
+      it 'returns true' do
+        options = { program_id: '1', uri: 'playlist_url', bandwidth: 6400,
+                    audio_codec: 'mp3' }
+        item = M3u8::PlaylistItem.new(options)
+        playlist.items << item
 
-    output = "#EXTM3U\n" +
-             %(#EXT-X-STREAM-INF:PROGRAM-ID=1,CODECS="mp4a.40.34",) +
-             "BANDWIDTH=6400\nplaylist_url\n"
+        expect(playlist.master?).to be true
+      end
+    end
 
-    expect(test_io.string).to eq output
+    context 'when playlist is a media playlist' do
+      it 'returns false' do
+        item = M3u8::SegmentItem.new(duration: 10.991, segment: 'test_01.ts')
+        playlist.items << item
+        expect(playlist.master?).to be false
+      end
+    end
 
-    test_io = StringIO.new
-    playlist.write test_io
+    context 'when playlist is a new playlist' do
+      it 'returns false' do
+        expect(playlist.master?).to be false
+      end
+    end
 
-    output = "#EXTM3U\n" +
-             %(#EXT-X-STREAM-INF:PROGRAM-ID=1,CODECS="mp4a.40.34",) +
-             "BANDWIDTH=6400\nplaylist_url\n"
+    context 'when a new playlist is set as master' do
+      it 'returns true' do
+        playlist = described_class.new(master: true)
+        expect(playlist.master?).to be true
+      end
+    end
 
-    expect(test_io.string).to eq output
+    context 'when a new playlist is set as not master' do
+      it 'returns false' do
+        playlist = described_class.new(master: false)
+        expect(playlist.master?).to be false
+      end
+    end
   end
 
-  it 'should report if it is a master playlist' do
-    playlist = M3u8::Playlist.new
-    expect(playlist.master?).to be false
-    options = { program_id: '1', uri: 'playlist_url', bandwidth: 6400,
-                audio_codec: 'mp3' }
-    item = M3u8::PlaylistItem.new options
-    playlist.items << item
+  describe '#live?' do
+    context 'when playlist is a master playlist' do
+      it 'returns false' do
+        options = { program_id: '1', uri: 'playlist_url', bandwidth: 6400,
+                    audio_codec: 'mp3' }
+        item = M3u8::PlaylistItem.new(options)
+        playlist.items << item
 
-    expect(playlist.master?).to be true
-  end
-
-  it 'should raise error on write if item types are mixed' do
-    playlist = M3u8::Playlist.new
+        expect(playlist.live).to be false
+      end
+    end
 
-    hash = { program_id: 1, width: 1920, height: 1080, codecs: 'avc',
-             bandwidth: 540, uri: 'test.url' }
-    item = M3u8::PlaylistItem.new(hash)
-    playlist.items << item
+    context 'when playlist is a media playlist and set as live' do
+      it 'returns true' do
+        playlist = described_class.new(live: true)
+        item = M3u8::SegmentItem.new(duration: 10.991, segment: 'test_01.ts')
+        playlist.items << item
+        expect(playlist.live?).to be true
+      end
+    end
 
-    hash = { duration: 10.991, segment: 'test.ts' }
-    item = M3u8::SegmentItem.new(hash)
-    playlist.items << item
+    context 'when a new playlist is set as not live' do
+      it 'returns false' do
+        playlist = described_class.new(live: false)
+        expect(playlist.live).to be false
+      end
+    end
 
-    message = 'Playlist is invalid.'
-    io = StringIO.new
-    expect { playlist.write io }
-      .to raise_error(M3u8::PlaylistTypeError, message)
+    context 'when playlist is a new playlist' do
+      it 'returns false' do
+        expect(playlist.live?).to be false
+      end
+    end
   end
 
-  it 'should return valid status' do
-    playlist = M3u8::Playlist.new
-    expect(playlist.valid?).to be true
-
-    hash = { program_id: 1, width: 1920, height: 1080, codecs: 'avc',
-             bandwidth: 540, uri: 'test.url' }
-    item = M3u8::PlaylistItem.new(hash)
-    playlist.items << item
-    expect(playlist.valid?).to be true
+  describe '#to_s' do
+    it 'returns master playlist text' do
+      options = { program_id: '1', uri: 'playlist_url', bandwidth: 6400,
+                  audio_codec: 'mp3' }
+      item = M3u8::PlaylistItem.new(options)
+      playlist.items << item
+
+      options = { program_id: '2', uri: 'playlist_url', bandwidth: 50_000,
+                  width: 1920, height: 1080, profile: 'high', level: 4.1,
+                  audio_codec: 'aac-lc' }
+      item = M3u8::PlaylistItem.new(options)
+      playlist.items << item
+
+      expected = "#EXTM3U\n" +
+                 %(#EXT-X-STREAM-INF:PROGRAM-ID=1,CODECS="mp4a.40.34") +
+                 ",BANDWIDTH=6400\nplaylist_url\n" \
+                 '#EXT-X-STREAM-INF:PROGRAM-ID=2,' +
+                 %(RESOLUTION=1920x1080,CODECS="avc1.640029,mp4a.40.2") +
+                 ",BANDWIDTH=50000\nplaylist_url\n"
+      expect(playlist.to_s).to eq(expected)
+    end
 
-    hash = { program_id: 1, width: 1920, height: 1080, codecs: 'avc',
-             bandwidth: 540, uri: 'test.url' }
-    item = M3u8::PlaylistItem.new(hash)
-    playlist.items << item
-    expect(playlist.valid?).to be true
+    it 'returns media playlist text' do
+      options = { duration: 11.344644, segment: '1080-7mbps00000.ts' }
+      item =  M3u8::SegmentItem.new(options)
+      playlist.items << item
+
+      options = { duration: 11.261233, segment: '1080-7mbps00001.ts' }
+      item =  M3u8::SegmentItem.new(options)
+      playlist.items << item
+
+      expected = "#EXTM3U\n" \
+        "#EXT-X-MEDIA-SEQUENCE:0\n" \
+        "#EXT-X-TARGETDURATION:10\n" \
+        "#EXTINF:11.344644,\n" \
+        "1080-7mbps00000.ts\n" \
+        "#EXTINF:11.261233,\n" \
+        "1080-7mbps00001.ts\n" \
+        "#EXT-X-ENDLIST\n"
+      expect(playlist.to_s).to eq(expected)
+    end
+  end
 
-    hash = { duration: 10.991, segment: 'test.ts' }
-    item = M3u8::SegmentItem.new(hash)
-    playlist.items << item
+  describe '#valid?' do
+    context 'when playlist is valid' do
+      it 'returns true' do
+        expect(playlist.valid?).to be true
+
+        options = { program_id: 1, width: 1920, height: 1080, codecs: 'avc',
+                    bandwidth: 540, uri: 'test.url' }
+        item = M3u8::PlaylistItem.new(options)
+        playlist.items << item
+        expect(playlist.valid?).to be true
+
+        options = { program_id: 1, width: 1920, height: 1080, codecs: 'avc',
+                    bandwidth: 540, uri: 'test.url' }
+        item = M3u8::PlaylistItem.new(options)
+        playlist.items << item
+        expect(playlist.valid?).to be true
+      end
+    end
 
-    expect(playlist.valid?).to be false
+    context 'when playlist is invalid' do
+      it 'returns false' do
+        options = { program_id: 1, width: 1920, height: 1080, codecs: 'avc',
+                    bandwidth: 540, uri: 'test.url' }
+        item = M3u8::PlaylistItem.new(options)
+        playlist.items << item
+        expect(playlist.valid?).to be true
+
+        options = { duration: 10.991, segment: 'test.ts' }
+        item = M3u8::SegmentItem.new(options)
+        playlist.items << item
+        expect(playlist.valid?).to be false
+      end
+    end
   end
 
-  it 'should allow reading of playlists' do
-    file = File.open 'spec/fixtures/master.m3u8'
-    playlist = M3u8::Playlist.read file
-    expect(playlist.master?).to be true
-    expect(playlist.items.size).to eq(8)
-  end
+  describe '#write' do
+    context 'when playlist is valid' do
+      it 'returns playlist text' do
+        options = { program_id: '1', uri: 'playlist_url', bandwidth: 6400,
+                    audio_codec: 'mp3' }
+        item = M3u8::PlaylistItem.new(options)
+        playlist.items << item
+
+        io = StringIO.new
+        playlist.write(io)
+        expected = "#EXTM3U\n" +
+                   %(#EXT-X-STREAM-INF:PROGRAM-ID=1,CODECS="mp4a.40.34",) +
+                   "BANDWIDTH=6400\nplaylist_url\n"
+        expect(io.string).to eq(expected)
+      end
+    end
 
-  it 'should return the total duration of a playlist' do
-    playlist = M3u8::Playlist.new
-    item = M3u8::SegmentItem.new(duration: 10.991, segment: 'test_01.ts')
-    playlist.items << item
-    item = M3u8::SegmentItem.new(duration: 9.891, segment: 'test_02.ts')
-    playlist.items << item
-    item = M3u8::SegmentItem.new(duration: 10.556, segment: 'test_03.ts')
-    playlist.items << item
-    item = M3u8::SegmentItem.new(duration: 8.790, segment: 'test_04.ts')
-    playlist.items << item
-
-    expect(playlist.duration.round(3)).to eq(40.228)
+    context 'when item types are invalid' do
+      it 'raises error' do
+        options = { program_id: 1, width: 1920, height: 1080, codecs: 'avc',
+                    bandwidth: 540, uri: 'test.url' }
+        item = M3u8::PlaylistItem.new(options)
+        playlist.items << item
+
+        options = { duration: 10.991, segment: 'test.ts' }
+        item = M3u8::SegmentItem.new(options)
+        playlist.items << item
+
+        message = 'Playlist is invalid.'
+        io = StringIO.new
+        expect { playlist.write(io) }
+          .to raise_error(M3u8::PlaylistTypeError, message)
+      end
+    end
   end
 end

data/spec/lib/m3u8/reader_spec.rb

@@ -2,13 +2,15 @@
 require 'spec_helper'
 
 describe M3u8::Reader do
+  let(:reader) { described_class.new }
+
   describe '#read' do
-    it 'should parse master playlist' do
+    it 'parses master playlist' do
       file = File.open('spec/fixtures/master.m3u8')
       reader = M3u8::Reader.new
       playlist = reader.read(file)
       expect(playlist.master?).to be true
-
+      expect(playlist.discontinuity_sequence).to be_nil
       expect(playlist.independent_segments).to be true
 
       item = playlist.items[0]
@@ -50,7 +52,7 @@ describe M3u8::Reader do
       expect(item.resolution).to be_nil
     end
 
-    it 'should parse master playlist with I-Frames' do
+    it 'parses master playlist with I-Frames' do
       file = File.open('spec/fixtures/master_iframes.m3u8')
       reader = M3u8::Reader.new
       playlist = reader.read(file)
@@ -65,13 +67,14 @@ describe M3u8::Reader do
       expect(item.uri).to eq('low/iframe.m3u8')
     end
 
-    it 'should parse segment playlist' do
+    it 'parses media playlist' do
       file = File.open('spec/fixtures/playlist.m3u8')
       reader = M3u8::Reader.new
       playlist = reader.read(file)
       expect(playlist.master?).to be false
       expect(playlist.version).to eq(4)
       expect(playlist.sequence).to eq(1)
+      expect(playlist.discontinuity_sequence).to eq(8)
       expect(playlist.cache).to be false
       expect(playlist.target).to eq(12)
       expect(playlist.type).to eq('VOD')
@@ -88,7 +91,7 @@ describe M3u8::Reader do
       expect(playlist.items.size).to eq(140)
     end
 
-    it 'should parse I-Frame playlist' do
+    it 'parses I-Frame playlist' do
       file = File.open('spec/fixtures/iframes.m3u8')
       reader = M3u8::Reader.new
       playlist = reader.read(file)
@@ -108,7 +111,7 @@ describe M3u8::Reader do
       expect(item.byterange.start).to be_nil
     end
 
-    it 'should parse segment playlist with comments' do
+    it 'parses segment playlist with comments' do
       file = File.open('spec/fixtures/playlist_with_comments.m3u8')
       reader = M3u8::Reader.new
       playlist = reader.read(file)
@@ -130,7 +133,7 @@ describe M3u8::Reader do
       expect(playlist.items.size).to eq(139)
     end
 
-    it 'should parse variant playlist with audio options and groups' do
+    it 'parses variant playlist with audio options and groups' do
       file = File.open('spec/fixtures/variant_audio.m3u8')
       reader = M3u8::Reader.new
       playlist = reader.read(file)
@@ -151,7 +154,7 @@ describe M3u8::Reader do
       expect(item.forced).to be true
     end
 
-    it 'should parse variant playlist with camera angles' do
+    it 'parses variant playlist with camera angles' do
       file = File.open('spec/fixtures/variant_angles.m3u8')
       reader = M3u8::Reader.new
       playlist = reader.read(file)
@@ -177,7 +180,7 @@ describe M3u8::Reader do
       expect(item.subtitles).to eq('subs')
     end
 
-    it 'should process multiple reads as separate playlists' do
+    it 'processes multiple reads as separate playlists' do
       file = File.open('spec/fixtures/master.m3u8')
       reader = M3u8::Reader.new
       playlist = reader.read(file)
@@ -190,7 +193,7 @@ describe M3u8::Reader do
       expect(playlist.items.size).to eq(8)
     end
 
-    it 'should parse playlist with session data' do
+    it 'parses playlist with session data' do
       file = File.open('spec/fixtures/session_data.m3u8')
       reader = M3u8::Reader.new
       playlist = reader.read(file)
@@ -203,7 +206,7 @@ describe M3u8::Reader do
       expect(item.uri).to eq('lyrics.json')
     end
 
-    it 'should parse encrypted playlist' do
+    it 'parses encrypted playlist' do
       file = File.open('spec/fixtures/encrypted.m3u8')
       reader = M3u8::Reader.new
       playlist = reader.read(file)
@@ -216,7 +219,7 @@ describe M3u8::Reader do
       expect(item.uri).to eq('https://priv.example.com/key.php?r=52')
     end
 
-    it 'should parse map (media intialization section) playlists' do
+    it 'parses map (media intialization section) playlists' do
       file = File.open('spec/fixtures/map_playlist.m3u8')
       reader = M3u8::Reader.new
       playlist = reader.read(file)
@@ -230,7 +233,7 @@ describe M3u8::Reader do
       expect(item.byterange.start).to eq(600)
     end
 
-    it 'should read segment with timestamp' do
+    it 'reads segment with timestamp' do
       file = File.open('spec/fixtures/timestamp_playlist.m3u8')
       reader = M3u8::Reader.new
       playlist = reader.read(file)
@@ -241,18 +244,25 @@ describe M3u8::Reader do
       expect(item_date_time.time).to eq(Time.iso8601('2016-04-11T15:24:31Z'))
     end
 
-    context 'playlist with daterange' do
-      it 'parses playlist' do
-        file = File.open('spec/fixtures/date_range_scte35.m3u8')
-        reader = M3u8::Reader.new
-        playlist = reader.read(file)
-        expect(playlist.items.count).to eq(5)
+    it 'parses playlist with daterange' do
+      file = File.open('spec/fixtures/date_range_scte35.m3u8')
+      reader = M3u8::Reader.new
+      playlist = reader.read(file)
+      expect(playlist.items.count).to eq(5)
+
+      item = playlist.items[0]
+      expect(item).to be_a(M3u8::DateRangeItem)
 
-        item = playlist.items[0]
-        expect(item).to be_a(M3u8::DateRangeItem)
+      item = playlist.items[4]
+      expect(item).to be_a(M3u8::DateRangeItem)
+    end
 
-        item = playlist.items[4]
-        expect(item).to be_a(M3u8::DateRangeItem)
+    context 'when playlist source is invalid' do
+      it 'raises error with message' do
+        message = 'Playlist must start with a #EXTM3U tag, line read ' \
+          'contained the value: /path/to/file'
+        expect { reader.read('/path/to/file') }
+          .to raise_error(M3u8::InvalidPlaylistError, message)
       end
     end
   end