public void AttachValue_Thread_ReturnsInitial()
        {
            LogContext.CreateNewLogContext();
            var pair1 = new KeyValuePair <string, object>("1", 1);
            var pair2 = new KeyValuePair <string, object>("2", 2);

            var e         = new ManualResetEvent(false);
            var threadId1 = Thread.CurrentThread.ManagedThreadId;
            var threadId2 = 0;
            var thread    = new Thread(() =>
            {
                threadId2 = Thread.CurrentThread.ManagedThreadId;
                LogContext.Current.AttachValue(pair2);
                e.Set();
            });

            LogContext.Current.AttachValue(pair1);
            thread.Start();
            e.WaitOne();
            var actualValues   = LogContext.Current.GetValues();
            var expectedValues = new[] { pair1, pair2 };

            CollectionAssert.AreEquivalent(expectedValues, actualValues);
            Assert.AreNotEqual(threadId1, threadId2);
        }
        public void AttachValue_SameContext_ReturnsInitial()
        {
            var context = LogContext.CreateNewLogContext();
            var pair    = new KeyValuePair <string, object>("1", 1);

            context.AttachValue(pair);
            var actualValues   = context.GetValues();
            var expectedValues = new[] { pair };

            Assert.AreEqual(expectedValues, actualValues);
        }
        public void CreateScope_ReturnsInitialValues()
        {
            var context = LogContext.CreateNewLogContext();
            var pair1   = new KeyValuePair <string, object>("1", 1);
            var pair2   = new KeyValuePair <string, object>("2", 2);
            var pair2A  = new KeyValuePair <string, object>("2", 20);

            context.AttachValue(pair1);
            context.AttachValue(pair2);
            using (context.CreateScope(pair2A))
            {
                CollectionAssert.AreEquivalent(new [] { pair1, pair2A }, context.GetValues());
            }
            CollectionAssert.AreEquivalent(new[] { pair1, pair2 }, context.GetValues());
        }
        public async Task AttachValue_ThreadPool_ReturnsInitial()
        {
            LogContext.CreateNewLogContext();
            var pair1 = new KeyValuePair <string, object>("1", 1);
            var pair2 = new KeyValuePair <string, object>("2", 2);

            void Foo()
            {
                LogContext.Current.AttachValue(pair2);
            }

            LogContext.Current.AttachValue(pair1);
            await Task.Factory.StartNew(Foo);

            var actualValues   = LogContext.Current.GetValues();
            var expectedValues = new[] { pair1, pair2 };

            CollectionAssert.AreEquivalent(expectedValues, actualValues);
        }
        public void AttachValue_AsyncVoid_ReturnsInitial()
        {
            LogContext.CreateNewLogContext();
            var pair1 = new KeyValuePair <string, object>("1", 1);
            var pair2 = new KeyValuePair <string, object>("2", 2);

            async void Foo()
            {
                await Task.CompletedTask;

                LogContext.Current.AttachValue(pair2);
                await Task.CompletedTask;
            }

            LogContext.Current.AttachValue(pair1);
            Foo();
            var actualValues   = LogContext.Current.GetValues();
            var expectedValues = new[] { pair1, pair2 };

            CollectionAssert.AreEquivalent(expectedValues, actualValues);
        }
 public Task PreReceive(ReceiveContext context)
 {
     LogContext.CreateNewLogContext();
     return(Task.CompletedTask);
 }
 public Task Invoke(HttpContext context)
 {
     LogContext.CreateNewLogContext();
     return(_next.Invoke(context));
 }