strava-ruby-client 0.1.0 → 0.2.0

data/spec/fixtures/strava/oauth_token_refresh_token.yml

@@ -1,52 +0,0 @@
----
-http_interactions:
-- request:
-    method: post
-    uri: https://www.strava.com/oauth/token
-    body:
-      encoding: UTF-8
-      string: client_id=24523&client_secret=client-secret&grant_type=refresh_token&refresh_token=refresh-token
-    headers:
-      Accept:
-      - application/json; charset=utf-8
-      User-Agent:
-      - Strava Ruby Client/0.1.0
-      Content-Type:
-      - application/x-www-form-urlencoded
-      Accept-Encoding:
-      - gzip;q=1.0,deflate;q=0.6,identity;q=0.3
-  response:
-    status:
-      code: 200
-      message: OK
-    headers:
-      Date:
-      - Thu, 22 Nov 2018 22:31:57 GMT
-      Content-Type:
-      - application/json; charset=UTF-8
-      Transfer-Encoding:
-      - chunked
-      Connection:
-      - keep-alive
-      Cache-Control:
-      - max-age=0, private, must-revalidate
-      Via:
-      - 1.1 linkerd
-      Status:
-      - 200 OK
-      X-Request-Id:
-      - df1c7766-41ac-44e5-b2a1-fc96486b2c7c
-      Etag:
-      - W/"0f3eb115bd7d2ef9718c83ece058e3f9"
-      X-Frame-Options:
-      - SAMEORIGIN,DENY
-      X-Content-Type-Options:
-      - nosniff
-      X-Xss-Protection:
-      - 1; mode=block
-    body:
-      encoding: ASCII-8BIT
-      string: '{"token_type":"Bearer","access_token":"new-access-token","expires_at":1542940199,"expires_in":14282,"refresh_token":"new-refresh-token"}'
-    http_version:
-  recorded_at: Thu, 22 Nov 2018 22:31:57 GMT
-recorded_with: VCR 4.0.0

data/spec/spec_helper.rb

@@ -1,10 +0,0 @@
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..'))
-
-require 'rubygems'
-require 'rspec'
-
-require 'strava-ruby-client'
-
-Dir[File.join(File.dirname(__FILE__), 'support', '**/*.rb')].each do |file|
-  require file
-end

data/spec/strava/api/client_spec.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Strava::Api::Client do
-  before do
-    Strava::Api::Config.reset
-  end
-  it_behaves_like 'web client'
-  context 'with a token' do
-    let(:client) { Strava::Api::Client.new(access_token: ENV['STRAVA_ACCESS_TOKEN'] || 'access-token') }
-    describe '#athlete', vcr: { cassette_name: 'client_athlete' } do
-      let(:athlete) { client.athlete }
-      it 'returns athlete' do
-        expect(athlete).to be_a Strava::Models::Athlete
-        expect(athlete.id).to eq 26_462_176
-        expect(athlete.created_at).to eq Time.parse('2017-11-28 19:05:35 UTC')
-        expect(athlete.updated_at).to eq Time.parse('2018-11-19 01:44:15 UTC')
-        expect(athlete.firstname).to eq 'Daniel'
-        expect(athlete.lastname).to eq 'Block'
-        expect(athlete.city).to eq 'New York'
-        expect(athlete.email).to eq 'dblock@example.com'
-      end
-    end
-    describe '#athlete_activities', vcr: { cassette_name: 'client_athlete_activities' } do
-      let(:athlete_activities) { client.athlete_activities }
-      it 'returns athlete activities' do
-        expect(athlete_activities).to be_a Enumerable
-        expect(athlete_activities.count).to eq 30
-        activity = athlete_activities.first
-        expect(activity.id).to eq 1_972_463_847
-        expect(activity.athlete).to be_a Strava::Models::Athlete
-        expect(activity.map).to be_a Strava::Models::Map
-        expect(activity.start_date).to be_a Time
-      end
-    end
-  end
-end

data/spec/strava/api/config_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-describe Strava::Api::Config do
-  before do
-    Strava::Api.config.reset
-  end
-  describe '#defaults' do
-    it 'sets endpoint' do
-      expect(Strava::Api.config.endpoint).to eq 'https://www.strava.com/api/v3'
-    end
-  end
-  describe '#configure' do
-    before do
-      Strava::Api.configure do |config|
-        config.endpoint = 'updated'
-      end
-    end
-    it 'sets endpoint' do
-      expect(Strava::Api.config.endpoint).to eq 'updated'
-    end
-  end
-end

