togglv8 0.2.0

data/spec/lib/togglv8/dashboard_spec.rb

@@ -0,0 +1,31 @@
+describe 'Dashboard' do
+  before :all do
+    @toggl = TogglV8::API.new(Testing::API_TOKEN)
+    @workspaces = @toggl.workspaces
+    @workspace_id = @workspaces.first['id']
+  end
+
+  it 'gets nil dashboard data' do
+    dashboard = @toggl.dashboard(@workspace_id)
+    expect(dashboard).to eq Hash['most_active_user' => nil, 'activity' => nil]
+  end
+
+  context 'gets dashboard time entries' do
+    before :all do
+      @new_time_entry = @toggl.start_time_entry({ 'wid' => @workspace_id, 'description' => 'new time entry' })
+    end
+
+    after :all do
+      @toggl.delete_time_entry(@new_time_entry['id'])
+    end
+
+    it 'gets dashboard data' do
+      dashboard = @toggl.dashboard(@workspace_id)
+      expect(dashboard['most_active_user']).to be nil
+      expect(dashboard['activity']).to_not be nil
+      expect(dashboard['activity'].first['user_id']).to eq @toggl.me['id']
+      expect(dashboard['activity'].first['project_id']).to be nil
+      expect(dashboard['activity'].first['description']).to eq 'new time entry'
+    end
+  end
+end

data/spec/lib/togglv8/projects_spec.rb

@@ -0,0 +1,105 @@
+describe 'Projects' do
+  before :all do
+    @toggl = TogglV8::API.new(Testing::API_TOKEN)
+    @workspaces = @toggl.workspaces
+    @workspace_id = @workspaces.first['id']
+  end
+
+  it 'gets {} if there are no workspace projects' do
+    projects = @toggl.projects(@workspace_id)
+    expect(projects).to be_empty
+  end
+
+  context 'new project' do
+    before :all do
+      @project = @toggl.create_project({ 'name' => 'new project', 'wid' => @workspace_id })
+      project_ids = @toggl.my_projects.map { |p| p['id'] }
+      expect(project_ids).to eq [ @project['id'] ]
+    end
+
+    after :all do
+      TogglV8SpecHelper.delete_all_projects(@toggl)
+      projects = @toggl.my_projects
+      expect(projects).to be_empty
+    end
+
+    it 'creates a project' do
+      expect(@project).to_not be nil
+      expect(@project['name']).to eq 'new project'
+      expect(@project['billable']).to eq false
+      expect(@project['is_private']).to eq true
+      expect(@project['active']).to eq true
+      expect(@project['template']).to eq false
+      expect(@project['auto_estimates']).to eq false
+      expect(@project['wid']).to eq @workspace_id
+    end
+
+    it 'gets project data' do
+      project = @toggl.get_project(@project['id'])
+      expect(project).to_not be nil
+      expect(project['wid']).to eq @project['wid']
+      expect(project['name']).to eq @project['name']
+      expect(project['billable']).to eq @project['billable']
+      expect(project['is_private']).to eq @project['is_private']
+      expect(project['active']).to eq @project['active']
+      expect(project['template']).to eq @project['template']
+      expect(project['auto_estimates']).to eq @project['auto_estimates']
+      expect(project['at']).to_not be nil
+    end
+  end
+
+  context 'updated project' do
+    before :each do
+      @project = @toggl.create_project({ 'name' => 'project to update', 'wid' => @workspace_id })
+    end
+
+    after :each do
+      @toggl.delete_project(@project['id'])
+    end
+
+    it 'updates project data' do
+      new_values = {
+        'name' => 'PROJECT-NEW',
+        'is_private' => false,
+        'active' => false,
+        'auto_estimates' => true,
+      }
+
+      project = @toggl.update_project(@project['id'], new_values)
+      expect(project).to include(new_values)
+    end
+
+    it 'updates Pro project data', :pro_account do
+      new_values = {
+        'template' => 'true',
+        'billable' => 'true',
+      }
+      project = @toggl.update_project(@project['id'], new_values)
+      expect(project).to include(new_values)
+    end
+  end
+
+  context 'multiple projects' do
+    after :all do
+      TogglV8SpecHelper.delete_all_projects(@toggl)
+    end
+
+    it 'deletes multiple projects' do
+      # start with no projects
+      expect(@toggl.projects(@workspace_id)).to be_empty
+
+      p1 = @toggl.create_project({ 'name' => 'p1', 'wid' => @workspace_id })
+      p2 = @toggl.create_project({ 'name' => 'p2', 'wid' => @workspace_id })
+      p3 = @toggl.create_project({ 'name' => 'p3', 'wid' => @workspace_id })
+
+      # see 3 new projects
+      expect(@toggl.projects(@workspace_id).length).to eq 3
+
+      p_ids = [p1, p2, p3].map { |p| p['id'] }
+      @toggl.delete_projects(p_ids)
+
+      # end with no projects
+      expect(@toggl.projects(@workspace_id)).to be_empty
+    end
+  end
+end

