Skip to content

Commit 16a5607

Browse files
MDoernerMDoerner
committed
Add tests for the RewritingManager
Also makes the IRewriteSession expose the target code kind in order to make the RewritingManager testable.
1 parent 0ded26b commit 16a5607

9 files changed

+264
-22
lines changed

‎Rubberduck.Parsing/Rewriter/AttributesRewriteSession.cs

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,6 @@
11
using System;
22
using Rubberduck.Parsing.VBA;
3+
using Rubberduck.Parsing.VBA.Parsing;
34
using Rubberduck.VBEditor;
45

56
namespace Rubberduck.Parsing.Rewriter
@@ -15,6 +16,8 @@ public AttributesRewriteSession(IParseManager parseManager, IRewriterProvider re
1516
_parseManager = parseManager;
1617
}
1718

19+
public override CodeKind TargetCodeKind => CodeKind.AttributesCode;
20+
1821
protected override IExecutableModuleRewriter ModuleRewriter(QualifiedModuleName module)
1922
{
2023
return RewriterProvider.AttributesModuleRewriter(module);

‎Rubberduck.Parsing/Rewriter/CodePaneRewriteSession.cs

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,6 @@
11
using System;
22
using Rubberduck.Parsing.VBA;
3+
using Rubberduck.Parsing.VBA.Parsing;
34
using Rubberduck.VBEditor;
45

56
namespace Rubberduck.Parsing.Rewriter
@@ -15,6 +16,7 @@ public CodePaneRewriteSession(IParseManager parseManager, IRewriterProvider rewr
1516
_parseManager = parseManager;
1617
}
1718

19+
public override CodeKind TargetCodeKind => CodeKind.CodePaneCode;
1820

1921
protected override IExecutableModuleRewriter ModuleRewriter(QualifiedModuleName module)
2022
{

‎Rubberduck.Parsing/Rewriter/IRewriteSession.cs

Lines changed: 3 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,5 @@
1-
using Rubberduck.VBEditor;
1+
using Rubberduck.Parsing.VBA.Parsing;
2+
using Rubberduck.VBEditor;
23

34
namespace Rubberduck.Parsing.Rewriter
45
{
@@ -8,5 +9,6 @@ public interface IRewriteSession
89
void Rewrite();
910
bool IsInvalidated { get; }
1011
void Invalidate();
12+
CodeKind TargetCodeKind { get; }
1113
}
1214
}

‎Rubberduck.Parsing/Rewriter/RewriteSessionBase.cs

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2,6 +2,7 @@
22
using System.Collections.Generic;
33
using System.Linq;
44
using NLog;
5+
using Rubberduck.Parsing.VBA.Parsing;
56
using Rubberduck.VBEditor;
67

78
namespace Rubberduck.Parsing.Rewriter
@@ -16,6 +17,7 @@ public abstract class RewriteSessionBase : IRewriteSession
1617
protected readonly Logger Logger = LogManager.GetCurrentClassLogger();
1718
private readonly object _invalidationLockObject = new object();
1819

20+
public abstract CodeKind TargetCodeKind { get; }
1921

2022
protected RewriteSessionBase(IRewriterProvider rewriterProvider, Func<IRewriteSession, bool> rewritingAllowed)
2123
{

‎Rubberduck.Parsing/Rewriter/RewritingManager.cs

Lines changed: 6 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,6 @@
11
using System;
22
using System.Collections.Generic;
3+
using Rubberduck.Parsing.VBA.Parsing;
34

45
namespace Rubberduck.Parsing.Rewriter
56
{
@@ -56,12 +57,12 @@ private bool TryAllowExclusiveRewrite(IRewriteSession rewriteSession)
5657

5758
private bool IsCurrentlyActive(IRewriteSession rewriteSession)
5859
{
59-
switch (rewriteSession)
60+
switch (rewriteSession.TargetCodeKind)
6061
{
61-
case CodePaneRewriteSession codePaneSession:
62-
return _activeCodePaneSessions.Contains(codePaneSession);
63-
case AttributesRewriteSession attributeSession:
64-
return _activeAttributesSessions.Contains(attributeSession);
62+
case CodeKind.CodePaneCode:
63+
return _activeCodePaneSessions.Contains(rewriteSession);
64+
case CodeKind.AttributesCode:
65+
return _activeAttributesSessions.Contains(rewriteSession);
6566
default:
6667
throw new NotSupportedException(nameof(rewriteSession));
6768
}

‎RubberduckTests/Rewriter/AttributesRewriteSessionTests.cs

Lines changed: 3 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -51,15 +51,10 @@ public void DoesNotCallRewriteOutsideTheSuspendAction()
5151

5252
[Test]
5353
[Category("Rewriter")]
54-
public void ChecksOutAttributesRewriters()
54+
public void TargetsAttributesCode()
5555
{
56-
var rewriteSession = RewriteSession(session => true, out var mockRewriterProvider);
57-
var module = new QualifiedModuleName("TestProject", string.Empty, "TestModule");
58-
59-
rewriteSession.CheckOutModuleRewriter(module);
60-
61-
var (qmn, codeKind, mockRewriter) = mockRewriterProvider.RequestedRewriters().Single();
62-
Assert.AreEqual(CodeKind.AttributesCode, codeKind);
56+
var rewriteSession = RewriteSession(session => true, out _);
57+
Assert.AreEqual(CodeKind.AttributesCode, rewriteSession.TargetCodeKind);
6358
}
6459

6560
protected override IRewriteSession RewriteSession(IParseManager parseManager, Func<IRewriteSession, bool> rewritingAllowed, out MockRewriterProvider mockProvider)

‎RubberduckTests/Rewriter/CodePaneRewriteSessionTests.cs

Lines changed: 3 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -82,15 +82,10 @@ public void DoesNotRequestParseIfNoRewritersAreCheckedOut()
8282

8383
[Test]
8484
[Category("Rewriter")]
85-
public void ChecksOutCodePaneRewriters()
85+
public void TargetsCodePaneCode()
8686
{
87-
var rewriteSession = RewriteSession(session => true, out var mockRewriterProvider);
88-
var module = new QualifiedModuleName("TestProject", string.Empty, "TestModule");
89-
90-
rewriteSession.CheckOutModuleRewriter(module);
91-
92-
var (qmn, codeKind, mockRewriter) = mockRewriterProvider.RequestedRewriters().Single();
93-
Assert.AreEqual(CodeKind.CodePaneCode, codeKind);
87+
var rewriteSession = RewriteSession(session => true, out _);
88+
Assert.AreEqual(CodeKind.CodePaneCode, rewriteSession.TargetCodeKind);
9489
}
9590

9691
protected override IRewriteSession RewriteSession(IParseManager parseManager, Func<IRewriteSession, bool> rewritingAllowed, out MockRewriterProvider mockProvider)

‎RubberduckTests/Rewriter/RewriteManagerTests.cs

Lines changed: 228 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,228 @@
1+
using System;
2+
using System.Collections.Generic;
3+
using System.Linq;
4+
using Moq;
5+
using NUnit.Framework;
6+
using Rubberduck.Parsing.Rewriter;
7+
using Rubberduck.Parsing.VBA.Parsing;
8+
9+
namespace RubberduckTests.Rewriter
10+
{
11+
[TestFixture]
12+
public class RewriteManagerTests
13+
{
14+
[Test]
15+
[Category("Rewriter")]
16+
public void ReturnsValidCodePaneSessions()
17+
{
18+
var rewritingManager = RewritingManager(out _);
19+
var codePaneSession = rewritingManager.CheckOutCodePaneSession();
20+
Assert.IsFalse(codePaneSession.IsInvalidated);
21+
}
22+
23+
24+
[Test]
25+
[Category("Rewriter")]
26+
public void ReturnsValidAttributesSessions()
27+
{
28+
var rewritingManager = RewritingManager(out _);
29+
var attributesSession = rewritingManager.CheckOutAttributesSession();
30+
Assert.IsFalse(attributesSession.IsInvalidated);
31+
}
32+
33+
34+
[Test]
35+
[Category("Rewriter")]
36+
public void InvalidateAllSessionsCallsInvalidateOnAllActiveSessions()
37+
{
38+
var rewritingManager = RewritingManager(out var mockFactory);
39+
rewritingManager.CheckOutCodePaneSession();
40+
rewritingManager.CheckOutAttributesSession();
41+
rewritingManager.CheckOutCodePaneSession();
42+
rewritingManager.CheckOutAttributesSession();
43+
44+
rewritingManager.InvalidateAllSessions();
45+
46+
foreach (var mockSession in mockFactory.RequestedCodePaneSessions().Concat(mockFactory.RequestedAttributesSessions()))
47+
{
48+
mockSession.Verify(m => m.Invalidate(), Times.Once);
49+
}
50+
}
51+
52+
[Test]
53+
[Category("Rewriter")]
54+
public void CallingTheRewritingAllowedCallbackFromAnActiveCodePaneSessionCallsInvalidateOnAllActiveSessions()
55+
{
56+
var rewritingManager = RewritingManager(out var mockFactory);
57+
var codePaneSession = rewritingManager.CheckOutCodePaneSession();
58+
rewritingManager.CheckOutAttributesSession();
59+
rewritingManager.CheckOutCodePaneSession();
60+
rewritingManager.CheckOutAttributesSession();
61+
62+
codePaneSession.Rewrite();
63+
64+
foreach (var mockSession in mockFactory.RequestedCodePaneSessions().Concat(mockFactory.RequestedAttributesSessions()))
65+
{
66+
mockSession.Verify(m => m.Invalidate(), Times.Once);
67+
}
68+
}
69+
70+
[Test]
71+
[Category("Rewriter")]
72+
public void CallingTheRewritingAllowedCallbackFromAnActiveAttributesSessionCallsInvalidateOnAllActiveSessions()
73+
{
74+
var rewritingManager = RewritingManager(out var mockFactory);
75+
rewritingManager.CheckOutCodePaneSession();
76+
var attributesSession = rewritingManager.CheckOutAttributesSession();
77+
rewritingManager.CheckOutCodePaneSession();
78+
rewritingManager.CheckOutAttributesSession();
79+
80+
attributesSession.Rewrite();
81+
82+
foreach (var mockSession in mockFactory.RequestedCodePaneSessions().Concat(mockFactory.RequestedAttributesSessions()))
83+
{
84+
mockSession.Verify(m => m.Invalidate(), Times.Once);
85+
}
86+
}
87+
88+
[Test]
89+
[Category("Rewriter")]
90+
public void CallingTheRewritingAllowedCallbackFromANoLongerActiveCodePaneSessionDoesNotCallInvalidateOnAnyActiveSession_InactiveDueToRewrite()
91+
{
92+
var rewritingManager = RewritingManager(out var mockFactory);
93+
var codePaneSession = rewritingManager.CheckOutCodePaneSession();
94+
var attributesSession = rewritingManager.CheckOutAttributesSession();
95+
96+
rewritingManager.InvalidateAllSessions();
97+
98+
rewritingManager.CheckOutCodePaneSession();
99+
rewritingManager.CheckOutAttributesSession();
100+
101+
codePaneSession.Rewrite();
102+
103+
foreach (var mockSession in mockFactory.RequestedCodePaneSessions()
104+
.Concat(mockFactory.RequestedAttributesSessions())
105+
.Where(session => session.Object != codePaneSession && session.Object != attributesSession))
106+
{
107+
mockSession.Verify(m => m.Invalidate(), Times.Never);
108+
}
109+
}
110+
111+
[Test]
112+
[Category("Rewriter")]
113+
public void CallingTheRewritingAllowedCallbackFromANoLongerActiveAttributesSessionDoesNotCallInvalidateOnAnyActiveSession_InactiveDueToRewrite()
114+
{
115+
var rewritingManager = RewritingManager(out var mockFactory);
116+
var codePaneSession = rewritingManager.CheckOutCodePaneSession();
117+
var attributesSession = rewritingManager.CheckOutAttributesSession();
118+
119+
rewritingManager.InvalidateAllSessions();
120+
121+
rewritingManager.CheckOutCodePaneSession();
122+
rewritingManager.CheckOutAttributesSession();
123+
124+
codePaneSession.Rewrite();
125+
126+
foreach (var mockSession in mockFactory.RequestedCodePaneSessions()
127+
.Concat(mockFactory.RequestedAttributesSessions())
128+
.Where(session => session.Object != codePaneSession && session.Object != attributesSession))
129+
{
130+
mockSession.Verify(m => m.Invalidate(), Times.Never);
131+
}
132+
}
133+
134+
[Test]
135+
[Category("Rewriter")]
136+
public void CallingTheRewritingAllowedCallbackFromANoLongerActiveCodePaneSessionDoesNotCallInvalidateOnAnyActiveSession_InactiveDueToInvalidateAll()
137+
{
138+
var rewritingManager = RewritingManager(out var mockFactory);
139+
var codePaneSession = rewritingManager.CheckOutCodePaneSession();
140+
var attributesSession = rewritingManager.CheckOutAttributesSession();
141+
142+
attributesSession.Rewrite();
143+
144+
rewritingManager.CheckOutCodePaneSession();
145+
rewritingManager.CheckOutAttributesSession();
146+
147+
codePaneSession.Rewrite();
148+
149+
foreach (var mockSession in mockFactory.RequestedCodePaneSessions()
150+
.Concat(mockFactory.RequestedAttributesSessions())
151+
.Where(session => session.Object != codePaneSession && session.Object != attributesSession))
152+
{
153+
mockSession.Verify(m => m.Invalidate(), Times.Never);
154+
}
155+
}
156+
157+
[Test]
158+
[Category("Rewriter")]
159+
public void CallingTheRewritingAllowedCallbackFromANoLongerActiveAttributesSessionDoesNotCallInvalidateOnAnyActiveSession_InactiveDueToInvalidateAll()
160+
{
161+
var rewritingManager = RewritingManager(out var mockFactory);
162+
var codePaneSession = rewritingManager.CheckOutCodePaneSession();
163+
var attributesSession = rewritingManager.CheckOutAttributesSession();
164+
165+
codePaneSession.Rewrite();
166+
167+
rewritingManager.CheckOutCodePaneSession();
168+
rewritingManager.CheckOutAttributesSession();
169+
170+
attributesSession.Rewrite();
171+
172+
foreach (var mockSession in mockFactory.RequestedCodePaneSessions()
173+
.Concat(mockFactory.RequestedAttributesSessions())
174+
.Where( session => session.Object != codePaneSession && session.Object != attributesSession))
175+
{
176+
mockSession.Verify(m => m.Invalidate(), Times.Never);
177+
}
178+
}
179+
180+
private IRewritingManager RewritingManager(out MockRewriteSessionFactory mockFactory)
181+
{
182+
mockFactory = new MockRewriteSessionFactory();
183+
return new RewritingManager(mockFactory);
184+
}
185+
}
186+
187+
public class MockRewriteSessionFactory : IRewriteSessionFactory
188+
{
189+
private readonly List<Mock<IRewriteSession>> _requestedCodePaneSessions = new List<Mock<IRewriteSession>>();
190+
private readonly List<Mock<IRewriteSession>> _requestedAttributesSessions = new List<Mock<IRewriteSession>>();
191+
192+
public IEnumerable<Mock<IRewriteSession>> RequestedCodePaneSessions()
193+
{
194+
return _requestedCodePaneSessions;
195+
}
196+
197+
public IEnumerable<Mock<IRewriteSession>> RequestedAttributesSessions()
198+
{
199+
return _requestedAttributesSessions;
200+
}
201+
202+
public IRewriteSession CodePaneSession(Func<IRewriteSession, bool> rewritingAllowed)
203+
{
204+
var mockSession = MockSession(rewritingAllowed, CodeKind.CodePaneCode);
205+
_requestedCodePaneSessions.Add(mockSession);
206+
return mockSession.Object;
207+
}
208+
209+
private Mock<IRewriteSession> MockSession(Func<IRewriteSession, bool> rewritingAllowed, CodeKind targetCodeKind)
210+
{
211+
var mockSession = new Mock<IRewriteSession>();
212+
mockSession.Setup(m => m.Rewrite()).Callback(() => rewritingAllowed.Invoke(mockSession.Object));
213+
var isInvalidated = false;
214+
mockSession.Setup(m => m.IsInvalidated).Returns(() => isInvalidated);
215+
mockSession.Setup(m => m.Invalidate()).Callback(() => isInvalidated = true);
216+
mockSession.Setup(m => m.TargetCodeKind).Returns(targetCodeKind);
217+
218+
return mockSession;
219+
}
220+
221+
public IRewriteSession AttributesSession(Func<IRewriteSession, bool> rewritingAllowed)
222+
{
223+
var mockSession = MockSession(rewritingAllowed, CodeKind.AttributesCode);
224+
_requestedAttributesSessions.Add(mockSession);
225+
return mockSession.Object;
226+
}
227+
}
228+
}

‎RubberduckTests/Rewriter/RewriteSessionTestBase.cs

Lines changed: 14 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -168,6 +168,20 @@ public void CallsRewriteOnlyOnceForRewritersCheckedOutMultipleTimes()
168168
mockRewriter.Verify(m => m.Rewrite(), Times.Once);
169169
}
170170

171+
[Test]
172+
[Category("Rewriter")]
173+
public void ChecksOutRewritersForTheTargetCodeKind()
174+
{
175+
var rewriteSession = RewriteSession(session => true, out var mockRewriterProvider);
176+
var module = new QualifiedModuleName("TestProject", string.Empty, "TestModule");
177+
178+
rewriteSession.CheckOutModuleRewriter(module);
179+
180+
var expectedCodeKind = rewriteSession.TargetCodeKind;
181+
var (qmn, actualCodeKind, mockRewriter) = mockRewriterProvider.RequestedRewriters().Single();
182+
Assert.AreEqual(expectedCodeKind, actualCodeKind);
183+
}
184+
171185
protected IRewriteSession RewriteSession(Func<IRewriteSession, bool> rewritingAllowed,
172186
out MockRewriterProvider mockProvider)
173187
{

0 commit comments

Comments
 (0)