HGKeeper

// Convey

// This program is free software: you can redistribute it and/or modify

// it under the terms of the GNU General Public License as published by

// the Free Software Foundation, either version 3 of the License, or

// (at your option) any later version.

// This program is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License

// along with this program. If not, see <http://www.gnu.org/licenses/>.

package state

import (

"testing"

"github.com/aphistic/sweet"

junit "github.com/aphistic/sweet-junit"

. "github.com/onsi/gomega"

)

type stateSuite struct{}

func TestMain(m *testing.M) {

RegisterFailHandler(sweet.GomegaFail)

sweet.Run(m, func(s *sweet.S) {

s.RegisterPlugin(junit.NewPlugin())

s.AddSuite(&stateSuite{})

})

}

func (s *stateSuite) TestWrappedEnvironment(t sweet.T) {

st1 := New()

st1.MergeEnv([]string{"Y=0"})

st2 := st1.WrapWithExpandableEnv([]string{"X=1", "Y=1"}, []string{}, ";")

st3 := st2.WrapWithExpandableEnv([]string{"X=2", "Y=2"}, []string{}, ";")

st4 := st3.WrapWithExpandableEnv([]string{"X=3", "Y=3", "Z=3"}, []string{}, ";")

// Things in the "base" env are not overridden, but things

// that are wrapped take the highest precedence

Expect(st4.GetEnv()).To(ConsistOf([]string{"X=1", "Y=0", "Z=3"}))

}

func (s *stateSuite) TestMapSlice(t sweet.T) {

st1 := New()

st1.MergeEnv([]string{"FOO=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(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(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 := New()

st.MergeEnv([]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 := New()

st.MergeEnv([]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 := New()

st.MergeEnv([]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 := New()

st.MergeEnv([]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.GetEnv())

Expect(err).NotTo(BeNil())

Expect(err.Error()).To(ContainSubstring("hit limit"))

}

func (s *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 (s *stateSuite) TestProduct(t sweet.T) {

p := product(map[string][]string{

"a": {"1", "2", "3"},

"b": {"4", "5"},

"c": {"6", "7"},

})

Expect(p).To(ConsistOf([]map[string]string{

{"a": "1", "b": "4", "c": "6"},

{"a": "1", "b": "4", "c": "7"},

{"a": "1", "b": "5", "c": "6"},

{"a": "1", "b": "5", "c": "7"},

{"a": "2", "b": "4", "c": "6"},

{"a": "2", "b": "4", "c": "7"},

{"a": "2", "b": "5", "c": "6"},

{"a": "2", "b": "5", "c": "7"},

{"a": "3", "b": "4", "c": "6"},

{"a": "3", "b": "4", "c": "7"},

{"a": "3", "b": "5", "c": "6"},

{"a": "3", "b": "5", "c": "7"},

}))

}

func (s *stateSuite) TestWrapParent(t sweet.T) {

st1 := New()

st1.WrapWithExpandableEnv(nil, nil, "")

Expect(st1.parent).To(BeNil())

st2 := st1.WrapWithExpandableEnv(nil, nil, "")

Expect(st2.parent).To(BeIdenticalTo(st1))

}

func (s *stateSuite) TestWrapWithExpandableEnvMap(t sweet.T) {

st1 := New()

st1.MergeEnv([]string{"FOO=BAR", "BAR=BAZ"})

Expect(st1.GetEnv()).To(HaveLen(2))

Expect(st1.GetEnv()).To(ConsistOf([]string{"FOO=BAR", "BAR=BAZ"}))

st2 := st1.WrapWithExpandableEnv([]string{"FOO=BONK", "BAZ=BONK"}, nil, "")

Expect(st2.GetEnv()).To(HaveLen(3))

Expect(st2.GetEnv()).To(ConsistOf([]string{"FOO=BAR", "BAR=BAZ", "BAZ=BONK"}))

}

func (s *stateSuite) TestRunning(t sweet.T) {

st1 := New()

Expect(st1.GetRunning()).To(BeEmpty())

st1.MarkRunning("foo")

Expect(st1.GetRunning()).To(HaveLen(1))

Expect(st1.GetRunning()).To(ConsistOf([]string{"foo"}))

st2 := st1.WrapWithExpandableEnv(nil, nil, "")

st2.MarkRunning("bar")

Expect(st2.GetRunning()).To(HaveLen(2))

Expect(st2.GetRunning()).To(ConsistOf([]string{"foo", "bar"}))

st2.UnmarkRunning("bar")

Expect(st2.GetRunning()).To(HaveLen(1))

Expect(st2.GetRunning()).To(ConsistOf([]string{"foo"}))

Expect(st1.GetRunning()).To(HaveLen(1))

Expect(st1.GetRunning()).To(ConsistOf([]string{"foo"}))

}

func (s *stateSuite) TestDetached(t sweet.T) {

st1 := New()

Expect(st1.GetDetached()).To(BeEmpty())

st1.MarkDetached("foo")

Expect(st1.GetDetached()).To(HaveLen(1))

Expect(st1.GetDetached()).To(ConsistOf([]string{"foo"}))

st2 := st1.WrapWithExpandableEnv(nil, nil, "")

st2.MarkDetached("bar")

Expect(st2.GetDetached()).To(HaveLen(2))

Expect(st2.GetDetached()).To(ConsistOf([]string{"foo", "bar"}))

Expect(st1.GetDetached()).To(HaveLen(2))

Expect(st1.GetDetached()).To(ConsistOf([]string{"foo", "bar"}))

}

func mapEnv(st *State, val string) []string {

mapped, err := st.MapSlice([]string{val}, st.GetEnv())

Expect(err).To(BeNil())

return mapped

}

grim/convey