/// <summary>
        /// Tests whether the action has invalid <see cref="Microsoft.AspNetCore.Mvc.ModelBinding.ModelStateDictionary"/>.
        /// </summary>
        /// <typeparam name="TBuilder">Class representing ASP.NET Core MVC test builder.</typeparam>
        /// <param name="builder">Instance of <see cref="IBaseTestBuilderWithComponentShouldHaveTestBuilder{TBuilder}"/> type.</param>
        /// <param name="withNumberOfErrors">Expected number of <see cref="Microsoft.AspNetCore.Mvc.ModelBinding.ModelStateDictionary"/> errors.
        /// If default null is provided, the test builder checks only if any errors are found.</param>
        /// <returns>The same component should have test builder.</returns>
        public static TBuilder InvalidModelState <TBuilder>(
            this IBaseTestBuilderWithComponentShouldHaveTestBuilder <TBuilder> builder,
            int?withNumberOfErrors = null)
            where TBuilder : IBaseTestBuilder
        {
            var actualBuilder = (BaseTestBuilderWithComponentBuilder <TBuilder>)builder;

            var actualModelStateErrors = (actualBuilder.TestContext as ActionTestContext)
                                         ?.ModelState
                                         .Values
                                         .SelectMany(c => c.Errors)
                                         .Count();

            if (actualModelStateErrors == 0 ||
                (withNumberOfErrors != null && actualModelStateErrors != withNumberOfErrors))
            {
                throw new ModelErrorAssertionException(string.Format(
                                                           "{0} to have invalid model state{1}, {2}.",
                                                           actualBuilder.TestContext.ExceptionMessagePrefix,
                                                           withNumberOfErrors == null ? string.Empty : $" with {withNumberOfErrors} errors",
                                                           withNumberOfErrors == null ? "but was in fact valid" : $"but in fact contained {actualModelStateErrors}"));
            }

            return(actualBuilder.Builder);
        }
        /// <summary>
        /// Tests whether the component has valid <see cref="Microsoft.AspNetCore.Mvc.ModelBinding.ModelStateDictionary"/> with no errors.
        /// </summary>
        /// <typeparam name="TBuilder">Class representing ASP.NET Core MVC test builder.</typeparam>
        /// <param name="builder">Instance of <see cref="IBaseTestBuilderWithComponentShouldHaveTestBuilder{TBuilder}"/> type.</param>
        /// <returns>The same component should have test builder.</returns>
        public static TBuilder ValidModelState <TBuilder>(this IBaseTestBuilderWithComponentShouldHaveTestBuilder <TBuilder> builder)
            where TBuilder : IBaseTestBuilder
        {
            var actualBuilder = (BaseTestBuilderWithComponentBuilder <TBuilder>)builder;

            ModelStateValidator.CheckValidModelState(actualBuilder.TestContext as ActionTestContext);

            return(actualBuilder.Builder);
        }
        /// <summary>
        /// Tests whether the component sets specific <see cref="Microsoft.Extensions.Caching.Distributed.IDistributedCache"/> entries.
        /// </summary>
        /// <typeparam name="TBuilder">Class representing ASP.NET Core MVC test builder.</typeparam>
        /// <param name="builder">Instance of <see cref="IBaseTestBuilderWithComponentShouldHaveTestBuilder{TBuilder}"/> type.</param>
        /// <param name="distributedCacheTestBuilder">Builder for testing specific <see cref="Microsoft.Extensions.Caching.Distributed.IDistributedCache"/> entries.</param>
        /// <returns>The same component should have test builder.</returns>
        public static TBuilder DistributedCache <TBuilder>(
            this IBaseTestBuilderWithComponentShouldHaveTestBuilder <TBuilder> builder,
            Action <IDistributedCacheTestBuilder> distributedCacheTestBuilder)
            where TBuilder : IBaseTestBuilder
        {
            var actualBuilder = (BaseTestBuilderWithComponentBuilder <TBuilder>)builder;

            distributedCacheTestBuilder(new DistributedCacheTestBuilder(actualBuilder.TestContext));

            return(actualBuilder.Builder);
        }
        /// <summary>
        /// Tests whether the action saves entities in the <see cref="Microsoft.EntityFrameworkCore.DbContext"/>.
        /// </summary>
        /// <typeparam name="TBuilder">Class representing ASP.NET Core MVC test builder.</typeparam>
        /// <param name="builder">Instance of <see cref="IBaseTestBuilderWithComponentShouldHaveTestBuilder{TBuilder}"/> type.</param>
        /// <param name="dbContextTestBuilder">
        /// Action containing all assertions for the <see cref="Microsoft.EntityFrameworkCore.DbContext"/> entities.
        /// </param>
        /// <returns>The same component should have test builder.</returns>
        public static TBuilder Data <TBuilder>(
            this IBaseTestBuilderWithComponentShouldHaveTestBuilder <TBuilder> builder,
            Action <IWithDbContextTestBuilder> dbContextTestBuilder)
            where TBuilder : IBaseTestBuilder
        {
            var actualBuilder = (BaseTestBuilderWithComponentBuilder <TBuilder>)builder;

            dbContextTestBuilder(new WithDbContextTestBuilder(actualBuilder.TestContext));

            return(actualBuilder.Builder);
        }
        /// <summary>
        /// Tests whether the component sets specific <see cref="Microsoft.Extensions.Caching.Memory.IMemoryCache"/> entries.
        /// </summary>
        /// <typeparam name="TBuilder">Class representing ASP.NET Core MVC test builder.</typeparam>
        /// <param name="builder">Instance of <see cref="IBaseTestBuilderWithComponentShouldHaveTestBuilder{TBuilder}"/> type.</param>
        /// <param name="memoryCacheTestBuilder">Builder for testing specific <see cref="Microsoft.Extensions.Caching.Memory.IMemoryCache"/> entries.</param>
        /// <returns>The same component should have test builder.</returns>
        public static TBuilder MemoryCache <TBuilder>(
            this IBaseTestBuilderWithComponentShouldHaveTestBuilder <TBuilder> builder,
            Action <IMemoryCacheTestBuilder> memoryCacheTestBuilder)
            where TBuilder : IBaseTestBuilder
        {
            var actualBuilder = (BaseTestBuilderWithComponentBuilder <TBuilder>)builder;

            memoryCacheTestBuilder(new MemoryCacheTestBuilder(actualBuilder.TestContext));

            return(actualBuilder.Builder);
        }
        /// <summary>
        /// Tests whether the component applies additional features to the <see cref="Microsoft.AspNetCore.Http.HttpResponse"/>.
        /// </summary>
        /// <typeparam name="TBuilder">Class representing ASP.NET Core MVC test builder.</typeparam>
        /// <param name="builder">Instance of <see cref="IBaseTestBuilderWithComponentShouldHaveTestBuilder{TBuilder}"/> type.</param>
        /// <param name="httpResponseTestBuilder">Builder for testing the <see cref="Microsoft.AspNetCore.Http.HttpResponse"/>.</param>
        /// <returns>The same component should have test builder.</returns>
        public static TBuilder HttpResponse <TBuilder>(
            this IBaseTestBuilderWithComponentShouldHaveTestBuilder <TBuilder> builder,
            Action <IHttpResponseTestBuilder> httpResponseTestBuilder)
            where TBuilder : IBaseTestBuilder
        {
            var actualBuilder = (BaseTestBuilderWithComponentBuilder <TBuilder>)builder;

            httpResponseTestBuilder(new HttpResponseTestBuilder(actualBuilder.TestContext));

            return(actualBuilder.Builder);
        }
