espn 0.1.3 → 0.2.0

data/spec/espn/helpers_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+class MockHelper
+  include ESPN::Helpers
+end
+
+describe ESPN::Helpers do
+  before do
+    @helper = MockHelper.new
+  end
+
+  describe '#blank?' do
+    it 'should be true for an empty string' do
+      @helper.blank?('').should be_true
+    end
+
+    it 'should be false for a non empty string' do
+      @helper.blank?('foo').should be_false
+    end
+
+    it 'should be true for a nil object' do
+      @helper.blank?(nil).should be_true
+    end
+
+    it 'should be false for a non nil object' do
+      @helper.blank?(Object.new).should be_false
+    end
+  end
+
+
+end

data/spec/espn/mapper_spec.rb

@@ -0,0 +1,136 @@
+require 'spec_helper'
+
+class MockMapper
+  include ESPN::Mapper
+end
+
+describe ESPN::Mapper do
+  before do
+    @mapper = MockMapper.new
+  end
+
+  describe '#map_league_to_sport' do
+    describe 'param types' do
+      it 'should accept a string' do
+        @mapper.map_league_to_sport('nhl').should include(sport: 'hockey')
+      end
+
+      it 'should accept a symbol' do
+        @mapper.map_league_to_sport(:mlb).should include(sport: 'baseball')
+      end
+    end
+
+    context 'with a league that has no mapping' do
+      it 'should include nil for the sport' do
+        @mapper.map_league_to_sport('foobar').should include(sport: nil)
+      end
+    end
+
+    context 'with a given league (mma)' do
+      ESPN::Mapper::LEAGUE_MAP[:mma].each do |league|
+        it "should map #{league} to mma" do
+          @mapper.map_league_to_sport(league).should include(sport: 'mma')
+        end
+      end
+    end
+  end
+
+  describe '#sport?' do
+    context 'with a valid sport' do
+      it 'should return true with a symbol' do
+        @mapper.sport?(:'horse-racing').should be_true
+      end
+
+      it 'should return true with a string' do
+        @mapper.sport?(:baseball).should be_true
+      end
+    end
+
+    context 'with an invalid sport' do
+      it 'should return false' do
+        @mapper.sport?(:mlb).should be_false
+      end
+    end
+  end
+
+  describe '#league?' do
+    context 'with a valid league' do
+      it 'should return true with a symbol' do
+        @mapper.league?(:mlb).should be_true
+      end
+
+      it 'should return true with a string' do
+        @mapper.league?('concacaf.champions_cup').should be_true
+      end
+    end
+
+    context 'with an invalid league' do
+      it 'should return false' do
+        @mapper.league?(:baseball).should be_false
+      end
+    end
+  end
+
+  describe '#extract_sport_and_league' do
+    context 'with a league' do
+      it 'should return the sport, league' do
+        @mapper.extract_sport_and_league(['mlb']).should eq(['baseball', 'mlb'])
+      end
+
+      it 'should convert symbols to strings' do
+        @mapper.extract_sport_and_league([:mlb]).should eq(['baseball', 'mlb'])
+      end
+    end
+
+    context 'with a sport' do
+      it 'should return the sport and a blank string' do
+        results = @mapper.extract_sport_and_league(['horse-racing'])
+        results.should eq(['horse-racing', ''])
+      end
+
+      it 'should convert symbols to strings' do
+        results = @mapper.extract_sport_and_league([:baseball])
+        results.should eq(['baseball', ''])
+      end
+    end
+
+    context 'with a league and a sport' do
+      it 'should return the first two args' do
+        results = @mapper.extract_sport_and_league(['foo', 'bar'])
+        results.should eq(['foo', 'bar'])
+      end
+
+      it 'should convert symbols to strings' do
+        results = @mapper.extract_sport_and_league([:foo, :bar])
+        results.should eq(['foo', 'bar'])
+      end
+    end
+
+    context 'with more than two arguments' do
+      it 'should return the first two args' do
+        results = @mapper.extract_sport_and_league(['foo', 'bar', 'baz'])
+        results.should eq(['foo', 'bar'])
+      end
+    end
+
+    context 'with sport in the opts hash' do
+      it 'should return the sport from the opts hash' do
+        results = @mapper.extract_sport_and_league(['foo'], sport: 'bar')
+        results.should eq(['bar', ''])
+      end
+    end
+
+    context 'with league in the opts hash' do
+      it 'should return the league from the opts hash' do
+        results = @mapper.extract_sport_and_league(['mlb'], league: 'foo')
+        results.should eq(['baseball', 'foo'])
+      end
+
+      it 'should map the league to a sport' do
+        results = @mapper.extract_sport_and_league([], league: 'mlb')
+        results.should eq(['baseball', 'mlb'])
+      end
+    end
+  end
+
+end

