music_blender 0.0.1

data/test/unit/artist_test.rb

@@ -0,0 +1,9 @@
+require 'test_helper'
+
+module MusicBlender
+  class ArtistTest < MiniTest::Unit::TestCase
+    def test_instantiation
+      assert_kind_of(Artist,create(:artist))
+    end
+  end
+end

data/test/unit/bootstrap_test.rb

@@ -0,0 +1,32 @@
+require 'test_helper'
+
+module MusicBlender
+  class BootstrapTest < MiniTest::Unit::TestCase
+    attr_reader :bootstrap, :mock_shell
+
+    describe Bootstrap do
+      let(:bootstrap) { Bootstrap.new }
+      let(:mock_shell) { mock('shell')}
+      let(:mock_music_folder) { mock('music_folder') }
+
+      before do
+        Shell.stubs(:new).returns(mock_shell)
+        MusicFolder.stubs(:current).returns(mock_music_folder)
+      end
+
+      def test_call
+        DbAdapter.any_instance.expects(:spin_up)
+        mock_music_folder.expects(:load_tracks)
+        mock_music_folder.expects(:update_missing_flags)
+        mock_shell.expects(:run).throws(:exited)
+        bootstrap.call
+      end
+
+      def test_config
+        assert_equal(mock_music_folder,bootstrap.send(:music_folder))
+      end
+
+    end
+  end
+end
+

data/test/unit/db_adapter_test.rb

@@ -0,0 +1,37 @@
+require 'test_helper'
+
+module MusicBlender
+  class DbAdapterTest < MiniTest::Unit::TestCase
+
+    describe DbAdapter do
+      let(:mock_connection) { mock('db_connection') }
+      let(:adapter) { DbAdapter.new }
+
+      before do
+        ActiveRecord::Base.stubs(:establish_connection).returns(mock_connection)
+        ActiveRecord::Base.stubs(:connection).returns(mock_connection)
+        ActiveRecord::Base.stubs('logger').returns(true)
+      end
+
+      def test_spinup_without_prior_db
+        File.expects(:exist?).returns(false)
+        adapter.expects(:load)
+        ActiveRecord::Migrator.expects(:migrate).never
+
+        adapter.spin_up
+      end
+
+      def test_spinup_with_prior_db
+        File.expects(:exist?).returns(true)
+        ActiveRecord::Migrator.expects(:migrate)
+        File.expects(:open).with(adapter.send(:path_to_schema),'w:utf-8').yields(mock('schema_file'))
+        ActiveRecord::SchemaDumper.expects(:dump)
+        adapter.expects(:load).never
+
+        adapter.spin_up
+      end
+    end
+
+  end
+end
+

data/test/unit/id3_adapter_test.rb

@@ -0,0 +1,42 @@
+require 'test_helper'
+
+module MusicBlender
+  class Id3AdapterTest < MiniTest::Unit::TestCase
+
+    describe Id3Adapter do
+      let(:path) { "#{MUSIC_PATH}/point1sec.mp3" }
+      let(:adapter) { Id3Adapter.new(path,nil) }
+
+      describe 'loading data' do
+
+        def test_loads_artist
+          assert_equal('DefBeats', adapter.artist)
+        end
+
+        def test_loads_title
+          assert_equal('Silent MP3 10th-of-a-sec', adapter.title)
+        end
+
+        def test_loads_rating
+          assert_equal(1, adapter.rating)
+        end
+      end
+
+      describe 'setting data' do
+
+        def test_sets_rating
+          assert_difference('adapter.rating' => 41) do
+            adapter.set_rating(42)
+          end
+        ensure
+          adapter.send(:v2tag).remove_frame(adapter.send(:rating_frame))
+          adapter.send(:tag_file).save
+        end
+
+      end
+
+    end
+
+  end
+end
+

data/test/unit/music_folder_test.rb

