Add Alerting Contact Points

cli/backup/alerting.go

@@ -0,0 +1,34 @@
+package backup
+
+import (
+	"context"
+
+	"github.com/bep/simplecobra"
+	"github.com/esnet/gdg/cli/support"
+	"github.com/spf13/cobra"
+)
+
+func newAlertingCommand() simplecobra.Commander {
+	description := "Manage Alerting resources"
+	return &support.SimpleCommand{
+		NameP: "alerting",
+		Short: description,
+		Long:  description,
+		WithCFunc: func(cmd *cobra.Command, r *support.RootCommand) {
+			cmd.Aliases = []string{"alert"}
+			// connections := cmd
+			// connections.PersistentFlags().StringP("connection", "", "", "filter by connection slug")
+		},
+		CommandsList: []simplecobra.Commander{
+			newAlertingContactCommand(),
+			// newClearConnectionsCmd(),
+			// newUploadConnectionsCmd(),
+			// newDownloadConnectionsCmd(),
+			// newListConnectionsCmd(),
+			// newConnectionsPermissionCmd(),
+		},
+		RunFunc: func(ctx context.Context, cd *simplecobra.Commandeer, rootCmd *support.RootCommand, args []string) error {
+			return cd.CobraCommand.Help()
+		},
+	}
+}

cli/backup/alerting_contacts.go

