6749638574

Committed 03 Nov 2023 08:00PM UTC coverage: 44.916% (+1.1%) from 43.795%

Build # 6749638574

Build Type

push

github

Committed by

luttje

Commit Message

fix JS failing on callback/function parameter + add tests

Run Details

802 of 2447 branches covered (0.0%)

Branch coverage included in aggregate %.

75 of 76 new or added lines in 4 files covered. (98.68%)

147 existing lines in 11 files now uncovered.

4048 of 8351 relevant lines covered (48.47%)

17051.46 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

92.63

/Support/Key2Joy.Tests/Core/Mapping/Actions/Scripting/ExposedMethodTests.cs

using Key2Joy.Mapping.Actions.Scripting;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Moq;
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;

namespace Key2Joy.Tests.Core.Mapping.Actions.Scripting;

public class MockExposedMethod : ExposedMethod
{
    public MockExposedMethod()
        : base("functionName", "methodName")
    { }

    public MockExposedMethod(string functionName, string methodName)
        : base(functionName, methodName)
    { }

    public override IList<Type> GetParameterTypes(out IList<object> parameterDefaultValues, out bool isLastParameterParams)
        => throw new NotImplementedException();

    public override object InvokeMethod(object[] transformedParameters)
        => transformedParameters;

    public object GetInstance() => this.Instance;
}

public class MockType
{
    public void MethodWithNoParameters()
    { }

    public string MethodThatConcatsParameters(string p1, int p2)
        => p1 + p2;

    public string MethodThatConcatsFloatParameters(float p1, float p2)
        => $"{p1.ToString(new CultureInfo("en_US"))}|{p2.ToString(new CultureInfo("en_US"))}";

    public string MethodThatConcatsParametersAndHasParams(string p1, int p2, params string[] p3)
        => p1 + p2 + string.Join("/", p3);

    public string MethodWithDefaultParameters(string p1, int p2 = 2)
        => $"{p1}|{p2}";
}

[TestClass]
public class ExposedMethodTests
{
    [TestMethod]
    public void Test_Prepare_SetsInstanceAndParameterTypes()
    {
        var exposedMethod = new Mock<MockExposedMethod>() { CallBase = true };

        IList<object> _;
        bool __;
        exposedMethod.Setup(m => m.GetParameterTypes(out _, out __)).Returns(new List<Type> { typeof(string), typeof(int) });

        var instance = new object();
        exposedMethod.Object.Prepare(instance);

        Assert.AreEqual(instance, exposedMethod.Object.GetInstance());

        var resultingParameters = (object[])exposedMethod.Object.TransformAndRedirect("test", 2);
        Assert.IsInstanceOfType(resultingParameters[0], typeof(string));
        Assert.IsInstanceOfType(resultingParameters[1], typeof(int));
    }

    [TestMethod]
    [ExpectedException(typeof(InvalidOperationException))]
    public void Test_RegisterParameterTransformer_FailsIfNotPrepared()
    {
        var exposedMethod = new Mock<MockExposedMethod>() { CallBase = true };

        exposedMethod.Object.RegisterParameterTransformer<int>((p, t) => p * 2);
    }

    [TestMethod]
    public void Test_RegisterParameterTransformer_ReplacesExistingTransformer()
    {
        var exposedMethod = new Mock<MockExposedMethod>() { CallBase = true };

        IList<object> _;
        bool __;
        exposedMethod.Setup(m => m.GetParameterTypes(out _, out __)).Returns(new List<Type> { typeof(int) });
        var instance = new object();
        exposedMethod.Object.Prepare(instance);

        exposedMethod.Object.RegisterParameterTransformer<int>((p, t) => p * 2);
        exposedMethod.Object.RegisterParameterTransformer<int>((p, t) => p * 3);

        var resultingParameters = (object[])exposedMethod.Object.TransformAndRedirect(1);
        Assert.AreEqual(3, resultingParameters[0]); // Ensures the transformer was replaced, not added
    }