@@ -0,0 +1,92 @@
+require 'test_helper'
+require 'ostruct'
+
+module MusicBlender
+  class MusicFolderTest < MiniTest::Unit::TestCase
+
+    describe MusicFolder do
+      let(:music_folder) { create(:music_folder_with_tracks) }
+      let(:mock_id3_tag) { mock('tag') }
+
+      before do
+        Track.any_instance.stubs(:rating_frame => OpenStruct.new(:text => '5'))
+        mock_id3_tag.stubs(:title => 'Foo', :artist => 'Bar')
+        Track.any_instance.stubs(:import_id3_tag_attributes)
+      end
+
+      def test_pick_a_track
+        assert_includes(music_folder.tracks,music_folder.pick_a_track)
+      end
+
+      describe 'loading new tracks' do
+
+        before do
+          Track.any_instance.unstub(:import_id3_tag_attributes)
+          create(:track, :music_folder => music_folder, :relative_path => 'a')
+          music_folder.stubs(:relative_paths => ['a','b','c'])
+        end
+
+        def test_load_new_tracks
+          assert_difference('Track.count' => 2) do
+            music_folder.load_tracks
+          end
+        end
+
+      end
+
+      describe 'update missing flags' do
+        let(:track) { create(:track) }
+
+        def test_updates_missing_flags
+          refute(track.missing?)
+          track.music_folder.update_missing_flags
+          assert(track.reload.missing?)
+        end
+      end
+
+      describe 'music_path' do
+
+        def test_uses_constant
+          assert_equal(MUSIC_PATH, MusicFolder.music_path)
+        end
+
+      end
+
+      describe 'current' do
+
+        before do
+          MusicFolder.instance_variable_set(:@current, nil)
+        end
+
+        describe 'when one does not already exist' do
+
+          before do
+            MusicFolder.stubs(:music_path).returns('/some/non/existent/path/dsedfget')
+          end
+
+          def test_create_music_folder
+            assert_difference('MusicFolder.count') do
+              MusicFolder.current
+            end
+          end
+
+        end
+
+        describe 'when one does already exist' do
+          let(:music_folder) { create(:music_folder) }
+
+          before do
+            MusicFolder.stubs(:music_path).returns(music_folder.path)
+          end
+
+          def test_fetch_current_music_folder
+            assert_difference('MusicFolder.count' => 0) do
+              MusicFolder.current
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

data/test/unit/player_monitor_test.rb

@@ -0,0 +1,70 @@
+require 'test_helper'
+require 'tempfile'
+
+module MusicBlender
+  class PlayerMonitorTest < MiniTest::Unit::TestCase
+
+    describe PlayerMonitor do
+      attr_reader :mock_stderr_writable, :mock_stdout_writable, :thread
+
+      let (:mock_player) { mock('player') }
+      let (:monitor) { PlayerMonitor.new(mock_player) }
+
+      before do
+        mock_player.stubs(:logger => Logger.new('/dev/null'))
+        mock_stdout_readable, @mock_stdout_writable = IO.pipe
+        mock_stderr_readable, @mock_stderr_writable = IO.pipe
+        mock_player.stubs(:stdout).returns(mock_stdout_readable)
+        mock_player.stubs(:stderr).returns(mock_stderr_readable)
+        @thread = Thread.new { monitor.run }
+      end
+
+      after do
+        thread.exit
+      end
+
+      def test_should_process_i_messages
+        assert_equal(nil,monitor.song_name)
+        write_to_player('@I Foobar')
+        assert_equal('Foobar',monitor.song_name)
+      end
+
+      def test_should_process_f_messages
+        write_to_player('@F 1 2 3 4')
+        assert_equal(1,monitor.frames)
+        assert_equal(2,monitor.frames_remaining)
+        assert_equal(3,monitor.seconds)
+        assert_equal(4,monitor.seconds_remaining)
+      end
+
+      def test_should_process_p_stop_messages
+        write_to_player('@P 0')
+        assert_equal(0,monitor.stop_pause_status)
+        assert_equal(false,monitor.playing)
+      end
+
+      def test_should_process_p_paused_messages
+        write_to_player('@P 1')
+        assert_equal(1,monitor.stop_pause_status)
+        assert_equal(false,monitor.playing)
+      end
+
+      def test_should_process_p_resumed_messages
+        write_to_player('@P 2')
+        assert_equal(2,monitor.stop_pause_status)
+        assert_equal(true,monitor.playing)
+      end
+
+      #######
+      private
+      #######
+
+      def write_to_player(string)
+        mock_stdout_writable.write(string)
+        mock_stdout_writable.close
+        sleep 0.002
+      end
+
+    end
+  end
+end

data/test/unit/player_test.rb

