-
Notifications
You must be signed in to change notification settings - Fork 3
/
implementation_test.go
136 lines (123 loc) · 3.21 KB
/
implementation_test.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
package flatpack
import (
"reflect"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
type simple struct {
Foo string
Bar []string
Baz struct {
Foo string
Bar int
Baz float64
}
Quux []int
}
type pointery struct {
Foo struct {
Foo string
}
Bar *struct {
Foo string
}
Baz []*int
}
// Test that we avoid a new panic introduced in go 1.5:
// reflect.Value.Interface: cannot return value obtained from unexported field or method
type badEmbedding struct {
simple
}
var _ = Describe("implementation", func() {
Describe(".assign()", func() {
It("panics over unsupported types", func() {
it := implementation{stubEnvironment(map[string]string{})}
unsupported := reflect.ValueOf(make(chan int))
Expect(func() {
it.assign(unsupported, "", Key{})
}).To(Panic())
})
})
Describe(".Unmarshal()", func() {
It("handles strings and numbers", func() {
fx := simple{}
env := map[string]string{
"FOO": "foo",
"BAZ_FOO": "baz foo",
"BAZ_BAR": "42",
"BAZ_BAZ": "3.14159",
}
it := implementation{stubEnvironment(env)}
err := it.Unmarshal(&fx)
Expect(err).To(Succeed())
Expect(fx.Foo).To(Equal("foo"))
Expect(fx.Baz.Foo).To(Equal("baz foo"))
Expect(fx.Baz.Bar).To(Equal(42))
Expect(fx.Baz.Baz).To(Equal(3.14159))
})
It("handles slices", func() {
fx := simple{}
env := map[string]string{
"BAR": `["foo", "bar"]`,
"QUUX": `[1,2,3]`,
}
it := implementation{stubEnvironment(env)}
err := it.Unmarshal(&fx)
Expect(err).To(Succeed())
Expect(fx.Bar).To(Equal([]string{"foo", "bar"}))
Expect(fx.Quux).To(Equal([]int{1, 2, 3}))
})
It("allocates pointers when needed", func() {
fx := pointery{}
env := map[string]string{
"FOO_FOO": "foo foo",
}
it := implementation{stubEnvironment(env)}
err := it.Unmarshal(&fx)
Expect(err).To(Succeed())
Expect(fx.Bar).To(BeNil())
env = map[string]string{
"FOO_FOO": "foo foo",
"BAR_FOO": "bar foo",
"BAZ": `[1,2,3]`,
}
it = implementation{stubEnvironment(env)}
err = it.Unmarshal(&fx)
Expect(err).To(Succeed())
Expect(fx.Bar).NotTo(BeNil())
one, two, three := 1, 2, 3
Expect(fx.Baz).To(Equal([]*int{&one, &two, &three}))
})
Context("error reporting", func() {
It("complains about malformed JSON", func() {
fx := simple{}
env := map[string]string{
"FOO": "foo",
"BAR": `["not-a-valid-json-array`,
"BAZ_FOO": "baz foo",
}
it := implementation{stubEnvironment(env)}
err := it.Unmarshal(&fx)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(MatchRegexp("unexpected end of JSON input"))
})
It("complains about reflection without panicking", func() {
it := implementation{stubEnvironment(map[string]string{})}
s := badEmbedding{}
err := it.Unmarshal(&s)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(MatchRegexp("reflection error"))
})
It("complains about malformed integers", func() {
env := map[string]string{
"BAZ_BAR": "not-a-number",
}
it := implementation{stubEnvironment(env)}
s := simple{}
err := it.Unmarshal(&s)
Expect(err).To(HaveOccurred())
Expect(err.Error()).To(MatchRegexp("malformed value"))
})
})
})
})