bassnode-ruby-echonest 0.1.2

data/spec/analysis_spec.rb

@@ -0,0 +1,110 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'spec_helper'
+
+include SpecHelper
+
+describe Echonest::Analysis do
+  before do
+    @analysis = Echonest::Analysis.new(open(fixture('analysis.json')).read)
+  end
+
+  it "should have beats" do
+    beats = @analysis.beats
+
+    beats.size.should eql(324)
+    beats.first.start.should eql(0.27661)
+    beats.first.duration.should eql(0.36476)
+    beats.first.confidence.should eql(0.468)
+  end
+
+  it "should have segments" do
+    segments = @analysis.segments
+    segment = segments.first
+
+    segments.size.should eql(274)
+    segment.start.should eql(0.0)
+    segment.duration.should eql(0.43909)
+    segment.confidence.should eql(1.0)
+    segment.loudness.time.should eql(0.0)
+    segment.loudness.value.should eql(-60.0)
+    segment.max_loudness.time.should eql(0.11238)
+    segment.max_loudness.value.should eql(-33.563)
+    segment.pitches.size.should eql(12)
+    segment.pitches.first.should eql(0.138)
+    segment.timbre.size.should eql(12)
+    segment.timbre.first.should eql(11.525)
+  end
+
+  it "should have bars" do
+    bars = @analysis.bars
+
+    bars.size.should eql(80)
+    bars.first.start.should eql(1.00704)
+    bars.first.duration.should eql(1.48532)
+    bars.first.confidence.should eql(0.188)
+  end
+
+  it "should have tempo" do
+    @analysis.tempo.should eql(168.460)
+  end
+
+  it "should have sections" do
+    sections = @analysis.sections
+    section = sections.first
+
+    sections.size.should eql(7)
+    section.start.should eql(0.0)
+    section.duration.should eql(20.04271)
+    section.confidence.should eql(1.0)
+  end
+
+  it "should have durtion" do
+    @analysis.duration.should eql(120.68526)
+  end
+
+  it "should have end of fade in" do
+    @analysis.end_of_fade_in.should eql(0.0)
+  end
+
+  it "should have start of fade out" do
+    @analysis.start_of_fade_out.should eql(113.557)
+  end
+
+  it "should have key" do
+    @analysis.key.should eql(7)
+  end
+
+  it "should derive key letter from key" do
+    @analysis.key_letter.should eql(Echonest::Analysis::CHROMATIC[7])
+  end
+  
+  it "should have loudness" do
+    @analysis.loudness.should eql(-19.140)
+  end
+
+  it "should have mode" do
+    @analysis.mode.should eql(1)
+  end
+
+  it "should derive major? from mode" do
+    @analysis.major?.should eql(true)
+  end
+
+  it "should derive minor? from mode" do
+    @analysis.minor?.should eql(false)
+  end
+
+  it "should have time signature" do
+    @analysis.time_signature.should eql(4)
+  end
+
+  it "should have tatums" do
+    tatums = @analysis.tatums
+
+    tatums.size.should eql(648)
+    tatums.first.start.should eql(0.09469)
+    tatums.first.duration.should eql(0.18193)
+    tatums.first.confidence.should eql(0.286)
+  end
+end

data/spec/api_spec.rb

