togglv9 0.1.0

data/spec/lib/togglv9/time_entries_spec.rb

@@ -0,0 +1,456 @@
+require 'date'
+
+describe 'Time Entries' do
+  before :all do
+    @toggl = TogglV9::API.new(Testing::API_TOKEN)
+    @workspaces = @toggl.workspaces
+    @workspace_id = @workspaces.first['id']
+  end
+
+  context 'CRUD time entry' do
+    before :each do
+      time_entry_info = {
+        'wid' => @workspace_id,
+        'start' => @toggl.iso8601(DateTime.now),
+        'duration' => 77
+      }
+
+      @expected = time_entry_info.clone
+
+      @time_entry = @toggl.create_time_entry(@workspace_id, time_entry_info)
+    end
+
+    after :each do
+      @toggl.delete_time_entry(@workspace_id, @time_entry['id'])
+    rescue RuntimeError => e
+      if e.message != "HTTP Status: 404"
+        raise e
+      end
+    end
+
+    it 'creates a time entry' do
+      expect(@time_entry['wid']).to eq @expected['wid']
+      expect(@time_entry['duration']).to eq @expected['duration']
+      expect(Time.parse(@time_entry['start'])).to eq Time.parse(@expected['start'])
+    end
+
+    it 'requires a workspace, project, or task to create' do
+      time_entry_info = {
+        'start' => @toggl.iso8601(DateTime.now),
+        'duration' => 77
+      }
+
+      expect {
+        @toggl.create_time_entry(@workspace_id, time_entry_info)
+      }.to raise_error(ArgumentError)
+    end
+
+    it 'gets a time entry' do
+      retrieved_time_entry = @toggl.get_time_entry(@time_entry['id'])
+      retrieved_time_entry.delete('guid')
+
+      ['start', 'stop'].each do |key|
+        expect(retrieved_time_entry[key]).to eq_ts @time_entry[key]
+        retrieved_time_entry.delete(key)
+        @time_entry.delete(key)
+      end
+      expected = @time_entry.clone
+      expected['tags'] ||= []
+      expected['tag_ids'] ||= []
+      expected.delete('uid')
+      expected.delete('wid')
+
+      expect(retrieved_time_entry).to eq expected
+    end
+
+    it 'updates a time entry' do
+      time_entry_info = {
+        'start' => '2010-02-13T23:31:30+00:00',
+        'duration' => 42
+      }
+
+      expected = time_entry_info.clone
+
+      time_entry_updated = @toggl.update_time_entry(@workspace_id, @time_entry['id'], time_entry_info)
+      expect(time_entry_updated['duration']).to eq expected['duration']
+      expect(Time.parse(time_entry_updated['start'])).to eq Time.parse(expected['start'])
+    end
+
+    it 'deletes a time entry' do
+      existing_time_entry = @toggl.get_time_entry(@time_entry['id'])
+      expect(existing_time_entry.has_key?('server_deleted_at')).to eq true
+      expect(existing_time_entry['server_deleted_at']).to eq nil
+
+      deleted_time_entry = @toggl.delete_time_entry(@workspace_id, @time_entry['id'])
+
+      expect { @toggl.get_time_entry(@time_entry['id']) }.to raise_error(RuntimeError, 'HTTP Status: 404')
+    end
+  end
+
+  context '+ UTC offset' do
+    # ISO8601 times with positive '+' UTC offsets must be properly encoded
+
+    before :each do
+      time_entry_info = {
+        'wid' => @workspace_id,
+        'start' => '2016-01-22T12:08:14+02:00',
+        'duration' => 77
+      }
+
+      @expected = time_entry_info.clone
+
+      @time_entry = @toggl.create_time_entry(@workspace_id, time_entry_info)
+    end
+
+    after :each do
+      @toggl.delete_time_entry(@workspace_id, @time_entry['id'])
+    rescue RuntimeError => e
+      if e.message != "HTTP Status: 404"
+        raise e
+      end
+    end
+
+    it 'creates a time entry' do
+      expect(@time_entry['wid']).to eq @expected['wid']
+      expect(@time_entry['duration']).to eq @expected['duration']
+      expect(Time.parse(@time_entry['start'])).to eq Time.parse(@expected['start'])
+    end
+
+    it 'requires a workspace, project, or task to create' do
+      time_entry_info = {
+        'start' => '2016-01-22T12:08:14+02:00',
+        'duration' => 77
+      }
+
+      expect {
+        @toggl.create_time_entry(@workspace_id, time_entry_info)
+      }.to raise_error(ArgumentError)
+    end
+
+    it 'gets a time entry' do
+      retrieved_time_entry = @toggl.get_time_entry(@time_entry['id'])
+      retrieved_time_entry.delete('guid')
+
+      ['start', 'stop'].each do |key|
+        expect(retrieved_time_entry[key]).to eq_ts @time_entry[key]
+        retrieved_time_entry.delete(key)
+        @time_entry.delete(key)
+      end
+      expected = @time_entry.clone
+      expected['tags'] ||= []
+      expected['tag_ids'] ||= []
+      expected.delete('uid')
+      expected.delete('wid')
+
+      expect(retrieved_time_entry).to eq expected
+    end
+
+    it 'updates a time entry' do
+      time_entry_info = {
+        'start' => '2010-02-13T23:31:30+07:00',
+        'duration' => 42
+      }
+
+      expected = time_entry_info.clone
+
+      time_entry_updated = @toggl.update_time_entry(@workspace_id, @time_entry['id'], time_entry_info)
+      expect(time_entry_updated['duration']).to eq expected['duration']
+      expect(Time.parse(time_entry_updated['start'])).to eq Time.parse(expected['start'])
+    end
+
+    it 'deletes a time entry' do
+      existing_time_entry = @toggl.get_time_entry(@time_entry['id'])
+      expect(existing_time_entry.has_key?('server_deleted_at')).to eq true
+
+      deleted_time_entry = @toggl.delete_time_entry(@workspace_id, @time_entry['id'])
+
+      expect { @toggl.get_time_entry(@time_entry['id']) }.to raise_error(RuntimeError, 'HTTP Status: 404')
+    end
+  end
+
+  context 'multiple time entries' do
+    before :all do
+      time_entry_info = {
+        'wid' => @workspace_id,
+        'duration' => 77
+      }
+      @now = DateTime.now
+
+      start = { 'start' => @toggl.iso8601(@now - 9) }
+      @time_entry_nine_days_ago = @toggl.create_time_entry(@workspace_id, time_entry_info.merge(start))
+      @nine_days_ago_id = @time_entry_nine_days_ago['id']
+
+      start = { 'start' => @toggl.iso8601(@now - 7) }
+      @time_entry_last_week = @toggl.create_time_entry(@workspace_id, time_entry_info.merge(start))
+      @last_week_id = @time_entry_last_week['id']
+
+      start = { 'start' => @toggl.iso8601(@now) }
+      @time_entry_now = @toggl.create_time_entry(@workspace_id, time_entry_info.merge(start))
+      @now_id = @time_entry_now['id']
+
+      start = { 'start' => @toggl.iso8601(@now + 7) }
+      @time_entry_next_week = @toggl.create_time_entry(@workspace_id, time_entry_info.merge(start))
+      @next_week_id = @time_entry_next_week['id']
+    end
+
+    after :all do
+      TogglV9SpecHelper.delete_all_time_entries(@toggl)
+    end
+
+    it 'gets time entries (reaching back 9 days up till now)' do
+      ids = @toggl.get_time_entries.map { |t| t['id']}
+      expect(ids.sort).to eq [ @last_week_id, @now_id ]
+    end
+
+    it 'gets time entries after start_date (up till now)' do
+      ids = @toggl.get_time_entries({:start_date => @now - 1}).map { |t| t['id']}
+      expect(ids.sort).to eq [ @now_id ]
+    end
+
+    it 'gets time entries between start_date and end_date' do
+      ids = @toggl.get_time_entries({:start_date => @now - 1, :end_date => @now + 1}).map { |t| t['id']}
+      expect(ids.sort).to eq [ @now_id ]
+    end
+
+    it 'gets time entries in the future' do
+      ids = @toggl.get_time_entries({:start_date => @now - 1, :end_date => @now + 8}).map { |t| t['id']}
+      expect(ids.sort).to eq [ @now_id, @next_week_id ]
+    end
+  end
+
+  context 'start and stop time entry' do
+    it 'starts and stops a time entry' do
+      time_entry_info = {
+        'workspace_id' => @workspace_id,
+        'description' => 'time entry description'
+      }
+
+      # start time entry
+      running_time_entry = @toggl.start_time_entry(@workspace_id, time_entry_info)
+
+      # get current time entry by '/current'
+      time_entry_current = @toggl.get_current_time_entry
+      # get current time entry by id
+      time_entry_by_id = @toggl.get_time_entry(running_time_entry['id'])
+      time_entry_by_id.delete('guid')
+
+      # compare two methods of getting current time entry
+      time_entry_current.delete('uid')
+      time_entry_current.delete('wid')
+      expect(time_entry_current).to eq time_entry_by_id
+
+      # compare current time entry with running time entry
+      expect(time_entry_by_id['start']).to eq_ts running_time_entry['start']
+      time_entry_by_id.delete('start')
+      running_time_entry.delete('start')
+
+      running_time_entry['tags'] = [] if running_time_entry['tags'].nil?
+      running_time_entry['tag_ids'] = [] if running_time_entry['tag_ids'].nil?
+      running_time_entry.delete('uid')
+      running_time_entry.delete('wid')
+      expect(time_entry_by_id).to eq running_time_entry
+      expect(time_entry_by_id.has_key?('stop')).to eq true
+      expect(time_entry_by_id['stop']).to eq nil
+
+      # stop time entry
+      stopped_time_entry = @toggl.stop_time_entry(@workspace_id, running_time_entry['id'])
+      expect(stopped_time_entry.has_key?('stop')).to eq true
+
+      @toggl.delete_time_entry(@workspace_id, stopped_time_entry['id'])
+    end
+
+    it 'returns nil if there is no current time entry' do
+      time_entry = @toggl.get_current_time_entry
+      expect(time_entry).to be {}
+    end
+
+    it 'requires a workspace, project, or task to start' do
+      time_entry_info = {
+        'description' => 'time entry description'
+      }
+
+      expect {
+        @toggl.start_time_entry(@workspace_id, time_entry_info)
+      }.to raise_error(ArgumentError)
+    end
+  end
+
+  context 'time entry tags' do
+    before :each do
+      time_entry_info = {
+        'wid' => @workspace_id,
+        'duration' => 7777
+      }
+      @now = DateTime.now
+
+      start = { 'start' => @toggl.iso8601(@now - 7) }
+      @time7 = @toggl.create_time_entry(@workspace_id, time_entry_info.merge(start))
+
+      start = { 'start' => @toggl.iso8601(@now - 6) }
+      @time6 = @toggl.create_time_entry(@workspace_id, time_entry_info.merge(start))
+
+      start = { 'start' => @toggl.iso8601(@now - 5) }
+      @time5 = @toggl.create_time_entry(@workspace_id, time_entry_info.merge(start))
+
+      start = { 'start' => @toggl.iso8601(@now - 4) }
+      @time4 = @toggl.create_time_entry(@workspace_id, time_entry_info.merge(start))
+
+      @time_entry_ids = [ @time7['id'], @time6['id'], @time5['id'], @time4['id']]
+    end
+
+    after :each do
+      TogglV9SpecHelper.delete_all_time_entries(@toggl)
+      TogglV9SpecHelper.delete_all_tags(@toggl)
+    end
+
+    xit 'adds and removes one tag' do
+      # Add one tag
+      @toggl.update_time_entries_tags_fixed(@workspace_id, @time_entry_ids,
+        {'tags' =>['money'], 'tag_action' => 'add'})
+
+      time_entries = @toggl.get_time_entries
+      tags = time_entries.map { |t| t['tags'] }
+      expect(tags).to eq [
+        ['money'],
+        ['money'],
+        ['money'],
+        ['money']
+      ]
+
+      # Remove one tag
+      @toggl.update_time_entries_tags_fixed(@workspace_id, @time_entry_ids,
+        {'tags' =>['money'], 'tag_action' => 'remove'})
+
+      time_entries = @toggl.get_time_entries
+      tags = time_entries.map { |t| t['tags'] }.compact
+      expect(tags).to eq []
+    end
+
+    xit '"removes" a non-existent tag' do
+      # Not tags to start
+      time_entries = @toggl.get_time_entries
+      tags = time_entries.map { |t| t['tags'] }.compact
+      expect(tags).to eq []
+
+      # "Remove" a tag
+      @toggl.update_time_entries_tags_fixed(@workspace_id, @time_entry_ids,
+        {'tags' =>['void'], 'tag_action' => 'remove'})
+
+      # No tags to finish
+      time_entries = @toggl.get_time_entries
+      tags = time_entries.map { |t| t['tags'] }.compact
+      expect(tags).to eq []
+    end
+
+    xit 'adds and removes multiple tags' do
+      # Add multiple tags
+      @toggl.update_time_entries_tags_fixed(@workspace_id, @time_entry_ids,
+        {'tags' =>['billed', 'productive'], 'tag_action' => 'add'})
+
+      time_entries = @toggl.get_time_entries
+      tags = time_entries.map { |t| t['tags'] }
+      expect(tags).to eq [
+        ['billed', 'productive'],
+        ['billed', 'productive'],
+        ['billed', 'productive'],
+        ['billed', 'productive']
+      ]
+
+      # Remove multiple tags
+      @toggl.update_time_entries_tags_fixed(@workspace_id, @time_entry_ids,
+        {'tags' =>['billed','productive'], 'tag_action' => 'remove'})
+
+      time_entries = @toggl.get_time_entries
+      tags = time_entries.map { |t| t['tags'] }.compact
+      expect(tags).to eq []
+    end
+
+    xit 'manages multiple tags' do
+      # Add some tags
+      @toggl.update_time_entries_tags_fixed(@workspace_id, @time_entry_ids,
+        {'tags' =>['billed', 'productive'], 'tag_action' => 'add'})
+
+      # Remove some tags
+      @toggl.update_time_entries_tags_fixed(@workspace_id, [ @time6['id'], @time4['id'] ],
+        {'tags' =>['billed'], 'tag_action' => 'remove'})
+
+      # Add some tags
+      @toggl.update_time_entries_tags_fixed(@workspace_ids, [ @time7['id'] ],
+        {'tags' =>['best'], 'tag_action' => 'add'})
+
+      time7 = @toggl.get_time_entry(@time7['id'])
+      time6 = @toggl.get_time_entry(@time6['id'])
+      time5 = @toggl.get_time_entry(@time5['id'])
+      time4 = @toggl.get_time_entry(@time4['id'])
+
+      tags = [ time7['tags'], time6['tags'], time5['tags'], time4['tags'] ]
+      expect(tags).to eq [
+        ['best', 'billed', 'productive'],
+        [                  'productive'],
+        [        'billed', 'productive'],
+        [                  'productive']
+      ]
+    end
+  end
+
+  context 'iso8601' do
+    before :all do
+      @ts = DateTime.new(2008,6,21, 13,30,2, "+09:00")
+      @expected = '2008-06-21T13:30:02+09:00'
+    end
+
+    it 'formats a DateTime' do
+      expect(@toggl.iso8601(@ts)).to eq @expected
+    end
+
+    it 'formats a Date' do
+      ts = @ts.to_date
+      expect(@toggl.iso8601(@ts)).to eq @expected
+    end
+
+    it 'formats a Time' do
+      ts = @ts.to_time
+      expect(@toggl.iso8601(@ts)).to eq @expected
+    end
+
+    it 'cannot format a FixNum' do
+      expect{ @toggl.iso8601(1234567890) }.to raise_error(ArgumentError)
+    end
+
+    it 'cannot format a malformed timestamp' do
+      expect{ @toggl.iso8601('X') }.to raise_error(ArgumentError)
+    end
+
+    context 'String' do
+      it 'converts +00:00 to Zulu' do
+        ts = '2015-08-21T09:21:02+00:00'
+        expected = '2015-08-21T09:21:02Z'
+
+        expect(@toggl.iso8601(ts)).to eq expected
+      end
+
+      it 'converts -00:00 to Z' do
+        ts = '2015-08-21T09:21:02-00:00'
+        expected = '2015-08-21T09:21:02Z'
+
+        expect(@toggl.iso8601(ts)).to eq expected
+      end
+
+      it 'maintains an offset' do
+        expect(@toggl.iso8601('2015-08-21T04:21:02-05:00')).to eq '2015-08-21T04:21:02-05:00'
+      end
+    end
+  end
+
+  RSpec::Matchers.define :eq_ts do |expected|
+    # Matching actual time is necessary due to differing formats.
+    # Example:
+    # 1) POST time_entries/start returns 2015-08-21T07:28:20Z
+    #    when GET time_entries/{time_entry_id} returns 2015-08-21T07:28:20+00:00
+    # 2) 2015-08-21T03:20:30-05:00 and 2015-08-21T08:20:30+00:00 refer to
+    #    the same moment in time, but one is in local time and the other in UTC
+    match do |actual|
+      DateTime.parse(actual) == DateTime.parse(expected)
+    end
+  end
+end

