grim/convey

Revert state test.
expand-list
2017-10-03, Eric Fritz
06eb1c85a2b5
Parents a495ad4dc08f
Children f099426f7d97
Revert state test.
1 files changed, 20 insertions(+), 94 deletions(-)
  • +20 -94
    state/state_test.go
    • --- a/state/state_test.go Tue Oct 03 21:46:20 2017 -0500
    +++ b/state/state_test.go Tue Oct 03 21:49:51 2017 -0500
    @@ -37,101 +37,27 @@
    })
    }
    -func (s *stateSuite) TestMapSlice(t sweet.T) {
    +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
    + }
    +
    st1 := &State{}
    st1.Environment = []string{"FOO=BAR"}
    - Expect(mapEnv(st1, "$X")).To(ConsistOf([]string{"$X"}))
    - Expect(mapEnv(st1, "$FOO")).To(ConsistOf([]string{"BAR"}))
    + Expect(mapEnv(st1, "$X")).To(Equal([]string{"$X"}))
    + Expect(mapEnv(st1, "$FOO")).To(Equal([]string{"BAR"}))
    st2 := st1.WrapWithExpandableEnv([]string{"X=A;B;C"}, []string{"X"}, ";")
    - Expect(mapEnv(st2, "$X")).To(ConsistOf([]string{"A", "B", "C"}))
    - Expect(mapEnv(st2, "$FOO")).To(ConsistOf([]string{"BAR"}))
    + Expect(mapEnv(st2, "$X")).To(Equal([]string{"A", "B", "C"}))
    + Expect(mapEnv(st2, "$FOO")).To(Equal([]string{"BAR"}))
    st3 := st2.WrapWithExpandableEnv([]string{"BAR=B;A;R::B;A;Z", "FOO=SAME"}, []string{"BAR"}, "::")
    - 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"},
    - }))
    + 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"}))
    }
    func (s *stateSuite) TestWrapParent(t sweet.T) {
    @@ -154,6 +80,12 @@
    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())
    @@ -171,9 +103,3 @@
    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
    -}