data/spec/strava/oauth/client_spec.rb

@@ -1,120 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Strava::OAuth::Client do
-  before do
-    Strava::OAuth::Config.reset
-  end
-  it_behaves_like 'web client'
-  context 'with defaults' do
-    let(:client) { Strava::OAuth::Client.new }
-    describe '#initialize' do
-      it 'sets endpoint' do
-        expect(client.endpoint).to eq 'https://www.strava.com/oauth'
-      end
-      Strava::OAuth::Config::ATTRIBUTES.each do |key|
-        it "sets #{key}" do
-          expect(client.send(key)).to eq Strava::OAuth::Config.send(key)
-        end
-      end
-      context '#authorize_url' do
-        it 'requires client id' do
-          expect { client.authorize_url }.to raise_error ArgumentError, 'Missing Strava client id.'
-        end
-      end
-    end
-  end
-  context 'with custom settings' do
-    describe '#initialize' do
-      Strava::OAuth::Config::ATTRIBUTES.each do |key|
-        context key do
-          let(:client) { Strava::OAuth::Client.new(key => 'custom') }
-          it "sets #{key}" do
-            expect(client.send(key)).to_not eq Strava::OAuth::Config.send(key)
-            expect(client.send(key)).to eq 'custom'
-          end
-        end
-      end
-    end
-  end
-  context 'global config' do
-    after do
-      Strava::OAuth::Client.config.reset
-    end
-    let(:client) { Strava::OAuth::Client.new }
-    context 'client id and secret' do
-      before do
-        Strava::OAuth::Client.configure do |config|
-          config.client_id = 'custom client id'
-          config.client_secret = 'custom client secret'
-        end
-      end
-      describe '#initialize' do
-        it 'sets client id and secret' do
-          expect(client.client_id).to eq 'custom client id'
-          expect(client.client_secret).to eq 'custom client secret'
-        end
-      end
-    end
-  end
-  context 'with a client id and secret' do
-    let(:client) { Strava::OAuth::Client.new(client_id: '12345', client_secret: 'client-secret') }
-    context '#authorize_url' do
-      it 'returns url' do
-        expect(client.authorize_url).to eq 'https://www.strava.com/oauth/authorize?approval_prompt=auto&client_id=12345&redirect_uri=http%3A%2F%2Flocalhost&response_type=code&scope=read'
-      end
-      it 'returns url with custom options' do
-        expect(
-          client.authorize_url(
-            redirect_uri: 'https://example.com/oauth',
-            approval_prompt: 'force',
-            response_type: 'code',
-            scope: 'activity:read_all',
-            state: 'magic'
-          )
-        ).to eq 'https://www.strava.com/oauth/authorize?approval_prompt=force&client_id=12345&redirect_uri=https%3A%2F%2Fexample.com%2Foauth&response_type=code&scope=activity%3Aread_all&state=magic'
-      end
-    end
-    context '#oauth_token' do
-      it 'errors with an invalid client id', vcr: { cassette_name: 'oauth_token_invalid_client' } do
-        expect { client.oauth_token(code: 'code') }.to raise_error Strava::Errors::Fault do |e|
-          expect(e.message).to eq 'Bad Request'
-          expect(e.errors).to eq([{ 'code' => 'invalid', 'field' => 'client_id', 'resource' => 'Application' }])
-        end
-      end
-      it 'errors with an invalid code', vcr: { cassette_name: 'oauth_token_invalid_code' } do
-        expect { client.oauth_token(code: 'code') }.to raise_error Faraday::ClientError do |e|
-          expect(e.message).to eq 'Bad Request'
-          expect(e.errors).to eq([{ 'code' => 'invalid', 'field' => 'code', 'resource' => 'RequestToken' }])
-        end
-      end
-      it 'performs the initial token exchange', vcr: { cassette_name: 'oauth_token_authorization_code' } do
-        token = client.oauth_token(code: 'deadbeef585a6edb1f00309d3e1e0fec74973fb0')
-        expect(token).to be_a Strava::Models::Token
-        expect(token.access_token).to eq 'deadbeefd7ab44704fb2a146bd98c7a349a2b43d'
-        expect(token.refresh_token).to eq 'deadbeef9d64b225d0c50db4854a8d6c8757702d'
-        expect(token.token_type).to eq 'Bearer'
-        expect(token.expires_in).to eq 21_600
-        expect(token.expires_at).to eq Time.at(1_542_940_199)
-        athlete = token.athlete
-        expect(athlete).to be_a Strava::Models::Athlete
-        expect(athlete.updated_at).to eq Time.parse('2018-11-19 01:44:15 UTC')
-        expect(athlete.firstname).to eq 'Daniel'
-        expect(athlete.lastname).to eq 'Block'
-        expect(athlete.city).to eq 'New York'
-      end
-      it 'refreshes the token', vcr: { cassette_name: 'oauth_token_refresh_token' } do
-        token = client.oauth_token(
-          refresh_token: '8b15b6bb9d64a225d0c50db4854a8d6c8757702d',
-          grant_type: 'refresh_token'
-        )
-        expect(token).to be_a Strava::Models::Token
-        expect(token.access_token).to eq 'new-access-token'
-        expect(token.refresh_token).to eq 'new-refresh-token'
-        expect(token.token_type).to eq 'Bearer'
-        expect(token.expires_in).to eq 14_282
-        expect(token.expires_at).to eq Time.at(1_542_940_199)
-        expect(token.athlete).to be nil
-      end
-    end
-  end
-end

data/spec/strava/oauth/config_spec.rb

@@ -1,24 +0,0 @@
-require 'spec_helper'
-
-describe Strava::OAuth::Config do
-  describe '#defaults' do
-    it 'sets endpoint' do
-      expect(Strava::OAuth.config.endpoint).to eq 'https://www.strava.com/oauth'
-      expect(Strava::OAuth.config.client_id).to be nil
-      expect(Strava::OAuth.config.client_secret).to be nil
-    end
-  end
-  describe '#configure' do
-    before do
-      Strava::OAuth.configure do |config|
-        config.client_id = 'client id'
-        config.client_secret = 'client secret'
-      end
-    end
-    it 'sets client id and secret' do
-      expect(Strava::OAuth.config.endpoint).to eq 'https://www.strava.com/oauth'
-      expect(Strava::OAuth.config.client_id).to eq 'client id'
-      expect(Strava::OAuth.config.client_secret).to eq 'client secret'
-    end
-  end
-end

data/spec/strava/version_spec.rb

@@ -1,7 +0,0 @@
-require 'spec_helper'
-
-describe Strava do
-  it 'has a version' do
-    expect(Strava::VERSION).to_not be nil
-  end
-end

data/spec/strava/web/client_spec.rb

@@ -1,9 +0,0 @@
-require 'spec_helper'
-
-describe Strava::Web::Client do
-  describe '#endpoint' do
-    it 'is not implemented' do
-      expect { subject.endpoint }.to raise_error NotImplementedError
-    end
-  end
-end

data/spec/strava/web/config_spec.rb

@@ -1,4 +0,0 @@
-require 'spec_helper'
-
-describe Strava::Web::Config do
-end

data/spec/support/shared/it_behaves_like_web_client.rb

@@ -1,131 +0,0 @@
-require 'spec_helper'
-
-RSpec.shared_examples 'web client' do
-  before do
-    described_class.config.reset
-    Strava::Web::Config.reset
-  end
-  context 'with defaults' do
-    let(:client) { described_class.new }
-    context '#initialize' do
-      it 'implements endpoint' do
-        expect(client.endpoint).to_not be nil
-      end
-      it 'includes default http configuration' do
-        expect(client.user_agent).to eq 'Strava Ruby Client/0.1.0'
-      end
-      it 'sets user-agent' do
-        expect(client.user_agent).to eq Strava::Web::Config.user_agent
-        expect(client.user_agent).to include Strava::VERSION
-      end
-      (Strava::Web::Config::ATTRIBUTES - [:logger]).each do |key|
-        it "sets #{key}" do
-          expect(client.send(key)).to eq Strava::Web::Config.send(key)
-        end
-      end
-    end
-  end
-  context 'with custom settings' do
-    context '#initialize' do
-      Strava::Web::Config::ATTRIBUTES.each do |key|
-        context key.to_s do
-          let(:client) { described_class.new(key => 'custom') }
-          it "sets #{key}" do
-            expect(client.send(key)).to_not eq Strava::Web::Config.send(key)
-            expect(client.send(key)).to eq 'custom'
-          end
-        end
-      end
-    end
-  end
-  context 'global config' do
-    let(:client) { described_class.new }
-    context 'user-agent' do
-      before do
-        Strava::Web::Client.configure do |config|
-          config.user_agent = 'custom/user-agent'
-        end
-      end
-      context '#initialize' do
-        it 'sets user-agent' do
-          expect(client.user_agent).to eq 'custom/user-agent'
-        end
-        it 'creates a connection with the custom user-agent' do
-          expect(client.send(:connection).headers).to include(
-            'Accept' => 'application/json; charset=utf-8',
-            'User-Agent' => 'custom/user-agent'
-          )
-        end
-      end
-    end
-    context 'proxy' do
-      before do
-        Strava::Web::Client.configure do |config|
-          config.proxy = 'http://localhost:8080'
-        end
-      end
-      context '#initialize' do
-        it 'sets proxy' do
-          expect(client.proxy).to eq 'http://localhost:8080'
-        end
-        it 'creates a connection with the proxy' do
-          expect(client.send(:connection).proxy.uri.to_s).to eq 'http://localhost:8080'
-        end
-      end
-    end
-    context 'SSL options' do
-      before do
-        Strava::Web::Client.configure do |config|
-          config.ca_path = '/ca_path'
-          config.ca_file = '/ca_file'
-        end
-      end
-      context '#initialize' do
-        it 'sets ca_path and ca_file' do
-          expect(client.ca_path).to eq '/ca_path'
-          expect(client.ca_file).to eq '/ca_file'
-        end
-        it 'creates a connection with ssl options' do
-          ssl = client.send(:connection).ssl
-          expect(ssl.ca_path).to eq '/ca_path'
-          expect(ssl.ca_file).to eq '/ca_file'
-        end
-      end
-    end
-    context 'logger option' do
-      let(:logger) { Logger.new(STDOUT) }
-      before do
-        Strava::Web::Client.configure do |config|
-          config.logger = logger
-        end
-      end
-      context '#initialize' do
-        it 'sets logger' do
-          expect(client.logger).to eq logger
-        end
-        it 'creates a connection with a logger' do
-          expect(client.send(:connection).builder.handlers).to include ::Faraday::Response::Logger
-        end
-      end
-    end
-    context 'timeout options' do
-      before do
-        Strava::Web::Client.configure do |config|
-          config.timeout = 10
-          config.open_timeout = 15
-        end
-      end
-      context '#initialize' do
-        it 'sets timeout and open_timeout' do
-          expect(client.timeout).to eq 10
-          expect(client.open_timeout).to eq 15
-        end
-        it 'creates a connection with timeout options' do
-          conn = client.send(:connection)
-          expect(conn.options.timeout).to eq 10
-          expect(conn.options.open_timeout).to eq 15
-        end
-      end
-    end
-  end
-end

data/spec/support/vcr.rb

@@ -1,12 +0,0 @@
-require 'vcr'
-require 'webmock/rspec'
-
-VCR.configure do |config|
-  config.cassette_library_dir = 'spec/fixtures/strava'
-  config.hook_into :webmock
-  config.default_cassette_options = { record: :new_episodes }
-  config.configure_rspec_metadata!
-  config.before_record do |i|
-    i.response.body.force_encoding('UTF-8')
-  end
-end

data/strava-ruby-client.gemspec

@@ -1,21 +0,0 @@
-$LOAD_PATH.push File.expand_path('lib', __dir__)
-require 'strava/version'
-
-Gem::Specification.new do |s|
-  s.name = 'strava-ruby-client'
-  s.bindir = 'bin'
-  s.version = Strava::VERSION
-  s.authors = ['Daniel Doubrovkine']
-  s.email = 'dblock@dblock.org'
-  s.platform = Gem::Platform::RUBY
-  s.required_rubygems_version = '>= 1.3.6'
-  s.files = `git ls-files`.split("\n")
-  s.test_files = `git ls-files -- spec/*`.split("\n")
-  s.require_paths = ['lib']
-  s.homepage = 'http://github.com/dblock/strava-ruby-client'
-  s.licenses = ['MIT']
-  s.summary = 'Strava API Ruby client.'
-  s.add_dependency 'faraday', '>= 0.9'
-  s.add_dependency 'faraday_middleware'
-  s.add_dependency 'hashie'
-end