public async Task <ActionResult> GetCustomerById(int customerId)
{
LogStart();
try
{
var errorInfo = new ErrorInfo();
// Customer Id
errorInfo = IdentifierValidator.Validate(customerId);
if (errorInfo.ErrorCode != ErrorTypes.OK)
{
throw new BadInputException(errorInfo);
}
var customerModel = await _customerRepository.GetCustomerByIdentifierAsync(customerId);
// Customer
errorInfo = CustomerObjectValidator.Validate(customerModel, customerId);
if (errorInfo.ErrorCode != ErrorTypes.OK)
{
throw new NotFoundException(errorInfo);
}
// Map
var result = _mapper.Map <CustomerDto>(customerModel);
return(Ok(result));
}
catch (Exception ex)
{
LogError(ex);
throw ex;
}
}
/// <summary>
/// Attempts to validate a user-provided identifier.
/// </summary>
/// <param name="identifier">The identifier to validate.</param>
/// <exception cref="PasswordValidationException">Thrown on validation failure.</exception>
public void Validate(string identifier)
{
if (!IdentifierValidator.Validate(identifier, out string errorMessage))
{
throw new IdentifierValidationException(errorMessage);
}
}
//[Obsolete]
//public static Func<string, bool> NameVerifier
//{
// get { return nameVerifier ?? defaultNameVerifier; }
// set { nameVerifier = value; }
//}
public static void ValidateName(string name)
{
if (IdentifierValidator.Verify(name) == false)
{
throw new ArgumentException($"{name} is invalid name", nameof(name));
}
}
/// <summary>
/// Sets the value of a variable referenced within the expression prior
/// to evaluation. This override allows specifying the Type of the variable
/// instead of trying to introspect it. Also allows for passing null as the
/// value.
/// </summary>
/// <param name="name">
/// Name of the variable referenced within the expression.
/// </param>
/// <param name="value">
/// Value of the variable that should be used when evaluating the expression.
/// </param>
/// <param name="type">
/// The variable Type.
/// </param>
public void SetVariable(
string name,
object value,
Type type)
{
if (variables.ContainsKey(name))
{
variables[name].Value = value;
}
else
{
if (IdentifierValidator.IsValidIdentifier(name))
{
variables[name] = new Variable
{
Type = type,
Value = value
};
initialized = false;
}
else
{
throw new ArgumentException("Invalid value passed in for variable name. " +
"Valid variable names must start with a letter or underscore, and not contain any whitespace.");
}
}
}
public string GetSafeIdentifier(string name)
{
if (string.IsNullOrEmpty(name))
{
return(name);
}
// NOTE: "partial" differs in behavior on macOS vs. Windows, Windows reports "partial" as a valid identifier
// This check ensures the same output on both platforms
switch (name)
{
case "partial": return(name);
// `this` isn't in TypeNameUtilities.reserved_keywords; special-case.
case "this": return("this_");
}
// In the ideal world, it should not be applied twice.
// Sadly that is not true in reality, so we need to exclude non-symbols
// when replacing the argument name with a valid identifier.
// (ReturnValue.ToNative() takes an argument which could be either an expression or mere symbol.)
if (name [name.Length - 1] != ')' && !name.Contains('.') && !name.StartsWith("@"))
{
if (!IdentifierValidator.IsValidIdentifier(name) ||
Array.BinarySearch(TypeNameUtilities.reserved_keywords, name) >= 0)
{
name = name + "_";
}
}
return(name.Replace('$', '_'));
}
private void ID_TextChanged(object sender, TextChangedEventArgs e)
{
if (this.ID.Text != string.Empty && IdentifierValidator.Verify(this.ID.Text) == false)
{
//this.blinker.HasError = true;
}
}
/// <summary>
/// Create cil source-code representation of a <see cref="EnumDefinition"/>.
/// </summary>
/// <exception cref="Exceptions.InvalidAssemblyNameException">
/// Thrown when a invalid assembly name is given.
/// </exception>
/// <exception cref="Exceptions.InvalidNamespaceException">
/// Thrown when a invalid namespace identifier is given.
/// </exception>
/// <exception cref="Exceptions.OutOfBoundsValueException">
/// Thrown when enum value does not fit in given storage-type.
/// </exception>
/// <param name="enumDefinition">Enum to generate cil source-code for</param>
/// <param name="assemblyName">Name of the assembly to generate</param>
/// <param name="namespace">Optional namespace to add the enum to</param>
/// <param name="headerMode">Mode to use when adding a header</param>
/// <param name="indentMode">Mode to use for indenting</param>
/// <param name="spaceIndentSize">When indenting with spaces this controls how many</param>
/// <param name="newlineMode">Mode to use for ending lines</param>
/// <param name="storageType">Underlying enum storage-type to use</param>
/// <param name="curlyBracketMode">Mode to use when writing curly brackets</param>
/// <returns>String containing the genenerated cil sourcecode</returns>
public static string ExportCil(
this EnumDefinition enumDefinition,
string assemblyName,
string @namespace = null,
HeaderMode headerMode = HeaderMode.Default,
CodeBuilder.IndentMode indentMode = CodeBuilder.IndentMode.Spaces,
int spaceIndentSize = 4,
CodeBuilder.NewlineMode newlineMode = CodeBuilder.NewlineMode.Unix,
StorageType storageType = StorageType.Implicit,
CurlyBracketMode curlyBracketMode = CurlyBracketMode.NewLine)
{
if (enumDefinition == null)
{
throw new ArgumentNullException(nameof(enumDefinition));
}
if (string.IsNullOrEmpty(assemblyName) || !IdentifierValidator.Validate(assemblyName))
{
throw new InvalidAssemblyNameException(assemblyName);
}
if (!string.IsNullOrEmpty(@namespace) && !IdentifierValidator.ValidateNamespace(@namespace))
{
throw new InvalidNamespaceException(@namespace);
}
foreach (var oobEntry in enumDefinition.Entries.Where(e => !storageType.Validate(e.Value)))
{
throw new OutOfBoundsValueException(storageType, oobEntry.Value);
}
var builder = new CodeBuilder(indentMode, spaceIndentSize, newlineMode);
if (headerMode != HeaderMode.None)
{
builder.AddHeader();
builder.WriteEndLine();
}
// Add reference to mscorlib.
builder.WriteLine(".assembly extern mscorlib { }");
builder.WriteEndLine();
// Add assembly info.
builder.Write($".assembly {assemblyName}");
StartScope(builder, curlyBracketMode);
builder.WriteLine(".ver 1:0:0:0");
EndScope(builder);
builder.WriteEndLine();
// Add module info.
builder.WriteLine($".module {assemblyName}.dll");
builder.WriteEndLine();
// Add enum class.
builder.AddEnum(enumDefinition, storageType, curlyBracketMode, @namespace);
return(builder.Build());
}
public void ReturnFailureForEmptyIdentifier()
{
Validator <string> validator = new IdentifierValidator();
ValidationResults validationResults = validator.Validate(string.Empty);
Assert.IsFalse(validationResults.IsValid);
Assert.AreEqual(1, (new List <ValidationResult>(validationResults)).Count);
}
public void ReturnFailureForInvalidDefaultLengthIdentifier()
{
Validator<string> validator = new IdentifierValidator();
ValidationResults validationResults = validator.Validate("asdaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaasdaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaasdaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaasdaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaasdaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaasdaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaasdaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaasdaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaasdaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaasdaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaasdaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaasdaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaasdaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaasdaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaasdaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaasdaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaasdaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaasdaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaasdaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaasdaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaasdaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaasdaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaasdaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
Assert.IsFalse(validationResults.IsValid);
Assert.AreEqual(1, (new List<ValidationResult>(validationResults)).Count);
}
public void IdentifierWithValidNameIsValid()
{
var alert = new Alert();
alert.Identifier = "43b080713727";
var identifierValidator = new IdentifierValidator(alert);
Assert.True(identifierValidator.IsValid);
}
public void ReturnFailureForEmptyIdentifier()
{
Validator<string> validator = new IdentifierValidator();
ValidationResults validationResults = validator.Validate(string.Empty);
Assert.IsFalse(validationResults.IsValid);
Assert.AreEqual(1, (new List<ValidationResult>(validationResults)).Count);
}
public void ReturnFailureForInvalidIdentifierByLanguage()
{
Validator <string> validator = new IdentifierValidator("VB", null);
ValidationResults validationResults = validator.Validate("?asd");
Assert.IsFalse(validationResults.IsValid);
Assert.AreEqual(1, (new List <ValidationResult>(validationResults)).Count);
}
public void ReturnSuccessForValidIdentifierByLanguage()
{
Validator <string> validator = new IdentifierValidator("VB", null);
ValidationResults validationResults = validator.Validate("test");
Assert.IsTrue(validationResults.IsValid);
Assert.AreEqual(0, (new List <ValidationResult>(validationResults)).Count);
}
public void ReturnFailureForInvalidDefaultLengthIdentifier()
{
Validator <string> validator = new IdentifierValidator();
ValidationResults validationResults = validator.Validate("asdaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaasdaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaasdaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaasdaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaasdaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaasdaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaasdaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaasdaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaasdaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaasdaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaasdaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaasdaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaasdaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaasdaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaasdaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaasdaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaasdaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaasdaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaasdaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaasdaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaasdaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaasdaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaasdaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
Assert.IsFalse(validationResults.IsValid);
Assert.AreEqual(1, (new List <ValidationResult>(validationResults)).Count);
}
public IdentifierValidatorTests()
{
_pidUriTemplateService = new Mock <IPidUriTemplateService>();
_pidUriGenerationService = new Mock <IPidUriGenerationService>();
_consumerGroupService = new Mock <IConsumerGroupService>();
_validator = new IdentifierValidator(_pidUriTemplateService.Object, _pidUriGenerationService.Object, _consumerGroupService.Object);
_metadata = new MetadataBuilder().GenerateSamplePidUri().Build();
}
private static bool VerifyName(string name)
{
if (NameValidator.VerifyName(name) == false)
{
return(false);
}
return(IdentifierValidator.Verify(name));
}
/// <summary>
/// Initializes a new instance of the <see cref="EnumBuilder"/> class
/// </summary>
/// <exception cref="Exceptions.InvalidEnumNameException">
/// Thrown when name is not a valid identifier.
/// </exception>
/// <param name="name">Name of the enum</param>
public EnumBuilder(string name)
{
if (!IdentifierValidator.Validate(name))
{
throw new Exceptions.InvalidEnumNameException(this.name);
}
this.name = name;
}
public async Task Name_User_TestAsync()
{
var userItemFilter = new UserItemFilter(typeof(IUser));
var userItem = await userItemFilter.GetUserItemAsync(app);
var condition = IdentifierValidator.Verify(userItem.Name);
Assert.IsTrue(condition);
}
public void AttributeBasedConstructorWithEmptyAttributeCollection()
{
Validator <string> validator = new IdentifierValidator((NameValueCollection)null);
ValidationResults validationResults = validator.Validate("test");
Assert.IsTrue(validationResults.IsValid);
Assert.AreEqual(0, (new List <ValidationResult>(validationResults)).Count);
}
public void Invalid(string value)
{
IValidator <Identifier> validator = new IdentifierValidator();
var target = new ValidationTarget <Identifier>(new Identifier(value));
validator.Validate(target);
Assert.True(target.GetResult().HasErrors);
}
public void IdentifierWithCommaIsInvalid()
{
var alert = new Alert();
alert.Identifier = "43b080713727,";
var identifierValidator = new IdentifierValidator(alert);
Assert.False(identifierValidator.IsValid);
Assert.Equal(typeof(IdentifierError), identifierValidator.Errors.ElementAt(0).GetType());
Assert.Equal(1, identifierValidator.Errors.Count());
}
public static string NextInvalidIdentifier()
{
string name;
while (IdentifierValidator.Verify((name = NextWord())) == true)
{
;
}
return(name);
}
public void IsValidIdentifier()
{
Assert.IsTrue(IdentifierValidator.IsValidIdentifier("name"));
Assert.IsTrue(IdentifierValidator.IsValidIdentifier("Name_With_Underscores"));
// Yes, this is "wrong" -- keywords aren't identifiers -- but the keyword check is done elsewhere.
Assert.IsTrue(IdentifierValidator.IsValidIdentifier("true"));
Assert.IsFalse(IdentifierValidator.IsValidIdentifier("name-with-hyphens and spaces"));
Assert.IsFalse(IdentifierValidator.IsValidIdentifier("123"));
}
public void ReturnFailureForInvalidConfigurableLengthIdentifier()
{
NameValueCollection atts = new NameValueCollection();
atts.Add("length", "4");
Validator<string> validator = new IdentifierValidator(atts);
ValidationResults validationResults = validator.Validate("ABCDE");
Assert.IsFalse(validationResults.IsValid);
Assert.AreEqual(1, (new List<ValidationResult>(validationResults)).Count);
}
public void ReturnFailureForInvalidConfigurableLengthIdentifier()
{
NameValueCollection atts = new NameValueCollection();
atts.Add("length", "4");
Validator <string> validator = new IdentifierValidator(atts);
ValidationResults validationResults = validator.Validate("ABCDE");
Assert.IsFalse(validationResults.IsValid);
Assert.AreEqual(1, (new List <ValidationResult>(validationResults)).Count);
}
public override ValidationResult Validate(object value, CultureInfo cultureInfo)
{
try
{
IdentifierValidator.Validate(value.ToString());
return(new ValidationResult(true, null));
}
catch (Exception e)
{
return(new ValidationResult(false, e.Message));
}
}
public void IgnoreEmptyValuesIfOptionalFlagTrue()
{
NameValueCollection attributes = new NameValueCollection();
attributes.Add("optionalValue", "True");
Validator <string> validator = new IdentifierValidator(attributes);
ValidationResults validationResults = validator.Validate("");
Assert.IsTrue(validationResults.IsValid);
Assert.AreEqual(0, (new List <ValidationResult>(validationResults)).Count);
}
public void AttributeBasedConstructor()
{
NameValueCollection attributes = new NameValueCollection();
attributes.Add("language", "VB");
Validator <string> validator = new IdentifierValidator(attributes);
ValidationResults validationResults = validator.Validate("test");
Assert.IsTrue(validationResults.IsValid);
Assert.AreEqual(0, (new List <ValidationResult>(validationResults)).Count);
}
/// <summary>
/// Create csharp source-code representation of a <see cref="EnumDefinition"/>.
/// </summary>
/// <exception cref="Exceptions.InvalidNamespaceException">
/// Thrown when a invalid namespace identifier is given.
/// </exception>
/// <exception cref="Exceptions.OutOfBoundsValueException">
/// Thrown when enum value does not fit in given storage-type.
/// </exception>
/// <param name="enumDefinition">Enum to generate csharp source-code for</param>
/// <param name="namespace">Optional namespace to add the enum to</param>
/// <param name="headerMode">Mode to use when adding a header</param>
/// <param name="indentMode">Mode to use for indenting</param>
/// <param name="spaceIndentSize">When indenting with spaces this controls how many</param>
/// <param name="newlineMode">Mode to use for ending lines</param>
/// <param name="storageType">Underlying enum storage-type to use</param>
/// <param name="curlyBracketMode">Mode to use when writing curly brackets</param>
/// <returns>String containing the genenerated csharp sourcecode</returns>
public static string ExportCSharp(
this EnumDefinition enumDefinition,
string @namespace = null,
HeaderMode headerMode = HeaderMode.Default,
CodeBuilder.IndentMode indentMode = CodeBuilder.IndentMode.Spaces,
int spaceIndentSize = 4,
CodeBuilder.NewlineMode newlineMode = CodeBuilder.NewlineMode.Unix,
StorageType storageType = StorageType.Implicit,
CurlyBracketMode curlyBracketMode = CurlyBracketMode.NewLine)
{
if (enumDefinition == null)
{
throw new ArgumentNullException(nameof(enumDefinition));
}
if (!string.IsNullOrEmpty(@namespace) && !IdentifierValidator.ValidateNamespace(@namespace))
{
throw new InvalidNamespaceException(@namespace);
}
foreach (var oobEntry in enumDefinition.Entries.Where(e => !storageType.Validate(e.Value)))
{
throw new OutOfBoundsValueException(storageType, oobEntry.Value);
}
var builder = new CodeBuilder(indentMode, spaceIndentSize, newlineMode);
if (headerMode != HeaderMode.None)
{
builder.AddHeader();
builder.WriteEndLine();
}
builder.WriteLine("using System.CodeDom.Compiler;");
builder.WriteEndLine();
if (string.IsNullOrEmpty(@namespace))
{
builder.AddEnum(enumDefinition, storageType, curlyBracketMode);
}
else
{
builder.AddNamespace(
@namespace,
b => b.AddEnum(enumDefinition, storageType, curlyBracketMode),
curlyBracketMode);
}
return(builder.Build());
}
static string EnsureValidIdentifer(string name)
{
if (string.IsNullOrWhiteSpace(name))
{
return(name);
}
name = IdentifierValidator.CreateValidIdentifier(name);
if (char.IsNumber(name [0]))
{
name = $"_{name}";
}
return(name);
}
/// <summary>
/// Add a entry to the enum.
/// </summary>
/// <exception cref="Exceptions.InvalidEnumEntryNameException">
/// Thrown when name is not a valid identifier.
/// </exception>
/// <exception cref="Exceptions.DuplicateEnumEntryNameException">
/// Thrown when name is not unique.
/// </exception>
/// <exception cref="Exceptions.DuplicateEnumEntryValueException">
/// Thrown when value is not unique.
/// </exception>
/// <param name="name">Name of the entry</param>
/// <param name="value">Value of the entry</param>
/// <param name="comment">Optional comment about the entry</param>
public void PushEntry(string name, long value, string comment = null)
{
if (!IdentifierValidator.Validate(name))
{
throw new Exceptions.InvalidEnumEntryNameException(this.name, name);
}
if (this.entries.Any(e => e.Name == name))
{
throw new Exceptions.DuplicateEnumEntryNameException(this.name, name);
}
if (this.entries.Any(e => e.Value == value))
{
throw new Exceptions.DuplicateEnumEntryValueException(this.name, value);
}
this.entries.Add(new EnumEntry(name, value, comment));
}
private static bool ValidateIdentifier(string identifier)
{
if (String.IsNullOrEmpty(identifier))
{
return(false);
}
if (!IdentifierValidator.IsLetter(identifier[0]))
{
return(false);
}
for (int i = 1; i < identifier.Length; ++i)
{
if (!IdentifierValidator.IsValidCharacter(identifier[i]))
{
return(false);
}
}
return(true);
}
public void CreateValidIdentifier_Encoded()
{
Assert.AreEqual("my_x45_identifier_x36_test", IdentifierValidator.CreateValidIdentifier("my-identifier$test", true));
Assert.AreEqual("myidentifier_x55357__x56842_test", IdentifierValidator.CreateValidIdentifier("myidentifier😊test", true));
}
public static bool VerifyName(string name)
{
return(IdentifierValidator.Verify(name));
}
public void AttributeBasedConstructorWithEmptyAttributeCollection()
{
Validator<string> validator = new IdentifierValidator((NameValueCollection)null);
ValidationResults validationResults = validator.Validate("test");
Assert.IsTrue(validationResults.IsValid);
Assert.AreEqual(0, (new List<ValidationResult>(validationResults)).Count);
}
public void ReturnSuccessForValidIdentifierByLanguage()
{
Validator<string> validator = new IdentifierValidator("VB", null);
ValidationResults validationResults = validator.Validate("test");
Assert.IsTrue(validationResults.IsValid);
Assert.AreEqual(0, (new List<ValidationResult>(validationResults)).Count);
}
public async Task <IActionResult> UpdateCustomer(int id, UpdateCustomerRequest request)
{
var errorInfo = new ErrorInfo();
// Verify customer identifier from route and request body
errorInfo = IdentifierValidator.Validate(id, request.CustomerIdentifier);
if (errorInfo.ErrorCode != ErrorTypes.OK)
{
throw new BadInputException(errorInfo);
}
// Find customer to update
var currentCustomer = await _customerRepository.GetCustomerByIdentifierAsync(id);
// Customer
errorInfo = CustomerObjectValidator.Validate(currentCustomer, id);
if (errorInfo.ErrorCode != ErrorTypes.OK)
{
throw new BadInputException(errorInfo);
}
bool isModified = false;
// Fullname
if (request.FullName != null && currentCustomer.FullName != request.FullName)
{
errorInfo = FullNameValidator.Validate(request.FullName, out string fullName);
if (errorInfo.ErrorCode != ErrorTypes.OK)
{
throw new BadInputException(errorInfo);
}
isModified = true;
currentCustomer.FullName = fullName;
}
// Date of Birth
if (request.DateOfBirth != null && currentCustomer.DateOfBirth.ToString() != request.DateOfBirth)
{
errorInfo = DateTimeValidator.Validate(request.DateOfBirth, out DateTime? validDate);
if (errorInfo.ErrorCode != ErrorTypes.OK)
{
throw new BadInputException(errorInfo);
}
isModified = true;
currentCustomer.DateOfBirth = validDate;
currentCustomer.Age = CalculateAge.Calculate(request.DateOfBirth);
}
// Validate ICollection Address
if (request?.Address != null)
{
foreach (var item in request.Address)
{
errorInfo = AddressValidator.Validate(item);
if (errorInfo.ErrorCode != ErrorTypes.OK)
{
throw new BadInputException(errorInfo);
}
}
isModified = true;
currentCustomer.Address = _mapper.Map <List <AddressModel> >(request.Address);
}
if (isModified)
{
// TODO: To implement the updated and created date in Model
// newCustomer.UpdatedDate = DateTime.UtcNow;
await _customerRepository.UpdateCustomerAsync(currentCustomer);
}
// Map Journal Model to Journal Dto
var resultDto = _mapper.Map <CustomerDto>(currentCustomer);
return(Ok(resultDto));
}
public void AttributeBasedConstructor()
{
NameValueCollection attributes = new NameValueCollection();
attributes.Add("language", "VB");
Validator<string> validator = new IdentifierValidator(attributes);
ValidationResults validationResults = validator.Validate("test");
Assert.IsTrue(validationResults.IsValid);
Assert.AreEqual(0, (new List<ValidationResult>(validationResults)).Count);
}
public void ReturnFailureForInvalidIdentifierByLanguage()
{
Validator<string> validator = new IdentifierValidator("VB", null);
ValidationResults validationResults = validator.Validate("?asd");
Assert.IsFalse(validationResults.IsValid);
Assert.AreEqual(1, (new List<ValidationResult>(validationResults)).Count);
}
public void ReturnErrorForUnknownLanguage()
{
Validator<string> validator = new IdentifierValidator("UnknownLanguage", null);
ValidationResults validationResults = validator.Validate("valid");
}
public void IgnoreEmptyValuesIfOptionalFlagTrue()
{
NameValueCollection attributes = new NameValueCollection();
attributes.Add("optionalValue", "True");
Validator<string> validator = new IdentifierValidator(attributes);
ValidationResults validationResults = validator.Validate("");
Assert.IsTrue(validationResults.IsValid);
Assert.AreEqual(0, (new List<ValidationResult>(validationResults)).Count);
}
