XCode/XUnitTest.XCode/Code/ClassBuilderTests.cs

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using XCode.Code;
using XCode.DataAccessLayer;
using Xunit;

namespace XUnitTest.XCode.Code;

public class ClassBuilderTests
{
    private IList<IDataTable> _tables;
    private IDataTable _table;
    private BuilderOption _option;

    public ClassBuilderTests()
    {
        _option = new BuilderOption();
        _tables = ClassBuilder.LoadModels(@"..\..\XCode\Membership\Member.xml", _option, out _);
        _table = _tables.FirstOrDefault(e => e.Name == "User");
    }

    private String ReadTarget(String file, String text)
    {
        //var file2 = @"..\..\XUnitTest.XCode\".CombinePath(file);
        //File.WriteAllText(file2, text);

        var target = File.ReadAllText(file.GetFullPath());

        return target;
    }

    [Fact]
    public void Normal()
    {
        var builder = new ClassBuilder
        {
            Table = _table,
        };
        builder.Option.Namespace = "Company.MyName";
        builder.Option.Usings.Add("NewLife.Remoting");

        builder.Execute();

        var rs = builder.ToString();
        Assert.NotEmpty(rs);

        var target = ReadTarget("Code\\class_user_normal.cs", rs);
        Assert.Equal(target, rs);
    }

    [Fact]
    public void BaseClass()
    {
        var builder = new ClassBuilder
        {
            Table = _table,
        };
        builder.Option.BaseClass = "MyEntityBase";
        builder.Option.Partial = false;

        builder.Execute();

        var rs = builder.ToString();
        Assert.NotEmpty(rs);

        var target = ReadTarget("Code\\class_user_baseclass.cs", rs);
        Assert.Equal(target, rs);
    }

    [Fact]
    public void Pure()
    {
        var option = new BuilderOption
        {
            Pure = true,
            Partial = true,
            ClassNameTemplate = "Pure{name}",
            BaseClass = "Object, Ixx{name}",
            ModelNameForCopy = "Ixx{name}",
        };

        var builder = new ClassBuilder
        {
            Table = _table,
            Option = option,
        };

        builder.Execute();

        var rs = builder.ToString();
        Assert.NotEmpty(rs);

        var target = ReadTarget("Code\\class_user_pure.cs", rs);
        Assert.Equal(target, rs);
    }

    [Fact]
    public void Interface()
    {
        var option = new BuilderOption
        {
            Interface = true,
            BaseClass = "NewLife.Data.IModel",
            ClassNameTemplate = "Ixx{name}",
        };
        option.Excludes.Add("UpdateUser");
        option.Excludes.Add("UpdateUserID");
        option.Excludes.Add("UpdateIP");
        option.Excludes.Add("UpdateTime");

        var builder = new ClassBuilder
        {
            Table = _table,
            Option = option,
        };

        builder.Execute();

        var rs = builder.ToString();
        Assert.NotEmpty(rs);

        var target = ReadTarget("Code\\class_user_interface.cs", rs);
        Assert.Equal(target, rs);
    }

    [Fact]
    public void Extend()
    {
        var option = new BuilderOption
        {
            Pure = true,
            HasIModel = true,
            BaseClass = "Object, Ixx{name}",
            ClassNameTemplate = "Extend{name}",
            ModelNameForCopy = "Extend{name}",
        };

        var builder = new ClassBuilder
        {
            Table = _table,
            Option = option,
        };

        builder.Execute();

        var rs = builder.ToString();
        Assert.NotEmpty(rs);

        var target = ReadTarget("Code\\class_user_extend.cs", rs);
        Assert.Equal(target, rs);
    }

    [Fact]
    public void Extend2()
    {
        var option = new BuilderOption
        {
            Pure = true,
            HasIModel = true,
            BaseClass = null,
            ClassNameTemplate = "Extend{name}2",
            DisplayNameTemplate = "{displayName}模型",
        };
        option.Excludes.Add("UpdateUser");
        option.Excludes.Add("UpdateUserID");
        option.Excludes.Add("UpdateIP");
        option.Excludes.Add("UpdateTime");

        var builder = new ClassBuilder
        {
            Table = _table,
            Option = option,
        };

        builder.Execute();

        var rs = builder.ToString();
        Assert.NotEmpty(rs);

        var target = ReadTarget("Code\\class_user_extend2.cs", rs);
        Assert.Equal(target, rs);
    }