@@ -0,0 +1,158 @@
+package backup
+
+import (
+	"context"
+	"encoding/json"
+	"log"
+	"log/slog"
+
+	"github.com/bep/simplecobra"
+	"github.com/esnet/gdg/cli/support"
+	"github.com/esnet/gdg/internal/service"
+	"github.com/jedib0t/go-pretty/v6/table"
+	"github.com/spf13/cobra"
+)
+
+func newAlertingContactCommand() simplecobra.Commander {
+	description := "Manage Alerting ContactPoints "
+	return &support.SimpleCommand{
+		NameP: "contactpoint",
+		Short: description,
+		Long:  description,
+		WithCFunc: func(cmd *cobra.Command, r *support.RootCommand) {
+			cmd.Aliases = []string{"contact", "contacts", "contactpoints"}
+		},
+		CommandsList: []simplecobra.Commander{
+			newListContactPointsCmd(),
+			newClearContactPointsCmd(),
+			newUploadContactPointsCmd(),
+			newDownloadContactPointsCmd(),
+		},
+		RunFunc: func(ctx context.Context, cd *simplecobra.Commandeer, rootCmd *support.RootCommand, args []string) error {
+			return cd.CobraCommand.Help()
+		},
+	}
+}
+
+func newListContactPointsCmd() simplecobra.Commander {
+	description := "List all contact points for the given Organization"
+	return &support.SimpleCommand{
+		NameP: "list",
+		Short: description,
+		Long:  description,
+		WithCFunc: func(cmd *cobra.Command, r *support.RootCommand) {
+			cmd.Aliases = []string{"l"}
+		},
+		RunFunc: func(ctx context.Context, cd *simplecobra.Commandeer, rootCmd *support.RootCommand, args []string) error {
+			rootCmd.TableObj.AppendHeader(table.Row{"uid", "name", "slug", "type", "provenance", "settings"})
+			contactPoints, err := rootCmd.GrafanaSvc().ListContactPoints()
+			slog.Info("Listing contact points for context",
+				slog.String("Organization", GetOrganizationName()),
+				slog.String("context", GetContext()))
+			slog.Warn("GDG does not manage the 'email receiver' entity.  It has a very odd behavior compared to all " +
+				"other entities. If you need to manage email contacts, please create a new contact.  GDG will ignore the default contact.")
+			if err != nil {
+				log.Fatal("unable to retrieve Orgs contact points", slog.Any("err", err))
+			}
+			if len(contactPoints) == 0 {
+				slog.Info("No contact points found")
+			} else {
+				for _, link := range contactPoints {
+					rawBytes, err := json.Marshal(link.Settings)
+					if err != nil {
+						slog.Warn("unable to marshall settings to valid JSON")
+					}
+					typeVal := ""
+					if link.Type != nil {
+						typeVal = *link.Type
+					}
+					rootCmd.TableObj.AppendRow(table.Row{link.UID, link.Name, service.GetSlug(link.Name), typeVal, link.Provenance, string(rawBytes)})
+				}
+				rootCmd.Render(cd.CobraCommand, contactPoints)
+			}
+			return nil
+		},
+	}
+}
+
+func newDownloadContactPointsCmd() simplecobra.Commander {
+	description := "Download all contact points for the given Organization"
+	return &support.SimpleCommand{
+		NameP: "download",
+		Short: description,
+		Long:  description,
+		WithCFunc: func(cmd *cobra.Command, r *support.RootCommand) {
+			cmd.Aliases = []string{"d"}
+		},
+		RunFunc: func(ctx context.Context, cd *simplecobra.Commandeer, rootCmd *support.RootCommand, args []string) error {
+			file, err := rootCmd.GrafanaSvc().DownloadContactPoints()
+			slog.Info("Download contact points for context",
+				slog.String("Organization", GetOrganizationName()),
+				slog.String("context", GetContext()))
+			if err != nil {
+				slog.Error("unable to contact point")
+			} else {
+				slog.Info("contact points successfully downloaded", slog.Any("file", file))
+			}
+			return nil
+		},
+	}
+}
+
+func newUploadContactPointsCmd() simplecobra.Commander {
+	description := "Upload all contact points for the given Organization"
+	return &support.SimpleCommand{
+		NameP: "upload",
+		Short: description,
+		Long:  description,
+		WithCFunc: func(cmd *cobra.Command, r *support.RootCommand) {
+			cmd.Aliases = []string{"u"}
+		},
+		RunFunc: func(ctx context.Context, cd *simplecobra.Commandeer, rootCmd *support.RootCommand, args []string) error {
+			newItems, err := rootCmd.GrafanaSvc().UploadContactPoints()
+			slog.Info("Upload contact points for context",
+				slog.String("Organization", GetOrganizationName()),
+				slog.String("context", GetContext()))
+			if err != nil {
+				slog.Error("unable to upload contact points", slog.Any("err", err))
+			} else {
+				slog.Info("contact points successfully uploaded")
+				rootCmd.TableObj.AppendHeader(table.Row{"name"})
+				for _, item := range newItems {
+					rootCmd.TableObj.AppendRow(table.Row{item})
+				}
+
+				rootCmd.Render(cd.CobraCommand, newItems)
+			}
+			return nil
+		},
+	}
+}
+
+func newClearContactPointsCmd() simplecobra.Commander {
+	description := "Clear all contact points for the given Organization"
+	return &support.SimpleCommand{
+		NameP: "clear",
+		Short: description,
+		Long:  description,
+		WithCFunc: func(cmd *cobra.Command, r *support.RootCommand) {
+			cmd.Aliases = []string{"l"}
+		},
+		RunFunc: func(ctx context.Context, cd *simplecobra.Commandeer, rootCmd *support.RootCommand, args []string) error {
+			removedItems, err := rootCmd.GrafanaSvc().ClearContactPoints()
+			slog.Info("Clear contact points for context",
+				slog.String("Organization", GetOrganizationName()),
+				slog.String("context", GetContext()))
+			if err != nil {
+				slog.Error("unable to contact point")
+			} else {
+				slog.Info("contact points successfully removed")
+				rootCmd.TableObj.AppendHeader(table.Row{"name"})
+				for _, item := range removedItems {
+					rootCmd.TableObj.AppendRow(table.Row{item})
+				}
+			}
+			return nil
+		},
+	}
+}

cli/backup/backup.go

@@ -35,6 +35,7 @@ limited to clear/delete, list, download and upload.  Any other functionality wil
 			newOrganizationsCommand(),
 			newTeamsCommand(),
 			newUsersCommand(),
