cultome_player 2.0.0

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

@@ -0,0 +1,63 @@
+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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,301 @@
+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

data/spec/cultome_player/plugins/help_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+class TestPlugin
+	include CultomePlayer::Plugins::Help
+end
+
+describe CultomePlayer::Plugins::Help do
+	let(:p){ TestPlugin.new }
+
+	it 'respond to command_help' do
+		p.should respond_to(:command_help)
+	end
+
+	it 'respond to usage_help' do
+		p.should respond_to(:usage_help)
+	end
+
+	it 'respond to description_help' do
+		p.should respond_to(:description_help)
+	end
+end

data/spec/cultome_player/plugins_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe CultomePlayer::Plugins do
+	let(:p){
+		class TestPlugin
+			include CultomePlayer::Plugins
+		end
+
+		TestPlugin.new
+	}
+	it 'check if plugins respond to a given command' do
+		p.plugins_respond_to?("help").should be_true
+		p.plugins_respond_to?("nonexistent").should_not be_true
+	end
+
+	it 'return the format for a command' do
+		p.plugin_command_sintaxis("help").should be_instance_of Regexp
+	end
+end

data/spec/cultome_player/utils_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe CultomePlayer::Utils do
+	let(:t){ TestClass.new(:rspec) }
+
+	describe 'arrange information in columns' do
+		it 'everything fits in a row' do
+			t.arrange_in_columns(["12345", "1234567890"], [5, 10], 2).should eq "12345  1234567890"
+		end
+
+		it 'data bigger than column span into another row' do
+			t.arrange_in_columns(["12345", "123456789012345"], [5, 10], 2).should eq "12345  1234567890\n       12345"
+		end
+	end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,108 @@
+require 'coveralls'
+require 'database_cleaner'
+require 'cultome_player'
+
+Coveralls.wear!
+
+include CultomePlayer::Environment
+include CultomePlayer::Utils
+include CultomePlayer::Objects
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+  config.filter_run_excluding :mplayer
+  config.order = 'random'
+
+  config.before(:suite) do
+    prepare_environment(:rspec)
+    with_connection do
+      DatabaseCleaner.strategy = :transaction
+      DatabaseCleaner.clean_with(:truncation)
+    end
+  end
+
+  config.before(:each) do
+    with_connection { DatabaseCleaner.start }
+  end
+
+  config.after(:each) do
+    with_connection { DatabaseCleaner.clean }
+  end
+end
+
+module FakeStatus
+  def current_artist
+    Artist.new(name: 'artist_uno')
+  end
+
+  def current_album
+    Album.new(name: 'album_tres')
+  end
+end
+
+module FakeExtractor
+  def extract_from_txt(filepath, opc)
+    filename = filepath[filepath.rindex("/")+1, filepath.length]
+    extension = filename[filename.rindex(".")+1, filename.length]
+
+    file_info = { filename: filename, path: filepath, extension: extension }
+
+    file_info[:relative_path] = filepath.gsub(/#{opc[:root_path]}\//, '') if opc.has_key?(:root_path)
+
+      return file_info
+  end
+end
+
+module MockPlayer
+  def send_to_player(cmd)
+    if cmd == 'pause'
+      if @paused
+        @paused = @stopped = false
+        @playing = true
+      else
+        @paused = true
+        @stopped = @playing = false
+      end
+    elsif cmd.start_with?('load')
+      @is_player_running = @playing = true
+    elsif cmd.start_with?('stop')
+      @is_player_running = @paused = @playing = false
+      @stopped = true
+    elsif cmd.start_with?('jump')
+      # do nothing
+    else
+      puts "ERROR: #{cmd} !!!!!!!"
+    end
+  end
+
+  def control_pipe
+    STDOUT
+  end
+
+  def start_player
+    @play_in_player = true
+    @playing = true
+    @paused = @stopped = false
+  end
+end
+
+class TestClass
+  include CultomePlayer
+  include FakeStatus
+  include FakeExtractor
+  include MockPlayer
+
+  def initialize(env=:rspec)
+    prepare_environment(env) unless env.nil?
+    playlists.register(:current)
+    playlists.register(:history)
+    playlists.register(:queue)
+    playlists.register(:focus)
+  end
+end
+
+def test_folder
+  File.join(File.dirname(File.expand_path(__FILE__)), 'test')
+end