コード例 #7
0
        /// <summary>
        /// Tests whether the component sets specific <see cref="Microsoft.AspNetCore.Http.ISession"/> entries.
        /// </summary>
        /// <typeparam name="TBuilder">Class representing ASP.NET Core MVC test builder.</typeparam>
        /// <param name="builder">Instance of <see cref="IBaseTestBuilderWithComponentShouldHaveTestBuilder{TBuilder}"/> type.</param>
        /// <param name="sessionTestBuilder">Builder for testing specific <see cref="Microsoft.AspNetCore.Http.ISession"/> entries.</param>
        /// <returns>The same component should have test builder.</returns>
        public static TBuilder Session <TBuilder>(
            this IBaseTestBuilderWithComponentShouldHaveTestBuilder <TBuilder> builder,
            Action <ISessionTestBuilder> sessionTestBuilder)
            where TBuilder : IBaseTestBuilder
        {
            var actualBuilder = (BaseTestBuilderWithComponentBuilder <TBuilder>)builder;

            sessionTestBuilder(new SessionTestBuilder(actualBuilder.TestContext));

            return(actualBuilder.Builder);
        }
コード例 #8
0
        /// <summary>
        /// Tests whether the component sets specific entries in the <see cref="Microsoft.AspNetCore.Mvc.Controller.ViewBag"/>.
        /// </summary>
        /// <typeparam name="TBuilder">Class representing ASP.NET Core MVC test builder.</typeparam>
        /// <param name="builder">Instance of <see cref="IBaseTestBuilderWithComponentShouldHaveTestBuilder{TBuilder}"/> type.</param>
        /// <param name="viewBagTestBuilder">Builder for testing specific dynamic view bag entries.</param>
        /// <returns>The same component should have test builder.</returns>
        public static TBuilder ViewBag <TBuilder>(
            this IBaseTestBuilderWithComponentShouldHaveTestBuilder <TBuilder> builder,
            Action <IViewBagTestBuilder> viewBagTestBuilder)
            where TBuilder : IBaseTestBuilder
        {
            var actualBuilder = (BaseTestBuilderWithComponentBuilder <TBuilder>)builder;

            viewBagTestBuilder(new ViewBagTestBuilder(actualBuilder.TestContext));

            return(actualBuilder.Builder);
        }
        /// <summary>
        /// Tests whether the component has specific <see cref="Microsoft.AspNetCore.Mvc.ModelBinding.ModelStateDictionary"/> errors.
        /// </summary>
        /// <typeparam name="TBuilder">Class representing ASP.NET Core MVC test builder.</typeparam>
        /// <param name="builder">Instance of <see cref="IBaseTestBuilderWithComponentShouldHaveTestBuilder{TBuilder}"/> type.</param>
        /// <param name="modelStateTestBuilder">Builder for testing specific <see cref="Microsoft.AspNetCore.Mvc.ModelBinding.ModelStateDictionary"/> errors.</param>
        /// <returns>The same component should have test builder.</returns>
        public static TBuilder ModelState <TBuilder>(
            this IBaseTestBuilderWithComponentShouldHaveTestBuilder <TBuilder> builder,
            Action <IModelStateTestBuilder> modelStateTestBuilder)
            where TBuilder : IBaseTestBuilder
        {
            var actualBuilder = (BaseTestBuilderWithComponentBuilder <TBuilder>)builder;

            modelStateTestBuilder(new ModelStateTestBuilder(actualBuilder.TestContext as ActionTestContext));

            return(actualBuilder.Builder);
        }
        /// <summary>
        /// Tests whether the component does not set any <see cref="Microsoft.Extensions.Caching.Distributed.IDistributedCache"/> entries.
        /// </summary>
        /// <typeparam name="TBuilder">Class representing ASP.NET Core MVC test builder.</typeparam>
        /// <param name="builder">Instance of <see cref="IBaseTestBuilderWithComponentShouldHaveTestBuilder{TBuilder}"/> type.</param>
        /// <returns>The same component should have test builder.</returns>
        public static TBuilder NoDistributedCache <TBuilder>(this IBaseTestBuilderWithComponentShouldHaveTestBuilder <TBuilder> builder)
            where TBuilder : IBaseTestBuilder
        {
            var actualBuilder = (BaseTestBuilderWithComponentBuilder <TBuilder>)builder;

            if (actualBuilder.TestContext.GetDistributedCacheMock().Count > 0)
            {
                DataProviderValidator.ThrowNewDataProviderAssertionExceptionWithNoEntries(
                    actualBuilder.TestContext,
                    DistributedCacheTestBuilder.DistributedCacheName);
            }

            return(actualBuilder.Builder);
        }
