subtitle_it 1.9.0 → 2.0.0

data/spec/subtitle_it/bin_spec.rb

@@ -1,142 +1,154 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
 module BinspecHelper
-  def mock_xmlrpc(stubs={});    @mock_xmlrpc ||= mock(XMLRPC::Client, stubs);  end
-  def mock_subdown;             @mock_subdown = mock(Subdown);  end
-  def mock_file;                @mock_file = mock(File);  end
-  
+  def mock_xmlrpc(stubs = {})
+    @mock_xmlrpc ||= double(XMLRPC::Client, stubs)
+  end
+
+  def mock_subdown
+    @mock_subdown = double(Subdown)
+  end
+
+  def mock_file
+    @mock_file = double(File)
+  end
+
   def mock_movie
-    @mock_movie = mock(Movie, {:filename => "Beavis Butthead Do America.avi", 
-      :haxx => '09a2c497663259cb' })
+    @mock_movie = double(Movie, filename: 'Beavis Butthead Do America.avi',
+                                haxx: '09a2c497663259cb')
   end
-  
+
   def mock_subtitle
-    @mock_subtitle = mock(Subtitle, { 
-      :info => sub_info, :format => 'srt', :<=> => 1
-    })
+    @mock_subtitle = double(Subtitle,       :info => sub_info, :format => 'srt', :<=> => 1)
   end
-  
+
   def sub_info
-    { 
-      "SubLanguageID"   => 'eng',
-      "MovieName"       => 'Resevoir Dogs',
-      "MovieYear"       => '1992',
-      "SubFileName"     => 'Cool sub',
-      "MovieImdbRating" => '10.0',
-      "SubDownloadsCnt" => '310',
-      "SubRating"       => '9.5',
-      "SubFormat"       => 'srt',
-      "SubSumCD"        => '2',
-      "SubAuthorComment" => 'Nice nice...'
-      }
+    {
+      'SubLanguageID'   => 'eng',
+      'LanguageName'    => 'English',
+      'MovieName'       => 'Resevoir Dogs',
+      'MovieYear'       => '1992',
+      'SubFileName'     => 'Cool sub',
+      'MovieFPS'        => '29.0',
+      'MovieImdbRating' => '10.0',
+      'SubAddDate'      => '12-12-2012 00:01:01',
+      'SubDownloadsCnt' => '310',
+      'SubRating'       => '9.5',
+      'SubFormat'       => 'srt',
+      'SubSumCD'        => '2',
+      'SubAuthorComment' => 'Nice nice...'
+    }
   end
 end
 
 describe Bin do
   include BinspecHelper
-  
-  it "should require ARGV" do
-    lambda { Bin::run!(nil) }.should raise_error    
+
+  it 'should require ARGV' do
+    expect { Bin.run!(nil) }.to raise_error
   end
-  
+
   # Having a hard time testing the command line tool...
   # #
-  # 
+  #
   # it "should call for movie" do
   #   Subdownloader.should_receive(:new)
-  #   File.should_receive(:exists?).and_return(true)
+  #   File.should_receive(:exist?).and_return(true)
   #   File.should_receive(:open).and_return(mock_file)
   #   SubtitleIt::Bin::run!(["movie.avi"])
   # end
-  # 
+  #
   # it "should call for subtitle" do
   #   @subwork_mock = mock(Subwork, :run! => true)#.should_receive(:new)
   #   @subwork_mock.should_receive(:new)
   #   @subwork_mock.should_receive(:run!)
-  #   File.should_receive(:exists?).and_return(true)
+  #   File.should_receive(:exist?).and_return(true)
   #   SubtitleIt::Bin::run!(["movie.srt"])
-  # end  
+  # end
 end
-  
-describe Subdownloader do    
+
+describe Subdownloader do
   include BinspecHelper
-  
-  it "should print languages" do
-    STDOUT.should_receive(:puts).at_least(30).times 
-    SubtitleIt::Bin.print_languages    
+
+  it 'should print languages' do
+    expect(STDOUT).to receive(:puts).at_least(30).times
+    SubtitleIt::Bin.print_languages
   end
 
