← Back to branch summary

~halega/+junk/sharpdevelop

« back to all changes in this revision

Viewing changes to src/AddIns/Misc/PackageManagement/Test/Src/RecentPackageRepositoryTests.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/RecentPackageRepositoryTests.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.Core;
 
8
using ICSharpCode.PackageManagement;
 
9
using ICSharpCode.PackageManagement.Design;
 
10
using NuGet;
 
11
using NUnit.Framework;
 
12
using PackageManagement.Tests.Helpers;
 
13
 
 
14
namespace PackageManagement.Tests
 
15
{
 
16
        [TestFixture]
 
17
        public class RecentPackageRepositoryTests
 
18
        {
 
19
                RecentPackageRepository repository;
 
20
                FakePackageRepository aggregateRepository;
 
21
                PackageManagementEvents packageManagementEvents;
 
22
                List<RecentPackageInfo> recentPackages;
 
23
                
 
24
                void CreateRepository()
 
25
                {
 
26
                        CreateRecentPackages();
 
27
                        CreateRepository(recentPackages);
 
28
                }
 
29
                
 
30
                void CreateRecentPackages()
 
31
                {
 
32
                        recentPackages =  new List<RecentPackageInfo>();
 
33
                        aggregateRepository = new FakePackageRepository();
 
34
                }
 
35
                
 
36
                void CreateRepository(IList<RecentPackageInfo> recentPackages)
 
37
                {
 
38
                        packageManagementEvents = new PackageManagementEvents();
 
39
                        repository = new RecentPackageRepository(recentPackages, aggregateRepository, packageManagementEvents);
 
40
                }
 
41
                
 
42
                FakePackage AddOnePackageToRepository(string id)
 
43
                {
 
44
                        var package = new FakePackage(id);
 
45
                        repository.AddPackage(package);
 
46
                        return package;
 
47
                }
 
48
                
 
49
                IEnumerable<IPackage> AddTwoDifferentPackagesToRepository()
 
50
                {
 
51
                        yield return AddOnePackageToRepository("Test.Package.1");
 
52
                        yield return AddOnePackageToRepository("Test.Package.2");
 
53
                }
 
54
 
 
55
                IEnumerable<IPackage> AddFourDifferentPackagesToRepository()
 
56
                {
 
57
                        yield return AddOnePackageToRepository("Test.Package.1");
 
58
                        yield return AddOnePackageToRepository("Test.Package.2");
 
59
                        yield return AddOnePackageToRepository("Test.Package.3");
 
60
                        yield return AddOnePackageToRepository("Test.Package.4");
 
61
                }
 
62
                
 
63
                FakePackage CreateRepositoryWithOneRecentPackageSavedInOptions()
 
64
                {
 
65
                        CreateRecentPackages();
 
66
                        var package = new FakePackage("Test");
 
67
                        aggregateRepository.FakePackages.Add(package);
 
68
                        recentPackages.Add(new RecentPackageInfo(package));
 
69
                        CreateRepository(recentPackages);
 
70
                        return package;
 
71
                }
 
72
                
 
73
                [Test]
 
74
                public void Source_NewRecentRepositoryCreated_IsRecentPackages()
 
75
                {
 
76
                        CreateRepository();
 
77
                        Assert.AreEqual("RecentPackages", repository.Source);
 
78
                }
 
79
                
 
80
                [Test]
 
81
                public void GetPackages_RepositoryIsEmptyAndOnePackageAdded_ReturnsPackageAdded()
 
82
                {
 
83
                        CreateRepository();
 
84
                        var package = AddOnePackageToRepository("Test.Package");
 
85
                        
 
86
                        var packages = repository.GetPackages();
 
87
                        
 
88
                        var expectedPackages = new FakePackage[] {
 
89
                                package
 
90
                        };
 
91
                        
 
92
                        PackageCollectionAssert.AreEqual(expectedPackages, packages);
 
93
                }
 
94
                
 
95
                [Test]
 
96
                public void GetPackages_RepositoryIsEmptyAndTwoDifferentPackagesAdded_ReturnsPackagesInReverseOrderWithLastAddedFirst()
 
97
                {
 
98
                        CreateRepository();
 
99
                        var packagesAdded = AddTwoDifferentPackagesToRepository();
 
100
                        
 
101
                        var packages = repository.GetPackages();
 
102
                        
 
103
                        var expectedPackages = packagesAdded.Reverse();
 
104
                        
 
105
                        PackageCollectionAssert.AreEqual(expectedPackages, packages);
 
106
                }
 
107
                
 
108
                [Test]
 
109
                public void GetPackages_RepositoryCanHoldThreePackagesAndFourPackagesAdded_ReturnsLastThreePackagesAddedInReverseOrder()
 
110
                {
 
111
                        CreateRepository();
 
112
                        repository.MaximumPackagesCount = 3;
 
113
                        var packagesAdded = AddFourDifferentPackagesToRepository();
 
114
                        
 
115
                        var packages = repository.GetPackages();
 
116
                        
 
117
                        var expectedPackages = packagesAdded.Reverse().Take(3);
 
118
                        
 
119
                        PackageCollectionAssert.AreEqual(expectedPackages, packages);
 
120
                }
 
121
                
 
122
                [Test]
 
123
                public void GetPackages_RepositoryIsEmptyAndSamePackageIsAddedTwice_OnePackageReturned()
 
124
                {
 
125
                        CreateRepository();
 
126
                        AddOnePackageToRepository("Test");
 
127
                        var package = AddOnePackageToRepository("Test");
 
128
                        
 
129
                        var packages = repository.GetPackages();
 
130
                        
 
131
                        var expectedPackages = new FakePackage[] {
 
132
                                package
 
133
                        };
 
134
                        
 
135
                        PackageCollectionAssert.AreEqual(expectedPackages, packages);
 
136
                }
 
137
                
 
138
                [Test]
 
139
                public void AddPackage_RepositoryIsEmptyAndOnePackageAdded_RecentPackageAddedToOptions()
 
140
                {
 
141
                        CreateRepository();
 
142
                        var package = AddOnePackageToRepository("Test");
 
143
                        
 
144
                        var expectedPackages = new RecentPackageInfo[] {
 
145
                                new RecentPackageInfo(package)
 
146
                        };
 
147
                        
 
148
                        RecentPackageInfoCollectionAssert.AreEqual(expectedPackages, recentPackages);
 
149
                }
 
150
                
 
151
                [Test]
 
152
                public void AddPackage_RepositoryIsEmptyAndTwoPackagesAddedFromDifferentSources_BothRecentPackagesAddedToOptions()
 
153
                {
 
154
                        CreateRepository();
 
155
                        var package1 = AddOnePackageToRepository("Test1");
 
156
                        var package2 = AddOnePackageToRepository("Test2");
 
157
                        
 
158
                        var expectedPackages = new RecentPackageInfo[] {
 
159
                                new RecentPackageInfo(package2),
 
160
                                new RecentPackageInfo(package1)
 
161
                        };
 
162
                        
 
163
                        RecentPackageInfoCollectionAssert.AreEqual(expectedPackages, recentPackages);
 
164
                }
 
165
                
 
166
                [Test]
 
167
                public void GetPackages_SavedOptionsHasOneRecentPackage_ContainsPackageTakenFromAggregateRepositoryMatchingSavedRecentPackageInfo()
 
168
                {
 
169
                        var package = CreateRepositoryWithOneRecentPackageSavedInOptions();
 
170
                        
 
171
                        var recentPackages = repository.GetPackages();
 
172
                        
 
173
                        var expectedPackages = new FakePackage[] {
 
174
                                package
 
175
                        };
 
176
                        
 
177
                        PackageCollectionAssert.AreEqual(expectedPackages, recentPackages);
 
178
                }
 
179
                
 
180
                [Test]
 
181
                public void GetPackages_SavedOptionsHasOneRecentPackageAndGetPackagesCalledTwice_OnePackageReturned()
 
182
                {
 
183
                        var package = CreateRepositoryWithOneRecentPackageSavedInOptions();
 
184
                        
 
185
                        repository.GetPackages();
 
186
                        var recentPackages = repository.GetPackages();
 
187
                        
 
188
                        var expectedPackages = new FakePackage[] {
 
189
                                package
 
190
                        };
 
191
                        
 
192
                        PackageCollectionAssert.AreEqual(expectedPackages, recentPackages);
 
193
                }
 
194
                
 
195
                [Test]
 
196
                public void GetPackages_OneRecentPackageAndAggregrateRepositoryHasTwoPackagesWithSameIdButDifferentVersions_OnePackageReturnedWithMatchingVersion()
 
197
                {
 
198
                        var package1 = CreateRepositoryWithOneRecentPackageSavedInOptions();
 
199
                        var package2 = new FakePackage(package1.Id);
 
200
                        package2.Version = new Version(2, 0);
 
201
                        aggregateRepository.FakePackages.Add(package2);
 
202
                        
 
203
                        var recentPackages = repository.GetPackages();
 
204
                        
 
205
                        var expectedPackages = new FakePackage[] {
 
206
                                package1
 
207
                        };
 
208
                        
 
209
                        PackageCollectionAssert.AreEqual(expectedPackages, recentPackages);
 
210
                }
 
211
                
 
212
                [Test]
 
213
                public void ParentPackageInstalled_EventFires_PackageAddedToRecentPackages()
 
214
                {
 
215
                        CreateRepository();
 
216
                        
 
217
                        var package = new FakePackage("Test");
 
218
                        packageManagementEvents.OnParentPackageInstalled(package);
 
219
                        
 
220
                        var recentPackages = repository.GetPackages();
 
221
                        
 
222
                        var expectedPackages = new FakePackage[] {
 
223
                                package
 
224
                        };
 
225
                        
 
226
                        PackageCollectionAssert.AreEqual(expectedPackages, recentPackages);
 
227
                }
 
228
 
 
229
                public void Clear_OneRecentPackage_PackagesRemoved()
 
230
                {
 
231
                        CreateRepository();
 
232
                        AddOnePackageToRepository("Test1");
 
233
                        
 
234
                        repository.Clear();
 
235
                        
 
236
                        int count = repository.GetPackages().Count();
 
237
                        
 
238
                        Assert.AreEqual(0, count);
 
239
                }
 
240
                
 
241
                [Test]
 
242
                public void Clear_OneRecentPackageInOptions_RecentPackagesAreRemovedFromOptions()
 
243
                {
 
244
                        CreateRepositoryWithOneRecentPackageSavedInOptions();
 
245
                        
 
246
                        repository.Clear();
 
247
                        
 
248
                        int count = recentPackages.Count;
 
249
                        
 
250
                        Assert.AreEqual(0, count);
 
251
                }
 
252
                
 
253
                [Test]
 
254
                public void HasRecentPackages_NoSavedRecentPackages_ReturnsFalse()
 
255
                {
 
256
                        CreateRepository();
 
257
                        
 
258
                        bool hasRecentPackages = repository.HasRecentPackages;
 
259
                        
 
260
                        Assert.IsFalse(hasRecentPackages);
 
261
                }
 
262
                
 
263
                [Test]
 
264
                public void HasRecentPackages_OneSavedRecentPackages_ReturnsTrue()
 
265
                {
 
266
                        CreateRepositoryWithOneRecentPackageSavedInOptions();
 
267
                        
 
268
                        bool hasRecentPackages = repository.HasRecentPackages;
 
269
                        
 
270
                        Assert.IsTrue(hasRecentPackages);
 
271
                }
 
272
        }
 
273
}