From 1f52d5d0fda0d1132d04c900565f2ecffccfd778 Mon Sep 17 00:00:00 2001 From: Henrique Dias Date: Tue, 25 Apr 2017 10:51:48 +0100 Subject: [PATCH] add some tests --- frontmatter/frontmatter.go | 2 +- frontmatter/runes.go | 6 +- frontmatter/runes_test.go | 131 ++++++++++++++++++++++++++++++++++ utils/variables/types_test.go | 49 +++++++++++++ 4 files changed, 184 insertions(+), 4 deletions(-) create mode 100644 frontmatter/runes_test.go create mode 100644 utils/variables/types_test.go diff --git a/frontmatter/frontmatter.go b/frontmatter/frontmatter.go index 85a1bee9..a0deb86c 100644 --- a/frontmatter/frontmatter.go +++ b/frontmatter/frontmatter.go @@ -76,7 +76,7 @@ func Unmarshal(content []byte) (interface{}, error) { return nil, err } default: - return nil, errors.New("Invalid frontmatter type.") + return nil, errors.New("Invalid frontmatter type") } return data, nil diff --git a/frontmatter/runes.go b/frontmatter/runes.go index 49b96dd6..b4ad1dc2 100644 --- a/frontmatter/runes.go +++ b/frontmatter/runes.go @@ -36,10 +36,10 @@ func RuneToStringFormat(mark rune) (string, error) { return "yaml", nil case '+': return "toml", nil - case '{': + case '{', '}': return "json", nil default: - return "", errors.New("Unsupported format type.") + return "", errors.New("Unsupported format type") } } @@ -53,6 +53,6 @@ func StringFormatToRune(format string) (rune, error) { case "json": return '{', nil default: - return '0', errors.New("Unsupported format type.") + return '0', errors.New("Unsupported format type") } } diff --git a/frontmatter/runes_test.go b/frontmatter/runes_test.go new file mode 100644 index 00000000..6d120948 --- /dev/null +++ b/frontmatter/runes_test.go @@ -0,0 +1,131 @@ +package frontmatter + +import "testing" + +type hasRuneTest struct { + File []byte + Return bool +} + +var testHasRune = []hasRuneTest{ + hasRuneTest{ + File: []byte(`--- +Lorem ipsum dolor sit amet, consectetur adipiscing elit. +Sed auctor libero eget ante fermentum commodo. +---`), + Return: true, + }, + hasRuneTest{ + File: []byte(`+++ +Lorem ipsum dolor sit amet, consectetur adipiscing elit. +Sed auctor libero eget ante fermentum commodo. ++++`), + Return: true, + }, + hasRuneTest{ + File: []byte(`{ + "json": "Lorem ipsum dolor sit amet" +}`), + Return: true, + }, + hasRuneTest{ + File: []byte(`+`), + Return: false, + }, + hasRuneTest{ + File: []byte(`++`), + Return: false, + }, + hasRuneTest{ + File: []byte(`-`), + Return: false, + }, + hasRuneTest{ + File: []byte(`--`), + Return: false, + }, + hasRuneTest{ + File: []byte(`Lorem ipsum`), + Return: false, + }, +} + +func TestHasRune(t *testing.T) { + for _, test := range testHasRune { + if HasRune(test.File) != test.Return { + t.Error("Incorrect value on HasRune") + } + } +} + +type appendRuneTest struct { + Before []byte + After []byte + Mark rune +} + +var testAppendRuneTest = []appendRuneTest{} + +func TestAppendRune(t *testing.T) { + for i, test := range testAppendRuneTest { + if !compareByte(AppendRune(test.Before, test.Mark), test.After) { + t.Errorf("Incorrect value on AppendRune of Test %d", i) + } + } +} + +func compareByte(a, b []byte) bool { + if a == nil && b == nil { + return true + } + + if a == nil || b == nil { + return false + } + + if len(a) != len(b) { + return false + } + + for i := range a { + if a[i] != b[i] { + return false + } + } + + return true +} + +var testRuneToStringFormat = map[rune]string{ + '-': "yaml", + '+': "toml", + '{': "json", + '}': "json", + '1': "", + 'a': "", +} + +func TestRuneToStringFormat(t *testing.T) { + for mark, format := range testRuneToStringFormat { + val, _ := RuneToStringFormat(mark) + if val != format { + t.Errorf("Incorrect value on RuneToStringFormat of %v; want: %s; got: %s", mark, format, val) + } + } +} + +var testStringFormatToRune = map[string]rune{ + "yaml": '-', + "toml": '+', + "json": '{', + "lorem": '0', +} + +func TestStringFormatToRune(t *testing.T) { + for format, mark := range testStringFormatToRune { + val, _ := StringFormatToRune(format) + if val != mark { + t.Errorf("Incorrect value on StringFormatToRune of %s; want: %v; got: %v", format, mark, val) + } + } +} diff --git a/utils/variables/types_test.go b/utils/variables/types_test.go new file mode 100644 index 00000000..9955b9b2 --- /dev/null +++ b/utils/variables/types_test.go @@ -0,0 +1,49 @@ +package variables + +import "testing" + +type interfaceToBool struct { + Value interface{} + Result bool +} + +var testIsMap = []*interfaceToBool{ + &interfaceToBool{"teste", false}, + &interfaceToBool{453478, false}, + &interfaceToBool{-984512, false}, + &interfaceToBool{true, false}, + &interfaceToBool{map[string]bool{}, true}, + &interfaceToBool{map[int]bool{}, true}, + &interfaceToBool{map[interface{}]bool{}, true}, + &interfaceToBool{[]string{}, false}, +} + +func TestIsMap(t *testing.T) { + for _, test := range testIsMap { + if IsMap(test.Value) != test.Result { + t.Errorf("Incorrect value on IsMap for %v; want: %v; got: %v", test.Value, test.Result, !test.Result) + } + } +} + +var testIsSlice = []*interfaceToBool{ + &interfaceToBool{"teste", false}, + &interfaceToBool{453478, false}, + &interfaceToBool{-984512, false}, + &interfaceToBool{true, false}, + &interfaceToBool{map[string]bool{}, false}, + &interfaceToBool{map[int]bool{}, false}, + &interfaceToBool{map[interface{}]bool{}, false}, + &interfaceToBool{[]string{}, true}, + &interfaceToBool{[]int{}, true}, + &interfaceToBool{[]bool{}, true}, + &interfaceToBool{[]interface{}{}, true}, +} + +func TestIsSlice(t *testing.T) { + for _, test := range testIsSlice { + if IsSlice(test.Value) != test.Result { + t.Errorf("Incorrect value on IsSlice for %v; want: %v; got: %v", test.Value, test.Result, !test.Result) + } + } +}