JsConfig Scope spill over to normal requests

[dlj]

Hello

Using HttpResult with ResultScope, as written in the documentation, seem to have an effect on other calls.
If a request is called after, sporadically the default JsConfig does not seem to apply.

Crude reproduction included, reproduced on SS 5.6.1

using Funq;
using ServiceStack;
using ServiceStack.Text;
using System;
using System.Diagnostics;
using System.Net.Http;
using System.Threading.Tasks;

namespace WebApplication1
{
    public class TestResponse
    {
        public int Id { get; set; }
        public int? nullableint { get; set; }
        public DateTime tmpDate { get; set; } = DateTime.UtcNow;
    }

    public class GetNormal { }
    public class GetHTTPResultWithResultScope { }

    public class MysService : Service
    {
        public object Get(GetNormal request)
        {
            return new TestResponse() { Id = 1 };
        }

        public object Get(GetHTTPResultWithResultScope request)
        {
            return new HttpResult(new TestResponse() { Id = 1 })
            {
                ResultScope = () => ServiceStack.Text.JsConfig.With(new ServiceStack.Text.Config { IncludeNullValues = true, DateHandler = DateHandler.UnixTime })
            };
        }
    }

    public class Global : System.Web.HttpApplication
    {
        const string URL = "http://localhost:54321";
        protected void Application_Start(object sender, EventArgs e)
        {
            var service = new RestService();
            service.Init();

            load();
        }

        public async Task loadhttp()
        {
            var client = new HttpClient();
            var x = await client.GetAsync($"{URL}/json/reply/GetHTTPResultWithResultScope");
            var body = await x.Content.ReadAsStringAsync();

            if (body.Contains("null"))
            {
                Debug.WriteLine($"HttpResult : Body had Null, Everything is okay");
            }
        }

        public async Task loadnormal(int i = 0)
        {
            var client = new HttpClient();
            var x = await client.GetAsync($"{URL}/json/reply/GetNormal");
            var body = await x.Content.ReadAsStringAsync();

            if (body.Contains("null"))
            {
                Debug.WriteLine($"Iteration {i} : Warning, Body had Null");
                throw new Exception("This should not be null");
            }
        }

        public async void load()
        {
            await loadnormal();
            await loadhttp();
            for (int i = 0; i < 100; i++)
            {
                await loadnormal(i);
            }

        }
    }

    public class RestService : AppHostHttpListenerBase
    {
        public RestService() : base("RestService", typeof(Global).Assembly)
        {

        }

        public override void Configure(Container container)
        {
            JsConfig.Init(new ServiceStack.Text.Config
            {
                IncludeNullValues = false,
                DateHandler = DateHandler.ISO8601
            });

            SetConfig(new HostConfig
            {
                DebugMode = true,
                StrictMode = true,
            });
        }
    }
}

[mythz]

I can't repro this.

I've converted this to a Unit test which I can run against a Self Host and a against a Remote Host and incremented the iteration count to 1000 and can't get it to fail:

using System;
using System.Diagnostics;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;
using Funq;
using NUnit.Framework;
using ServiceStack;
using ServiceStack.Text;

namespace Issues.Tests
{
    public class TestResponse
    {
        public int Id { get; set; }
        public int? nullableint { get; set; }
        public DateTime tmpDate { get; set; } = DateTime.UtcNow;
    }

    public class GetNormal { }
    public class GetHTTPResultWithResultScope { }

    public class MyServices : Service
    {
        public object Get(GetNormal request)
        {
            return new TestResponse { Id = 1 };
        }

        public object Get(GetHTTPResultWithResultScope request)
        {
            return new HttpResult(new TestResponse { Id = 1 })
            {
                ResultScope = () => JsConfig.With(new Config { IncludeNullValues = true, DateHandler = DateHandler.UnixTime })
            };
        }
    }

    public abstract class JsConfigScopeIssueBase
    {
        public abstract string BaseUrl { get; }
        
        public async Task load(int times)
        {
            await loadnormal();
            await loadhttp();
            for (int i = 0; i < times; i++)
            {
//                await loadhttp(i);
                await loadnormal(i);
            }

        }
        
        public async Task loadhttp(int i = 0)
        {
            var client = new HttpClient();
            var url = BaseUrl.CombineWith("/json/reply/GetHTTPResultWithResultScope");
            var x = await client.GetAsync(url);
            var body = await x.Content.ReadAsStringAsync();

            if (!body.Contains("null"))
            {
                body.Print();
                Assert.Fail($"Iteration {i} : HttpResult : Body did not have null");
            }
        }

        public async Task loadnormal(int i = 0)
        {
            var client = new HttpClient();
            var url = BaseUrl.CombineWith("/json/reply/GetNormal");
            var x = await client.GetAsync(url);
            var body = await x.Content.ReadAsStringAsync();

            if (body.Contains("null"))
            {
                body.Print();
                Assert.Fail($"Iteration {i} : Warning, Body had Null");
            }
        }
    }

    public class JsConfigScopeIssueRemoteHost : JsConfigScopeIssueBase
    {
        public override string BaseUrl => "http://localhost:5000/";
        
        [Test]
        public async Task Load_RemoteHost()
        {
            await load(1000);
        }
    }

    public class JsConfigScopeIssueSelfHost : JsConfigScopeIssueBase
    {
        public override string BaseUrl => "http://localhost:20000/";

        public class AppHost : AppSelfHostBase
        {
            public AppHost() : base("issues", typeof(MyServices).Assembly) { }

            // Configure your AppHost with the necessary configuration and dependencies your App needs
            public override void Configure(Container container)
            {
                JsConfig.Init(new Config {
                    IncludeNullValues = false,
                    DateHandler = DateHandler.ISO8601
                });

                SetConfig(new HostConfig {
                    DebugMode = true,
                    StrictMode = true,
                });
            }
        }
        
        private ServiceStackHost appHost;

        [OneTimeSetUp]
        public void TestFixtureSetUp()
        {
            appHost = new AppHost()
                .Init()
                .Start(BaseUrl);
        }

        [OneTimeTearDown]
        public void TestFixtureTearDown() => appHost.Dispose();

        [Test]
        public async Task Load_SelfHost()
        {
            await load(1000);
        }
    }   
}

I've run this test suite against .NET Core and .NET Framework, neither is failing:

Can you try running this test suite locally, and if you've made modifications to get it to fail can you reply with what they were, thx.

[dlj]

I can not reproduce it with your code but the moment i put it on an IIS it starts to fail.
Attached a small gif and my sample project. Not really sure how to get Nunit to work with a HttpApplication so the tests are run in Startup and outputted to the console.

WebApplication.zip

[mythz]

thx for the repro, it should be resolved within this commit where in .NET FX JsConfigScope needs to use ThreadStatic so it needs to avoid async Thread Hops in JsConfigScope'd requests by sync serializing to a Buffered MemoryStream.

This change is available from v5.6.1 that's now available on MyGet.