-  it "should download a subtitle" do
-    Movie.should_receive(:new).and_return(mock_movie)
-    Subdown.should_receive(:new).and_return(mock_subdown)#mock(Subdown))     
-       
-    STDIN.should_receive(:gets).and_return("1")    
-    STDOUT.should_receive(:puts).with("Found 2 results. Choose one:\n")
-    STDOUT.should_receive(:printf).with("Choose: ")    
-    STDOUT.should_receive(:puts).with("You can choose multiple ones, separated with spaces or a range separated with hifen.")
-    STDOUT.should_receive(:puts).with("Downloading 1 subtitles...")
-    STDOUT.should_receive(:puts).with("1) Resevoir Dogs / 1992 | Cool sub | Movie score: 10.0\n   Lang: Eng | Format: SRT | Downloads: 310 | Rating: 9.5 | CDs: 2\n   Comments: Nice nice... \n\n")    
-    STDOUT.should_receive(:puts).with("2) Resevoir Dogs / 1992 | Cool sub | Movie score: 10.0\n   Lang: Eng | Format: SRT | Downloads: 310 | Rating: 9.5 | CDs: 2\n   Comments: Nice nice... \n\n")    
-    STDOUT.should_receive(:puts).with("Done. Wrote: Beavis Butthead Do America.srt.")
-
-    File.should_receive(:open).with("Beavis Butthead Do America.srt", "w").and_return(true)     
-
-    @mock_subdown.should_receive(:log_in!).and_return(true)
-    @mock_subdown.should_receive(:download_subtitle).and_return(mock_subtitle)
-    @mock_subdown.should_receive(:search_subtitles).and_return([mock_subtitle, mock_subtitle])        
-    @mock_subdown.should_receive(:log_out!).and_return(true)    
-    
-    Subdownloader.new.run! "file.avi"        
+  it 'should download a subtitle' do
+    expect(Movie).to receive(:new).and_return(mock_movie)
+    expect(Subdown).to receive(:new).and_return(mock_subdown)
+
+    expect(STDIN).to receive(:gets).and_return('1')
+    expect(STDOUT).to receive(:puts).with(/You can choose multiple ones/)
+    expect(STDOUT).to receive(:puts).with("Found #{'2'.yellow} results:\n")
+    expect(STDOUT).to receive(:print).with(/Choose/)
+    expect(STDOUT).to receive(:puts).with("  #{'1'.yellow}. #{'Eng'.green} | #{'SRT'.blue} | #{'Resevoir Dogs'.cyan} / #{'1992'.cyan} | #{'9.5'.yellow} | FPS 29.0 | 2 CDs | 2012-12-12")
+    expect(STDOUT).to receive(:puts).with("  #{'2'.yellow}. #{'Eng'.green} | #{'SRT'.blue} | #{'Resevoir Dogs'.cyan} / #{'1992'.cyan} | #{'9.5'.yellow} | FPS 29.0 | 2 CDs | 2012-12-12")
+    expect(STDOUT).to receive(:puts).with('Downloading 1 subtitle...')
+    expect(STDOUT).to receive(:puts).with('Done: Beavis Butthead Do America.eng.srt'.yellow)
+
+    expect(File).to receive(:open).with('Beavis Butthead Do America.eng.srt', 'w').and_return(true)
+
+    expect(@mock_subdown).to receive(:log_in!).and_return(true)
+    expect(@mock_subdown).to receive(:download_subtitle).and_return(mock_subtitle)
+    expect(@mock_subdown).to receive(:search_subtitles).and_return([mock_subtitle, mock_subtitle])
+    expect(@mock_subdown).to receive(:log_out!).and_return(true)
+
+    Subdownloader.new.run! 'file.avi'
   end
-  
-  it "should get extension files" do
-    Bin.get_extension("Lots.of.dots.happen").should eql("happen")
-    lambda { Bin.get_extension("Nodotstoo") }.should raise_error
+
+  # it 'should download and convert a subtitle' do
+  #   expect(Subtitle).to receive(:new).and_return(mock_subtitle)
+  # end
+
+  it 'should get extension files' do
+    expect(Bin.get_extension('Lots.of.dots.happen')).to eql('happen')
+    expect { Bin.get_extension('Nodotstoo') }.to raise_error
   end
-  
-  it "should swap extensions" do
-    Bin.swap_extension("foo.txt", "srt").should eql("foo.srt")
+
+  it 'should swap extensions' do
+    expect(Bin.swap_extension('foo.txt', 'srt')).to eql('foo.srt')
   end
