AutomaticTestRunner.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection;
using System.Diagnostics;
using System.Runtime.CompilerServices;
using System.IO;
 
using Barotrauma;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Input;
using Microsoft.Xna.Framework.Graphics;
using HarmonyLib;
using CrabUI;
using System.Text;
using System.Threading;
using System.Xml;
using System.Xml.Linq;
 
namespace CrabUITest
{
  public class IgnoreAttribute : System.Attribute { }
  public class HideFromAutoTestRunnerAttribute : System.Attribute { }
 
  public enum TestStatus
  {
    Passed,
    Failed,
    Unknown,
    Stashed,
  }
  public record TestReport(Type TestClass, MethodInfo TestMethod, TestStatus Status, string DeepCompare = "");
 
  public class TestingConfig
  {
    public static string ConfigPath => Path.Combine(CUITest.IgnoredDataPath, "Config.xml");
 
    public event Action OnChanged;
 
    private string autorun = "";
    public string Autorun
    {
      get => autorun;
      set
      {
        autorun = value ?? "";
        Save();
        OnChanged?.Invoke();
      }
    }
 
    public void Load()
    {
      if (!File.Exists(ConfigPath)) return;
      XDocument xdoc = XDocument.Load(ConfigPath);
      XElement root = xdoc.Element("Autorun");
      Autorun = root?.Value;
    }
 
    public void Save()
    {
      XDocument xdoc = new XDocument();
      xdoc.Add(new XElement("Autorun", Autorun ?? ""));
      xdoc.Save(ConfigPath);
    }
  }
 
  public class AutomaticTestRunner
  {
    public CUIComponent TestChamber => CUITest.TestChamber;
    public static string TestStashPath => Path.Combine(CUITest.IgnoredDataPath, "Stash");
 
    public AutoTestGUI GUI;
    public TestingConfig Config;
 
 
    public IEnumerable<Type> GetAllTestClasses()
    {
      Assembly targetAssembly = Assembly.GetAssembly(typeof(FillMethods));
 
      return targetAssembly.GetTypes()
        .Where(t => t.IsSubclassOf(typeof(FillMethods)));
    }
 
    public IEnumerable<MethodInfo> GetAllTestMethodsForAClass(Type type)
    {
      return type.GetMethods(BindingFlags.Public | BindingFlags.Static)
        .Where(mi => FillMethods.IsTestMethod(mi));
    }
 
    public IEnumerable<MethodInfo> GetAllAutoTestMethodsForAClass(Type type)
    {
      return type.GetMethods(BindingFlags.Public | BindingFlags.Static)
        .Where(mi => FillMethods.IsTestMethod(mi) && !Attribute.IsDefined(mi, typeof(HideFromAutoTestRunnerAttribute)));
    }
 
    public string[] GetClassMethodPairs()
    {
      List<string> all = new();
      foreach (Type type in GetAllTestClasses())
      {
        foreach (MethodInfo mi in GetAllTestMethodsForAClass(type))
        {
          all.Add($"{type.Name}.{mi.Name}");
        }
      }
      return all.ToArray();
    }
 
    public static (Type, MethodInfo) DeconstructFullName(string fullName)
    {
      string typeName = fullName.Split('.').ElementAtOrDefault(0);
      string methodName = fullName.Split('.').ElementAtOrDefault(1);
 
      Assembly targetAssembly = Assembly.GetAssembly(typeof(FillMethods));
 
      Type type = targetAssembly.GetTypes().Find(T => T.Name == typeName);
      if (type == null) return (null, null);
 
      MethodInfo method = type.GetMethod(methodName, BindingFlags.Public | BindingFlags.Static);
      return (type, method);
    }
 
    // Could be in it's own class
    public string DeepCompare(string real, string stashed)
    {
      StringBuilder result = new StringBuilder("‖color:gray‖");
 
      int minLength = Math.Min(real.Length, stashed.Length);
 
      bool ok = true;
      for (int i = 0; i < minLength; i++)
      {
        if (ok)
        {
          if (real[i] != stashed[i]) { ok = false; result.Append("‖end‖‖color:cyan‖"); }
        }
        else
        {
          if (real[i] == stashed[i]) { ok = true; result.Append("‖end‖‖color:gray‖"); }
        }
 
        result.Append(real[i]);
      }
      result.Append("‖end‖");
 
      return result.ToString();
    }
 
    private MethodInfo activeTest; public MethodInfo ActiveTest
    {
      get => activeTest;
      set
      {
        if (activeTest == value)
        {
          CUITest.ClearTestChamber();
          return;
        }
 
        activeTest = value;
 
        if (activeTest != null)
        {
          if (TestChamber == null) CUITest.CreateTestChamber();
          if (TestChamber.Parent == null) CUITest.OpenTestChamber();
 
          CUITest.ClearTestChamber();
        }
        else
        {
          CUITest.ClearTestChamber();
          if (TestChamber.Parent != null) CUITest.CloseTestChamber();
        }
      }
    }
 
    public event Action<TestReport> OnTestReport;
 
