feat(config): support JSON files (fanal#159)

* feat(config): support JSON files

* feat(json): add Version()

* fix Type() and add test

Author: ronaudinho

analyzer/config/const.go

@@ -3,4 +3,5 @@ package config
 const (
 	YAML = "yaml"
 	TOML = "toml"
+	JSON = "json"
 )

analyzer/config/json/json.go

@@ -0,0 +1,59 @@
+package json
+
+import (
+	"os"
+	"path/filepath"
+
+	"github.com/open-policy-agent/conftest/parser/json"
+	"golang.org/x/xerrors"
+
+	"github.com/aquasecurity/fanal/analyzer"
+	"github.com/aquasecurity/fanal/analyzer/config"
+	"github.com/aquasecurity/fanal/types"
+)
+
+func init() {
+	analyzer.RegisterAnalyzer(&jsonConfigAnalyzer{
+		parser: &json.Parser{},
+	})
+}
+
+const version = 1
+
+var requiredExts = []string{".json"}
+
+type jsonConfigAnalyzer struct {
+	parser *json.Parser
+}
+
+func (a jsonConfigAnalyzer) Analyze(target analyzer.AnalysisTarget) (*analyzer.AnalysisResult, error) {
+	var parsed interface{}
+	if err := a.parser.Unmarshal(target.Content, &parsed); err != nil {
+		return nil, xerrors.Errorf("unable to parse JSON (%s): %w", target.FilePath, err)
+	}
+	return &analyzer.AnalysisResult{
+		Configs: []types.Config{{
+			Type:     config.JSON,
+			FilePath: target.FilePath,
+			Content:  parsed,
+		}},
+	}, nil
+}
+
+func (a jsonConfigAnalyzer) Required(filePath string, _ os.FileInfo) bool {
+	ext := filepath.Ext(filePath)
+	for _, required := range requiredExts {
+		if ext == required {
+			return true
+		}
+	}
+	return false
+}
+
+func (a jsonConfigAnalyzer) Type() analyzer.Type {
+	return analyzer.TypeJSON
+}
+
+func (a jsonConfigAnalyzer) Version() int {
+	return version
+}

analyzer/config/json/json_test.go

@@ -0,0 +1,146 @@
+package json
+
+import (
+	"io/ioutil"
+	"testing"
+
+	"github.com/open-policy-agent/conftest/parser/json"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+
+	"github.com/aquasecurity/fanal/analyzer"
+	"github.com/aquasecurity/fanal/analyzer/config"
+	"github.com/aquasecurity/fanal/types"
+)
+
+func Test_jsonConfigAnalyzer_Analyze(t *testing.T) {
+	tests := []struct {
+		name      string
+		inputFile string
+		want      *analyzer.AnalysisResult
+		wantErr   string
+	}{
+		{
+			name:      "happy path",
+			inputFile: "testdata/deployment.json",
+			want: &analyzer.AnalysisResult{
+				Configs: []types.Config{
+					{
+						Type:     config.JSON,
+						FilePath: "testdata/deployment.json",
+						Content: map[string]interface{}{
+							"apiVersion": "apps/v1",
+							"kind":       "Deployment",
+							"metadata": map[string]interface{}{
+								"name": "hello-kubernetes",
+							},
+							"spec": map[string]interface{}{
+								"replicas": float64(3),
+							},
+						},
+					},
+				},
+			},
+		},
+		{
+			name:      "happy path: json array",
+			inputFile: "testdata/array.json",
+			want: &analyzer.AnalysisResult{
+				Configs: []types.Config{
+					{
+						Type:     config.JSON,
+						FilePath: "testdata/array.json",
+						Content: []interface{}{
+							map[string]interface{}{
+								"apiVersion": "apps/v1",
+								"kind":       "Deployment",
+								"metadata": map[string]interface{}{
+									"name": "hello-kubernetes",
+								},
+								"spec": map[string]interface{}{
+									"replicas": float64(3),
+								},
+							},
+							map[string]interface{}{
+								"apiVersion": "apps/v2",
+								"kind":       "Deployment",
+								"metadata": map[string]interface{}{
+									"name": "hello-kubernetes",
+								},
+								"spec": map[string]interface{}{
+									"replicas": float64(3),
+								},
+							},
+						},
+					},
+				},
+			},
+		},
+		{
+			name:      "broken JSON",
+			inputFile: "testdata/broken.json",
+			wantErr:   "unmarshal json",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			b, err := ioutil.ReadFile(tt.inputFile)
+			require.NoError(t, err)
+
+			a := jsonConfigAnalyzer{
+				parser: &json.Parser{},
+			}
+
+			got, err := a.Analyze(analyzer.AnalysisTarget{
+				FilePath: tt.inputFile,
+				Content:  b,
+			})
+
+			if tt.wantErr != "" {
+				require.NotNil(t, err)
+				assert.Contains(t, err.Error(), tt.wantErr)
+				return
+			}
+			assert.NoError(t, err)
+			assert.Equal(t, tt.want, got)
+		})
+	}
+}
+
+func Test_jsonConfigAnalyzer_Required(t *testing.T) {
+	tests := []struct {
+		name     string
+		filePath string
+		want     bool
+	}{
+		{
+			name:     "json",
+			filePath: "deployment.json",
+			want:     true,
+		},
+		{
+			name:     "yaml",
+			filePath: "deployment.yaml",
+			want:     false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			a := jsonConfigAnalyzer{
+				parser: &json.Parser{},
+			}
+
+			got := a.Required(tt.filePath, nil)
+			assert.Equal(t, tt.want, got)
+		})
+	}
+}
+
+func Test_jsonConfigAnalyzer_Type(t *testing.T) {
+	want := analyzer.TypeJSON
+	a := jsonConfigAnalyzer{
+		parser: &json.Parser{},
+	}
+	got := a.Type()
+	assert.Equal(t, want, got)
+}

analyzer/config/json/testdata/array.json

@@ -0,0 +1,22 @@
+[
+	{
+		"apiVersion": "apps/v1",
+		"kind": "Deployment",
+		"metadata": {
+			"name": "hello-kubernetes"
+		},
+		"spec": {
+			"replicas": 3
+		}
+	},
+	{
+		"apiVersion": "apps/v2",
+		"kind": "Deployment",
+		"metadata": {
+			"name": "hello-kubernetes"
+		},
+		"spec": {
+			"replicas": 3
+		}
+	}
+]

analyzer/config/json/testdata/broken.json

@@ -0,0 +1,3 @@
+{
+	"apiVersion": "apps/v1",
+}

analyzer/config/json/testdata/deployment.json

@@ -0,0 +1,10 @@
+{
+	"apiVersion": "apps/v1",
+	"kind": "Deployment",
+	"metadata": {
+		"name": "hello-kubernetes"
+	},
+	"spec": {
+		"replicas": 3
+	}
+}

analyzer/const.go

@@ -37,4 +37,5 @@ const (
 	// Structured Config
 	TypeYaml = Type("yaml")
 	TypeTOML = Type("toml")
+	TypeJSON = Type("json")
 )