@@ -0,0 +1,144 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'spec_helper'
+require "echonest"
+
+include SpecHelper
+
+describe Echonest::Api do
+  before do
+    @api = Echonest::Api.new('8TPE3VC60ODJTNTFE')
+  end
+
+  it "should build parameters" do
+    params = @api.build_params(:id => 'TRXXHTJ1294CD8F3B3')
+    params.keys.size.should eql(3)
+    params[:api_key].should eql('8TPE3VC60ODJTNTFE')
+    params[:id].should eql('TRXXHTJ1294CD8F3B3')
+    params[:format].should eql('json')
+  end
+
+  it "should build parameters to list" do
+    params = @api.build_params_to_list(:id => 'TRXXHTJ1294CD8F3B3')
+    params.length.should eql(3)
+    params[0].should eql(['id', 'TRXXHTJ1294CD8F3B3'])
+    params.should be_include(['api_key', '8TPE3VC60ODJTNTFE'])
+    params.should be_include(['format', 'json'])
+  end
+
+  it "should pass arguments to user agent" do
+    @api.user_agent.should_receive(:get_content).
+      with(
+      URI('http://developer.echonest.com/api/v4/xxx/yyy'),
+      [
+        ['foo', 'bar'],
+        ['api_key', '8TPE3VC60ODJTNTFE'],
+        ['format', 'json']
+      ]).and_return(open(fixture('profile.json')).read)
+
+    @api.request('xxx/yyy', :get, :foo => 'bar')
+  end
+
+  it "should pass arguments including a file to user agent" do
+    file = open(fixture('sample.mp3'))
+    file.should_receive(:read).and_return('content')
+
+
+    @api.user_agent.should_receive(:post_async).
+      with(
+      URI('http://developer.echonest.com/api/v4/xxx/zzz?api_key=8TPE3VC60ODJTNTFE&bar=baz&format=json'),
+      'content',
+      {
+        'Content-Type' => 'application/octet-stream'
+      }).and_return(open(fixture('profile.json')).read)
+
+    @api.request('xxx/zzz', :post, { :bar => 'baz' }, file)
+  end
+
+  it "should call api method" do
+    content = open(fixture('profile.json')).read
+
+    make_connection_stub(content, :post)
+    response = @api.request('track/profile', :post, :id => 'TRXXHTJ1294CD8F3B3')
+    response.should be_success
+    response.body.status.version.should eql("4.2")
+  end
+
+  it "should raise error when api method call was failed" do
+    make_connection_stub(open(fixture('profile_failure.json')).read, :post)
+
+    lambda {
+      @api.request('track/profile', :post, :id => 'TRXXHTJ1294CD8F3B3')
+    }.should raise_error(Echonest::Api::Error, 'api_key - Invalid key: "XXXXX" is not a valid, active api key')
+  end
+
+  it "should raise error when unknown api method was called" do
+    @api.user_agent.stub!('get_content').and_raise(HTTPClient::BadResponseError.new('error message'))
+
+    lambda {
+      @api.request('track/xxxx', :get, :id => 'TRXXHTJ1294CD8F3B3')
+    }.should raise_error(Echonest::Api::Error, 'track/xxxx: error message')
+  end
+
+  it "should make http request with agent name" do
+    @api.user_agent.agent_name.should eql('ruby-echonest/' + Echonest::VERSION)
+  end
+
+  describe '#track' do
+    it 'should return track methods' do
+      track = @api.track
+      track.class.should eql(Echonest::ApiMethods::Track)
+      track.instance_eval { @api }.should eql(@api)
+    end
+  end
+
+  describe '#artist' do
+    it 'should return artist methods' do
+      artist = @api.artist('Weezer')
+      artist.class.should eql(Echonest::ApiMethods::Artist)
+      artist.instance_eval {@api}.should eql(@api)
+    end
+
+    it 'should return artist methods even artist name was empty' do
+      artist = @api.artist
+      artist.class.should eql(Echonest::ApiMethods::Artist)
+      artist.instance_eval {@api}.should eql(@api)
+    end
+  end
+
+  describe '#song' do
+    it 'should return song methods' do
+      song = @api.song
+      song.class.should eql(Echonest::ApiMethods::Song)
+      song.instance_eval {@api}.should eql(@api)
+    end
+  end
+
+  describe '#playlist' do
+    it 'should return playlist methods' do
+      playlist = @api.playlist
+      playlist.class.should eql(Echonest::ApiMethods::Playlist)
+      playlist.instance_eval {@api}.should eql(@api)
+    end
+  end
+
+  it 'should have traditional API methods' do
+    filename = fixture('sample.mp3')
+    analysis = Echonest::Analysis.new(open(fixture('analysis.json')).read)
+    track = Echonest::ApiMethods::Track.new(@api)
+
+    %w/tempo duration end_of_fade_in key loudness mode start_of_fade_out time_signature bars beats sections tatums segments/.
+      each do |method|
+
+      @api.should_receive(:track).and_return(track)
+      track.should_receive(:analysis).with(filename).and_return(analysis)
+      analysis.should_receive(method.to_sym)
+
+      @api.send('get_' + method, filename)
+    end
+  end
+
+  def make_connection_stub(content, method)
+    @api.user_agent.stub!(method.to_s + '_content').and_return(content)
+  end
+end