    public void StopTest() => ActiveTest = null;
 
    public void RunAllTests()
    {
      foreach (Type testClass in GetAllTestClasses())
      {
        foreach (MethodInfo testMethod in GetAllAutoTestMethodsForAClass(testClass))
        {
          RunTest(testClass, testMethod);
        }
      }
    }
 
    public void ClearStash()
    {
      foreach (Type testClass in GetAllTestClasses())
      {
        foreach (MethodInfo testMethod in GetAllTestMethodsForAClass(testClass))
        {
          if (!Directory.Exists(Path.Combine(TestStashPath, testClass.Name)))
          {
            Directory.CreateDirectory(Path.Combine(TestStashPath, testClass.Name));
          }
 
          string testPath = Path.Combine(TestStashPath, testClass.Name, $"{testMethod.Name}.xml");
 
          if (File.Exists(testPath))
          {
            File.Delete(testPath);
            OnTestReport?.Invoke(new TestReport(testClass, testMethod, TestStatus.Unknown));
          }
        }
      }
    }
 
    public void RunTest(string fullName)
    {
      (Type testClass, MethodInfo testMethod) = DeconstructFullName(fullName);
      RunTest(testClass, testMethod);
    }
 
    public void RunTest(Type testClass, MethodInfo testMethod)
    {
      Action<CUIComponent> test = testMethod.CreateDelegate<Action<CUIComponent>>();
 
      ActiveTest = testMethod;
 
      try
      {
        test(TestChamber);
        TestChamber.MainComponent.Step();
 
 
        if (!Directory.Exists(Path.Combine(TestStashPath, testClass.Name)))
        {
          Directory.CreateDirectory(Path.Combine(TestStashPath, testClass.Name));
        }
 
        string testPath = Path.Combine(TestStashPath, testClass.Name, $"{testMethod.Name}.xml");
 
        if (!File.Exists(testPath))
        {
          OnTestReport?.Invoke(new TestReport(testClass, testMethod, TestStatus.Unknown));
          return;
        }
 
        string stashed = "";
        using (StreamReader reader = new StreamReader(testPath))
        {
          stashed = reader.ReadToEnd().Trim();
        }
 
        string real = TestChamber.Serialize(CUIAttribute.Calculated).Trim();
        if (stashed == real)
        {
          OnTestReport?.Invoke(new TestReport(testClass, testMethod, TestStatus.Passed));
        }
        else
        {
          OnTestReport?.Invoke(new TestReport(testClass, testMethod, TestStatus.Failed, DeepCompare(real, stashed)));
        }
      }
      catch (Exception e) { CUITest.Log(e, Color.Orange); }
    }
 
    public void StashTest(string fullName)
    {
      (Type testClass, MethodInfo testMethod) = DeconstructFullName(fullName);
      StashTest(testClass, testMethod);
    }
 
    public void StashTest(Type testClass, MethodInfo testMethod)
    {
      Action<CUIComponent> test = testMethod.CreateDelegate<Action<CUIComponent>>();
 
      ActiveTest = testMethod;
 
      try
      {
        test(TestChamber);
        TestChamber.MainComponent.Step();
 
 
        if (!Directory.Exists(Path.Combine(TestStashPath, testClass.Name)))
        {
          Directory.CreateDirectory(Path.Combine(TestStashPath, testClass.Name));
        }
 
        string testPath = Path.Combine(TestStashPath, testClass.Name, $"{testMethod.Name}.xml");
 
        using (StreamWriter writer = new StreamWriter(testPath, false))
        {
          writer.WriteLine(TestChamber.Serialize(CUIAttribute.Calculated));
        }
 
        OnTestReport?.Invoke(new TestReport(testClass, testMethod, TestStatus.Stashed));
      }
      catch (Exception e) { CUITest.Log(e, Color.Orange); }
    }
 
    public void PrintResultsToConsole(TestReport report)
    {
      string fullName = $"{report.TestClass.Name}.{report.TestMethod.Name}";
 
      if (report.Status is TestStatus.Passed)
      {
        CUITest.Log($"{fullName} Passed", Color.Lime);
      }
 
      if (report.Status is TestStatus.Unknown)
      {
        CUITest.Log($"{fullName} is not stashed yet", Color.Yellow);
      }
 
      if (report.Status is TestStatus.Stashed)
      {
        CUITest.Log($"{fullName} Stashed", Color.Cyan);
      }
 
      if (report.Status is TestStatus.Failed)
      {
        CUITest.Log($"{fullName} Failed", Color.Red);
        CUITest.Log(report.DeepCompare);
      }
    }
 
 
 
    public AutomaticTestRunner()
    {
      GUI = new AutoTestGUI(this);
      Config = new TestingConfig();
      Config.OnChanged += () => GUI.UseConfig(Config);
      Config.Load();
 
      if (Config.Autorun != "") RunTest(Config.Autorun);
 
      //GetClassMethodPairs().ToList().ForEach(t => CUITest.Log(t));
      OnTestReport += PrintResultsToConsole;
    }
  }
}