dovico 1.0.0

data/lib/dovico/version.rb

@@ -0,0 +1,3 @@
+module Dovico
+  VERSION = '1.0.0'
+end

data/spec/helper.rb

@@ -0,0 +1,24 @@
+require "simplecov"
+require "simplecov-rcov"
+SimpleCov.formatters = [
+  SimpleCov::Formatter::HTMLFormatter,
+  SimpleCov::Formatter::RcovFormatter
+]
+SimpleCov.start do
+  add_filter "db/"
+  add_filter "spec/"
+  add_group "Dovico", "lib/dovico"
+end
+require "rspec"
+require "rspec/its"
+require "timecop"
+require "rack/test"
+require 'webmock/rspec'
+
+require 'pry'
+
+# Load libs
+require "dovico"
+
+Timecop.safe_mode = true
+WebMock.disable_net_connect!(allow_localhost: true)

data/spec/unit/dovico/api_client_spec.rb

@@ -0,0 +1,81 @@
+require "helper"
+
+module Dovico
+  describe Dovico::ApiClient do
+    let(:client_token) { "aaaaa-client-token-aaaaa" }
+    let(:user_token) { "zzzzz-user-token-zzzzz" }
+    let(:response_body) do
+      {
+        "Stubbed": "Response"
+      }.to_json
+    end
+
+    before do
+      Dovico::ApiClient.initialize!(client_token, user_token)
+    end
+
+    describe ".get" do
+      context 'with a succcessful response' do
+        it "passes the correct headers to the request and parses the JSON response" do
+          stub_request(
+            :get,
+            "#{Dovico::ApiClient::API_URL}TimeEntries?filter=1234%205678&version=#{Dovico::ApiClient::API_VERSION}"
+          )
+            .with(
+              headers: {
+                'Accept': 'application/json',
+                'Content-Type': 'application/json',
+                'Authorization': "WRAP access_token=\"client=#{client_token}&user_token=#{user_token}\"",
+              }
+            )
+            .to_return(body: response_body)
+
+          response = Dovico::ApiClient.get(
+            'TimeEntries',
+            params: {
+              filter: '1234 5678'
+            }
+          )
+
+          expect(response).to eq({"Stubbed": "Response"}.stringify_keys)
+        end
+      end
+
+      context 'with a succcessful response' do
+        it "raises an error if the API response is not 200 OK" do
+          stub_request(:get, "#{Dovico::ApiClient::API_URL}TimeEntries?version=#{Dovico::ApiClient::API_VERSION}")
+            .to_return(
+              status: 503,
+              body: response_body
+            )
+
+          expect { Dovico::ApiClient.get('TimeEntries') }.to raise_error 'Error during HTTP request'
+        end
+      end
+    end
+
+    describe ".post" do
+      it 'posts the body with a POST request' do
+        stub_request(:post,
+          "#{Dovico::ApiClient::API_URL}TimeEntries?version=#{Dovico::ApiClient::API_VERSION}"
+        )
+          .with(
+            body: '{"Fake":"Object"}',
+          )
+          .to_return(body: response_body)
+
+        Dovico::ApiClient.post('TimeEntries', body: {"Fake": "Object"}.to_json)
+      end
+    end
+
+    describe ".put" do
+      it 'perform a PUT request' do
+        stub_request(:put, "#{Dovico::ApiClient::API_URL}TimeEntries?version=#{Dovico::ApiClient::API_VERSION}")
+          .to_return(body: response_body)
+
+        response = Dovico::ApiClient.put('TimeEntries')
+        expect(response).to eq({"Stubbed": "Response"}.stringify_keys)
+      end
+    end
+  end
+end

data/spec/unit/dovico/model/assignment_spec.rb

@@ -0,0 +1,26 @@
+require "helper"
+
+module Dovico
+  describe Dovico::Assignment do
+    let(:assignment_api_hash) do
+      {
+        "ItemID":       "123",
+        "AssignmentID": "T456",
+        "Name":         "Dovico API Client",
+        "StartDate":    "2017-01-01",
+        "FinishDate":   "2017-12-31",
+      }.stringify_keys
+    end
+
+    describe ".parse" do
+      it "parses the API hash" do
+        assignment = Dovico::Assignment.parse(assignment_api_hash)
+
+        expect(assignment).to be_an(Dovico::Assignment)
+        expect(assignment.id).to eq('123')
+        expect(assignment.assignement_id).to eq('T456')
+        expect(assignment.name).to eq('Dovico API Client')
+      end
+    end
+  end
+end