コード例 #11
0
        /// <summary>
        /// Tests whether the component does not set any <see cref="Microsoft.AspNetCore.Http.ISession"/> entries.
        /// </summary>
        /// <typeparam name="TBuilder">Class representing ASP.NET Core MVC test builder.</typeparam>
        /// <param name="builder">Instance of <see cref="IBaseTestBuilderWithComponentShouldHaveTestBuilder{TBuilder}"/> type.</param>
        /// <returns>The same component should have test builder.</returns>
        public static TBuilder NoSession <TBuilder>(this IBaseTestBuilderWithComponentShouldHaveTestBuilder <TBuilder> builder)
            where TBuilder : IBaseTestBuilder
        {
            var actualBuilder = (BaseTestBuilderWithComponentBuilder <TBuilder>)builder;

            if (actualBuilder.TestContext.Session.Keys.Any())
            {
                DataProviderValidator.ThrowNewDataProviderAssertionExceptionWithNoEntries(
                    actualBuilder.TestContext,
                    SessionTestBuilder.SessionName);
            }

            return(actualBuilder.Builder);
        }
コード例 #12
0
        /// <summary>
        /// Tests whether the component does not set any dynamic view bag entries.
        /// </summary>
        /// <typeparam name="TBuilder">Class representing ASP.NET Core MVC test builder.</typeparam>
        /// <param name="builder">Instance of <see cref="IBaseTestBuilderWithComponentShouldHaveTestBuilder{TBuilder}"/> type.</param>
        /// <returns>The same component should have test builder.</returns>
        public static TBuilder NoViewBag <TBuilder>(this IBaseTestBuilderWithComponentShouldHaveTestBuilder <TBuilder> builder)
            where TBuilder : IBaseTestBuilder
        {
            var actualBuilder = (BaseTestBuilderWithComponentBuilder <TBuilder>)builder;

            if (actualBuilder.TestContext.GetViewData().Count > 0)
            {
                DataProviderValidator.ThrowNewDataProviderAssertionExceptionWithNoEntries(
                    actualBuilder.TestContext,
                    ViewBagTestBuilder.ViewBagName);
            }

            return(actualBuilder.Builder);
        }
        /// <summary>
        /// Tests whether the component sets specific <see cref="Microsoft.Extensions.Caching.Distributed.IDistributedCache"/> entries.
        /// </summary>
        /// <typeparam name="TBuilder">Class representing ASP.NET Core MVC test builder.</typeparam>
        /// <param name="builder">Instance of <see cref="IBaseTestBuilderWithComponentShouldHaveTestBuilder{TBuilder}"/> type.</param>
        /// <param name="withNumberOfEntries">Expected number of <see cref="Microsoft.Extensions.Caching.Distributed.IDistributedCache"/> entries.</param>
        /// <returns>The same component should have test builder.</returns>
        public static TBuilder DistributedCache <TBuilder>(
            this IBaseTestBuilderWithComponentShouldHaveTestBuilder <TBuilder> builder,
            int?withNumberOfEntries = null)
            where TBuilder : IBaseTestBuilder
        {
            var actualBuilder = (BaseTestBuilderWithComponentBuilder <TBuilder>)builder;

            DataProviderValidator.ValidateDataProviderNumberOfEntries(
                actualBuilder.TestContext,
                DistributedCacheTestBuilder.DistributedCacheName,
                withNumberOfEntries,
                actualBuilder.TestContext.GetDistributedCacheMock().Count);

            return(actualBuilder.Builder);
        }
