grim/convey

Update state tests.
expand-list
2017-10-03, Eric Fritz
6144f314f439
Parents f099426f7d97
Children 1f100c6c13ec
Update state tests.
2 files changed, 94 insertions(+), 32 deletions(-)
  • +0 -12
    state/state.go
  • +94 -20
    state/state_test.go
    • --- a/state/state.go Tue Oct 03 21:50:34 2017 -0500
    +++ b/state/state.go Tue Oct 03 21:51:04 2017 -0500
    @@ -252,15 +252,3 @@
    return names
    }
    -
    -// getName returns the name of the variable `var` if the string is of the
    -// form $var or ${var}.
    -func getName(env string) string {
    - env = strings.TrimSpace(env)
    -
    - if strings.HasPrefix(env, "$") {
    - return strings.Trim(env[1:], "{}")
    - }
    -
    - return ""
    -}
    \ No newline at end of file
    --- a/state/state_test.go Tue Oct 03 21:50:34 2017 -0500
    +++ b/state/state_test.go Tue Oct 03 21:51:04 2017 -0500
    @@ -37,27 +37,101 @@
    })
    }
    -func (s *stateSuite) TestMap(t sweet.T) {
    - mapEnv := func(st *State, val string) []string {
    - mapped, err := st.MapSlice([]string{val}, st.Environment)
    - Expect(err).To(BeNil())
    - return mapped
    - }
    -
    +func (s *stateSuite) TestMapSlice(t sweet.T) {
    st1 := &State{}
    st1.Environment = []string{"FOO=BAR"}
    - Expect(mapEnv(st1, "$X")).To(Equal([]string{"$X"}))
    - Expect(mapEnv(st1, "$FOO")).To(Equal([]string{"BAR"}))
    + Expect(mapEnv(st1, "$X")).To(ConsistOf([]string{"$X"}))
    + Expect(mapEnv(st1, "$FOO")).To(ConsistOf([]string{"BAR"}))
    st2 := st1.WrapWithExpandableEnv([]string{"X=A;B;C"}, []string{"X"}, ";")
    - Expect(mapEnv(st2, "$X")).To(Equal([]string{"A", "B", "C"}))
    - Expect(mapEnv(st2, "$FOO")).To(Equal([]string{"BAR"}))
    + Expect(mapEnv(st2, "$X")).To(ConsistOf([]string{"A", "B", "C"}))
    + Expect(mapEnv(st2, "$FOO")).To(ConsistOf([]string{"BAR"}))
    st3 := st2.WrapWithExpandableEnv([]string{"BAR=B;A;R::B;A;Z", "FOO=SAME"}, []string{"BAR"}, "::")
    - Expect(mapEnv(st3, "$X")).To(Equal([]string{"A", "B", "C"}))
    - Expect(mapEnv(st3, "$FOO")).To(Equal([]string{"BAR"}))
    - Expect(mapEnv(st3, "$BAR")).To(Equal([]string{"B;A;R", "B;A;Z"}))
    + Expect(mapEnv(st3, "$X")).To(ConsistOf([]string{"A", "B", "C"}))
    + Expect(mapEnv(st3, "$FOO")).To(ConsistOf([]string{"BAR"}))
    + Expect(mapEnv(st3, "$BAR")).To(ConsistOf([]string{"B;A;R", "B;A;Z"}))
    +}
    +
    +func (s *stateSuite) TestMapSliceComplex(t sweet.T) {
    + st := &State{}
    + st.Environment = []string{"FOO=BAR"}
    + st = st.WrapWithExpandableEnv([]string{"X=A;B;C", "Y=D;E;F"}, []string{"X", "Y"}, ";")
    +
    + // No expansion
    + Expect(mapEnv(st, "BONK")).To(ConsistOf([]string{"BONK"}))
    + Expect(mapEnv(st, "$FOO")).To(ConsistOf([]string{"BAR"}))
    +
    + // Simple
    + Expect(mapEnv(st, "$X")).To(ConsistOf([]string{"A", "B", "C"}))
    + Expect(mapEnv(st, "$Y")).To(ConsistOf([]string{"D", "E", "F"}))
    +
    + // Templated
    + Expect(mapEnv(st, "x${X}x")).To(ConsistOf([]string{"xAx", "xBx", "xCx"}))
    + Expect(mapEnv(st, "x${Y}x")).To(ConsistOf([]string{"xDx", "xEx", "xFx"}))
    +
    + // Cartesian product
    + Expect(mapEnv(st, "$X/$Y")).To(ConsistOf([]string{
    + "A/D", "A/E", "A/F",
    + "B/D", "B/E", "B/F",
    + "C/D", "C/E", "C/F",
    + }))
    +}
    +
    +func (s *stateSuite) TestMapSliceIterative(t sweet.T) {
    + st := &State{}
    + st.Environment = []string{"FOO=BAR"}
    + st = st.WrapWithExpandableEnv([]string{"X=A;x$Y", "Y=B;y$Z", "Z=C;D;E"}, []string{"X", "Y", "Z"}, ";")
    +
    + Expect(mapEnv(st, "$X")).To(ConsistOf([]string{"A", "xB", "xyC", "xyD", "xyE"}))
    +}
    +
    +func (s *stateSuite) TestMapSliceIndirect(t sweet.T) {
    + st := &State{}
    + st.Environment = []string{"FOO=BAR"}
    + st = st.WrapWithExpandableEnv([]string{"X=$Y", "Y=A;$Z;C", "Z=B;$W", "W=D"}, []string{"X", "Y", "Z"}, ";")
    +
    + Expect(mapEnv(st, "$X")).To(ConsistOf([]string{"A", "B", "C", "D"}))
    +}
    +
    +func (s *stateSuite) TestMapSliceRecursive(t sweet.T) {
    + st := &State{}
    + st.Environment = []string{"FOO=BAR"}
    + st = st.WrapWithExpandableEnv([]string{"X=A;x$Y", "Y=B;y$Z", "Z=C;D;$X"}, []string{"X", "Y", "Z"}, ";")
    +
    + _, err := st.MapSlice([]string{"$X"}, st.Environment)
    + Expect(err).NotTo(BeNil())
    + Expect(err.Error()).To(ContainSubstring("hit limit"))
    +}
    +
    +func (e *stateSuite) TestGetNames(t sweet.T) {
    + names := getNames("foo $bar ${baz} ${bar} $bonk_quux honk")
    + Expect(names).To(HaveLen(4))
    + Expect(names).To(ConsistOf([]string{"bar", "baz", "bar", "bonk_quux"}))
    +}
    +
    +func (e *stateSuite) TestProduct(t sweet.T) {
    + p := product(map[string][]string{
    + "a": []string{"1", "2", "3"},
    + "b": []string{"4", "5"},
    + "c": []string{"6", "7"},
    + })
    +
    + Expect(p).To(ConsistOf([]map[string]string{
    + map[string]string{"a": "1", "b": "4", "c": "6"},
    + map[string]string{"a": "1", "b": "4", "c": "7"},
    + map[string]string{"a": "1", "b": "5", "c": "6"},
    + map[string]string{"a": "1", "b": "5", "c": "7"},
    + map[string]string{"a": "2", "b": "4", "c": "6"},
    + map[string]string{"a": "2", "b": "4", "c": "7"},
    + map[string]string{"a": "2", "b": "5", "c": "6"},
    + map[string]string{"a": "2", "b": "5", "c": "7"},
    + map[string]string{"a": "3", "b": "4", "c": "6"},
    + map[string]string{"a": "3", "b": "4", "c": "7"},
    + map[string]string{"a": "3", "b": "5", "c": "6"},
    + map[string]string{"a": "3", "b": "5", "c": "7"},
    + }))
    }
    func (s *stateSuite) TestWrapParent(t sweet.T) {
    @@ -80,12 +154,6 @@
    Expect(st2.Environment).To(ConsistOf([]string{"FOO=BAR", "BAR=BAZ", "BAZ=BONK"}))
    }
    -func (s *stateSuite) TestGetName(t sweet.T) {
    - Expect(getName("foo")).To(Equal(""))
    - Expect(getName("$FOO")).To(Equal("FOO"))
    - Expect(getName("${FOO}")).To(Equal("FOO"))
    -}
    -
    func (s *stateSuite) TestDetached(t sweet.T) {
    st1 := New()
    Expect(st1.GetDetached()).To(BeEmpty())
    @@ -103,3 +171,9 @@
    Expect(st1.GetDetached()).To(ConsistOf([]string{"foo", "bar"}))
    }
    +
    +func mapEnv(st *State, val string) []string {
    + mapped, err := st.MapSlice([]string{val}, st.Environment)
    + Expect(err).To(BeNil())
    + return mapped
    +}