data/spec/unit/dovico/model/employee_spec.rb

@@ -0,0 +1,44 @@
+require "helper"
+
+module Dovico
+  describe Dovico::Employee do
+    let(:employee_api_hash) do
+      {
+        "ID": "123",
+        "FirstName": "James",
+        "LastName": "Bond",
+      }.stringify_keys
+    end
+
+    describe ".parse" do
+      it "parses the hash" do
+        employee = Dovico::Employee.parse(employee_api_hash)
+
+        expect(employee).to be_an(Dovico::Employee)
+        expect(employee.id).to eq('123')
+        expect(employee.first_name).to eq('James')
+        expect(employee.last_name).to eq('Bond')
+      end
+    end
+
+    describe ".myself" do
+      let(:employee_me_answer) do
+        {
+          "Employees": [ employee_api_hash ]
+        }.stringify_keys
+      end
+
+      before do
+        allow(ApiClient).to receive(:get).and_return(employee_me_answer)
+      end
+
+      it 'calls the API and return an Employee object' do
+        myself = Dovico::Employee.myself
+
+        expect(ApiClient).to have_received(:get).with("#{Dovico::Employee::URL_PATH}/Me")
+        expect(myself).to be_an(Dovico::Employee)
+        expect(myself.id).to eq('123')
+      end
+    end
+  end
+end

data/spec/unit/dovico/model/project_spec.rb

@@ -0,0 +1,56 @@
+require "helper"
+
+module Dovico
+  describe Dovico::Project do
+    let(:project_api_hash) do
+      {
+        "ItemID":       "123",
+        "AssignmentID": "T456",
+        "Name":         "Project Dovico API Client",
+        "StartDate":    "2017-01-01",
+        "FinishDate":   "2017-12-31",
+      }.stringify_keys
+    end
+    let(:projects_api_hash) do
+      {
+        "Assignments": [project_api_hash]
+      }.stringify_keys
+    end
+    let(:task_api_hash) do
+      {
+        "ItemID":       "789",
+        "AssignmentID": "E456",
+        "Name":         "Task write specs",
+        "StartDate":    "2016-10-25",
+        "FinishDate":   "2018-05-01",
+      }.stringify_keys
+    end
+    let(:tasks_api_hash) do
+      {
+        "Assignments": [task_api_hash]
+      }.stringify_keys
+    end
+
+    describe ".all" do
+      before do
+        allow(ApiClient).to receive(:get).with(Dovico::Project::URL_PATH).and_return(projects_api_hash)
+        allow(ApiClient).to receive(:get).with("#{Dovico::Project::URL_PATH}T456").and_return(tasks_api_hash)
+      end
+
+      it "lists all the assignements" do
+        projects = Dovico::Project.all
+
+        expect(projects.count).to eq(1)
+        project = projects.first
+        expect(project).to be_an(Dovico::Project)
+        expect(project.id).to eq('123')
+        expect(project.name).to eq('Project Dovico API Client')
+
+        expect(project.tasks.count).to eq(1)
+        task = project.tasks.first
+        expect(task.id).to eq('789')
+        expect(task.name).to eq('Task write specs')
+      end
+    end
+  end
+end

data/spec/unit/dovico/model/task_spec.rb

@@ -0,0 +1,26 @@
+require "helper"
+
+module Dovico
+  describe Dovico::Task do
+    let(:task_api_hash) do
+      {
+        "ItemID":       "123",
+        "AssignmentID": "E456",
+        "Name":         "Dovico API Client",
+        "StartDate":    "2017-01-01",
+        "FinishDate":   "2017-12-31",
+      }.stringify_keys
+    end
+
+    describe ".parse" do
+      it "parses the API hash" do
+        task = Dovico::Task.parse(task_api_hash)
+
+        expect(task).to be_an(Dovico::Task)
+        expect(task.id).to eq('123')
+        expect(task.assignement_id).to eq('E456')
+        expect(task.name).to eq('Dovico API Client')
+      end
+    end
+  end
+end