data/spec/lib/togglv9/users_spec.rb

@@ -0,0 +1,87 @@
+describe 'Users' do
+  before :all do
+    @toggl = TogglV9::API.new(Testing::API_TOKEN)
+    @user = @toggl.me(all=true)
+    @workspaces = @toggl.workspaces
+    @workspace_id = @workspaces.first['id']
+  end
+
+  it 'returns /me' do
+    expect(@user).to_not be_nil
+    expect(@user['id']).to eq Testing::USER_ID
+    expect(@user['fullname']).to eq Testing::USERNAME
+    # expect(@user['image_url']).to eq 'https://assets.toggl.com/avatars/a5d106126b6bed8df283e708af0828ee.png'
+    # expect(@user['timezone']).to eq 'Etc/UTC'
+    # expect(@user['workspaces'].length).to eq 1
+    # expect(@user['workspaces'].first['name']).to eq "togglv9's workspace"
+  end
+
+  it 'returns my_clients' do
+    my_clients = @toggl.my_clients(@user)
+    expect(my_clients).to be_empty
+  end
+
+  it 'returns my_projects' do
+    my_projects = @toggl.my_projects(@user)
+    expect(my_projects).to be_empty
+  end
+
+  it 'returns my_projects and my_deleted_projects' do
+    # Create project
+    project = @toggl.create_project(@workspace_id, { 'name' => 'my project' })
+
+    my_project_ids         = @toggl.my_projects.map { |p| p['id'] }
+    my_deleted_project_ids = @toggl.my_deleted_projects.map { |p| p['id'] }
+
+    expect(my_project_ids).to eq [ project['id'] ]
+    expect(my_deleted_project_ids).not_to include(project['id'])
+
+    # Delete project
+    @toggl.delete_project(@workspace_id, project['id'])
+
+    my_project_ids         = @toggl.my_projects.map { |p| p['id'] }
+    # FIXME: in v9 the /me response looks not to contain projects that were already deleted
+    # my_deleted_project_ids = @toggl.my_deleted_projects.map { |p| p['id'] }
+
+    expect(my_project_ids).to eq []
+    # expect(my_deleted_project_ids).to include(project['id'])
+  end
+
+  it 'returns my_tags' do
+    my_tags = @toggl.my_tags(@user)
+    expect(my_tags).to be_empty
+  end
+
+  it 'returns my_tasks' do
+    my_tasks = @toggl.my_tasks(@user)
+    expect(my_tasks).to be_empty
+  end
+
+  it 'returns my_time_entries' do
+    my_time_entries = @toggl.my_time_entries(@user)
+    expect(my_time_entries).to be_empty
+  end
+
+  it 'returns my_workspaces' do
+    my_workspaces = @toggl.my_workspaces(@user)
+    expect(my_workspaces.length).to eq 1
+  end
+
+  context 'new user' do
+    # FIXME: user creation API is deprecated https://engineering.toggl.com/changes/2023/11/02/v9-auth-endpoints-deprecation/index.html
+    xit 'creates a new user' do
+      now = Time.now.to_i
+      user_info = {
+        'email' => "test-#{now}+1@mailinator.com",
+        'timezone' => 'Etc/UTC'
+      }
+      user_additional = {
+        'password' => "password-#{now}+1",
+        'tos_accepted' => 'true'
+      }
+
+      new_user = @toggl.create_user(user_info.merge(user_additional))
+      expect(new_user).to include(user_info)
+    end
+  end
+end

