mr_eko 0.2.4.1 → 0.3.0

data/test/playlist_test.rb

@@ -1,17 +1,17 @@
-class PlaylistTest < Test::Unit::TestCase  
-  
+class PlaylistTest < Test::Unit::TestCase
+
   context "a new playlist" do
     setup do
       @playlist = MrEko::Playlist.new
     end
-    
+
     should "have no songs" do
       assert_equal 0, @playlist.songs.size
     end
   end
-  
+
   context "create_from_options" do
-    
+
     setup do
       @options = {:tempo => 100..200}
       MrEko::Song.delete
@@ -23,113 +23,120 @@ class PlaylistTest < Test::Unit::TestCase
       assert_raise(MrEko::Playlist::NoSongsError){ MrEko::Playlist.create_from_options(@options) }
       assert_equal @playlist_count, MrEko::Playlist.count
     end
-    
+
     should "create a playlist when there are songs found" do
-      assert MrEko::Song.insert(  :tempo => @options[:tempo].max, 
-                                :filename => 'third_eye.mp3',
-                                :artist => 'Tool', 
-                                :title => 'Third Eye',
-                                :md5 => Digest::MD5.hexdigest(Time.now.to_s),
-                                :created_on => Time.now,
-                                :duration => 567
-                              )
-                              
+      assert create_song(:tempo => @options[:tempo].max)
+
       assert MrEko::Playlist.create_from_options(@options)
       assert_equal @playlist_count + 1, MrEko::Playlist.count
     end
-    
+
     should "filter out certain options before querying for songs" do
       unfiltered_options = {:name => "Rock You in Your Face mix #{rand(1000)}", :time_signature => 4}
       MrEko::Song.expects(:where).with(Not(has_key(:name))).once.returns(sequel_dataset_stub)
       assert_raise(MrEko::Playlist::NoSongsError){ MrEko::Playlist.create_from_options(unfiltered_options) }
     end
-  end 
-  
-  context "prepare_options!" do
-    
+  end
+
+  context 'output' do
+    setup do
+      @playlist = MrEko::Playlist.create(:name => "Best Playlist#{rand(1000)}")
+      @song1 = create_song(:title => 'Song A')
+      @song2 = create_song(:title => 'Song B')
+      @playlist.songs << @song1
+      @playlist.songs << @song2
+    end
+
+    context 'default format' do
+
+      should 'be PLS' do
+        assert @playlist.output.match /^\[playlist\]/
+        assert @playlist.output.match /NumberOfEntries/
+      end
+    end
+
+    context 'text format' do
+
+      should 'contain a comma-sep list of the song name and file path' do
+        assert @playlist.output(:text).match /#{@song1.filename}\, #{@song1.title}/
+        assert @playlist.output(:text).match /#{@song2.filename}\, #{@song2.title}/
+      end
+    end
+  end
+
+  context "prepare_options" do
+
     context "when passed a preset option" do
-      
+
       should "only use the presets' options, not the others passed" do
         opts = { :time_signature => 4, :preset => :gym }
-        MrEko::Playlist.prepare_options!(opts)
-        assert !opts.has_key?(:time_signature)
-        assert_equal MrEko::Presets::FACTORY[:gym][:tempo], opts[:tempo]
+        transformed = MrEko::Playlist.prepare_options(opts)
+
+        assert_nil transformed.detect{ |opt| opt.has_key?(:time_signature) }
+        assert_equal MrEko::Presets::FACTORY[:gym].detect{ |opt| opt.has_key?(:tempo) }[:tempo],
+                     transformed.detect{ |opt| opt.has_key?(:tempo) }[:tempo]
       end
     end
-    
-    context "for tempo" do
-      
-      should "not transform when tempo is a Range" do
-        opts = {:tempo => 160..180}
-        MrEko::Playlist.prepare_options!(opts)
-        assert_equal 160..180, opts[:tempo]
+
+    context "transformation" do
+
+      should "handle less-than sign" do
+        transformed = MrEko::Playlist.prepare_options({:duration => "<20"})
+        assert_equal "duration < 20".lit, transformed.last
       end
