Demo changes

cmd/main.go

@@ -12,9 +12,7 @@ import (
 )
 
 const (
-	astSchemaEnv    = "AST_SCHEMA"
-	astHostEnv      = "AST_HOST"
-	astPortEnv      = "AST_PORT"
+	astURIEnv       = "AST_URI"
 	scansPathEnv    = "SCANS_PATH"
 	projectsPathEnv = "PROJECTS_PATH"
 	resultsPathEnv  = "RESULTS_PATH"
@@ -25,51 +23,39 @@ const (
 )
 
 func main() {
-	// Key ast_schema will be bound to AST_SCHEMA
-	astSchemaKey := strings.ToLower(astSchemaEnv)
-	err := bindKeyToEnvAndDefault(astSchemaKey, astSchemaEnv, "http")
+	// Key ast_uri will be bound to AST_URI
+	astURIKey := strings.ToLower(astURIEnv)
+	err := bindKeyToEnvAndDefault(astURIKey, astURIEnv, "http://localhost:80")
 	exitIfError(err)
-	schema := viper.GetString(astSchemaKey)
-
-	astHostKey := strings.ToLower(astHostEnv)
-	err = bindKeyToEnvAndDefault(astHostKey, astHostEnv, "localhost")
-	exitIfError(err)
-	host := viper.GetString(astHostKey)
-
-	astPortKey := strings.ToLower(astPortEnv)
-	err = bindKeyToEnvAndDefault(astPortKey, astPortEnv, "80")
-	exitIfError(err)
-	port := viper.GetString(astPortKey)
+	ast := viper.GetString(astURIKey)
 
 	scansPathKey := strings.ToLower(scansPathEnv)
-	err = bindKeyToEnvAndDefault(scansPathKey, scansPathEnv, "scans")
+	err = bindKeyToEnvAndDefault(scansPathKey, scansPathEnv, "api/scans")
 	exitIfError(err)
 	scans := viper.GetString(scansPathKey)
 
 	projectsPathKey := strings.ToLower(projectsPathEnv)
-	err = bindKeyToEnvAndDefault(projectsPathKey, projectsPathEnv, "projects")
+	err = bindKeyToEnvAndDefault(projectsPathKey, projectsPathEnv, "api/projects")
 	exitIfError(err)
 	projects := viper.GetString(projectsPathKey)
 
 	resultsPathKey := strings.ToLower(resultsPathEnv)
-	err = bindKeyToEnvAndDefault(resultsPathKey, resultsPathEnv, "results")
+	err = bindKeyToEnvAndDefault(resultsPathKey, resultsPathEnv, "api/results")
 	exitIfError(err)
 	results := viper.GetString(resultsPathKey)
 
 	uploadsPathKey := strings.ToLower(uploadsPathEnv)
-	err = bindKeyToEnvAndDefault(uploadsPathKey, uploadsPathEnv, "uploads")
+	err = bindKeyToEnvAndDefault(uploadsPathKey, uploadsPathEnv, "api/uploads")
 	exitIfError(err)
 	uploads := viper.GetString(uploadsPathKey)
 
 	err = bindKeyToEnvAndDefault(commands.AccessKeyIDConfigKey, commands.AccessKeyIDEnv, "")
 	exitIfError(err)
 	err = bindKeyToEnvAndDefault(commands.AccessKeySecretConfigKey, commands.AccessKeySecretEnv, "")
 	exitIfError(err)
-	err = bindKeyToEnvAndDefault(commands.AstAuthenticationHostConfigKey, commands.AstAuthenticationHostEnv, "")
+	err = bindKeyToEnvAndDefault(commands.AstAuthenticationURIConfigKey, commands.AstAuthenticationURIEnv, "")
 	exitIfError(err)
 
-	ast := fmt.Sprintf("%s://%s:%s/api", schema, host, port)
-
 	scansURL := fmt.Sprintf("%s/%s", ast, scans)
 	uploadsURL := fmt.Sprintf("%s/%s", ast, uploads)
 	projectsURL := fmt.Sprintf("%s/%s", ast, projects)
@@ -103,5 +89,5 @@ func bindKeyToEnvAndDefault(key, env, defaultVal string) error {
 // When building an executable for Windows and providing a name,
 // be sure to explicitly specify the .exe suffix when setting the executable’s name.
 // env GOOS=windows GOARCH=amd64 go build -o ./bin/ast.exe ./cmd
-// "bin/ast.exe" -v scan create   --inputFile  ./internal/commands/payloads/uploads.json --sources ./internal/commands/payloads/sources.zip
-// "bin/ast.exe" scan get  --id 4d9a9189-ddcc-4aa0-ba2f-9d6d7f92eceb
+// "bin/ast.exe" -v scan create   --input-file  ./internal/commands/payloads/uploads.json --sources ./internal/commands/payloads/sources.zip
+// "bin/ast.exe" scan list   4d9a9189-ddcc-4aa0-ba2f-9d6d7f92eceb

internal/commands/cluster.go

@@ -0,0 +1,29 @@
+package commands
+
+import (
+	"fmt"
+
+	"github.com/spf13/cobra"
+)
+
+func NewClusterCommand() *cobra.Command {
+	clusterCmd := &cobra.Command{
+		Use:   "cluster",
+		Short: "Manage AST cluster",
+	}
+
+	deployClusterCmd := &cobra.Command{
+		Use:   "deploy",
+		Short: "Deploy AST resources",
+		RunE:  runDeployClusterCommand(),
+	}
+	clusterCmd.AddCommand(deployClusterCmd)
+	return clusterCmd
+}
+
+func runDeployClusterCommand() func(cmd *cobra.Command, args []string) error {
+	return func(cmd *cobra.Command, args []string) error {
+		fmt.Println("deploy cluster")
+		return nil
+	}
+}

internal/commands/project.go

@@ -36,17 +36,17 @@ func NewProjectCommand(projectsWrapper wrappers.ProjectsWrapper) *cobra.Command
 	createProjCmd.PersistentFlags().StringP(inputFileFlag, inputFileFlagSh, "",
 		"A file holding the requested project object in JSON format. Takes precedence over --input")
 
-	getAllProjCmd := &cobra.Command{
-		Use:   "get-all",
-		Short: "Returns all projects in the system",
-		RunE:  runGetAllProjectsCommand(projectsWrapper),
+	listProjectsCmd := &cobra.Command{
+		Use:   "list",
+		Short: "List all projects in the system",
+		RunE:  runListProjectsCommand(projectsWrapper),
 	}
-	getAllProjCmd.PersistentFlags().Uint64P(limitFlag, limitFlagSh, 0, limitUsage)
-	getAllProjCmd.PersistentFlags().Uint64P(offsetFlag, offsetFlagSh, 0, offsetUsage)
+	listProjectsCmd.PersistentFlags().Uint64P(limitFlag, limitFlagSh, 0, limitUsage)
+	listProjectsCmd.PersistentFlags().Uint64P(offsetFlag, offsetFlagSh, 0, offsetUsage)
 
-	getProjCmd := &cobra.Command{
-		Use:   "get",
-		Short: "Returns information about a project",
+	showProjectCmd := &cobra.Command{
+		Use:   "show",
+		Short: "Show information about a project",
 		RunE:  runGetProjectByIDCommand(projectsWrapper),
 	}
 
@@ -62,7 +62,7 @@ func NewProjectCommand(projectsWrapper wrappers.ProjectsWrapper) *cobra.Command
 		RunE:  runGetProjectsTagsCommand(projectsWrapper),
 	}
 
-	projCmd.AddCommand(createProjCmd, getProjCmd, getAllProjCmd, deleteProjCmd, tagsCmd)
+	projCmd.AddCommand(createProjCmd, showProjectCmd, listProjectsCmd, deleteProjCmd, tagsCmd)
 	return projCmd
 }
 
@@ -132,7 +132,7 @@ func runCreateProjectCommand(projectsWrapper wrappers.ProjectsWrapper) func(cmd
 	}
 }
 
-func runGetAllProjectsCommand(projectsWrapper wrappers.ProjectsWrapper) func(cmd *cobra.Command, args []string) error {
+func runListProjectsCommand(projectsWrapper wrappers.ProjectsWrapper) func(cmd *cobra.Command, args []string) error {
 	return func(cmd *cobra.Command, args []string) error {
 		var allProjectsModel *projectsRESTApi.SlicedProjectsResponseModel
 		var errorModel *projectsRESTApi.ErrorModel
@@ -226,6 +226,7 @@ func runGetProjectsTagsCommand(projectsWrapper wrappers.ProjectsWrapper) func(cm
 		var tags *[]string
 		var errorModel *projectsRESTApi.ErrorModel
 		var err error
+
 		tags, errorModel, err = projectsWrapper.Tags()
 		if err != nil {
 			return errors.Wrapf(err, "%s", failedGettingTags)

internal/commands/project_test.go

@@ -23,9 +23,9 @@ func TestProjectNoSub(t *testing.T) {
 
 func TestRunCreateProjectCommandWithFile(t *testing.T) {
 	cmd := createASTTestCommand()
-	err := executeTestCommand(cmd, "-v", "project", "create", "--inputFile", "./payloads/nonsense.json")
+	err := executeTestCommand(cmd, "-v", "project", "create", "--input-file", "./payloads/nonsense.json")
 	assert.Assert(t, err != nil)
-	err = executeTestCommand(cmd, "-v", "project", "create", "--inputFile", "./payloads/projects.json")
+	err = executeTestCommand(cmd, "-v", "project", "create", "--input-file", "./payloads/projects.json")
 	assert.NilError(t, err)
 }
 
@@ -50,7 +50,7 @@ func TestRunCreateProjectCommandWithInputBadFormat(t *testing.T) {
 
 func TestRunGetProjectByIdCommandNoScanID(t *testing.T) {
 	cmd := createASTTestCommand()
-	err := executeTestCommand(cmd, "-v", "project", "get")
+	err := executeTestCommand(cmd, "-v", "project", "show")
 	assert.Assert(t, err != nil)
 	assert.Assert(t, err.Error() == "Failed getting a project: Please provide a project ID")
 }
@@ -64,7 +64,7 @@ func TestRunGetProjectByIdCommandFlagNonExist(t *testing.T) {
 
 func TestRunGetProjectByIdCommand(t *testing.T) {
 	cmd := createASTTestCommand()
-	err := executeTestCommand(cmd, "-v", "project", "get", "MOCK")
+	err := executeTestCommand(cmd, "-v", "project", "show", "MOCK")
 	assert.NilError(t, err)
 }
 func TestRunDeleteProjectByIdCommandNoProjectID(t *testing.T) {
@@ -89,30 +89,30 @@ func TestRunDeleteProjectByIdCommand(t *testing.T) {
 
 func TestRunGetAllProjectsCommand(t *testing.T) {
 	cmd := createASTTestCommand()
-	err := executeTestCommand(cmd, "-v", "project", "get-all")
+	err := executeTestCommand(cmd, "-v", "project", "list")
 	assert.NilError(t, err)
 }
 
 func TestRunGetAllProjectsCommandFlagNonExist(t *testing.T) {
 	cmd := createASTTestCommand()
-	err := executeTestCommand(cmd, "-v", "project", "get-all", "--chibutero")
+	err := executeTestCommand(cmd, "-v", "project", "list", "--chibutero")
 	assert.Assert(t, err != nil)
 	assert.Assert(t, err.Error() == unknownFlag)
 }
 
 func TestRunGetAllProjectsCommandWithLimit(t *testing.T) {
 	cmd := createASTTestCommand()
-	err := executeTestCommand(cmd, "-v", "project", "get-all", "--limit", "40")
+	err := executeTestCommand(cmd, "-v", "project", "list", "--limit", "40")
 	assert.NilError(t, err)
-	err = executeTestCommand(cmd, "-v", "project", "get-all", "-l", "40")
+	err = executeTestCommand(cmd, "-v", "project", "list", "-l", "40")
 	assert.NilError(t, err)
 }
 
 func TestRunGetAllProjectsCommandWithOffset(t *testing.T) {
 	cmd := createASTTestCommand()
-	err := executeTestCommand(cmd, "-v", "project", "get-all", "--offset", "150")
+	err := executeTestCommand(cmd, "-v", "project", "list", "--offset", "150")
 	assert.NilError(t, err)
-	err = executeTestCommand(cmd, "-v", "project", "get-all", "-o", "150")
+	err = executeTestCommand(cmd, "-v", "project", "list", "-o", "150")
 	assert.NilError(t, err)
 }
 

internal/commands/result.go

@@ -10,7 +10,7 @@ import (
 )
 
 const (
-	failedGettingResults = "Failed getting results"
+	failedListingResults = "Failed listing results"
 )
 
 func NewResultCommand(resultsWrapper wrappers.ResultsWrapper) *cobra.Command {
@@ -19,15 +19,15 @@ func NewResultCommand(resultsWrapper wrappers.ResultsWrapper) *cobra.Command {
 		Short: "Retrieve AST results",
 	}
 
-	getResultsCmd := &cobra.Command{
-		Use:   "get",
-		Short: "Returns results for a given scan",
+	listResultsCmd := &cobra.Command{
+		Use:   "list",
+		Short: "List results for a given scan",
 		RunE:  runGetResultByScanIDCommand(resultsWrapper),
 	}
-	getResultsCmd.PersistentFlags().Uint64P(limitFlag, limitFlagSh, 0, limitUsage)
-	getResultsCmd.PersistentFlags().Uint64P(offsetFlag, offsetFlagSh, 0, offsetUsage)
+	listResultsCmd.PersistentFlags().Uint64P(limitFlag, limitFlagSh, 0, limitUsage)
+	listResultsCmd.PersistentFlags().Uint64P(offsetFlag, offsetFlagSh, 0, offsetUsage)
 
-	resultCmd.AddCommand(getResultsCmd)
+	resultCmd.AddCommand(listResultsCmd)
 	return resultCmd
 }
 
@@ -37,22 +37,23 @@ func runGetResultByScanIDCommand(resultsWrapper wrappers.ResultsWrapper) func(cm
 		var errorModel *wrappers.ResultError
 		var err error
 		if len(args) == 0 {
-			return errors.Errorf("%s: Please provide a scan ID", failedGettingResults)
+			return errors.Errorf("%s: Please provide a scan ID", failedListingResults)
 		}
 		scanID := args[0]
 		limit, offset := getLimitAndOffset(cmd)
+
 		resultResponseModel, errorModel, err = resultsWrapper.GetByScanID(scanID, limit, offset)
 		if err != nil {
-			return errors.Wrapf(err, "%s", failedGettingResults)
+			return errors.Wrapf(err, "%s", failedListingResults)
 		}
 		// Checking the response
 		if errorModel != nil {
-			return errors.Errorf("%s: CODE: %d, %s", failedGettingResults, errorModel.Code, errorModel.Message)
+			return errors.Errorf("%s: CODE: %d, %s", failedListingResults, errorModel.Code, errorModel.Message)
 		} else if resultResponseModel != nil {
 			var responseModelJSON []byte
 			responseModelJSON, err = json.Marshal(resultResponseModel)
 			if err != nil {
-				return errors.Wrapf(err, "%s: failed to serialize results response ", failedGettingResults)
+				return errors.Wrapf(err, "%s: failed to serialize results response ", failedListingResults)
 			}
 			cmdOut := cmd.OutOrStdout()
 			fmt.Fprintln(cmdOut, string(responseModelJSON))

internal/commands/result_test.go

@@ -16,12 +16,12 @@ func TestResultHelp(t *testing.T) {
 
 func TestRunGetResultsByScanIDCommandNoScanID(t *testing.T) {
 	cmd := createASTTestCommand()
-	err := executeTestCommand(cmd, "-v", "result", "get")
+	err := executeTestCommand(cmd, "-v", "result", "list")
 	assert.Assert(t, err != nil)
-	assert.Assert(t, err.Error() == "Failed getting results: Please provide a scan ID")
+	assert.Assert(t, err.Error() == "Failed listing results: Please provide a scan ID")
 }
 func TestRunGetResultsByScanIDCommand(t *testing.T) {
 	cmd := createASTTestCommand()
-	err := executeTestCommand(cmd, "-v", "result", "get", "MOCK")
+	err := executeTestCommand(cmd, "-v", "result", "list", "MOCK")
 	assert.NilError(t, err)
 }