Skip to content

Commit 3e5a186

Browse files
cocowallacocowalla
committed
Remove _sink field
Instantiate sink in in test instead. Response to feedback in #21
1 parent 188741e commit 3e5a186

File tree

1 file changed

+92
-83
lines changed

1 file changed

+92
-83
lines changed

‎test/Serilog.Sinks.Async.Tests/BackgroundWorkerSinkSpec.cs

Lines changed: 92 additions & 83 deletions
Original file line numberDiff line numberDiff line change
@@ -11,22 +11,15 @@
1111

1212
namespace Serilog.Sinks.Async.Tests
1313
{
14-
public class BackgroundWorkerSinkSpec : IDisposable
14+
public class BackgroundWorkerSinkSpec
1515
{
1616
readonly Logger _logger;
1717
readonly MemorySink _innerSink;
18-
BackgroundWorkerSink _sink;
1918

2019
public BackgroundWorkerSinkSpec()
2120
{
2221
_innerSink = new MemorySink();
2322
_logger = new LoggerConfiguration().WriteTo.Sink(_innerSink).CreateLogger();
24-
_sink = new BackgroundWorkerSink(_logger, 10000, false);
25-
}
26-
27-
public void Dispose()
28-
{
29-
_sink.Dispose();
3023
}
3124

3225
[Fact]
@@ -38,118 +31,134 @@ public void WhenCtorWithNullSink_ThenThrows()
3831
[Fact]
3932
public async Task WhenEmitSingle_ThenRelaysToInnerSink()
4033
{
41-
var logEvent = CreateEvent();
42-
_sink.Emit(logEvent);
34+
using (var sink = this.CreateSinkWithDefaultOptions())
35+
{
36+
var logEvent = CreateEvent();
37+
38+
sink.Emit(logEvent);
4339

44-
await Task.Delay(TimeSpan.FromSeconds(3));
40+
await Task.Delay(TimeSpan.FromSeconds(3));
4541

46-
Assert.Equal(1, _innerSink.Events.Count);
42+
Assert.Equal(1, _innerSink.Events.Count);
43+
}
4744
}
4845

4946
[Fact]
5047
public async Task WhenInnerEmitThrows_ThenContinuesRelaysToInnerSink()
5148
{
52-
_innerSink.ThrowAfterCollecting = true;
53-
54-
var events = new List<LogEvent>
49+
using (var sink = this.CreateSinkWithDefaultOptions())
5550
{
56-
CreateEvent(),
57-
CreateEvent(),
58-
CreateEvent()
59-
};
60-
events.ForEach(e => _sink.Emit(e));
51+
_innerSink.ThrowAfterCollecting = true;
6152

62-
await Task.Delay(TimeSpan.FromSeconds(3));
53+
var events = new List<LogEvent>
54+
{
55+
CreateEvent(),
56+
CreateEvent(),
57+
CreateEvent()
58+
};
59+
events.ForEach(e => sink.Emit(e));
60+
61+
await Task.Delay(TimeSpan.FromSeconds(3));
6362

64-
Assert.Equal(3, _innerSink.Events.Count);
63+
Assert.Equal(3, _innerSink.Events.Count);
64+
}
6565
}
6666

6767
[Fact]
6868
public async Task WhenEmitMultipleTimes_ThenRelaysToInnerSink()
6969
{
70-
var events = new List<LogEvent>
70+
using (var sink = this.CreateSinkWithDefaultOptions())
7171
{
72-
CreateEvent(),
73-
CreateEvent(),
74-
CreateEvent()
75-
};
76-
77-
events.ForEach(e => { _sink.Emit(e); });
72+
var events = new List<LogEvent>
73+
{
74+
CreateEvent(),
75+
CreateEvent(),
76+
CreateEvent()
77+
};
78+
events.ForEach(e => { sink.Emit(e); });
7879

79-
await Task.Delay(TimeSpan.FromSeconds(3));
80+
await Task.Delay(TimeSpan.FromSeconds(3));
8081

81-
Assert.Equal(3, _innerSink.Events.Count);
82+
Assert.Equal(3, _innerSink.Events.Count);
83+
}
8284
}
8385