-      
-      should "transform even when there aren't any passed tempo opts" do
-        opts = {:time_signature => 4}
-        MrEko::Playlist.prepare_options!(opts)
-        assert opts.has_key? :tempo
+
+      should "handle greater-than sign" do
+        transformed = MrEko::Playlist.prepare_options({:tempo => ">151"})
+        assert_equal "tempo > 151".lit, transformed.last
       end
 
-      should "remove min and max keys" do
-        opts = {:min_tempo => 100, :max_tempo => 200}
-        MrEko::Playlist.prepare_options!(opts)
-        assert !opts.has_key?(:min_tempo)
-        assert !opts.has_key?(:max_tempo)
+      should "handle basic assignment" do
+        transformed = MrEko::Playlist.prepare_options({:artist => "Radiohead"})
+        assert_equal( {:artist => "Radiohead"}, transformed.last )
       end
-      
-      should "create a range with the passed min and max tempos" do
-        opts = {:min_tempo => 100, :max_tempo => 200}
-        MrEko::Playlist.prepare_options!(opts)
-        assert_equal 100..200, opts[:tempo]
+
+      context "percentage values" do
+        [:loudness, :energy, :danceability].each do |attribute|
+          should "translate #{attribute} into decimal form" do
+            transformed = MrEko::Playlist.prepare_options({attribute => 32})
+            assert_equal( {attribute => 0.32}, transformed.last )
+          end
+        end
       end
     end
-    
-    context "for duration" do
-      
-      should "not transform when duration is a Range" do
-        opts = {:duration => 200..2010}
-        MrEko::Playlist.prepare_options!(opts)
-        assert_equal 200..2010, opts[:duration]
-      end
-      
-      should "transform even when there aren't any passed duration opts" do
-        opts = {:time_signature => 4}
-        MrEko::Playlist.prepare_options!(opts)
-        assert opts.has_key? :duration
+
+    context "defaults" do
+      should "be overridable" do
+        transformed = MrEko::Playlist.prepare_options({:tempo => 180})
+        assert_equal 180, transformed.detect{ |opt| opt.has_key?(:tempo) }[:tempo]
       end
 
-      should "remove min and max keys" do
-        opts = {:min_duration => 100, :max_duration => 2000}
-        MrEko::Playlist.prepare_options!(opts)
-        assert !opts.has_key?(:min_duration)
-        assert !opts.has_key?(:max_duration)
+      should "be set for tempo" do
+        transformed = MrEko::Playlist.prepare_options({})
+        assert_equal 0..500, transformed.detect{ |opt| opt.has_key?(:tempo) }[:tempo]
       end
 
-      should "create a range with the passed min and max durations" do
-        opts = {:min_duration => 100, :max_duration => 2000}
-        MrEko::Playlist.prepare_options!(opts)
-        assert_equal 100..2000, opts[:duration]
+      should "be set for duration" do
+        transformed = MrEko::Playlist.prepare_options({})
+        assert_equal 10..1200, transformed.detect{ |opt| opt.has_key?(:duration) }[:duration]
       end
     end
-    
+
     context "for mode" do
-      
+
       should "transform into numeric representation" do
-        opts = {:mode => 'minor'}
-        MrEko::Playlist.prepare_options!(opts)
-        assert_equal 0, opts[:mode]
+        transformed = MrEko::Playlist.prepare_options(:mode => 'minor')
+        assert_equal 0, transformed.detect{ |opt| opt.key?(:mode) }[:mode]
       end
     end
 
     context "for key" do
-      
+
       should "transform into numeric representation" do
-        opts = {:key => 'C#'}
-        MrEko::Playlist.prepare_options!(opts)
-        assert_equal 1, opts[:key]
+        transformed = MrEko::Playlist.prepare_options(:key => 'C#')
+        assert_equal 1, transformed.detect{ |opt| opt.key?(:key) }[:key]
       end
     end
 
   end
-end
+end

data/test/song_test.rb

