Completed
Last Updated: 22 Jun 2022 13:47 by ADMIN
Created by: Mihail
Comments: 4
Type: Bug Report
4

When a breakpoint is added inside an async test that uses JustMock the debugger is failing to hit it. 

To reproduce the issue follow the next steps:

1. Open the attached project

2. Create a breakpoint at the first arrangement in the async test method.

3. Start debugging the async test

Result: the breakpoint is not hit.

The issue is observed for both .NET Core and .NET Framework.

Completed
Last Updated: 22 Jun 2022 13:47 by ADMIN

Using the mentioned (or later) product version, the following simple test fails (throws NullReferenceException):

[TestMethod]
public void TestMethod()
{
    var cultureInfo = Mock.Create<CultureInfo>();
    var thisThrowsAnException = cultureInfo.Name;
}

One of the possible workarounds is to create a mock like this:

readonly string cultureName = CultureInfo.InvariantCulture.Name;
...
var cultureInfo = Mock.Create(() => new CultureInfo(cultureName));

Completed
Last Updated: 22 Jun 2022 13:46 by ADMIN

Using a different version of the NuGet package compared to the locally installed product could cause an unexpected error to occur, see the screenshot below:

image

 
Completed
Last Updated: 22 Jun 2022 13:45 by ADMIN

The case is reproducible (but might not be limited to) in a dedicated environment including Windows 10, JustMock R3.2021, Visual Studio 2019 and .NET 5. When the profiler is enabled the Visual Studio has problems with the test discovery and reports "Stack overflow" exception. The same applies to building solutions with Azure Function project.

CLR Stack from memory dump captured upon test execution:

000000CD7CE038D0 00007ffafb22d3b6 [GCFrame: 000000cd7ce038d0]
000000CD7CE03A40 00007ffafb22d3b6 [GCFrame: 000000cd7ce03a40]
000000CD7CE0A530 00007ffafb22d3b6 [PrestubMethodFrame: 000000cd7ce0a530] System.Runtime.Loader.AssemblyLoadContext.OnAssemblyResolve(System.Reflection.RuntimeAssembly, System.String)
000000CD7CE0A988 00007ffafb22d3b6 [GCFrame: 000000cd7ce0a988]
000000CD7CE0E3C0 00007ffafb22d3b6 [PrestubMethodFrame: 000000cd7ce0e3c0]  System.Runtime.Loader.AssemblyLoadContext.OnAssemblyResolve(System.Reflection.RuntimeAssembly, System.String)

... (omitted for brevity)

