using System;
|
using System.Collections.Generic;
|
using System.IO;
|
using System.Linq;
|
using System.Runtime.Versioning;
|
using Mono.Cecil;
|
using Mono.Cecil.Cil;
|
using NUnit.Framework;
|
|
namespace OpenTap.Package.UnitTests;
|
|
[TestFixture]
|
public class UninstallContextTest
|
{
|
|
[Test]
|
public void TestDeleteFile()
|
{
|
var uninstallContext = UninstallContext.Create(Installation.Current);
|
|
// initially verify that all the files exist.
|
foreach (var file in Installation.Current.GetOpenTapPackage().Files)
|
{
|
Assert.That(File.Exists(file.RelativeDestinationPath));
|
}
|
|
foreach (var file in Installation.Current.GetOpenTapPackage().Files)
|
{
|
uninstallContext.Delete(file);
|
}
|
|
// After deleting the files verify that all files are deleted.
|
bool verifyAllFilesDeleted = true;
|
foreach (var file in Installation.Current.GetOpenTapPackage().Files)
|
{
|
if (File.Exists(file.RelativeDestinationPath))
|
{
|
verifyAllFilesDeleted = false;
|
}
|
}
|
|
uninstallContext.UndoAllDeletions();
|
|
Assert.That(verifyAllFilesDeleted, Is.True);
|
|
// finally after undo, verify that all files are back.
|
foreach (var file in Installation.Current.GetOpenTapPackage().Files)
|
{
|
Assert.That(File.Exists(file.RelativeDestinationPath));
|
}
|
Assert.That(File.Exists(".uninstall/.OpenTapIgnore"), Is.True);
|
|
}
|
|
class TestAsmDef(string assemblyName, string @namespace, string className, string displayName, int majorVersion, string helpLink = null)
|
{
|
public readonly string assemblyName = assemblyName;
|
public readonly string className = className;
|
public readonly string @namespace = @namespace;
|
public readonly string displayName = displayName;
|
public int majorVersion = majorVersion;
|
public readonly string helpLink = helpLink;
|
}
|
|
static string CreateNewAssemblyWithTestStep(TestAsmDef def)
|
{
|
var asmName = new AssemblyNameDefinition(def.assemblyName, new Version(def.majorVersion, 0));
|
string moduleName = "TestModule";
|
|
var asm = AssemblyDefinition.CreateAssembly(asmName, moduleName, ModuleKind.Dll);
|
|
var teststep = asm.MainModule.ImportReference(typeof(TestStep));
|
var runMethod = asm.MainModule.ImportReference(typeof(TestStep).GetMethod("Run", System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance)).Resolve();
|
var ctorMethod = asm.MainModule.ImportReference(typeof(TestStep).GetConstructor([])).Resolve();
|
|
// create dummy plugin
|
{
|
// Create new test step
|
var t = new TypeDefinition(def.@namespace, def.className, TypeAttributes.AnsiClass | TypeAttributes.BeforeFieldInit | TypeAttributes.Public, teststep);
|
asm.MainModule.Types.Add(t);
|
|
// Create default constructor
|
{
|
var ctor = new MethodDefinition(".ctor", ctorMethod.Attributes, asm.MainModule.TypeSystem.Void);
|
var il = ctor.Body.GetILProcessor();
|
il.Emit(OpCodes.Ldarg_0);
|
il.Emit(OpCodes.Call, t.Module.ImportReference(ctorMethod));
|
il.Emit(OpCodes.Ret);
|
t.Methods.Add(ctor);
|
}
|
|
// build Run() method
|
{
|
var newRunMethod = new MethodDefinition("Run", MethodAttributes.Public, runMethod.ReturnType) { IsHideBySig = true, IsVirtual = true };
|
var il = newRunMethod.Body.GetILProcessor();
|
il.Emit(OpCodes.Ret);
|
t.Methods.Add(newRunMethod);
|
}
|
|
// Add display attribute
|
{
|
Type attrType = typeof(DisplayAttribute);
|
object[] arguments = [def.displayName, "Runtime Generated Step", "Cecil", 1.0, false, Array.Empty<string>()];
|
Type[] signature = [ .. arguments.Select(x => x.GetType()) ];
|
var tCtor = t.Module.ImportReference(attrType.GetConstructor(signature));
|
var attr = new CustomAttribute(tCtor);
|
var attrArguments = arguments.Select(x => new CustomAttributeArgument(t.Module.ImportReference(x.GetType()), x));
|
foreach (var arg in attrArguments) attr.ConstructorArguments.Add(arg);
|
t.CustomAttributes.Add(attr);
|
}
|
// Add HelpLink attribute
|
if (def.helpLink != null)
|
{
|
Type attrType = typeof(HelpLinkAttribute);
|
object[] arguments = [def.helpLink];
|
Type[] signature = [ .. arguments.Select(x => x.GetType()) ];
|
var tCtor = t.Module.ImportReference(attrType.GetConstructor(signature));
|
var attr = new CustomAttribute(tCtor);
|
var attrArguments = arguments.Select(x => new CustomAttributeArgument(t.Module.ImportReference(x.GetType()), x));
|
foreach (var arg in attrArguments) attr.ConstructorArguments.Add(arg);
|
t.CustomAttributes.Add(attr);
|
}
|
}
|
|
var fp = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString() + ".dll");
|
asm.Write(fp);
|
return fp;
|
}
|
|
[Test]
|
public void TestLoadDifferentPluginVersions()
|
{
|
const string testAssemblyName = nameof(TestLoadDifferentPluginVersions);
|
var asmLocation = Path.Combine(Installation.Current.Directory, testAssemblyName + ".dll");
|
if (File.Exists(asmLocation)) File.Delete(asmLocation);
|
using var _ = Utils.WithDisposable(() => File.Delete(asmLocation));
|
|
var uninstall = UninstallContext.Create(Installation.Current);
|
var def1 = new TestAsmDef(testAssemblyName, "ns1", "stepclass", "First Name", 1);
|
var def2 = new TestAsmDef(testAssemblyName, "ns1", "stepclass", "Second Name", 2);
|
// Create two different versions of the same assembly with minor changes.
|
var asm1 = CreateNewAssemblyWithTestStep(def1);
|
var asm2 = CreateNewAssemblyWithTestStep(def2);
|
|
TypeData initialTd = null;
|
{
|
// Copy the assembly into the installation
|
File.Copy(asm1, asmLocation);
|
PluginManager.Search();
|
var td = TypeData.GetDerivedTypes<ITestStep>().FirstOrDefault(s => s.Name == $"{def1.@namespace}.{def1.className}");
|
Assert.That(td, Is.Not.Null);
|
var disp1 = td.GetDisplayAttribute();
|
Assert.That(disp1.GetFullName(), Is.EqualTo("Cecil \\ First Name"));
|
// load the plugin. By loading the plugin, we prevent the Searcher from invalidating it.
|
td.AsTypeData().Load();
|
initialTd = td.AsTypeData();
|
}
|
|
|
// Verify the type still exists after deletion
|
{
|
uninstall.Delete(new PackageFile() { FileName = testAssemblyName + ".dll", RelativeDestinationPath = testAssemblyName + ".dll" });
|
PluginManager.Search();
|
var td = TypeData.GetDerivedTypes<ITestStep>().FirstOrDefault(s => s.Name == $"{def1.@namespace}.{def1.className}");
|
Assert.That(td, Is.Not.Null);
|
Assert.That(td.AsTypeData().Type, Is.Not.Null);
|
}
|
|
// Uninstall the type
|
uninstall.Delete(new PackageFile() { FileName = testAssemblyName + ".dll", RelativeDestinationPath = testAssemblyName + ".dll" });
|
|
// Verify that the type now remains even if it was deleted
|
{
|
PluginManager.Search();
|
var td = TypeData.GetDerivedTypes<ITestStep>().FirstOrDefault(s => s.Name == $"{def1.@namespace}.{def1.className}");
|
Assert.That(td, Is.Not.Null);
|
Type tp = td.AsTypeData().Type;
|
Assert.That(tp, Is.Not.Null);
|
Assert.That(tp.Assembly.Location, Does.Not.Exist);
|
}
|
|
// Verify that the old type name is still used after updating the dll
|
{
|
File.Copy(asm2, asmLocation);
|
PluginManager.Search();
|
var td = TypeData.GetDerivedTypes<ITestStep>().FirstOrDefault(s => s.Name == $"{def1.@namespace}.{def1.className}");
|
Assert.That(td, Is.Not.Null);
|
var disp1 = td.GetDisplayAttribute();
|
Assert.That(disp1.GetFullName(), Is.EqualTo("Cecil \\ First Name"));
|
}
|
|
// Verify that the first loaded typedata is still valid
|
{
|
Assert.That(initialTd, Is.Not.Null);
|
var disp1 = initialTd.GetDisplayAttribute();
|
Assert.That(disp1.GetFullName(), Is.EqualTo("Cecil \\ First Name"));
|
var step = (TestStep)initialTd.CreateInstance();
|
}
|
|
// Verify that the actual file on disk is the 2nd variant
|
{
|
var newSearcher = new PluginSearcher();
|
newSearcher.Search([asmLocation]);
|
Dictionary<string, TypeData> allTypes = (Dictionary<string, TypeData>)newSearcher.GetType()
|
.GetField("AllTypes", System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic)
|
.GetValue(newSearcher);
|
Assert.That(allTypes, Is.Not.Null);
|
Assert.That(allTypes.Count, Is.EqualTo(1));
|
Assert.That(allTypes[$"{def1.@namespace}.{def1.className}"].GetDisplayAttribute().GetFullName(), Is.EqualTo("Cecil \\ Second Name"));
|
}
|
}
|
|
[Test]
|
public void TestUpgradeUnloadedPluginTypes()
|
{
|
const string testAssemblyName = nameof(TestUpgradeUnloadedPluginTypes);
|
// This test is very similar to the first variant.
|
// The difference is that this variant does not load the plugin initially.
|
// This verifies the functionality that we should be able to remove / update a plugin if it has not been loaded previously.
|
var asmLocation = Path.Combine(Installation.Current.Directory, testAssemblyName + ".dll");
|
if (File.Exists(asmLocation)) File.Delete(asmLocation);
|
using var _ = Utils.WithDisposable(() => File.Delete(asmLocation));
|
|
var uninstall = UninstallContext.Create(Installation.Current);
|
var def1 = new TestAsmDef(testAssemblyName, "ns2", "stepclass", "First Name", 1);
|
var def2 = new TestAsmDef(testAssemblyName, "ns2", "stepclass", "Second Name", 2);
|
// Create two different versions of the same assembly with minor changes.
|
var asm1 = CreateNewAssemblyWithTestStep(def1);
|
var asm2 = CreateNewAssemblyWithTestStep(def2);
|
|
{
|
// Copy the assembly into the installation
|
File.Copy(asm1, asmLocation);
|
PluginManager.Search();
|
var td = TypeData.GetDerivedTypes<ITestStep>().FirstOrDefault(s => s.Name == $"{def1.@namespace}.{def1.className}");
|
Assert.That(td, Is.Not.Null);
|
var disp1 = td.GetDisplayAttribute();
|
Assert.That(disp1.GetFullName(), Is.EqualTo("Cecil \\ First Name"));
|
bool loaded = td.AsTypeData().IsAssemblyLoaded();
|
}
|
|
|
// Verify that the type is gone after uninstalling it
|
{
|
uninstall.Delete(new PackageFile() { FileName = testAssemblyName + ".dll", RelativeDestinationPath = testAssemblyName + ".dll" });
|
PluginManager.Search();
|
var td = TypeData.GetDerivedTypes<ITestStep>().FirstOrDefault(s => s.Name == $"{def1.@namespace}.{def1.className}");
|
Assert.That(td, Is.Null);
|
}
|
|
// Verify that we get the new version by updating the dll
|
{
|
File.Copy(asm2, asmLocation);
|
PluginManager.Search();
|
var td = TypeData.GetDerivedTypes<ITestStep>().FirstOrDefault(s => s.Name == $"{def1.@namespace}.{def1.className}");
|
Assert.That(td, Is.Not.Null);
|
var disp1 = td.GetDisplayAttribute();
|
Assert.That(disp1.GetFullName(), Is.EqualTo("Cecil \\ Second Name"));
|
}
|
}
|
|
[Test]
|
public void TestAttributeScanning()
|
{
|
const string testAssemblyName = nameof(TestAttributeScanning);
|
var asmLocation = Path.Combine(Installation.Current.Directory, testAssemblyName + ".dll");
|
if (File.Exists(asmLocation)) File.Delete(asmLocation);
|
var def1 = new TestAsmDef(testAssemblyName, "AttributeTest", "MyStepClass", "My Type", 1,
|
helpLink: "example helplink string");
|
var asm1 = CreateNewAssemblyWithTestStep(def1);
|
File.Copy(asm1, asmLocation);
|
using var _ = Utils.WithDisposable(() => File.Delete(asmLocation));
|
PluginManager.Search();
|
|
var td = TypeData.GetDerivedTypes<ITestStep>().FirstOrDefault(s => s.Name == $"{def1.@namespace}.{def1.className}").AsTypeData();
|
{
|
Assert.That(td, Is.Not.Null);
|
Assert.That(td.IsAssemblyLoaded(), Is.False);
|
}
|
{
|
var disp1 = td.GetDisplayAttribute();
|
Assert.That(disp1.GetFullName(), Is.EqualTo("Cecil \\ My Type"));
|
Assert.That(td.IsAssemblyLoaded(), Is.False);
|
}
|
{
|
var disp2 = td.GetAttribute<DisplayAttribute>();
|
Assert.That(disp2.GetFullName(), Is.EqualTo("Cecil \\ My Type"));
|
Assert.That(td.IsAssemblyLoaded(), Is.False);
|
}
|
{
|
Assert.That(td.IsBrowsable, Is.True);
|
Assert.That(td.IsAssemblyLoaded(), Is.False);
|
}
|
{
|
var help = td.GetAttribute<HelpLinkAttribute>();
|
Assert.That(help, Is.Not.Null);
|
Assert.That(help.HelpLink, Is.EqualTo("example helplink string"));
|
Assert.That(td.IsAssemblyLoaded(), Is.False);
|
}
|
}
|
|
[SupportedOSPlatform("ios")]
|
public class UnsupportedStep : TestStep
|
{
|
public override void Run()
|
{
|
}
|
}
|
|
[SupportedOSPlatform("osx")]
|
[SupportedOSPlatform("macos")]
|
[SupportedOSPlatform("windows")]
|
[SupportedOSPlatform("linux")]
|
public class SupportedStep : TestStep
|
{
|
public override void Run()
|
{
|
}
|
}
|
|
[TestCase(typeof(UnsupportedStep), false)]
|
[TestCase(typeof(SupportedStep), true)]
|
public void TestSupportedOSPlatformScanned(Type t, bool supported)
|
{
|
var td = TypeData.FromType(t);
|
var scanned = TypeData.GetDerivedTypes<ITestStep>().FirstOrDefault(x => x.Name == td.Name);
|
TypeData expected = supported ? td : null;
|
Assert.That(scanned, Is.EqualTo(expected));
|
}
|
}
|
