Tests for CLI (#6)

* Completed List cmd and added API calls * Minor comments and add delete code to pass linting * Typo in descriptions * Minor comments * Validations * Validations-1 * improved branch flag validation * removed build * working after refactory with bad names * Command working, test not working * Corrected creation of service * Finalized structure using service * Deleted tests * cleanup * cleanup * cleanup * removed space with tab * aligned types in model.go * Update model.go * resolved comments * Refactor * removed long descriptions * Working incomplete tests * Completed tests * cleanup * checks * PR comments * PR comments * minor comment issue * minor comment issue * updated tests to work with workflow * Updated tests to support new option service * Improved eror handling for list * Improved error handling * Upgraded go-gh * reusing rest client error
2022-07-14 02:14:03 +05:30
parent 47c4b91fe4
commit db34270ecb
11 changed files with 615 additions and 61 deletions
--- a/cmd/delete.go
+++ b/cmd/delete.go
@@ -17,31 +17,38 @@ func NewCmdDelete() *cobra.Command {
 	f := types.DeleteOptions{}

 	var deleteCmd = &cobra.Command{
-		Use:   "delete",
+		Use:   "delete <key>",
 		Short: "Delete cache by key",
-		Run: func(cmd *cobra.Command, args []string) {
+		RunE: func(cmd *cobra.Command, args []string) error {
 			if len(args) != 1 {
-				fmt.Printf("accepts 1 arg(s), received %d\n", len(args))
-				return
+				return fmt.Errorf(fmt.Sprintf("accepts 1 arg(s), received %d", len(args)))
 			}

 			f.Key = args[0]

 			repo, err := internal.GetRepo(f.Repo)
 			if err != nil {
-				fmt.Println(err)
-				return
+				return err
 			}
-			artifactCache := service.NewArtifactCache(repo, COMMAND, VERSION)
+
+			artifactCache, err := service.NewArtifactCache(repo, COMMAND, VERSION)
+			if err != nil {
+				fmt.Printf("error connecting to %s\n", repo.Host())
+				fmt.Println("check your internet connection or https://githubstatus.com")
+				return nil
+			}
+
 			queryParams := url.Values{}
 			f.GenerateBaseQueryParams(queryParams)

 			if !f.Confirm {
-				var matchedCaches = getCacheListWithExactMatch(f, artifactCache)
+				matchedCaches, err := getCacheListWithExactMatch(f, artifactCache)
+				if err != nil {
+					return err
+				}
 				matchedCachesLen := len(matchedCaches)
 				if matchedCachesLen == 0 {
-					fmt.Printf("Cache with input key '%s' does not exist\n", f.Key)
-					return
+					return fmt.Errorf(fmt.Sprintf("Cache with input key '%s' does not exist\n", f.Key))
 				}
 				fmt.Printf("You're going to delete %s", internal.PrintSingularOrPlural(matchedCachesLen, "cache entry\n\n", "cache entries\n\n"))
 				internal.PrettyPrintTrimmedCacheList(matchedCaches)
@@ -50,22 +57,26 @@ func NewCmdDelete() *cobra.Command {
 					Message: "Are you sure you want to delete the cache entries?",
 					Options: []string{"Delete", "Cancel"},
 				}
-				err := survey.AskOne(prompt, &choice)
+				err = survey.AskOne(prompt, &choice)
 				if err != nil {
-					fmt.Println("Error occured while taking input from user while trying to delete cache")
-					return
+					return fmt.Errorf("Error occured while taking input from user while trying to delete cache")
 				}
 				f.Confirm = choice == "Delete"
 				fmt.Println()
 			}
 			if f.Confirm {
-				cachesDeleted := artifactCache.DeleteCaches(queryParams)
+				cachesDeleted, err := artifactCache.DeleteCaches(queryParams)
+				if err != nil {
+					return err
+				}
+
 				if cachesDeleted > 0 {
 					fmt.Printf("%s Deleted %s with key '%s'\n", internal.RedTick(), internal.PrintSingularOrPlural(cachesDeleted, "cache entry", "cache entries"), f.Key)
 				} else {
 					fmt.Printf("Cache with input key '%s' does not exist\n", f.Key)
 				}
 			}
+			return nil
 		},
 	}
 	deleteCmd.Flags().StringVarP(&f.Repo, "repo", "R", "", "Select another repository for finding actions cache.")
@@ -99,18 +110,20 @@ EXAMPLES:
 `
 }

-func getCacheListWithExactMatch(f types.DeleteOptions, artifactCache service.ArtifactCacheService) []types.ActionsCache {
+func getCacheListWithExactMatch(f types.DeleteOptions, artifactCache service.ArtifactCacheService) ([]types.ActionsCache, error) {
 	listOption := types.ListOptions{BaseOptions: types.BaseOptions{Repo: f.Repo, Branch: f.Branch, Key: f.Key}, Limit: 100, Order: "", Sort: ""}
 	queryParams := url.Values{}

 	listOption.GenerateBaseQueryParams(queryParams)
-	caches := artifactCache.ListAllCaches(queryParams, f.Key)
-
+	caches, err := artifactCache.ListAllCaches(queryParams, f.Key)
+	if err != nil {
+		return nil, err
+	}
 	var exactMatchedKeys []types.ActionsCache
 	for _, cache := range caches {
 		if strings.EqualFold(f.Key, cache.Key) {
 			exactMatchedKeys = append(exactMatchedKeys, cache)
 		}
 	}
-	return exactMatchedKeys
+	return exactMatchedKeys, nil
 }
--- a/cmd/list.go
+++ b/cmd/list.go
@@ -1,13 +1,14 @@
 package cmd

 import (
+	"errors"
 	"fmt"
-	"log"
 	"net/url"

 	"github.com/actions/gh-actions-cache/internal"
 	"github.com/actions/gh-actions-cache/service"
 	"github.com/actions/gh-actions-cache/types"
+	"github.com/cli/go-gh/pkg/api"
 	"github.com/spf13/cobra"
 )

@@ -16,42 +17,59 @@ func NewCmdList() *cobra.Command {

 	f := types.ListOptions{}

-	var listCmd = &cobra.Command{
+	var listCmd = &cobra.Command {
 		Use:   "list",
 		Short: "Lists the actions cache",
-		Run: func(cmd *cobra.Command, args []string) {
+		RunE: func(cmd *cobra.Command, args []string) error {
 			if len(args) != 0 {
-				fmt.Printf("Invalid argument(s). Expected 0 received %d\n", len(args))
-				fmt.Println(getListHelp())
-				return
+				return fmt.Errorf(fmt.Sprintf("Invalid argument(s). Expected 0 received %d", len(args)))
 			}

 			repo, err := internal.GetRepo(f.Repo)
 			if err != nil {
-				log.Fatal(err)
+				return err
 			}

+			// This will silence the usage (help) message as they are not needed for errors beyond this point
+			cmd.SilenceUsage = true
+
 			err = f.Validate()
 			if err != nil {
-				log.Fatal(err)
+				return err
 			}

-			artifactCache := service.NewArtifactCache(repo, COMMAND, VERSION)
+			artifactCache, err := service.NewArtifactCache(repo, COMMAND, VERSION)
+			if err != nil {
+				return types.HandledError{Message: err.Error(), InnerError: err}
+			}

 			if f.Branch == "" && f.Key == "" {
-				totalCacheSize := artifactCache.GetCacheUsage()
-				fmt.Printf("Total caches size %s\n\n", internal.FormatCacheSize(totalCacheSize))
+				totalCacheSize, err := artifactCache.GetCacheUsage()
+				if err == nil {
+					fmt.Printf("Total caches size %s\n\n", internal.FormatCacheSize(totalCacheSize))
+				}
 			}

 			queryParams := url.Values{}
 			f.GenerateQueryParams(queryParams)
-			listCacheResponse := artifactCache.ListCaches(queryParams)
+			listCacheResponse, err := artifactCache.ListCaches(queryParams)
+			if err != nil {
+				var httpError api.HTTPError
+				if errors.As(err, &httpError) && httpError.StatusCode == 404 {
+					return types.HandledError{Message: "The given repo does not exist.", InnerError: err}
+				} else if errors.As(err, &httpError) && httpError.StatusCode >= 400 && httpError.StatusCode < 500 {
+					return types.HandledError{Message: httpError.Message, InnerError: err}
+				} else {
+					return types.HandledError{Message: "We could not process your request due to internal error.", InnerError: err}
+				}
+			}

 			totalCaches := listCacheResponse.TotalCount
 			caches := listCacheResponse.ActionsCaches

 			fmt.Printf("Showing %d of %d cache entries in %s/%s\n\n", displayedEntriesCount(len(caches), f.Limit), totalCaches, repo.Owner(), repo.Name())
 			internal.PrettyPrintCacheList(caches)
+      		return nil
 		},
 	}

--- a/cmd/list_test.go
+++ b/cmd/list_test.go
@@ -0,0 +1,220 @@
+package cmd
+
+import (
+	"errors"
+	"fmt"
+	"testing"
+	"reflect"
+
+	"github.com/actions/gh-actions-cache/internal"
+	"github.com/stretchr/testify/assert"
+	"github.com/actions/gh-actions-cache/types"
+	"gopkg.in/h2non/gock.v1"
+)
+
+func TestListWithIncorrectArguments(t *testing.T) {
+	t.Cleanup(gock.Off)
+
+	cmd := NewCmdList()
+	cmd.SetArgs([]string{"keyValue"})
+	err := cmd.Execute()
+
+	assert.NotNil(t, err)
+	assert.Equal(t, err, fmt.Errorf("Invalid argument(s). Expected 0 received 1"))
+	assert.True(t, gock.IsDone(), internal.PrintPendingMocks(gock.Pending()))
+}
+
+func TestListWithIncorrectRepo(t *testing.T) {
+	t.Cleanup(gock.Off)
+
+	cmd := NewCmdList()
+	cmd.SetArgs([]string{"--repo", "testOrg/testRepo/123/123"})
+	err := cmd.Execute()
+
+	assert.NotNil(t, err)
+	assert.Equal(t, err, fmt.Errorf("expected the \"[HOST/]OWNER/REPO\" format, got \"testOrg/testRepo/123/123\""))
+	assert.True(t, gock.IsDone(), internal.PrintPendingMocks(gock.Pending()))
+}
+
+func TestListWithNegativeLimit(t *testing.T) {
+	t.Cleanup(gock.Off)
+
+	cmd := NewCmdList()
+	cmd.SetArgs([]string{"--limit", "-1", "--repo", "testOrg/testRepo"})
+	err := cmd.Execute()
+
+	assert.NotNil(t, err)
+	assert.Equal(t, err, fmt.Errorf("-1 is not a valid value for limit flag. Allowed values: 1-100"))
+	assert.True(t, gock.IsDone(), internal.PrintPendingMocks(gock.Pending()))
+}
+
+func TestListWithIncorrectLimit(t *testing.T) {
+	t.Cleanup(gock.Off)
+
+	cmd := NewCmdList()
+	cmd.SetArgs([]string{"--limit", "101", "--repo", "testOrg/testRepo"})
+	err := cmd.Execute()
+
+	assert.NotNil(t, err)
+	assert.Equal(t, err, fmt.Errorf("101 is not a valid value for limit flag. Allowed values: 1-100"))
+	assert.True(t, gock.IsDone(), internal.PrintPendingMocks(gock.Pending()))
+}
+
+func TestListWithIncorrectOrder(t *testing.T) {
+	t.Cleanup(gock.Off)
+
+	cmd := NewCmdList()
+	cmd.SetArgs([]string{"--order", "incorrectOrderValue", "--repo", "testOrg/testRepo"})
+	err := cmd.Execute()
+
+	assert.NotNil(t, err)
+	assert.Equal(t, err, fmt.Errorf("incorrectOrderValue is not a valid value for order flag. Allowed values: asc/desc"))
+	assert.True(t, gock.IsDone(), internal.PrintPendingMocks(gock.Pending()))
+}
+
+func TestListWithIncorrectSort(t *testing.T) {
+	t.Cleanup(gock.Off)
+
+	cmd := NewCmdList()
+	cmd.SetArgs([]string{"--sort", "incorrectSortValue", "--repo", "testOrg/testRepo"})
+	err := cmd.Execute()
+
+	assert.NotNil(t, err)
+	assert.Equal(t, err, fmt.Errorf("incorrectSortValue is not a valid value for sort flag. Allowed values: last-used/size/created-at"))
+	assert.True(t, gock.IsDone(), internal.PrintPendingMocks(gock.Pending()))
+}
+
+func TestListWithIncorrectRepoForListCaches(t *testing.T) {
+	t.Cleanup(gock.Off)
+	gock.New("https://api.github.com").
+		Get("/repos/testOrg/testRepo/actions/cache/usage").
+		Reply(200).
+		JSON(`{
+			"full_name": "t-dedah/vipul-bugbash",
+			"active_caches_size_in_bytes": 291205,
+			"active_caches_count": 12
+		}`)
+
+	gock.New("https://api.github.com").
+		Get("/repos/testOrg/testRepo/actions/caches").
+		Reply(404).
+		JSON(`{
+			"message": "Not Found",
+			"documentation_url": "https://docs.github.com/rest/reference/actions#get-github-actions-cache-list-for-a-repository"
+		}`)
+
+	cmd := NewCmdList()
+	cmd.SetArgs([]string{"--repo", "testOrg/testRepo"})
+	err := cmd.Execute()
+
+	assert.NotNil(t, err)
+	assert.Equal(t, reflect.TypeOf(err), reflect.TypeOf(types.HandledError{}))
+
+	var customError types.HandledError
+	errors.As(err, &customError)
+	assert.Equal(t, customError.Message, "The given repo does not exist.")
+
+	assert.True(t, gock.IsDone(), internal.PrintPendingMocks(gock.Pending()))
+}
+
+func TestListWithUnauthorizedRequestForListCaches(t *testing.T) {
+	t.Cleanup(gock.Off)
+	gock.New("https://api.github.com").
+		Get("/repos/testOrg/testRepo/actions/cache/usage").
+		Reply(200).
+		JSON(`{
+			"full_name": "t-dedah/vipul-bugbash",
+			"active_caches_size_in_bytes": 291205,
+			"active_caches_count": 12
+		}`)
+
+	gock.New("https://api.github.com").
+		Get("/repos/testOrg/testRepo/actions/caches").
+		Reply(401).
+		JSON(`{
+			"message": "Must have admin rights to Repository.",
+			"documentation_url": "https://docs.github.com/rest/actions/cache#delete-a-github-actions-cache-for-a-repository-using-a-cache-id"
+		}`)
+
+	cmd := NewCmdList()
+	cmd.SetArgs([]string{"--repo", "testOrg/testRepo"})
+	err := cmd.Execute()
+
+	assert.NotNil(t, err)
+	assert.Equal(t, reflect.TypeOf(err), reflect.TypeOf(types.HandledError{}))
+
+	var customError types.HandledError
+	errors.As(err, &customError)
+	assert.Equal(t, customError.Message, "Must have admin rights to Repository.")
+
+	assert.True(t, gock.IsDone(), internal.PrintPendingMocks(gock.Pending()))
+}
+
+func TestListWithInternalServerErrorForListCaches(t *testing.T) {
+	t.Cleanup(gock.Off)
+	gock.New("https://api.github.com").
+		Get("/repos/testOrg/testRepo/actions/cache/usage").
+		Reply(200).
+		JSON(`{
+			"full_name": "t-dedah/vipul-bugbash",
+			"active_caches_size_in_bytes": 291205,
+			"active_caches_count": 12
+		}`)
+
+	gock.New("https://api.github.com").
+		Get("/repos/testOrg/testRepo/actions/caches").
+		Reply(500).
+		JSON(`{
+			"message": "Internal Server Error",
+			"documentation_url": "https://docs.github.com/rest/reference/actions#get-github-actions-cache-list-for-a-repository"
+		}`)
+
+	cmd := NewCmdList()
+	cmd.SetArgs([]string{"--repo", "testOrg/testRepo"})
+	err := cmd.Execute()
+
+	assert.NotNil(t, err)
+	assert.Equal(t, reflect.TypeOf(err), reflect.TypeOf(types.HandledError{}))
+
+	var customError types.HandledError
+	errors.As(err, &customError)
+	assert.Equal(t, customError.Message, "We could not process your request due to internal error.")
+
+	assert.True(t, gock.IsDone(), internal.PrintPendingMocks(gock.Pending()))
+}
+
+func TestListSuccess(t *testing.T) {
+	t.Cleanup(gock.Off)
+	gock.New("https://api.github.com").
+		Get("/repos/testOrg/testRepo/actions/cache/usage").
+		Reply(200).
+		JSON(`{
+			"full_name": "t-dedah/vipul-bugbash",
+			"active_caches_size_in_bytes": 2432967,
+			"active_caches_count": 1
+		}`)
+
+	gock.New("https://api.github.com").
+		Get("/repos/testOrg/testRepo/actions/caches").
+		Reply(200).
+		JSON(`{
+			"total_count": 1,
+			"actions_caches": [
+				{
+					"id": 29,
+					"ref": "refs/heads/master",
+					"key": "Linux-build-cache-node-modules-3fd22dd3a926d576e2562e8b76a5ff157cd3b986f3d44195acfe7efa6bc05919-8",
+					"version": "7fcda33c1e1d849a13bcc06f49b9ab64efc01ca9dabe4d7a8d0d387feef4fc88",
+					"last_accessed_at": "2022-06-22T20:32:45.550000000Z",
+					"created_at": "2022-06-22T20:32:45.550000000Z",
+					"size_in_bytes": 2432967
+				}]
+			}`)
+
+	cmd := NewCmdList()
+	cmd.SetArgs([]string{"--repo", "testOrg/testRepo"})
+	err := cmd.Execute()
+
+	assert.Nil(t, err)
+	assert.True(t, gock.IsDone(), internal.PrintPendingMocks(gock.Pending()))
+}