data/spec/lib/togglv8/tags_spec.rb

@@ -0,0 +1,47 @@
+describe 'Tags' do
+  before :all do
+    @toggl = TogglV8::API.new(Testing::API_TOKEN)
+    @workspaces = @toggl.workspaces
+    @workspace_id = @workspaces.first['id']
+  end
+
+  context 'new tag' do
+    before :all do
+      @tag = @toggl.create_tag({ 'name' => 'new tag', 'wid' => @workspace_id })
+      tag_ids = @toggl.my_tags.map { |t| t['id'] }
+      expect(tag_ids).to eq [ @tag['id'] ]
+    end
+
+    after :all do
+      TogglV8SpecHelper.delete_all_tags(@toggl)
+      tags = @toggl.my_tags
+      expect(tags).to be_empty
+    end
+
+    it 'creates a tag' do
+      expect(@tag).to_not be nil
+      expect(@tag['name']).to eq 'new tag'
+      expect(@tag['notes']).to eq nil
+      expect(@tag['wid']).to eq @workspace_id
+    end
+  end
+
+  context 'updated tag' do
+    before :each do
+      @tag = @toggl.create_tag({ 'name' => 'tag to update', 'wid' => @workspace_id })
+    end
+
+    after :each do
+      @toggl.delete_tag(@tag['id'])
+    end
+
+    it 'updates tag data' do
+      new_values = {
+        'name' => 'TAG-NEW',
+      }
+
+      tag = @toggl.update_tag(@tag['id'], new_values)
+      expect(tag).to include(new_values)
+    end
+  end
+end

data/spec/lib/togglv8/tasks_spec.rb