    [Fact]
    public void Save()
    {
        var builder = new ClassBuilder
        {
            Table = _table,
        };
        var option = builder.Option;
        option.Pure = true;
        option.Output = ".\\Output\\Save";

        if (Directory.Exists(option.Output.GetFullPath())) Directory.Delete(option.Output.GetFullPath(), true);

        builder.Execute();

        var file = (option.Output + "\\" + builder.Table.DisplayName + ".cs").GetFullPath();
        if (File.Exists(file)) File.Delete(file);

        builder.Save();
        Assert.True(File.Exists(file));

        var rs = File.ReadAllText(file);
        var target = ReadTarget("Code\\class_user_save.cs", rs);
        Assert.Equal(target, rs);

        file = (option.Output + "\\" + builder.Table.Name + ".xs").GetFullPath();
        if (File.Exists(file)) File.Delete(file);

        builder.Save(".xs", false, false);
        Assert.True(File.Exists(file));

        rs = File.ReadAllText(file);
        Assert.Equal(target, rs);
    }

    [Fact]
    public void BuildModels()
    {
        var dir = ".\\Output\\Models\\";
        if (Directory.Exists(dir.GetFullPath())) Directory.Delete(dir.GetFullPath(), true);

        var option = new BuilderOption
        {
            Output = dir,
            ClassNameTemplate = "{name}Model",
            Partial = true,
        };

        ClassBuilder.BuildModels(_tables, option);

        option.ClassNameTemplate = "I{name}Model";
        ClassBuilder.BuildInterfaces(_tables, option);

        foreach (var item in _tables)
        {
            var file = dir.CombinePath(item.Name + "Model.cs").GetFullPath();
            Assert.True(File.Exists(file));

            if (item.Name == "User")
            {
                var rs = File.ReadAllText(file);
                var target = ReadTarget("Code\\Models\\UserModel.cs", rs);
                Assert.Equal(target, rs);
            }

            file = dir.CombinePath("I" + item.Name + "Model.cs").GetFullPath();
            Assert.True(File.Exists(file));

            if (item.Name == "User")
            {
                var rs = File.ReadAllText(file);
                var target = ReadTarget("Code\\Models\\IUserModel.cs", rs);
                Assert.Equal(target, rs);
            }
        }
    }

    [Fact]
    public void BuildDtos()
    {
        var dir = ".\\Output\\Dtos\\";
        if (Directory.Exists(dir.GetFullPath())) Directory.Delete(dir.GetFullPath(), true);

        var option = new BuilderOption
        {
            Output = dir,
            ClassNameTemplate = "{name}Dto",
            Partial = true,
        };

        ClassBuilder.BuildModels(_tables, option);

        option.ClassNameTemplate = null;
        ClassBuilder.BuildInterfaces(_tables, option);

        foreach (var item in _tables)
        {
            var file = dir.CombinePath(item.Name + "Dto.cs").GetFullPath();
            Assert.True(File.Exists(file));

            if (item.Name == "User")
            {
                var rs = File.ReadAllText(file);
                var target = ReadTarget("Code\\Dtos\\UserDto.cs", rs);
                Assert.Equal(target, rs);
            }

            file = dir.CombinePath("I" + item.Name + ".cs").GetFullPath();
            Assert.True(File.Exists(file));

            if (item.Name == "User")
            {
                var rs = File.ReadAllText(file);
                var target = ReadTarget("Code\\Dtos\\IUser.cs", rs);
                Assert.Equal(target, rs);
            }
        }
    }

    [Fact]
    public void BuildTT()
    {
        var dir = ".\\Output\\BuildTT\\";
        if (Directory.Exists(dir.GetFullPath())) Directory.Delete(dir.GetFullPath(), true);

        var option = new BuilderOption
        {
            Output = dir,
            ClassNameTemplate = "{name}TT"
        };

        // 测试Built.tt
        foreach (var item in _tables)
        {
            var builder = new ClassBuilder
            {
                Table = item,
                Option = option,
            };
            builder.Execute();
            builder.Save(null, true, false);
        }

        foreach (var item in _tables)
        {
            var file = dir.CombinePath(item.Name + "TT.cs").GetFullPath();
            Assert.True(File.Exists(file));

            if (item.Name == "User")
            {
                var rs = File.ReadAllText(file);
                var target = ReadTarget("Code\\BuildTT\\UserTT.cs", rs);
                Assert.Equal(target, rs);
            }
        }

        // 清理
        //Directory.Delete(dir.GetFullPath(), true);
    }
}