luticate2-api/Luticate2.Auth.Tests/Business/FieldsExpressions/LuFieldsExpressionsTests.cs

using System;
using System.Linq.Expressions;
using Luticate2.Auth.Business;
using Luticate2.Auth.Business.Fields;
using Luticate2.Auth.Business.FieldsExpressions;
using Luticate2.Auth.Business.FieldsExpressions.Basic;
using Luticate2.Auth.Dbo;
using Luticate2.Auth.Dbo.Fields;
using Luticate2.Auth.Dbo.Result;
using Luticate2.Auth.Interfaces;
using Microsoft.Extensions.DependencyInjection;
using Xunit;

namespace Luticate2.Auth.Tests.Business.FieldsExpressions
{
    public class LuFieldsExpressionsTestDbo1TestModel1 : LuFieldsExpressions<TestDbo1, TestModel1>
    {
        public LuFieldsExpressionsTestDbo1TestModel1(IServiceProvider serviceProvider) : base(serviceProvider)
        {
        }

        protected override LuResult<Expression<Func<TType1, object>>> GetExpressionInternal<TType1>(Expression<Func<TType1, TestModel1>> modelProperty, LuFieldDbo field)
        {
            if (field.StartsWith<TestDbo1>(x => x.MyInt))
            {
                return GetSubField<TType1, int, int>(modelProperty, field, x => x.MyInt);
            }
            else if (field.StartsWith<TestDbo1>(x => x.Metadata))
            {
                return GetSubField<TType1, MetadataDbo, MetadataModel>(modelProperty, field, x => x.MetadataModel);
            }

            return base.GetExpressionInternal(modelProperty, field);
        }
    }

    public class LuFieldsExpressionsMetadataDboMetadataModel : LuFieldsExpressions<MetadataDbo, MetadataModel>
    {
        public LuFieldsExpressionsMetadataDboMetadataModel(IServiceProvider serviceProvider) : base(serviceProvider)
        {
        }

        protected override LuResult<Expression<Func<TType1, object>>> GetExpressionInternal<TType1>(Expression<Func<TType1, MetadataModel>> modelProperty, LuFieldDbo field)
        {
            if (field.StartsWith<MetadataDbo>(x => x.Id))
            {
                return GetSubField<TType1, Guid, Guid>(modelProperty, field, x => x.Id);
            }

            return base.GetExpressionInternal(modelProperty, field);
        }
    }
    
    public class TestDbo1
    {
        public string MyString { get; set; }

        public int MyInt { get; set; }

        public MetadataDbo Metadata { get; set; }
    }

    public class MetadataDbo
    {
        public Guid Id { get; set; }

        public DateTime CreatedAt { get; set; }
    }
    
    public class TestModel1
    {
        public string MyString { get; set; }

        public int MyInt { get; set; }

        public MetadataModel MetadataModel { get; set; }
    }

    public class MetadataModel
    {
        public Guid Id { get; set; }

        public DateTime CreatedAt { get; set; }
    }
    
    public class LuFieldsExpressionsTests
    {
        public IServiceProvider GetServiceProvider()
        {
            var serviceCollection = new ServiceCollection();

            serviceCollection.AddSingleton<ILuFieldsExpressions<TestDbo1, TestModel1>, LuFieldsExpressionsTestDbo1TestModel1>();
            serviceCollection.AddSingleton<ILuFieldsExpressions<MetadataDbo, MetadataModel>, LuFieldsExpressionsMetadataDboMetadataModel>();
            serviceCollection.AddSingleton<ILuFieldsExpressions<string, string>, LuFieldsExpressionsString>();
            serviceCollection.AddSingleton<ILuFieldsExpressions<int, int>, LuFieldsExpressions<int, int>>();
            serviceCollection.AddSingleton<ILuFieldsExpressions<Guid, Guid>, LuFieldsExpressions<Guid, Guid>>();

            var serviceProvider = serviceCollection.BuildServiceProvider();
            return serviceProvider;
        }
        
        [Fact]
        public void Test1()
        {
            var serviceProvider = GetServiceProvider();
            var fieldExpression = serviceProvider.GetService<ILuFieldsExpressions<TestDbo1, TestModel1>>();
            var exprResult = fieldExpression.GetExpression<TestModel1>(x => x, LuFieldDbo.Make("Metadata.Id"));
            Assert.Equal(LuStatus.Success.ToInt(), exprResult.Status);
            Assert.NotNull(exprResult.Data);
            var operand = LuExpressionUtils.GetFromConvert(exprResult.Data);
            var str = operand.ToString();
            Assert.Equal("x.MetadataModel.Id", str);
        }

        [Fact]
        public void TestError1()
        {
            var serviceProvider = GetServiceProvider();
            var fieldExpression = serviceProvider.GetService<ILuFieldsExpressions<TestDbo1, TestModel1>>();
            var exprResult = fieldExpression.GetExpression<TestModel1>(x => x, LuFieldDbo.Make("Metadata.Id.NxField"));
            Assert.Equal(LuStatus.InputError.ToInt(), exprResult.Status);
            Assert.Null(exprResult.Data);
        }

        [Fact]
        public void TestError2()
        {
            var serviceProvider = GetServiceProvider();
            var fieldExpression = serviceProvider.GetService<ILuFieldsExpressions<TestDbo1, TestModel1>>();
            var exprResult = fieldExpression.GetExpression<TestModel1>(x => x, LuFieldDbo.Make("Metadata.*"));
            Assert.Equal(LuStatus.InputError.ToInt(), exprResult.Status);
            Assert.Null(exprResult.Data);
        }
    }
}