@@ -0,0 +1,158 @@
+class SongTest < Test::Unit::TestCase
+
+  TEST_MP3 = File.join(File.dirname(__FILE__), 'data', 'they_want_a_test.mp3')
+  TAGLESS_MP3 = File.join(File.dirname(__FILE__), 'data', 'tagless.mp3')
+
+  def enmfp_data_stub(overrides={})
+    opts = {
+      'code'         => '98ouhajsnd081oi2he0da8sdoihjasdi2y9e8aASD3e8yaushdjQWD',
+      'tag'          => 0,
+      'raw_data'     => "[]", # JSON returned from EN
+      'metadata' => {
+        'artist'       => 'SebastiAn',
+        'title'        => 'Ross Ross Ross',
+        'release'      => 'Total',
+        'genre'        => 'Electronic',
+        'filename'     => '/Users/you/Music/sebastian-ross_ross_ross.mp3',
+        'bitrate'      => 320,
+        'sample_rate'  => 44100,
+        'codegen_time' => 9.221,
+        'duration'     => 219,
+      }
+    }.merge(overrides)
+
+    Hashie::Mash.new(opts)
+  end
+
+  def setup
+    MrEko::Song.delete
+  end
+
+
+  context 'create_from_file!' do
+
+    should 'catalog from tags by default' do
+      MrEko::Song.expects(:catalog_via_tags).with(TEST_MP3, kind_of(Hash)).returns(MrEko::Song.new)
+      MrEko::Song.create_from_file!(TEST_MP3)
+    end
+
+    should 'try cataloging via ENMFP when tags dont work' do
+      MrEko::Song.expects(:catalog_via_tags).with(TEST_MP3, kind_of(Hash)).returns(nil)
+      MrEko::Song.expects(:catalog_via_enmfp).with(TEST_MP3, kind_of(Hash)).returns(MrEko::Song.new)
+      MrEko::Song.create_from_file!(TEST_MP3)
+    end
+
+    should 'not try cataloging if we have it stored already' do
+      md5  = MrEko.md5(TEST_MP3)
+      stub = MrEko::Song.new
+
+      MrEko::Song.expects(:where).with(:md5 => md5).returns( [stub] )
+      MrEko::Song.expects(:catalog_via_enmfp).never
+      MrEko::Song.expects(:catalog_via_tags).never
+
+      assert_equal stub, MrEko::Song.create_from_file!(TEST_MP3)
+    end
+
+    should 'not atempt to catalog via ENMFP if the tags_only option is passed in' do
+      MrEko::Song.expects(:catalog_via_tags).with(TEST_MP3, kind_of(Hash)).returns(nil)
+      MrEko::Song.expects(:catalog_via_enmfp).never
+
+      MrEko::Song.create_from_file!(TEST_MP3, :tags_only => true)
+
+    end
+  end
+
+
+  context 'catalog_via_enmfp' do
+
+    should 'raise an error if the ENMFP fingerprint contains errors' do
+      MrEko::Song.stubs(:enmfp_data).returns(enmfp_data_stub('error' => 'BOOM'))
+      assert_raise(MrEko::Song::EnmfpError){ MrEko::Song.catalog_via_enmfp(TEST_MP3) }
+    end
+
+    should 'try to upload when no songs are returned from the Song#identify call' do
+      stub_data = enmfp_data_stub
+      empty_profile_stub = stub(:songs => [])
+      id_opts = {
+        :code    => stub_data.raw_data,
+        :artist  => stub_data.metadata.artist,
+        :title   => stub_data.metadata.title,
+        :release => stub_data.metadata.release,
+        :bucket  => 'audio_summary'
+      }
+      MrEko::Song.stubs(:enmfp_data).returns(stub_data)
+      Echonest::ApiMethods::Song.any_instance.expects(:identify).with(id_opts).returns(empty_profile_stub)
+      MrEko::Song.expects(:get_datapoints_by_upload).returns([stub_everything, stub_everything(:id => 'whatever')])
+      MrEko::Song.catalog_via_enmfp(TEST_MP3)
+    end
+
+    should 'try to get the profile data when a song is returned from the Song#identify call' do
+      stub_data = enmfp_data_stub
+      profile_stub = stub(:songs => [stub_everything(:id => 'FJJ299KLOP')])
+      profile_details_stub = stub(:songs => [stub(:audio_summary => stub_everything)])
+
+      MrEko::Song.stubs(:enmfp_data).returns(stub_data)
+      Echonest::ApiMethods::Song.any_instance.expects(:identify).returns(profile_stub)
+      Echonest::ApiMethods::Song.any_instance.expects(:profile).with(:id => 'FJJ299KLOP', :bucket => 'audio_summary').returns(profile_details_stub)
+      MrEko::Song.expects(:get_datapoints_by_upload).never
+
+
+      assert_difference 'MrEko::Song.count' do
+        MrEko::Song.catalog_via_enmfp(TEST_MP3)
+      end
+    end
+  end
+
+  context 'catalog_via_tags' do
+
+    context 'for a mp3 with no useful tag information' do
+
+      setup do
+        @mp3 = MrEko::Song.parse_id3_tags(TAGLESS_MP3)
+        assert_nil @mp3.artist
+        assert_nil @mp3.title
+      end
+
+      should 'return nil' do
+        assert_nil MrEko::Song.catalog_via_tags(TAGLESS_MP3)
+      end
+    end
+
+    context 'for a mp3 with the required tag information' do
+
+      setup do
+        @mp3 = MrEko::Song.parse_id3_tags(TEST_MP3)
+        assert_not_nil @mp3.artist
+        assert_not_nil @mp3.title
+      end
+
+      should 'create a Song' do
+        songs_stub = [stub(:audio_summary => stub_everything, :artist => @mp3.artist, :title => @mp3.title, :id => 'xxx')]
+        Echonest::ApiMethods::Song.any_instance.expects(:search).returns(stub(:songs => songs_stub))
+
+        assert_difference 'MrEko::Song.count' do
+          MrEko::Song.catalog_via_tags(TEST_MP3)
+        end
+      end
+    end
+  end
+
+  context 'cleaning funky ID3 tags' do
+
+    should "decode iTunes' crazy tags" do
+      dm = Iconv.conv('UTF-16', 'LATIN1', 'Dead Meadow')
+      tag_stub = OpenStruct.new(:artist => dm, :title => 'Good Moaning')
+      ID3Lib::Tag.expects(:new).once.returns(tag_stub)
+      parsed_tags = MrEko::Song.parse_id3_tags(TEST_MP3)
+
+      assert_equal "Dead Meadow", parsed_tags.artist
+    end
+
+    should "not blow up when there isn't any crazy encoding" do
+      tag_stub = OpenStruct.new(:artist => 'Dead Meadow', :title => 'Good Moaning')
+      ID3Lib::Tag.expects(:new).once.returns(tag_stub)
+
+      assert_nothing_raised{ MrEko::Song.parse_id3_tags(TEST_MP3) }
+    end
+  end
+end