data/spec/espn/request_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+describe ESPN::Request do
+  before do
+    @client = ESPN::Client.new
+  end
+
+  describe '#get' do
+    it 'should build a url from a template' do
+      opts = { foo: 'bar' }
+      pattern = '/:foo/baz'
+      @client.should_receive(:request).with(:get, '/bar/baz', opts)
+      @client.get(pattern, opts)
+    end
+
+    it 'should call request' do
+      opts = { foo: 'bar' }
+      pattern = '/foo/bar'
+      @client.should_receive(:request).with(:get, pattern, opts)
+      @client.get(pattern, opts)
+    end
+  end
+
+  describe '#build_url' do
+    it 'should remove duplicate slashes' do
+      @client.send(:build_url, '/foo///bar', {}).should eq('/foo/bar')
+    end
+
+    it 'should remove trailing slashes' do
+      @client.send(:build_url, '/foo/bar/', {}).should eq('/foo/bar')
+    end
+
+    it 'should expand a pattern' do
+      fragments = { foo: 'bar' }
+      mock_uri = double('URITemplate')
+      URITemplate.stub(:new).and_return(mock_uri)
+      mock_uri.should_receive(:expand).with(fragments).and_return('/')
+      @client.send(:build_url, '/:some/pattern', fragments)
+    end
+
+    context 'when sport is not a fragment' do
+      it 'should delete the league fragment' do
+        fragments = { league: 'somerandomleague' }
+        fragments.should_receive(:delete).with(:league)
+        @client.send(:build_url, ':some/pattern', fragments)
+      end
+    end
+
+    context 'when sport is a fragment' do
+      it 'should not delete the league fragment' do
+        fragments = { league: 'mlb', sport: 'baseball' }
+        fragments.should_not_receive(:delete)
+        @client.send(:build_url, ':some/pattern', fragments)
+      end
+    end
+
+    context 'when method is not a fragment' do
+      it 'should remove headlines from the pattern' do
+        pattern = ':sport/:league/news/headlines/:method'
+        pattern.should_receive(:gsub!).with('headlines', '')
+        @client.send(:build_url, pattern, {})
+      end
+    end
+  end
+end

data/spec/espn_spec.rb

@@ -9,12 +9,21 @@ describe ESPN do
   end
 
   describe '.method_missing' do
+    before do
+      @mock_espn = double('ESPN')
+      ESPN.stub(:new).and_return(@mock_espn)
+    end
+
     it 'should call super if ESPN::Client does not respond to the method' do
-      pending
+      @mock_espn.stub(:respond_to?).with(:to_s).and_return(false)
+      @mock_espn.should_not_receive(:to_s)
+      ESPN.to_s
     end
 
     it 'should send the method to a new ESPN::Client if it responds' do
-      pending
+      @mock_espn.stub(:respond_to?).with(:foobar).and_return(true)
+      @mock_espn.should_receive(:send).with(:foobar)
+      ESPN.foobar
     end
   end
 

data/spec/faraday/response/raise_espn_error_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+describe Faraday::Response::RaiseESPNError do
+  before do
+    @class = described_class.new
+  end
+
+  context 'when used' do
+    before do
+      @response = Hashie::Mash.new(method: :get, url: 'http://test')
+      @response.body = Hashie::Mash.new(status: 'error', message: 'foobar')
+    end
+
+    it 'does not raise an error if the response has no body' do
+      @response.body = nil
+      lambda {
+        @class.on_complete(@response)
+      }.should_not raise_error
+    end
+
+    it 'does not raise an error for HTTP 200' do
+      @response.body.code = 200
+      lambda {
+        @class.on_complete(@response)
+      }.should_not raise_error
+    end
+
+    it 'raises an error for HTTP 400' do
+      @response.body.code = 400
+      lambda {
+        @class.on_complete(@response)
+      }.should raise_error(ESPN::BadRequest)
+    end
+
+    it 'raises an error for HTTP 401' do
+      @response.body.code = 401
+      lambda {
+        @class.on_complete(@response)
+      }.should raise_error(ESPN::Unauthorized)
+    end
+
+    it 'raises an error for HTTP 403' do
+      @response.body.code = 403
+      lambda {
+        @class.on_complete(@response)
+      }.should raise_error(ESPN::Forbidden)
+    end
+
+    it 'raises an error for HTTP 404' do
+      @response.body.code = 404
+      lambda {
+        @class.on_complete(@response)
+      }.should raise_error(ESPN::NotFound)
+    end
+
+    it 'raises an error for HTTP 500' do
+      @response.body.code = 500
+      lambda {
+        @class.on_complete(@response)
+      }.should raise_error(ESPN::InternalServerError)
+    end
+
+    it 'raises an error fro HTTP 504' do
+      @response.body.code = 504
+      lambda {
+        @class.on_complete(@response)
+      }.should raise_error(ESPN::GatewayTimeout)
+    end
+  end
+
+  describe '#error_message' do
+    it 'should be formatted correctly' do
+      response = Hashie::Mash.new(method: :get, url: 'http://test')
+      response.body = Hashie::Mash.new(status: 'error', message: 'some error')
+      result = @class.error_message(response)
+      result.should eq('GET http://test: error - some error')
+    end
+  end
+
+end

data/spec/responses/athletes.json

