1package pgs
2
3import (
4	"errors"
5	"testing"
6
7	"github.com/stretchr/testify/assert"
8)
9
10func TestPrefixContext_Log(t *testing.T) {
11	t.Parallel()
12
13	l := newMockLogger()
14	c := initPrefixContext(nil, &rootDebugger{l: l}, "foo")
15
16	c.Log("bar")
17	assert.Equal(t, "[foo] bar\n", l.buf.String())
18}
19
20func TestPrefixContext_Logf(t *testing.T) {
21	t.Parallel()
22
23	l := newMockLogger()
24	c := initPrefixContext(nil, &rootDebugger{l: l}, "foo")
25
26	c.Logf("bar %s", "baz")
27	assert.Equal(t, "[foo] bar baz\n", l.buf.String())
28}
29
30func TestPrefixContext_Debug(t *testing.T) {
31	t.Parallel()
32
33	l := newMockLogger()
34	c := initPrefixContext(nil, &rootDebugger{l: l, logDebugs: true}, "foo")
35
36	c.Debug("bar")
37	assert.Equal(t, "[foo] bar\n", l.buf.String())
38}
39
40func TestPrefixContext_Debugf(t *testing.T) {
41	t.Parallel()
42
43	l := newMockLogger()
44	c := initPrefixContext(nil, &rootDebugger{l: l, logDebugs: true}, "foo")
45
46	c.Debugf("bar %s", "baz")
47	assert.Equal(t, "[foo] bar baz\n", l.buf.String())
48}
49
50func TestPrefixContext_Fail(t *testing.T) {
51	t.Parallel()
52
53	d := InitMockDebugger()
54	c := initPrefixContext(nil, d, "foo")
55
56	c.Fail("bar")
57	assert.True(t, d.Failed())
58}
59
60func TestPrefixContext_Failf(t *testing.T) {
61	t.Parallel()
62
63	d := InitMockDebugger()
64	c := initPrefixContext(nil, d, "foo")
65
66	c.Failf("bar %s", "baz")
67	assert.True(t, d.Failed())
68}
69
70func TestPrefixContext_CheckErr(t *testing.T) {
71	t.Parallel()
72
73	d := InitMockDebugger()
74	c := initPrefixContext(nil, d, "foo")
75
76	c.CheckErr(nil)
77	assert.False(t, d.Failed())
78	err := errors.New("bar")
79	c.CheckErr(err)
80	assert.True(t, d.Exited())
81	assert.Equal(t, d.Err(), err)
82}
83
84func TestPrefixContext_Assert(t *testing.T) {
85	t.Parallel()
86
87	d := InitMockDebugger()
88	c := initPrefixContext(nil, d, "foo")
89
90	c.Assert(true)
91	assert.False(t, d.Failed())
92	c.Assert(false)
93	assert.True(t, d.Failed())
94}
95
96func TestPrefixContext_OutputPath(t *testing.T) {
97	t.Parallel()
98
99	d := Context(InitMockDebugger(), Parameters{}, "foo/bar")
100	c := initPrefixContext(d, InitMockDebugger(), "")
101	assert.Equal(t, c.OutputPath(), d.OutputPath())
102}
103
104func TestPrefixContext_PushPop(t *testing.T) {
105	t.Parallel()
106
107	r := Context(InitMockDebugger(), Parameters{}, "foo/bar")
108	p := initPrefixContext(r, InitMockDebugger(), "baz")
109
110	c := p.Push("fizz")
111	assert.IsType(t, prefixContext{}, c)
112	assert.IsType(t, rootContext{}, c.Pop().Pop())
113}
114
115func TestPrefixContext_PushPopDir(t *testing.T) {
116	t.Parallel()
117
118	r := Context(InitMockDebugger(), Parameters{}, "foo/bar")
119	p := initPrefixContext(r, InitMockDebugger(), "fizz")
120	c := p.PushDir("baz")
121
122	assert.Equal(t, "foo/bar/baz", c.OutputPath())
123	assert.Equal(t, "foo/bar", c.Push("buzz").PopDir().OutputPath())
124}
125
126func TestPrefixContext_Parameters(t *testing.T) {
127	t.Parallel()
128
129	p := Parameters{"foo": "bar"}
130	r := Context(InitMockDebugger(), p, ".")
131	c := r.Push("foo")
132
133	assert.Equal(t, p, c.Parameters())
134}
135
136func TestDirContext_OutputPath(t *testing.T) {
137	t.Parallel()
138
139	r := Context(InitMockDebugger(), Parameters{}, "foo/bar")
140	d := initDirContext(r, InitMockDebugger(), "baz")
141	assert.Equal(t, "foo/bar/baz", d.OutputPath())
142}
143
144func TestDirContext_Push(t *testing.T) {
145	t.Parallel()
146
147	r := Context(InitMockDebugger(), Parameters{}, "foo/bar")
148	d := initDirContext(r, InitMockDebugger(), "baz")
149	c := d.Push("fizz")
150
151	assert.Equal(t, d.OutputPath(), c.OutputPath())
152	assert.IsType(t, prefixContext{}, c)
153}
154
155func TestDirContext_PushPopDir(t *testing.T) {
156	t.Parallel()
157
158	r := Context(InitMockDebugger(), Parameters{}, "foo")
159	d := initDirContext(r, InitMockDebugger(), "bar")
160	c := d.PushDir("baz")
161
162	assert.Equal(t, "foo/bar/baz", c.OutputPath())
163	c = c.PopDir()
164	assert.Equal(t, "foo/bar", c.OutputPath())
165	c = c.PopDir()
166	assert.Equal(t, "foo", c.OutputPath())
167}
168
169func TestRootContext_OutputPath(t *testing.T) {
170	t.Parallel()
171
172	r := Context(InitMockDebugger(), Parameters{}, "foo")
173	assert.Equal(t, "foo", r.OutputPath())
174}
175
176func TestRootContext_PushPop(t *testing.T) {
177	t.Parallel()
178
179	d := InitMockDebugger()
180	r := Context(d, Parameters{}, "foo")
181
182	c := r.Push("bar")
183	assert.Equal(t, "foo", c.OutputPath())
184	c = c.Pop()
185
186	assert.False(t, d.Failed())
187	c.Pop()
188	assert.True(t, d.Failed())
189}
190
191func TestRootContext_PushPopDir(t *testing.T) {
192	t.Parallel()
193
194	r := Context(InitMockDebugger(), Parameters{}, "foo")
195	c := r.PushDir("bar")
196	assert.Equal(t, "foo/bar", c.OutputPath())
197
198	c = c.PopDir()
199	assert.Equal(t, "foo", c.OutputPath())
200
201	c = c.PopDir()
202	assert.Equal(t, "foo", c.OutputPath())
203}
204
205func TestRootContext_Parameters(t *testing.T) {
206	t.Parallel()
207
208	p := Parameters{"foo": "bar"}
209	r := Context(InitMockDebugger(), p, "foo")
210	assert.Equal(t, p, r.Parameters())
211}
212
213func TestRootContext_JoinPath(t *testing.T) {
214	t.Parallel()
215
216	r := Context(InitMockDebugger(), Parameters{}, "foo")
217	assert.Equal(t, "foo/bar", r.JoinPath("bar"))
218}
219
220func TestDirContext_JoinPath(t *testing.T) {
221	t.Parallel()
222
223	r := Context(InitMockDebugger(), Parameters{}, "foo")
224	c := r.PushDir("bar")
225
226	assert.Equal(t, "foo/bar/baz", c.JoinPath("baz"))
227}
228
229func TestPrefixContext_JoinPath(t *testing.T) {
230	t.Parallel()
231
232	r := Context(InitMockDebugger(), Parameters{}, "foo")
233	c := r.Push("baz")
234
235	assert.Equal(t, "foo/bar", c.JoinPath("bar"))
236}
237
238func TestPrefixContext_Exit(t *testing.T) {
239	t.Parallel()
240
241	d := InitMockDebugger()
242	r := Context(d, Parameters{}, "")
243	r.Exit(123)
244
245	assert.True(t, d.Exited())
246	assert.Equal(t, 123, d.ExitCode())
247}
248