+			newAlertingCommand(),
 		},
 	}
 }

cli/commandeer.go

@@ -27,7 +27,9 @@ func Execute(defaultCfg string, args []string, options ...support.RootOption) er
 	cd, err := x.Execute(context.Background(), args)
 
 	if err != nil || len(args) == 0 {
-		_ = cd.CobraCommand.Help()
+		if cd != nil {
+			_ = cd.CobraCommand.Help()
+		}
 		return err
 	}
 

cli/test/backup/alerting_contactpoints_test.go

@@ -0,0 +1,92 @@
+package backup
+
+import (
+	"io"
+	"strings"
+	"testing"
+
+	"github.com/esnet/gdg/cli"
+	"github.com/esnet/gdg/cli/support"
+	"github.com/esnet/gdg/internal/service"
+	"github.com/esnet/gdg/internal/service/mocks"
+	"github.com/esnet/gdg/internal/tools/ptr"
+	"github.com/esnet/gdg/pkg/test_tooling"
+	"github.com/esnet/gdg/pkg/test_tooling/common"
+	"github.com/grafana/grafana-openapi-client-go/models"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestContactPoints(t *testing.T) {
+	getOptionMockSvc := func(testSvc *mocks.GrafanaService) func() support.RootOption {
+		return func() support.RootOption {
+			return func(response *support.RootCommand) {
+				response.GrafanaSvc = func() service.GrafanaService {
+					return testSvc
+				}
+			}
+		}
+	}
+
+	t.Run("NoDataTest", func(t *testing.T) {
+		testSvc := new(mocks.GrafanaService)
+		testSvc.EXPECT().InitOrganizations().Return()
+		testSvc.EXPECT().ListContactPoints().Return(nil, nil)
+		optionMockSvc := getOptionMockSvc(testSvc)
+		r, w, cleanup := test_tooling.InterceptStdout()
+		defer cleanup()
+
+		err := cli.Execute(common.DefaultTestConfig, []string{"backup", "alerting", "contactpoint", "list"}, optionMockSvc())
+		assert.Nil(t, err)
+		defer cleanup()
+		w.Close()
+
+		out, _ := io.ReadAll(r)
+		outStr := string(out)
+		assert.True(t, strings.Contains(outStr, "WRN GDG does not manage the 'email receiver' entity."))
+		assert.True(t, strings.Contains(outStr, "No contact points found"))
+	})
+	t.Run("ListingTest", func(t *testing.T) {
+		testSvc := new(mocks.GrafanaService)
+		getMockSvc := func() service.GrafanaService {
+			return testSvc
+		}
+		resp := []*models.EmbeddedContactPoint{
+			{
+				Name:     "Discord",
+				Type:     ptr.Of("discordType"),
+				Settings: map[string]any{"token": "secret", "someValue": "result"},
+			},
+			{
+				Name:     "Slack",
+				Type:     ptr.Of("slackType"),
+				Settings: map[string]any{"token": "secret", "slack": "rocks"},
+			},
+		}
+
+		testSvc.EXPECT().InitOrganizations().Return()
+		testSvc.EXPECT().ListContactPoints().Return(resp, nil)
+
+		optionMockSvc := func() support.RootOption {
+			return func(response *support.RootCommand) {
+				response.GrafanaSvc = getMockSvc
+			}
+		}
+		r, w, cleanup := test_tooling.InterceptStdout()
+		defer cleanup()
+
+		err := cli.Execute(common.DefaultTestConfig, []string{"backup", "alerting", "contactpoint", "list"}, optionMockSvc())
+		assert.Nil(t, err)
+		defer cleanup()
+		w.Close()
+
+		out, _ := io.ReadAll(r)
+		outStr := string(out)
+		assert.True(t, strings.Contains(outStr, "WRN GDG does not manage the 'email receiver' entity."))
+		assert.True(t, strings.Contains(outStr, "PROVENANCE"))
+		assert.True(t, strings.Contains(outStr, "Discord"))
+		assert.True(t, strings.Contains(outStr, "Slack"))
+		// validate Type
+		assert.True(t, strings.Contains(outStr, "discordType"))
+		assert.True(t, strings.Contains(outStr, "slackType"))
+	})
+}

cli/test/conections_test.go → cli/test/backup/conections_test.go

@@ -1,10 +1,12 @@
-package test
+package backup
 
 import (
 	"io"
 	"strings"
 	"testing"
 
+	"github.com/esnet/gdg/pkg/test_tooling"
+
 	"github.com/esnet/gdg/cli"
 	"github.com/esnet/gdg/cli/support"
 	"github.com/esnet/gdg/internal/service"
@@ -38,7 +40,7 @@ func TestConnectionCommand(t *testing.T) {
 			response.GrafanaSvc = getMockSvc
 		}
 	}
-	r, w, cleanup := InterceptStdout()
+	r, w, cleanup := test_tooling.InterceptStdout()
 
 	err := cli.Execute(common.DefaultTestConfig, []string{"backup", "connections", "list"}, optionMockSvc())
 	assert.Nil(t, err)

cli/test/backup/main_test.go

@@ -0,0 +1,18 @@
+package backup
+
+import (
+	"log"
+	"os"
+	"testing"
+
+	"github.com/esnet/gdg/pkg/test_tooling/path"
+)
+
+func TestMain(m *testing.M) {
+	err := path.FixTestDir("backup", "../../..")
+	if err != nil {
+		log.Fatal(err.Error())
+	}
+	code := m.Run()
+	os.Exit(code)
+}

cli/test/devel_test.go → cli/test/tools/devel_test.go

@@ -1,9 +1,11 @@
-package test
+package tools
 
 import (
 	"strings"
 	"testing"
 
+	"github.com/esnet/gdg/pkg/test_tooling"
+
 	"github.com/esnet/gdg/cli"
 	"github.com/esnet/gdg/cli/support"
 	"github.com/esnet/gdg/internal/service/mocks"
@@ -21,7 +23,7 @@ func TestDevelSrvInfo(t *testing.T) {
 		err := cli.Execute(string(data), []string{"tools", "devel", "srvinfo"}, optionMockSvc())
 		return err
 	}
-	outStr, closeReader := setupAndExecuteMockingServices(t, execMe)
+	outStr, closeReader := test_tooling.SetupAndExecuteMockingServices(t, execMe)
 	defer closeReader()
 
 	assert.True(t, strings.Contains(outStr, "Version="))
@@ -37,15 +39,15 @@ func TestDevelSrvCompletion(t *testing.T) {
 		}
 	}
 
-	outStr, closeReader := setupAndExecuteMockingServices(t, fn([]string{"tools", "devel", "completion", "fish"}))
+	outStr, closeReader := test_tooling.SetupAndExecuteMockingServices(t, fn([]string{"tools", "devel", "completion", "fish"}))
 	assert.True(t, strings.Contains(outStr, "fish"))
 	assert.True(t, strings.Contains(outStr, "__completion_prepare_completions"))
 	closeReader()
-	outStr, closeReader = setupAndExecuteMockingServices(t, fn([]string{"tools", "devel", "completion", "bash"}))
+	outStr, closeReader = test_tooling.SetupAndExecuteMockingServices(t, fn([]string{"tools", "devel", "completion", "bash"}))
 	assert.True(t, strings.Contains(outStr, "bash"))
 	assert.True(t, strings.Contains(outStr, "flag_parsing_disabled"))
 	closeReader()
-	outStr, closeReader = setupAndExecuteMockingServices(t, fn([]string{"tools", "devel", "completion", "zsh"}))
+	outStr, closeReader = test_tooling.SetupAndExecuteMockingServices(t, fn([]string{"tools", "devel", "completion", "zsh"}))
 	assert.True(t, strings.Contains(outStr, "shellCompDirectiveKeepOrder"))
 	closeReader()
 }