1
2 package toml
3
4 import (
5 "bytes"
6 "encoding/json"
7 "fmt"
8 "reflect"
9 "testing"
10 "time"
11 )
12
13 func testgenInvalid(t *testing.T, input string) {
14 t.Logf("Input TOML:\n%s", input)
15 tree, err := Load(input)
16 if err != nil {
17 return
18 }
19
20 typedTree := testgenTranslate(*tree)
21
22 buf := new(bytes.Buffer)
23 if err := json.NewEncoder(buf).Encode(typedTree); err != nil {
24 return
25 }
26
27 t.Fatalf("test did not fail. resulting tree:\n%s", buf.String())
28 }
29
30 func testgenValid(t *testing.T, input string, jsonRef string) {
31 t.Logf("Input TOML:\n%s", input)
32 tree, err := Load(input)
33 if err != nil {
34 t.Fatalf("failed parsing toml: %s", err)
35 }
36
37 typedTree := testgenTranslate(*tree)
38
39 buf := new(bytes.Buffer)
40 if err := json.NewEncoder(buf).Encode(typedTree); err != nil {
41 t.Fatalf("failed translating to JSON: %s", err)
42 }
43
44 var jsonTest interface{}
45 if err := json.NewDecoder(buf).Decode(&jsonTest); err != nil {
46 t.Logf("translated JSON:\n%s", buf.String())
47 t.Fatalf("failed decoding translated JSON: %s", err)
48 }
49
50 var jsonExpected interface{}
51 if err := json.NewDecoder(bytes.NewBufferString(jsonRef)).Decode(&jsonExpected); err != nil {
52 t.Logf("reference JSON:\n%s", jsonRef)
53 t.Fatalf("failed decoding reference JSON: %s", err)
54 }
55
56 if !reflect.DeepEqual(jsonExpected, jsonTest) {
57 t.Logf("Diff:\n%#+v\n%#+v", jsonExpected, jsonTest)
58 t.Fatal("parsed TOML tree is different than expected structure")
59 }
60 }
61
62 func testgenTranslate(tomlData interface{}) interface{} {
63 switch orig := tomlData.(type) {
64 case map[string]interface{}:
65 typed := make(map[string]interface{}, len(orig))
66 for k, v := range orig {
67 typed[k] = testgenTranslate(v)
68 }
69 return typed
70 case *Tree:
71 return testgenTranslate(*orig)
72 case Tree:
73 keys := orig.Keys()
74 typed := make(map[string]interface{}, len(keys))
75 for _, k := range keys {
76 typed[k] = testgenTranslate(orig.GetPath([]string{k}))
77 }
78 return typed
79 case []*Tree:
80 typed := make([]map[string]interface{}, len(orig))
81 for i, v := range orig {
82 typed[i] = testgenTranslate(v).(map[string]interface{})
83 }
84 return typed
85 case []map[string]interface{}:
86 typed := make([]map[string]interface{}, len(orig))
87 for i, v := range orig {
88 typed[i] = testgenTranslate(v).(map[string]interface{})
89 }
90 return typed
91 case []interface{}:
92 typed := make([]interface{}, len(orig))
93 for i, v := range orig {
94 typed[i] = testgenTranslate(v)
95 }
96 return testgenTag("array", typed)
97 case time.Time:
98 return testgenTag("datetime", orig.Format("2006-01-02T15:04:05Z"))
99 case bool:
100 return testgenTag("bool", fmt.Sprintf("%v", orig))
101 case int64:
102 return testgenTag("integer", fmt.Sprintf("%d", orig))
103 case float64:
104 return testgenTag("float", fmt.Sprintf("%v", orig))
105 case string:
106 return testgenTag("string", orig)
107 }
108
109 panic(fmt.Sprintf("Unknown type: %T", tomlData))
110 }
111
112 func testgenTag(typeName string, data interface{}) map[string]interface{} {
113 return map[string]interface{}{
114 "type": typeName,
115 "value": data,
116 }
117 }
118
View as plain text