@@ -0,0 +1,97 @@
+describe 'Tasks', :pro_account do
+  before :all do
+    @toggl = TogglV8::API.new(Testing::API_TOKEN)
+    @workspaces = @toggl.workspaces
+    @workspace_id = @workspaces.first['id']
+    @project = @toggl.create_project({ name: 'project with a task', wid: @workspace_id })
+  end
+
+  after :all do
+    @toggl.delete_project(@project['id'])
+  end
+
+  context 'new task' do
+    before :all do
+      @task = @toggl.create_task({ name: 'new task', pid: @project['id'] })
+      task_ids = @toggl.get_project_tasks(@project['id']).map { |t| t['id'] }
+      expect(task_ids).to eq [ @task['id'] ]
+    end
+
+    after :all do
+      TogglV8SpecHelper.delete_all_tasks(@toggl)
+      tasks = @toggl.get_project_tasks(@project['id'])
+      expect(tasks).to be_empty
+    end
+
+    it 'creates a task' do
+      expect(@task).to_not be nil
+      expect(@task['name']).to eq 'new task'
+      expect(@task['pid']).to eq @project['id']
+      expect(@task['wid']).to eq @workspace_id
+      expect(@task['active']).to eq true
+    end
+
+    it 'gets a task' do
+      task = @toggl.get_task(@task['id'])
+      expect(task).to eq @task
+    end
+  end
+
+  context 'updated task' do
+    before :each do
+      @task = @toggl.create_task({ name: 'task to update', pid: @project['id'] })
+    end
+
+    after :each do
+      @toggl.delete_task(@task['id'])
+    end
+
+    it 'updates task data' do
+      new_values = {
+        'name' => 'task-NEW',
+      }
+
+      task = @toggl.update_task(@task['id'], new_values)
+      expect(task).to include(new_values)
+    end
+  end
+
+  context 'multiple tasks' do
+    before :each do
+      @task1 = @toggl.create_task({ name: 'task1', pid: @project['id'] })
+      @task2 = @toggl.create_task({ name: 'task2', pid: @project['id'] })
+      @task3 = @toggl.create_task({ name: 'task3', pid: @project['id'] })
+    end
+
+    after :all do
+      TogglV8SpecHelper.delete_all_tasks(@toggl)
+    end
+
+    it 'updates multiple tasks' do
+      # start with 3 active tasks
+      tasks = @toggl.get_project_tasks(@project['id'])
+      active_flags = tasks.map { |t| t['active'] }
+      expect().to match_array(['true', 'true', 'true'])
+
+      t_ids = [@task1, @task2, @task3].map { |t| t['id'] }
+      params = { 'active': true }
+      @toggl.update_tasks(t_ids, params)
+
+      # end with 3 inactive tasks
+      tasks = @toggl.get_project_tasks(@project['id'])
+      active_flags = tasks.map { |t| t['active'] }
+      expect().to match_array(['true', 'true', 'true'])
+    end
+
+    it 'deletes multiple tasks' do
+      # start with 3 new tasks
+      expect(@toggl.get_project_tasks(@project['id']).length).to eq 3
+
+      t_ids = [@task1, @task2, @task3].map { |t| t['id'] }
+      @toggl.delete_tasks(t_ids)
+
+      # end with no tasks
+      expect(@toggl.get_project_tasks(@project['id']).length).to be_empty
+    end
+  end
+end

data/spec/lib/togglv8/time_entries_spec.rb