8486
[Fact]
8587
public async Task WhenQueueFull_ThenDropsEvents()
8688
{
87-
_sink = new BackgroundWorkerSink(_logger, 1, false);
88-
89-
// Cause a delay when emmitting to the inner sink, allowing us to fill the queue to capacity
90-
// after the first event is popped
91-
_innerSink.DelayEmit = TimeSpan.FromMilliseconds(300);
92-
93-
var events = new List<LogEvent>
89+
using (var sink = new BackgroundWorkerSink(_logger, 1, false))
9490
{
95-
CreateEvent(),
96-
CreateEvent(),
97-
CreateEvent(),
98-
CreateEvent(),
99-
CreateEvent()
100-
};
101-
events.ForEach(e =>
102-
{
103-
var sw = Stopwatch.StartNew();
104-
_sink.Emit(e);
105-
sw.Stop();
91+
// Cause a delay when emmitting to the inner sink, allowing us to fill the queue to capacity
92+
// after the first event is popped
93+
_innerSink.DelayEmit = TimeSpan.FromMilliseconds(300);
94+
95+
var events = new List<LogEvent>
96+
{
97+
CreateEvent(),
98+
CreateEvent(),
99+
CreateEvent(),
100+
CreateEvent(),
101+
CreateEvent()
102+
};
103+
events.ForEach(e =>
104+
{
105+
var sw = Stopwatch.StartNew();
106+
sink.Emit(e);
107+
sw.Stop();
106108

107-
Assert.True(sw.ElapsedMilliseconds < 200, "Should not block the caller when the queue is full");
108-
});
109+
Assert.True(sw.ElapsedMilliseconds < 200, "Should not block the caller when the queue is full");
110+
});
109111

110-
// If we *weren't* dropped events, the delay in the inner sink would mean the 5 events would take
111-
// at least 15 seconds to process
112-
await Task.Delay(TimeSpan.FromSeconds(2));
112+
// If we *weren't* dropped events, the delay in the inner sink would mean the 5 events would take
113+
// at least 15 seconds to process
114+
await Task.Delay(TimeSpan.FromSeconds(2));
113115

114-
// Events should be dropped
115-
Assert.Equal(2, _innerSink.Events.Count);
116+
// Events should be dropped
117+
Assert.Equal(2, _innerSink.Events.Count);
118+
}
116119
}
117120

118121
[Fact]
119122
public async Task WhenQueueFull_ThenBlocks()
120123
{
121-
_sink = new BackgroundWorkerSink(_logger, 1, true);
122-
123-
// Cause a delay when emmitting to the inner sink, allowing us to fill the queue to capacity
124-
// after the first event is popped
125-
_innerSink.DelayEmit = TimeSpan.FromMilliseconds(300);
126-
127-
var events = new List<LogEvent>
124+
using (var sink = new BackgroundWorkerSink(_logger, 1, true))
128125
{
129-
CreateEvent(),
130-
CreateEvent(),
131-
CreateEvent()
132-
};
126+
// Cause a delay when emmitting to the inner sink, allowing us to fill the queue to capacity
127+
// after the first event is popped
128+
_innerSink.DelayEmit = TimeSpan.FromMilliseconds(300);
133129

134-
int i = 0;
135-
events.ForEach(e =>
136-
{
137-
var sw = Stopwatch.StartNew();
138-
_sink.Emit(e);
139-
sw.Stop();
140-
141-
// Emit should return immediately the first time, since the queue is not yet full. On
142-
// subsequent calls, the queue should be full, so we should be blocked
143-
if (i > 0)
130+
var events = new List<LogEvent>
144131
{
145-
Assert.True(sw.ElapsedMilliseconds > 200, "Should block the caller when the queue is full");
146-
}
147-
});
132+
CreateEvent(),
133+
CreateEvent(),
134+
CreateEvent()
135+
};
148136

149-
await Task.Delay(TimeSpan.FromSeconds(2));
137+
int i = 0;
138+
events.ForEach(e =>
139+
{
140+
var sw = Stopwatch.StartNew();
141+
sink.Emit(e);
142+
sw.Stop();
143+
144+
// Emit should return immediately the first time, since the queue is not yet full. On
145+
// subsequent calls, the queue should be full, so we should be blocked
146+
if (i > 0)
147+
{
148+
Assert.True(sw.ElapsedMilliseconds > 200, "Should block the caller when the queue is full");
149+
}
150+
});
151+
152+
await Task.Delay(TimeSpan.FromSeconds(2));
153+
154+
// No events should be dropped
155+
Assert.Equal(3, _innerSink.Events.Count);
156+
}
157+
}
150158

151-
// No events should be dropped
152-
Assert.Equal(3, _innerSink.Events.Count);
159+
private BackgroundWorkerSink CreateSinkWithDefaultOptions()
160+
{
161+
return new BackgroundWorkerSink(_logger, 10000, false);
153162
}
154163

155164
private static LogEvent CreateEvent()

0 commit comments

Comments
 (0)