data/spec/apimethods_base_spec.rb

@@ -0,0 +1,207 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'spec_helper'
+require "echonest"
+
+include SpecHelper
+
+describe Echonest::ApiMethods::Base do
+  before do
+    @api = Echonest::Api.new('8TPE3VC60ODJTNTFE')
+    @base = Echonest::ApiMethods::Base.new(@api)
+  end
+
+  it "should call @api.request" do
+    @api.should_receive(:request).with(:get, 'method_foo', {:hash => 'paramerter'})
+    @base.request(:get, 'method_foo', {:hash => 'paramerter'})
+  end
+
+  describe ".build_params_with_validation" do
+    it "should pass validation for required key" do
+      args = {
+        :required => {
+          :key1 => 'value1',
+        },
+      }
+      Echonest::ApiMethods::Base.build_params_with_validation(
+        args,
+        %w[key1],
+        [],
+        []).should == {:key1 => 'value1'}
+    end
+
+    it "should raise error if required key not exist in parametor" do
+      lambda {
+        args = {
+          :required => {
+            :key2 => 'value2',
+          },
+        }
+        Echonest::ApiMethods::Base.build_params_with_validation(
+          args,
+          %w[key1],
+          [],
+          [])
+      }.should raise_error(ArgumentError, 'key1 is required')
+    end
+
+    it "should pass validation for required_any key" do
+      args = {
+        :required_any => {
+          :key1 => 'value1',
+        },
+      }
+      Echonest::ApiMethods::Base.build_params_with_validation(
+        args,
+        [],
+        %w[key1 key2],
+        []).should == {:key1 => 'value1'}
+
+      args = {
+        :required_any => {
+          :key2 => 'value2',
+        },
+      }
+      Echonest::ApiMethods::Base.build_params_with_validation(
+        args,
+        [],
+        %w[key1 key2],
+        []).should == {:key2 => 'value2'}
+    end
+
+    it "should raise error if required_any key not exist in parametor" do
+      lambda {
+        args = {
+          :required_any => {
+            :key3 => 'value3',
+          },
+        }
+        Echonest::ApiMethods::Base.build_params_with_validation(
+          args,
+          [],
+          %w[key1 key2],
+          [])
+      }.should raise_error(ArgumentError, 'key1 or key2 is required')
+    end
+
+    it "should pass validation for option key" do
+      args = {
+        :option => {
+          :key1 => 'value1',
+        },
+      }
+      Echonest::ApiMethods::Base.build_params_with_validation(
+        args,
+        [],
+        [],
+        %w[key1 key2]).should == {:key1 => 'value1'}
+    end
+
+    it "should empty hash for option if keys for option not exist in parametor" do
+      args = {
+        :option => {
+          :key3 => 'value3',
+        },
+      }
+      Echonest::ApiMethods::Base.build_params_with_validation(
+        args,
+        [],
+        [],
+        %w[key1 key2]).should == {}
+    end
+
+    it "should pass validation for required, required_any and option keys" do
+      args = {
+        :required => {
+          :key1 => 'value1',
+        },
+        :required_any => {
+          :key3 => 'value3',
+        },
+        :option => {
+          :key4 => 'value4',
+          :key5 => 'value5',
+        },
+      }
+      Echonest::ApiMethods::Base.build_params_with_validation(
+        args, 
+        %w[key1],
+        %w[key2 key3],
+        %w[key4 key5 key6]).should == {
+        :key1 => 'value1',
+        :key3 => 'value3',
+        :key4 => 'value4',
+        :key5 => 'value5',
+      }
+    end
+  end
+
+  describe ".validator" do
+    it "should return Proc instance" do
+      Echonest::ApiMethods::Base.validator(%w[required], %w[required_any], %w[option]).should be_an_instance_of(Proc)
+    end
+  end
+
+  describe ".method_with_option" do
+    before do
+      class FooBar < Echonest::ApiMethods::Base
+      end
+      @foobar = FooBar.new('dummy')
+    end
+
+    it "should define_method with option parametor" do
+      @foobar.class.class_eval do
+        def request(p1, p2, p3)
+          p1.should == 'foobar/baz'
+          p2.should == :get
+          p3.should == {:k1 => 'v1'}
+          'test response'
+        end
+
+        method_with_option('baz', %w[k1 k2]) do |response|
+          response.should == 'test response'
+        end
+      end
+
+      @foobar.baz(:k1 => 'v1')
+    end
+  end
+
+  describe ".method_with_required_any" do
+    before do
+      class FooBar < Echonest::ApiMethods::Base
+      end
+      @foobar = FooBar.new('dummy')
+    end
+
+    it "should define_method with option parametor" do
+      @foobar.class.class_eval do
+        def request(p1, p2, p3)
+          p1.should == 'category/baz'
+          p2.should == :get
+          p3.should == {
+            :rk1 => 'rv1',
+            :rak1 => 'ravv1',
+            :ok1 => 'ov1'
+          }
+          'test response'
+        end
+
+        method_with_required_any(
+          'Category',
+          'baz',
+          :get,
+          %w[rk1],
+          %w[rak1 rak2],
+          %w[ok1 ok2],
+          lambda{|s| {:rak1 => 'ravv1'}},
+          lambda{|response| response.should == 'test response'})
+      end
+
+      @foobar.baz(
+        :rk1 => 'rv1',
+        :ok1 => 'ov1')
+    end
+  end
+
+end