コード例 #14
0
        /// <summary>
        /// Tests whether the component sets entries in the <see cref="Microsoft.AspNetCore.Http.ISession"/>.
        /// </summary>
        /// <typeparam name="TBuilder">Class representing ASP.NET Core MVC test builder.</typeparam>
        /// <param name="builder">Instance of <see cref="IBaseTestBuilderWithComponentShouldHaveTestBuilder{TBuilder}"/> type.</param>
        /// <param name="withNumberOfEntries">Expected number of <see cref="Microsoft.AspNetCore.Http.ISession"/> entries.
        /// If default null is provided, the test builder checks only if any entries are found.</param>
        /// <returns>The same component should have test builder.</returns>
        public static TBuilder Session <TBuilder>(
            this IBaseTestBuilderWithComponentShouldHaveTestBuilder <TBuilder> builder,
            int?withNumberOfEntries = null)
            where TBuilder : IBaseTestBuilder
        {
            var actualBuilder = (BaseTestBuilderWithComponentBuilder <TBuilder>)builder;

            DataProviderValidator.ValidateDataProviderNumberOfEntries(
                actualBuilder.TestContext,
                SessionTestBuilder.SessionName,
                withNumberOfEntries,
                actualBuilder.TestContext.Session.Keys.Count());

            return(actualBuilder.Builder);
        }
コード例 #15
0
        /// <summary>
        /// Tests whether the component sets entries in the dynamic view bag.
        /// </summary>
        /// <typeparam name="TBuilder">Class representing ASP.NET Core MVC test builder.</typeparam>
        /// <param name="builder">Instance of <see cref="IBaseTestBuilderWithComponentShouldHaveTestBuilder{TBuilder}"/> type.</param>
        /// <param name="withNumberOfEntries">Expected number of dynamic view bag entries.
        /// If default null is provided, the test builder checks only if any entries are found.</param>
        /// <returns>The same component should have test builder.</returns>
        public static TBuilder ViewBag <TBuilder>(
            this IBaseTestBuilderWithComponentShouldHaveTestBuilder <TBuilder> builder,
            int?withNumberOfEntries = null)
            where TBuilder : IBaseTestBuilder
        {
            var actualBuilder = (BaseTestBuilderWithComponentBuilder <TBuilder>)builder;

            DataProviderValidator.ValidateDataProviderNumberOfEntries(
                actualBuilder.TestContext,
                ViewBagTestBuilder.ViewBagName,
                withNumberOfEntries,
                actualBuilder.TestContext.GetViewData().Count);

            return(actualBuilder.Builder);
        }