data/spec/unit/dovico/model/time_entry_generator_spec.rb

@@ -0,0 +1,86 @@
+require "helper"
+
+module Dovico
+  describe Dovico::TimeEntryGenerator do
+    subject do
+      Dovico::TimeEntryGenerator.new(
+        employee_id: employee_id,
+        assignments: assignments_config
+      )
+    end
+    let(:employee_id) { "999" }
+    let(:assignment_1) do
+      {
+        "project_id": "1234",
+        "task_id":    "456",
+        "hours":      4,
+      }.stringify_keys
+    end
+    let(:assignment_2) do
+      {
+        "project_id": "6789",
+        "task_id":    "999",
+        "hours":      3,
+      }.stringify_keys
+    end
+    let(:assignments_config) do
+      {
+        "default_day": [ assignment_1, assignment_2 ]
+      }.stringify_keys
+    end
+
+    describe "#generate" do
+      let(:start_date) { Date.parse('2017-01-02') }
+      let(:end_date)   { Date.parse('2017-01-06') }
+
+      context 'with minimal configuration' do
+        it 'creates TimeEntries object for the date range' do
+          time_entries = subject.generate(start_date, end_date)
+
+          # 5 days * 2 time entries
+          expect(time_entries.count).to eq(10)
+          first_time_entry = time_entries.first
+          last_time_entry = time_entries.last
+
+          expect(first_time_entry.id).to be_nil
+          expect(first_time_entry.employee_id).to eq(employee_id)
+          expect(first_time_entry.project_id).to eq('1234')
+          expect(first_time_entry.task_id).to eq('456')
+          expect(first_time_entry.date).to eq('2017-01-02')
+          expect(first_time_entry.start_time).to eq('0900')
+          expect(first_time_entry.stop_time).to eq('1300')
+          expect(first_time_entry.total_hours).to eq(4)
+
+          expect(first_time_entry.employee_id).to eq(employee_id)
+          expect(last_time_entry.project_id).to eq('6789')
+          expect(last_time_entry.task_id).to eq('999')
+          expect(last_time_entry.date).to eq('2017-01-06')
+          expect(last_time_entry.start_time).to eq('1300')
+          expect(last_time_entry.stop_time).to eq('1600')
+          expect(last_time_entry.total_hours).to eq(3)
+        end
+      end
+
+      context 'with specific day assignments' do
+        let(:assignments_config) do
+          {
+            'default_day': [ assignment_1, assignment_2 ],
+            '2016-02-29': [],
+            '2016-03-01': [ assignment_2 ],
+          }.stringify_keys
+        end
+        let(:start_date) { Date.parse('2016-02-29') }
+        let(:end_date) { Date.parse('2016-03-01') }
+
+        it 'uses specific day assignments' do
+          time_entries = subject.generate(start_date, end_date)
+
+          expect(time_entries.count).to eq(1)
+          time_entry = time_entries.first
+          expect(time_entry.date).to eq('2016-03-01')
+          expect(time_entry.total_hours).to eq(3)
+        end
+      end
+    end
+  end
+end

data/spec/unit/dovico/model/time_entry_spec.rb