data/test/test.rb

@@ -6,12 +6,17 @@ require 'test/unit'
 require 'shoulda'
 require 'mocha'
 require "mr_eko"
+require "ruby-debug"
 
 require 'sequel/extensions/migration'
 Sequel::Migrator.apply(MrEko.connection, File.join(File.dirname(__FILE__), "..", "db", "migrate"))
+# Clear the tables out
+(MrEko.connection.tables - [:schema_info]).each do |table|
+  MrEko.connection.run "DELETE FROM #{table}"
+end
 
 class Test::Unit::TestCase
-  
+
   # Could be fleshed out some more.
   def sequel_dataset_stub
     data = mock()
@@ -19,4 +24,33 @@ class Test::Unit::TestCase
     data
   end
 
-end
+  def create_song(opts={})
+    defaults = {
+      :filename => 'third_eye.mp3',
+      :artist => 'Tool',
+      :title => 'Third Eye',
+      :md5 => Digest::MD5.hexdigest(Time.now.to_s + rand(10000000).to_s),
+      :created_on => Time.now,
+      :duration => 567,
+      :tempo => 143
+    }.merge(opts)
+
+    MrEko::Song.create(defaults)
+  end
+
+  def assert_difference(expression, difference = 1, message = nil, &block)
+    b = block.send(:binding)
+    exps = expression.is_a?(Array) ? expression : [expression]
+    before = exps.map { |e| eval(e, b) }
+
+    yield
+
+    exps.each_with_index do |e, i|
+      error = "#{e.inspect} didn't change by #{difference}"
+      error = "#{message}.\n#{error}" if message
+      assert_equal(before[i] + difference, eval(e, b), error)
+    end
+  end
+
+
+end

data/test/timed_playlist_test.rb

