From 3e94566e8cf8288954216617d4b4f60da935a8bd Mon Sep 17 00:00:00 2001 From: Julian Verdurmen <5808377+304NotModified@users.noreply.github.com> Date: Wed, 26 Feb 2025 10:44:15 +0100 Subject: [PATCH] Improve tests to improve migration to NSubstitute Remove LegacyStepArgumentTypeConverterExtensions Add ArgumentHelpers Removed dead test code Remove some unused vars in the tests Fixed some spelling in comments --- .../Reqnroll.RuntimeTests/ArgumentHelpers.cs | 12 +++ .../StepArgumentTransformationTests.cs | 15 ++-- .../StepArgumentTypeConverterTest.cs | 46 +++++++---- .../StepExecutionTestsWithConversions.cs | 79 +++---------------- ...pExecutionTestsWithConversionsForTables.cs | 36 +++------ 5 files changed, 77 insertions(+), 111 deletions(-) create mode 100644 Tests/Reqnroll.RuntimeTests/ArgumentHelpers.cs diff --git a/Tests/Reqnroll.RuntimeTests/ArgumentHelpers.cs b/Tests/Reqnroll.RuntimeTests/ArgumentHelpers.cs new file mode 100644 index 000000000..5aa43d409 --- /dev/null +++ b/Tests/Reqnroll.RuntimeTests/ArgumentHelpers.cs @@ -0,0 +1,12 @@ +using Moq; +using Reqnroll.Bindings.Reflection; + +namespace Reqnroll.RuntimeTests; + +internal static class ArgumentHelpers +{ + public static IBindingType IsBindingType() + { + return It.Is(bt => bt.TypeEquals(typeof(T))); + } +} diff --git a/Tests/Reqnroll.RuntimeTests/StepArgumentTransformationTests.cs b/Tests/Reqnroll.RuntimeTests/StepArgumentTransformationTests.cs index d971a1df2..139ac5739 100644 --- a/Tests/Reqnroll.RuntimeTests/StepArgumentTransformationTests.cs +++ b/Tests/Reqnroll.RuntimeTests/StepArgumentTransformationTests.cs @@ -1,3 +1,4 @@ +using System; using System.Collections.Generic; using System.Globalization; using System.Linq; @@ -84,6 +85,7 @@ public class StepArgumentTransformationTests private readonly Mock contextManagerStub = new Mock(); private readonly Mock methodBindingInvokerStub = new Mock(); private readonly List stepTransformations = new List(); + private readonly CultureInfo _enUSCulture = new CultureInfo("en-US", false); public StepArgumentTransformationTests() { @@ -179,7 +181,8 @@ public async Task StepArgumentTypeConverterShouldUseUserConverterForConversion() var stepArgumentTypeConverter = CreateStepArgumentTypeConverter(); - var result = await stepArgumentTypeConverter.ConvertAsync("user xyz", typeof(User), new CultureInfo("en-US", false)); + var runtimeBindingType = new RuntimeBindingType(typeof(User)); + var result = await stepArgumentTypeConverter.ConvertAsync("user xyz", runtimeBindingType, _enUSCulture); result.Should().Be(resultUser); } @@ -197,7 +200,8 @@ public async Task StepArgumentTypeConverterShouldUseAsyncUserConverterForConvers var stepArgumentTypeConverter = CreateStepArgumentTypeConverter(); - var result = await stepArgumentTypeConverter.ConvertAsync("user xyz", typeof(User), new CultureInfo("en-US", false)); + var runtimeBindingType = new RuntimeBindingType(typeof(User)); + var result = await stepArgumentTypeConverter.ConvertAsync("user xyz", runtimeBindingType, _enUSCulture); result.Should().Be(resultUser); } @@ -215,7 +219,8 @@ public async Task StepArgumentTypeConverterShouldUseAsyncValueTaskUserConverterF var stepArgumentTypeConverter = CreateStepArgumentTypeConverter(); - var result = await stepArgumentTypeConverter.ConvertAsync("user xyz", typeof(User), new CultureInfo("en-US", false)); + var typeToConvertTo = new RuntimeBindingType(typeof(User)); + var result = await stepArgumentTypeConverter.ConvertAsync("user xyz", typeToConvertTo, _enUSCulture); result.Should().Be(resultUser); } @@ -240,8 +245,8 @@ public async Task ShouldUseStepArgumentTransformationToConvertTable() var stepArgumentTypeConverter = CreateStepArgumentTypeConverter(); - - var result = await stepArgumentTypeConverter.ConvertAsync(table, typeof(IEnumerable), new CultureInfo("en-US", false)); + var typeToConvertTo = new RuntimeBindingType(typeof(IEnumerable)); + var result = await stepArgumentTypeConverter.ConvertAsync(table, typeToConvertTo, _enUSCulture); result.Should().NotBeNull(); result.Should().Be(resultUsers); diff --git a/Tests/Reqnroll.RuntimeTests/StepArgumentTypeConverterTest.cs b/Tests/Reqnroll.RuntimeTests/StepArgumentTypeConverterTest.cs index 57431a0bf..81074e6fe 100644 --- a/Tests/Reqnroll.RuntimeTests/StepArgumentTypeConverterTest.cs +++ b/Tests/Reqnroll.RuntimeTests/StepArgumentTypeConverterTest.cs @@ -35,28 +35,32 @@ public StepArgumentTypeConverterTests() [Fact] public async Task ShouldConvertStringToStringType() { - var result = await _stepArgumentTypeConverter.ConvertAsync("testValue", typeof(string), _enUSCulture); + var typeToConvertTo = new RuntimeBindingType(typeof(string)); + var result = await _stepArgumentTypeConverter.ConvertAsync("testValue", typeToConvertTo, _enUSCulture); result.Should().Be("testValue"); } [Fact] public async Task ShouldConvertStringToIntType() { - var result = await _stepArgumentTypeConverter.ConvertAsync("10", typeof(int), _enUSCulture); + var typeToConvertTo = new RuntimeBindingType(typeof(int)); + var result = await _stepArgumentTypeConverter.ConvertAsync("10", typeToConvertTo, _enUSCulture); result.Should().Be(10); } [Fact] public async Task ShouldConvertStringToDateType() { - var result = await _stepArgumentTypeConverter.ConvertAsync("2009/10/06", typeof(DateTime), _enUSCulture); + var typeToConvertTo = new RuntimeBindingType(typeof(DateTime)); + var result = await _stepArgumentTypeConverter.ConvertAsync("2009/10/06", typeToConvertTo, _enUSCulture); result.Should().Be(new DateTime(2009, 10, 06)); } [Fact] public async Task ShouldConvertStringToFloatType() { - var result = await _stepArgumentTypeConverter.ConvertAsync("10.01", typeof(float), _enUSCulture); + var typeToConvertTo = new RuntimeBindingType(typeof(float)); + var result = await _stepArgumentTypeConverter.ConvertAsync("10.01", typeToConvertTo, _enUSCulture); result.Should().Be(10.01f); } @@ -68,49 +72,56 @@ private enum TestEnumeration [Fact] public async Task ShouldConvertStringToEnumerationType() { - var result = await _stepArgumentTypeConverter.ConvertAsync("Value1", typeof(TestEnumeration), _enUSCulture); + var typeToConvertTo = new RuntimeBindingType(typeof(TestEnumeration)); + var result = await _stepArgumentTypeConverter.ConvertAsync("Value1", typeToConvertTo, _enUSCulture); result.Should().Be(TestEnumeration.Value1); } [Fact] public async Task ShouldConvertStringToEnumerationTypeWithDifferingCase() { - var result = await _stepArgumentTypeConverter.ConvertAsync("vALUE1", typeof(TestEnumeration), _enUSCulture); + var typeToConvertTo = new RuntimeBindingType(typeof(TestEnumeration)); + var result = await _stepArgumentTypeConverter.ConvertAsync("vALUE1", typeToConvertTo, _enUSCulture); result.Should().Be(TestEnumeration.Value1); } [Fact] public async Task ShouldConvertStringToEnumerationTypeWithWhitespace() { - var result = await _stepArgumentTypeConverter.ConvertAsync("Value 1", typeof(TestEnumeration), _enUSCulture); + var typeToConvertTo = new RuntimeBindingType(typeof(TestEnumeration)); + var result = await _stepArgumentTypeConverter.ConvertAsync("Value 1", typeToConvertTo, _enUSCulture); result.Should().Be(TestEnumeration.Value1); } [Fact] public async Task ShouldConvertGuidToGuidType() { - var result = await _stepArgumentTypeConverter.ConvertAsync("{EF338B79-FD29-488F-8CA7-39C67C2B8874}", typeof (Guid), _enUSCulture); + var typeToConvertTo = new RuntimeBindingType(typeof (Guid)); + var result = await _stepArgumentTypeConverter.ConvertAsync("{EF338B79-FD29-488F-8CA7-39C67C2B8874}", typeToConvertTo, _enUSCulture); result.Should().Be(new Guid("{EF338B79-FD29-488F-8CA7-39C67C2B8874}")); } [Fact] public async Task ShouldConvertNullableGuidToGuidType() { - var result = await _stepArgumentTypeConverter.ConvertAsync("{1081CFD1-F31F-420F-9360-40590ABEF887}", typeof(Guid?), _enUSCulture); + var typeToConvertTo = new RuntimeBindingType(typeof(Guid?)); + var result = await _stepArgumentTypeConverter.ConvertAsync("{1081CFD1-F31F-420F-9360-40590ABEF887}", typeToConvertTo, _enUSCulture); result.Should().Be(new Guid("{1081CFD1-F31F-420F-9360-40590ABEF887}")); } [Fact] public async Task ShouldConvertNullableGuidWithEmptyValueToNull() { - var result = await _stepArgumentTypeConverter.ConvertAsync("", typeof(Guid?), _enUSCulture); + var typeToConvertTo = new RuntimeBindingType(typeof(Guid?)); + var result = await _stepArgumentTypeConverter.ConvertAsync("", typeToConvertTo, _enUSCulture); result.Should().BeNull(); } [Fact] public async Task ShouldConvertLooseGuids() { - var result = await _stepArgumentTypeConverter.ConvertAsync("1", typeof (Guid), _enUSCulture); + var typeToConvertTo = new RuntimeBindingType(typeof (Guid)); + var result = await _stepArgumentTypeConverter.ConvertAsync("1", typeToConvertTo, _enUSCulture); result.Should().Be(new Guid("10000000-0000-0000-0000-000000000000")); } @@ -118,7 +129,8 @@ public async Task ShouldConvertLooseGuids() public async Task ShouldUseATypeConverterWhenAvailable() { var originalValue = new DateTimeOffset(2019, 7, 29, 0, 0, 0, TimeSpan.Zero); - var result = await _stepArgumentTypeConverter.ConvertAsync(originalValue, typeof (TestClass), _enUSCulture); + var typeToConvertTo = new RuntimeBindingType(typeof (TestClass)); + var result = await _stepArgumentTypeConverter.ConvertAsync(originalValue, typeToConvertTo, _enUSCulture); result.Should().BeOfType(typeof(TestClass)); result.As().Time.Should().Be(originalValue); } @@ -129,8 +141,9 @@ public async Task ShouldTraceWarningIfMultipleTransformationsFound() var method = typeof(TestClass).GetMethod(nameof(TestClass.StringToIntConverter)); _stepTransformations.Add(new StepArgumentTransformationBinding(@"\d+", new RuntimeBindingMethod(method))); _stepTransformations.Add(new StepArgumentTransformationBinding(@".*", new RuntimeBindingMethod(method))); - - await _stepArgumentTypeConverter.ConvertAsync("1", typeof(int), _enUSCulture); + + var typeToConvertTo = new RuntimeBindingType(typeof(int)); + await _stepArgumentTypeConverter.ConvertAsync("1", typeToConvertTo, _enUSCulture); _testTracer.Verify(c => c.TraceWarning(It.IsAny()), Times.Once); } @@ -142,8 +155,9 @@ public async Task ShouldNotTraceWarningIfTransformationsHaveDifferentOrder() _stepTransformations.Add(new StepArgumentTransformationBinding(@"\d+", new RuntimeBindingMethod(method))); _stepTransformations.Add(new StepArgumentTransformationBinding(@".*", new RuntimeBindingMethod(method), order: 10)); - - await _stepArgumentTypeConverter.ConvertAsync("1", typeof(int), _enUSCulture); + + var typeToConvertTo = new RuntimeBindingType(typeof(int)); + await _stepArgumentTypeConverter.ConvertAsync("1", typeToConvertTo, _enUSCulture); _testTracer.Verify(c => c.TraceWarning(It.IsAny()), Times.Never); } diff --git a/Tests/Reqnroll.RuntimeTests/StepExecutionTestsWithConversions.cs b/Tests/Reqnroll.RuntimeTests/StepExecutionTestsWithConversions.cs index 5a0383dd9..abcb86833 100644 --- a/Tests/Reqnroll.RuntimeTests/StepExecutionTestsWithConversions.cs +++ b/Tests/Reqnroll.RuntimeTests/StepExecutionTestsWithConversions.cs @@ -1,36 +1,12 @@ -using System; using System.Globalization; -using System.Linq.Expressions; using System.Threading.Tasks; using FluentAssertions; using Xunit; using Moq; -using Reqnroll.Bindings; using Reqnroll.Bindings.Reflection; namespace Reqnroll.RuntimeTests { - internal static class LegacyStepArgumentTypeConverterExtensions - { - public static async Task ConvertAsync(this IStepArgumentTypeConverter converter, object value, Type typeToConvertTo, CultureInfo cultureInfo) - { - return await converter.ConvertAsync(value, new RuntimeBindingType(typeToConvertTo), cultureInfo); - } - - public static Expression> GetCanConvertMethodFilter(object argument, Type type) - { - return c => c.CanConvert(argument, It.Is(bt => bt.TypeEquals(type)), It.IsAny()); - } - - public static Expression>> GetConvertAsyncMethodFilter(object argument, Type type) - { - return c => c.ConvertAsync(It.Is(s => s.Equals(argument)), It.Is(bt => bt.TypeEquals(type)), It.IsAny()); - //Arg.Is.Equal(argument), - //Arg.Matches(bt => bt.TypeEquals(type)), - //Arg.Is.Anything); - } - } - [Binding] public class StepExecutionTestsBindingsForArgumentConvert { @@ -59,7 +35,7 @@ public virtual void DoubleArgWithTable(double param, Table table) } } - + public class StepExecutionTestsWithConversions : StepExecutionTestsBase { [Fact] @@ -67,10 +43,6 @@ public async Task ShouldCallBindingWithSimpleConvertParam() { var (testRunner, bindingMock) = GetTestRunnerFor(); - //bindingInstance.Expect(b => b.BindingWithSimpleConvertParam(1.23)); - - //MockRepository.ReplayAll(); - await testRunner.GivenAsync("sample step with simple convert param: 1.23"); GetLastTestStatus().Should().Be(ScenarioExecutionStatus.OK); @@ -80,9 +52,7 @@ public async Task ShouldCallBindingWithSimpleConvertParam() [Fact] public async Task ShouldRaiseErrorIfSimpleConvertParamFails() { - var (testRunner, bindingMock) = GetTestRunnerFor(); - - //MockRepository.ReplayAll(); + var (testRunner, _) = GetTestRunnerFor(); await testRunner.GivenAsync("sample step with simple convert param: not-a-double"); @@ -92,45 +62,31 @@ public async Task ShouldRaiseErrorIfSimpleConvertParamFails() [Fact] public async Task ShouldCallTheOnlyThatCanConvert() { - StepArgumentTypeConverterStub.Setup(LegacyStepArgumentTypeConverterExtensions.GetCanConvertMethodFilter("argument", typeof(double))).Returns(true); - //StepArgumentTypeConverterStub.Setup(c => c.CanConvert(It.IsAny(), It.IsAny(), It.IsAny())).Returns(false); - StepArgumentTypeConverterStub.Setup(LegacyStepArgumentTypeConverterExtensions.GetConvertAsyncMethodFilter("argument", typeof(double))).ReturnsAsync(1.23); + StepArgumentTypeConverterStub.Setup(c => c.CanConvert("argument", ArgumentHelpers.IsBindingType(), It.IsAny())).Returns(true); + StepArgumentTypeConverterStub.Setup(c => c.ConvertAsync("argument", ArgumentHelpers.IsBindingType(), It.IsAny())).ReturnsAsync(1.23); var (testRunner, bindingMock) = GetTestRunnerWithConverterStub(); - - - - //bindingInstance.Expect(b => b.DoubleArg(1.23)); - - //MockRepository.ReplayAll(); - await testRunner.GivenAsync("sample step for argument convert: argument"); GetLastTestStatus().Should().Be(ScenarioExecutionStatus.OK, ContextManagerStub.ScenarioContext.TestError?.ToString()); bindingMock.Verify(x => x.DoubleArg(1.23)); - //StepArgumentTypeConverterStub.Verify(c => c.Convert("argument", It.Is(bt => bt.TypeEquals(typeof(double))), It.IsAny())).; LegacyStepArgumentTypeConverterExtensions.GetConvertMethodFilter("argument", typeof(double))).Return(1.23); } - + [Fact] public async Task ShouldRaiseAmbiguousIfMultipleCanConvert() { - StepArgumentTypeConverterStub.Setup(LegacyStepArgumentTypeConverterExtensions.GetCanConvertMethodFilter("argument", typeof(double))).Returns(true); - StepArgumentTypeConverterStub.Setup(LegacyStepArgumentTypeConverterExtensions.GetCanConvertMethodFilter("argument", typeof(int))).Returns(true); + StepArgumentTypeConverterStub.Setup(c => c.CanConvert("argument", ArgumentHelpers.IsBindingType(), It.IsAny())).Returns(true); + StepArgumentTypeConverterStub.Setup(c => c.CanConvert("argument", ArgumentHelpers.IsBindingType(), It.IsAny())).Returns(true); StepArgumentTypeConverterStub.Setup(c => c.CanConvert(It.IsAny(), It.IsAny(), It.IsAny())).Returns(false); - var (testRunner, bindingMock) = GetTestRunnerWithConverterStub(); - - // return false unless its a Double or an Int - - //MockRepository.ReplayAll(); + var (testRunner, _) = GetTestRunnerWithConverterStub(); await testRunner.GivenAsync("sample step for argument convert: argument"); - GetLastTestStatus().Should().Be(ScenarioExecutionStatus.BindingError, ContextManagerStub.ScenarioContext.TestError?.ToString()); } @@ -139,24 +95,17 @@ public async Task ShouldCallTheOnlyThatCanConvertWithTable() { Table table = new Table("h1"); - // return false unless its a Double or table->table - StepArgumentTypeConverterStub.Setup(LegacyStepArgumentTypeConverterExtensions.GetCanConvertMethodFilter("argument", typeof(double))).Returns(true); - //StepArgumentTypeConverterStub.Setup(c => c.CanConvert(It.IsAny(), It.IsAny(), It.IsAny())).Returns(false); + // return false unless it's a Double or table->table + StepArgumentTypeConverterStub.Setup(c => c.CanConvert("argument", ArgumentHelpers.IsBindingType(), It.IsAny())).Returns(true); - StepArgumentTypeConverterStub.Setup(LegacyStepArgumentTypeConverterExtensions.GetConvertAsyncMethodFilter(table, typeof(Table))).ReturnsAsync(table); - StepArgumentTypeConverterStub.Setup(LegacyStepArgumentTypeConverterExtensions.GetConvertAsyncMethodFilter("argument", typeof(double))).ReturnsAsync(1.23); + StepArgumentTypeConverterStub.Setup(c => c.ConvertAsync(It.Is(s => s.Equals(table)), ArgumentHelpers.IsBindingType(), It.IsAny())).ReturnsAsync(table); + StepArgumentTypeConverterStub.Setup(c => c.ConvertAsync("argument", ArgumentHelpers.IsBindingType(), It.IsAny())).ReturnsAsync(1.23); var (testRunner, bindingMock) = GetTestRunnerWithConverterStub(); - - //bindingInstance.Expect(b => b.DoubleArgWithTable(1.23, table)); - - //MockRepository.ReplayAll(); - await testRunner.GivenAsync("sample step for argument convert with table: argument", null, table); - GetLastTestStatus().Should().Be(ScenarioExecutionStatus.OK, ContextManagerStub.ScenarioContext.TestError?.ToString()); bindingMock.Verify(x => x.DoubleArgWithTable(1.23, table)); } @@ -164,13 +113,11 @@ public async Task ShouldCallTheOnlyThatCanConvertWithTable() [Fact] public async Task ShouldRaiseParamErrorIfNoneCanConvert() { - var (testRunner, bindingMock) = GetTestRunnerFor(); + var (testRunner, _) = GetTestRunnerFor(); // none can convert StepArgumentTypeConverterStub.Setup(c => c.CanConvert(It.IsAny(), It.IsAny(), It.IsAny())).Returns(false); - // MockRepository.ReplayAll(); - await testRunner.GivenAsync("sample step for argument convert: argument"); GetLastTestStatus().Should().Be(ScenarioExecutionStatus.BindingError, ContextManagerStub.ScenarioContext.TestError?.ToString()); diff --git a/Tests/Reqnroll.RuntimeTests/StepExecutionTestsWithConversionsForTables.cs b/Tests/Reqnroll.RuntimeTests/StepExecutionTestsWithConversionsForTables.cs index 1afc7529d..127004d4f 100644 --- a/Tests/Reqnroll.RuntimeTests/StepExecutionTestsWithConversionsForTables.cs +++ b/Tests/Reqnroll.RuntimeTests/StepExecutionTestsWithConversionsForTables.cs @@ -42,12 +42,9 @@ public async Task ShouldCallTheUserConverterToConvertTableWithTable() Table table = new Table("h1"); var user = new User(); - // return false unless its a User - StepArgumentTypeConverterStub.Setup(LegacyStepArgumentTypeConverterExtensions.GetCanConvertMethodFilter(table, typeof(User))).Returns(true); - StepArgumentTypeConverterStub.Setup(LegacyStepArgumentTypeConverterExtensions.GetConvertAsyncMethodFilter(table, typeof(User))).ReturnsAsync(user); - - //bindingInstance.Expect(b => b.SingleTable(user)); - //MockRepository.ReplayAll(); + // return false unless it's a User + StepArgumentTypeConverterStub.Setup(c => c.CanConvert(table, ArgumentHelpers.IsBindingType(), It.IsAny())).Returns(true); + StepArgumentTypeConverterStub.Setup(c => c.ConvertAsync(It.Is(s => s.Equals(table)), ArgumentHelpers.IsBindingType(), It.IsAny())).ReturnsAsync(user); await testRunner.GivenAsync("sample step for argument convert with table", null, table); @@ -63,17 +60,12 @@ public async Task ShouldCallTheUserConverterToConvertTableWithTableAndMultilineA Table table = new Table("h1"); var user = new User(); var multiLineArg = "multi-line arg"; - // return false unless its a User - StepArgumentTypeConverterStub.Setup(LegacyStepArgumentTypeConverterExtensions.GetCanConvertMethodFilter(table, typeof(User))).Returns(true); + // return false unless it's a User + StepArgumentTypeConverterStub.Setup(c => c.CanConvert(table, ArgumentHelpers.IsBindingType(), It.IsAny())).Returns(true); StepArgumentTypeConverterStub.Setup(c => c.CanConvert(It.IsAny(), It.IsAny(), It.IsAny())).Returns(false); - StepArgumentTypeConverterStub.Setup(LegacyStepArgumentTypeConverterExtensions.GetConvertAsyncMethodFilter(multiLineArg, typeof(string))).ReturnsAsync(multiLineArg); - StepArgumentTypeConverterStub.Setup(LegacyStepArgumentTypeConverterExtensions.GetConvertAsyncMethodFilter(table, typeof(User))).ReturnsAsync(user); - - + StepArgumentTypeConverterStub.Setup(c => c.ConvertAsync(multiLineArg, ArgumentHelpers.IsBindingType(), It.IsAny())).ReturnsAsync(multiLineArg); + StepArgumentTypeConverterStub.Setup(c => c.ConvertAsync(It.Is(s => s.Equals(table)), ArgumentHelpers.IsBindingType(), It.IsAny())).ReturnsAsync(user); - //bindingInstance.Expect(b => b.MultilineArgumentAndTable(multiLineArg, user)); - //MockRepository.ReplayAll(); - await testRunner.GivenAsync("sample step for argument convert with multiline argument and table", multiLineArg, table); GetLastTestStatus().Should().Be(ScenarioExecutionStatus.OK); @@ -89,17 +81,13 @@ public async Task ShouldCallTheUserConverterToConvertTableWithTableAndMultilineA string argumentValue = "argument"; var user = new User(); var multiLineArg = "multi-line arg"; - // return false unless its a User + // return false unless it's a User // must also stub CanConvert & Convert for the string argument as we've introduced a parameter - StepArgumentTypeConverterStub.Setup(LegacyStepArgumentTypeConverterExtensions.GetCanConvertMethodFilter(table, typeof(User))).Returns(true); + StepArgumentTypeConverterStub.Setup(c => c.CanConvert(table, ArgumentHelpers.IsBindingType(), It.IsAny())).Returns(true); StepArgumentTypeConverterStub.Setup(c => c.CanConvert(It.IsAny(), It.IsAny(), It.IsAny())).Returns(false); - StepArgumentTypeConverterStub.Setup(LegacyStepArgumentTypeConverterExtensions.GetConvertAsyncMethodFilter(table, typeof(User))).ReturnsAsync(user); - StepArgumentTypeConverterStub.Setup(LegacyStepArgumentTypeConverterExtensions.GetConvertAsyncMethodFilter(argumentValue, typeof(string))).ReturnsAsync(argumentValue); - StepArgumentTypeConverterStub.Setup(LegacyStepArgumentTypeConverterExtensions.GetConvertAsyncMethodFilter(multiLineArg, typeof(string))).ReturnsAsync(multiLineArg); - - - //bindingInstance.Expect(b => b.ParameterMultilineArgumentAndTable(argumentValue, multiLineArg, user)); - //MockRepository.ReplayAll(); + StepArgumentTypeConverterStub.Setup(c => c.ConvertAsync(It.Is(s => s.Equals(table)), ArgumentHelpers.IsBindingType(), It.IsAny())).ReturnsAsync(user); + StepArgumentTypeConverterStub.Setup(c => c.ConvertAsync(argumentValue, ArgumentHelpers.IsBindingType(), It.IsAny())).ReturnsAsync(argumentValue); + StepArgumentTypeConverterStub.Setup(c => c.ConvertAsync(multiLineArg, ArgumentHelpers.IsBindingType(), It.IsAny())).ReturnsAsync(multiLineArg); await testRunner.GivenAsync("sample step for argument convert with parameter, multiline argument and table: argument", multiLineArg, table);