@@ -0,0 +1,51 @@
+{
+    "sports": [{
+        "name": "baseball",
+        "id": 1,
+        "uid": "s:1",
+        "leagues": [{
+            "name": "Major League Baseball",
+            "abbreviation": "mlb",
+            "id": 10,
+            "uid": "s:1~l:10",
+            "groupId": 9,
+            "shortName": "MLB",
+            "athletes": [{
+                "id": 5383,
+                "firstName": "Chase",
+                "lastName": "Utley",
+                "fullName": "Chase Utley",
+                "displayName": "Chase Utley",
+                "shortName": "C. Utley",
+                "links": {
+                    "api": {
+                        "athletes": {
+                            "href": "http://api.espn.com/v1/sports/baseball/mlb/athletes/5383"
+                        },
+                        "news": {
+                            "href": "http://api.espn.com/v1/sports/baseball/mlb/athletes/5383/news"
+                        },
+                        "notes": {
+                            "href": "http://api.espn.com/v1/sports/baseball/mlb/athletes/5383/news/notes"
+                        }
+                    },
+                    "web": {
+                        "athletes": {
+                            "href": "http://espn.go.com/mlb/player/_/id/5383/chase-utley?ex_cid=espnapi_public"
+                        }
+                    },
+                    "mobile": {
+                        "athletes": {
+                            "href": "http://m.espn.go.com/mlb/playercard?playerId=5383&ex_cid=espnapi_public"
+                        }
+                    }
+                }
+            }]
+        }]
+    }],
+    "resultsOffset": 0,
+    "resultsLimit": 50,
+    "resultsCount": 1,
+    "timestamp": "2013-08-27T17:15:39Z",
+    "status": "success"
+}

data/spec/responses/audio.json

@@ -0,0 +1,101 @@
+{
+   "resultsCount":29,
+   "resultsOffset":0,
+   "resultsLimit":10,
+   "recordings":[
+      {
+         "id":8656148,
+         "published":"2012-11-20T17:27:56Z",
+         "premium":false,
+         "headline":"First Take",
+         "shortDescription":"",
+         "description":"Skip Bayless and Stephen A. Smith debate the Bears, the 49ers and Colin Kaepernick, Ed Reed hits, Steelers, Patriots and NFC East.",
+         "links":{
+            "api":{
+               "recordings":{
+                  "href":"http://api.espn.com/v1/audio/recordings/8656148"
+               }
+            },
+            "web":{
+               "href":"http://espn.go.com/espnradio/play?id=8656148&ex_cid=espnapi_internal"
+            },
+            "mobile":{
+               "href":"http://m.espn.go.com/general/play?id=8656148&ex_cid=espnapi_internal"
+            },
+            "source":{
+               "default":{
+                  "href":"http://c.espnradio.com/audio/1259102/firsttake_2012-11-20-122302.mp3"
+               },
+               "bitrate32k":{
+                  "href":"http://c.espnradio.com/audio/1259102/firsttake_2012-11-20-122302.32.mp3"
+               },
+               "bitrate48k":{
+                  "href":"http://c.espnradio.com/audio/1259102/firsttake_2012-11-20-122302.48.mp3"
+               },
+               "bitrate128k":{
+                  "href":"http://c.espnradio.com/audio/1259102/firsttake_2012-11-20-122302.128.mp3"
+               }
+            }
+         },
+         "thumbnails":{
+            "xsmall":{
+               "href":"http://a.espncdn.com/i/espnradio/stations/espn/podcasts/first_take_90.jpg",
+               "width":90,
+               "height":90
+            },
+            "small":{
+               "href":"http://a.espncdn.com/i/espnradio/stations/espn/podcasts/first_take_134.jpg",
+               "width":134,
+               "height":75
+            },
+            "large":{
+               "href":"http://a.espncdn.com/i/espnradio/stations/espn/podcasts/first_take_288.jpg",
+               "width":288,
+               "height":162
+            },
+            "medium":{
+               "href":"http://a.espncdn.com/i/espnradio/stations/espn/podcasts/first_take_203.jpg",
+               "width":203,
+               "height":114
+            },
+            "xlarge":{
+               "href":"http://a.espncdn.com/i/espnradio/stations/espn/podcasts/first_take_300.jpg",
+               "width":300,
+               "height":300
+            }
+         },
+         "categories":[
+            {
+               "podcastId":6247496,
+               "podcast":{
+                  "id":6247496,
+                  "description":"ESPN: First Take",
+                  "links":{
+                     "api":{
+                        "podcasts":{
+                           "href":"http://api.espn.com/v1/audio/podcasts/6247496"
+                        }
+                     },
+                     "web":{
+                        "href":"http://espn.go.com/espnradio/podcast/archive?id=6247496&ex_cid=espnapi_internal"
+                     },
+                     "mobile":{
+                        "href":"http://m.espn.go.com/general/cast?id=6247496&ex_cid=espnapi_internal"
+                     }
+                  }
+               },
+               "description":"ESPN: First Take",
+               "type":"podcast"
+            }
+         ],
+         "keywords":[
+            "1st and 10",
+            "first take",
+            "Skip Bayless",
+            "Stephen A. Smith"
+         ]
+      }
+   ],
+   "timestamp":"2012-11-21T17:21:21Z",
+   "status":"success"
+}