cultome_player 2.0.0 → 2.0.2

data/spec/cultome_player/player/interface/extended/show_spec.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
-
-describe CultomePlayer::Player::Interface::Extended do
-  let(:t){ TestClass.new }
-  context 'when no playlist is active and no parameters' do
-    it 'shows a message saying so, and giving instructions to play' do
-      r = t.execute 'show'
-      r.message.should eq "Nothing to show yet. Try with 'play' first."
-    end
-  end
-
-  context 'with and active playlist and playback' do
-    before :each do
-      t.execute "connect '#{test_folder}' => test"
-      t.execute 'play'
-    end
-
-    it 'without parameters shows the current song' do
-      r = t.execute 'show'
-      r.message.should match /^:::: Song: .+? (\\ Artist: .+? \\ Album: .+? )?::::$/
-      r.message.should match /[\d]{2}:[\d]{2} \|[#_]+?\| [\d]{2}:[\d]{2}/
-    end
-
-    context 'with object parameter' do
-      it 'library' do
-        r = t.execute 'show @library'
-        r.list.should_not be_empty
-      end
-
-      it 'song' do
-        r = t.execute 'show @song'
-        r.message.should match /:::: Song: .+? (\\ Artist: .+? )?(\\ Album: .+? )?::::\n?/
-      end
-    end
-  end
-end

data/spec/cultome_player/player/interface/extended/shuffle_spec.rb

@@ -1,26 +0,0 @@
-require 'spec_helper'
-
-describe CultomePlayer::Player::Interface::Extended do
-  let(:t){ TestClass.new }
-
-  context '#shuffle' do
-    it 'check shuffle status' do
-      r = t.execute('shuffle')
-      r.message.should eq "No shuffling"
-      r.shuffling.should be_false
-    end
-
-    it 'turn on the shuffle' do
-      t.should_not be_shuffling
-      t.execute('shuffle on')
-      t.should be_shuffling
-    end
-
-    it 'turn off shuffle' do
-      t.execute('shuffle on')
-      t.should be_shuffling
-      t.execute('shuffle off')
-      t.should_not be_shuffling
-    end
-  end
-end

data/spec/cultome_player/player/interface/extended_spec.rb

@@ -1,136 +0,0 @@
-require 'spec_helper'
-
-describe CultomePlayer::Player::Interface::Extended do
-  let(:t){ TestClass.new }
-
-  it 'repeats a song from the beginning' do
-  	t.should_receive(:send_to_player).with(/^jump 0$/)
-  	t.repeat(nil)
-  end
-
-	describe 'search' do
-    it 'respond to description_search' do
-      t.should respond_to(:description_search)
-    end
-
-    it 'respond to usage_search' do
-      t.should respond_to(:usage_search)
-    end
-
-    it 'respond with Response object' do
-      t.execute("search on").should be_instance_of Response
-    end
-	end
-
-	describe 'show' do
-    it 'respond to description_show' do
-      t.should respond_to(:description_show)
-    end
-
-    it 'respond to usage_show' do
-      t.should respond_to(:usage_show)
-    end
-
-    it 'respond with Response object' do
-      t.execute("show").should be_instance_of Response
-    end
-	end
-
-	describe 'enqueue' do
-    it 'respond to description_enqueue' do
-      t.should respond_to(:description_enqueue)
-    end
-
-    it 'respond to usage_enqueue' do
-      t.should respond_to(:usage_enqueue)
-    end
-
-    it 'respond with Response object' do
-      t.execute("enqueue on").should be_instance_of Response
-    end
-	end
-
-	describe 'shuffle' do
-    it 'respond to description_shuffle' do
-      t.should respond_to(:description_shuffle)
-    end
-
-    it 'respond to usage_shuffle' do
-      t.should respond_to(:usage_shuffle)
-    end
-
-    it 'respond with Response object' do
-      t.execute("shuffle on").should be_instance_of Response
-    end
-	end
-
-	describe 'connect' do
-    it 'respond to description_connect' do
-      t.should respond_to(:description_connect)
-    end
-
-    it 'respond to usage_connect' do
-      t.should respond_to(:usage_connect)
-    end
-
-    it 'respond with Response object' do
-      t.execute("connect drive").should be_instance_of Response
-    end
-	end
-
-	describe 'disconnect' do
-    it 'respond to description_disconnect' do
-      t.should respond_to(:description_disconnect)
-    end
-
-    it 'respond to usage_disconnect' do
-      t.should respond_to(:usage_disconnect)
-    end
-
-    it 'respond with Response object' do
-      t.execute("disconnect drive").should be_instance_of Response
-    end
-	end
-
-	describe 'ff' do
-    it 'respond to description_ff' do
-      t.should respond_to(:description_ff)
-    end
-
-    it 'respond to usage_ff' do
-      t.should respond_to(:usage_ff)
-    end
-
-    it 'respond with Response object' do
-      t.execute("ff").should be_instance_of Response
-    end
-	end
-
-	describe 'fb' do
-    it 'respond to description_fb' do
-      t.should respond_to(:description_fb)
-    end
-
-    it 'respond to usage_fb' do
-      t.should respond_to(:usage_fb)
-    end
-
-    it 'respond with Response object' do
-      t.execute("fb").should be_instance_of Response
-    end
-	end
-
-	describe 'repeat' do
-    it 'respond to description_repeat' do
-      t.should respond_to(:description_repeat)
-    end
-
-    it 'respond to usage_repeat' do
-      t.should respond_to(:usage_repeat)
-    end
-
-    it 'respond with Response object' do
-      t.execute("repeat").should be_instance_of Response
-    end
-	end
-end

data/spec/cultome_player/player/interface/helper_spec.rb

@@ -1,63 +0,0 @@
-require 'spec_helper'
-
-describe CultomePlayer::Player::Interface::Helper do
-  let(:t){ TestClass.new }
-
-  it 'raise an error if processing a unknown object' do
-    expect{ t.process_for_search([Parameter.new({type: :object, value: 'unknown'})]) }.to raise_error 'invalid search:unknown type'
-  end
-
-  it 'create a progress bar' do
-    t.get_progress_bar(55, 200, 10).should eq "|##________|"
-    t.get_progress_bar(55, 100, 10).should eq "|#####_____|"
-    t.get_progress_bar(55, 100, 20).should eq "|###########_________|"
-  end
-
-  it 'create a progress bar with labels in both sides' do
-    t.get_progress_bar_with_labels(5, 10, 10, "left", "right").should eq "left |#####_____| right"
-    t.get_progress_bar_with_labels(5, 10, 10, "left").should eq "left |#####_____|"
-    t.get_progress_bar_with_labels(5, 10, 10, "", "right").should eq "|#####_____| right"
-  end
-
-  it 'format seconds to minutos:seconds' do
-    t.format_secs(4).should eq "00:04"
-    t.format_secs(75).should eq "01:15"
-    t.format_secs(65).should eq "01:05"
-  end
-
-  describe '#process_object_for_search' do
-    it 'returns sql criteria and values for object type artist' do
-      artist = double("artist", name: "artist_name")
-      t.should_receive(:current_artist).and_return(artist)
-
-      q,v = t.send(:process_object_for_search, [Parameter.new({type: :object, value: :artist})] )
-      q.should eq 'artists.name = ?'
-      v.should eq ["artist_name"]
-    end
-
-    it 'returns sql criteria and values for object type album' do
-      album = double("album", name: "album_name")
-      t.should_receive(:current_album).and_return(album)
-
-      q,v = t.send(:process_object_for_search, [Parameter.new({type: :object, value: :album})] )
-      q.should eq 'albums.name = ?'
-      v.should eq ["album_name"]
-    end
-
-    it 'returns sql criteria and values for object type song' do
-      song = double("song", name: "song_name")
-      t.should_receive(:current_song).and_return(song)
-
-      q,v = t.send(:process_object_for_search, [Parameter.new({type: :object, value: :song})] )
-      q.should eq 'songs.name = ?'
-      v.should eq ["song_name"]
-    end
-
-    it 'returns sql criteria and values for object type library' do
-      q,v = t.send(:process_object_for_search, [Parameter.new({type: :object, value: :library})] )
-      q.should eq 'songs.id > 0'
-      v.should be_empty
-    end
-  end
-
-end

data/spec/cultome_player/player/interface_spec.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-
-describe CultomePlayer::Player::Interface do
-  let(:t){ TestClass.new }
-
-  it 'respond to basic commands' do
-    [:play , :pause , :stop , :next , :prev , :quit].each do |cmd|
-      t.should respond_to cmd
-    end
-  end
-
-  it 'respond to extended commands' do
-    [:show , :enqueue , :search , :shuffle , :connect , :disconnect , :ff , :fb].each do |cmd|
-      t.should respond_to cmd
-    end
-  end
-end

data/spec/cultome_player/player/playlist_spec.rb

@@ -1,301 +0,0 @@
-require 'spec_helper'
-
-describe CultomePlayer::Player::Playlist do
-  let(:p){ CultomePlayer::Player::Playlist::Playlists.new }
-
-  it 'add a new playlist' do
-    p.should be_empty
-    p.register(:playlist)
-    p.should have(1).item
-  end
-
-  it 'raise error if trying to use a unregistered playlist' do
-    expect{ p[:playlist] }.to raise_error('unknown playlist:playlist is not registered' )
-  end
-
-  context 'with a playlist registered' do
-    before :each do
-      p.register(:playlist)
-    end
-
-    it 'should return playlists object' do
-      p[:playlist].should be_instance_of CultomePlayer::Player::Playlist::Playlists
-    end
-
-    it 'raise and error if traying to register a previous registered playlist' do
-      expect{ p.register(:playlist) }.to raise_error('invalid registry:playlist already registered')
-    end
-
-    it 'get a playlist by name' do
-      p[:playlist].should have(1).item
-      p[:playlist].first.should_not be_nil
-    end
-
-    it 'add an element to an existing playlist' do
-      p[:playlist].first.should be_empty
-      p[:playlist] << "eleme"
-      p[:playlist].first.should have(1).item
-      p[:playlist] << "eleme"
-      p[:playlist].first.should have(2).item
-    end
-
-    it 'replace the content of a playlist' do
-      p[:playlist].first.should be_empty
-      p[:playlist] << "eleme"
-      p[:playlist] << "eleme"
-      p[:playlist].first.should have(2).item
-      p[:playlist] <= %w{uno dos tres cuatro}
-      p[:playlist].first.should have(4).item
-    end
-
-    it 'raise an error if trying to get the next song in an empty list' do
-      expect{ p[:playlist].next }.to raise_error 'playlist empty:no songs in playlists'
-    end
-
-    it 'change shuffle status' do
-      p[:playlist].should_not be_shuffling
-      p[:playlist].shuffle
-      p[:playlist].should be_shuffling
-      p[:playlist].order
-      p[:playlist].should_not be_shuffling
-    end
-
-    context 'with a full playlist' do
-      before :each do
-        p[:playlist] <= %w{uno dos tres cuatro}
-      end
-
-      it 'shuffle the content of the playlist' do
-        p[:playlist].first.should eq %w{uno dos tres cuatro}
-        p[:playlist].shuffle
-        p[:playlist].shuffle if p[:playlist].first == %w{uno dos tres cuatro}
-        p[:playlist].first.should_not eq %w{uno dos tres cuatro}
-      end
-
-      it 'get an element by index' do
-        p[:playlist].at(0).should eq "uno"
-        p[:playlist].at(3).should eq "cuatro"
-      end
-
-      it 'order the content of the playlist' do
-        p[:playlist].order
-        p[:playlist].first.should eq %w{cuatro dos tres uno}
-      end
-
-      it 'updated the play index' do
-        expect{ p[:playlist].next }.to change{ p[:playlist].play_index }.by(1)
-      end
-
-      it 'reset the play order when ordered' do
-        p[:playlist].next
-        p[:playlist].play_index.should eq 0
-        p[:playlist].next
-        p[:playlist].play_index.should eq 1
-
-        p[:playlist].order
-
-        p[:playlist].next
-        p[:playlist].play_index.should eq 0
-      end
-
-      it 'reset the play order when shuffled' do
-        p[:playlist].next
-        p[:playlist].play_index.should eq 0
-        p[:playlist].next
-        p[:playlist].play_index.should eq 1
-
-        p[:playlist].shuffle
-
-        p[:playlist].next
-        p[:playlist].play_index.should eq 0
-      end
-
-      it 'repeat the list if repeat is active' do
-        p[:playlist].repeat?.should be_true
-        p[:playlist].next.should eq "uno"
-        p[:playlist].next
-        p[:playlist].next
-        p[:playlist].next.should eq "cuatro"
-        p[:playlist].next.should eq "uno"
-      end
-
-      it 'raise an error if traying to retrive an ended playlist' do
-        p[:playlist].repeat false
-        p[:playlist].repeat?.should be_false
-        p[:playlist].next.should eq "uno"
-        p[:playlist].next
-        p[:playlist].next
-        p[:playlist].next.should eq "cuatro"
-        expect{ p[:playlist].next }.to raise_error("playlist empty:no songs in playlists")
-      end
-
-      it 'return nil if checking current song but playlist has not be played' do
-        p[:playlist].current.should be_nil
-      end
-
-      it 'return the current song in playlist' do
-        p[:playlist].next.should eq "uno"
-        p[:playlist].current.should eq "uno"
-      end
-
-      it 'removes and return the next song from the playlist' do
-        p[:playlist].should have(4).songs
-        p[:playlist].remove_next.should eq "uno"
-        p[:playlist].should have(3).songs
-        p[:playlist].remove_next.should eq "dos"
-        p[:playlist].should have(2).songs
-      end
-
-      it 'iterate over every song' do
-        pl = ":"
-        p[:playlist].each_song do |s|
-          pl << s.to_s
-        end
-        pl.should eq ":unodostrescuatro"
-      end
-
-      it 'check if there are songs remaining in the playlist' do
-        p[:playlist].repeat(false)
-        p[:playlist].repeat?.should be_false
-        p[:playlist].next?.should be_true
-        p[:playlist].next
-        p[:playlist].next
-        p[:playlist].next
-        p[:playlist].next
-        p[:playlist].next?.should be_false
-      end
-
-      it 'pop the last element inserted' do
-        p[:playlist].should have(4).songs
-        p[:playlist] << 'cinco'
-        p[:playlist].should have(5).songs
-        p[:playlist].pop.should eq 'cinco'
-        p[:playlist].pop.should eq 'cuatro'
-        p[:playlist].should have(3).songs
-      end
-
-      it 'rewind the playlist' do
-        p[:playlist].next.should eq 'uno'
-        p[:playlist].next.should eq 'dos'
-        p[:playlist].next.should eq 'tres'
-        p[:playlist].next.should eq 'cuatro'
-        p[:playlist].current.should eq 'cuatro'
-        p[:playlist].rewind_by(1).should eq 'tres'
-        p[:playlist].current.should eq 'tres'
-        p[:playlist].rewind_by(2).should eq 'uno'
-        p[:playlist].current.should eq 'uno'
-      end
-    end
-  end
-
-  context 'with multiple playlist registered' do
-    before :each do
-      p.register(:uno)
-      p.register(:dos)
-    end
-
-    it 'get multiples playlists by name' do
-      p[:uno, :dos].should have(2).item
-    end
-
-    it 'add an element to more than one existing playlists' do
-      p[:uno, :dos].each{|p| p.should be_empty }
-      p[:uno, :dos] << "elem"
-      p[:uno, :dos].each{|p| p.should have(1).item }
-    end
-
-    it 'replace the content of more than one existing playlists' do
-      p[:uno, :dos].each{|p| p.should be_empty }
-      p[:uno, :dos] << "elem"
-      p[:uno, :dos] << "elem"
-      p[:uno, :dos].each{|p| p.should have(2).item }
-      p[:uno, :dos].each{|p| p.should eq ["elem", "elem"] }
-      p[:uno, :dos] <= %w{uno dos tres cuatro}
-      p[:uno, :dos].each{|p| p.should have(4).item }
-      p[:uno, :dos].each{|p| p.should eq %w{uno dos tres cuatro} }
-    end
-
-    it 'return elements in aparence order' do
-      p.register(:tres)
-      p[:uno] << "uno"
-      p[:dos] << "dos"
-      p[:tres] << "tres"
-
-      p[:uno, :dos, :tres].next.should eq %w{uno dos tres}
-    end
-
-    it 'return nil if checking current song but playlist has not be played' do
-      p[:uno, :dos].current.should be_nil
-      p[:uno] << "uno"
-      p[:uno].next
-      expect{ p[:uno, :dos].current }.to raise_error "no current:no current song in one of the playlists"
-    end
-
-    it 'return the current song in playlist' do
-      p[:uno] << "uno"
-      p[:dos] << "tres"
-      p[:uno, :dos].next.should eq ["uno", "tres"]
-      p[:uno, :dos].current.should eq ["uno", "tres"]
-    end
-
-    it 'raise an error if getting the next of an empty playlist' do
-      p[:uno] << "uno"
-      expect{ p[:uno, :dos].next }.to raise_error 'playlist empty:no songs in one of the playlists'
-    end
-
-    it 'iterate over every song' do
-      p[:uno] << "uno"
-      p[:dos] << "dos"
-      pl = ":"
-      p.each_song do |s,idx|
-        pl << "#{idx}#{s.to_s}"
-      end
-      pl.should eq ":1uno2dos"
-    end
-
-    it 'check if there are songs remaining in the playlists' do
-      p[:uno, :dos].repeat false
-      p[:uno, :dos].repeat?.should eq [false, false]
-      p[:uno, :dos] << 'uno'
-      p[:uno] << 'dos'
-      p[:uno].next?.should be_true
-      p[:dos].next?.should be_true
-      p[:uno, :dos].next?.should eq [true, true]
-      p[:uno, :dos].next
-      p[:uno, :dos].next?.should eq [true, false]
-    end
-
-    it 'change shuffle status' do
-      p[:uno, :dos].shuffling?.should eq [false, false]
-      p[:uno, :dos].shuffle
-      p[:uno, :dos].shuffling?.should eq [true, true]
-      p[:uno, :dos].order
-      p[:uno, :dos].shuffling?.should eq [false, false]
-    end
-
-
-    it 'pop the last element inserted' do
-      p[:uno].should have(0).songs
-      p[:dos].should have(0).songs
-      p[:uno] << 'cinco'
-      p[:dos] << 'seis'
-      p[:uno].should have(1).songs
-      p[:dos].should have(1).songs
-      p[:uno, :dos].pop.should eq ['cinco', 'seis']
-      p[:uno].should have(0).songs
-      p[:dos].should have(0).songs
-    end
-
-    it 'rewind the playlists' do
-      p[:uno] << 'uno'
-      p[:uno] << 'dos'
-      p[:dos] << 'tres'
-      p[:dos] << 'cuatro'
-
-      p[:uno, :dos].next.should eq ['uno', 'tres']
-      p[:uno, :dos].next.should eq ['dos', 'cuatro']
-      p[:uno, :dos].current.should eq ['dos', 'cuatro']
-      p[:uno, :dos].rewind_by(1).should eq ['uno', 'tres']
-    end
-  end
-end