@@ -0,0 +1,76 @@
+require 'test_helper'
+
+module MusicBlender
+  class PlayerTest < MiniTest::Unit::TestCase
+
+    describe Player do
+      let(:player) { Player.new }
+      let(:mock_stdin) { mock('stdin') }
+      let(:mock_stdout) { mock('stdout') }
+      let(:mock_stderr) { mock('stderr') }
+      let(:mock_wait_thread) { mock('wait_thread') }
+      let(:mock_monitor_thread) { mock('monitor_thread') }
+
+      before do
+        Open3.expects(:popen3).returns(mock_stdin,mock_stdout,mock_stderr,mock_wait_thread)
+        Thread.expects(:new).returns(mock_monitor_thread)
+        player.stubs(:config)
+      end
+
+      describe 'play' do
+        let(:track1) { create(:track) }
+        let(:track2) { create(:track) }
+        let(:music_folder) { create(:music_folder) }
+
+        before do
+          player.stubs(:music_folder).returns(music_folder)
+          music_folder.stubs(:pick_a_track).returns(track1)
+          mock_stdin.stubs(:puts)
+        end
+
+        def test_loads_a_song
+          mock_stdin.expects(:puts).with(regexp_matches(/^LOAD #{track1.full_path}/))
+          player.play
+        end
+
+        def test_sets_last_played_at
+          player.stubs(:current_track => track1)
+          assert_operator(track1.last_played_at,:<,1.minute.ago)
+          player.play
+          assert_operator(track1.last_played_at,:>,1.minute.ago)
+        end
+
+      end
+
+      def test_should_pause
+        mock_stdin.expects(:puts).with('PAUSE')
+        player.pause
+      end
+
+      def test_should_stop
+        mock_stdin.expects(:puts).with('STOP')
+        player.stop
+      end
+
+      def test_should_quit
+        mock_stdin.expects(:puts).with('QUIT')
+        player.quit
+      end
+
+      describe 'delegated methods' do
+        let(:mock_monitor) { mock('monitor') }
+
+        before do
+          PlayerMonitor.stubs(:new => mock_monitor)
+        end
+
+        def test_should_get_status_string
+          mock_monitor.expects(:stop_pause_status => 1)
+          assert_equal('Paused', player.status_string)
+        end
+
+      end
+
+    end
+  end
+end

data/test/unit/shell_test.rb

@@ -0,0 +1,71 @@
+require 'test_helper'
+
+module MusicBlender
+  class ShellTest < MiniTest::Unit::TestCase
+    attr_reader :mock_player, :mock_scanner
+
+    describe Shell do
+      let(:mock_player) { mock('player') }
+      let(:shell) { Shell.new }
+
+      before do
+        mock_player.stubs(:stop)
+        mock_player.stubs(:quit)
+        Shell.stubs(:player).returns(mock_player)
+      end
+
+      def test_gracefully_fail_to_execute_command
+        assert_equal('',$stdout.string)
+        run_shell(:ping)
+        assert_match(/Unrecognized Command: ping/,$stdout.string)
+      end
+
+      describe 'info' do
+        before do
+          Shell.expects(:print_info)
+        end
+
+        def test_execute_info
+          assert_equal('',$stdout.string)
+          run_shell(:info)
+          refute_equal('',$stdout.string)
+        end
+      end
+
+      describe 'player commands' do
+        def test_execute_player_commands
+          [:play,:stop,:quit].each do |command|
+            mock_player.expects(command)
+            run_shell(command)
+          end
+        end
+      end
+
+      describe 'commands with arguments' do
+        let(:track) { create(:track) }
+
+        before do
+          mock_player.stubs(:current_track => track)
+        end
+
+        def test_executes_command_with_arguments
+          assert_equal('',$stdout.string)
+          assert_difference('track.rating' => -31) do
+            run_shell('rate 11')
+          end
+          assert_match(/Rating Updated To: 11/,$stdout.string)
+        end
+      end
+
+      #######
+      private
+      #######
+
+      def run_shell(command)
+        shell.stubs(:gets).returns(command.to_s).then.returns('exit')
+        assert_throws(:exited) { shell.run }
+      end
+
+    end
+  end
+end

data/test/unit/track_test.rb

@@ -0,0 +1,48 @@
+require 'test_helper'
+
+module MusicBlender
+  class TrackTest < MiniTest::Unit::TestCase
+
+    describe Track do
+      let(:track) { create(:track) }
+      let(:mock_id3_tag) { mock('tag') }
+
+      def setup
+        Track.any_instance.stubs(:rating_frame => OpenStruct.new(:text => '5'))
+        mock_id3_tag.stubs(:title => 'Foo', :artist => 'Bar')
+        Track.any_instance.stubs(:id3v2_tag => mock_id3_tag)
+      end
+
+      def test_full_path
+        assert_kind_of(String,track.full_path)
+      end
+
+
+      describe 'except_recently_played scope' do
+        attr_reader :track1, :track2, :track3
+
+        before do
+          @track1 = create(:track, :last_played_at => 3.days.ago)
+          @track2 = create(:track, :last_played_at => 2.days.ago)
+          @track3 = create(:track, :last_played_at => 1.days.ago)
+        end
+
+        def test_does_not_include_recently_played
+          assert_includes(Track.except_recently_played,track1)
+          track1.update_column(:last_played_at, Time.now)
+          refute_includes(Track.except_recently_played,track1)
+        end
+
+        describe 'most_recent scope' do
+
+          def test_gets_most_recent_2_tracks
+            refute_includes(Track.most_recent(2),track1)
+            track1.update_column(:last_played_at, Time.now)
+            assert_includes(Track.most_recent(2),track1)
+          end
+
+        end
+      end
+    end
+  end
+end