← Back to branch summary

~halega/+junk/sharpdevelop

« back to all changes in this revision

Viewing changes to src/AddIns/Misc/PackageManagement/Test/Src/PackageManagementSolutionTests.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/PackageManagementSolutionTests.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
 
 
8
using ICSharpCode.PackageManagement;
 
9
using ICSharpCode.PackageManagement.Design;
 
10
using ICSharpCode.SharpDevelop.Project;
 
11
using NuGet;
 
12
using NUnit.Framework;
 
13
using PackageManagement.Tests.Helpers;
 
14
 
 
15
namespace PackageManagement.Tests
 
16
{
 
17
        [TestFixture]
 
18
        public class PackageManagementSolutionTests
 
19
        {
 
20
                PackageManagementSolution solution;
 
21
                FakeRegisteredPackageRepositories fakeRegisteredPackageRepositories;
 
22
                OneRegisteredPackageSourceHelper packageSourcesHelper;
 
23
                FakePackageManagementProjectService fakeProjectService;
 
24
                FakePackageManagementProjectFactory fakeProjectFactory;
 
25
                TestableProject testProject;
 
26
                FakeSolutionPackageRepositoryFactory fakeSolutionPackageRepositoryFactory;
 
27
                FakeSolutionPackageRepository fakeSolutionPackageRepository;
 
28
                
 
29
                void CreatePackageSources()
 
30
                {
 
31
                        packageSourcesHelper = new OneRegisteredPackageSourceHelper();
 
32
                }
 
33
                
 
34
                void CreateSolution()
 
35
                {
 
36
                        CreatePackageSources();
 
37
                        CreateSolution(packageSourcesHelper.Options);
 
38
                }
 
39
                
 
40
                void CreateSolution(PackageManagementOptions options)
 
41
                {
 
42
                        testProject = ProjectHelper.CreateTestProject();
 
43
                        fakeRegisteredPackageRepositories = new FakeRegisteredPackageRepositories();
 
44
                        fakeProjectFactory = new FakePackageManagementProjectFactory();
 
45
                        fakeProjectService = new FakePackageManagementProjectService();
 
46
                        
 
47
                        fakeProjectService.CurrentProject = testProject;
 
48
                        fakeProjectService.OpenSolution = testProject.ParentSolution;
 
49
                        
 
50
                        fakeSolutionPackageRepositoryFactory = new FakeSolutionPackageRepositoryFactory();
 
51
                        fakeSolutionPackageRepository = fakeSolutionPackageRepositoryFactory.FakeSolutionPackageRepository;
 
52
                        
 
53
                        solution =
 
54
                                new PackageManagementSolution(
 
55
                                        fakeRegisteredPackageRepositories,
 
56
                                        fakeProjectService,
 
57
                                        fakeProjectFactory,
 
58
                                        fakeSolutionPackageRepositoryFactory);
 
59
                }
 
60
                
 
61
                TestableProject AddProjectToOpenProjects(string projectName)
 
62
                {
 
63
                        TestableProject project = ProjectHelper.CreateTestProject(projectName);
 
64
                        fakeProjectService.FakeOpenProjects.Add(project);
 
65
                        return project;
 
66
                }
 
67
                
 
68
                FakePackage AddPackageInReverseDependencyOrderToSolution(string packageId)
 
69
                {
 
70
                        var package = new FakePackage(packageId);
 
71
                        fakeSolutionPackageRepository.FakePackagesByReverseDependencyOrder.Add(package);
 
72
                        return package;
 
73
                }
 
74
                
 
75
                [Test]
 
76
                public void GetActiveProject_ProjectIsSelected_CreatesProjectUsingCurrentProjectSelectedInSharpDevelop()
 
77
                {
 
78
                        CreateSolution();
 
79
                        
 
80
                        IPackageManagementProject activeProject = solution.GetActiveProject();
 
81
                        IProject actualProject = fakeProjectFactory.FirstProjectPassedToCreateProject;
 
82
                        
 
83
                        Assert.AreEqual(testProject, actualProject);
 
84
                }
 
85
                
 
86
                [Test]
 
87
                public void GetActiveProject_ProjectIsSelected_CreatesProjectUsingCurrentActiveRepository()
 
88
                {
 
89
                        CreateSolution();
 
90
                        
 
91
                        IPackageManagementProject activeProject = solution.GetActiveProject();
 
92
                        
 
93
                        IPackageRepository repository = fakeProjectFactory.FirstRepositoryPassedToCreateProject;
 
94
                        IPackageRepository expectedRepository = fakeRegisteredPackageRepositories.ActiveRepository;
 
95
                        
 
96
                        Assert.AreEqual(expectedRepository, repository);
 
97
                }
 
98
                
 
99
                [Test]
 
100
                public void GetActiveProject_ProjectIsSelected_ReturnsProjectCreatedByFactory()
 
101
                {
 
102
                        CreateSolution();
 
103
                        
 
104
                        IPackageManagementProject activeProject = solution.GetActiveProject();
 
105
                        IPackageManagementProject expectedProject = fakeProjectFactory.FirstFakeProjectCreated;
 
106
                        
 
107
                        Assert.AreEqual(expectedProject, activeProject);
 
108
                }
 
109
                
 
110
                [Test]
 
111
                public void GetActiveProject_RepositoryPassed_CreatesProjectUsingRepository()
 
112
                {
 
113
                        CreateSolution();
 
114
                        var expectedRepository = new FakePackageRepository();
 
115
                        solution.GetActiveProject(expectedRepository);
 
116
                        
 
117
                        IPackageRepository repository = fakeProjectFactory.FirstRepositoryPassedToCreateProject;
 
118
                        
 
119
                        Assert.AreEqual(expectedRepository, repository);
 
120
                }
 
121
                
 
122
                [Test]
 
123
                public void GetActiveProject_RepositoryPassed_CreatesProjectUsingCurrentActiveProject()
 
124
                {
 
125
                        CreateSolution();
 
126
                        var expectedRepository = new FakePackageRepository();
 
127
                        TestableProject expectedProject = ProjectHelper.CreateTestProject();
 
128
                        fakeProjectService.CurrentProject = expectedProject;
 
129
                        
 
130
                        solution.GetActiveProject(expectedRepository);
 
131
                        
 
132
                        MSBuildBasedProject project = fakeProjectFactory.FirstProjectPassedToCreateProject;
 
133
                        
 
134
                        Assert.AreEqual(expectedProject, project);
 
135
                }
 
136
                
 
137
                [Test]
 
138
                public void GetActiveProject_RepositoryPassed_ReturnsProjectFromProjectFactory()
 
139
                {
 
140
                        CreateSolution();
 
141
                        var expectedRepository = new FakePackageRepository();
 
142
                        IPackageManagementProject project = solution.GetActiveProject(expectedRepository);
 
143
                        
 
144
                        FakePackageManagementProject expectedProject = fakeProjectFactory.FirstFakeProjectCreated;
 
145
                        
 
146
                        Assert.AreEqual(expectedProject, project);
 
147
                }
 
148
                
 
149
                [Test]
 
150
                public void GetProject_PackagesSourceAndProjectNamePassed_CreatesProjectUsingFoundProjectMatchingName()
 
151
                {
 
152
                        CreateSolution();
 
153
                        TestableProject expectedProject = AddProjectToOpenProjects("Test");
 
154
                        var source = new PackageSource("http://sharpdevelop.net");
 
155
                        
 
156
                        solution.GetProject(source, "Test");
 
157
                        
 
158
                        MSBuildBasedProject project = fakeProjectFactory.FirstProjectPassedToCreateProject;
 
159
                        
 
160
                        Assert.AreEqual(expectedProject, project);
 
161
                }
 
162
                
 
163
                [Test]
 
164
                public void GetProject_PackagesSourceAndProjectNameWithDifferentCasePassed_CreatesProjectUsingFoundProjectMatchingName()
 
165
                {
 
166
                        CreateSolution();
 
167
                        TestableProject expectedProject = AddProjectToOpenProjects("Test");
 
168
                        var source = new PackageSource("http://sharpdevelop.net");
 
169
                        
 
170
                        solution.GetProject(source, "TEST");
 
171
                        
 
172
                        MSBuildBasedProject project = fakeProjectFactory.FirstProjectPassedToCreateProject;
 
173
                        
 
174
                        Assert.AreEqual(expectedProject, project);
 
175
                }
 
176
                
 
177
                [Test]
 
178
                public void GetProject_PackagesSourceAndProjectPassed_ReturnsProjectFromProjectFactory()
 
179
                {
 
180
                        CreateSolution();
 
181
                        AddProjectToOpenProjects("Test");
 
182
                        var source = new PackageSource("http://sharpdevelop.net");
 
183
                        IPackageManagementProject project = solution.GetProject(source, "Test");
 
184
                        
 
185
                        FakePackageManagementProject expectedProject = fakeProjectFactory.FirstFakeProjectCreated;
 
186
                        
 
187
                        Assert.AreEqual(expectedProject, project);
 
188
                }
 
189
                
 
190
                [Test]
 
191
                public void GetProject_PackagesSourceAndProjectPassed_PackageSourceUsedToCreateRepository()
 
192
                {
 
193
                        CreateSolution();
 
194
                        AddProjectToOpenProjects("Test");
 
195
                        var expectedSource = new PackageSource("http://sharpdevelop.net");
 
196
                        IPackageManagementProject project = solution.GetProject(expectedSource, "Test");
 
197
                        
 
198
                        PackageSource actualSource = fakeRegisteredPackageRepositories.PackageSourcePassedToCreateRepository;
 
199
                        
 
200
                        Assert.AreEqual(expectedSource, actualSource);
 
201
                }
 
202
                
 
203
                [Test]
 
204
                public void GetProject_PackagesRepositoryAndProjectNamePassed_CreatesProjectUsingFoundProjectMatchingName()
 
205
                {
 
206
                        CreateSolution();
 
207
                        TestableProject expectedProject = AddProjectToOpenProjects("Test");
 
208
                        var repository = new FakePackageRepository();
 
209
                        
 
210
                        solution.GetProject(repository, "Test");
 
211
                        
 
212
                        MSBuildBasedProject project = fakeProjectFactory.FirstProjectPassedToCreateProject;
 
213
                        
 
214
                        Assert.AreEqual(expectedProject, project);
 
215
                }
 
216
                
 
217
                [Test]
 
218
                public void GetProject_PackagesRepositoryAndProjectPassed_CreatesProjectUsingProjectPassed()
 
219
                {
 
220
                        CreateSolution();
 
221
                        TestableProject expectedProject = AddProjectToOpenProjects("Test");
 
222
                        var repository = new FakePackageRepository();
 
223
                        
 
224
                        solution.GetProject(repository, expectedProject);
 
225
                        
 
226
                        MSBuildBasedProject project = fakeProjectFactory.FirstProjectPassedToCreateProject;
 
227
                        
 
228
                        Assert.AreEqual(expectedProject, project);
 
229
                }
 
230
                
 
231
                [Test]
 
232
                public void GetProject_PackagesRepositoryAndProjectPassed_ReturnsProjectCreatedFromProjectFactory()
 
233
                {
 
234
                        CreateSolution();
 
235
                        TestableProject msbuildProject = AddProjectToOpenProjects("Test");
 
236
                        var repository = new FakePackageRepository();
 
237
                        
 
238
                        IPackageManagementProject project = solution.GetProject(repository, msbuildProject);
 
239
                        
 
240
                        FakePackageManagementProject expectedProject = fakeProjectFactory.FirstFakeProjectCreated;
 
241
                        
 
242
                        Assert.AreEqual(expectedProject, project);
 
243
                }
 
244
                
 
245
                [Test]
 
246
                public void GetProject_PackagesRepositoryAndProjectPassed_CreatesProjectUsingRepository()
 
247
                {
 
248
                        CreateSolution();
 
249
                        TestableProject expectedProject = AddProjectToOpenProjects("Test");
 
250
                        var expectedRepository = new FakePackageRepository();
 
251
                        
 
252
                        solution.GetProject(expectedRepository, expectedProject);
 
253
                        
 
254
                        IPackageRepository repository = fakeProjectFactory.FirstRepositoryPassedToCreateProject;
 
255
                        
 
256
                        Assert.AreEqual(expectedRepository, repository);
 
257
                }
 
258
                
 
259
                [Test]
 
260
                public void GetProject_RepositoryAndProjectNameWithDifferentCasePassed_CreatesProjectUsingFoundProjectMatchingName()
 
261
                {
 
262
                        CreateSolution();
 
263
                        TestableProject expectedProject = AddProjectToOpenProjects("Test");
 
264
                        var repository = new FakePackageRepository();
 
265
                        
 
266
                        solution.GetProject(repository, "TEST");
 
267
                        
 
268
                        MSBuildBasedProject project = fakeProjectFactory.FirstProjectPassedToCreateProject;
 
269
                        
 
270
                        Assert.AreEqual(expectedProject, project);
 
271
                }
 
272
                
 
273
                [Test]
 
274
                public void GetProject_RepositoryAndProjectNamePassed_ReturnsProject()
 
275
                {
 
276
                        CreateSolution();
 
277
                        AddProjectToOpenProjects("Test");
 
278
                        var repository = new FakePackageRepository();
 
279
                        
 
280
                        IPackageManagementProject project = solution.GetProject(repository, "Test");
 
281
                        
 
282
                        FakePackageManagementProject expectedProject = fakeProjectFactory.FirstFakeProjectCreated;
 
283
                        
 
284
                        Assert.AreEqual(expectedProject, project);
 
285
                }
 
286
                
 
287
                [Test]
 
288
                public void GetProject_RepositoryAndProjectNamePassed_RepositoryUsedToCreateProject()
 
289
                {
 
290
                        CreateSolution();
 
291
                        AddProjectToOpenProjects("Test");
 
292
                        var expectedRepository = new FakePackageRepository();
 
293
                        
 
294
                        solution.GetProject(expectedRepository, "Test");
 
295
                        
 
296
                        IPackageRepository actualRepository = fakeProjectFactory.FirstRepositoryPassedToCreateProject;
 
297
                        
 
298
                        Assert.AreEqual(expectedRepository, actualRepository);
 
299
                }
 
300
                
 
301
                [Test]
 
302
                public void GetMSBuildProjects_TwoProjectsInOpenSolution_ReturnsTwoProjects()
 
303
                {
 
304
                        CreateSolution();
 
305
                        AddProjectToOpenProjects("A");
 
306
                        AddProjectToOpenProjects("B");
 
307
                        
 
308
                        IEnumerable<IProject> projects = solution.GetMSBuildProjects();
 
309
                        List<IProject> expectedProjects = fakeProjectService.FakeOpenProjects;
 
310
                        
 
311
                        CollectionAssert.AreEqual(expectedProjects, projects);
 
312
                }
 
313
                
 
314
                [Test]
 
315
                public void IsOpen_NoSolutionOpen_ReturnsFalse()
 
316
                {
 
317
                        CreateSolution();
 
318
                        fakeProjectService.OpenSolution = null;
 
319
                        
 
320
                        bool open = solution.IsOpen;
 
321
                        
 
322
                        Assert.IsFalse(open);
 
323
                }
 
324
                
 
325
                [Test]
 
326
                public void IsOpen_SolutionIsOpen_ReturnsTrue()
 
327
                {
 
328
                        CreateSolution();
 
329
                        fakeProjectService.OpenSolution = new Solution(new MockProjectChangeWatcher());
 
330
                        
 
331
                        bool open = solution.IsOpen;
 
332
                        
 
333
                        Assert.IsTrue(open);
 
334
                }
 
335
                
 
336
                [Test]
 
337
                public void GetActiveMSBuildProject_CurrentProjectIsSetInProjectService_ReturnsProjectCurrentlySelected()
 
338
                {
 
339
                        CreateSolution();
 
340
                        fakeProjectService.CurrentProject = testProject;
 
341
                        
 
342
                        IProject activeProject = solution.GetActiveMSBuildProject();
 
343
                        
 
344
                        Assert.AreEqual(testProject, activeProject);
 
345
                }
 
346
                
 
347
                [Test]
 
348
                public void HasMultipleProjects_OneProjectInSolution_ReturnsFalse()
 
349
                {
 
350
                        CreateSolution();
 
351
                        TestableProject project = ProjectHelper.CreateTestProject();
 
352
                        fakeProjectService.AddFakeProject(project);
 
353
                        
 
354
                        bool hasMultipleProjects = solution.HasMultipleProjects();
 
355
                        
 
356
                        Assert.IsFalse(hasMultipleProjects);
 
357
                }
 
358
                
 
359
                [Test]
 
360
                public void HasMultipleProjects_TwoProjectsInSolution_ReturnsTrue()
 
361
                {
 
362
                        CreateSolution();
 
363
                        TestableProject project1 = ProjectHelper.CreateTestProject();
 
364
                        fakeProjectService.AddFakeProject(project1);
 
365
                        TestableProject project2 = ProjectHelper.CreateTestProject();
 
366
                        fakeProjectService.AddFakeProject(project2);
 
367
                        
 
368
                        bool hasMultipleProjects = solution.HasMultipleProjects();
 
369
                        
 
370
                        Assert.IsTrue(hasMultipleProjects);
 
371
                }
 
372
                
 
373
                [Test]
 
374
                public void FileName_SolutionHasFileName_ReturnsSolutionFileName()
 
375
                {
 
376
                        CreateSolution();
 
377
                        var solution = new Solution(new MockProjectChangeWatcher());
 
378
                        string expectedFileName = @"d:\projects\myproject\Project.sln";
 
379
                        solution.FileName = expectedFileName;
 
380
                        fakeProjectService.OpenSolution = solution;
 
381
                        
 
382
                        string fileName = solution.FileName;
 
383
                        
 
384
                        Assert.AreEqual(expectedFileName, fileName);
 
385
                }
 
386
                
 
387
                [Test]
 
388
                public void IsInstalled_PackageIsInstalledInSolutionLocalRepository_ReturnsTrue()
 
389
                {
 
390
                        CreateSolution();
 
391
                        FakePackage package = FakePackage.CreatePackageWithVersion("Test", "1.3.4.5");
 
392
                        fakeSolutionPackageRepository.FakeSharedRepository.FakePackages.Add(package);
 
393
                        
 
394
                        bool installed = solution.IsPackageInstalled(package);
 
395
                        
 
396
                        Assert.IsTrue(installed);
 
397
                }
 
398
                
 
399
                [Test]
 
400
                public void IsInstalled_PackageIsNotInstalledInSolutionLocalRepository_ReturnsFalse()
 
401
                {
 
402
                        CreateSolution();
 
403
                        FakePackage package = FakePackage.CreatePackageWithVersion("Test", "1.3.4.5");
 
404
                        
 
405
                        bool installed = solution.IsPackageInstalled(package);
 
406
                        
 
407
                        Assert.IsFalse(installed);
 
408
                }
 
409
                
 
410
                [Test]
 
411
                public void IsInstalled_PackageIsNotInstalledInSolutionLocalRepository_ActivSolutionUsedToCreateSolutionPackageRepository()
 
412
                {
 
413
                        CreateSolution();
 
414
                        FakePackage package = FakePackage.CreatePackageWithVersion("Test", "1.3.4.5");
 
415
                        
 
416
                        solution.IsPackageInstalled(package);
 
417
                        
 
418
                        Solution expectedSolution = fakeProjectService.OpenSolution;
 
419
                        Solution solutionUsedToCreateSolutionPackageRepository = 
 
420
                                fakeSolutionPackageRepositoryFactory.SolutionPassedToCreateSolutionPackageRepository;
 
421
                        
 
422
                        Assert.AreEqual(expectedSolution, solutionUsedToCreateSolutionPackageRepository);
 
423
                }
 
424
                
 
425
                [Test]
 
426
                public void GetActiveProject_SolutionOpenButNoProjectSelected_ReturnsNull()
 
427
                {
 
428
                        CreateSolution();
 
429
                        fakeProjectService.CurrentProject = null;
 
430
                        
 
431
                        IPackageManagementProject activeProject = solution.GetActiveProject();
 
432
                        
 
433
                        Assert.IsNull(activeProject);
 
434
                }
 
435
                
 
436
                [Test]
 
437
                public void GetActiveProject_RepositoryPassedWhenSolutionOpenButNoProjectSelected_ReturnsNull()
 
438
                {
 
439
                        CreateSolution();
 
440
                        fakeProjectService.CurrentProject = null;
 
441
                        
 
442
                        var repository = new FakePackageRepository();
 
443
                        IPackageManagementProject activeProject = solution.GetActiveProject(repository);
 
444
                        
 
445
                        Assert.IsNull(activeProject);
 
446
                }
 
447
                
 
448
                [Test]
 
449
                public void GetPackages_OnePackageInSolutionRepository_ReturnsOnePackage()
 
450
                {
 
451
                        CreateSolution();
 
452
                        fakeProjectService.CurrentProject = null;
 
453
                        FakePackage package = FakePackage.CreatePackageWithVersion("Test", "1.3.4.5");
 
454
                        fakeSolutionPackageRepository.FakeSharedRepository.FakePackages.Add(package);
 
455
                        
 
456
                        IQueryable<IPackage> packages = solution.GetPackages();
 
457
                        
 
458
                        var expectedPackages = new FakePackage[] {
 
459
                                package
 
460
                        };
 
461
                        
 
462
                        PackageCollectionAssert.AreEqual(expectedPackages, packages);
 
463
                }
 
464
                
 
465
                [Test]
 
466
                public void GetPackagesInReverseDependencyOrder_TwoPackages_ReturnsPackagesFromSolutionLocalRepositoryInCorrectOrder()
 
467
                {
 
468
                        CreateSolution();
 
469
                        FakePackage packageA = AddPackageInReverseDependencyOrderToSolution("A");
 
470
                        FakePackage packageB = AddPackageInReverseDependencyOrderToSolution("A");
 
471
                        
 
472
                        packageB.DependenciesList.Add(new PackageDependency("A"));
 
473
                        
 
474
                        var expectedPackages = new FakePackage[] {
 
475
                                packageB,
 
476
                                packageA
 
477
                        };
 
478
                        
 
479
                        IEnumerable<IPackage> packages = solution.GetPackagesInReverseDependencyOrder();
 
480
                        
 
481
                        PackageCollectionAssert.AreEqual(expectedPackages, packages);
 
482
                }
 
483
                
 
484
                [Test]
 
485
                public void GetProjects_SolutionHasOneProject_ReturnsOneProject()
 
486
                {
 
487
                        CreateSolution();
 
488
                        AddProjectToOpenProjects("MyProject");
 
489
                        var repository = new FakePackageRepository();
 
490
                        List<IPackageManagementProject> projects = solution.GetProjects(repository).ToList();
 
491
                        
 
492
                        Assert.AreEqual(1, projects.Count);
 
493
                }
 
494
                
 
495
                [Test]
 
496
                public void GetProjects_SolutionHasOneProject_RepositoryUsedToCreateProject()
 
497
                {
 
498
                        CreateSolution();
 
499
                        AddProjectToOpenProjects("MyProject");
 
500
                        var expectedRepository = new FakePackageRepository();
 
501
                        List<IPackageManagementProject> projects = solution.GetProjects(expectedRepository).ToList();
 
502
                        
 
503
                        IPackageRepository repository = fakeProjectFactory.FirstRepositoryPassedToCreateProject;
 
504
                        
 
505
                        Assert.AreEqual(expectedRepository, repository);
 
506
                }
 
507
                
 
508
                [Test]
 
509
                public void GetProjects_SolutionHasOneProject_MSBuildProjectUsedToCreateProject()
 
510
                {
 
511
                        CreateSolution();
 
512
                        TestableProject expectedProject = AddProjectToOpenProjects("MyProject");
 
513
                        var repository = new FakePackageRepository();
 
514
                        List<IPackageManagementProject> projects = solution.GetProjects(repository).ToList();
 
515
                        
 
516
                        MSBuildBasedProject project = fakeProjectFactory.FirstProjectPassedToCreateProject;
 
517
                        
 
518
                        Assert.AreEqual(expectedProject, project);
 
519
                }
 
520
                
 
521
                [Test]
 
522
                public void GetProjects_SolutionHasNoProjects_ReturnsNoProjects()
 
523
                {
 
524
                        CreateSolution();
 
525
                        var repository = new FakePackageRepository();
 
526
                        List<IPackageManagementProject> projects = solution.GetProjects(repository).ToList();
 
527
                        
 
528
                        Assert.AreEqual(0, projects.Count);
 
529
                }
 
530
                
 
531
                [Test]
 
532
                public void GetProjects_SolutionHasTwoProjects_ReturnsTwoProjects()
 
533
                {
 
534
                        CreateSolution();
 
535
                        AddProjectToOpenProjects("One");
 
536
                        AddProjectToOpenProjects("Two");
 
537
                        var repository = new FakePackageRepository();
 
538
                        List<IPackageManagementProject> projects = solution.GetProjects(repository).ToList();
 
539
                        
 
540
                        Assert.AreEqual(2, projects.Count);
 
541
                }
 
542
        }
 
543
}