feat: Wire in new datasources & finding structures

config.example.toml

@@ -6,15 +6,15 @@ label = "Go"
 slack_emoji = ":golang:"
 
 [[ecosystem]]
-label = "Npm"
+label = "Js"
 slack_emoji = ":javascript:"
 
 [[ecosystem]]
-label = "Pip"
+label = "Python"
 slack_emoji = ":python:"
 
 [[ecosystem]]
-label = "Rubygems"
+label = "Ruby"
 slack_emoji = ":ruby:"
 
 # Configure the severities we're reporting on
@@ -34,6 +34,10 @@ slack_emoji = ":severity_medium:"
 label = "Low"
 slack_emoji = ":severity_low:"
 
+[[severity]]
+label = "Undefined"
+slack_emoji = ":white_check_mark:"
+
 # Configure individual teams to report directly on their work
 [[team]]
 name = "Some Team"

config/config.go

@@ -99,18 +99,18 @@ func LoadEnv(params ViperParams) error {
 	return nil
 }
 
-func GetIconForSeverity(severity string, severities []SeverityConfig) (string, error) {
+func GetIconForSeverity(severity FindingSeverityType, severities []SeverityConfig) (string, error) {
 	for _, config := range severities {
-		if config.Label == severity {
+		if config.Label == SeverityNames[severity] {
 			return config.Slack_emoji, nil
 		}
 	}
-	return "", fmt.Errorf("No Slack icon available for severity %s", severity)
+	return "", fmt.Errorf("No Slack icon available for severity %s", SeverityNames[severity])
 }
 
-func GetIconForEcosystem(ecosystem string, ecosystems []EcosystemConfig) (string, error) {
+func GetIconForEcosystem(ecosystem FindingEcosystemType, ecosystems []EcosystemConfig) (string, error) {
 	for _, config := range ecosystems {
-		if config.Label == ecosystem {
+		if strings.ToLower(config.Label) == string(ecosystem) {
 			return config.Slack_emoji, nil
 		}
 	}

config/config_test.go

@@ -1,4 +1,4 @@
-package config
+package config_test
 
 import (
 	"fmt"
@@ -7,53 +7,54 @@ import (
 	"testing"
 
 	"github.com/stretchr/testify/assert"
+	"github.com/underdog-tech/vulnbot/config"
 )
 
 func TestGetIconForConfiguredSeverity(t *testing.T) {
-	severities := []SeverityConfig{
+	severities := []config.SeverityConfig{
 		{Label: "High", Slack_emoji: ":high:"},
 		{Label: "Low", Slack_emoji: ":low:"},
 	}
-	icon, err := GetIconForSeverity("High", severities)
+	icon, err := config.GetIconForSeverity(config.FindingSeverityHigh, severities)
 	assert.Equal(t, icon, ":high:")
 	assert.Nil(t, err)
 }
 
 func TestGetIconForUnconfiguredSeverity(t *testing.T) {
-	severities := []SeverityConfig{
+	severities := []config.SeverityConfig{
 		{Label: "High", Slack_emoji: ":high:"},
 		{Label: "Low", Slack_emoji: ":low:"},
 	}
-	icon, err := GetIconForSeverity("Medium", severities)
+	icon, err := config.GetIconForSeverity(config.FindingSeverityModerate, severities)
 	assert.Empty(t, icon)
 	assert.Error(t, err)
 }
 
 func TestGetIconForConfiguredEcosystem(t *testing.T) {
-	ecosystems := []EcosystemConfig{
-		{Label: "Pip", Slack_emoji: ":python:"},
+	ecosystems := []config.EcosystemConfig{
+		{Label: "Python", Slack_emoji: ":python:"},
 		{Label: "Go", Slack_emoji: ":golang:"},
 	}
-	icon, err := GetIconForEcosystem("Pip", ecosystems)
+	icon, err := config.GetIconForEcosystem(config.FindingEcosystemPython, ecosystems)
 	assert.Equal(t, icon, ":python:")
 	assert.Nil(t, err)
 }
 
 func TestGetConfiguredTeamConfigBySlug(t *testing.T) {
-	testersTeam := TeamConfig{Name: "Testers", Github_slug: "testers-team"}
-	failersTeam := TeamConfig{Name: "Failers", Github_slug: "failers-team"}
-	TeamConfigs := []TeamConfig{
+	testersTeam := config.TeamConfig{Name: "Testers", Github_slug: "testers-team"}
+	failersTeam := config.TeamConfig{Name: "Failers", Github_slug: "failers-team"}
+	TeamConfigs := []config.TeamConfig{
 		testersTeam,
 		failersTeam,
 	}
-	team, err := GetTeamConfigBySlug("testers-team", TeamConfigs)
+	team, err := config.GetTeamConfigBySlug("testers-team", TeamConfigs)
 	assert.Equal(t, team, testersTeam)
 	assert.Nil(t, err)
 }
 
 func TestGetUnconfiguredTeamConfigBySlug(t *testing.T) {
-	TeamConfigs := []TeamConfig{} // Empty is easiest for this purpose
-	team, err := GetTeamConfigBySlug("unknown-team", TeamConfigs)
+	TeamConfigs := []config.TeamConfig{} // Empty is easiest for this purpose
+	team, err := config.GetTeamConfigBySlug("unknown-team", TeamConfigs)
 	assert.Empty(t, team)
 	assert.Error(t, err)
 }
@@ -76,14 +77,14 @@ func TestLoadConfig(t *testing.T) {
 	}
 	testDataPath := filepath.Join(currentDir, "/testdata/test_config.toml")
 
-	var config Config
-	_ = LoadConfig(ViperParams{
-		Output:     &config,
+	var cfg config.Config
+	_ = config.LoadConfig(config.ViperParams{
+		Output:     &cfg,
 		ConfigPath: &testDataPath,
 	})
 
-	assert.IsType(t, Config{}, config)
-	assert.Equal(t, expectedSlackChannel, config.Default_slack_channel)
+	assert.IsType(t, config.Config{}, cfg)
+	assert.Equal(t, expectedSlackChannel, cfg.Default_slack_channel)
 }
 
 func TestLoadEnv(t *testing.T) {
@@ -94,12 +95,12 @@ func TestLoadEnv(t *testing.T) {
 	}
 	testDataPath := filepath.Join(currentDir, "/testdata/config.env")
 
-	var env Env
-	_ = LoadEnv(ViperParams{
+	var env config.Env
+	_ = config.LoadEnv(config.ViperParams{
 		EnvFileName: &testDataPath,
 		Output:      &env,
 	})
 
-	assert.IsType(t, Env{}, env)
+	assert.IsType(t, config.Env{}, env)
 	assert.Equal(t, expectedSlackAuthToken, env.SlackAuthToken)
 }

internal/datasources.go

@@ -0,0 +1,39 @@
+package internal
+
+import (
+	"sync"
+
+	"github.com/underdog-tech/vulnbot/config"
+	"github.com/underdog-tech/vulnbot/logger"
+	"github.com/underdog-tech/vulnbot/querying"
+)
+
+func GetDataSources(env config.Env, cfg config.Config) []querying.DataSource {
+	dataSources := []querying.DataSource{}
+
+	if env.GithubToken != "" {
+		ghds := querying.NewGithubDataSource(cfg, env)
+		dataSources = append(dataSources, &ghds)
+	}
+
+	return dataSources
+}
+
+func QueryAllDataSources(dataSources *[]querying.DataSource) *querying.ProjectCollection {
+	log := logger.Get()
+	projects := querying.NewProjectCollection()
+	wg := new(sync.WaitGroup)
+
+	for _, ds := range *dataSources {
+		wg.Add(1)
+		go func(currentDS querying.DataSource) {
+			err := currentDS.CollectFindings(projects, wg)
+			if err != nil {
+				log.Error().Err(err).Type("datasource", currentDS).Msg("Failed to query datasource")
+			}
+		}(ds)
+	}
+	wg.Wait()
+
+	return projects
+}