    [TestMethod]
    [ExpectedException(typeof(InvalidOperationException))]
    public void Test_TransformAndRedirect_FailsIfNotPrepared()
    {
        var exposedMethod = new Mock<MockExposedMethod>() { CallBase = true };

        IList<object> _;
        bool __;
        exposedMethod.Setup(m => m.GetParameterTypes(out _, out __)).Returns(new List<Type> { typeof(DayOfWeek) });
        exposedMethod.Setup(m => m.InvokeMethod(It.IsAny<object[]>())).Returns<object[]>(p => p[0]);

        var resultingParameters = (object[])exposedMethod.Object.TransformAndRedirect(nameof(DayOfWeek.Monday));
    }

    [TestMethod]
    public void Test_TransformAndRedirect_EnumConversion()
    {
        var exposedMethod = new Mock<MockExposedMethod>() { CallBase = true };

        IList<object> _;
        bool __;
        exposedMethod.Setup(m => m.GetParameterTypes(out _, out __)).Returns(new List<Type> { typeof(DayOfWeek) });

        var instance = new object();
        exposedMethod.Object.Prepare(instance);

        var resultingParameters = (object[])exposedMethod.Object.TransformAndRedirect(nameof(DayOfWeek.Monday));
        var resultingParameters2 = (object[])exposedMethod.Object.TransformAndRedirect((int)DayOfWeek.Monday);

        Assert.AreEqual(DayOfWeek.Monday, resultingParameters[0]);
        Assert.AreEqual(DayOfWeek.Monday, resultingParameters2[0]);
    }

    [TestMethod]
    public void Test_TransformAndRedirect_ObjectArrayConversion()
    {
        var exposedMethod = new Mock<MockExposedMethod>() { CallBase = true };

        IList<object> _;
        bool __;
        exposedMethod.Setup(m => m.GetParameterTypes(out _, out __)).Returns(new List<Type> { typeof(string[]), typeof(int[]) });

        var instance = new object();
        exposedMethod.Object.Prepare(instance);

        var objectArray = new object[] { "string", "anotherString" };
        var intArray = new int[] { 1, 2 };
        var resultingParameters = (object[])exposedMethod.Object.TransformAndRedirect(objectArray, intArray);

        Assert.IsInstanceOfType<string[]>(resultingParameters[0]);
        Assert.AreEqual(((string[])resultingParameters[0])[1], "anotherString");

        Assert.IsInstanceOfType<int[]>(resultingParameters[1]);
        Assert.AreEqual(((int[])resultingParameters[1])[1], 2);
    }

    [TestMethod]
    [ExpectedException(typeof(InvalidOperationException))]
    public void Test_TransformAndRedirect_InvalidOperationException()
    {
        var exposedMethod = new Mock<MockExposedMethod>() { CallBase = true };

        IList<object> _;
        bool __;
        exposedMethod.Setup(m => m.GetParameterTypes(out _, out __)).Returns(new List<Type> { typeof(MockExposedMethod) });

        exposedMethod.Object.TransformAndRedirect(new object());
    }

    [TestMethod]
    public void Test_TypeExposedMethod_GetParameterTypesIfNone()
    {
        var exposedMethod = new TypeExposedMethod("functionName", nameof(MockType.MethodWithNoParameters), typeof(MockType));

        var parameterTypes = exposedMethod.GetParameterTypes(out var _, out var _);

        Assert.IsFalse(parameterTypes.Any());
    }

    [TestMethod]
    public void Test_TypeExposedMethod_GetParameterTypes()
    {
        var exposedMethod = new TypeExposedMethod("functionName", nameof(MockType.MethodThatConcatsParameters), typeof(MockType));

        var parameterTypes = exposedMethod.GetParameterTypes(out var _, out var _).ToList();

        CollectionAssert.AreEqual(parameterTypes, new Type[] { typeof(string), typeof(int) });
    }

    [TestMethod]
    public void Test_TypeExposedMethod_InvokeMethod()
    {
        var exposedMethod = new TypeExposedMethod("functionName", nameof(MockType.MethodThatConcatsParameters), typeof(MockType));

        var instance = new MockType();
        exposedMethod.Prepare(instance);

        var result = exposedMethod.InvokeMethod(new object[] { "1", 23 });

        Assert.AreEqual("123", result);
    }

