Пример #1
0
        //---------------------------------------------------
        //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);
        }
Пример #4
0
        /// <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"));
        }
Пример #5
0
        /// <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);
        }
Пример #6
0
        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."));
        }
Пример #8
0
        /// <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));
        }
Пример #9
0
        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.");
        }
Пример #19
0
        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);
        }
Пример #20
0
        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"));
        }
Пример #24
0
        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");
        }
Пример #25
0
        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");
        }
Пример #26
0
        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>");
        }
Пример #28
0
        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);
        }
Пример #40
0
        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 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>");
        }
        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 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");
        }
Пример #50
0
        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 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 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");
        }