public void OnProvidersExecuting_SucceedsWithGeneralAttributeAndValidMetadata()
{
// Arrange
var provider = new TestMetadataProvider(ValidMetadata);
var context = GetApplicatonModelProviderContext(typeof(GeneralController));
// Act
provider.OnProvidersExecuting(context);
// Assert
var controllerModel = Assert.Single(context.Result.Controllers);
var actionModel = Assert.Single(controllerModel.Actions);
Assert.Collection(actionModel.Properties.OrderBy(kvp => ((Type)kvp.Key).Name),
kvp =>
{
Assert.Equal(typeof(IWebHookBodyTypeMetadataService), kvp.Key);
Assert.IsAssignableFrom <IReadOnlyList <IWebHookBodyTypeMetadataService> >(kvp.Value);
},
kvp =>
{
Assert.Equal(typeof(IWebHookEventMetadata), kvp.Key);
Assert.IsAssignableFrom <IReadOnlyList <IWebHookEventMetadata> >(kvp.Value);
},
kvp =>
{
Assert.Equal(typeof(IWebHookEventSelectorMetadata), kvp.Key);
Assert.IsAssignableFrom <GeneralWebHookAttribute>(kvp.Value);
},
kvp =>
{
Assert.Equal(typeof(IWebHookPingRequestMetadata), kvp.Key);
Assert.IsAssignableFrom <IReadOnlyList <IWebHookPingRequestMetadata> >(kvp.Value);
});
}
public void GetValueFormattingServiceFor_should_honor_custom_formatters_then_explicit_then_formattable_then_general_then_ToString()
{
var testMetadataProvider = new TestMetadataProvider(cfg => cfg.ValueFormattingConfiguration()
.RegisterFrameworkDefaultGeneralFormatters()
.RegisterExplicit(typeof(bool), new FormatAttribute(">{0}<"))
.RegisterExplicit(typeof(int), new FormatAttribute("i{0}"))
.RegisterExplicit(typeof(MyFormattable2), new FormatAttribute("my-explicit2"))
.RegisterGeneral(new MyStructFormatter()));
var parameter = ParameterInfoHelper.GetMethodParameter <object[]>(Step_with_custom_formatters);
var formatter = testMetadataProvider
.GetValueFormattingServiceFor(parameter);
var values = new object[]
{
null, // null
5, // explicit int
true, // [FormatBoolean] overriding explicit bool
5.5, // general struct
new MyClass(), // toString
new MyFormattable1(), // [Format]
new MyFormattable2(), // explicit formatter
new MyFormattable3() // ISelfFormattable
};
Assert.That(formatter.FormatValue(values), Is.EqualTo("#<null> | #i5 | #On | #s5.5 | #my-class | #my-custom-format1 | #my-explicit2 | #my3"));
}
public void GetStepName_should_properly_convert_predefined_step_type(string inputStepType, string lastStepType, string expectedStepType)
{
var metadataProvider = new TestMetadataProvider(new DefaultNameFormatter());
var descriptor = new StepDescriptor(inputStepType, "some_test_method", (o, a) => Task.FromResult(0));
var stepName = metadataProvider.GetStepName(descriptor, lastStepType);
Assert.That(stepName.StepTypeName.ToString(), Is.EqualTo(expectedStepType));
}
public void It_should_format_step_parameters_with_specified_formatter(string cultureInfo, double parameter, string expectedFormattedParameter)
{
var parameterInfo = ParameterInfoHelper.GetMethodParameter <double>(Step_with_parameter);
var formatter = new TestMetadataProvider(new DefaultNameFormatter(), new StepTypeConfiguration(), new TestCultureInfoProvider(new CultureInfo(cultureInfo)))
.GetParameterFormatter(parameterInfo);
Assert.That(formatter.Invoke(parameter), Is.EqualTo(expectedFormattedParameter));
}
public void Should_allow_to_reconfigure_GetStepTypeNameFromFormattedStepName(string formattedName, string expectedType, string expectedName)
{
_subject = new TestableMetadataProvider(new[] { "call", "invoke" }, "");
var type = _subject.GetStepTypeNameFromFormattedStepName(ref formattedName);
Assert.That(type, Is.EqualTo(expectedType), "type");
Assert.That(formattedName, Is.EqualTo(expectedName), "name");
}
public void GetStepName_should_not_extract_step_type_if_nothing_is_left_after_it()
{
var metadataProvider = new TestMetadataProvider(new DefaultNameFormatter());
var descriptor = new StepDescriptor("given", (o, a) => Task.FromResult(DefaultStepResultDescriptor.Instance));
var stepName = metadataProvider.GetStepName(descriptor, null);
Assert.That(stepName.StepTypeName, Is.EqualTo(null));
Assert.That(stepName.NameFormat, Is.EqualTo("given"));
}
public void GetStepName_should_properly_infer_default_step_type_from_method_name(string methodName, string lastStepType, string expectedStepType, string expectedStepNameFormat)
{
var metadataProvider = new TestMetadataProvider(new DefaultNameFormatter());
var descriptor = new StepDescriptor(methodName, (o, a) => Task.FromResult(DefaultStepResultDescriptor.Instance));
var stepName = metadataProvider.GetStepName(descriptor, lastStepType);
Assert.That(stepName.StepTypeName?.ToString(), Is.EqualTo(expectedStepType));
Assert.That(stepName.NameFormat, Is.EqualTo(expectedStepNameFormat));
}
public void Should_allow_to_reconfigure_predefined_step_types(string formattedName, string expectedType, string expectedNameFormat)
{
var metadataProvider = new TestMetadataProvider(new DefaultNameFormatter(), new StepTypeConfiguration().UpdatePredefinedStepTypes("call", "invoke"));
var descriptor = new StepDescriptor(formattedName, (o, a) => Task.FromResult(DefaultStepResultDescriptor.Instance));
var step = metadataProvider.GetStepName(descriptor, null);
Assert.That(step.StepTypeName?.ToString(), Is.EqualTo(expectedType), "type");
Assert.That(step.NameFormat, Is.EqualTo(expectedNameFormat), "name");
}
public void It_should_format_step_parameters_with_specified_formatter(string cultureInfo, double parameter, string expectedFormattedParameter)
{
var parameterInfo = ParameterInfoHelper.GetMethodParameter <double>(Step_with_parameter);
var metadataProvider = new TestMetadataProvider(cfg =>
cfg.CultureInfoProviderConfiguration()
.UpdateCultureInfoProvider(new TestCultureInfoProvider(new CultureInfo(cultureInfo))));
var formatter = metadataProvider.GetValueFormattingServiceFor(parameterInfo);
Assert.That(formatter.FormatValue(parameter), Is.EqualTo(expectedFormattedParameter));
}
public void Should_disable_normalization_if_replacementString_is_empty(string repeatedStepReplacement)
{
var metadataProvider = new TestMetadataProvider(new DefaultNameFormatter(), new StepTypeConfiguration().UpdateRepeatedStepReplacement(repeatedStepReplacement));
var stepTypeName = "given";
var descriptor = new StepDescriptor(stepTypeName, "some_name", (o, a) => Task.FromResult(0));
Assert.That(metadataProvider.GetStepName(descriptor, stepTypeName).StepTypeName.ToString(), Is.EqualTo(stepTypeName.ToUpperInvariant()));
}
public void OnProvidersExecuting_SucceedsWithGeneralAttributeAndValidMetadata_IncludingBodyType()
{
// Arrange
var provider = new TestMetadataProvider(ValidMetadata);
var context = new ApplicationModelProviderContext(new[] { typeof(JsonGeneralController).GetTypeInfo() });
var defaultProvider = new DefaultApplicationModelProvider(Options.Create(new MvcOptions()));
defaultProvider.OnProvidersExecuting(context);
// Act
provider.OnProvidersExecuting(context);
// Assert
var controllerModel = Assert.Single(context.Result.Controllers);
var actionModel = Assert.Single(controllerModel.Actions);
Assert.Collection(actionModel.Properties.OrderBy(kvp => ((Type)kvp.Key).Name),
kvp =>
{
Assert.Equal(typeof(IWebHookBodyTypeMetadata), kvp.Key);
var attribute = Assert.IsAssignableFrom <GeneralWebHookAttribute>(kvp.Value);
Assert.Equal(WebHookBodyType.Json, attribute.BodyType);
},
kvp =>
{
Assert.Equal(typeof(IWebHookBodyTypeMetadataService), kvp.Key);
Assert.IsAssignableFrom <IReadOnlyList <IWebHookBodyTypeMetadataService> >(kvp.Value);
},
kvp =>
{
Assert.Equal(typeof(IWebHookEventMetadata), kvp.Key);
Assert.IsAssignableFrom <IReadOnlyList <IWebHookEventMetadata> >(kvp.Value);
},
kvp =>
{
Assert.Equal(typeof(IWebHookEventSelectorMetadata), kvp.Key);
Assert.IsAssignableFrom <GeneralWebHookAttribute>(kvp.Value);
},
kvp =>
{
Assert.Equal(typeof(IWebHookPingRequestMetadata), kvp.Key);
Assert.IsAssignableFrom <IReadOnlyList <IWebHookPingRequestMetadata> >(kvp.Value);
});
}
public TestableBDDRunner(Type featureTestClass, TestMetadataProvider testableMetadataProvider, IProgressNotifier progressNotifier)
: base(featureTestClass, testableMetadataProvider, progressNotifier)
{
}
public void SetUp()
{
_subject = new TestableMetadataProvider();
}
public ConversionContext(TestMetadataProvider metadataProvider)
{
_metadataProvider = metadataProvider;
}
public void SetUp()
{
_subject = new TestableMetadataProvider();
}
public void Should_disable_normalization_if_replacementString_is_empty(string repeatedStepReplacement)
{
_subject = new TestableMetadataProvider(new[] { "given", "when", "then" }, repeatedStepReplacement);
Assert.That(_subject.NormalizeStepTypeName("abc", "abc"), Is.EqualTo("abc"));
}
public TestableBDDRunner(Type featureTestClass, TestMetadataProvider testableMetadataProvider, IProgressNotifier progressNotifier)
: base(featureTestClass, testableMetadataProvider, progressNotifier) { }
public void Should_allow_to_reconfigure_GetStepTypeNameFromFormattedStepName(string formattedName, string expectedType, string expectedName)
{
_subject = new TestableMetadataProvider(new[] { "call", "invoke" }, "");
var type = _subject.GetStepTypeNameFromFormattedStepName(ref formattedName);
Assert.That(type, Is.EqualTo(expectedType), "type");
Assert.That(formattedName, Is.EqualTo(expectedName), "name");
}
public void Should_disable_normalization_if_replacementString_is_empty(string repeatedStepReplacement)
{
_subject = new TestableMetadataProvider(new[] { "given", "when", "then" }, repeatedStepReplacement);
Assert.That(_subject.NormalizeStepTypeName("abc", "abc"), Is.EqualTo("abc"));
}
public StepsConverter(TestMetadataProvider metadataProvider, Func <Type, ResultStatus> mapExceptionToStatus)
{
_mapExceptionToStatus = mapExceptionToStatus;
_metadataProvider = metadataProvider;
}