@@ -0,0 +1,168 @@
+require "helper"
+
+module Dovico
+  describe Dovico::TimeEntry do
+    subject do
+      Dovico::TimeEntry.parse(time_entry_api_hash)
+    end
+    let(:project_hash) do
+      {
+        "ID": "111"
+      }.stringify_keys
+    end
+    let(:task_hash) do
+      {
+        "ID": "222"
+      }.stringify_keys
+    end
+    let(:employee_hash) do
+      {
+        "ID": "333"
+      }.stringify_keys
+    end
+    let(:time_entry_api_hash) do
+      {
+        "ID":         "456",
+        "StartTime":  "0800",
+        "StopTime":   "1100",
+        "Project":    project_hash,
+        "Task":       task_hash,
+        "Employee":   employee_hash,
+        "Date":       "2017-01-05",
+        "TotalHours": "3",
+        "Description": "Unit test",
+      }.stringify_keys
+    end
+
+    describe ".parse" do
+      it "parses the API hash" do
+        time_entry = Dovico::TimeEntry.parse(time_entry_api_hash)
+
+        expect(time_entry).to be_an(Dovico::TimeEntry)
+        expect(time_entry.start_time).to eq('0800')
+        expect(time_entry.project_id).to eq('111')
+        expect(time_entry.employee_id).to eq('333')
+        expect(time_entry.total_hours).to eq('3')
+      end
+
+      context 'with a GUID ID' do
+        it 'removes the first character of the GUID' do
+          time_entry = Dovico::TimeEntry.parse(
+            time_entry_api_hash.merge(
+              {"ID": "T0bb4860f-2669-49ab-ae5e-dd8908366c8b"}.stringify_keys
+            )
+          )
+
+          expect(time_entry.id).to eq('0bb4860f-2669-49ab-ae5e-dd8908366c8b')
+        end
+      end
+    end
+
+    describe ".get" do
+      let(:time_entry_list_api) do
+        {
+          "TimeEntries": [ time_entry_api_hash ]
+        }.stringify_keys
+      end
+
+      before do
+        allow(ApiClient).to receive(:get).and_return(time_entry_list_api)
+      end
+
+      it 'calls the API and return an TimeEntry object' do
+        time_entry = Dovico::TimeEntry.get('999')
+
+        expect(ApiClient).to have_received(:get).with("#{Dovico::TimeEntry::URL_PATH}/999")
+        expect(time_entry).to be_an(Dovico::TimeEntry)
+        expect(time_entry.id).to eq('456')
+      end
+    end
+
+    describe ".batch_create!" do
+      let(:assignments) do
+        [ subject ]
+      end
+
+      before do
+        allow(ApiClient).to receive(:post)
+      end
+
+      it 'calls the API and post TimeEntries objects' do
+        Dovico::TimeEntry.batch_create!(assignments)
+
+        expect(ApiClient).to have_received(:post).with(
+          "#{Dovico::TimeEntry::URL_PATH}",
+          body: [subject.to_api].to_json
+        )
+      end
+    end
+
+    describe ".submit!" do
+      let(:start_date) { Date.parse("2017-01-02") }
+      let(:end_date) { Date.parse("2017-01-12") }
+      let(:employee_id) { "333" }
+
+      before do
+        allow(ApiClient).to receive(:post)
+      end
+
+      it 'calls the API and submit a time range' do
+        Dovico::TimeEntry.submit!(employee_id, start_date, end_date)
+
+        expect(ApiClient).to have_received(:post).with(
+          "#{Dovico::TimeEntry::URL_PATH}/Employee/#{employee_id}/Submit",
+          params: {
+            daterange: "2017-01-02 2017-01-12"
+          },
+          body: {}.to_json
+        )
+      end
+    end
+
+    describe ".create!" do
+      before do
+        allow(ApiClient).to receive(:post)
+      end
+
+      it 'calls the API and post TimeEntries objects' do
+        subject.create!
+
+        expect(ApiClient).to have_received(:post).with(
+          "#{Dovico::TimeEntry::URL_PATH}",
+          body: [subject.to_api].to_json
+        )
+      end
+    end
+
+    describe ".update!" do
+      before do
+        allow(ApiClient).to receive(:put)
+      end
+
+      it 'calls the API and post TimeEntries objects' do
+        subject.update!
+
+        expect(ApiClient).to have_received(:put).with(
+          "#{Dovico::TimeEntry::URL_PATH}",
+          body: [subject.to_api].to_json
+        )
+      end
+    end
+
+    describe ".to_api" do
+      it 'serializes the object' do
+        expect(subject.to_api).to eq(
+          "ID"          => "456",
+          "EmployeeID"  => "333",
+          "ProjectID"   => "111",
+          "TaskID"      => "222",
+          "Date"        => "2017-01-05",
+          "StartTime"   => "0800",
+          "StopTime"    => "1100",
+          "TotalHours"  => "3",
+          "Description" => "Unit test",
+        )
+      end
+    end
+  end
+end