@@ -0,0 +1,247 @@
+require 'date'
+
+describe 'Time Entries' do
+  before :all do
+    @toggl = TogglV8::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(time_entry_info)
+    end
+
+    after :each do
+      @toggl.delete_time_entry(@time_entry['id'])
+    end
+
+    it 'creates a time entry' do
+      expect(@time_entry).to include(@expected)
+    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(time_entry_info)
+      }.to raise_error(ArgumentError)
+    end
+
+    it 'gets a time entry' do
+      retrieved_time_entry = @toggl.get_time_entry(@time_entry['id'])
+
+      ['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
+
+      expect(retrieved_time_entry).to eq @time_entry
+    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(@time_entry['id'], time_entry_info)
+      expect(time_entry_updated).to include(expected)
+    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 false
+
+      deleted_time_entry = @toggl.delete_time_entry(@time_entry['id'])
+      expect(deleted_time_entry).to eq "[#{ @time_entry['id'] }]"
+
+      zombie_time_entry = @toggl.get_time_entry(@time_entry['id'])
+      expect(zombie_time_entry.has_key?('server_deleted_at')).to eq true
+    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 - 7) }
+      @time_entry_last_week = @toggl.create_time_entry(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(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(time_entry_info.merge(start))
+      @next_week_id = @time_entry_next_week['id']
+    end
+
+    after :all do
+      @toggl.delete_time_entry(@last_week_id)
+      @toggl.delete_time_entry(@now_id)
+      @toggl.delete_time_entry(@next_week_id)
+    end
+
+    it 'gets time entries (reaching back 9 days up till now)' do
+      ids = @toggl.get_time_entries.map { |t| t['id']}
+      expect(ids).to eq [ @last_week_id, @now_id ]
+    end
+
+    it 'gets time entries after start timestamp (up till now)' do
+      ids = @toggl.get_time_entries(start_timestamp = @now - 1).map { |t| t['id']}
+      expect(ids).to eq [ @now_id ]
+    end
+
+    it 'gets time entries before end timestamp' do
+      ids = @toggl.get_time_entries(end_timestamp = @now + 1).map { |t| t['id']}
+      expect(ids).to be_empty
+    end
+
+    it 'gets time entries between start and end timestamps' do
+      ids = @toggl.get_time_entries(start_timestamp = @now - 1, end_timestamp = @now + 1).map { |t| t['id']}
+      expect(ids).to eq [ @now_id ]
+    end
+
+    it 'gets time entries in the future' do
+      ids = @toggl.get_time_entries(start_timestamp = @now - 1, end_timestamp = @now + 8).map { |t| t['id']}
+      expect(ids).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 = {
+        'wid' => @workspace_id,
+        'description' => 'time entry description'
+      }
+
+      # start time entry
+      running_time_entry = @toggl.start_time_entry(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'])
+
+      # compare two methods of getting current time entry
+      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')
+
+      expect(time_entry_by_id).to eq running_time_entry
+      expect(time_entry_by_id.has_key?('stop')).to eq false
+
+      # stop time entry
+      stopped_time_entry = @toggl.stop_time_entry(running_time_entry['id'])
+      expect(stopped_time_entry.has_key?('stop')).to eq true
+
+      @toggl.delete_time_entry(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 nil
+    end
+
+    it 'requires a workspace, project, or task to start' do
+      time_entry_info = {
+        'description' => 'time entry description'
+      }
+
+      expect {
+        @toggl.start_time_entry(time_entry_info)
+      }.to raise_error(ArgumentError)
+    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
+      xit 'converts Zulu to +00:00' do
+        ts = '2015-08-21T09:21:02Z'
+        expected = '2015-08-21T09:21:02+00:00'
+
+        expect(@toggl.iso8601(ts)).to eq expected
+      end
+
+      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/togglv8/users_spec.rb

@@ -0,0 +1,55 @@
+describe 'Users' do
+  before :all do
+    @toggl = TogglV8::API.new(Testing::API_TOKEN)
+    @user = @toggl.me(all=true)
+  end
+
+  it 'returns /me' do
+    expect(@user).to_not be_nil
+    expect(@user['id']).to eq 1820939
+    expect(@user['fullname']).to eq 'togglv8'
+    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 "togglv8'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_tags' do
+    my_tags = @toggl.my_tags(@user)
+    expect(my_tags).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
+    it 'creates a new user' do
+      now = Time.now.to_i
+      user_info = {
+        'email' => "test-#{now}@mailinator.com",
+        'timezone' => 'Etc/UTC'
+      }
+      user_password = { 'password' => "password-#{now}" }
+
+      new_user = @toggl.create_user(user_info.merge(user_password))
+      expect(new_user).to include(user_info)
+    end
+  end
+end

data/spec/lib/togglv8_spec.rb

@@ -0,0 +1,59 @@
+require 'fileutils'
+
+describe 'TogglV8::API' do
+  before :each do
+    sleep(Testing::DELAY_SEC)
+  end
+
+  it 'initializes with api_token' do
+    toggl = TogglV8::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::USERNAME
+  end
+
+  it 'initializes with username and password' do
+    toggl = TogglV8::API.new(Testing::USERNAME, 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::USERNAME
+  end
+
+  it 'does not initialize with bogus api_token' do
+    toggl = TogglV8::API.new('4880nqor1orr9n241sn08070q33oq49s')
+    expect { toggl.me } .to raise_error(RuntimeError)
+  end
+
+  context '.toggl file' do
+    before :each do
+      @home = File.join(Dir.pwd, "tmp")
+      Dir.mkdir(@home)
+
+      @original_home = Dir.home
+      ENV['HOME'] = @home
+    end
+
+    after :each do
+      FileUtils.rm_rf(@home)
+      ENV['HOME'] = @original_home
+    end
+
+    it 'initializes with .toggl file' do
+      toggl_file = File.join(@home, '.toggl')
+      File.open(toggl_file, 'w') { |file| file.write(Testing::API_TOKEN) }
+
+      toggl = TogglV8::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::USERNAME
+    end
+
+    it 'raises error if .toggl file is missing' do
+      expect{ toggl = TogglV8::API.new }.to raise_error(RuntimeError)
+    end
+
+  end
+end