    [TestMethod]
    public void Test_TypeExposedMethod_InvokeMethodLenientCast()
    {
        var exposedMethod = new TypeExposedMethod("functionName", nameof(MockType.MethodThatConcatsFloatParameters), typeof(MockType));

        var instance = new MockType();
        exposedMethod.Prepare(instance);

        var result = (string)exposedMethod.TransformAndRedirect(new object[] { 1.5d, 2.5d });

        Assert.AreEqual("1.5|2.5", result);
    }

    [TestMethod]
    public void Test_TypeExposedMethod_InvokeMethodImpliedEmptyParams()
    {
        var exposedMethod = new TypeExposedMethod("functionName", nameof(MockType.MethodThatConcatsParametersAndHasParams), typeof(MockType));

        var instance = new MockType();
        exposedMethod.Prepare(instance);

        var result = (string)exposedMethod.TransformAndRedirect(new object[] { "1", 23 }); // No params

        Assert.AreEqual("123", result);
    }

    [TestMethod]
    public void Test_TypeExposedMethod_InvokeMethodWithDefaultParameters()
    {
        var exposedMethod = new TypeExposedMethod("functionName", nameof(MockType.MethodWithDefaultParameters), typeof(MockType));

        var instance = new MockType();
        exposedMethod.Prepare(instance);

        var result = (string)exposedMethod.TransformAndRedirect(new object[] { "1" });

        Assert.AreEqual("1|2", result);
    }
}

