feat: page size and pagination for get notifications cmd (#235)

* feat: page size and pagination for get notifications cmd

* fix(notifications): get all by default

* fix: use url.Values to build query params

Author: dexyk

api/client/base_client.go

@@ -113,12 +113,17 @@ func (c *BaseClient) List(kind string) ([]byte, int, error) {
 }
 
 func (c *BaseClient) ListWithParams(kind string, query url.Values) ([]byte, int, error) {
+	if len(query) == 0 {
+		return c.List(kind)
+	}
 	url := fmt.Sprintf("https://%s/api/%s/%s?%s", c.host, c.apiVersion, kind, query.Encode())
 
 	log.Printf("GET %s\n", url)
 
 	req, err := http.NewRequest("GET", url, nil)
-
+	if err != nil {
+		return nil, 0, err
+	}
 	req.Header.Set("Content-Type", "application/json")
 	req.Header.Set("Authorization", fmt.Sprintf("Token %s", c.authToken))
 	req.Header.Set("User-Agent", UserAgent)

api/client/notifications_v1_alpha.go

@@ -3,6 +3,7 @@ package client
 import (
 	"errors"
 	"fmt"
+	"net/url"
 
 	models "github.com/semaphoreci/cli/api/models"
 )
@@ -24,8 +25,18 @@ func NewNotificationsV1AlphaApi() NotificationsV1AlphaApi {
 	}
 }
 
-func (c *NotificationsV1AlphaApi) ListNotifications() (*models.NotificationListV1Alpha, error) {
-	body, status, err := c.BaseClient.List(c.ResourceNamePlural)
+func (c *NotificationsV1AlphaApi) ListNotifications(pageSize int32, pageToken string) (*models.NotificationListV1Alpha, error) {
+	query := url.Values{}
+
+	if pageSize > 0 {
+		query.Add("page_size", fmt.Sprintf("%d", pageSize))
+	}
+
+	if pageToken != "" {
+		query.Add("page_token", pageToken)
+	}
+
+	body, status, err := c.BaseClient.ListWithParams(c.ResourceNamePlural, query)
 
 	if err != nil {
 		return nil, fmt.Errorf("connecting to Semaphore failed '%s'", err)

api/models/notification_list_v1_alpha.go

@@ -5,7 +5,8 @@ import (
 )
 
 type NotificationListV1Alpha struct {
-	Notifications []NotificationV1Alpha `json:"notifications" yaml:"notifications"`
+	Notifications   []NotificationV1Alpha `json:"notifications" yaml:"notifications"`
+	NextPageToken   string                `json:"next_page_token,omitempty" yaml:"next_page_token,omitempty"`
 }
 
 func NewNotificationListV1AlphaFromJson(data []byte) (*NotificationListV1Alpha, error) {

cmd/get.go

@@ -523,6 +523,8 @@ func init() {
 	RootCmd.AddCommand(getCmd)
 
 	getNotificationCmd := NewGetNotificationCmd()
+	getNotificationCmd.Flags().Int32P("page-size", "s", 0, "Number of items per page (max 300)")
+	getNotificationCmd.Flags().StringP("page-token", "t", "", "Token for the next page")
 
 	getCmd.AddCommand(GetDashboardCmd)
 	getCmd.AddCommand(getNotificationCmd)

cmd/get_notification.go

@@ -6,6 +6,7 @@ import (
 	"text/tabwriter"
 
 	client "github.com/semaphoreci/cli/api/client"
+	models "github.com/semaphoreci/cli/api/models"
 
 	"github.com/semaphoreci/cli/cmd/utils"
 	"github.com/spf13/cobra"
@@ -49,22 +50,39 @@ func RunGetNotification(cmd *cobra.Command, args []string) {
 func RunListNotifications(cmd *cobra.Command, args []string) {
 	c := client.NewNotificationsV1AlphaApi()
 
-	notifList, err := c.ListNotifications()
+	pageSize, _ := cmd.Flags().GetInt32("page-size")
+	pageToken, _ := cmd.Flags().GetString("page-token")
+	fetchAll := (pageSize == 0) && (pageToken == "")
 
-	utils.Check(err)
+	var allNotifications []models.NotificationV1Alpha
+
+	for {
+		notifList, err := c.ListNotifications(pageSize, pageToken)
+		utils.Check(err)
+
+		allNotifications = append(allNotifications, notifList.Notifications...)
+		pageToken = notifList.NextPageToken
+
+		if !fetchAll || notifList.NextPageToken == "" {
+			break
+		}
+	}
 
 	const padding = 3
 	w := tabwriter.NewWriter(os.Stdout, 0, 0, padding, ' ', 0)
 
 	fmt.Fprintln(w, "NAME\tAGE")
 
-	for _, n := range notifList.Notifications {
+	for _, n := range allNotifications {
 		updateTime, err := n.Metadata.UpdateTime.Int64()
-
 		utils.Check(err)
 
 		fmt.Fprintf(w, "%s\t%s\n", n.Metadata.Name, utils.RelativeAgeForHumans(updateTime))
 	}
+	if !fetchAll && pageToken != "" {
+		fmt.Fprintf(w, "\nNext page token: %s\n", pageToken)
+		fmt.Fprintf(w, "To view next page, run: sem get notifications --page-token %s\n", pageToken)
+	}
 
 	if err := w.Flush(); err != nil {
 		fmt.Printf("Error flushing when pretty printing notifications: %v\n", err)

cmd/get_notification_test.go

@@ -0,0 +1,133 @@
+package cmd
+
+import (
+	"fmt"
+	"net/http"
+	"testing"
+
+	httpmock "github.com/jarcoal/httpmock"
+	"github.com/stretchr/testify/assert"
+)
+
+func Test__ListNotifications__Response200(t *testing.T) {
+	httpmock.Activate()
+	defer httpmock.DeactivateAndReset()
+
+	received := false
+
+	httpmock.RegisterResponder("GET", "https://org.semaphoretext.xyz/api/v1alpha/notifications",
+		func(req *http.Request) (*http.Response, error) {
+			received = true
+
+			n1 := `{
+				"metadata": {
+					"name": "notif1",
+					"update_time": "124"
+				}
+			}`
+
+			n2 := `{
+				"metadata": {
+					"name": "notif2",
+					"update_time": "125"
+				}
+			}`
+
+			notifications := fmt.Sprintf(`{"notifications":[%s,%s]}`, n1, n2)
+
+			return httpmock.NewStringResponse(200, notifications), nil
+		},
+	)
+
+	RootCmd.SetArgs([]string{"get", "notifications"})
+	RootCmd.Execute()
+
+	assert.True(t, received, "Expected the API to receive GET notifications")
+}
+
+func Test__GetNotification__Response200(t *testing.T) {
+	httpmock.Activate()
+	defer httpmock.DeactivateAndReset()
+
+	received := false
+
+	httpmock.RegisterResponder("GET", "https://org.semaphoretext.xyz/api/v1alpha/notifications/test-notif",
+		func(req *http.Request) (*http.Response, error) {
+			received = true
+
+			notification := `{
+				"metadata": {
+					"name": "test-notif",
+					"update_time": "124"
+				}
+			}`
+
+			return httpmock.NewStringResponse(200, notification), nil
+		},
+	)
+
+	RootCmd.SetArgs([]string{"get", "notifications", "test-notif"})
+	RootCmd.Execute()
+
+	assert.True(t, received, "Expected the API to receive GET notifications/test-notif")
+}
+
+func Test__ListNotifications__WithAllFlag(t *testing.T) {
+	httpmock.Activate()
+	defer httpmock.DeactivateAndReset()
+
+	page1Called := false
+	httpmock.RegisterResponder("GET", "https://org.semaphoretext.xyz/api/v1alpha/notifications",
+		func(req *http.Request) (*http.Response, error) {
+			page1Called = true
+
+			n1 := `{
+				"metadata": {
+					"name": "notif1",
+					"update_time": "124"
+				}
+			}`
+
+			n2 := `{
+				"metadata": {
+					"name": "notif2",
+					"update_time": "125"
+				}
+			}`
+
+			response := fmt.Sprintf(`{
+				"notifications": [%s,%s],
+				"next_page_token": "page2"
+			}`, n1, n2)
+
+			return httpmock.NewStringResponse(200, response), nil
+		},
+	)
+
+	page2Called := false
+	httpmock.RegisterResponder("GET", "https://org.semaphoretext.xyz/api/v1alpha/notifications?page_token=page2",
+		func(req *http.Request) (*http.Response, error) {
+			page2Called = true
+
+			n3 := `{
+				"metadata": {
+					"name": "notif3",
+					"update_time": "126"
+				}
+			}`
+
+			response := fmt.Sprintf(`{
+				"notifications": [%s],
+				"next_page_token": ""
+			}`, n3)
+
+			return httpmock.NewStringResponse(200, response), nil
+		},
+	)
+
+	RootCmd.SetArgs([]string{"get", "notifications"})
+	RootCmd.Execute()
+
+	assert.True(t, page1Called, "Expected the API to receive GET notifications for first page")
+	assert.True(t, page2Called, "Expected the API to receive GET notifications for second page")
+}