@@ -0,0 +1,130 @@
+class TimedPlaylistTest < Test::Unit::TestCase
+
+  context 'a new TimedPlaylist' do
+
+    should 'accept a hash of options' do
+      assert MrEko::TimedPlaylist.new(:length => 600, :name => 'whatever')
+    end
+
+    should 'set those options as expected' do
+      pl = MrEko::TimedPlaylist.new(:length => 600, :name => 'Awesome')
+      assert_equal 600, pl.length
+      assert_equal 'Awesome', pl.name
+    end
+
+  end
+
+  context 'initial' do
+
+    should 'add the attribute to the list of initial attributes' do
+      MrEko::TimedPlaylist.new(:length => 600, :name => 'sad shit') do |pl|
+        assert pl.initial(:mode, :minor)
+        assert_equal :minor, pl.attributes[:initial][:mode]
+      end
+    end
+  end
+
+  context 'final' do
+
+    should 'add the attribute to the list of final attributes' do
+      MrEko::TimedPlaylist.new(:length => 200, :name => 'Rock') do |pl|
+        assert pl.final(:tempo, 120)
+        assert_equal 120, pl.attributes[:final][:tempo]
+      end
+    end
+  end
+
+  context 'static' do
+
+    should 'add the attribute to the list of static attributes' do
+      MrEko::TimedPlaylist.new(:length => 1000, :name => 'Bump') do |pl|
+        assert pl.static(:genre, 'HipHop')
+        assert_equal 'HipHop',  pl.attributes[:static][:genre]
+      end
+    end
+  end
+
+  context 'save' do
+
+    should 'populate the step_map' do
+      list = MrEko::TimedPlaylist.new(:length => 360) do |pl|
+        pl.initial(:tempo, 100)
+        pl.final(:tempo, 106)
+      end
+
+      assert list.step_map.empty?
+      assert list.save
+      assert !list.step_map.empty?
+    end
+
+    should 'increase the step length to 4.minutes if value is less that that' do
+      list = MrEko::TimedPlaylist.new(:length => 300) do |pl|
+        pl.initial(:tempo, 60)
+        pl.final(:tempo, 80)
+      end
+
+      assert list.save
+      assert_equal [20, 240], list.step_map[:tempo]
+    end
+
+    should 'populate the step_map with the proper mode step data' do
+      list = MrEko::TimedPlaylist.new(:length => 3060) do |pl|
+        pl.initial(:mode, :major)
+        pl.final(:mode, :minor)
+      end
+
+      assert list.save
+      assert_equal [2, 3060.to_f/2], list.step_map[:mode]
+    end
+
+    should 'populate the step_map with the proper tempo and loudness step data' do
+      list = MrEko::TimedPlaylist.new(:length => 3600) do |pl|
+        pl.initial(:tempo, 60)
+        pl.final(:tempo, 70)
+
+        pl.initial(:loudness, -13)
+        pl.final(:loudness, -9)
+      end
+
+      assert list.save
+      assert_equal [10, 3600.to_f/10], list.step_map[:tempo]
+      assert_equal [4, 3600.to_f/4], list.step_map[:loudness]
+    end
+
+    should 'populate the step_map with the proper energy and danceability fractional step data' do
+      list = MrEko::TimedPlaylist.new(:length => 3600) do |pl|
+        pl.initial(:energy, 0.622)
+        pl.final(:energy, 0.888)
+
+        pl.initial(:danceability, 0.22)
+        pl.final(:danceability, 0.88)
+      end
+
+      assert list.save
+      assert_equal [3, (3600.to_f/3).round], list.step_map[:energy]
+      assert_equal [7, (3600.to_f/7).round], list.step_map[:danceability]
+    end
+
+    should 'populate the step_map with the proper key step data' do
+      list = MrEko::TimedPlaylist.new(:length => 3060) do |pl|
+        pl.initial(:key, 'C#')
+        pl.final(:key, 'A#')
+      end
+
+      step = MrEko.key_lookup('A#') - MrEko.key_lookup('C#')
+      assert list.save
+      assert_equal [step, 3060.to_f/step], list.step_map[:key]
+    end
+
+
+    context 'validation' do
+      should "raise an exception when initial and final attribute keys don't match" do
+        pl = MrEko::TimedPlaylist.new(:length => 1000) do |pl|
+          assert pl.initial(:tempo, 66)
+        end
+
+        assert_raise(MrEko::TimedPlaylist::InvalidAttributes){ pl.save }
+      end
+    end
+  end
+end