data/spec/lib/togglv9/workspaces_spec.rb

@@ -0,0 +1,46 @@
+describe 'Workspaces' do
+  before :all do
+    @toggl = TogglV9::API.new(Testing::API_TOKEN)
+    @user = @toggl.me(all=true)
+    @workspaces = @toggl.my_workspaces
+    @workspace_id = @workspaces.first['id']
+    @organization_id = @user['workspaces'].find { |w| w['id'] == @workspace_id }['organization_id']
+    @project = @toggl.create_project(@workspace_id, { 'name' => 'project with a task' })
+  end
+
+  after :all do
+    @toggl.delete_project(@workspace_id, @project['id'])
+  end
+
+  it 'shows users' do
+    users = @toggl.users(@organization_id, @workspace_id)
+    expect(users.length).to eq 2
+
+    expect(users.first['user_id']).to eq Testing::USER_ID
+    expect(users.first['email']).to   eq Testing::EMAIL
+    expect(users.first['name']).to    eq Testing::USERNAME
+
+    expect(users.last['user_id']).to      eq Testing::OTHER_USER_ID
+    expect(users.last['email']).to        eq Testing::OTHER_EMAIL
+    expect(users.last['name']).to         eq Testing::OTHER_USERNAME
+    expect(users.last['workspace_id']).to eq @workspace_id
+  end
+
+  context 'tasks', :pro_account do
+    before :each do
+      @task = @toggl.create_task(@workspace_id, @project['id'], 'name' => 'workspace task')
+    end
+
+    after :each do
+      @toggl.delete_task(@workspace_id, @project['id'], @task['id'])
+    end
+
+    it 'shows tasks' do
+      tasks = @toggl.tasks(@workspace_id)
+      expect(tasks.length).to eq 1
+      expect(tasks.first['name']).to eq 'workspace task'
+      expect(tasks.first['pid']).to eq @project['id']
+      expect(tasks.first['wid']).to eq @workspace_id
+    end
+  end
+end

