//--------------------------------------------------- //private helpers private ISuccessOrErrors SetupRestOfDto(IGenericServicesDbContext context, Post post = null) { var db = context as SampleWebAppDb; if (db == null) { throw new NullReferenceException("The IDbContextWithValidation must be linked to TemplateWebAppDb."); } var status = SuccessOrErrors.Success("OK if no errors set"); //now we sort out the blogger var errMsg = SetBloggerIdFromDropDownList(db); if (errMsg != null) { status.AddNamedParameterError("Bloggers", errMsg); } //now we sort out the tags errMsg = ChangeTagsBasedOnMultiSelectList(db, post); if (errMsg != null) { status.AddNamedParameterError("UserChosenTags", errMsg); } return(status); }
/// <summary> /// This extension will undertake a SaveChangesAsync but will catch any validation errors /// or specific SqlException specified in ServicesConfiguration.SqlErrorDict and return /// them as errors /// </summary> /// <param name="db"></param> /// <returns>Task containing status saying whether SaveChanges was successful or not. If not then holds errors</returns> public static async Task <ISuccessOrErrors> SaveChangesWithCheckingAsync(this IGenericSaveChanges db) { var result = new SuccessOrErrors(); var numChanges = 0; try { numChanges = await db.SaveChangesAsync().ConfigureAwait(false); //then update it } catch (DbEntityValidationException ex) { return(result.SetErrors(ex.EntityValidationErrors.SelectMany( x => x.ValidationErrors.Select(y => new ValidationResult(y.ErrorMessage, new[] { y.PropertyName }))))); } catch (DbUpdateException ex) { var decodedErrors = TryDecodeDbUpdateException(ex); if (decodedErrors == null) { throw; //it isn't something we understand } return(result.SetErrors(decodedErrors)); } return(result.SetSuccessMessage("Successfully added or updated {0} items", numChanges)); }
public async Task <ISuccessOrErrors <TDto> > CreateOrUpdateAsync <TDto>(TDto dto, ActionFlags actions) where TDto : DtoBase <TContext, TEntity, TDto>, new() { var status = SuccessOrErrors <TDto> .SuccessWithResult(null, "Success"); status = validateDtoState(status, dto, actions); if (status.IsValid) { var entity = DTORepositoryContainer.Mapper.Map <TEntity>(dto, opts => { opts.Items["DbContext"] = dbContext; opts.Items["CurrentStatus"] = status; opts.Items["ActionFlags"] = actions; }); if (status.IsValid) { await dbContext.SaveChangesAsync(); DTORepositoryContainer.Mapper.Map <TEntity, TDto>(entity, dto, opts => { opts.Items["ActionFlags"] = actions; opts.Items["DbContext"] = dbContext; }); return(status.SetSuccessWithResult(dto, "Success")); } } return(status); }
/// <summary> /// This is used in an update. It copies only the properties in TDto that do not have the [DoNotCopyBackToDatabase] on them. /// You can override this if you need a more complex copy /// </summary> /// <param name="context"></param> /// <param name="source"></param> /// <param name="destination"></param> /// <return>Task containing status. destination is only valid if status.IsValid</return> protected internal virtual async Task <ISuccessOrErrors> UpdateDataFromDtoAsync(IGenericServicesDbContext context, TDto source, TEntity destination) { var mapper = GenericServicesConfig.AutoMapperConfigs[CreateDictionaryKey <TDto, TEntity>()].CreateMapper(); mapper.Map(source, destination); return(SuccessOrErrors.Success("Successful copy of data")); }
/// <summary> /// This will take an IQueryable request and add single on the end to realise the request. /// It catches if the single didn't produce an item /// </summary> /// <typeparam name="T"></typeparam> /// <param name="request">An IQueryable request with a filter that yeilds a single item</param> /// <param name="methodName">Do not specify. System fills this in with the calling method</param> /// <returns>Returns status. If Valid then status.Result is the single item, otherwise an new, empty class</returns> public static ISuccessOrErrors <T> RealiseSingleWithErrorChecking <T>(this IQueryable <T> request, [CallerMemberName] string methodName = "") where T : class, new() { var status = new SuccessOrErrors <T>(new T(), "we return empty class if it fails"); try { var result = request.SingleOrDefault(); if (result == null) { status.AddSingleError( "We could not find an entry using that filter. Has it been deleted by someone else?"); } else { status.SetSuccessWithResult(result, "successful"); } } catch (Exception ex) { if (GenericServicesConfig.RealiseSingleExceptionMethod == null) { throw; //nothing to catch error } var errMsg = GenericServicesConfig.RealiseSingleExceptionMethod(ex, methodName); if (errMsg != null) { status.AddSingleError(errMsg); } else { throw; //do not understand the error so rethrow } } return(status); }
private async Task <ISuccessOrErrors> DeleteBloggerWithPost(IGenericServicesDbContext db, Post post) { var blogger = await db.Set <Blog>().FindAsync(post.BlogId); db.Set <Blog>().Remove(blogger); return(SuccessOrErrors.Success("It was fine.")); }
private ISuccessOrErrors DeleteBloggerWithPost(IGenericServicesDbContext db, SimplePostDto post) { var blogger = db.Set <Blog>().SingleOrDefault(x => x.Name == post.BloggerName); db.Set <Blog>().Remove(blogger); return(SuccessOrErrors.Success("It was fine.")); }
/// <summary> /// This extension will undertake a SaveChangesAsync but will catch any validation errors /// or specific SqlException specified in ServicesConfiguration.SqlErrorDict and return /// them as errors /// </summary> /// <param name="db"></param> /// <returns>Task containing status saying whether SaveChanges was successful or not. If not then holds errors</returns> public static async Task <ISuccessOrErrors> SaveChangesWithCheckingAsync(this DbContext db) { var result = new SuccessOrErrors(); var numChanges = 0; try { numChanges = await db.SaveChangesAsync().ConfigureAwait(false); //then update it } catch (ValidationException ex) { var validationResults = new List <ValidationResult>(); validationResults.Add(ex.ValidationResult); return(result.SetErrors(validationResults)); } catch (DbUpdateException ex) { var decodedErrors = TryDecodeDbUpdateException(ex); if (decodedErrors == null) { throw; //it isn't something we understand } return(result.SetErrors(decodedErrors)); } return(result.SetSuccessMessage("Successfully added or updated {0} items", numChanges)); }
protected override ISuccessOrErrors <Post> CreateDataFromDto(IGenericServicesDbContext context, DetailPostDto source) { var status = SetupRestOfDto(context); return(status.IsValid ? base.CreateDataFromDto(context, this) : SuccessOrErrors <Post> .ConvertNonResultStatus(status)); }
protected internal override async Task <ISuccessOrErrors <Post> > CreateDataFromDtoAsync(IGenericServicesDbContext context, DetailPostDtoAsync source) { var status = await SetupRestOfDto(context); return(status.IsValid ? await base.CreateDataFromDtoAsync(context, this) : SuccessOrErrors <Post> .ConvertNonResultStatus(status)); }
public void Test02UnsetStatusHasNoErrorsOk() { //SETUP var status = new SuccessOrErrors <string>(); //ATTEMPT //VERIFY status.HasErrors.ShouldEqual(false); }
/// <summary> /// This is used to update the SalesOrderHeader total when a line item is deleted /// </summary> /// <param name="db"></param> /// <param name="lineItemBeingDeleted"></param> /// <returns></returns> public static ISuccessOrErrors UpdateSalesOrderHeader(IGenericServicesDbContext db, SalesOrderDetail lineItemBeingDeleted) { var salesOrderHeader = db.Set <SalesOrderHeader>().Include(x => x.SalesOrderDetails).Single(x => x.SalesOrderID == lineItemBeingDeleted.SalesOrderID); salesOrderHeader.SubTotal = salesOrderHeader.SalesOrderDetails.Where( x => x.SalesOrderDetailID != lineItemBeingDeleted.SalesOrderDetailID).Sum(x => x.LineTotal); return(SuccessOrErrors.Success("Removed Ok")); }
public void Test17CheckConvertIntToAnotherResultStatusFail() { //SETUP //ATTEMPT var ex = Assert.Throws <ArgumentNullException>(() => SuccessOrErrors <string> .ConvertNonResultStatus("string")); //VERIFY ex.Message.ShouldStartWith("The status parameter was not derived from a type thta supported ISuccessOrErrors."); }
public void Test02UnsetStatusHasNoErrorsOk() { //SETUP var status = new SuccessOrErrors<string>(); //ATTEMPT //VERIFY status.HasErrors.ShouldEqual(false); }
public void Test01DefaultsToNotValidOk() { //SETUP var status = new SuccessOrErrors <string>(); //ATTEMPT //VERIFY status.IsValid.ShouldEqual(false); status.ToString().ShouldEqual("Not currently setup"); }
public void Test03DefaultsAccessErrorsFailsOk() { //SETUP var status = new SuccessOrErrors <string>(); //ATTEMPT var ex = Assert.Throws <InvalidOperationException>(() => status.Errors.Any()); //VERIFY ex.Message.ShouldEqual("The status must have an error set or the success message set before you can access errors."); }
public void Test01DefaultsToNotValidOk() { //SETUP var status = new SuccessOrErrors<string>(); //ATTEMPT //VERIFY status.IsValid.ShouldEqual(false); status.ToString().ShouldEqual("Not currently setup"); }
public void Test03DefaultsAccessErrorsFailsOk() { //SETUP var status = new SuccessOrErrors<string>(); //ATTEMPT var ex = Assert.Throws<InvalidOperationException>(() => status.Errors.Any()); //VERIFY ex.Message.ShouldEqual("The status must have an error set or the success message set before you can access errors."); }
public async Task <ISuccessOrErrors> DeleteAsync(params object[] identifiers) { var status = SuccessOrErrors.Success("Delete success"); var dbSet = this.dbContext.Set <TEntity>(); var entity = await dbSet.FindAsync(identifiers); dbSet.Remove(entity); await dbContext.SaveChangesAsync(); return(status); }
public ISuccessOrErrors Delete(params object[] identifiers) { var status = SuccessOrErrors.Success("Delete success"); var dbSet = this.dbContext.Set <TEntity>(); var entity = dbSet.Find(identifiers); dbSet.Remove(entity); dbContext.SaveChanges(); return(status); }
public void Test50SingleErrorGetAllErrorsOk() { //SETUP var status = new SuccessOrErrors(); //ATTEMPT status.AddSingleError("This was {0}.", "bad"); var str = status.GetAllErrors(); //VERIFY str.ShouldEqual("This was bad."); }
public void Test21CombineUnsetStatusHasNoErrorsOk() { //SETUP var status1 = new SuccessOrErrors <string>(); var status2 = new SuccessOrErrors(); //ATTEMPT status1.Combine(status2); //VERIFY status1.HasErrors.ShouldEqual(false); }
private ISuccessOrErrors <SqlTableInfo> GetSqlTableDataFromClass(Type efClassType) { ISuccessOrErrors <SqlTableInfo> status = new SuccessOrErrors <SqlTableInfo>(); var combinedName = GetEfTableDataFromClass(efClassType).CombinedName; SqlTableInfo sqlTable; if (!_sqlInfoDict.TryGetValue(combinedName, out sqlTable)) { return(status.AddSingleError("Missing SQL Table: Could not find the SQL table called {0}.", combinedName)); } return(status.SetSuccessWithResult(sqlTable, "All OK")); }
public void Check05CheckAssignNonResultOk() { //SETUP ISuccessOrErrors status = new SuccessOrErrors <string>(); //ATTEMPT ((SuccessOrErrors <string>)status).SetSuccessWithResult("The result", "This is a message"); //VERIFY status.IsValid.ShouldEqual(true); ((SuccessOrErrors <string>)status).Result.ShouldEqual("The result"); }
public void Check03SetSuccessViaStaticOk() { //SETUP //ATTEMPT var status = SuccessOrErrors <string> .SuccessWithResult("The result", "This is a message"); //VERIFY status.IsValid.ShouldEqual(true); status.Result.ShouldEqual("The result"); status.SuccessMessage.ShouldEqual("This is a message"); }
public void Check04UpdateSuccessMessageOk() { //SETUP var status = SuccessOrErrors <string> .SuccessWithResult("The result", "This is a message"); //ATTEMPT status.UpdateSuccessMessage("New success message"); //VERIFY status.IsValid.ShouldEqual(true); status.SuccessMessage.ShouldEqual("New success message"); }
public void Test51SingleErrorAsHtmlOk() { //SETUP var status = new SuccessOrErrors(); //ATTEMPT status.AddSingleError("This was {0}.", "bad"); var html = status.ErrorsAsHtml(); //VERIFY html.ShouldEqual("<p>This was bad.</p>"); }
public void Check01SetErrorsNoResultOk() { //SETUP var status = new SuccessOrErrors <string>(); //ATTEMPT status.AddSingleError("This is an error"); //VERIFY status.IsValid.ShouldEqual(false); status.Result.ShouldEqual(null); }
public void Test52SingleParamErrorGetAllErrorsOk() { //SETUP var status = new SuccessOrErrors(); //ATTEMPT status.AddNamedParameterError("MyParameterName", "This was {0}.", "bad"); var str = status.GetAllErrors(); //VERIFY str.ShouldEqual("MyParameterName: This was bad."); }
public void Test35CombineBadStatusFail() { //SETUP var status1 = new SuccessOrErrors <string>(); var status2 = "hello"; //ATTEMPT var ex = Assert.Throws <ArgumentNullException>(() => status1.Combine(status2)); //VERIFY ex.Message.ShouldStartWith("The status parameter was not derived from a type that supported ISuccessOrErrors."); }
public void Test53SingleParamErrorAsHtmlOk() { //SETUP var status = new SuccessOrErrors(); //ATTEMPT status.AddNamedParameterError("MyParameterName", "This was {0}.", "bad"); var html = status.ErrorsAsHtml(); //VERIFY html.ShouldEqual("<p>MyParameterName: This was bad.</p>"); }
protected internal override async Task <ISuccessOrErrors <TEntity> > CreateDataFromDtoAsync(IGenericServicesDbContext context, TDto source) { using (new LogStartStop(this)) { if (_whereToFail.HasFlag(InstrumentedOpFlags.FailOnCreateDataFromDto)) { return(SuccessOrErrors <TEntity> .ConvertNonResultStatus(new SuccessOrErrors().AddSingleError("Flag was set to fail in CreateDataFromDto."))); } return(await base.CreateDataFromDtoAsync(context, source).ConfigureAwait(false)); } }
public void Test20CombineDefaultsToNotValidOk() { //SETUP var status1 = new SuccessOrErrors <string>(); var status2 = new SuccessOrErrors(); //ATTEMPT status1.Combine(status2); //VERIFY status1.IsValid.ShouldEqual(false); status1.ToString().ShouldEqual("Not currently setup"); }
public void Test05SetSuccessOk() { //SETUP var status = new SuccessOrErrors(); //ATTEMPT status.SetSuccessMessage("This was {0}.", "successful"); //VERIFY status.IsValid.ShouldEqual(true); status.HasErrors.ShouldEqual(false); status.HasWarnings.ShouldEqual(false); status.SuccessMessage.ShouldEqual("This was successful."); status.Errors.Count.ShouldEqual(0); }
public void Test04AddSingleErrorOk() { //SETUP var status = new SuccessOrErrors<string>(); //ATTEMPT status.AddSingleError("This was {0}.", "bad"); //VERIFY status.IsValid.ShouldEqual(false); status.HasErrors.ShouldEqual(true); status.SuccessMessage.ShouldEqual(""); status.Result.ShouldEqual(null); status.Errors.Count.ShouldEqual(1); status.Errors[0].ErrorMessage.ShouldEqual("This was bad."); status.Errors[0].MemberNames.Count().ShouldEqual(0); }
public ActionResult AjaxFormReturn(TestAjaxFormModel model) { if (!ModelState.IsValid) { //model errors so return errors return ModelState.ReturnModelErrorsAsJson(); } if (!model.ShouldFail) { return Json(new { SuccessMessage = "This was successful" }); } //else errors, so send back the errors var status = new SuccessOrErrors(); status.AddSingleError("The ShouldFail flag was set, which causes a service failure."); status.AddNamedParameterError("ShouldFail", "This should be false for this to work."); return status.ReturnErrorsAsJson(model); }
/// <summary> /// This extension will undertake a SaveChangesAsync but will catch any validation errors /// or specific SqlException specified in ServicesConfiguration.SqlErrorDict and return /// them as errors /// </summary> /// <param name="db"></param> /// <returns>Task containing status saying whether SaveChanges was successful or not. If not then holds errors</returns> public static async Task<ISuccessOrErrors> SaveChangesWithCheckingAsync(this IGenericSaveChanges db) { var result = new SuccessOrErrors(); var numChanges = 0; try { numChanges = await db.SaveChangesAsync().ConfigureAwait(false); //then update it } catch (DbEntityValidationException ex) { return result.SetErrors(ex.EntityValidationErrors.SelectMany( x => x.ValidationErrors.Select(y => new ValidationResult(y.ErrorMessage, new[] { y.PropertyName })))); } catch (DbUpdateException ex) { var decodedErrors = TryDecodeDbUpdateException(ex); if (decodedErrors == null) throw; //it isn't something we understand return result.SetErrors(decodedErrors); } return result.SetSuccessMessage("Successfully added or updated {0} items", numChanges); }
public void Test11CheckConvertResultToNormalStatusNotValidOk() { //SETUP var statusWithResult = new SuccessOrErrors<string>(); statusWithResult.AddSingleError("There was an error"); //ATTEMPT var status = statusWithResult as ISuccessOrErrors; //VERIFY status.IsValid.ShouldEqual(false); status.HasErrors.ShouldEqual(true); }
public void Test10CheckConvertResultToNormalStatusValidOk() { //SETUP var statusWithResult = new SuccessOrErrors<string>(); statusWithResult.SetSuccessWithResult("The result", "This is a message"); //ATTEMPT var status = statusWithResult as ISuccessOrErrors; //VERIFY status.IsValid.ShouldEqual(true); status.HasErrors.ShouldEqual(false); }
public void Check21StatusToJsonProperty() { //SETUP var status = new SuccessOrErrors(); var dto = new { MyInt = 1 }; //ATTEMPT status.AddNamedParameterError("MyInt", "This is a property level error."); var jsonResult = status.ReturnErrorsAsJson(dto); //VERIFY var json = jsonResult.Data.SerialiseToJson(); json.ShouldEqual("{\"errorsDict\":{\"MyInt\":{\"errors\":[\"This is a property level error.\"]}}}"); }
public void Test16CheckConvertResultToNormalStatusNotValidOk() { //SETUP var statusWithResult = new SuccessOrErrors(); statusWithResult.AddSingleError("error"); //ATTEMPT var status = SuccessOrErrors<string>.ConvertNonResultStatus(statusWithResult); //VERIFY status.IsValid.ShouldEqual(false); status.HasErrors.ShouldEqual(true); }
public void Test26CombineOtherSetSuccessOk() { //SETUP var status1 = new SuccessOrErrors<string>(); var status2 = new SuccessOrErrors<DateTime>(); status2.SetSuccessWithResult(DateTime.Now, "This was {0}.", "successful"); //ATTEMPT status1.Combine(status2); //VERIFY status1.IsValid.ShouldEqual(false); status1.ToString().ShouldEqual("Not currently setup"); }
public void Test55MultipleErrorsAsHtmlOk() { //SETUP var status = new SuccessOrErrors(); //ATTEMPT status.AddSingleError("This was {0}.", "bad"); status.AddNamedParameterError("MyParameterName", "This was {0}.", "bad"); var html = status.ErrorsAsHtml(); //VERIFY html.ShouldEqual("<ul><li>This was bad.</li><li>MyParameterName: This was bad.</li></ul>"); }
public void Test31CombineAddOtherSingleErrorOk() { //SETUP var status1 = new SuccessOrErrors<string>(); var status2 = new SuccessOrErrors(); status2.AddSingleError("This was {0}.", "bad"); //ATTEMPT status1.Combine(status2); //VERIFY status1.IsValid.ShouldEqual(false); status1.HasErrors.ShouldEqual(true); status1.SuccessMessage.ShouldEqual(""); status1.Errors.Count.ShouldEqual(1); status1.Errors[0].ErrorMessage.ShouldEqual("This was bad."); status1.Errors[0].MemberNames.Count().ShouldEqual(0); }
public void Test27SuccessWithOtherWarningsOk() { //SETUP var status1 = new SuccessOrErrors<string>(); var status2 = new SuccessOrErrors(); status2.AddWarning("This is a warning"); status1.SetSuccessWithResult("The result", "This was {0}.", "successful"); //ATTEMPT status1.Combine(status2); //VERIFY status1.IsValid.ShouldEqual(true); status1.HasErrors.ShouldEqual(false); status1.HasWarnings.ShouldEqual(true); status1.SuccessMessage.ShouldEqual("This was successful. (has 1 warnings)"); status1.Warnings.Count.ShouldEqual(1); status1.Warnings[0].ShouldEqual("Warning: This is a warning"); }
public void Test35CombineBadStatusFail() { //SETUP var status1 = new SuccessOrErrors<string>(); var status2 = "hello"; //ATTEMPT var ex = Assert.Throws<ArgumentNullException>(() => status1.Combine(status2)); //VERIFY ex.Message.ShouldStartWith("The status parameter was not derived from a type that supported ISuccessOrErrors."); }
public void Test05SetSuccessResultOk() { //SETUP var status = new SuccessOrErrors<string>(); //ATTEMPT status.SetSuccessWithResult("The result", "This is a message"); //VERIFY status.IsValid.ShouldEqual(true); status.HasErrors.ShouldEqual(false); status.Result.ShouldEqual("The result"); status.SuccessMessage.ShouldEqual("This is a message"); }
public void Check20StatusToJsonTopLevel() { //SETUP var status = new SuccessOrErrors(); var dto = new {MyInt = 1}; //ATTEMPT status.AddSingleError("This is a top level error."); var jsonResult = status.ReturnErrorsAsJson(dto); //VERIFY var json = jsonResult.Data.SerialiseToJson(); json.ShouldEqual("{\"errorsDict\":{\"\":{\"errors\":[\"This is a top level error.\"]}}}"); }
public void Test08CheckAssignNonResultOk() { //SETUP ISuccessOrErrors status = new SuccessOrErrors<string>(); //ATTEMPT ((SuccessOrErrors<string>)status).SetSuccessWithResult("The result", "This is a message"); //VERIFY status.IsValid.ShouldEqual(true); status.HasErrors.ShouldEqual(false); ((SuccessOrErrors<string>)status).Result.ShouldEqual("The result"); }
public void Test25CombineSetSuccessOk() { //SETUP var status1 = new SuccessOrErrors<string>(); var status2 = new SuccessOrErrors(); status1.SetSuccessWithResult("The result", "This was {0}.", "successful"); //ATTEMPT status1.Combine(status2); //VERIFY status1.IsValid.ShouldEqual(true); status1.HasErrors.ShouldEqual(false); status1.HasWarnings.ShouldEqual(false); status1.Result.ShouldEqual("The result"); status1.SuccessMessage.ShouldEqual("This was successful."); status1.Errors.Count.ShouldEqual(0); }
public void Test06SuccessWithWarningsOk() { //SETUP var status = new SuccessOrErrors(); //ATTEMPT status.AddWarning("This is a warning"); status.SetSuccessMessage("This was {0}.", "successful"); //VERIFY status.IsValid.ShouldEqual(true); status.HasErrors.ShouldEqual(false); status.HasWarnings.ShouldEqual(true); status.SuccessMessage.ShouldEqual("This was successful. (has 1 warnings)"); status.Warnings.Count.ShouldEqual(1); status.Warnings[0].ShouldEqual("Warning: This is a warning"); }
public void Test21CombineUnsetStatusHasNoErrorsOk() { //SETUP var status1 = new SuccessOrErrors<string>(); var status2 = new SuccessOrErrors(); //ATTEMPT status1.Combine(status2); //VERIFY status1.HasErrors.ShouldEqual(false); }
public void Test54MultipleErrorsGetAllErrorsOk() { //SETUP var status = new SuccessOrErrors(); //ATTEMPT status.AddSingleError("This was {0}.", "bad"); status.AddNamedParameterError("MyParameterName", "This was {0}.", "bad"); var str = status.GetAllErrors(); //VERIFY str.ShouldEqual("This was bad.\nMyParameterName: This was bad."); }
public void Test20CombineDefaultsToNotValidOk() { //SETUP var status1 = new SuccessOrErrors<string>(); var status2 = new SuccessOrErrors(); //ATTEMPT status1.Combine(status2); //VERIFY status1.IsValid.ShouldEqual(false); status1.ToString().ShouldEqual("Not currently setup"); }
public void Test16CheckConvertResultStatusToAnotherResultStatusValidOk() { //SETUP var statusWithResult = new SuccessOrErrors<int>(); statusWithResult.SetSuccessWithResult(1,"This is a message"); //ATTEMPT var status = SuccessOrErrors<string>.ConvertNonResultStatus(statusWithResult); //VERIFY status.IsValid.ShouldEqual(true); status.HasErrors.ShouldEqual(false); status.Result.ShouldEqual(null); }
public void Test11AddNamedParameterErrorOk() { //SETUP var status = new SuccessOrErrors(); //ATTEMPT status.AddNamedParameterError("MyParameterName", "This was {0}.", "bad"); //VERIFY status.IsValid.ShouldEqual(false); status.HasErrors.ShouldEqual(true); status.SuccessMessage.ShouldEqual(""); status.Errors.Count.ShouldEqual(1); status.Errors[0].ErrorMessage.ShouldEqual("This was bad."); status.Errors[0].MemberNames.Count().ShouldEqual(1); status.Errors[0].MemberNames.First().ShouldEqual("MyParameterName"); }
public void Test26CombineOtherSetSuccessOk() { //SETUP var status1 = new SuccessOrErrors(); var status2 = new SuccessOrErrors(); status2.SetSuccessMessage("This was {0}.", "successful"); //ATTEMPT status1.Combine(status2); //VERIFY status1.IsValid.ShouldEqual(false); status1.ToString().ShouldEqual("Not currently setup"); }