← Back to branch summary

~halega/+junk/sharpdevelop

« back to all changes in this revision

Viewing changes to src/AddIns/Misc/PackageManagement/Test/Src/PackageViewModelTests.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/PackageViewModelTests.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 System.Linq;
 
7
using ICSharpCode.PackageManagement;
 
8
using ICSharpCode.PackageManagement.Design;
 
9
using ICSharpCode.PackageManagement.Scripting;
 
10
using NuGet;
 
11
using NUnit.Framework;
 
12
using PackageManagement.Tests.Helpers;
 
13
 
 
14
namespace PackageManagement.Tests
 
15
{
 
16
        [TestFixture]
 
17
        public class PackageViewModelTests
 
18
        {
 
19
                TestablePackageViewModel viewModel;
 
20
                FakePackage fakePackage;
 
21
                FakePackageManagementSolution fakeSolution;
 
22
                FakePackageManagementEvents fakePackageManagementEvents;
 
23
                ExceptionThrowingPackageManagementSolution exceptionThrowingSolution;
 
24
                ExceptionThrowingPackageManagementProject exceptionThrowingProject;
 
25
                FakeInstallPackageAction fakeInstallPackageAction;
 
26
                FakeUninstallPackageAction fakeUninstallPackageAction;
 
27
                FakeLogger fakeLogger;
 
28
                FakePackageActionRunner fakeActionRunner;
 
29
                List<FakeSelectedProject> fakeSelectedProjects;
 
30
                
 
31
                void CreateFakeSolution()
 
32
                {
 
33
                        fakeSolution = new FakePackageManagementSolution();
 
34
                        fakeSolution.FakeActiveMSBuildProject = ProjectHelper.CreateTestProject();
 
35
                }
 
36
                
 
37
                void CreateViewModel()
 
38
                {
 
39
                        CreateFakeSolution();
 
40
                        CreateViewModel(fakeSolution);
 
41
                }
 
42
                
 
43
                void CreateViewModelWithExceptionThrowingSolution()
 
44
                {
 
45
                        exceptionThrowingSolution = new ExceptionThrowingPackageManagementSolution();
 
46
                        exceptionThrowingSolution.FakeActiveMSBuildProject = ProjectHelper.CreateTestProject();
 
47
                        CreateViewModel(exceptionThrowingSolution);
 
48
                }
 
49
                
 
50
                void CreateViewModelWithExceptionThrowingProject()
 
51
                {
 
52
                        CreateViewModel();
 
53
                        exceptionThrowingProject = new ExceptionThrowingPackageManagementProject();
 
54
                        viewModel.FakeSolution.FakeProjectToReturnFromGetProject = exceptionThrowingProject;
 
55
                }
 
56
                
 
57
                void CreateViewModel(FakePackageManagementSolution solution)
 
58
                {
 
59
                        viewModel = new TestablePackageViewModel(solution);
 
60
                        fakePackage = viewModel.FakePackage;
 
61
                        this.fakeSolution = solution;
 
62
                        fakePackageManagementEvents = viewModel.FakePackageManagementEvents;
 
63
                        fakeLogger = viewModel.FakeLogger;
 
64
                        fakeInstallPackageAction = solution.FakeProjectToReturnFromGetProject.FakeInstallPackageAction;
 
65
                        fakeUninstallPackageAction = solution.FakeProjectToReturnFromGetProject.FakeUninstallPackageAction;
 
66
                        fakeActionRunner = viewModel.FakeActionRunner;
 
67
                }
 
68
                
 
69
                void AddProjectToSolution()
 
70
                {
 
71
                        TestableProject project = ProjectHelper.CreateTestProject();
 
72
                        fakeSolution.FakeMSBuildProjects.Add(project);
 
73
                }
 
74
                
 
75
                void CreateViewModelWithTwoProjectsSelected(string projectName1, string projectName2)
 
76
                {
 
77
                        CreateFakeSolution();
 
78
                        AddTwoProjectsSelected(projectName1, projectName2);
 
79
                        CreateViewModel(fakeSolution);
 
80
                }
 
81
 
 
82
                void AddTwoProjectsSelected(string projectName1, string projectName2)
 
83
                {                       
 
84
                        AddProjectToSolution();
 
85
                        AddProjectToSolution();
 
86
                        fakeSolution.FakeMSBuildProjects[0].Name = projectName1;
 
87
                        fakeSolution.FakeMSBuildProjects[1].Name = projectName2;
 
88
                        fakeSolution.NoProjectsSelected();
 
89
                        
 
90
                        fakeSolution.AddFakeProjectToReturnFromGetProject(projectName1);
 
91
                        fakeSolution.AddFakeProjectToReturnFromGetProject(projectName2);
 
92
                }
 
93
                
 
94
                void SetPackageIdAndVersion(string id, string version)
 
95
                {
 
96
                        fakePackage.Id = id;
 
97
                        fakePackage.Version = new Version(version);
 
98
                }
 
99
                
 
100
                void UserCancelsProjectSelection()
 
101
                {
 
102
                        fakePackageManagementEvents.OnSelectProjectsReturnValue = false;
 
103
                }
 
104
                
 
105
                void UserAcceptsProjectSelection()
 
106
                {
 
107
                        fakePackageManagementEvents.OnSelectProjectsReturnValue = true;
 
108
                }
 
109
                
 
110
                List<FakeSelectedProject> CreateTwoFakeSelectedProjects()
 
111
                {
 
112
                        fakeSelectedProjects = new List<FakeSelectedProject>();
 
113
                        fakeSelectedProjects.Add(new FakeSelectedProject("Project A"));
 
114
                        fakeSelectedProjects.Add(new FakeSelectedProject("Project B"));
 
115
                        return fakeSelectedProjects;
 
116
                }
 
117
                
 
118
                FakePackageOperation AddFakeInstallPackageOperationWithPackageThatRequiresLicenseAcceptance(FakeSelectedProject selectedProject)
 
119
                {
 
120
                        return AddFakeInstallPackageOperationWithPackage(selectedProject, requireLicenseAcceptance: true);
 
121
                }
 
122
                
 
123
                FakePackageOperation AddFakeInstallPackageOperationWithPackageThatDoesNotRequireLicenseAcceptance(FakeSelectedProject selectedProject)
 
124
                {
 
125
                        return AddFakeInstallPackageOperationWithPackage(selectedProject, requireLicenseAcceptance: false);
 
126
                }
 
127
                
 
128
                FakePackageOperation AddFakeInstallPackageOperationWithPackage(FakeSelectedProject selectedProject, bool requireLicenseAcceptance)
 
129
                {
 
130
                        FakePackageOperation operation = selectedProject.AddFakeInstallPackageOperation();
 
131
                        operation.FakePackage.RequireLicenseAcceptance = requireLicenseAcceptance;
 
132
                        return operation;
 
133
                }
 
134
                
 
135
                FakePackageOperation AddFakeUninstallPackageOperationWithPackageThatRequiresLicenseAcceptance(FakeSelectedProject selectedProject)
 
136
                {
 
137
                        FakePackageOperation uninstallOperation = selectedProject.AddFakeUninstallPackageOperation();
 
138
                        uninstallOperation.FakePackage.RequireLicenseAcceptance = true;
 
139
                        return uninstallOperation;
 
140
                }
 
141
                
 
142
                FakeSelectedProject FirstFakeSelectedProject {
 
143
                        get { return fakeSelectedProjects[0]; }
 
144
                }
 
145
                
 
146
                FakeSelectedProject SecondFakeSelectedProject {
 
147
                        get { return fakeSelectedProjects[1]; }
 
148
                }
 
149
                
 
150
                [Test]
 
151
                public void AddPackageCommand_CommandExecuted_InstallsPackage()
 
152
                {
 
153
                        CreateViewModel();
 
154
                        viewModel.AddOneFakeInstallPackageOperationForViewModelPackage();
 
155
                        
 
156
                        viewModel.AddPackageCommand.Execute(null);
 
157
                                                
 
158
                        Assert.AreEqual(fakePackage, fakeInstallPackageAction.Package);
 
159
                }
 
160
                
 
161
                [Test]
 
162
                public void AddPackage_PackageAddedSuccessfully_SourcePackageRepositoryUsedToCreateProject()
 
163
                {
 
164
                        CreateViewModel();
 
165
                        viewModel.AddOneFakeInstallPackageOperationForViewModelPackage();
 
166
                        
 
167
                        viewModel.AddPackage();
 
168
                                                
 
169
                        Assert.AreEqual(fakePackage.Repository, fakeSolution.RepositoryPassedToGetProject);
 
170
                }
 
171
                
 
172
                [Test]
 
173
                public void AddPackage_PackageAddedSuccessfully_PackageIsInstalled()
 
174
                {
 
175
                        CreateViewModel();
 
176
                        viewModel.AddOneFakeInstallPackageOperationForViewModelPackage();
 
177
                        
 
178
                        viewModel.AddPackage();
 
179
                        
 
180
                        ProcessPackageAction actionExecuted = fakeActionRunner.ActionPassedToRun;
 
181
                        
 
182
                        Assert.AreEqual(fakeInstallPackageAction, actionExecuted);
 
183
                }
 
184
                
 
185
                [Test]
 
186
                public void AddPackage_PackageAddedSuccessfully_PackageOperationsUsedWhenInstallingPackage()
 
187
                {
 
188
                        CreateViewModel();
 
189
                        viewModel.AddOneFakeInstallPackageOperationForViewModelPackage();
 
190
                        viewModel.AddPackage();
 
191
                
 
192
                        PackageOperation[] expectedOperations = new PackageOperation[] {
 
193
                                new PackageOperation(fakePackage, PackageAction.Install)
 
194
                        };
 
195
                        
 
196
                        CollectionAssert.AreEqual(expectedOperations, fakeInstallPackageAction.Operations);
 
197
                }
 
198
                
 
199
                [Test]
 
200
                public void AddPackage_PackageAddedSuccessfully_PropertyNotifyChangedFiredForIsAddedProperty()
 
201
                {
 
202
                        CreateViewModel();
 
203
                        viewModel.AddOneFakeInstallPackageOperationForViewModelPackage();
 
204
 
 
205
                        string propertyChangedName = null;
 
206
                        viewModel.PropertyChanged += (sender, e) => propertyChangedName = e.PropertyName;
 
207
                        viewModel.AddPackage();
 
208
                        
 
209
                        Assert.AreEqual("IsAdded", propertyChangedName);
 
210
                }
 
211
 
 
212
                [Test]
 
213
                public void AddPackage_PackageAddedSuccessfully_PropertyNotifyChangedFiredAfterPackageInstalled()
 
214
                {
 
215
                        CreateViewModel();
 
216
                        IPackage packagePassedToInstallPackageWhenPropertyNameChanged = null;
 
217
                        viewModel.PropertyChanged += (sender, e) => {
 
218
                                packagePassedToInstallPackageWhenPropertyNameChanged = fakeInstallPackageAction.Package;
 
219
                        };
 
220
                        viewModel.AddPackage();
 
221
                        
 
222
                        Assert.AreEqual(fakePackage, packagePassedToInstallPackageWhenPropertyNameChanged);
 
223
                }
 
224
 
 
225
                [Test]
 
226
                public void HasLicenseUrl_PackageHasLicenseUrl_ReturnsTrue()
 
227
                {
 
228
                        CreateViewModel();
 
229
                        fakePackage.LicenseUrl = new Uri("http://sharpdevelop.com");
 
230
                        
 
231
                        Assert.IsTrue(viewModel.HasLicenseUrl);
 
232
                }
 
233
                
 
234
                [Test]
 
235
                public void HasLicenseUrl_PackageHasNoLicenseUrl_ReturnsFalse()
 
236
                {
 
237
                        CreateViewModel();
 
238
                        fakePackage.LicenseUrl = null;
 
239
                        
 
240
                        Assert.IsFalse(viewModel.HasLicenseUrl);
 
241
                }
 
242
                
 
243
                [Test]
 
244
                public void HasProjectUrl_PackageHasProjectUrl_ReturnsTrue()
 
245
                {
 
246
                        CreateViewModel();
 
247
                        fakePackage.ProjectUrl = new Uri("http://sharpdevelop.com");
 
248
                        
 
249
                        Assert.IsTrue(viewModel.HasProjectUrl);
 
250
                }
 
251
                
 
252
                [Test]
 
253
                public void HasProjectUrl_PackageHasNoProjectUrl_ReturnsFalse()
 
254
                {
 
255
                        CreateViewModel();
 
256
                        fakePackage.ProjectUrl = null;
 
257
                        
 
258
                        Assert.IsFalse(viewModel.HasProjectUrl);
 
259
                }
 
260
                
 
261
                [Test]
 
262
                public void HasReportAbuseUrl_PackageHasReportAbuseUrl_ReturnsTrue()
 
263
                {
 
264
                        CreateViewModel();
 
265
                        fakePackage.ReportAbuseUrl = new Uri("http://sharpdevelop.com");
 
266
                        
 
267
                        Assert.IsTrue(viewModel.HasReportAbuseUrl);
 
268
                }
 
269
                
 
270
                [Test]
 
271
                public void HasReportAbuseUrl_PackageHasNoReportAbuseUrl_ReturnsFalse()
 
272
                {
 
273
                        CreateViewModel();
 
274
                        fakePackage.ReportAbuseUrl = null;
 
275
                        
 
276
                        Assert.IsFalse(viewModel.HasReportAbuseUrl);
 
277
                }
 
278
                
 
279
                [Test]
 
280
                public void IsAdded_ProjectHasPackageAdded_ReturnsTrue()
 
281
                {
 
282
                        CreateViewModel();
 
283
                        fakeSolution.FakeProjectToReturnFromGetProject.FakePackages.Add(fakePackage);
 
284
                        
 
285
                        Assert.IsTrue(viewModel.IsAdded);
 
286
                }
 
287
                
 
288
                [Test]
 
289
                public void IsAdded_ProjectDoesNotHavePackageInstalled_ReturnsFalse()
 
290
                {
 
291
                        CreateViewModel();
 
292
                        fakeSolution.FakeProjectToReturnFromGetProject.FakePackages.Clear();
 
293
                        
 
294
                        Assert.IsFalse(viewModel.IsAdded);
 
295
                }
 
296
                
 
297
                [Test]
 
298
                public void RemovePackageCommand_CommandExecuted_UninstallsPackage()
 
299
                {
 
300
                        CreateViewModel();
 
301
                        viewModel.RemovePackageCommand.Execute(null);
 
302
                                                
 
303
                        Assert.AreEqual(fakePackage, fakeUninstallPackageAction.Package);
 
304
                }
 
305
                
 
306
                [Test]
 
307
                public void RemovePackage_PackageRemovedSuccessfully_RepositoryUsedToCreateProject()
 
308
                {
 
309
                        CreateViewModel();
 
310
                        viewModel.RemovePackage();
 
311
                        
 
312
                        Assert.AreEqual(fakePackage.Repository, fakeSolution.RepositoryPassedToGetProject);
 
313
                }
 
314
                
 
315
                [Test]
 
316
                public void RemovePackage_PackageRemovedSuccessfully_PropertyNotifyChangedFiredForIsAddedProperty()
 
317
                {
 
318
                        CreateViewModel();
 
319
                        string propertyChangedName = null;
 
320
                        viewModel.PropertyChanged += (sender, e) => propertyChangedName = e.PropertyName;
 
321
                        viewModel.RemovePackage();
 
322
                        
 
323
                        Assert.AreEqual("IsAdded", propertyChangedName);
 
324
                }
 
325
                
 
326
                [Test]
 
327
                public void RemovePackage_PackageRemovedSuccessfully_PropertyNotifyChangedFiredAfterPackageUninstalled()
 
328
                {
 
329
                        CreateViewModel();
 
330
                        IPackage packagePassedToUninstallPackageWhenPropertyNameChanged = null;
 
331
                        viewModel.PropertyChanged += (sender, e) => {
 
332
                                packagePassedToUninstallPackageWhenPropertyNameChanged = fakeUninstallPackageAction.Package;
 
333
                        };
 
334
                        viewModel.RemovePackage();
 
335
                        
 
336
                        Assert.AreEqual(fakePackage, packagePassedToUninstallPackageWhenPropertyNameChanged);
 
337
                }
 
338
                
 
339
                [Test]
 
340
                public void HasDependencies_PackageHasNoDependencies_ReturnsFalse()
 
341
                {
 
342
                        CreateViewModel();
 
343
                        fakePackage.HasDependencies = false;
 
344
                        
 
345
                        Assert.IsFalse(viewModel.HasDependencies);
 
346
                }
 
347
                
 
348
                [Test]
 
349
                public void HasDependencies_PackageHasDependency_ReturnsTrue()
 
350
                {
 
351
                        CreateViewModel();
 
352
                        fakePackage.HasDependencies = true;
 
353
                        
 
354
                        Assert.IsTrue(viewModel.HasDependencies);
 
355
                }
 
356
                
 
357
                [Test]
 
358
                public void HasNoDependencies_PackageHasNoDependencies_ReturnsTrue()
 
359
                {
 
360
                        CreateViewModel();
 
361
                        fakePackage.HasDependencies = false;
 
362
                        
 
363
                        Assert.IsTrue(viewModel.HasNoDependencies);
 
364
                }
 
365
                
 
366
                [Test]
 
367
                public void HasNoDependencies_PackageHasOneDependency_ReturnsFalse()
 
368
                {
 
369
                        CreateViewModel();
 
370
                        fakePackage.HasDependencies = true;
 
371
                        
 
372
                        Assert.IsFalse(viewModel.HasNoDependencies);
 
373
                }
 
374
                
 
375
                [Test]
 
376
                public void HasDownloadCount_DownloadCountIsZero_ReturnsTrue()
 
377
                {
 
378
                        CreateViewModel();
 
379
                        fakePackage.DownloadCount = 0;
 
380
                        
 
381
                        Assert.IsTrue(viewModel.HasDownloadCount);
 
382
                }
 
383
                
 
384
                [Test]
 
385
                public void HasDownloadCount_DownloadCountIsMinusOne_ReturnsFalse()
 
386
                {
 
387
                        CreateViewModel();
 
388
                        fakePackage.DownloadCount = -1;
 
389
                        
 
390
                        Assert.IsFalse(viewModel.HasDownloadCount);
 
391
                }
 
392
                
 
393
                [Test]
 
394
                public void HasLastUpdated_PackageHasLastUpdatedDate_ReturnsTrue()
 
395
                {
 
396
                        CreateViewModel();
 
397
                        fakePackage.LastUpdated = new DateTime(2011, 1, 2);
 
398
                        
 
399
                        Assert.IsTrue(viewModel.HasLastUpdated);
 
400
                }
 
401
                
 
402
                [Test]
 
403
                public void HasLastUpdated_PackageHasNoLastUpdatedDate_ReturnsFalse()
 
404
                {
 
405
                        CreateViewModel();
 
406
                        fakePackage.LastUpdated = null;
 
407
                        
 
408
                        Assert.IsFalse(viewModel.HasLastUpdated);
 
409
                }
 
410
                                
 
411
                [Test]
 
412
                public void AddPackage_PackageRequiresLicenseAgreementAcceptance_UserAskedToAcceptLicenseAgreementForPackageBeforeInstalling()
 
413
                {
 
414
                        CreateViewModel();
 
415
                        viewModel.AddOneFakeInstallPackageOperationForViewModelPackage();
 
416
                        fakePackage.RequireLicenseAcceptance = true;
 
417
                        fakePackageManagementEvents.OnAcceptLicensesReturnValue = true;
 
418
                        
 
419
                        viewModel.AddPackage();
 
420
                        
 
421
                        var expectedPackages = new FakePackage[] {
 
422
                                fakePackage
 
423
                        };
 
424
                        
 
425
                        IEnumerable<IPackage> actualPackages = fakePackageManagementEvents.LastPackagesPassedToOnAcceptLicenses;
 
426
                        
 
427
                        CollectionAssert.AreEqual(expectedPackages, actualPackages);
 
428
                }
 
429
                
 
430
                [Test]
 
431
                public void AddPackage_PackageRequiresLicenseAgreementAcceptanceButPackageInstalledInSolutionAlready_UserNotAskedToAcceptLicenseAgreementForPackageBeforeInstalling()
 
432
                {
 
433
                        CreateViewModel();
 
434
                        viewModel.AddOneFakeInstallPackageOperationForViewModelPackage();
 
435
                        fakePackage.RequireLicenseAcceptance = true;
 
436
                        fakePackageManagementEvents.OnAcceptLicensesReturnValue = true;
 
437
                        fakeSolution.FakeInstalledPackages.Add(fakePackage);
 
438
                        
 
439
                        viewModel.AddPackage();
 
440
                        
 
441
                        bool acceptLicenses = fakePackageManagementEvents.IsOnAcceptLicensesCalled;
 
442
                        
 
443
                        Assert.IsFalse(acceptLicenses);
 
444
                }
 
445
                
 
446
                [Test]
 
447
                public void AddPackage_PackageDoesNotRequireLicenseAgreementAcceptance_UserNotAskedToAcceptLicenseAgreementBeforeInstalling()
 
448
                {
 
449
                        CreateViewModel();
 
450
                        fakePackage.RequireLicenseAcceptance = false;
 
451
                        viewModel.AddPackage();
 
452
                        
 
453
                        Assert.IsFalse(fakePackageManagementEvents.IsOnAcceptLicensesCalled);
 
454
                }
 
455
                
 
456
                [Test]
 
457
                public void AddPackage_PackageRequiresLicenseAgreementAcceptanceAndUserDeclinesAgreement_PackageIsNotInstalled()
 
458
                {
 
459
                        CreateViewModel();
 
460
                        viewModel.AddOneFakeInstallPackageOperationForViewModelPackage();
 
461
                        fakePackage.RequireLicenseAcceptance = true;
 
462
                        fakePackageManagementEvents.OnAcceptLicensesReturnValue = false;
 
463
                        
 
464
                        viewModel.AddPackage();
 
465
                        
 
466
                        Assert.IsFalse(fakeInstallPackageAction.IsExecuteCalled);
 
467
                }
 
468
                
 
469
                [Test]
 
470
                public void AddPackage_PackageRequiresLicenseAgreementAcceptanceAndUserDeclinesAgreement_PropertyChangedEventNotFired()
 
471
                {
 
472
                        CreateViewModel();
 
473
                        viewModel.AddOneFakeInstallPackageOperationForViewModelPackage();
 
474
                        fakePackage.RequireLicenseAcceptance = true;
 
475
                        fakePackageManagementEvents.OnAcceptLicensesReturnValue = false;
 
476
                        bool propertyChangedEventFired = false;
 
477
                        viewModel.PropertyChanged += (sender, e) => propertyChangedEventFired = true;
 
478
                        
 
479
                        viewModel.AddPackage();
 
480
                        
 
481
                        Assert.IsFalse(propertyChangedEventFired);
 
482
                }
 
483
                
 
484
                [Test]
 
485
                public void AddPackage_OnePackageOperationIsToUninstallPackageWhichRequiresLicenseAcceptance_UserIsNotAskedToAcceptLicenseAgreementForPackageToBeUninstalled()
 
486
                {
 
487
                        CreateViewModel();
 
488
                        fakePackage.RequireLicenseAcceptance = false;
 
489
                        PackageOperation operation = viewModel.AddOneFakeUninstallPackageOperation();
 
490
                        FakePackage packageToUninstall = operation.Package as FakePackage;
 
491
                        packageToUninstall.RequireLicenseAcceptance = true;
 
492
                        viewModel.AddPackage();
 
493
                        
 
494
                        Assert.IsFalse(fakePackageManagementEvents.IsOnAcceptLicensesCalled);
 
495
                }
 
496
                
 
497
                [Test]
 
498
                public void AddPackage_CheckLoggerUsed_PackageViewModelLoggerUsedWhenResolvingPackageOperations()
 
499
                {
 
500
                        CreateViewModel();
 
501
                        viewModel.AddOneFakeInstallPackageOperationForViewModelPackage();
 
502
                        viewModel.AddPackage();
 
503
                        
 
504
                        ILogger expectedLogger = viewModel.OperationLoggerCreated;
 
505
                        ILogger actualLogger = fakeSolution.FakeProjectToReturnFromGetProject.Logger;
 
506
                        Assert.AreEqual(expectedLogger, actualLogger);
 
507
                }
 
508
                
 
509
                [Test]
 
510
                public void AddPackage_PackageAddedSuccessfully_InstallingPackageMessageIsFirstMessageLogged()
 
511
                {
 
512
                        CreateViewModel();
 
513
                        viewModel.AddOneFakeInstallPackageOperationForViewModelPackage();
 
514
                        fakePackage.Id = "Test.Package";
 
515
                        fakePackage.Version = new Version(1, 2, 0, 55);
 
516
                        viewModel.AddPackage();
 
517
                        
 
518
                        string expectedMessage = "------- Installing...Test.Package 1.2.0.55 -------";
 
519
                        string actualMessage = fakeLogger.FirstFormattedMessageLogged;
 
520
                        
 
521
                        Assert.AreEqual(expectedMessage, actualMessage);
 
522
                }
 
523
                
 
524
                [Test]
 
525
                public void AddPackage_PackageAddedSuccessfully_NextToLastMessageLoggedMarksEndOfInstallation()
 
526
                {
 
527
                        CreateViewModel();
 
528
                        viewModel.AddOneFakeInstallPackageOperationForViewModelPackage();
 
529
                        viewModel.AddPackage();
 
530
                        
 
531
                        string expectedMessage = "==============================";
 
532
                        string actualMessage = fakeLogger.NextToLastFormattedMessageLogged;
 
533
                                                
 
534
                        Assert.AreEqual(expectedMessage, actualMessage);
 
535
                }
 
536
                
 
537
                [Test]
 
538
                public void AddPackage_PackageAddedSuccessfully_LastMessageLoggedIsEmptyLine()
 
539
                {
 
540
                        CreateViewModel();
 
541
                        viewModel.AddOneFakeInstallPackageOperationForViewModelPackage();
 
542
                        viewModel.AddPackage();
 
543
                        
 
544
                        string expectedMessage = String.Empty;
 
545
                        string actualMessage = fakeLogger.LastFormattedMessageLogged;
 
546
                                                
 
547
                        Assert.AreEqual(expectedMessage, actualMessage);
 
548
                }
 
549
                
 
550
                [Test]
 
551
                public void RemovePackage_PackageRemovedSuccessfully_UninstallingPackageMessageIsFirstMessageLogged()
 
552
                {
 
553
                        CreateViewModel();
 
554
                        viewModel.AddOneFakeInstallPackageOperationForViewModelPackage();
 
555
                        fakePackage.Id = "Test.Package";
 
556
                        fakePackage.Version = new Version(1, 2, 0, 55);
 
557
                        viewModel.RemovePackage();
 
558
                        
 
559
                        string expectedMessage = "------- Uninstalling...Test.Package 1.2.0.55 -------";
 
560
                        string actualMessage = fakeLogger.FirstFormattedMessageLogged;
 
561
                                                
 
562
                        Assert.AreEqual(expectedMessage, actualMessage);
 
563
                }
 
564
                
 
565
                [Test]
 
566
                public void RemovePackage_PackageRemovedSuccessfully_NextToLastMessageLoggedMarksEndOfInstallation()
 
567
                {
 
568
                        CreateViewModel();
 
569
                        viewModel.AddOneFakeInstallPackageOperationForViewModelPackage();
 
570
                        viewModel.RemovePackage();
 
571
                        
 
572
                        string expectedMessage = "==============================";
 
573
                        string actualMessage = fakeLogger.NextToLastFormattedMessageLogged;
 
574
                                                
 
575
                        Assert.AreEqual(expectedMessage, actualMessage);
 
576
                }
 
577
                
 
578
                [Test]
 
579
                public void RemovePackage_PackageRemovedSuccessfully_LastMessageLoggedIsEmptyLine()
 
580
                {
 
581
                        CreateViewModel();
 
582
                        viewModel.RemovePackage();
 
583
                        
 
584
                        string expectedMessage = String.Empty;
 
585
                        string actualMessage = fakeLogger.LastFormattedMessageLogged;
 
586
                                                
 
587
                        Assert.AreEqual(expectedMessage, actualMessage);
 
588
                }
 
589
                
 
590
                [Test]
 
591
                public void AddPackage_ExceptionWhenInstallingPackage_ExceptionErrorMessageReported()
 
592
                {
 
593
                        CreateViewModelWithExceptionThrowingProject();
 
594
                        viewModel.AddOneFakeInstallPackageOperationForViewModelPackage();
 
595
                        Exception ex = new Exception("Test");
 
596
                        exceptionThrowingProject.ExceptionToThrowWhenCreateInstallPackageActionCalled = ex;
 
597
                        viewModel.AddPackage();
 
598
                        
 
599
                        Assert.AreEqual(ex, fakePackageManagementEvents.ExceptionPassedToOnPackageOperationError);
 
600
                }
 
601
                
 
602
                [Test]
 
603
                public void AddPackage_PackageAddedSuccessfully_MessagesReportedPreviouslyAreCleared()
 
604
                {
 
605
                        CreateViewModel();
 
606
                        viewModel.AddOneFakeInstallPackageOperationForViewModelPackage();
 
607
                        viewModel.AddPackage();
 
608
                        
 
609
                        Assert.IsTrue(fakePackageManagementEvents.IsOnPackageOperationsStartingCalled);
 
610
                }
 
611
                
 
612
                [Test]
 
613
                public void AddPackage_ExceptionWhenInstallingPackage_ExceptionLogged()
 
614
                {
 
615
                        CreateViewModelWithExceptionThrowingProject();
 
616
                        viewModel.AddOneFakeInstallPackageOperationForViewModelPackage();
 
617
                        Exception ex = new Exception("Exception error message");
 
618
                        exceptionThrowingProject.ExceptionToThrowWhenCreateInstallPackageActionCalled = ex;
 
619
                        viewModel.AddPackage();
 
620
                        
 
621
                        string actualMessage = fakeLogger.SecondFormattedMessageLogged;
 
622
                        bool containsExceptionErrorMessage = actualMessage.Contains("Exception error message");
 
623
                        
 
624
                        Assert.IsTrue(containsExceptionErrorMessage, actualMessage);
 
625
                }
 
626
                
 
627
                [Test]
 
628
                public void RemovePackage_ExceptionWhenUninstallingPackage_ExceptionErrorMessageReported()
 
629
                {
 
630
                        CreateViewModelWithExceptionThrowingProject();
 
631
                        Exception ex = new Exception("Test");
 
632
                        exceptionThrowingProject.ExceptionToThrowWhenCreateUninstallPackageActionCalled = ex;
 
633
                        viewModel.RemovePackage();
 
634
                        
 
635
                        Assert.AreEqual(ex, fakePackageManagementEvents.ExceptionPassedToOnPackageOperationError);
 
636
                }
 
637
                
 
638
                [Test]
 
639
                public void RemovePackage_PackageUninstalledSuccessfully_MessagesReportedPreviouslyAreCleared()
 
640
                {
 
641
                        CreateViewModel();
 
642
                        viewModel.RemovePackage();
 
643
                        
 
644
                        Assert.IsTrue(fakePackageManagementEvents.IsOnPackageOperationsStartingCalled);
 
645
                }
 
646
                
 
647
                [Test]
 
648
                public void RemovePackage_ExceptionWhenUninstallingPackage_ExceptionLogged()
 
649
                {
 
650
                        CreateViewModelWithExceptionThrowingProject();
 
651
                        Exception ex = new Exception("Exception error message");
 
652
                        exceptionThrowingProject.ExceptionToThrowWhenCreateUninstallPackageActionCalled = ex;
 
653
                        viewModel.RemovePackage();
 
654
                        
 
655
                        string actualMessage = fakeLogger.SecondFormattedMessageLogged;
 
656
                        bool containsExceptionErrorMessage = actualMessage.Contains("Exception error message");
 
657
                        
 
658
                        Assert.IsTrue(containsExceptionErrorMessage, actualMessage);
 
659
                }
 
660
                
 
661
                [Test]
 
662
                public void AddPackage_ExceptionThrownWhenResolvingPackageOperations_ExceptionReported()
 
663
                {
 
664
                        CreateViewModelWithExceptionThrowingSolution();
 
665
                        viewModel.AddOneFakeInstallPackageOperationForViewModelPackage();
 
666
                        
 
667
                        var exception = new Exception("Test");
 
668
                        exceptionThrowingSolution.ExceptionToThrowWhenGetProjectCalled = exception;
 
669
                        viewModel.AddPackage();
 
670
                        
 
671
                        Assert.AreEqual(exception, fakePackageManagementEvents.ExceptionPassedToOnPackageOperationError);
 
672
                }
 
673
                
 
674
                [Test]
 
675
                public void AddPackage_PackagesInstalledSuccessfully_ViewModelPackageUsedWhenResolvingPackageOperations()
 
676
                {
 
677
                        CreateViewModel();
 
678
                        viewModel.AddOneFakeInstallPackageOperationForViewModelPackage();
 
679
                        viewModel.AddPackage();
 
680
                        
 
681
                        FakePackage expectedPackage = fakePackage;
 
682
                        IPackage actualPackage = fakeSolution
 
683
                                .FakeProjectToReturnFromGetProject
 
684
                                .PackagePassedToGetInstallPackageOperations;
 
685
                        
 
686
                        Assert.AreEqual(expectedPackage, actualPackage);
 
687
                }
 
688
                
 
689
                [Test]
 
690
                public void AddPackage_PackagesInstalledSuccessfully_PackageDependenciesNotIgnoredWhenCheckingForPackageOperations()
 
691
                {
 
692
                        CreateViewModel();
 
693
                        viewModel.AddOneFakeInstallPackageOperationForViewModelPackage();
 
694
                        viewModel.AddPackage();
 
695
                        
 
696
                        bool result = fakeSolution
 
697
                                .FakeProjectToReturnFromGetProject
 
698
                                .IgnoreDependenciesPassedToGetInstallPackageOperations;
 
699
                        
 
700
                        Assert.IsFalse(result);
 
701
                }
 
702
                
 
703
                [Test]
 
704
                public void RemovePackage_PackageRemovedSuccessfully_PackageIsRemoved()
 
705
                {
 
706
                        CreateViewModel();
 
707
                        viewModel.AddOneFakeInstallPackageOperationForViewModelPackage();
 
708
                        viewModel.RemovePackage();
 
709
                        
 
710
                        ProcessPackageAction actionExecuted = fakeActionRunner.ActionPassedToRun;
 
711
                        
 
712
                        Assert.AreEqual(fakeUninstallPackageAction, actionExecuted);
 
713
                }
 
714
                
 
715
                [Test]
 
716
                public void IsAdded_SolutionSelectedContainingOneProjectAndPackageIsInstalledInSolutionSharedRepository_ReturnsTrue()
 
717
                {
 
718
                        CreateFakeSolution();
 
719
                        AddProjectToSolution();
 
720
                        fakeSolution.NoProjectsSelected();
 
721
                        fakeSolution.FakeInstalledPackages.Add(fakePackage);
 
722
                        CreateViewModel(fakeSolution);
 
723
                        
 
724
                        bool added = viewModel.IsAdded;
 
725
                        
 
726
                        Assert.IsTrue(added);
 
727
                }
 
728
                
 
729
                [Test]
 
730
                public void IsAdded_SolutionSelectedContainingOneProjectAndPackageIsNotInstalledInSolutionSharedRepository_ReturnsFalse()
 
731
                {
 
732
                        CreateViewModel();
 
733
                        AddProjectToSolution();
 
734
                        fakeSolution.NoProjectsSelected();
 
735
                        
 
736
                        bool added = viewModel.IsAdded;
 
737
                        
 
738
                        Assert.IsFalse(added);
 
739
                }
 
740
                
 
741
                [Test]
 
742
                public void IsManaged_SolutionSelectedContainingTwoProjects_ReturnsTrue()
 
743
                {
 
744
                        CreateFakeSolution();
 
745
                        AddProjectToSolution();
 
746
                        AddProjectToSolution();
 
747
                        fakeSolution.NoProjectsSelected();
 
748
                        CreateViewModel(fakeSolution);
 
749
                        
 
750
                        bool managed = viewModel.IsManaged;
 
751
                        
 
752
                        Assert.IsTrue(managed);
 
753
                }
 
754
                
 
755
                [Test]
 
756
                public void IsManaged_SolutionWithOneProjectSelected_ReturnsFalse()
 
757
                {
 
758
                        CreateFakeSolution();
 
759
                        AddProjectToSolution();
 
760
                        fakeSolution.FakeActiveMSBuildProject = fakeSolution.FakeMSBuildProjects[0];
 
761
                        CreateViewModel(fakeSolution);
 
762
                        
 
763
                        bool managed = viewModel.IsManaged;
 
764
                        
 
765
                        Assert.IsFalse(managed);
 
766
                }
 
767
                
 
768
                [Test]
 
769
                public void ManagePackageCommand_TwoProjectsSelectedAndCommandExecuted_UserPromptedToSelectTwoProjects()
 
770
                {
 
771
                        CreateViewModelWithTwoProjectsSelected("Project A", "Project B");
 
772
                        UserCancelsProjectSelection();
 
773
                        viewModel.ManagePackageCommand.Execute(null);
 
774
                        
 
775
                        IEnumerable<IPackageManagementSelectedProject> selectedProjects = 
 
776
                                fakePackageManagementEvents.SelectedProjectsPassedToOnSelectProjects;
 
777
                        
 
778
                        var expectedSelectedProjects = new List<IPackageManagementSelectedProject>();
 
779
                        expectedSelectedProjects.Add(new FakeSelectedProject("Project A"));
 
780
                        expectedSelectedProjects.Add(new FakeSelectedProject("Project B"));
 
781
                        
 
782
                        SelectedProjectCollectionAssert.AreEqual(expectedSelectedProjects, selectedProjects);
 
783
                }
 
784
                
 
785
                [Test]
 
786
                public void ManagePackage_TwoProjectsSelectedAndUserAcceptsSelectedProjects_MessagesReportedPreviouslyAreCleared()
 
787
                {
 
788
                        CreateViewModelWithTwoProjectsSelected("Project A", "Project B");
 
789
                        UserAcceptsProjectSelection();
 
790
                        
 
791
                        viewModel.ManagePackage();
 
792
                        
 
793
                        Assert.IsTrue(fakePackageManagementEvents.IsOnPackageOperationsStartingCalled);
 
794
                }
 
795
                
 
796
                [Test]
 
797
                public void ManagePackage_TwoProjectsSelectedAndUserCancelsSelectedProjects_MessagesReportedPreviouslyAreNotCleared()
 
798
                {
 
799
                        CreateViewModelWithTwoProjectsSelected("Project A", "Project B");
 
800
                        UserCancelsProjectSelection();
 
801
                        
 
802
                        viewModel.ManagePackage();
 
803
                        
 
804
                        Assert.IsFalse(fakePackageManagementEvents.IsOnPackageOperationsStartingCalled);
 
805
                }
 
806
                
 
807
                [Test]
 
808
                public void ManagePackage_TwoProjectsSelectedAndUserAcceptsSelectedProjects_IsAddedPropertyChanged()
 
809
                {
 
810
                        CreateViewModelWithTwoProjectsSelected("Project A", "Project B");
 
811
                        UserAcceptsProjectSelection();
 
812
                        
 
813
                        string propertyChangedName = null;
 
814
                        viewModel.PropertyChanged += (sender, e) => propertyChangedName = e.PropertyName;
 
815
                        
 
816
                        viewModel.ManagePackage();
 
817
                        
 
818
                        Assert.AreEqual("IsAdded", propertyChangedName);
 
819
                }
 
820
                
 
821
                [Test]
 
822
                public void ManagePackage_TwoProjectsSelectedAndUserAcceptsSelectedProjects_NextToLastMessageLoggedMarksEndOfInstallation()
 
823
                {
 
824
                        CreateViewModelWithTwoProjectsSelected("Project A", "Project B");
 
825
                        UserAcceptsProjectSelection();
 
826
                        
 
827
                        viewModel.ManagePackage();
 
828
                        
 
829
                        string expectedMessage = "==============================";
 
830
                        string actualMessage = fakeLogger.NextToLastFormattedMessageLogged;
 
831
                                                
 
832
                        Assert.AreEqual(expectedMessage, actualMessage);
 
833
                }
 
834
                
 
835
                [Test]
 
836
                public void ManagePackage_TwoProjectsSelectedAndUserAcceptsSelectedProjects_LastMessageLoggedIsEmptyLine()
 
837
                {
 
838
                        CreateViewModelWithTwoProjectsSelected("Project A", "Project B");
 
839
                        UserAcceptsProjectSelection();
 
840
                        
 
841
                        viewModel.ManagePackage();
 
842
                        
 
843
                        string expectedMessage = String.Empty;
 
844
                        string actualMessage = fakeLogger.LastFormattedMessageLogged;
 
845
                                                
 
846
                        Assert.AreEqual(expectedMessage, actualMessage);
 
847
                }
 
848
                
 
849
                [Test]
 
850
                public void ManagePackagesForSelectedProjects_OneProjectIsSelected_OneProjectIsInstalled()
 
851
                {
 
852
                        CreateViewModel();
 
853
                        CreateTwoFakeSelectedProjects();
 
854
                        FakeSelectedProject project = fakeSelectedProjects[1];
 
855
                        project.IsSelected = true;
 
856
                        InstallPackageAction expectedAction = project.FakeInstallPackageAction;
 
857
                        
 
858
                        viewModel.ManagePackagesForSelectedProjects(fakeSelectedProjects);
 
859
                        
 
860
                        List<ProcessPackageAction> actions = fakeActionRunner.GetActionsRunInOneCallAsList();
 
861
                        InstallPackageAction action = actions[0] as InstallPackageAction;
 
862
                        
 
863
                        Assert.AreEqual(1, actions.Count);
 
864
                        Assert.AreEqual(fakePackage, action.Package);
 
865
                        Assert.AreEqual(expectedAction, action);
 
866
                }
 
867
                
 
868
                [Test]
 
869
                public void ManagePackagesForSelectedProjects_FirstProjectIsSelectedAndPackageOperationRequiresLicenseAcceptance_UserPromptedToAcceptLicenses()
 
870
                {
 
871
                        CreateViewModel();
 
872
                        CreateTwoFakeSelectedProjects();
 
873
                        FakeSelectedProject selectedProject = fakeSelectedProjects[0];
 
874
                        selectedProject.IsSelected = true;
 
875
                        FakePackageOperation operation = selectedProject.AddFakeInstallPackageOperation();
 
876
                        operation.FakePackage.RequireLicenseAcceptance = true;
 
877
                        fakePackageManagementEvents.OnAcceptLicensesReturnValue = false;
 
878
                        
 
879
                        viewModel.ManagePackagesForSelectedProjects(fakeSelectedProjects);
 
880
                        
 
881
                        var expectedPackages = new FakePackage[] {
 
882
                                operation.FakePackage
 
883
                        };
 
884
                        
 
885
                        List<IPackage> actualPackages = fakePackageManagementEvents.GetPackagesPassedToOnAcceptLicensesAsList();
 
886
                        
 
887
                        CollectionAssert.AreEqual(expectedPackages, actualPackages);
 
888
                }
 
889
                
 
890
                [Test]
 
891
                public void ManagePackagesForSelectedProjects_FirstProjectIsSelectedAndPackageOperationRequiresLicenseAcceptance_PackageInViewModelUsedToGetPackageOperations()
 
892
                {
 
893
                        CreateViewModel();
 
894
                        CreateTwoFakeSelectedProjects();
 
895
                        FakeSelectedProject selectedProject = fakeSelectedProjects[0];
 
896
                        selectedProject.IsSelected = true;
 
897
                        FakePackageOperation operation = selectedProject.AddFakeInstallPackageOperation();
 
898
                        operation.FakePackage.RequireLicenseAcceptance = true;
 
899
                        fakePackageManagementEvents.OnAcceptLicensesReturnValue = false;
 
900
                        
 
901
                        viewModel.ManagePackagesForSelectedProjects(fakeSelectedProjects);
 
902
                        
 
903
                        IPackage actualPackage = selectedProject.FakeProject.PackagePassedToGetInstallPackageOperations;
 
904
                        
 
905
                        Assert.AreEqual(fakePackage, actualPackage);
 
906
                }
 
907
                
 
908
                [Test]
 
909
                public void ManagePackagesForSelectedProjects_FirstProjectIsSelectedAndPackageOperationRequiresLicenseAcceptance_PackageDependenciesAreNotIgnored()
 
910
                {
 
911
                        CreateViewModel();
 
912
                        CreateTwoFakeSelectedProjects();
 
913
                        FakeSelectedProject selectedProject = fakeSelectedProjects[0];
 
914
                        selectedProject.IsSelected = true;
 
915
                        FakePackageOperation operation = selectedProject.AddFakeInstallPackageOperation();
 
916
                        operation.FakePackage.RequireLicenseAcceptance = true;
 
917
                        fakePackageManagementEvents.OnAcceptLicensesReturnValue = false;
 
918
                        
 
919
                        viewModel.ManagePackagesForSelectedProjects(fakeSelectedProjects);
 
920
                        
 
921
                        bool ignored = selectedProject.FakeProject.IgnoreDependenciesPassedToGetInstallPackageOperations;
 
922
                        
 
923
                        Assert.IsFalse(ignored);
 
924
                }
 
925
                
 
926
                [Test]
 
927
                public void ManagePackagesForSelectedProjects_FirstProjectIsSelectedAndTwoPackageOperationsRequireLicenseAcceptance_UserPromptedToAcceptLicensesForTwoPackages()
 
928
                {
 
929
                        CreateViewModel();
 
930
                        CreateTwoFakeSelectedProjects();
 
931
                        FirstFakeSelectedProject.IsSelected = true;
 
932
                        
 
933
                        FakePackageOperation firstOperation = 
 
934
                                AddFakeInstallPackageOperationWithPackageThatRequiresLicenseAcceptance(FirstFakeSelectedProject);
 
935
                        
 
936
                        FakePackageOperation secondOperation = 
 
937
                                AddFakeInstallPackageOperationWithPackageThatRequiresLicenseAcceptance(FirstFakeSelectedProject);
 
938
                        
 
939
                        fakePackageManagementEvents.OnAcceptLicensesReturnValue = false;
 
940
                        
 
941
                        viewModel.ManagePackagesForSelectedProjects(fakeSelectedProjects);
 
942
                        
 
943
                        var expectedPackages = new FakePackage[] {
 
944
                                firstOperation.FakePackage,
 
945
                                secondOperation.FakePackage
 
946
                        };
 
947
                        
 
948
                        List<IPackage> actualPackages = fakePackageManagementEvents.GetPackagesPassedToOnAcceptLicensesAsList();
 
949
                        
 
950
                        CollectionAssert.AreEqual(expectedPackages, actualPackages);
 
951
                }
 
952
                
 
953
                [Test]
 
954
                public void ManagePackagesForSelectedProjects_TwoPackageOperationsRequireLicenseAcceptanceButOneIsUninstallPackageOperation_UserPromptedToAcceptLicenseForInstallPackageOperationOnly()
 
955
                {
 
956
                        CreateViewModel();
 
957
                        CreateTwoFakeSelectedProjects();
 
958
                        FirstFakeSelectedProject.IsSelected = true;
 
959
                        FakePackageOperation installOperation = 
 
960
                                AddFakeInstallPackageOperationWithPackageThatRequiresLicenseAcceptance(FirstFakeSelectedProject);
 
961
                        AddFakeUninstallPackageOperationWithPackageThatRequiresLicenseAcceptance(FirstFakeSelectedProject);
 
962
                                                
 
963
                        fakePackageManagementEvents.OnAcceptLicensesReturnValue = false;
 
964
                        
 
965
                        viewModel.ManagePackagesForSelectedProjects(fakeSelectedProjects);
 
966
                        
 
967
                        var expectedPackages = new FakePackage[] {
 
968
                                installOperation.FakePackage
 
969
                        };
 
970
                        
 
971
                        List<IPackage> actualPackages = fakePackageManagementEvents.GetPackagesPassedToOnAcceptLicensesAsList();
 
972
                        
 
973
                        CollectionAssert.AreEqual(expectedPackages, actualPackages);
 
974
                }
 
975
                
 
976
                [Test]
 
977
                public void ManagePackagesForSelectedProjects_OneInstallPackageOperationsDoesNotRequireLicenseAcceptance_UserIsNotPromptedToAcceptLicense()
 
978
                {
 
979
                        CreateViewModel();
 
980
                        CreateTwoFakeSelectedProjects();
 
981
                        FirstFakeSelectedProject.IsSelected = true;
 
982
                        AddFakeInstallPackageOperationWithPackageThatDoesNotRequireLicenseAcceptance(FirstFakeSelectedProject);
 
983
                        
 
984
                        fakePackageManagementEvents.OnAcceptLicensesReturnValue = false;
 
985
                        
 
986
                        viewModel.ManagePackagesForSelectedProjects(fakeSelectedProjects);
 
987
                        
 
988
                        Assert.IsFalse(fakePackageManagementEvents.IsOnAcceptLicensesCalled);
 
989
                }
 
990
                
 
991
                [Test]
 
992
                public void ManagePackagesForSelectedProjects_OneInstallPackageOperationsRequiresLicenseAcceptanceButIsInstalledInSolutionAlready_UserIsNotPromptedToAcceptLicense()
 
993
                {
 
994
                        CreateViewModel();
 
995
                        CreateTwoFakeSelectedProjects();
 
996
                        FirstFakeSelectedProject.IsSelected = true;
 
997
                        
 
998
                        FakePackageOperation installOperation = 
 
999
                                AddFakeInstallPackageOperationWithPackageThatRequiresLicenseAcceptance(FirstFakeSelectedProject);
 
1000
                        
 
1001
                        fakeSolution.FakeInstalledPackages.Add(installOperation.FakePackage);
 
1002
                        
 
1003
                        fakePackageManagementEvents.OnAcceptLicensesReturnValue = false;
 
1004
                        
 
1005
                        viewModel.ManagePackagesForSelectedProjects(fakeSelectedProjects);
 
1006
                        
 
1007
                        Assert.IsFalse(fakePackageManagementEvents.IsOnAcceptLicensesCalled);
 
1008
                }
 
1009
                
 
1010
                [Test]
 
1011
                public void ManagePackagesForSelectedProjects_FirstProjectIsSelectedAndUserDoesNotAcceptPackageLicense_PackageIsNotInstalled()
 
1012
                {
 
1013
                        CreateViewModel();
 
1014
                        CreateTwoFakeSelectedProjects();
 
1015
                        FirstFakeSelectedProject.IsSelected = true;
 
1016
                        
 
1017
                        AddFakeInstallPackageOperationWithPackageThatRequiresLicenseAcceptance(FirstFakeSelectedProject);
 
1018
                        
 
1019
                        fakePackageManagementEvents.OnAcceptLicensesReturnValue = false;
 
1020
                        
 
1021
                        viewModel.ManagePackagesForSelectedProjects(fakeSelectedProjects);
 
1022
                        
 
1023
                        Assert.IsFalse(fakeActionRunner.IsRunCalled);
 
1024
                }
 
1025
                
 
1026
                [Test]
 
1027
                public void ManagePackagesForSelectedProjects_TwoProjectsButNeitherIsSelected_NoPackageActionsAreRun()
 
1028
                {
 
1029
                        CreateViewModel();
 
1030
                        CreateTwoFakeSelectedProjects();
 
1031
                        
 
1032
                        viewModel.ManagePackagesForSelectedProjects(fakeSelectedProjects);
 
1033
                        
 
1034
                        Assert.IsFalse(fakeActionRunner.IsRunCalled);
 
1035
                }
 
1036
                
 
1037
                [Test]
 
1038
                public void ManagePackagesForSelectedProjects_FirstProjectIsSelectedAndUserAcceptsPackageLicense_PackageIsInstalled()
 
1039
                {
 
1040
                        CreateViewModel();
 
1041
                        CreateTwoFakeSelectedProjects();
 
1042
                        FirstFakeSelectedProject.IsSelected = true;
 
1043
                        
 
1044
                        AddFakeInstallPackageOperationWithPackageThatRequiresLicenseAcceptance(FirstFakeSelectedProject);
 
1045
                        
 
1046
                        fakePackageManagementEvents.OnAcceptLicensesReturnValue = true;
 
1047
                                
 
1048
                        viewModel.ManagePackagesForSelectedProjects(fakeSelectedProjects);
 
1049
                        
 
1050
                        InstallPackageAction expectedAction = FirstFakeSelectedProject.FakeInstallPackageAction;
 
1051
                        List<ProcessPackageAction> actions = fakeActionRunner.GetActionsRunInOneCallAsList();
 
1052
                        InstallPackageAction action = actions[0] as InstallPackageAction;
 
1053
                        
 
1054
                        Assert.AreEqual(1, actions.Count);
 
1055
                        Assert.AreEqual(fakePackage, action.Package);
 
1056
                        Assert.AreEqual(expectedAction, action);
 
1057
                }
 
1058
                
 
1059
                [Test]
 
1060
                public void ManagePackagesForSelectedProjects_TwoProjectsAreSelectedAndUserAcceptsPackageLicense_UserIsNotPromptedTwiceToAcceptLicenses()
 
1061
                {
 
1062
                        CreateViewModel();
 
1063
                        CreateTwoFakeSelectedProjects();
 
1064
                        FirstFakeSelectedProject.IsSelected = true;
 
1065
                        AddFakeInstallPackageOperationWithPackageThatRequiresLicenseAcceptance(FirstFakeSelectedProject);
 
1066
                        
 
1067
                        SecondFakeSelectedProject.IsSelected = true;
 
1068
                        AddFakeInstallPackageOperationWithPackageThatRequiresLicenseAcceptance(SecondFakeSelectedProject);
 
1069
                        
 
1070
                        fakePackageManagementEvents.OnAcceptLicensesReturnValue = true;
 
1071
                                
 
1072
                        viewModel.ManagePackagesForSelectedProjects(fakeSelectedProjects);
 
1073
                        
 
1074
                        List<IEnumerable<IPackage>> packagesPassedToAcceptLicenses =
 
1075
                                fakePackageManagementEvents.PackagesPassedToAcceptLicenses;
 
1076
                        Assert.AreEqual(1, packagesPassedToAcceptLicenses.Count);
 
1077
                }
 
1078
                
 
1079
                [Test]
 
1080
                public void ManagePackagesForSelectedProjects_FirstProjectSelectedAndExceptionThrownWhenResolvingPackageOperations_ExceptionReported()
 
1081
                {
 
1082
                        CreateViewModel();
 
1083
                        CreateTwoFakeSelectedProjects();
 
1084
                        FirstFakeSelectedProject.IsSelected = true;
 
1085
                        var exceptionThrowingProject = new ExceptionThrowingPackageManagementProject();
 
1086
                        FirstFakeSelectedProject.FakeProject = exceptionThrowingProject;
 
1087
                        AddFakeInstallPackageOperationWithPackageThatDoesNotRequireLicenseAcceptance(FirstFakeSelectedProject);
 
1088
                        
 
1089
                        var exception = new Exception("Test");
 
1090
                        exceptionThrowingProject.ExceptionToThrowWhenGetInstallPackageOperationsCalled = exception;
 
1091
                        viewModel.ManagePackagesForSelectedProjects(fakeSelectedProjects);
 
1092
                        
 
1093
                        Assert.AreEqual(exception, fakePackageManagementEvents.ExceptionPassedToOnPackageOperationError);
 
1094
                }
 
1095
                
 
1096
                [Test]
 
1097
                public void ManagePackagesForSelectedProjects_FirstProjectSelectedAndExceptionThrownWhenCreatingInstallAction_ExceptionLogged()
 
1098
                {
 
1099
                        CreateViewModel();
 
1100
                        CreateTwoFakeSelectedProjects();
 
1101
                        FirstFakeSelectedProject.IsSelected = true;
 
1102
                        var exceptionThrowingProject = new ExceptionThrowingPackageManagementProject();
 
1103
                        FirstFakeSelectedProject.FakeProject = exceptionThrowingProject;
 
1104
                        AddFakeInstallPackageOperationWithPackageThatDoesNotRequireLicenseAcceptance(FirstFakeSelectedProject);
 
1105
                        
 
1106
                        var exception = new Exception("Exception error message");
 
1107
                        exceptionThrowingProject.ExceptionToThrowWhenCreateInstallPackageActionCalled = exception;
 
1108
                        viewModel.ManagePackagesForSelectedProjects(fakeSelectedProjects);
 
1109
                        
 
1110
                        bool contains = fakeLogger.FormattedMessagesLoggedContainsText("Exception error message");
 
1111
                        
 
1112
                        Assert.IsTrue(contains);
 
1113
                }
 
1114
                
 
1115
                [Test]
 
1116
                public void ManagePackagesForSelectedProjects_TwoProjectsOneSelectedAndPackageRequiresLicenseAcceptance_PackageViewModelLoggerUsedWhenResolvingPackageOperations()
 
1117
                {
 
1118
                        CreateViewModel();
 
1119
                        CreateTwoFakeSelectedProjects();
 
1120
                        FirstFakeSelectedProject.IsSelected = true;
 
1121
                        AddFakeInstallPackageOperationWithPackageThatRequiresLicenseAcceptance(FirstFakeSelectedProject);
 
1122
                        fakePackageManagementEvents.OnAcceptLicensesReturnValue = false;
 
1123
                        
 
1124
                        viewModel.ManagePackagesForSelectedProjects(fakeSelectedProjects);
 
1125
                        
 
1126
                        ILogger expectedLogger = viewModel.OperationLoggerCreated;
 
1127
                        ILogger actualLogger = FirstFakeSelectedProject.Project.Logger;
 
1128
                        Assert.AreEqual(expectedLogger, actualLogger);
 
1129
                }
 
1130
                
 
1131
                [Test]
 
1132
                public void ManagePackage_UserAcceptsProjectSelection_ManagingPackageMessageIsFirstMessageLogged()
 
1133
                {
 
1134
                        CreateViewModelWithTwoProjectsSelected("Project A", "Project B");
 
1135
                        UserAcceptsProjectSelection();
 
1136
                        fakePackage.Id = "Test.Package";
 
1137
                        fakePackage.Version = new Version(1, 2, 0, 55);
 
1138
                        viewModel.ManagePackage();
 
1139
                        
 
1140
                        string expectedMessage = "------- Managing...Test.Package 1.2.0.55 -------";
 
1141
                        string actualMessage = fakeLogger.FirstFormattedMessageLogged;
 
1142
                        
 
1143
                        Assert.AreEqual(expectedMessage, actualMessage);
 
1144
                }
 
1145
                
 
1146
                [Test]
 
1147
                public void ManagePackagesForSelectedProjects_TwoProjectsNoneSelectedAndFirstPackageHasLicense_UserIsNotPromptedToAcceptLicense()
 
1148
                {
 
1149
                        CreateViewModel();
 
1150
                        CreateTwoFakeSelectedProjects();
 
1151
                        AddFakeInstallPackageOperationWithPackageThatRequiresLicenseAcceptance(FirstFakeSelectedProject);
 
1152
                                
 
1153
                        viewModel.ManagePackagesForSelectedProjects(fakeSelectedProjects);
 
1154
                        
 
1155
                        Assert.IsFalse(fakePackageManagementEvents.IsOnAcceptLicensesCalled);
 
1156
                }
 
1157
                
 
1158
                [Test]
 
1159
                public void ManagePackage_TwoProjectsAndFirstSelectedInDialog_PackageIsInstalled()
 
1160
                {
 
1161
                        CreateViewModelWithTwoProjectsSelected("Project A", "Project B");
 
1162
                        UserAcceptsProjectSelection();
 
1163
                        fakePackageManagementEvents.ProjectsToSelect.Add("Project A");
 
1164
                        viewModel.ManagePackage();
 
1165
                        
 
1166
                        List<ProcessPackageAction> actions = fakeActionRunner.GetActionsRunInOneCallAsList();
 
1167
                        ProcessPackageAction action = actions[0];
 
1168
                        FakePackageManagementProject expectedProject = fakeSolution.FakeProjectsToReturnFromGetProject["Project A"];
 
1169
                        
 
1170
                        Assert.AreEqual(expectedProject, action.Project);
 
1171
                }
 
1172
                
 
1173
                [Test]
 
1174
                public void ManagePackage_TwoProjectsAndSecondSelectedInDialog_ProjectHasLoggerSet()
 
1175
                {
 
1176
                        CreateViewModelWithTwoProjectsSelected("Project A", "Project B");
 
1177
                        UserAcceptsProjectSelection();
 
1178
                        fakePackageManagementEvents.ProjectsToSelect.Add("Project B");
 
1179
                        viewModel.ManagePackage();
 
1180
                        
 
1181
                        FakePackageManagementProject project = fakeSolution.FakeProjectsToReturnFromGetProject["Project B"];
 
1182
                        ILogger expectedLogger = viewModel.OperationLoggerCreated;
 
1183
                        ILogger actualLogger = project.Logger;
 
1184
                        Assert.AreEqual(expectedLogger, actualLogger);
 
1185
                }
 
1186
        }
 
1187
}