VberAdmin_V4/SourceCode/Test/VberAdmin.Web.Tests/VberAdminWebTestBase.cs

using Abp.AspNetCore.TestBase;
using Abp.Extensions;
using Abp.Json;
using Abp.Web.Models;

using AngleSharp.Html.Dom;
using AngleSharp.Html.Parser;

using Microsoft.AspNetCore.Hosting;

using Newtonsoft.Json;
using Newtonsoft.Json.Serialization;

using Shouldly;

using System.Net;
using System.Net.Http.Headers;
using System.Text;

using VberAdmin.EntityFrameworkCore;
using VberAdmin.Models.TokenAuth;
using VberAdmin.Web.Startup;

using VberZero.BaseSystem.MultiTenancy;
using VberZero.BaseSystem.Users;

namespace VberAdmin.Web.Tests;

public abstract class VberAdminWebTestBase : AbpAspNetCoreIntegratedTestBase<Startup>
{
    protected static readonly Lazy<string> ContentRootFolder;

    static VberAdminWebTestBase()
    {
        ContentRootFolder = new Lazy<string>(WebContentDirectoryFinder.CalculateContentRootFolder, true);
    }

    protected override IWebHostBuilder CreateWebHostBuilder()
    {
        return base
            .CreateWebHostBuilder()
            .UseContentRoot(ContentRootFolder.Value)
            .UseSetting(WebHostDefaults.ApplicationKey, typeof(VberAdminWebMvcModule).Assembly.FullName);
    }

    #region Get response

    protected async Task<T> GetResponseAsObjectAsync<T>(string url,
        HttpStatusCode expectedStatusCode = HttpStatusCode.OK)
    {
        var strResponse = await GetResponseAsStringAsync(url, expectedStatusCode);
        return JsonConvert.DeserializeObject<T>(strResponse, new JsonSerializerSettings
        {
            ContractResolver = new CamelCasePropertyNamesContractResolver()
        });
    }

    protected async Task<string> GetResponseAsStringAsync(string url,
        HttpStatusCode expectedStatusCode = HttpStatusCode.OK)
    {
        var response = await GetResponseAsync(url, expectedStatusCode);
        return await response.Content.ReadAsStringAsync();
    }

    protected async Task<HttpResponseMessage> GetResponseAsync(string url,
        HttpStatusCode expectedStatusCode = HttpStatusCode.OK)
    {
        var response = await Client.GetAsync(url);
        response.StatusCode.ShouldBe(expectedStatusCode);
        return response;
    }

    #endregion Get response

    #region Authenticate

    /// <summary>
    /// /api/TokenAuth/Authenticate
    /// TokenAuthController
    /// </summary>
    /// <param name="tenancyName"></param>
    /// <param name="input"></param>
    /// <returns></returns>
    protected async Task AuthenticateAsync(string tenancyName, AuthenticateModel input)
    {
        if (tenancyName.IsNullOrWhiteSpace())
        {
            var tenant = UsingDbContext(context => context.Tenants.FirstOrDefault(t => t.TenancyName == tenancyName));
            if (tenant != null)
            {
                AbpSession.TenantId = tenant.Id;
                Client.DefaultRequestHeaders.Add("Abp.TenantId", tenant.Id.ToString());  //Set TenantId
            }
        }

        var response = await Client.PostAsync("/api/TokenAuth/Authenticate",
            new StringContent(input.ToJsonString(), Encoding.UTF8, "application/json"));
        response.StatusCode.ShouldBe(HttpStatusCode.OK);
        var result =
            JsonConvert.DeserializeObject<AjaxResponse<AuthenticateResultModel>>(
                await response.Content.ReadAsStringAsync());
        Client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", result?.Result.AccessToken);

        AbpSession.UserId = result?.Result.UserId;
    }

    #endregion Authenticate

    #region Login

    protected void LoginAsHostAdmin()
    {
        LoginAsHost(User.AdminUserName);
    }

    protected void LoginAsDefaultTenantAdmin()
    {
        LoginAsTenant(Tenant.DefaultTenantName, User.AdminUserName);
    }

    protected void LoginAsHost(string userName)
    {
        AbpSession.TenantId = null;

        var user =
            UsingDbContext(
                context =>
                    context.Users.FirstOrDefault(u => u.TenantId == AbpSession.TenantId && u.UserName == userName));
        if (user == null)
        {
            throw new Exception("There is no user: " + userName + " for host.");
        }

        AbpSession.UserId = user.Id;
    }

    protected void LoginAsTenant(string tenancyName, string userName)
    {
        var tenant = UsingDbContext(context => context.Tenants.FirstOrDefault(t => t.TenancyName == tenancyName));
        if (tenant == null)
        {
            throw new Exception("There is no tenant: " + tenancyName);
        }

        AbpSession.TenantId = tenant.Id;

        var user =
            UsingDbContext(
                context =>
                    context.Users.FirstOrDefault(u => u.TenantId == AbpSession.TenantId && u.UserName == userName));
        if (user == null)
        {
            throw new Exception("There is no user: " + userName + " for tenant: " + tenancyName);
        }

        AbpSession.UserId = user.Id;
    }

    #endregion Login

    #region UsingDbContext

    protected void UsingDbContext(Action<VberAdminDbContext> action)
    {
        using (var context = IocManager.Resolve<VberAdminDbContext>())
        {
            action(context);
            context.SaveChanges();
        }
    }

    protected T UsingDbContext<T>(Func<VberAdminDbContext, T> func)
    {
        T result;

        using (var context = IocManager.Resolve<VberAdminDbContext>())
        {
            result = func(context);
            context.SaveChanges();
        }

        return result;
    }

    protected async Task UsingDbContextAsync(Func<VberAdminDbContext, Task> action)
    {
        using (var context = IocManager.Resolve<VberAdminDbContext>())
        {
            await action(context);
            await context.SaveChangesAsync(true);
        }
    }

    protected async Task<T> UsingDbContextAsync<T>(Func<VberAdminDbContext, Task<T>> func)
    {
        T result;

        using (var context = IocManager.Resolve<VberAdminDbContext>())
        {
            result = await func(context);
            await context.SaveChangesAsync(true);
        }

        return result;
    }

    #endregion UsingDbContext

    #region ParseHtml

    protected IHtmlDocument ParseHtml(string htmlString)
    {
        return new HtmlParser().ParseDocument(htmlString);
    }

    #endregion ParseHtml
}