000000CD7CF72548 00007ffafb22d3b6 [GCFrame: 000000cd7cf72548]
000000CD7CF75F80 00007ffafb22d3b6 [PrestubMethodFrame: 000000cd7cf75f80] System.Runtime.Loader.AssemblyLoadContext.OnAssemblyResolve(System.Reflection.RuntimeAssembly, System.String)
000000CD7CF763D8 00007ffafb22d3b6 [GCFrame: 000000cd7cf763d8]
000000CD7CF79E10 00007ffafb22d3b6 [PrestubMethodFrame: 000000cd7cf79e10] System.Runtime.Loader.AssemblyLoadContext.OnAssemblyResolve(System.Reflection.RuntimeAssembly, System.String)
000000CD7CF7A268 00007ffafb22d3b6 [GCFrame: 000000cd7cf7a268]
000000CD7CF7DCA0 00007ffafb22d3b6 [PrestubMethodFrame: 000000cd7cf7dca0] System.Collections.Generic.Dictionary`2[[System.__Canon, System.Private.CoreLib],[System.__Canon, System.Private.CoreLib]]..ctor()
000000CD7CF7DF10 00007FFA9B787B2A System.AppContext..cctor() [/_/src/System.Private.CoreLib/shared/System/AppContext.cs @ 16]
000000CD7CF7E340 00007ffafb2b6c93 [GCFrame: 000000cd7cf7e340]
000000CD7CF7ED18 00007ffafb2b6c93 [HelperMethodFrame: 000000cd7cf7ed18]
000000CD7CF7EE20 00007FFA9B7876B9 System.AppContext.Setup(Char**, Char**, Int32)

 

Completed
Last Updated: 22 Jun 2022 13:44 by ADMIN
Currently, JustMock extension always uses the profiler deployed by the installation, which may be different from the one deployed by the JustMock.Commercial package. This could lead to unexpected failures in the rest run and different results inside and outside Visual Studio.
Unplanned
Last Updated: 03 Jun 2022 14:13 by Pam

Referencing the nuget Microsoft.ApplicationInsights.AspNetCore V2.20.0 in the project that is tested leads to the VS 2019 code coverage failing to produce the report. Here are the steps to reproduce:

1. Create a project from the template ASP.NET Core Web API targeting .NET 5

2. Add a reference to the nuget package Microsoft.ApplicationInsights.AspNetCore V2.20.0

3. Create a unit test project from the C# JustMock Test Project (.NET Core) template.

4. Run the VS code coverage.

Expected result: the code coverage report is produced.

Actual result: there is no code coverage report

Completed
Last Updated: 12 May 2022 07:51 by ADMIN
A System.InvalidProgramException is thrown when async unit tests are executed inside Visual Studio with code coverage. The unit tests are testing an implementation of Microsoft.Extensions.Caching.Distributed.IDistributedCache.
Completed
Last Updated: 10 Mar 2022 09:29 by ADMIN
Created by: Ivo
Comments: 0
Type: Bug Report
0

Considering the following simple scenario:

public class Class1
{
	private string arg1;

	public Class1(string arg1)
	{
		this.arg1 = arg1;
	}

	public Class3 Method(string arg)
	{
		throw new NotImplementedException();
	}
}

public class Class2
{
	static Class3 class3Instance; 

	public static void StaticMethod(string arg1, string arg2)
	{
		Class1 class1Instance = new Class1(arg1);
		class3Instance = class1Instance.Method(arg2);
	}
}

public class Class3
{

}

[TestClass]
public class Class2Test
{
	static Class1 mockClass1 = Mock.Create<Class1>();
	Class3 mockClass3 = Mock.Create<Class3>();

	[TestInitialize]
	public void SetUp()
	{
		Mock.Arrange(() => new Class1("arg1")).Returns(mockClass1);
		Mock.Arrange(() => mockClass1.Method("arg2")).Returns(mockClass3);
	}

	[TestMethod]
	public void TestB()
	{
		Class2.StaticMethod("arg1", "arg2");
	}
}

The test passes, but the debug trace output contains the warning message: "Calling one test method from another could result in unexpected behavior and must be avoided. Extract common mocking logic to a non-test method." even there is no call to the other test methods.

Completed
Last Updated: 10 Mar 2022 09:28 by ADMIN
An attempt to use Debug Window while debugging test code results in FileNotFoundException:

Exception thrown calling IDebugWindowPlugin plugin: System.IO.FileNotFoundException: Could not load file or assembly 'System.ServiceModel, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'. The system cannot find the file specified.
File name: 'System.ServiceModel, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089'
Unplanned
Last Updated: 12 Jan 2022 08:39 by ADMIN

Mock.Create<IPool>() fails with 

 

Telerik.JustMock.Core.MockException : Abstract type 'IPool' is not accessible for inheritance.
   In Telerik.JustMock.Core.MocksRepository.Create(Type type, MockCreationSettings settings)
   In Telerik.JustMock.Mock.<>c__39`1.<Create>b__39_0()
   In Telerik.JustMock.Core.ProfilerInterceptor.GuardInternal[T](Func`1 guardedAction) 

when trying to create a mock object from

public interface IPool

    {
        object GetItem(in Struct a, out Class b);
    }

 

 

Completed
Last Updated: 01 Dec 2021 14:07 by ADMIN
Created by: Jason
Comments: 2
Type: Bug Report
0

I've already created an issue in the JustMock repo, you can find it here: https://github.com/telerik/JustMockLite/issues/162. Below is the text from that issue...

I'm currently working on a PR to add JustMock to the suite of performance tests that currently exist in that repository. The problem is that some of the tests (like OneParameter and Callback) take a long time to finish for JustMock. I'm not sure why, but it's making it such that JustMock can't be added to the test suite. More to the point, the PR can't be accepted as-is because it would take too long to finish.

One thing Steve (owner of the repo) and I talked about is if the invocationCount value passed to the SimpleJobAttribute (which exists on both the MockingBenchmark and MockingBenchmark<T> classes) is reduced from 100,000 to something like 1,000, the tests then finish, but that doesn't address the underlying issue why these tests for JustMock slow down over repeated called.

There may be something in the benchmark tests with the way I've set things up with JustMock that may be incorrect. I've never used JustMock until today :). If there's something that I'm doing right, please let me know.

Unplanned
Last Updated: 01 Dec 2021 13:59 by ADMIN

Considering the sample class

using Azure.Messaging.ServiceBus;

public class Class2
{
	private static ServiceBusSender messageToTopicSender;
	private static string topicName;

	public static void SetRequestTopicClient(string serviceBusConnectionString, string topName)
	{
		topicName = topName;

		ServiceBusClient serviceBusClient = new ServiceBusClient(serviceBusConnectionString);
		messageToTopicSender = serviceBusClient.CreateSender(topicName);
	}
}

and the following tests

[TestClass]
public class Class1Test
{
	[TestInitialize]
	public void SetUp()
	{
		Mock.Arrange(() => Class2.SetRequestTopicClient("", "")).DoNothing();
	}

	[TestMethod]
	public void TestA()
	{
		Class2.SetRequestTopicClient("", "");
	}
}

[TestClass]
public class Class2Test
{
	static ServiceBusClient serviceBusClient = Mock.Create<ServiceBusClient>();
	ServiceBusSender messageToTopicSender = Mock.Create<ServiceBusSender>();

	[TestInitialize]
	public void SetUp()
	{
		Mock.Arrange(() => new ServiceBusClient("conStr")).Returns(serviceBusClient);
		Mock.Arrange(() => serviceBusClient.CreateSender("myTopic")).Returns(messageToTopicSender);
	}

	[TestMethod]
	public void TestB()
	{
		Class2.SetRequestTopicClient("conStr", "myTopic");
	}
}

Executing the tests in order TestA -> TestB results in failed TestB, but changing the order or runining them standalone succeeds.The outcome of the tests should not be dependent of the execution order.

 

Completed
Last Updated: 16 Sep 2021 08:40 by ADMIN
Created by: Calvin
Comments: 3
Type: Bug Report
0

I filed a prior ThreadLeak:

Thread leak in JustMock (telerik.com)

 

I think I've found another one: (VS version 16.10.31321.278)

telerik_justmock_debugwindow_service_client!Telerik.JustMock.DebugWindow.Service.Client.ServiceHostMonitor.MonitorTimer_Elapsed

Apparently, the MonitorTimer_Elapsed code is running on a threadpool thread and it takes longer than 1 sec (perhaps it's waiting on a lock?).

Another timer tick occurs and the method is called again. Eventually, the ThreadPool runs out of threads and grows by about 1 thread per second (1Mb /sec leak)

In one dump 2Gig was used (1962 threads on the same MonitorTimer_Elapsed stack frame)

In that same dump there were 52 stacks with this frame:

telerik_justmock_debugwindow_service_client!Telerik.JustMock.DebugWindow.Service.Client.ConnectionSetupServiceClientBase`[[System.__Canon,mscorlib]].get_ServiceAvailable

(this was the same item as my prior report).

 

Completed
Last Updated: 16 Sep 2021 08:38 by ADMIN

The following test fails:

[TestMethod]
public void TestCallOrderWithInOrder()
{
	// Arrange
	var mockClass1 = Mock.Create<Class1>();
	var mockClass2 = Mock.Create<Class2>();

	Mock.Arrange(() => mockClass1.Method1())
		.InOrder();
	Mock.Arrange(() => mockClass2.Method1())
		.InOrder()
		.Occurs(2);
	Mock.Arrange(() => mockClass1.Method2())
		.InOrder();

	// Act
	mockClass1.Method1();

	mockClass2.Method1();
	mockClass2.Method1(); // <--- this call is not allowed by
						  //      InOrder clause currently 
						  //      and throws AssertFailedException

	mockClass1.Method2();

	// Assert
	Mock.Assert(mockClass1);
	Mock.Assert(mockClass2);
}

Completed
Last Updated: 16 Sep 2021 08:37 by ADMIN

The following test is not working anymore since version JustMock_2021_2_615_4 but was working with JustMock_2021_1_326_1 and older versions:

public interface ITest
{
    void Test(string text);
}

[TestMethod]
public void MyTestMethod()
{
    var mock = Mock.Create<ITest>();
    Mock.Arrange(() => mock.Test("")).IgnoreArguments().OccursNever();
    Mock.Arrange(() => mock.Test(Arg.Matches<string>(a => a == "a"))).InOrder().OccursOnce();
    Mock.Arrange(() => mock.Test(Arg.Matches<string>(a => a == "b"))).InOrder().OccursOnce();


    mock.Test("a");
    mock.Test("b");

    Mock.Assert(mock);
}

If I remove the OccorsNever line, its working.
If I remove the 2 InOrder, its working.

Seems that something change there: https://www.telerik.com/support/whats-new/justmock/release-history/justmock-r2-sp1-2021

Completed
Last Updated: 17 Aug 2021 07:19 by ADMIN

Using elevated mocking mode (profiler enabled) with long path names for the test containers (above 260 characters) causes the following command:

dotnet test

to fail with error:

Testhost process exited with error: Fatal error. System.AccessViolationException: Attempted to read or write protected memory. This is often an indication that other memory is corrupt.
   at Microsoft.VisualStudio.TestPlatform.TestHost.Program.Main(System.String[])
. Please check the diagnostic logs for more information.

Test Run Aborted.

Unplanned
Last Updated: 02 Jun 2021 11:42 by ADMIN

The documentation on Fluent Mocking ends with this statement:

Important

Note that when you use Fluent Asserts only arrangements marked with either MustBeCalled or Occurs will be verified. For other tests you have to use the explicit assert.

What this fails to note is that, while this is true of the function "Assert", there is another function, "AssertAll", which will flag an error if any Arranged function call was not utilized.

 

On a related note, I left other suggestions for this same page a day or two ago.  I would have liked to leave the above statement using the same feedback utility, but I can no longer find the control that I used to leave those initial suggestions.

Unplanned
Last Updated: 26 May 2021 10:10 by ADMIN
String parameter "message" inside Mock.Assert APIs could be easily interpreted in the wrong way by associating them with the concrete assertion instead of the scope where this particular statement is taking place.
Unplanned
Last Updated: 18 May 2021 10:21 by ADMIN
JustMock Profiler prevents XAML Hot Reload and Visual Tree debugging functionalities. Disabling the profiler fixes the issue. This happens only for .NET Core WPF, under .NET Framework, everything runs as expected.
Unplanned
Last Updated: 13 May 2021 08:42 by ADMIN

We are trying to run unit tests via xUnit and mocking method occurence using JustMockLite. Method under arrange is creating a underlying Task however, once in a while test fails with following error

 


build	11-May-2021 14:36:09	               Telerik.JustMock.Xunit.AssertFailedException : Multiple assertion failures:
build	11-May-2021 14:36:09	               1. Occurrence expectation failed. Expected exactly 1 call. Calls so far: 0
build	11-May-2021 14:36:09	         Arrange expression: x => x.CallAsync(IsAny(), IsAny())
build	11-May-2021 14:36:09	               2. Occurrence expectation failed. Expected exactly 1 call. Calls so far: 0
build	11-May-2021 14:36:09	         Arrange expression: x => x.NotifyAsync(IsAny())
build	11-May-2021 14:36:09	               
build	11-May-2021 14:36:09	               ---- Telerik.JustMock.Diagnostics.DebugViewDetailsException : State:
build	11-May-2021 14:36:09	         Elevated mocking: disabled
build	11-May-2021 14:36:09	         
build	11-May-2021 14:36:09	         Arrangements and expectations:
build	11-May-2021 14:36:09	                   Arrangement (id=0) x => x.Load(IsAny()):
build	11-May-2021 14:36:09	                 Met: Occurences must be in [1, 1]; calls so far: 1. 
build	11-May-2021 14:36:09	             Arrangement (id=1) x => x.InitializePolicy(IsAny(), IsAny()):
build	11-May-2021 14:36:09	                 Met: Occurences must be in [1, 1]; calls so far: 1. 
build	11-May-2021 14:36:09	             Arrangement (id=2) x => x.RequestBulkSync(IsAny(), IsAny(), IsAny()):
build	11-May-2021 14:36:09	                 Met: Occurences must be in [any, 1]; calls so far: 1. 
build	11-May-2021 14:36:09	             Arrangement (id=3) x => x.CallAsync(IsAny(), IsAny()):
build	11-May-2021 14:36:09	                 Unmet: Occurences must be in [1, 1]; calls so far: 0. 
build	11-May-2021 14:36:09	             Arrangement (id=4) x => x.NotifyAsync(IsAny()):
build	11-May-2021 14:36:09	                 Unmet: Occurences must be in [1, 1]; calls so far: 0. 
build	11-May-2021 14:36:09	         
build	11-May-2021 14:36:09	         Invocations:

1 2 3 4 5