data/spec/artist_spec.rb

@@ -0,0 +1,184 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'spec_helper'
+require "echonest"
+
+include SpecHelper
+
+describe Echonest::ApiMethods::Artist do
+  before do
+    @api = Echonest::Api.new('8TPE3VC60ODJTNTFE')
+    @artist = Echonest::ApiMethods::Artist.new(@api)
+  end
+
+  def self.describe_bundle_for_artist(method, options=nil)
+    describe "#{method}" do
+      it "should request to artist/#{method} with name" do
+        @api.should_receive(:request).with(
+          "artist/#{method}",
+          :get,
+          :name => 'Weezer').and_return{ Echonest::Response.new('{"hello":"world"}') }
+
+        @artist.artist_name = 'Weezer'
+        @artist.send(method)
+      end
+
+      it "should request to artist/#{method} with id" do
+        @api.should_receive(:request).with(
+          "artist/#{method}",
+          :get,
+          :id => '1234').and_return{ Echonest::Response.new('{"hello":"world"}') }
+
+        @artist.artist_id = '1234'
+        @artist.send(method)
+      end
+
+      it "should request to artist/#{method} with option" do
+        options.each do |opt|
+          @api.should_receive(:request).with(
+            "artist/#{method}",
+            :get,
+            opt.merge(:name => 'Weezer')).and_return{ Echonest::Response.new('{"hello":"world"}') }
+
+          @artist.artist_name = 'Weezer'
+          @artist.send(method, opt)
+        end
+      end
+    end
+  end
+
+  def self.describe_bundle_for_option(method, options=nil)
+    describe "#{method}" do
+      it "should request to artist/#{method}" do
+        @api.should_receive(:request).with(
+          "artist/#{method}",
+          :get,
+          {}).and_return{ Echonest::Response.new('{"hello":"world"}') }
+
+        @artist.send(method)
+      end
+
+      it "should request to artist/#{method} with option" do
+        options.each do |opt|
+          @api.should_receive(:request).with(
+            "artist/#{method}",
+            :get,
+            opt).and_return{ Echonest::Response.new('{"hello":"world"}') }
+
+          @artist.send(method, opt)
+        end
+      end
+    end
+  end
+
+  describe_bundle_for_artist('audio', [
+    {:format => 'json'},
+    {:format => 'json', :results => 100},
+    {:format => 'json', :results => 100, :start => 20}
+  ])
+
+  describe_bundle_for_artist('biographies', [
+    {:format => 'json'},
+    {:format => 'json', :results => 100},
+    {:format => 'json', :results => 100, :start => 20},
+
+    {:format => 'json', :results => 100, :start => 20, :license => 'echo-source'},
+    {:format => 'json', :results => 100, :start => 20, :license => ['echo-source', 'cc-by-nc']}
+  ])
+
+  describe_bundle_for_artist('blogs', [
+    {:format => 'json'},
+    {:format => 'json', :results => 100},
+    {:format => 'json', :results => 100, :start => 20}
+  ])
+
+  describe_bundle_for_artist('familiarity', [
+    {:format => 'json'},
+    {:format => 'json', :results => 100},
+    {:format => 'json', :results => 100, :start => 20}
+  ])
+
+  describe_bundle_for_artist('hotttnesss', [
+    {:format => 'json'},
+    {:format => 'json', :results => 100},
+    {:format => 'json', :results => 100, :start => 20}
+  ])
+
+  describe_bundle_for_artist('images', [
+    {:format => 'json'},
+    {:format => 'json', :results => 100},
+    {:format => 'json', :results => 100, :start => 20},
+    {:format => 'json', :results => 100, :start => 20, :license => 'echo-source'},
+    {:format => 'json', :results => 100, :start => 20, :license => ['echo-source', 'cc-by-nc']}
+  ])
+
+  describe_bundle_for_artist('news', [
+    {:format => 'json'},
+    {:format => 'json', :results => 100},
+    {:format => 'json', :results => 100, :start => 20}
+  ])
+
+  describe_bundle_for_artist('profile', [
+    {:format => 'json'},
+    {:format => 'json', :results => 100},
+    {:format => 'json', :results => 100, :start => 20},
+    {:format => 'json', :results => 100, :start => 20, :bucket => 'audio'},
+    {:format => 'json', :results => 100, :start => 20, :bucket => ['audio', 'video']}
+  ])
+
+  describe_bundle_for_artist('reviews', [
+    {:format => 'json'},
+    {:format => 'json', :results => 100},
+    {:format => 'json', :results => 100, :start => 20}
+  ])
+
+  describe_bundle_for_option('search', [
+    {:format => 'json'},
+    {:format => 'json', :results => 100},
+    {:format => 'json', :results => 100, :bucket => 'audio'},
+    {:format => 'json', :results => 100, :bucket => %w[audio biographies blogs id:musicbrainz]}
+  ])
+
+  describe_bundle_for_artist('songs', [
+    {:format => 'json'},
+    {:format => 'json', :results => 100},
+    {:format => 'json', :results => 100, :bucket => 'audio'},
+    {:format => 'json', :results => 100, :bucket => %w[audio biographies blogs id:musicbrainz]}
+  ])
+
+  describe_bundle_for_artist('similar', [
+    {:format => 'json'},
+    {:format => 'json', :results => 100},
+    {:format => 'json', :results => 100, :max_familiarity => 0.9},
+    {:format => 'json', :results => 100, :bucket => 'audio'},
+    {:format => 'json', :results => 100, :bucket => %w[audio biographies blogs id:musicbrainz]}
+  ])
+
+  describe_bundle_for_artist('terms', [
+    {:format => 'json'},
+    {:format => 'json', :sort => 'weight'}
+  ])
+
+  describe_bundle_for_option('top_hottt', [
+    {:format => 'json'},
+    {:format => 'json', :results => 100},
+    {:format => 'json', :results => 100, :type => 'normal'},
+    {:format => 'json', :results => 100, :bucket => 'audio'},
+    {:format => 'json', :results => 100, :bucket => %w[audio biographies blogs id:musicbrainz]}
+  ])
+
+  describe_bundle_for_option('top_terms', [
+    {:format => 'json'},
+    {:format => 'json', :results => 100}
+  ])
+
+  describe_bundle_for_artist('urls', [
+    {:format => 'json'}
+  ])
+
+  describe_bundle_for_artist('video', [
+    {:format => 'json'},
+    {:format => 'json', :results => 100},
+    {:format => 'json', :results => 100, :start => 20}
+  ])
+end

data/spec/echonest_spec.rb

@@ -0,0 +1,12 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'spec_helper'
+require "echonest"
+
+include SpecHelper
+
+describe Echonest do
+  it "should return an instance of Echonest::Api" do
+    Echonest('XXXXXXXX').should be_an_instance_of(Echonest::Api)
+  end
+end