1	using Key2Joy.Mapping.Actions.Scripting;
2	using Microsoft.VisualStudio.TestTools.UnitTesting;
3	using Moq;
4	using System;
5	using System.Collections.Generic;
6	using System.Globalization;
7	using System.Linq;
8
9	namespace Key2Joy.Tests.Core.Mapping.Actions.Scripting;
10
11	public class MockExposedMethod : ExposedMethod
12	{
13	public MockExposedMethod()
14	: base("functionName", "methodName")	7✔
15	{ }	7✔
16
17	public MockExposedMethod(string functionName, string methodName)
18	: base(functionName, methodName)	×
UNCOV 19	{ }	×
20
21	public override IList<Type> GetParameterTypes(out IList<object> parameterDefaultValues, out bool isLastParameterParams)
UNCOV 22	=> throw new NotImplementedException();	×
23
24	public override object InvokeMethod(object[] transformedParameters)
25	=> transformedParameters;	5✔
26
27	public object GetInstance() => this.Instance;	1✔
28	}
29
30	public class MockType
31	{
32	public void MethodWithNoParameters()
UNCOV 33	{ }	×
34
35	public string MethodThatConcatsParameters(string p1, int p2)
36	=> p1 + p2;	1✔
37
38	public string MethodThatConcatsFloatParameters(float p1, float p2)
39	=> $"{p1.ToString(new CultureInfo("en_US"))}\|{p2.ToString(new CultureInfo("en_US"))}";	1✔
40
41	public string MethodThatConcatsParametersAndHasParams(string p1, int p2, params string[] p3)
42	=> p1 + p2 + string.Join("/", p3);	1✔
43
44	public string MethodWithDefaultParameters(string p1, int p2 = 2)
45	=> $"{p1}\|{p2}";	1✔
46	}
47
48	[TestClass]
49	public class ExposedMethodTests
50	{
51	[TestMethod]
52	public void Test_Prepare_SetsInstanceAndParameterTypes()
53	{
54	var exposedMethod = new Mock<MockExposedMethod>() { CallBase = true };	1✔
55
56	IList<object> _;
57	bool __;
58	exposedMethod.Setup(m => m.GetParameterTypes(out _, out __)).Returns(new List<Type> { typeof(string), typeof(int) });	1✔
59
60	var instance = new object();	1✔
61	exposedMethod.Object.Prepare(instance);	1✔
62
63	Assert.AreEqual(instance, exposedMethod.Object.GetInstance());	1✔
64
65	var resultingParameters = (object[])exposedMethod.Object.TransformAndRedirect("test", 2);	1✔
66	Assert.IsInstanceOfType(resultingParameters[0], typeof(string));	1✔
67	Assert.IsInstanceOfType(resultingParameters[1], typeof(int));	1✔
68	}	1✔
69
70	[TestMethod]
71	[ExpectedException(typeof(InvalidOperationException))]
72	public void Test_RegisterParameterTransformer_FailsIfNotPrepared()
73	{
74	var exposedMethod = new Mock<MockExposedMethod>() { CallBase = true };	1✔
75
76	exposedMethod.Object.RegisterParameterTransformer<int>((p, t) => p * 2);	1✔
UNCOV 77	}	×
78
79	[TestMethod]
80	public void Test_RegisterParameterTransformer_ReplacesExistingTransformer()
81	{
82	var exposedMethod = new Mock<MockExposedMethod>() { CallBase = true };	1✔
83
84	IList<object> _;
85	bool __;
86	exposedMethod.Setup(m => m.GetParameterTypes(out _, out __)).Returns(new List<Type> { typeof(int) });	1✔
87	var instance = new object();	1✔
88	exposedMethod.Object.Prepare(instance);	1✔
89
90	exposedMethod.Object.RegisterParameterTransformer<int>((p, t) => p * 2);	1✔
91	exposedMethod.Object.RegisterParameterTransformer<int>((p, t) => p * 3);	2✔
92
93	var resultingParameters = (object[])exposedMethod.Object.TransformAndRedirect(1);	1✔
94	Assert.AreEqual(3, resultingParameters[0]); // Ensures the transformer was replaced, not added	1✔
95	}	1✔
96
97	[TestMethod]
98	[ExpectedException(typeof(InvalidOperationException))]
99	public void Test_TransformAndRedirect_FailsIfNotPrepared()
100	{
101	var exposedMethod = new Mock<MockExposedMethod>() { CallBase = true };	1✔
102
103	IList<object> _;
104	bool __;
105	exposedMethod.Setup(m => m.GetParameterTypes(out _, out __)).Returns(new List<Type> { typeof(DayOfWeek) });	1✔
106	exposedMethod.Setup(m => m.InvokeMethod(It.IsAny<object[]>())).Returns<object[]>(p => p[0]);	1✔
107
108	var resultingParameters = (object[])exposedMethod.Object.TransformAndRedirect(nameof(DayOfWeek.Monday));	1✔
UNCOV 109	}	×
110
111	[TestMethod]
112	public void Test_TransformAndRedirect_EnumConversion()
113	{
114	var exposedMethod = new Mock<MockExposedMethod>() { CallBase = true };	1✔
115
116	IList<object> _;
117	bool __;
118	exposedMethod.Setup(m => m.GetParameterTypes(out _, out __)).Returns(new List<Type> { typeof(DayOfWeek) });	1✔
119
120	var instance = new object();	1✔
121	exposedMethod.Object.Prepare(instance);	1✔
122
123	var resultingParameters = (object[])exposedMethod.Object.TransformAndRedirect(nameof(DayOfWeek.Monday));	1✔
124	var resultingParameters2 = (object[])exposedMethod.Object.TransformAndRedirect((int)DayOfWeek.Monday);	1✔
125
126	Assert.AreEqual(DayOfWeek.Monday, resultingParameters[0]);	1✔
127	Assert.AreEqual(DayOfWeek.Monday, resultingParameters2[0]);	1✔
128	}	1✔
129
130	[TestMethod]
131	public void Test_TransformAndRedirect_ObjectArrayConversion()
132	{
133	var exposedMethod = new Mock<MockExposedMethod>() { CallBase = true };	1✔
134
135	IList<object> _;
136	bool __;
137	exposedMethod.Setup(m => m.GetParameterTypes(out _, out __)).Returns(new List<Type> { typeof(string[]), typeof(int[]) });	1✔
138
139	var instance = new object();	1✔
140	exposedMethod.Object.Prepare(instance);	1✔
141
142	var objectArray = new object[] { "string", "anotherString" };	1✔
143	var intArray = new int[] { 1, 2 };	1✔
144	var resultingParameters = (object[])exposedMethod.Object.TransformAndRedirect(objectArray, intArray);	1✔
145
146	Assert.IsInstanceOfType<string[]>(resultingParameters[0]);	1✔
147	Assert.AreEqual(((string[])resultingParameters[0])[1], "anotherString");	1✔
148
149	Assert.IsInstanceOfType<int[]>(resultingParameters[1]);	1✔
150	Assert.AreEqual(((int[])resultingParameters[1])[1], 2);	1✔
151	}	1✔
152
153	[TestMethod]
154	[ExpectedException(typeof(InvalidOperationException))]
155	public void Test_TransformAndRedirect_InvalidOperationException()
156	{
157	var exposedMethod = new Mock<MockExposedMethod>() { CallBase = true };	1✔
158
159	IList<object> _;
160	bool __;
161	exposedMethod.Setup(m => m.GetParameterTypes(out _, out __)).Returns(new List<Type> { typeof(MockExposedMethod) });	1✔
162
163	exposedMethod.Object.TransformAndRedirect(new object());	1✔
UNCOV 164	}	×
165
166	[TestMethod]
167	public void Test_TypeExposedMethod_GetParameterTypesIfNone()
168	{
169	var exposedMethod = new TypeExposedMethod("functionName", nameof(MockType.MethodWithNoParameters), typeof(MockType));	1✔
170
171	var parameterTypes = exposedMethod.GetParameterTypes(out var _, out var _);	1✔
172
173	Assert.IsFalse(parameterTypes.Any());	1✔
174	}	1✔
175
176	[TestMethod]
177	public void Test_TypeExposedMethod_GetParameterTypes()
178	{
179	var exposedMethod = new TypeExposedMethod("functionName", nameof(MockType.MethodThatConcatsParameters), typeof(MockType));	1✔
180
181	var parameterTypes = exposedMethod.GetParameterTypes(out var _, out var _).ToList();	1✔
182
183	CollectionAssert.AreEqual(parameterTypes, new Type[] { typeof(string), typeof(int) });	1✔
184	}	1✔
185
186	[TestMethod]
187	public void Test_TypeExposedMethod_InvokeMethod()
188	{
189	var exposedMethod = new TypeExposedMethod("functionName", nameof(MockType.MethodThatConcatsParameters), typeof(MockType));	1✔
190
191	var instance = new MockType();	1✔
192	exposedMethod.Prepare(instance);	1✔
193
194	var result = exposedMethod.InvokeMethod(new object[] { "1", 23 });	1✔
195
196	Assert.AreEqual("123", result);	1✔
197	}	1✔
198
199	[TestMethod]
200	public void Test_TypeExposedMethod_InvokeMethodLenientCast()
201	{
202	var exposedMethod = new TypeExposedMethod("functionName", nameof(MockType.MethodThatConcatsFloatParameters), typeof(MockType));	1✔
203
204	var instance = new MockType();	1✔
205	exposedMethod.Prepare(instance);	1✔
206
207	var result = (string)exposedMethod.TransformAndRedirect(new object[] { 1.5d, 2.5d });	1✔
208
209	Assert.AreEqual("1.5\|2.5", result);	1✔
210	}	1✔
211
212	[TestMethod]
213	public void Test_TypeExposedMethod_InvokeMethodImpliedEmptyParams()
214	{
215	var exposedMethod = new TypeExposedMethod("functionName", nameof(MockType.MethodThatConcatsParametersAndHasParams), typeof(MockType));	1✔
216
217	var instance = new MockType();	1✔
218	exposedMethod.Prepare(instance);	1✔
219
220	var result = (string)exposedMethod.TransformAndRedirect(new object[] { "1", 23 }); // No params	1✔
221
222	Assert.AreEqual("123", result);	1✔
223	}	1✔
224
225	[TestMethod]
226	public void Test_TypeExposedMethod_InvokeMethodWithDefaultParameters()
227	{
228	var exposedMethod = new TypeExposedMethod("functionName", nameof(MockType.MethodWithDefaultParameters), typeof(MockType));	1✔
229
230	var instance = new MockType();	1✔
231	exposedMethod.Prepare(instance);	1✔
232
233	var result = (string)exposedMethod.TransformAndRedirect(new object[] { "1" });	1✔
234
235	Assert.AreEqual("1\|2", result);	1✔
236	}	1✔
237	}

luttje / Key2Joy / 6749638574

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous