Tests

3 files changed, 197 insertions, 21 deletions

diff --git a/internal/config/config.go b/internal/config/config.go
index 2df7d98..361246e 100644
--- a/internal/config/config.go
+++ b/internal/config/config.go
@@ -2,51 +2,46 @@ package config
 
 import (
 	"fmt"
-	"gopkg.in/yaml.v3"
 	"io/ioutil"
 )
 
 type Map map[string]interface{}
 type Feeds map[string]*Feed
 
-type config struct {
-	GlobalConfig Map `yaml:",inline"`
-	Feeds        []configGroupFeed
-}
-
 type Config struct {
-	GlobalConfig Map `yaml:",inline"`
+	GlobalConfig Map
 	Feeds        Feeds
 }
 
 type Feed struct {
-	Name    string
-	Target  string
-	Url     string
-	MinFreq int
-	Config  Map
+	Name       string
+	Target     string `yaml:"-"`
+	Url        string
+	MinFreq    int   `yaml:"min-frequency"`
+	InclImages *bool `yaml:"include-images"`
 }
 
-func Load(path string) (*Config, error) {
+func Load(path string) (Config, error) {
+	var finishedCfg Config
+
 	buf, err := ioutil.ReadFile(path)
 	if err != nil {
-		return nil, fmt.Errorf("while reading '%s': %w", path, err)
+		return finishedCfg, fmt.Errorf("while reading '%s': %w", path, err)
 	}
 
 	var parsedCfg config
-	if err := yaml.Unmarshal(buf, &parsedCfg); err != nil {
-		return nil, fmt.Errorf("while unmarshalling: %w", err)
+	if parsedCfg, err = parse(buf); err != nil {
+		return finishedCfg, err
 	}
-	fmt.Printf("--- parsedCfg:\n%+v\n\n", parsedCfg)
 
-	var finishedCfg = Config{
+	finishedCfg = Config{
 		GlobalConfig: parsedCfg.GlobalConfig,
 		Feeds:        make(Feeds),
 	}
 
 	if err := buildFeeds(parsedCfg.Feeds, "", finishedCfg.Feeds); err != nil {
-		return nil, fmt.Errorf("while parsing: %w", err)
+		return finishedCfg, fmt.Errorf("while parsing: %w", err)
 	}
 
-	return &finishedCfg, nil
+	return finishedCfg, nil
 }
diff --git a/internal/config/config_test.go b/internal/config/config_test.go
new file mode 100644
index 0000000..44dbfe2
--- /dev/null
+++ b/internal/config/config_test.go
@@ -0,0 +1,163 @@
+package config
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestLoad(t *testing.T) {
+	type args struct {
+		path string
+	}
+	tests := []struct {
+		name    string
+		args    args
+		want    Config
+		wantErr bool
+	}{
+		// TODO: Add test cases.
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := Load(tt.args.path)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("Load() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("Load() got = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func s(s string) *string { return &s }
+func b(b bool) *bool     { return &b }
+
+//noinspection GoNilness,GoNilness
+func TestParse(t *testing.T) {
+	tests := []struct {
+		name         string
+		inp          string
+		wantErr      bool
+		feeds        []configGroupFeed
+		globalConfig Map
+	}{
+		{name: "Empty",
+			inp: "", wantErr: false, feeds: nil, globalConfig: nil},
+		{name: "Trash", inp: "Something", wantErr: true},
+		{name: "Simple config",
+			inp: "something: 1\nsomething_else: 2", wantErr: false, feeds: nil, globalConfig: Map{"something": 1, "something_else": 2}},
+		{name: "Config with feed",
+			inp: `
+something: 1
+feeds:
+   - name: Foo
+     url: whatever
+     target: bar
+     include-images: true
+     unknown-option: foo
+`,
+			wantErr:      false,
+			globalConfig: Map{"something": 1},
+			feeds: []configGroupFeed{
+				{Target: s("bar"), Feed: Feed{
+					Name:       "Foo",
+					Target:     "",
+					Url:        "whatever",
+					MinFreq:    0,
+					InclImages: b(true),
+				}}}},
+
+		{name: "Feeds",
+			inp: `
+feeds:
+   - name: Foo
+     url: whatever
+     min-frequency: 2
+   - name: Shrubbery
+     url: google.de
+     target: bla
+     include-images: false
+`,
+			wantErr: false,
+			feeds: []configGroupFeed{
+				{Target: nil, Feed: Feed{
+					Name:       "Foo",
+					Url:        "whatever",
+					MinFreq:    2,
+					InclImages: nil,
+				}},
+				{Target: s("bla"), Feed: Feed{
+					Name:       "Shrubbery",
+					Url:        "google.de",
+					MinFreq:    0,
+					InclImages: b(false),
+				}},
+			},
+		},
+		{name: "Empty Group",
+			inp: `
+feeds:
+   - group: Foo
+     target: bla
+`,
+			wantErr: false,
+			feeds:   []configGroupFeed{{Target: s("bla"), Group: Group{"Foo", nil}}},
+		},
+		{name: "Feeds and Groups",
+			inp: `
+feeds:
+   - name: Foo
+     url: whatever
+   - group: G1
+     target: target
+     feeds:
+      - group: G2
+        target: ""
+        feeds: 
+         - name: F1
+           url: google.de
+      - name: F2
+      - group: G3
+`,
+			wantErr: false,
+			feeds: []configGroupFeed{
+				{Target: nil, Feed: Feed{
+					Name: "Foo",
+					Url:  "whatever",
+				}},
+				{Target: s("target"), Group: Group{
+					Group: "G1",
+					Feeds: []configGroupFeed{
+						{Target: s(""), Group: Group{
+							Group: "G2",
+							Feeds: []configGroupFeed{
+								{Target: nil, Feed: Feed{Name: "F1", Url: "google.de"}},
+							}},
+						},
+						{Target: nil, Feed: Feed{Name: "F2"}},
+						{Target: nil, Group: Group{Group: "G3"}},
+					}},
+				},
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			var buf = []byte(tt.inp)
+			got, err := parse(buf)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("parse() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(got.Feeds, tt.feeds) {
+				t.Errorf("parse() got = %v, want %v", got.Feeds, tt.feeds)
+			}
+			if !reflect.DeepEqual(got.GlobalConfig, tt.globalConfig) {
+				t.Errorf("parse() got = %v, want %v", got.GlobalConfig, tt.globalConfig)
+			}
+		})
+	}
+}
diff --git a/internal/config/yaml.go b/internal/config/yaml.go
index 335dede..aa58685 100644
--- a/internal/config/yaml.go
+++ b/internal/config/yaml.go
@@ -1,6 +1,14 @@
 package config
 
-import "fmt"
+import (
+	"fmt"
+	"gopkg.in/yaml.v3"
+)
+
+type config struct {
+	GlobalConfig Map `yaml:",inline"`
+	Feeds        []configGroupFeed
+}
 
 type Group struct {
 	Group string
@@ -32,6 +40,16 @@ func (grpFeed *configGroupFeed) target() string {
 	return grpFeed.Group.Group
 }
 
+func parse(buf []byte) (config, error) {
+	var parsedCfg config
+	if err := yaml.Unmarshal(buf, &parsedCfg); err != nil {
+		return parsedCfg, fmt.Errorf("while unmarshalling: %w", err)
+	}
+	fmt.Printf("--- parsedCfg:\n%+v\n\n", parsedCfg)
+
+	return parsedCfg, nil
+}
+
 func appTarget(target, app string) string {
 	if target == "" {
 		return app