data/spec/lib/togglv9_spec.rb

@@ -0,0 +1,88 @@
+require 'fileutils'
+
+describe 'TogglV9' do
+  it 'initializes with api_token' do
+    toggl = TogglV9::API.new(Testing::API_TOKEN)
+    me = toggl.me
+    expect(me).to_not be nil
+    expect(me['api_token']).to eq Testing::API_TOKEN
+    expect(me['email']).to eq Testing::EMAIL
+  end
+
+  it 'initializes with username and password' do
+    toggl = TogglV9::API.new(Testing::EMAIL, Testing::PASSWORD)
+    me = toggl.me
+    expect(me).to_not be nil
+    expect(me['api_token']).to eq Testing::API_TOKEN
+    expect(me['email']).to eq Testing::EMAIL
+  end
+
+  it 'does not initialize with bogus api_token' do
+    toggl = TogglV9::API.new('4880nqor1orr9n241sn08070q33oq49s')
+    expect { toggl.me }.to raise_error(RuntimeError, "HTTP Status: 403")
+  end
+
+  context '.toggl file' do
+    before :each do
+      @tmp_home = mktemp_dir
+      @original_home = Dir.home
+      ENV['HOME'] = @tmp_home
+    end
+
+    after :each do
+      FileUtils.rm_rf(@tmp_home)
+      ENV['HOME'] = @original_home
+    end
+
+    it 'initializes with .toggl file' do
+      toggl_file = File.join(@tmp_home, '.toggl')
+      File.open(toggl_file, 'w') { |file| file.write(Testing::API_TOKEN) }
+
+      toggl = TogglV9::API.new
+      me = toggl.me
+      expect(me).to_not be nil
+      expect(me['api_token']).to eq Testing::API_TOKEN
+      expect(me['email']).to eq Testing::EMAIL
+    end
+
+    it 'initializes with .toggl file ending with a newline' do
+      toggl_file = File.join(@tmp_home, '.toggl')
+      File.open(toggl_file, 'w') { |file| file.write(Testing::API_TOKEN + "\n") }
+
+      toggl = TogglV9::API.new
+      me = toggl.me
+      expect(me).to_not be nil
+      expect(me['api_token']).to eq Testing::API_TOKEN
+      expect(me['email']).to eq Testing::EMAIL
+    end
+
+    it 'raises error if .toggl file is missing' do
+      expect{ toggl = TogglV9::API.new }.to raise_error(RuntimeError)
+    end
+  end
+
+  context 'handles errors' do
+    before :all do
+      @toggl = TogglV9::API.new(Testing::API_TOKEN)
+    end
+
+    it 'surfaces an HTTP Status Code in case of error' do
+      expect(@toggl.conn).to receive(:get).once.and_return(
+        MockResponse.new(400, {}, 'body'))
+      expect { @toggl.me }.to raise_error(RuntimeError, "HTTP Status: 400")
+    end
+
+    it 'retries a request up to 3 times if a 429 is received' do
+      expect(@toggl.conn).to receive(:get).exactly(3).times.and_return(
+        MockResponse.new(429, {}, 'body'))
+      expect { @toggl.me }.to raise_error(RuntimeError, "HTTP Status: 429")
+    end
+
+    it 'retries a request after 429' do
+      expect(@toggl.conn).to receive(:get).twice.and_return(
+        MockResponse.new(429, {}, 'body'),
+        MockResponse.new(200, {}, nil))
+      expect(@toggl.me).to eq({})   # response is {} in this case because body is nil
+    end
+  end
+end