public void ShouldNotThrowStackOverflowExceptionOnCircullarReference() { var objectToValidate = new ObjectWithCircularReference {Name = "object1"}; objectToValidate.RelatedObject = objectToValidate; var validator = new ObjectValidator(); var result = validator.Validate(new[] { objectToValidate }, null).ToArray(); }
public void ShouldValidateIEnumerable() { var objectToValidate = GetEnumerator(); var validator = new ObjectValidator(); var result = validator.Validate(new[] { objectToValidate }, null).ToArray(); Assert.IsTrue(result.Any()); Assert.AreEqual(2, result.Length); }
public void ShouldValidateObjectWithIEnumerable() { var objectToValidate = new ObjectWithIEnumerable() { Collection = new InnerObject []{new InnerObject(), new InnerObject{Value1 = "element"}, new InnerObject(), } }; var validator = new ObjectValidator(); var result = validator.Validate(new[] {objectToValidate}, null).ToArray(); Assert.IsTrue(result.Any()); Assert.AreEqual(2, result.Length); }
public void PropertyShouldNotAllowNullExpression() { // arrange var validator = new ObjectValidator<IComponent>(); Expression<Func<IComponent, ISite>> propertyExpression = null; // act var ex = Assert.Throws<ArgumentNullException>( () => validator.Property( propertyExpression ) ); // assert Assert.Equal( "propertyExpression", ex.ParamName ); }
public void PropertyShouldReturnSameBuilderForExpression() { // arrange var validator = new ObjectValidator<IComponent>(); // act var expected = validator.Property( c => c.Site ); var actual = validator.Property( c => c.Site ); // assert Assert.Same( expected, actual ); }
public void ShouldValidateLargeArrays() { const int length = 1000000; var objectToValidate = new InnerObject[length]; for (int i = 0; i < length; i++) { objectToValidate[i]=new InnerObject(); } var validator = new ObjectValidator(); var result = validator.Validate(new[] { objectToValidate }, null).ToArray(); Assert.IsTrue(result.Any()); Assert.AreEqual(length, result.Length); }
public void ValidateObjectShouldNotAllowNullInstance() { // arrange IComponent instance = null; var objectValidator = new ObjectValidator<IComponent>(); IObjectValidator<IComponent> validatorOfT = objectValidator; IObjectValidator validator = objectValidator; // act var ex1 = Assert.Throws<ArgumentNullException>( () => validatorOfT.ValidateObject( instance ) ); var ex2 = Assert.Throws<ArgumentNullException>( () => validator.ValidateObject( instance ) ); // assert Assert.Equal( "instance", ex1.ParamName ); Assert.Equal( "instance", ex2.ParamName ); }
private bool Validate(IValidatableObject movie) { // for lab 2 below // var validatior = new ObjectValidator (); var results = ObjectValidator.TryValidateObject(movie); if (results.Count() > 0) { //if (!String.IsNullOrEmpty (message)) foreach (var result in results) { MessageBox.Show(this, result.ErrorMessage, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); } ; return(false); } ; return(true); }
public void Validate_ValidatorIsRegisteredAndInstanceIsNotValid_ReturnProperlyErrorMesssage() { var instance = new object(); var validationResult = new ValidationResult(new List <ValidationFailure> { new ValidationFailure("prop", "error") }); var objectValidator = new ObjectValidator(validationResult); var validators = new List <IValidator> { new StringValidator(), objectValidator }; var validationProcessor = new ValidationProcessor(validators); var validationError = validationProcessor.Validate(instance).ValidationErrors.SingleOrDefault(e => true); Assert.AreEqual(string.Format("[ValidationError][Property='{0}'][AttemptedValue='{1}'][Message='{2}']", validationResult.Errors[0].PropertyName, validationResult.Errors[0].AttemptedValue, validationResult.Errors[0].ErrorMessage), validationError.Message); }
public ActionResult Add(CharacterModel character) { character.uniqueName = NameCheck(character.Name); ObjectValidator.TryValidateFullObject(character).ForEach(x => ModelState.AddModelError("", x.ErrorMessage)); if (ModelState.IsValid) { try { character.Id = s_characters.Add(character.Convert()).Id; return(RedirectToAction(nameof(CharacterSheet), new { id = character.Id })); } catch (Exception e) { ModelState.AddModelError("", e.Message); }; } ; return(View(character)); }
/// <summary>Adds a movie.</summary> /// <param name="movie">The movie to add.</param> /// <returns>The added movie.</returns> /// <exception cref="ArgumentNullException"><paramref name="movie"/> is <see langword="null"/>.</exception> /// <exception cref="ValidationException"><paramref name="movie"/> is invalid.</exception> /// <exception cref="ArgumentException">A movie with the same title already exists.</exception> public Movie Add(Movie movie) { //Validate if (movie == null) { throw new ArgumentNullException(nameof(movie)); } ObjectValidator.ValidateObject(movie); //Movie cannot already exist var existing = FindByTitleCore(movie.Title); if (existing != null) { throw new ArgumentException("Movie with same title already exists.", nameof(movie)); } //Create the new movie return(AddCore(movie)); }
private void DequeueInvalidTargets() { object target = null; while (this.targetQueue.Count > 0 && target == null) { target = this.targetQueue[QueueHeadIndex]; var unityObject = target as UnityEngine.Object; if (unityObject != null && ObjectValidator.Validate(unityObject)) { // We're reached a non-disposed and active target. return; } // Discard the target. this.targetQueue.RemoveAt(QueueHeadIndex); } }
public static async Task <TelimenaPackageInfo> GetToolkitUpdateInfo(IProgramsUnitOfWork unitOfWork, Program program, UpdateRequest request, string maximumSupportedToolkitVersion) { ObjectValidator.Validate(() => Version.TryParse(request.ToolkitVersion, out _) , new ArgumentException($"[{request.ToolkitVersion}] is not a valid version string")); List <TelimenaPackageInfo> packages = (await unitOfWork.ToolkitData.GetPackagesNewerThan(request.ToolkitVersion).ConfigureAwait(false)) .OrderByDescending(x => x.Version, new TelimenaVersionStringComparer()).ToList(); if (!request.AcceptBeta) { packages.RemoveAll(x => x.IsBeta); } if (packages.Any(x => x.IntroducesBreakingChanges)) { packages.Reverse(); List <TelimenaPackageInfo> listOfCompatiblePackages = new List <TelimenaPackageInfo>(); foreach (TelimenaPackageInfo package in packages) { if (!package.IntroducesBreakingChanges) { listOfCompatiblePackages.Add(package); } else { if (maximumSupportedToolkitVersion.IsNewerOrEqualVersion(package.Version)) { listOfCompatiblePackages.Add(package); } else //at this point a breaking package is not supported by the program, so time to break the loop - no point checking even newer ones { break; } } } return(listOfCompatiblePackages.LastOrDefault()); } return(packages.FirstOrDefault()); }
public void Save() { var validator = new ObjectValidator(typeof(SupplementCycleDefinitionDTO)); if (definition.Profile == null) { definition.Profile = UserContext.Current.CurrentProfile; } var result = validator.Validate(definition); if (!result.IsValid) { BAMessageBox.ShowValidationError(result.ToBAResults()); return; } parentView.RunAsynchronousOperation(delegate { try { context.CycleDefinition = ServiceManager.SaveSupplementsCycleDefinition(definition); //todo:add here clone of saved definition to the cache SupplementsCycleDefinitionsReposidory.Instance.Update(context.CycleDefinition.StandardClone()); parentView.SynchronizationContext.Send(delegate { Fill(parentView, context); IsModified = false; }, null); } catch (ValidationException ex) { parentView.SynchronizationContext.Send(state => BAMessageBox.ShowValidationError(ex.Results), null); } catch (Exception ex) { parentView.SynchronizationContext.Send(state => ExceptionHandler.Default.Process(ex, SuplementsEntryStrings.Exception_SupplementsCycleDefinitionEditorViewModel_Save, ErrorWindow.EMailReport), null); } }, v => { updateButtons(v.State == OperationState.Started); }); }
private void OnSave(object sender, EventArgs e) { if (!ValidateChildren()) { return; } //var movie = new Movie(); //movie.Name = _txtName.Text; //movie.Description = _txtDescription.Text; //movie.ReleaseYear = GetInt32(_txtReleaseYear); //movie.RunLength = GetInt32(_txtRunLength); //movie.IsOwned = _chkOwned.Checked; //Initializer syntax var movie = new Movie() { Name = _txtName.Text, Description = _txtDescription.Text, ReleaseYear = GetInt32(_txtReleaseYear), RunLength = GetInt32(_txtRunLength), IsOwned = _chkOwned.Checked, }; var results = ObjectValidator.TryValidate(movie); foreach (var result in results) //if (results.Count > 0) { // var firstMessage = results[0]; MessageBox.Show(this, result.ErrorMessage, "Validation Failed", MessageBoxButtons.OK); return; } ; Movie = movie; DialogResult = DialogResult.OK; Close(); }
public Product Update(Product product, out string message) { message = ""; if (product == null) { message = "Product cannot be null."; return(null); } ; //Validate product var errors = ObjectValidator.Validate(product); if (errors.Count() > 0) { message = errors.ElementAt(0).ErrorMessage; return(null); } ; //Verify Unique product var existing = GetProductByNameCore(product.Name); if (existing != null && existing.Id != product.Id) { message = "Product already exists."; return(null); } ; //Find Existing existing = existing ?? GetCore(product.Id); if (existing == null) { message = "Product not found"; return(null); } return(UpdateCore(product)); }
/// <summary>Updates a product.</summary> /// <param name="product">The product to update.</param> /// <returns>The updated product.</returns> public Product Update(Product product) { if (product == null) { throw new ArgumentNullException(nameof(product)); } var results = ObjectValidator.TryValidateObject(product); if (results.Count() > 0) { throw new ValidationException(results.FirstOrDefault().ErrorMessage); } //Get existing product var existing = GetCore(product.Id); return(UpdateCore(existing, product)); }
public async Task <List <TelimenaPackageInfo> > GetPackagesNewerThan(string version) { ObjectValidator.Validate(() => Version.TryParse(version, out _), new ArgumentException($"[{version}] is not a valid version string")); TelimenaPackageInfo current = await this.TelimenaPortalContext.ToolkitPackages.Where(x => x.Version == version).OrderByDescending(x => x.Id).FirstOrDefaultAsync().ConfigureAwait(false); List <TelimenaPackageInfo> packages; if (current != null) { packages = (await this.TelimenaPortalContext.ToolkitPackages.Where(x => x.UploadedDate > current.UploadedDate).ToListAsync().ConfigureAwait(false)) .OrderByDescending(x => x.Version, new TelimenaVersionStringComparer()).ThenByDescending(x => x.Id).ToList(); } else { packages = (await this.TelimenaPortalContext.ToolkitPackages.ToListAsync().ConfigureAwait(false)).Where(x => Utils.VersionComparison.Extensions.IsNewerVersionThan(x.Version, version)) .OrderByDescending(x => x.Version, new TelimenaVersionStringComparer()).ThenByDescending(x => x.Id).ToList(); } return(this.GetUniquePackages(packages)); }
/// <summary>Updates a product.</summary> /// <param name="product">The product to update.</param> /// <returns>The updated product.</returns> /// <exception cref="ArgumentNullException"><paramref name="product"/> is null.</exception> /// <exception cref="ValidationException"><paramref name="product"/> is invalid.</exception> /// <exception cref="Exception">Product not found.</exception> public Product Update(Product product) { // Validate if (product == null) { throw new ArgumentNullException(nameof(product)); } //if (!ObjectValidator.TryValidate(product, out var errors)) // throw new ArgumentException("Product is invalid.", nameof(product)); ObjectValidator.Validate(product); //Use throw expression //Get existing product var existing = GetCore(product.Id) ?? throw new Exception("Product not found."); //if (existing == null) // throw new Exception("Product not found."); return(UpdateCore(existing, product)); }
private void LoadConfiguration(IActivatingEventArgs <object> handler) { var settings = handler.Instance; var sectionName = GetSectionName(settings); if (sectionName != null) { // Lookup settings with the specified section name. var configuration = handler.Context.Resolve <IConfiguration>(); var section = configuration.GetSection(sectionName); // Bind the configuration to the settings instance. section.Bind(settings); } // Determine if the settings object can be validated. var validator = new ObjectValidator(settings); var validationResult = new ValidationResult(settings, validator); validationResult.ThrowIfInvalid(); }
private bool Validate(IValidatableObject movie) { //var message = movie.Validate(); //var context = new ValidationContext (movie); //var results = movie.Validate (context); var results = ObjectValidator.TryValidateObject(movie); if (results.Count() > 0) //if (results.Count () > 0) { foreach (var result in results) { MessageBox.Show(this, result.ErrorMessage, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); } ; return(false); } return(true); }
/// <summary>Adds a product.</summary> /// <param name="product">The product to add.</param> /// <returns>The added product.</returns> public Product Add(Product product) { // Check arguments if (product == null) { throw new ArgumentException(nameof(product)); } //Validate product ObjectValidator.Validate(product); var existing = FindByName(product.Name); if (existing != null) { throw new Exception("Game must be unique."); } //Emulate database by storing copy return(AddCore(product)); }
/// <summary>Adds a product.</summary> /// <param name="product">The product to add.</param> /// <returns>The added product.</returns> public Product Add(Product product) { if (product == null) { throw new ArgumentNullException(nameof(product)); } ObjectValidator.Validate(product); //products must be unique var existing = FindByName(product.Name); if (existing != null) { throw new Exception("Product must be unique."); } //Emulate database by storing copy return(AddCore(product)); }
//OnSave Event Handler, validates at business and UI level private void OnSave(object sender, EventArgs e) { if (!ValidateChildren()) { return; } var contact = Savedata(); try { ObjectValidator.Validate(contact); } catch (ValidationException) { MessageBox.Show(this, "Contact not valid.", "Error", MessageBoxButtons.OK); return; } CurrentContact = contact; DialogResult = DialogResult.OK; Close(); }
/// <summary> /// Updates an already existing movie /// </summary> /// <param name="movie">movie to update</param> /// <param name="message">error message</param> /// <returns>updated movie</returns> public Movie Update(Movie movie, out string message) { message = ""; //check for null if (movie == null) { message = "Movie cannot be null."; return(null); } //validate movie with IValidatableObject var errors = ObjectValidator.Validate(movie); if (errors.Count() > 0) { //get first error (element at 0) message = errors.ElementAt(0).ErrorMessage; return(null); } //verify movie is unique var existing = GetMovieByTitleCore(movie.Title); if (existing != null && existing.Id != movie.Id) { message = "Movie already exists."; return(null); } //find existing existing = existing ?? GetCore(movie.Id); if (existing == null) { message = "Product not found."; return(null); } return(UpdateCore(movie)); }
/// <summary>Adds a product.</summary> /// <param name="product">The product to add.</param> /// <returns>The added product.</returns> public Product Add(Product product) { //TODO: Check arguments //Check null if (product == null) { throw new ArgumentNullException("product"); } //Check invalid if (product.Name == null) { throw new ArgumentNullException("name"); } else if (product.Name == "") { throw new ArgumentException("Name cannot be empty"); } //Throw exception when adding a product with same name //var existing = GetCore(product.Id); //if (!(String.IsNullOrEmpty(existing.Name))) //{ // if (String.Compare(product.Name, existing.Name, true) == 0) // throw new ArgumentNullException("This product already added."); //} if (product.Price < 0) { throw new ArgumentOutOfRangeException("Price must be greater or equal to 0"); } //TODO: Validate product ObjectValidator.Validate(product); //Emulate database by storing copy return(AddCore(product)); }
/// <summary>Updates the movie.</summary> /// <param name="movie">The movie to update</param> /// <returns>The updated movie</returns> public Movie Update(Movie movie) { if (movie == null) { return(null); } //Validate using IValidatable Object if (!ObjectValidator.TryValidate(movie, out var errors)) { return(null); } var existing = GetCore(movie.Id); if (existing == null) { return(null); } return(UpdateCore(existing, movie)); }
public Release(DateTime ReleasedAt, String Sha1String, ReleaseDownloadUrl ReleaseDownloadUrl, ReleaseFileName ReleaseFileName, ModVersion ModVersion, FactorioVersion FactorioVersion, List <Dependency> Dependencies) { DateTimeValidator.ValidateRequiredDateTimeBeforePresent(ReleasedAt, nameof(ReleasedAt)); ObjectValidator.ValidateRequiredObject(Sha1String, nameof(Sha1String)); ObjectValidator.ValidateRequiredObject(ReleaseDownloadUrl, nameof(ReleaseDownloadUrl)); ObjectValidator.ValidateRequiredObject(ReleaseFileName, nameof(ReleaseFileName)); ObjectValidator.ValidateRequiredObject(ModVersion, nameof(ModVersion)); ObjectValidator.ValidateRequiredObject(FactorioVersion, nameof(FactorioVersion)); ListValidator.ValidateRequiredListNotEmpty(Dependencies, nameof(Dependencies)); Regex sha1CaptureRegex = new Regex(Release.Sha1CapturePattern); Match match = sha1CaptureRegex.Match(Sha1String); if (!match.Success) { throw new ArgumentException($"Unable to parse \"{Sha1String}\" to a valid SHA-1 hash due to formatting.", "Sha1String"); } String sha1 = match.Groups[1].Value; if (sha1.Length != Sha1Length) { throw new ArgumentException($"Unable to parse \"{Sha1String}\" to a valid SHA-1 hash due to length. The SHA-1 hash must have a length of exactly {Release.Sha1Length} characters.", "Sha1String"); } if (ModVersion != ReleaseFileName.ModVersion) { throw new ArgumentException("The specified release file name version does not match the specified release version.", "ReleaseFileName"); } this.ReleasedAt = ReleasedAt; this.ReleaseDownloadUrl = new ReleaseDownloadUrl(ReleaseDownloadUrl); this.ReleaseFileName = new ReleaseFileName(ReleaseFileName); this.Sha1 = sha1; this.ModVersion = new ModVersion(ModVersion); this.FactorioVersion = new FactorioVersion(FactorioVersion); // TODO: We may want to write an .AddDependency() method that validates that the dependency we're adding isn't for the release/mod itself. That would generate a circular dependency. this.Dependencies = Dependencies.ConvertAll(dependency => new Dependency(dependency)); }
public async Task <ProgramUpdatePackageInfo> StorePackageAsync(Program program, string packageName, Stream fileStream, string supportedToolkitVersion, bool isBeta, string releaseNotes, IFileSaver fileSaver) { var versions = await this.streamVersionReader.GetVersionsFromStream(packageName, fileStream , program.PrimaryAssembly.GetFileName()).ConfigureAwait(false); fileStream = await Utilities.ZipTheStreamIfNeeded(packageName, fileStream).ConfigureAwait(false); if (versions.toolkitVersion != null) { supportedToolkitVersion = versions.toolkitVersion; } ObjectValidator.Validate(() => Version.TryParse(supportedToolkitVersion, out Version _) , new InvalidOperationException($"[{supportedToolkitVersion}] is not a valid version string")); ObjectValidator.Validate(() => this.TelimenaPortalContext.ToolkitPackages.Any(x => x.Version == supportedToolkitVersion) , new ArgumentException($"There is no toolkit package with version [{supportedToolkitVersion}]")); ProgramUpdatePackageInfo pkg = await this.TelimenaPortalContext.UpdatePackages.Where(x => x.ProgramId == program.Id && x.Version == versions.appVersion #pragma warning disable 618 && x.SupportedToolkitVersion == supportedToolkitVersion).OrderByDescending(x => x.Id).FirstOrDefaultAsync().ConfigureAwait(false); #pragma warning restore 618 if (pkg == null) { pkg = new ProgramUpdatePackageInfo(packageName, program.Id, versions.appVersion, fileStream.Length, supportedToolkitVersion); this.TelimenaPortalContext.UpdatePackages.Add(pkg); } pkg.UpdateContentAndMetadata(isBeta, releaseNotes); await fileSaver.SaveFile(pkg, fileStream, this.containerName).ConfigureAwait(false); return(pkg); }
public static IList <Company> ReadCsvFile1() { Console.WriteLine("Running ReadCsvFile1"); var parser = new CsvFileParser(Common.CsvDataPath); var fileErrors = new Dictionary <int, IList <string> >(); var validator = new ObjectValidator(); //parser.Delimiters // can adjust the delimiters //parser.FixedWidths // can parse fixed widths var rowIndex = parser.RowStart; var companies = new List <Company>(); foreach (dynamic row in parser.ParseFile()) { var errors = new List <string>(); var rowObj = FileIOUtilities.MapObject <Company>(row, rowIndex, validator, null, ref errors); validator.TryValidate(rowObj, ref errors); companies.Add(rowObj); if (errors.Count > 0) { fileErrors.Add(rowIndex, errors); } rowIndex++; } foreach (var errs in fileErrors) { foreach (var err in errs.Value) { Console.WriteLine("Line:{0}, Error: {1}", errs.Key, err); } } return(companies); }
/// <summary>Adds a product.</summary> /// <param name="product">The product to add.</param> /// <returns>The added product.</returns> public Product Add(Product product) { if (product == null) { throw new ArgumentException(nameof(product)); } var results = ObjectValidator.TryValidateObject(product); if (results.Count() > 0) { throw new ValidationException(results.FirstOrDefault().ErrorMessage); } var existing = GetCore(product.Id); if (existing != null) { throw new InvalidOperationException("Id must be unique."); } return(AddCore(product)); }
public void ValidatorTests_Error() { string input = "THEVALUE"; string nullInput = null; Assert.That(() => ObjectValidator.Validate(() => int.TryParse(input, out int _), () => throw new InvalidOperationException($"Error to throw: [{input}]")), Throws.InvalidOperationException.With.Message.EqualTo("Error to throw: [THEVALUE]")); Assert.That(() => ObjectValidator.Validate(() => int.TryParse(nullInput, out int _), () => throw new InvalidOperationException($"Error to throw: [{nullInput}]")), Throws.InvalidOperationException.With.Message.EqualTo("Error to throw: []")); Assert.That(() => ObjectValidator.Validate(() => int.TryParse(input, out int _), new InvalidOperationException("Error to throw")), Throws.InvalidOperationException.With.Message.EqualTo("Error to throw")); Assert.That(() => ObjectValidator.Validate(() => int.TryParse(nullInput, out int _), new InvalidOperationException($"Error to throw: [{nullInput}]")), Throws.InvalidOperationException.With.Message.EqualTo("Error to throw: []")); Assert.That(() => ObjectValidator.Validate(() => this.MyOwnValidation("asd", 3, 2M, null), () => throw new InvalidOperationException($"Error to throw: [{input}]")), Throws.InvalidOperationException.With.Message.EqualTo("Error to throw: [THEVALUE]")); }
public Language(Language original) { ObjectValidator.ValidateRequiredObject(original, nameof(original)); if (original.Id != null) { this.Id = original.Id; } if (original.EnglishName != null) { this.EnglishName = original.EnglishName; } if (original.LanguageTag != null) { this.LanguageTag = original.LanguageTag; } if (original.Culture != null) { this.Culture = original.Culture; } this.IsDefault = original.IsDefault; this.ModTitles = original.ModTitles != null?original.ModTitles.ConvertAll(title => new ModTitle(title)) : null; }
/// <summary>Adds a product.</summary> /// <param name="product">The product to add.</param> /// <returns>The added product.</returns> public Product Add(Product product) { //TODO: Check arguments if (product == null) { throw new ArgumentNullException("product"); } ObjectValidator.TryValidate(product); //TODO: Validate product try { //_database.Add( AddCore(product); } catch (Exception e) { throw new Exception("Add failed", e); }; //Emulate database by storing copy return(AddCore(product)); }
/// <summary>Adds a product.</summary> /// <param name="product">The product to add.</param> /// <returns>The added product.</returns> public Product Add(Product product) { //TODO: Check arguments if (product.Name == null) { throw new ArgumentNullException(nameof(product)); } else if (product.Name == "") { throw new ArgumentException(nameof(product)); } if (product == null) { throw new ArgumentNullException(nameof(product)); } //TODO: Validate product ObjectValidator.Validate(product); //Emulate database by storing copy return(AddCore(product)); }
/// <summary>Updates a product.</summary> /// <param name="product">The product to update.</param> /// <returns>The updated product.</returns> public Product Update(Product product) { // Validate if (product == null) { return(null); } if (!ObjectValidator.TryValidate(product, out var errors)) { return(null); } //Get existing product var existing = GetCore(product.Id); if (existing == null) { return(null); } return(UpdateCore(existing, product)); }
public APIReturn Create(Marca toCreate) { try { result = new APIReturn { Content = JsonConvert.SerializeObject(rep.Create(toCreate)), Message = string.IsNullOrEmpty(ObjectValidator.MarcaValidator(toCreate)) ? "Adicionado com sucesso" : "Dados incorretos", ErrorMessage = ObjectValidator.MarcaValidator(toCreate) }; } catch (Exception ex) { result = new APIReturn { StatusCode = 500, Message = "Ocorreu um erro inesperado ao tendar criar o registro", ErrorMessage = ex.Message }; } return(result); }
public void ValidateObjectShouldValidateSpecifiedProperties() { // arrange var instance = new Mock<IComponent>().Object; var validator = new ObjectValidator<IComponent>(); var propertyNames = new[] { "Site" }; validator.Property( c => c.Site ).Required(); // act var actual = validator.ValidateObject( instance, propertyNames ); // assert Assert.Equal( 1, actual.Count ); Assert.Equal( "Site", actual[0].MemberNames.Single() ); }
public void ValidatePropertyShouldNotAllowNullOrEmptyPropertyName( string propertyName ) { // arrange var validator = new ObjectValidator<IComponent>(); object value = null; // act var ex = Assert.Throws<ArgumentNullException>( () => validator.ValidateProperty( propertyName, value ) ); // assert Assert.Equal( "propertyName", ex.ParamName ); }
public void ValidatePropertyShouldReturnExpectedResult() { // arrange var validator = new ObjectValidator<IComponent>(); validator.Property( c => c.Site ).Required(); // act var actual = validator.ValidateProperty( "Site", null ); // assert Assert.Equal( 1, actual.Count ); Assert.Equal( "Site", actual[0].MemberNames.Single() ); }
public void ValidateObjectShouldNotAllowNullPropertyNames() { // arrange var instance = new Mock<IComponent>().Object; IEnumerable<string> propertyNames = null; var objectValidator = new ObjectValidator<IComponent>(); IObjectValidator<IComponent> validatorOfT = objectValidator; IObjectValidator validator = objectValidator; // act var ex1 = Assert.Throws<ArgumentNullException>( () => validatorOfT.ValidateObject( instance, propertyNames ) ); var ex2 = Assert.Throws<ArgumentNullException>( () => validator.ValidateObject( instance, propertyNames ) ); // assert Assert.Equal( "propertyNames", ex1.ParamName ); Assert.Equal( "propertyNames", ex2.ParamName ); }