-  
-  it "should parse user input" do    
+
+  it 'should parse user input' do
     @subd = Subdownloader.new
-    @subd.parse_input("1 2-5 7 8-10 15").should eql([1, 2, 3, 4, 5, 7, 8, 9, 10, 15])    
+    expect(@subd.parse_input('1 2-5 7 8-10 15')).to eql([1, 2, 3, 4, 5, 7, 8, 9, 10, 15])
   end
 
-  it "should print choice" do
-    @sub = mock(Subtitle, :info => sub_info)
-      @subd = Subdownloader.new
-      @subd.print_option(@sub, 1).should eql("2) Resevoir Dogs / 1992 | Cool sub | Movie score: 10.0
-   Lang: Eng | Format: SRT | Downloads: 310 | Rating: 9.5 | CDs: 2
-   Comments: Nice nice... \n\n")        
+  it 'should print choice' do
+    @sub = double(Subtitle, info: sub_info)
+    @subd = Subdownloader.new
+    expect(@subd.print_option(@sub.info, 1)).
+      to eql("  #{'2'.yellow}. #{'Eng'.green} | #{'SRT'.blue} | #{'Resevoir Dogs'.cyan} / #{'1992'.cyan} | #{'9.5'.yellow} | FPS 29.0 | 2 CDs | 2012-12-12")
   end
 end
 
 describe Subwork do
   include BinspecHelper
-  
-  it "should call a new subtitle" do
-    File.should_receive(:open).with("file.srt", "r").and_return(mock_file) 
-    File.should_receive(:open).with("file.sub", "w").and_return(true)     
-
-    STDOUT.should_receive(:puts).with("Working on file file.srt...")
-    STDOUT.should_receive(:puts).with('Done. Wrote: file.sub.')
-    
-    Subtitle.should_receive(:new).and_return(mock_subtitle)
-    @mock_subtitle.should_receive(:to_sub).and_return('subbb')
-
-    Subwork.new.run!("file.srt", "sub")
+
+  it 'should call a new subtitle' do
+    expect(File).to receive(:open).with('file.srt', 'r').and_return(mock_file)
+    expect(File).to receive(:open).with('file.sub', 'w').and_return(true)
+
+    expect(STDOUT).to receive(:puts).with('Working on file file.srt...')
+    expect(STDOUT).to receive(:puts).with('Done: file.sub'.yellow)
+
+    expect(Subtitle).to receive(:new).and_return(mock_subtitle)
+    expect(@mock_subtitle).to receive(:to_sub).and_return('subbb')
+
+    Subwork.new.run!('file.srt', 'sub')
   end
-  
-  it "should not write if file exists" do
-    File.should_receive(:open).with("file.srt", "r").and_return(mock_file) 
-    File.should_receive(:exists?).and_return(true)
-
-    STDOUT.should_receive(:puts).with("Working on file file.srt...")
-    STDOUT.should_receive(:puts).with("File exists. file.sub")
-    
-    Subtitle.should_receive(:new).and_return(mock_subtitle)
-    @mock_subtitle.should_receive(:to_sub).and_return('subbb')
-    Subwork.new.run!("file.srt", "sub")
+
+  it 'should not write if file exist' do
+    expect(File).to receive(:open).with('file.srt', 'r').and_return(mock_file)
+    expect(File).to receive(:exist?).and_return(true)
+
+    expect(STDOUT).to receive(:puts).with('Working on file file.srt...')
+    expect(STDOUT).to receive(:puts).with('File exist: file.sub'.red)
+
+    expect(Subtitle).to receive(:new).and_return(mock_subtitle)
+    expect(@mock_subtitle).to receive(:to_sub).and_return('subbb')
+    Subwork.new.run!('file.srt', 'sub')
   end
 end

data/spec/subtitle_it/formats/ass_spec.rb

@@ -1,5 +1,4 @@
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
-describe Formats, ".ass" do
-
-end
+describe Formats, '.ass' do
+end

data/spec/subtitle_it/formats/mpl_spec.rb

@@ -1,45 +1,43 @@
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
-describe Formats, ".mpl" do
+describe Formats, '.mpl' do
   include SubFixtures
-  describe "In" do
-    
+  describe 'In' do
     before(:each) do
-      @mpl = Subtitle.new({:dump => mpl_fixture, :format => 'mpl'}) 
-    end  
+      @mpl = Subtitle.new(dump: mpl_fixture, format: 'mpl')
+    end
 
-    it "should parse the sub to an array" do
-      @mpl.lines.should be_instance_of(Array)
+    it 'should parse the sub to an array' do
+      expect(@mpl.lines).to be_instance_of(Array)
     end
-    
-    it "should have N lines" do
-      @mpl.should have(12).lines      
+
+    it 'should have N lines' do
+      expect(@mpl.lines.length).to eq(12)
     end
-    
-    it "should parse time of" do
-      @mpl.lines[0].time_on.to_s.should eql("00:17:05.000")
+
+    it 'should parse time of' do
+      expect(@mpl.lines[0].time_on.to_s).to eql('00:17:05.000')
     end
-    
-    it "should parse time of" do
-      @mpl.lines[0].time_off.to_s.should eql("00:18:35.000")
+
+    it 'should parse time of' do
+      expect(@mpl.lines[0].time_off.to_s).to eql('00:18:35.000')
     end
-    
-    it "should parse text" do
-      @mpl.lines[0].text.should eql("You always say that.|The same thing every time.")
+
+    it 'should parse text' do
+      expect(@mpl.lines[0].text).to eql('You always say that.|The same thing every time.')
     end
   end
-    
-  describe "Out!" do
-       
+
+  describe 'Out!' do
     before(:each) do
-      @sub = Subtitle.new({:dump => yml_fixture, :format => 'yml'}) 
-    end  
-  
-    it "should dump the object as a SRT" do
-      @sub.to_mpl.should eql("[3265][3285]worth killing for...
+      @sub = Subtitle.new(dump: yml_fixture, format: 'yml')
+    end
+
+    it 'should dump the object as a SRT' do
+      expect(@sub.to_mpl).to eql("[3265][3285]worth killing for...
 [3604][3634]worth dying for...
 [4203][4233]worth going to the hell for...
 [4203][4233]worth going a | line...\n")
     end
   end
-end
+end

data/spec/subtitle_it/formats/rsb_spec.rb

@@ -1,42 +1,41 @@
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
-describe Formats, ".rsb" do
+describe Formats, '.rsb' do
   include SubFixtures
-  describe "In" do
-    
+  describe 'In' do
     before(:each) do
-      @rsb = Subtitle.new({:dump => rsb_fixture, :format => 'rsb'}) 
-    end  
+      @rsb = Subtitle.new(dump: rsb_fixture, format: 'rsb')
+    end
+
+    it 'should parse the sub to an array' do
+      expect(@rsb.lines).to be_instance_of(Array)
+    end
 
-    it "should parse the sub to an array" do
-      @rsb.lines.should be_instance_of(Array)
+    it 'should have N lines' do
+      expect(@rsb.lines.length).to eq(3)
     end
-    
-    it "should have N lines" do
-      @rsb.should have(3).lines      
+
+    it 'should parse time of' do
+      expect(@rsb.lines[0].time_on.to_s).to eql('00:05:26.500')
     end
 
-    it "should parse time of" do
-      @rsb.lines[0].time_on.to_s.should eql("00:05:26.500")
+    it 'should parse time of' do
+      expect(@rsb.lines[0].time_off.to_s).to eql('00:05:28.500')
     end
-    
-    it "should parse time of" do
-      @rsb.lines[0].time_off.to_s.should eql("00:05:28.500")
+
+    it 'should parse text' do
+      expect(@rsb.lines[0].text).to eql('worth killing for...')
     end
-    
-    it "should parse text" do
-      @rsb.lines[0].text.should eql("worth killing for...")
-    end        
   end
-  
-  describe "Out" do
+
+  describe 'Out' do
     include SubFixtures
-    before(:each) do     
-      @sub = Subtitle.new({:dump => yml_fixture, :format => 'yml'}) 
-    end  
-      
-    it "should dump the object to rsb" do
-      @sub.to_rsb.should eql("- title: sincity\n- authors: \n- version: 1.1\n00:05:26.500 => 00:05:28.500 == worth killing for...\n00:06:00.400 => 00:06:03.400 == worth dying for...\n00:07:00.300 => 00:07:03.300 == worth going to the hell for...\n00:07:00.300 => 00:07:03.300 == worth going a | line...\n")
-    end
-  end  
-end
+    before(:each) do
+      @sub = Subtitle.new(dump: yml_fixture, format: 'yml')
+    end
+
+    it 'should dump the object to rsb' do
+      expect(@sub.to_rsb).to eql("- title: sincity\n- authors: \n- version: 1.1\n00:05:26.500 => 00:05:28.500 == worth killing for...\n00:06:00.400 => 00:06:03.400 == worth dying for...\n00:07:00.300 => 00:07:03.300 == worth going to the hell for...\n00:07:00.300 => 00:07:03.300 == worth going a | line...\n")
+    end
+  end
+end

data/spec/subtitle_it/formats/srt_spec.rb

@@ -1,42 +1,40 @@
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
-describe Formats, ".srt" do
+describe Formats, '.srt' do
   include SubFixtures
-  describe "In" do
-    
+  describe 'In' do
     before(:each) do
-      @srt = Subtitle.new({:dump => srt_fixture, :format => 'srt'}) 
-    end  
+      @srt = Subtitle.new(dump: srt_fixture, format: 'srt')
+    end
 
-    it "should parse the sub to an array" do
-      @srt.lines.should be_instance_of(Array)
+    it 'should parse the sub to an array' do
+      expect(@srt.lines).to be_instance_of(Array)
     end
-    
-    it "should have N lines" do
-      @srt.should have(543).lines      
+
+    it 'should have N lines' do
+      expect(@srt.lines.length).to eq(543)
     end
-    
-    it "should parse time of" do
-      @srt.lines[0].time_on.to_s.should eql("00:01:43.680")
+
+    it 'should parse time of' do
+      expect(@srt.lines[0].time_on.to_s).to eql('00:01:43.680')
     end
-    
-    it "should parse time of" do
-      @srt.lines[0].time_off.to_s.should eql("00:01:45.557")
+
+    it 'should parse time of' do
+      expect(@srt.lines[0].time_off.to_s).to eql('00:01:45.557')
     end
-    
-    it "should parse text" do
-      @srt.lines[0].text.should eql("My dear children,")
+
+    it 'should parse text' do
+      expect(@srt.lines[0].text).to eql('My dear children,')
     end
   end
-    
-  describe "Out!" do
-       
+
+  describe 'Out!' do
     before(:each) do
-      @sub = Subtitle.new({:dump => yml_fixture, :format => 'yml'}) 
-    end  
-  
-    it "should dump the object as a SRT" do
-      @sub.to_srt.should eql("1
+      @sub = Subtitle.new(dump: yml_fixture, format: 'yml')
+    end
+
+    it 'should dump the object as a SRT' do
+      expect(@sub.to_srt).to eql("1
 00:05:26,500 --> 00:05:28,500
 worth killing for...
 
@@ -50,8 +48,7 @@ worth going to the hell for...
 
 4
 00:07:00,300 --> 00:07:03,300
-worth going a 
- line...\n")
+worth going a \n line...\n")
     end
   end
-end
+end

data/spec/subtitle_it/formats/sub_spec.rb

@@ -1,46 +1,44 @@
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
-describe Formats, ".sub" do
+describe Formats, '.sub' do
   include SubFixtures
-  describe "Parse" do
-
+  describe 'Parse' do
     before(:each) do
-      @sub = Subtitle.new({:dump => sub_fixture, :format => 'sub'})
+      @sub = Subtitle.new(dump: sub_fixture, format: 'sub')
     end
 
-    it "should parse the sub to an array" do
-      @sub.lines.should be_instance_of(Array)
+    it 'should parse the sub to an array' do
+      expect(@sub.lines).to be_instance_of(Array)
     end
 
-    it "should have N lines" do
-      @sub.should have(2025).lines
+    it 'should have N lines' do
+      expect(@sub.lines.length).to eq(2025)
     end
 
-    it "should have a nic text on" do
-      @sub.lines[110].time_on.to_s.should eql('00:10:44.936')
+    it 'should have a nic text on' do
+      expect(@sub.lines[110].time_on.to_s).to eql('00:10:44.936')
     end
 
-    it "should have a nice text out" do
-      @sub.lines[110].time_off.to_s.should eql('00:10:49.941')
+    it 'should have a nice text out' do
+      expect(@sub.lines[110].time_off.to_s).to eql('00:10:49.941')
     end
 
-    it "should parse the sentece correctly" do
-      @sub.lines[0].text.should eql("You always say that.|The same thing every time.")
+    it 'should parse the sentece correctly' do
+      expect(@sub.lines[0].text).to eql('You always say that.|The same thing every time.')
     end
 
-    it "should parse the sentece correctly" do
-      @sub.lines[2020].text.should eql("I'm tryin' real hard...")
+    it 'should parse the sentece correctly' do
+      expect(@sub.lines[2020].text).to eql("I'm tryin' real hard...")
     end
   end
 
-  describe "Out" do
-
+  describe 'Out' do
     before(:each) do
-      @sub = Subtitle.new({:dump => yml_fixture, :format => 'yml'})
+      @sub = Subtitle.new(dump: yml_fixture, format: 'yml')
     end
 
-    it "should dump the object as a SUB" do
-      @sub.to_sub.should eql("{7816}{7864}worth killing for...
+    it 'should dump the object as a SUB' do
+      expect(@sub.to_sub).to eql("{7816}{7864}worth killing for...
 {8631}{8703}worth dying for...
 {10069}{10141}worth going to the hell for...
 {10069}{10141}worth going a | line...\n")

data/spec/subtitle_it/formats/xml_spec.rb

@@ -1,46 +1,46 @@
 require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 
-describe Formats, ".xml" do
+describe Formats, '.xml' do
   include SubFixtures
-  describe "In" do
+  describe 'In' do
     before(:each) do
-      @xml = Subtitle.new({:dump => xml_fixture, :format => 'xml'})
+      @xml = Subtitle.new(dump: xml_fixture, format: 'xml')
     end
 
-    it "should parse the sub to an array" do
-      @xml.lines.should be_instance_of(Array)
+    it 'should parse the sub to an array' do
+      expect(@xml.lines).to be_instance_of(Array)
     end
 
-    it "should have N lines" do
-      @xml.should have(13).lines
+    it 'should have N lines' do
+      expect(@xml.lines.length).to eq(13)
     end
 
-    it "should parse time of" do
-      @xml.lines[0].time_on.to_s.should eql("00:00:00.000")
-      @xml.lines[10].time_on.to_s.should eql("00:00:25.520")
+    it 'should parse time of' do
+      expect(@xml.lines[0].time_on.to_s).to eql('00:00:00.000')
+      expect(@xml.lines[10].time_on.to_s).to eql('00:00:25.520')
     end
 
-    it "should parse time of" do
-      @xml.lines[0].time_off.to_s.should eql("00:00:03.700")
-      @xml.lines[10].time_off.to_s.should eql("00:00:27.520")
+    it 'should parse time of' do
+      expect(@xml.lines[0].time_off.to_s).to eql('00:00:03.700')
+      expect(@xml.lines[10].time_off.to_s).to eql('00:00:27.520')
     end
 
-    it "should parse text" do
-      @xml.lines[0].text.should eql("I had just joined <span tts:fontFamily=\"monospaceSansSerif,proportionalSerif,TheOther\" tts:fontSize=\"+2\">Macromedia</span> in 1996,")
+    it 'should parse text' do
+      expect(@xml.lines[0].text).to eql("I had just joined <span tts:fontFamily=\"monospaceSansSerif,proportionalSerif,TheOther\" tts:fontSize=\"+2\">Macromedia</span> in 1996,")
     end
   end
 
-  describe "Out" do
+  describe 'Out' do
     before(:each) do
-      @sub = Subtitle.new({:dump => yml_fixture, :format => 'yml'})
+      @sub = Subtitle.new(dump: yml_fixture, format: 'yml')
     end
 
-    it "should parse the sub to an array" do
-      @sub.to_xml.should be_instance_of(String)
+    it 'should parse the sub to an array' do
+      expect(@sub.to_xml).to be_instance_of(String)
     end
 
-    it "should equal..." do
-      @sub.to_xml.should eql("<?xml version=\"1.0\" encoding=\"UTF-8\"?>
+    it 'should equal...' do
+      expect(@sub.to_xml).to eql("<?xml version=\"1.0\" encoding=\"UTF-8\"?>
 <tt xml:lang=\"en\" xmlns=\"http://www.w3.org/2006/10/ttaf1\"  xmlns:tts=\"http://www.w3.org/2006/10/ttaf1#styling\">
   <head>
     <styling>