Skip to content

Commit 7ba773a

Browse files
Rhys Koedijkrhyskoedijk
Rhys Koedijk
and
rhyskoedijk
authored
MudStepper directional logic support for "PreventStepChange" (#92)
* Stepper.PreventStepChange now passes a "direction" argument to allow conditional forward/backward logic * Fix step change direction logic * Add unit tests and fix step change direction logic (again) Co-authored-by: Rhys Koedijk <[email protected]>
1 parent 89adbc4 commit 7ba773a

File tree

5 files changed

+354
-13
lines changed

5 files changed

+354
-13
lines changed

‎CodeBeam.MudExtensions.UnitTest/Components/StepperTests.cs‎

Lines changed: 300 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -8,6 +8,7 @@
88
using FluentAssertions;
99
using MudBlazor;
1010
using MudExtensions;
11+
using MudExtensions.Enums;
1112

1213
namespace CodeBeam.MudExtensions.UnitTest.Components
1314
{
@@ -20,5 +21,304 @@ public void StepperRenderTest()
2021
var comp = Context.RenderComponent<MudStepper>();
2122
comp.Instance.Steps.Count.Should().Be(0);
2223
}
24+
25+
[Test]
26+
public async Task StepperPreventStepChangeDirectionIsForwardWhenCompletingStepOneOfOneTest()
27+
{
28+
// Arrange
29+
var lastStepChangeDirection = StepChangeDirection.None;
30+
var stepper = Context.RenderComponent<MudStepper>(
31+
ComponentParameterFactory.Parameter(
32+
nameof(MudStepper.PreventStepChange),
33+
new Func<StepChangeDirection, bool>((direction) =>
34+
{
35+
lastStepChangeDirection = direction;
36+
return false;
37+
})
38+
)
39+
);
40+
var step0 = Context.RenderComponent<MudStep>(
41+
ComponentParameterFactory.CascadingValue(stepper.Instance)
42+
);
43+
44+
// Act
45+
await stepper.Instance.CompleteStep(0, moveToNextStep: true);
46+
47+
// Assert
48+
lastStepChangeDirection.Should().Be(StepChangeDirection.Forward);
49+
}
50+
51+
[Test]
52+
public async Task StepperPreventStepChangeDirectionIsForwardWhenSkippingStepOneOfOneTest()
53+
{
54+
// Arrange
55+
var lastStepChangeDirection = StepChangeDirection.None;
56+
var stepper = Context.RenderComponent<MudStepper>(
57+
ComponentParameterFactory.Parameter(
58+
nameof(MudStepper.PreventStepChange),
59+
new Func<StepChangeDirection, bool>((direction) =>
60+
{
61+
lastStepChangeDirection = direction;
62+
return false;
63+
})
64+
)
65+
);
66+
var step0 = Context.RenderComponent<MudStep>(
67+
ComponentParameterFactory.CascadingValue(stepper.Instance)
68+
);
69+
70+
// Act
71+
await stepper.Instance.SkipStep(0, moveToNextStep: true);
72+
73+
// Assert
74+
lastStepChangeDirection.Should().Be(StepChangeDirection.Forward);
75+
}
76+
77+
[Test]
78+
public async Task StepperPreventStepChangeDirectionIsForwardWhenChangingFromStepOneToStepTwoTest()
79+
{
80+
// Arrange
81+
var lastStepChangeDirection = StepChangeDirection.None;
82+
var stepper = Context.RenderComponent<MudStepper>(
83+
ComponentParameterFactory.Parameter(
84+
nameof(MudStepper.PreventStepChange),
85+
new Func<StepChangeDirection, bool>((direction) =>
86+
{
87+
lastStepChangeDirection = direction;
88+
return false;
89+
})
90+
)
91+
);
92+
var step0 = Context.RenderComponent<MudStep>(
93+
ComponentParameterFactory.CascadingValue(stepper.Instance)
94+
);
95+
var step1 = Context.RenderComponent<MudStep>(
96+
ComponentParameterFactory.CascadingValue(stepper.Instance)
97+
);
98+
await stepper.Instance.SetActiveIndex(step0.Instance);
99+
100+
// Act
101+
await stepper.Instance.SetActiveIndex(1); // go to next step
102+
103+
// Assert
104+
lastStepChangeDirection.Should().Be(StepChangeDirection.Forward);
105+
}
106+
107+
[Test]
108+
public async Task StepperPreventStepChangeDirectionIsBackwardWhenChangingFromStepTwoToStepOneTest()
109+
{
110+
// Arrange
111+
var lastStepChangeDirection = StepChangeDirection.None;
112+
var stepper = Context.RenderComponent<MudStepper>(
113+
ComponentParameterFactory.Parameter(
114+
nameof(MudStepper.PreventStepChange),
115+
new Func<StepChangeDirection, bool>((direction) =>
116+
{
117+
lastStepChangeDirection = direction;
118+
return false;
119+
})
120+
)
121+
);
122+
var step0 = Context.RenderComponent<MudStep>(
123+
ComponentParameterFactory.CascadingValue(stepper.Instance)
124+
);
125+
var step1 = Context.RenderComponent<MudStep>(
126+
ComponentParameterFactory.CascadingValue(stepper.Instance)
127+
);
128+
await stepper.Instance.SetActiveIndex(step1.Instance);
129+
130+
// Act
131+
await stepper.Instance.SetActiveIndex(-1); // go to previous step
132+
133+
// Assert
134+
lastStepChangeDirection.Should().Be(StepChangeDirection.Backward);
135+
}
136+
137+
[Test]
138+
public async Task StepperPreventStepChangeDirectionIsNoneWhenChangingToTheSameStepTest()
139+
{
140+
// Arrange
141+
var lastStepChangeDirection = StepChangeDirection.None;
142+
var stepper = Context.RenderComponent<MudStepper>(
143+
ComponentParameterFactory.Parameter(
144+
nameof(MudStepper.PreventStepChange),
145+
new Func<StepChangeDirection, bool>((direction) =>
146+
{
147+
lastStepChangeDirection = direction;
148+
return false;
149+
})
150+
)
151+
);
152+
var step0 = Context.RenderComponent<MudStep>(
153+
ComponentParameterFactory.CascadingValue(stepper.Instance)
154+
);
155+
await stepper.Instance.SetActiveIndex(step0.Instance);
156+
157+
// Act
158+
await stepper.Instance.SetActiveIndex(0); // go to same step
159+
160+
// Assert
161+
lastStepChangeDirection.Should().Be(StepChangeDirection.None);
162+
}
163+
164+
[Test]
165+
public async Task StepperPreventStepChangeIsInvokedWhenCompletingActiveStepTest()
166+
{
167+
// Arrange
168+
var preventStepChangeWasInvoked = false;
169+
var stepper = Context.RenderComponent<MudStepper>(
170+
ComponentParameterFactory.Parameter(
171+
nameof(MudStepper.PreventStepChange),
172+
new Func<StepChangeDirection, bool>((direction) =>
173+
{
174+
preventStepChangeWasInvoked = true;
175+
return false;
176+
})
177+
)
178+
);
179+
var step0 = Context.RenderComponent<MudStep>(
180+
ComponentParameterFactory.CascadingValue(stepper.Instance)
181+
);
182+
var step1 = Context.RenderComponent<MudStep>(
183+
ComponentParameterFactory.CascadingValue(stepper.Instance)
184+
);
185+
await stepper.Instance.SetActiveIndex(step0.Instance);
186+
187+
// Act
188+
await stepper.Instance.CompleteStep(stepper.Instance.Steps.IndexOf(step0.Instance));
189+
190+
// Assert
191+
preventStepChangeWasInvoked.Should().Be(true);
192+
}
193+
194+
[Test]
195+
public async Task StepperPreventStepChangeIsInvokedWhenSkippingActiveStepTest()
196+
{
197+
// Arrange
198+
var preventStepChangeWasInvoked = false;
199+
var stepper = Context.RenderComponent<MudStepper>(
200+
ComponentParameterFactory.Parameter(
201+
nameof(MudStepper.PreventStepChange),
202+
new Func<StepChangeDirection, bool>((direction) =>
203+
{
204+
preventStepChangeWasInvoked = true;
205+
return false;
206+
})
207+
)
208+
);
209+
var step0 = Context.RenderComponent<MudStep>(
210+
ComponentParameterFactory.CascadingValue(stepper.Instance)
211+
);
212+
var step1 = Context.RenderComponent<MudStep>(
213+
ComponentParameterFactory.CascadingValue(stepper.Instance)
214+
);
215+
await stepper.Instance.SetActiveIndex(step0.Instance);
216+
217+
// Act
218+
await stepper.Instance.SkipStep(stepper.Instance.Steps.IndexOf(step0.Instance));
219+
220+
// Assert
221+
preventStepChangeWasInvoked.Should().Be(true);
222+
}
223+
224+
[Test]
225+
public async Task StepperPreventStepChangeIsNotInvokedWhenCompletingNonActiveStepTest()
226+
{
227+
// Arrange
228+
var preventStepChangeWasInvoked = false;
229+
var stepper = Context.RenderComponent<MudStepper>(
230+
ComponentParameterFactory.Parameter(
231+
nameof(MudStepper.PreventStepChange),
232+
new Func<StepChangeDirection, bool>((direction) =>
233+
{
234+
preventStepChangeWasInvoked = true;
235+
return false;
236+
})
237+
)
238+
);
239+
var step0 = Context.RenderComponent<MudStep>(
240+
ComponentParameterFactory.CascadingValue(stepper.Instance)
241+
);
242+
var step1 = Context.RenderComponent<MudStep>(
243+
ComponentParameterFactory.CascadingValue(stepper.Instance)
244+
);
245+
await stepper.Instance.SetActiveIndex(step0.Instance);
246+
247+
// Act
248+
await stepper.Instance.CompleteStep(stepper.Instance.Steps.IndexOf(step1.Instance));
249+
250+
// Assert
251+
preventStepChangeWasInvoked.Should().Be(false);
252+
}
253+
254+
[Test]
255+
public async Task StepperPreventStepChangeIsNotInvokedWhenSkippingNonActiveStepTest()
256+
{
257+
// Arrange
258+
var preventStepChangeWasInvoked = false;
259+
var stepper = Context.RenderComponent<MudStepper>(
260+
ComponentParameterFactory.Parameter(
261+
nameof(MudStepper.PreventStepChange),
262+
new Func<StepChangeDirection, bool>((direction) =>
263+
{
264+
preventStepChangeWasInvoked = true;
265+
return false;
266+
})
267+
)
268+
);
269+
var step0 = Context.RenderComponent<MudStep>(
270+
ComponentParameterFactory.CascadingValue(stepper.Instance)
271+
);
272+
var step1 = Context.RenderComponent<MudStep>(
273+
ComponentParameterFactory.CascadingValue(stepper.Instance)
274+
);
275+
await stepper.Instance.SetActiveIndex(step0.Instance);
276+
277+
// Act
278+
await stepper.Instance.SkipStep(stepper.Instance.Steps.IndexOf(step1.Instance));
279+
280+
// Assert
281+
preventStepChangeWasInvoked.Should().Be(false);
282+
}
283+
284+
[Test]
285+
public async Task StepperActiveIndexIsNotChangedWhenCompletingNonActiveStepTest()
286+
{
287+
// Arrange
288+
var stepper = Context.RenderComponent<MudStepper>();
289+
var step0 = Context.RenderComponent<MudStep>(
290+
ComponentParameterFactory.CascadingValue(stepper.Instance)
291+
);
292+
var step1 = Context.RenderComponent<MudStep>(
293+
ComponentParameterFactory.CascadingValue(stepper.Instance)
294+
);
295+
await stepper.Instance.SetActiveIndex(stepper.Instance.Steps.IndexOf(step0.Instance));
296+
297+
// Act
298+
await stepper.Instance.CompleteStep(stepper.Instance.Steps.IndexOf(step1.Instance), moveToNextStep: true);
299+
300+
// Assert
301+
stepper.Instance.ActiveIndex.Should().Be(stepper.Instance.Steps.IndexOf(step0.Instance));
302+
}
303+
304+
[Test]
305+
public async Task StepperActiveIndexIsNotChangedWhenSkippingNonActiveStepTest()
306+
{
307+
// Arrange
308+
var stepper = Context.RenderComponent<MudStepper>();
309+
var step0 = Context.RenderComponent<MudStep>(
310+
ComponentParameterFactory.CascadingValue(stepper.Instance)
311+
);
312+
var step1 = Context.RenderComponent<MudStep>(
313+
ComponentParameterFactory.CascadingValue(stepper.Instance)
314+
);
315+
await stepper.Instance.SetActiveIndex(stepper.Instance.Steps.IndexOf(step0.Instance));
316+
317+
// Act
318+
await stepper.Instance.SkipStep(stepper.Instance.Steps.IndexOf(step1.Instance), moveToNextStep: true);
319+
320+
// Assert
321+
stepper.Instance.ActiveIndex.Should().Be(stepper.Instance.Steps.IndexOf(step0.Instance));
322+
}
23323
}
24324
}

‎CodeBeam.MudExtensions/CodeBeam.MudExtensions.csproj‎

Lines changed: 7 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -48,7 +48,13 @@
4848
<Content Remove="compilerconfig.json" />
4949
<Content Remove="excubowebcompiler.json" />
5050
</ItemGroup>
51-
51+
52+
<ItemGroup>
53+
<AssemblyAttribute Include="System.Runtime.CompilerServices.InternalsVisibleTo">
54+
<_Parameter1>CodeBeam.MudExtensions.UnitTest</_Parameter1>
55+
</AssemblyAttribute>
56+
</ItemGroup>
57+
5258
<ItemGroup>
5359
<None Include="..\..\..\..\Desktop\MudBuilder\Mud_Secondary.png">
5460
<Pack>True</Pack>

0 commit comments

Comments
 (0)