← Back to branch summary

~halega/+junk/sharpdevelop

« back to all changes in this revision

Viewing changes to src/AddIns/Misc/PackageManagement/Test/Src/Scripting/PackageManagementConsoleHostTests.cs

  • Committer: sk
  • Date: 2011-09-10 05:17:57 UTC
  • Revision ID: halega@halega.com-20110910051757-qfouz1llya9m6boy
4.1.0.7915 Release Candidate 1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/AddIns/Misc/PackageManagement/Test/Src/Scripting/PackageManagementConsoleHostTests.cs
 
1
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
 
2
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
 
3
 
 
4
using System;
 
5
using System.Collections.Generic;
 
6
using ICSharpCode.PackageManagement;
 
7
using ICSharpCode.PackageManagement.Design;
 
8
using ICSharpCode.PackageManagement.EnvDTE;
 
9
using ICSharpCode.PackageManagement.Scripting;
 
10
using ICSharpCode.Scripting;
 
11
using ICSharpCode.Scripting.Tests.Utils;
 
12
using NuGet;
 
13
using NUnit.Framework;
 
14
using PackageManagement.Tests.Helpers;
 
15
 
 
16
namespace PackageManagement.Tests.Scripting
 
17
{
 
18
        [TestFixture]
 
19
        public class PackageManagementConsoleHostTests
 
20
        {
 
21
                TestablePackageManagementConsoleHost host;
 
22
                FakeScriptingConsoleWithLinesToRead scriptingConsole;
 
23
                FakePowerShellHost powerShellHost;
 
24
                FakePackageManagementSolution fakeSolution;
 
25
                FakeRegisteredPackageRepositories fakeRegisteredPackageRepositories;
 
26
                
 
27
                void CreateHost()
 
28
                {
 
29
                        host = new TestablePackageManagementConsoleHost();
 
30
                        fakeSolution = host.FakeSolution;
 
31
                        scriptingConsole = host.FakeScriptingConsole;
 
32
                        powerShellHost = host.FakePowerShellHostFactory.FakePowerShellHost;
 
33
                        fakeRegisteredPackageRepositories = host.FakeRegisteredPackageRepositories;
 
34
                }
 
35
                
 
36
                void RunHost()
 
37
                {
 
38
                        host.Run();
 
39
                        host.ThreadStartPassedToCreateThread.Invoke();
 
40
                }
 
41
                
 
42
                [Test]
 
43
                public void Dispose_ScriptingConsoleIsNotNull_ScriptingConsoleIsDisposed()
 
44
                {
 
45
                        CreateHost();
 
46
                        host.Dispose();
 
47
                        
 
48
                        Assert.IsTrue(scriptingConsole.IsDisposeCalled);
 
49
                }
 
50
                
 
51
                [Test]
 
52
                public void Dispose_ScriptingConsoleIsNull_NullReferenceExceptionIsNotThrown()
 
53
                {
 
54
                        CreateHost();
 
55
                        host.ScriptingConsole = null;
 
56
                        
 
57
                        Assert.DoesNotThrow(() => host.Dispose());
 
58
                }
 
59
                
 
60
                [Test]
 
61
                public void Run_ConsoleHostIsRun_StartsThreadToProcessCommandsEnteredIntoConsole()
 
62
                {
 
63
                        CreateHost();
 
64
                        host.Run();
 
65
                        
 
66
                        Assert.IsTrue(host.FakeThread.IsStartCalled);
 
67
                }
 
68
                
 
69
                [Test]
 
70
                public void Dispose_ConsoleHostRunCalled_ThreadJoinIsCalledWithTimeout()
 
71
                {
 
72
                        CreateHost();
 
73
                        host.Run();
 
74
                        host.Dispose();
 
75
                        
 
76
                        int timeout = host.FakeThread.TimeoutPassedToJoin;
 
77
                        int expectedTimeout = 100; //ms
 
78
                        
 
79
                        Assert.AreEqual(expectedTimeout, timeout);
 
80
                }
 
81
                
 
82
                [Test]
 
83
                public void Dispose_DisposeCalledTwiceAfterConsoleHostIsRun_ThreadJoinIsCalledOnce()
 
84
                {
 
85
                        CreateHost();
 
86
                        host.Run();
 
87
                        host.Dispose();
 
88
                        host.FakeThread.IsJoinCalled = false;
 
89
                        
 
90
                        host.Dispose();
 
91
                        
 
92
                        Assert.IsFalse(host.FakeThread.IsJoinCalled);
 
93
                }
 
94
                
 
95
                [Test]
 
96
                public void Dispose_DisposeCalledTwiceAfterConsoleHostIsRunAndThreadDoesNotFinishOnFirstCall_ThreadJoinIsCalledTwice()
 
97
                {
 
98
                        CreateHost();
 
99
                        host.Run();
 
100
                        host.FakeThread.JoinReturnValue = false;
 
101
                        host.Dispose();
 
102
                        host.FakeThread.IsJoinCalled = false;
 
103
                        
 
104
                        host.Dispose();
 
105
                        
 
106
                        Assert.IsTrue(host.FakeThread.IsJoinCalled);
 
107
                }
 
108
                
 
109
                [Test]
 
110
                public void IsRunning_DisposedAndThreadFinishes_ReturnsFalse()
 
111
                {
 
112
                        CreateHost();
 
113
                        host.Run();
 
114
                        host.FakeThread.JoinReturnValue = true;
 
115
                        host.Dispose();
 
116
                        
 
117
                        Assert.IsFalse(host.IsRunning);
 
118
                }
 
119
                
 
120
                [Test]
 
121
                public void IsRunning_DisposedButThreadDidNotFinish_ReturnsTrue()
 
122
                {
 
123
                        CreateHost();
 
124
                        host.Run();
 
125
                        host.FakeThread.JoinReturnValue = false;
 
126
                        host.Dispose();
 
127
                        
 
128
                        Assert.IsTrue(host.IsRunning);
 
129
                }
 
130
                
 
131
                [Test]
 
132
                public void Run_ConsoleExitsOnFirstRead_PowerShellHostIsCreated()
 
133
                {
 
134
                        CreateHost();
 
135
                        RunHost();
 
136
                        
 
137
                        IScriptingConsole scriptingConsole = host.FakePowerShellHostFactory.ScriptingConsolePassedToCreatePowerShellHost;
 
138
                        IScriptingConsole expectedScriptingConsole = scriptingConsole;
 
139
                        
 
140
                        Assert.AreSame(expectedScriptingConsole, scriptingConsole);
 
141
                }
 
142
                
 
143
                [Test]
 
144
                public void Run_ConsoleExitsOnFirstRead_PrivateDataIsSetToClearConsoleHostCommandObject()
 
145
                {
 
146
                        CreateHost();
 
147
                        RunHost();
 
148
                        
 
149
                        object privateDataObject = host.FakePowerShellHostFactory.PrivateDataPassedToCreatePowerShellHost;
 
150
                        
 
151
                        Assert.IsInstanceOf(typeof(ClearPackageManagementConsoleHostCommand), privateDataObject);
 
152
                }
 
153
                
 
154
                [Test]
 
155
                public void Run_ConsoleExitsOnFirstRead_DteObjectIsSet()
 
156
                {
 
157
                        CreateHost();
 
158
                        RunHost();
 
159
                        
 
160
                        object dte = host.FakePowerShellHostFactory.DtePassedToCreatePowerShellHost;
 
161
                        
 
162
                        Assert.IsInstanceOf(typeof(DTE), dte);
 
163
                }
 
164
                
 
165
                [Test]
 
166
                public void Run_ConsoleExitsOnFirstRead_PowerShellVersionIsSetToNuGetVersion()
 
167
                {
 
168
                        CreateHost();
 
169
                        var expectedVersion = new Version("1.0.1.3");
 
170
                        host.NuGetVersionToReturn = expectedVersion;
 
171
                        RunHost();
 
172
                        
 
173
                        Version version = host.FakePowerShellHostFactory.VersionPassedToCreatePowerShellHost;
 
174
                        
 
175
                        Assert.AreEqual(expectedVersion, version);
 
176
                }
 
177
                
 
178
                [Test]
 
179
                public void Run_ConsoleExitsOnFirstRead_InitialPowerShellExecutionPolicySet()
 
180
                {
 
181
                        CreateHost();
 
182
                        RunHost();
 
183
                        
 
184
                        Assert.IsTrue(powerShellHost.IsSetRemoteSignedExecutionPolicyCalled);
 
185
                }
 
186
                
 
187
                [Test]
 
188
                public void Run_ConsoleExitsOnFirstRead_ClearHostFunctionIsRedefined()
 
189
                {
 
190
                        CreateHost();
 
191
                        RunHost();
 
192
                        
 
193
                        string expectedExecutedScript = 
 
194
                                "function Clear-Host { $host.PrivateData.ClearHost() }";
 
195
                        
 
196
                        bool executed = powerShellHost.AllCommandsPassedToExecuteCommand.Contains(expectedExecutedScript);
 
197
                        
 
198
                        Assert.IsTrue(executed);
 
199
                }
 
200
                
 
201
                [Test]
 
202
                public void Run_ConsoleExitsOnFirstRead_PromptTextWrittenToConsole()
 
203
                {
 
204
                        CreateHost();
 
205
                        RunHost();
 
206
                        var expectedTextPassedToWrite = new String[] { "PM> "};
 
207
                        List<string> actualTextPassedToWrite = scriptingConsole.AllTextPassedToWrite;
 
208
                        
 
209
                        CollectionAssert.AreEqual(expectedTextPassedToWrite, actualTextPassedToWrite);
 
210
                }
 
211
                
 
212
                [Test]
 
213
                public void Run_ConsoleExitsOnFirstRead_PromptTextWrittenWithPromptyStyleToConsole()
 
214
                {
 
215
                        CreateHost();
 
216
                        RunHost();
 
217
                        
 
218
                        Assert.AreEqual(ScriptingStyle.Prompt, scriptingConsole.ScriptingStylePassedToWrite);
 
219
                }
 
220
                
 
221
                [Test]
 
222
                public void Run_OneCommandEntered_CommandExecutedByPowerShellHost()
 
223
                {
 
224
                        CreateHost();
 
225
                        scriptingConsole.AllTextToReturnFromReadLine.Add("RunThis");
 
226
                        RunHost();
 
227
                        
 
228
                        Assert.AreEqual("RunThis", powerShellHost.CommandPassedToExecuteCommand);
 
229
                }
 
230
                
 
231
                [Test]
 
232
                public void Run_OneCommandEntered_CommandPromptDisplayedAgain()
 
233
                {
 
234
                        CreateHost();
 
235
                        scriptingConsole.AllTextToReturnFromReadLine.Add("RunThis");
 
236
                        RunHost();
 
237
                        
 
238
                        var expectedTextPassedToWrite = new String[] { "PM> ", "PM> "};
 
239
                        List<string> actualTextPassedToWrite = scriptingConsole.AllTextPassedToWrite;
 
240
                        
 
241
                        CollectionAssert.AreEqual(expectedTextPassedToWrite, actualTextPassedToWrite);
 
242
                }
 
243
                
 
244
                [Test]
 
245
                public void Run_TwoCommandsEnteredByUser_FirstCommandExecuted()
 
246
                {
 
247
                        CreateHost();
 
248
                        var commands = new string[] { "one", "two" };
 
249
                        scriptingConsole.AllTextToReturnFromReadLine.AddRange(commands);
 
250
                        
 
251
                        host.ScriptingConsole = scriptingConsole;
 
252
                        RunHost();
 
253
                        
 
254
                        bool executed = powerShellHost.AllCommandsPassedToExecuteCommand.Contains("one");
 
255
                        
 
256
                        Assert.IsTrue(executed);
 
257
                }
 
258
                
 
259
                [Test]
 
260
                public void Run_TwoCommandsEnteredByUser_SecondCommandExecuted()
 
261
                {
 
262
                        CreateHost();
 
263
                        var commands = new string[] { "one", "two" };
 
264
                        scriptingConsole.AllTextToReturnFromReadLine.AddRange(commands);
 
265
                        
 
266
                        host.ScriptingConsole = scriptingConsole;
 
267
                        RunHost();
 
268
                        
 
269
                        bool executed = powerShellHost.AllCommandsPassedToExecuteCommand.Contains("two");
 
270
                        
 
271
                        Assert.IsTrue(executed);
 
272
                }
 
273
                
 
274
                [Test]
 
275
                public void Run_PowerShellHostInitialization_CmdletsAreImported()
 
276
                {
 
277
                        CreateHost();
 
278
                        string cmdletsAssemblyFileName = 
 
279
                                @"d:\program files\SharpDevelop\4.0\AddIns\PackageManagement\PackageManagement.Cmdlets.dll";
 
280
                        host.FakePackageManagementAddInPath.CmdletsAssemblyFileName = cmdletsAssemblyFileName;
 
281
                        RunHost();
 
282
                        
 
283
                        var expectedModules = new string[] {
 
284
                                cmdletsAssemblyFileName
 
285
                        };
 
286
                        IList<string> actualModules = powerShellHost.ModulesToImport;
 
287
                        
 
288
                        CollectionAssert.AreEqual(expectedModules, actualModules);
 
289
                }
 
290
                
 
291
                [Test]
 
292
                public void Run_TwoPowerShellFormattingConfigXmlFilesInAddInFolder_UpdateFormattingCalledWithTwoFormattingFiles()
 
293
                {
 
294
                        CreateHost();
 
295
                        var files = new string[] {
 
296
                                @"d:\program files\SharpDevelop\4.0\AddIns\PackageManagement\Scripting\Package.Format.ps1xml",
 
297
                                @"d:\temp\test\Format.ps1xml"
 
298
                        };
 
299
                        host.FakePackageManagementAddInPath.PowerShellFormattingFileNames.AddRange(files);
 
300
                        
 
301
                        RunHost();
 
302
                        
 
303
                        IEnumerable<string> actualFiles = powerShellHost.FormattingFilesPassedToUpdateFormatting;
 
304
                        
 
305
                        CollectionAssert.AreEqual(files, actualFiles);
 
306
                }
 
307
                
 
308
                [Test]
 
309
                public void Run_TextDisplayedBeforeFirstPromptDisplayed_NuGetVersionDisplayed()
 
310
                {
 
311
                        CreateHost();
 
312
                        powerShellHost.Version = new Version("1.2.0.4");
 
313
                        RunHost();
 
314
                        
 
315
                        string expected = "NuGet 1.2.0.4";
 
316
                        
 
317
                        bool contains = scriptingConsole.AllTextPassedToWriteLine.Contains(expected);
 
318
                        
 
319
                        Assert.IsTrue(contains);
 
320
                }
 
321
                
 
322
                [Test]
 
323
                public void Run_TextDisplayedBeforeFirstPromptDisplayed_HelpInfoDisplayed()
 
324
                {
 
325
                        CreateHost();
 
326
                        string expectedHelpMessage = "Type 'get-help NuGet' for more information.";
 
327
                        host.TextToReturnFromGetHelpInfo = expectedHelpMessage;
 
328
                        RunHost();
 
329
                        
 
330
                        bool contains = scriptingConsole.AllTextPassedToWriteLine.Contains("Type 'get-help NuGet' for more information.");
 
331
                        
 
332
                        Assert.IsTrue(contains);
 
333
                }
 
334
                
 
335
                [Test]
 
336
                public void Run_TextDisplayedBeforeFirstPromptDisplayed_BlankLineBeforePrompt()
 
337
                {
 
338
                        CreateHost();
 
339
                        host.TextToReturnFromGetHelpInfo = "abc";
 
340
                        RunHost();
 
341
                        
 
342
                        string actualLastLine = scriptingConsole.LastLinePassedToWriteLine;
 
343
                        string expectedLastLine = String.Empty;
 
344
                        
 
345
                        Assert.AreEqual(expectedLastLine, actualLastLine);
 
346
                }
 
347
                
 
348
                [Test]
 
349
                public void GetProject_ProjectNameAndPackageSourcePassed_ProjectNameUsedToGetProject()
 
350
                {
 
351
                        CreateHost();
 
352
                        string source = "http://sharpdevelop.net";
 
353
                        string expectedProjectName = "Test";
 
354
                        
 
355
                        host.GetProject(source, expectedProjectName);
 
356
                        
 
357
                        string actualProjectName = fakeSolution.ProjectNamePassedToGetProject;
 
358
                        
 
359
                        Assert.AreEqual(expectedProjectName, actualProjectName);
 
360
                }
 
361
                
 
362
                [Test]
 
363
                public void GetProject_ProjectNameAndPackageSourcePassed_PackageSourceUsedToGetProject()
 
364
                {
 
365
                        CreateHost();
 
366
                        string expectedSource = "http://sharpdevelop.net";
 
367
                        
 
368
                        host.GetProject(expectedSource, "Test");
 
369
                        
 
370
                        string actualSource = fakeSolution.PackageSourcePassedToGetProject.Source;
 
371
                        
 
372
                        Assert.AreEqual(expectedSource, actualSource);
 
373
                }
 
374
                
 
375
                [Test]
 
376
                public void GetProject_ProjectNameAndPackageSourcePassed_ReturnsProject()
 
377
                {
 
378
                        CreateHost();
 
379
                        string source = "http://sharpdevelop.net";
 
380
                        
 
381
                        IPackageManagementProject project = host.GetProject(source, "Test");
 
382
                        
 
383
                        FakePackageManagementProject expectedProject = fakeSolution.FakeProjectToReturnFromGetProject;
 
384
                        
 
385
                        Assert.AreEqual(expectedProject, project);
 
386
                }
 
387
                
 
388
                [Test]
 
389
                public void GetProject_NullPackageSourcePassed_UsesDefaultSourceToCreateProject()
 
390
                {
 
391
                        CreateHost();
 
392
                        var expectedSource = new PackageSource("http://sharpdevelop.net");
 
393
                        host.ActivePackageSource = expectedSource;
 
394
                        string packageSource = null;
 
395
                        
 
396
                        host.GetProject(packageSource, "Test");
 
397
                        
 
398
                        PackageSource actualSource = fakeSolution.PackageSourcePassedToGetProject;
 
399
                        
 
400
                        Assert.AreEqual(expectedSource, actualSource);
 
401
                }
 
402
                
 
403
                [Test]
 
404
                public void GetProject_NullProjectPassed_UsesDefaultProjectToCreateProject()
 
405
                {
 
406
                        CreateHost();
 
407
                        string source = "http://sharpdevelop.net";
 
408
                        TestableProject project = ProjectHelper.CreateTestProject("Test");
 
409
                        host.DefaultProject = project;
 
410
                        
 
411
                        host.GetProject(source, null);
 
412
                        
 
413
                        string projectName = fakeSolution.ProjectNamePassedToGetProject;
 
414
                        
 
415
                        Assert.AreEqual("Test", projectName);
 
416
                }
 
417
                
 
418
                [Test]
 
419
                public void GetProject_ProjectNameAndRepositoryPassed_ProjectNameUsedToGetProject()
 
420
                {
 
421
                        CreateHost();
 
422
                        var repository = new FakePackageRepository();
 
423
                        string expectedProjectName = "Test";
 
424
                        
 
425
                        host.GetProject(repository, expectedProjectName);
 
426
                        
 
427
                        string actualProjectName = fakeSolution.ProjectNamePassedToGetProject;
 
428
                        
 
429
                        Assert.AreEqual(expectedProjectName, actualProjectName);
 
430
                }
 
431
                
 
432
                [Test]
 
433
                public void GetProject_ProjectNameAndRepositoryPassed_RepositoryUsedToGetProject()
 
434
                {
 
435
                        CreateHost();
 
436
                        var repository = new FakePackageRepository();
 
437
                        
 
438
                        host.GetProject(repository, "Test");
 
439
                        
 
440
                        IPackageRepository actualRepository = fakeSolution.RepositoryPassedToGetProject;
 
441
                        
 
442
                        Assert.AreEqual(repository, actualRepository);
 
443
                }
 
444
                
 
445
                [Test]
 
446
                public void GetProject_ProjectNameAndRepositoryPassed_ReturnsProject()
 
447
                {
 
448
                        CreateHost();
 
449
                        var repository = new FakePackageRepository();
 
450
                        
 
451
                        IPackageManagementProject project = host.GetProject(repository, "Test");
 
452
                        
 
453
                        FakePackageManagementProject expectedProject = fakeSolution.FakeProjectToReturnFromGetProject;
 
454
                        
 
455
                        Assert.AreEqual(expectedProject, project);
 
456
                }
 
457
                
 
458
                [Test]
 
459
                public void GetProject_NullProjectNameAndNonNullRepositoryPassed_UsesDefaultProjectNameToCreateProject()
 
460
                {
 
461
                        CreateHost();
 
462
                        host.DefaultProject = ProjectHelper.CreateTestProject("MyProject");
 
463
                        var repository = new FakePackageRepository();
 
464
                        
 
465
                        IPackageManagementProject project = host.GetProject(repository, null);
 
466
                        
 
467
                        string projectName = fakeSolution.ProjectNamePassedToGetProject;
 
468
                        
 
469
                        Assert.AreEqual("MyProject", projectName);
 
470
                }
 
471
                
 
472
                [Test]
 
473
                public void ActivePackageSource_ConsoleHostCreated_ReturnsRegisteredPackageSourcesActivePackageSource()
 
474
                {
 
475
                        CreateHost();
 
476
                        var expectedPackageSource = new PackageSource("Test");
 
477
                        fakeRegisteredPackageRepositories.ActivePackageSource = expectedPackageSource;
 
478
                        
 
479
                        PackageSource actualPackageSource = host.ActivePackageSource;
 
480
                        
 
481
                        Assert.AreEqual(expectedPackageSource, actualPackageSource);
 
482
                }
 
483
                
 
484
                [Test]
 
485
                public void ActivePackageSource_ActivePackageSourceChanged_RegisteredPackageSourcesActivePackageSourceIsUpdated()
 
486
                {
 
487
                        CreateHost();
 
488
                        var expectedPackageSource = new PackageSource("Test");
 
489
                        host.ActivePackageSource = expectedPackageSource;
 
490
                        
 
491
                        PackageSource actualPackageSource = fakeRegisteredPackageRepositories.ActivePackageSource;
 
492
                        
 
493
                        Assert.AreEqual(expectedPackageSource, actualPackageSource);
 
494
                }
 
495
                
 
496
                [Test]
 
497
                public void Clear_ConsoleWindowHasOutputText_ScriptingConsoleIsCleared()
 
498
                {
 
499
                        CreateHost();
 
500
                        host.Clear();
 
501
                        
 
502
                        bool cleared = scriptingConsole.IsClearCalled;
 
503
                        
 
504
                        Assert.IsTrue(cleared);
 
505
                }
 
506
                
 
507
                [Test]
 
508
                public void WritePrompt_ConsoleWindowHasOutputText_PromptWritten()
 
509
                {
 
510
                        CreateHost();
 
511
                        host.Clear();
 
512
                        host.WritePrompt();
 
513
                        
 
514
                        var expectedTextPassedToWrite = new String[] { "PM> "};
 
515
                        List<string> actualTextPassedToWrite = scriptingConsole.AllTextPassedToWrite;
 
516
                        
 
517
                        CollectionAssert.AreEqual(expectedTextPassedToWrite, actualTextPassedToWrite);
 
518
                }
 
519
                
 
520
                [Test]
 
521
                public void IsRunning_BeforeRunCalled_ReturnsFalse()
 
522
                {
 
523
                        CreateHost();
 
524
                        bool running = host.IsRunning;
 
525
                        
 
526
                        Assert.IsFalse(running);
 
527
                }
 
528
                
 
529
                [Test]
 
530
                public void IsRunning_AfterRunCalled_ReturnsFalse()
 
531
                {
 
532
                        CreateHost();
 
533
                        RunHost();
 
534
                        bool running = host.IsRunning;
 
535
                        
 
536
                        Assert.IsTrue(running);
 
537
                }
 
538
                
 
539
                [Test]
 
540
                public void Run_SolutionOpenWhenConsoleRun_InvokeInitializePackagesCmdletIsRun()
 
541
                {
 
542
                        CreateHost();
 
543
                        fakeSolution.IsOpen = true;
 
544
                        RunHost();
 
545
                        
 
546
                        string expectedExecutedCommand = "Invoke-InitializePackages";
 
547
                        
 
548
                        bool executed = powerShellHost.AllCommandsPassedToExecuteCommand.Contains(expectedExecutedCommand);
 
549
                        
 
550
                        Assert.IsTrue(executed);
 
551
                }
 
552
                
 
553
                [Test]
 
554
                public void Run_SolutionIsNotOpenWhenConsoleRun_InvokeInitializePackagesCmdletIsNotRun()
 
555
                {
 
556
                        CreateHost();
 
557
                        fakeSolution.IsOpen = false;
 
558
                        RunHost();
 
559
                        
 
560
                        string command = "Invoke-InitializePackages";
 
561
                        
 
562
                        bool executed = powerShellHost.AllCommandsPassedToExecuteCommand.Contains(command);
 
563
                        
 
564
                        Assert.IsFalse(executed);
 
565
                }
 
566
                
 
567
                [Test]
 
568
                public void Run_SolutionIsNotOpenWhenConsoleRun_PowerShellWorkingDirectoryIsUpdated()
 
569
                {
 
570
                        CreateHost();
 
571
                        fakeSolution.IsOpen = false;
 
572
                        RunHost();
 
573
                        
 
574
                        string command = "Invoke-UpdateWorkingDirectory";
 
575
                        
 
576
                        bool executed = powerShellHost.AllCommandsPassedToExecuteCommand.Contains(command);
 
577
                        
 
578
                        Assert.IsTrue(executed);
 
579
                }
 
580
                
 
581
                [Test]
 
582
                public void Run_SolutionIsOpenWhenConsoleRun_PowerShellWorkingDirectoryIsUpdated()
 
583
                {
 
584
                        CreateHost();
 
585
                        fakeSolution.IsOpen = true;
 
586
                        RunHost();
 
587
                        
 
588
                        string command = "Invoke-UpdateWorkingDirectory";
 
589
                        
 
590
                        bool executed = powerShellHost.AllCommandsPassedToExecuteCommand.Contains(command);
 
591
                        
 
592
                        Assert.IsTrue(executed);
 
593
                }
 
594
                
 
595
                [Test]
 
596
                public void ShutdownConsole_ScriptingConsoleCreated_DisposesScriptingConsole()
 
597
                {
 
598
                        CreateHost();
 
599
                        host.ShutdownConsole();
 
600
                        
 
601
                        bool disposed = host.FakeScriptingConsole.IsDisposeCalled;
 
602
                        
 
603
                        Assert.IsTrue(disposed);
 
604
                }
 
605
                
 
606
                [Test]
 
607
                public void ShutdownConsole_ScriptingConsoleIsNull_NullReferenceExceptionIsNotThrown()
 
608
                {
 
609
                        CreateHost();
 
610
                        host.ScriptingConsole = null;
 
611
                        
 
612
                        Assert.DoesNotThrow(() => host.ShutdownConsole());
 
613
                }
 
614
                
 
615
                [Test]
 
616
                public void ExecuteCommand_ScriptingConsoleCreated_SendsCommandToScriptingConsole()
 
617
                {
 
618
                        CreateHost();
 
619
                        host.ExecuteCommand("test");
 
620
                        
 
621
                        string text = host.FakeScriptingConsole.TextPassedToSendLine;
 
622
                        string expectedText = "test";
 
623
                        
 
624
                        Assert.AreEqual(expectedText, text);
 
625
                }
 
626
                
 
627
                [Test]
 
628
                public void GetPackageRepository_PackageSourceSpecified_ReturnsPackageRepositoryFromRegisteredRepositories()
 
629
                {
 
630
                        CreateHost();
 
631
                        
 
632
                        var packageSource = new PackageSource("Test");
 
633
                        IPackageRepository repository = host.GetPackageRepository(packageSource);
 
634
                        FakePackageRepository expectedRepository = fakeRegisteredPackageRepositories.FakePackageRepository;
 
635
                        
 
636
                        Assert.AreEqual(expectedRepository, repository);
 
637
                }
 
638
                
 
639
                [Test]
 
640
                public void GetPackageRepository_PackageSourceSpecified_PackagSourceUsedToGetRepository()
 
641
                {
 
642
                        CreateHost();
 
643
                        
 
644
                        var expectedPackageSource = new PackageSource("Test");
 
645
                        IPackageRepository repository = host.GetPackageRepository(expectedPackageSource);
 
646
                        PackageSource packageSource = fakeRegisteredPackageRepositories.PackageSourcePassedToCreateRepository;
 
647
                        
 
648
                        Assert.AreEqual(expectedPackageSource, packageSource);
 
649
                }
 
650
        }
 
651
}