Add support for workflow usage and workflow run usage API endpoints (#1527)

Fixes: #1526.

Author: joshuabezaleel

github/actions_workflow_runs.go

@@ -54,6 +54,25 @@ type ListWorkflowRunsOptions struct {
 	ListOptions
 }
 
+// WorkflowRunUsage represents a usage of a specific workflow run.
+type WorkflowRunUsage struct {
+	Billable      *WorkflowRunEnvironment `json:"billable,omitempty"`
+	RunDurationMS *int64                  `json:"run_duration_ms,omitempty"`
+}
+
+// WorkflowRunEnvironment represents different runner environments available for a workflow run.
+type WorkflowRunEnvironment struct {
+	Ubuntu  *WorkflowRunBill `json:"UBUNTU,omitempty"`
+	MacOS   *WorkflowRunBill `json:"MACOS,omitempty"`
+	Windows *WorkflowRunBill `json:"WINDOWS,omitempty"`
+}
+
+// WorkflowRunBill specifies billable time for a specific environment in a workflow run.
+type WorkflowRunBill struct {
+	TotalMS *int64 `json:"total_ms,omitempty"`
+	Jobs    *int   `json:"jobs,omitempty"`
+}
+
 func (s *ActionsService) listWorkflowRuns(ctx context.Context, endpoint string, opts *ListWorkflowRunsOptions) (*WorkflowRuns, *Response, error) {
 	u, err := addOptions(endpoint, opts)
 	if err != nil {
@@ -193,3 +212,23 @@ func (s *ActionsService) DeleteWorkflowRunLogs(ctx context.Context, owner, repo
 
 	return s.client.Do(ctx, req, nil)
 }
+
+// GetWorkflowRunUsageByID gets a specific workflow usage run by run ID in the unit of billable milliseconds.
+//
+// GitHub API docs: https://developer.github.com/v3/actions/workflow-runs/#get-workflow-run-usage
+func (s *ActionsService) GetWorkflowRunUsageByID(ctx context.Context, owner, repo string, runID int64) (*WorkflowRunUsage, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/actions/runs/%v/timing", owner, repo, runID)
+
+	req, err := s.client.NewRequest("GET", u, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	workflowRunUsage := new(WorkflowRunUsage)
+	resp, err := s.client.Do(ctx, req, workflowRunUsage)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return workflowRunUsage, resp, nil
+}

github/actions_workflow_runs_test.go

@@ -250,3 +250,40 @@ func TestActionService_DeleteWorkflowRunLogs(t *testing.T) {
 		t.Errorf("DeleteWorkflowRunLogs returned error: %v", err)
 	}
 }
+
+func TestActionsService_GetWorkflowRunUsageByID(t *testing.T) {
+	client, mux, _, teardown := setup()
+	defer teardown()
+
+	mux.HandleFunc("/repos/o/r/actions/runs/29679449/timing", func(w http.ResponseWriter, r *http.Request) {
+		testMethod(t, r, "GET")
+		fmt.Fprint(w, `{"billable":{"UBUNTU":{"total_ms":180000,"jobs":1},"MACOS":{"total_ms":240000,"jobs":4},"WINDOWS":{"total_ms":300000,"jobs":2}},"run_duration_ms":500000}`)
+	})
+
+	workflowRunUsage, _, err := client.Actions.GetWorkflowRunUsageByID(context.Background(), "o", "r", 29679449)
+	if err != nil {
+		t.Errorf("Actions.GetWorkflowRunUsageByID returned error: %v", err)
+	}
+
+	want := &WorkflowRunUsage{
+		Billable: &WorkflowRunEnvironment{
+			Ubuntu: &WorkflowRunBill{
+				TotalMS: Int64(180000),
+				Jobs:    Int(1),
+			},
+			MacOS: &WorkflowRunBill{
+				TotalMS: Int64(240000),
+				Jobs:    Int(4),
+			},
+			Windows: &WorkflowRunBill{
+				TotalMS: Int64(300000),
+				Jobs:    Int(2),
+			},
+		},
+		RunDurationMS: Int64(500000),
+	}
+
+	if !reflect.DeepEqual(workflowRunUsage, want) {
+		t.Errorf("Actions.GetWorkflowRunUsageByID returned %+v, want %+v", workflowRunUsage, want)
+	}
+}

github/actions_workflows.go

@@ -30,6 +30,23 @@ type Workflows struct {
 	Workflows  []*Workflow `json:"workflows,omitempty"`
 }
 
+// WorkflowUsage represents a usage of a specific workflow.
+type WorkflowUsage struct {
+	Billable *WorkflowEnvironment `json:"billable,omitempty"`
+}
+
+// WorkflowEnvironment represents different runner environments available for a workflow.
+type WorkflowEnvironment struct {
+	Ubuntu  *WorkflowBill `json:"UBUNTU,omitempty"`
+	MacOS   *WorkflowBill `json:"MACOS,omitempty"`
+	Windows *WorkflowBill `json:"WINDOWS,omitempty"`
+}
+
+// WorkflowBill specifies billable time for a specific environment in a workflow.
+type WorkflowBill struct {
+	TotalMS *int64 `json:"total_ms,omitempty"`
+}
+
 // ListWorkflows lists all workflows in a repository.
 //
 // GitHub API docs: https://developer.github.com/v3/actions/workflows/#list-repository-workflows
@@ -86,3 +103,36 @@ func (s *ActionsService) getWorkflow(ctx context.Context, url string) (*Workflow
 
 	return workflow, resp, nil
 }
+
+// GetWorkflowUsageByID gets a specific workflow usage by ID in the unit of billable milliseconds.
+//
+// GitHub API docs: https://developer.github.com/v3/actions/workflows/#get-workflow-usage
+func (s *ActionsService) GetWorkflowUsageByID(ctx context.Context, owner, repo string, workflowID int64) (*WorkflowUsage, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/actions/workflows/%v/timing", owner, repo, workflowID)
+
+	return s.getWorkflowUsage(ctx, u)
+}
+
+// GetWorkflowUsageByFileName gets a specific workflow usage by file name in the unit of billable milliseconds.
+//
+// GitHub API docs: https://developer.github.com/v3/actions/workflows/#get-workflow-usage
+func (s *ActionsService) GetWorkflowUsageByFileName(ctx context.Context, owner, repo, workflowFileName string) (*WorkflowUsage, *Response, error) {
+	u := fmt.Sprintf("repos/%v/%v/actions/workflows/%v/timing", owner, repo, workflowFileName)
+
+	return s.getWorkflowUsage(ctx, u)
+}
+
+func (s *ActionsService) getWorkflowUsage(ctx context.Context, url string) (*WorkflowUsage, *Response, error) {
+	req, err := s.client.NewRequest("GET", url, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	workflowUsage := new(WorkflowUsage)
+	resp, err := s.client.Do(ctx, req, workflowUsage)
+	if err != nil {
+		return nil, resp, err
+	}
+
+	return workflowUsage, resp, nil
+}

github/actions_workflows_test.go

@@ -89,3 +89,67 @@ func TestActionsService_GetWorkflowByFileName(t *testing.T) {
 		t.Errorf("Actions.GetWorkflowByFileName returned %+v, want %+v", workflow, want)
 	}
 }
+
+func TestActionsService_GetWorkflowUsageByID(t *testing.T) {
+	client, mux, _, teardown := setup()
+	defer teardown()
+
+	mux.HandleFunc("/repos/o/r/actions/workflows/72844/timing", func(w http.ResponseWriter, r *http.Request) {
+		testMethod(t, r, "GET")
+		fmt.Fprint(w, `{"billable":{"UBUNTU":{"total_ms":180000},"MACOS":{"total_ms":240000},"WINDOWS":{"total_ms":300000}}}`)
+	})
+
+	workflowUsage, _, err := client.Actions.GetWorkflowUsageByID(context.Background(), "o", "r", 72844)
+	if err != nil {
+		t.Errorf("Actions.GetWorkflowUsageByID returned error: %v", err)
+	}
+
+	want := &WorkflowUsage{
+		Billable: &WorkflowEnvironment{
+			Ubuntu: &WorkflowBill{
+				TotalMS: Int64(180000),
+			},
+			MacOS: &WorkflowBill{
+				TotalMS: Int64(240000),
+			},
+			Windows: &WorkflowBill{
+				TotalMS: Int64(300000),
+			},
+		},
+	}
+	if !reflect.DeepEqual(workflowUsage, want) {
+		t.Errorf("Actions.GetWorkflowUsageByID returned %+v, want %+v", workflowUsage, want)
+	}
+}
+
+func TestActionsService_GetWorkflowUsageByFileName(t *testing.T) {
+	client, mux, _, teardown := setup()
+	defer teardown()
+
+	mux.HandleFunc("/repos/o/r/actions/workflows/main.yml/timing", func(w http.ResponseWriter, r *http.Request) {
+		testMethod(t, r, "GET")
+		fmt.Fprint(w, `{"billable":{"UBUNTU":{"total_ms":180000},"MACOS":{"total_ms":240000},"WINDOWS":{"total_ms":300000}}}`)
+	})
+
+	workflowUsage, _, err := client.Actions.GetWorkflowUsageByFileName(context.Background(), "o", "r", "main.yml")
+	if err != nil {
+		t.Errorf("Actions.GetWorkflowUsageByFileName returned error: %v", err)
+	}
+
+	want := &WorkflowUsage{
+		Billable: &WorkflowEnvironment{
+			Ubuntu: &WorkflowBill{
+				TotalMS: Int64(180000),
+			},
+			MacOS: &WorkflowBill{
+				TotalMS: Int64(240000),
+			},
+			Windows: &WorkflowBill{
+				TotalMS: Int64(300000),
+			},
+		},
+	}
+	if !reflect.DeepEqual(workflowUsage, want) {
+		t.Errorf("Actions.GetWorkflowUsageByFileName returned %+v, want %+v", workflowUsage, want)
+	}
+}