← Back to branch summary

~halega/+junk/sharpdevelop

« back to all changes in this revision

Viewing changes to src/AddIns/Misc/PackageManagement/Test/Src/PackageRepositoryCacheTests.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/PackageRepositoryCacheTests.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.IO.Packaging;
 
7
using ICSharpCode.PackageManagement;
 
8
using ICSharpCode.PackageManagement.Design;
 
9
using NuGet;
 
10
using NUnit.Framework;
 
11
using PackageManagement.Tests.Helpers;
 
12
 
 
13
namespace PackageManagement.Tests
 
14
{
 
15
        [TestFixture]
 
16
        public class PackageRepositoryCacheTests
 
17
        {
 
18
                PackageRepositoryCache cache;
 
19
                FakePackageRepositoryFactory fakePackageRepositoryFactory;
 
20
                PackageSource nuGetPackageSource;
 
21
                OneRegisteredPackageSourceHelper packageSourcesHelper;
 
22
                RecentPackageInfo[] recentPackagesPassedToCreateRecentPackageRepository;
 
23
                FakePackageRepository fakeAggregateRepositoryPassedToCreateRecentPackageRepository;
 
24
 
 
25
                void CreateCache()
 
26
                {
 
27
                        CreatePackageSources();
 
28
                        CreateCacheUsingPackageSources();
 
29
                }
 
30
                
 
31
                void CreatePackageSources()
 
32
                {
 
33
                        packageSourcesHelper = new OneRegisteredPackageSourceHelper();
 
34
                }
 
35
                
 
36
                void CreateCacheUsingPackageSources()
 
37
                {
 
38
                        nuGetPackageSource = new PackageSource("http://nuget.org", "NuGet");
 
39
                        fakePackageRepositoryFactory = new FakePackageRepositoryFactory();
 
40
                        RegisteredPackageSources packageSources = packageSourcesHelper.Options.PackageSources;
 
41
                        IList<RecentPackageInfo> recentPackages = packageSourcesHelper.Options.RecentPackages;
 
42
                        cache = new PackageRepositoryCache(fakePackageRepositoryFactory, packageSources, recentPackages);
 
43
                }
 
44
                
 
45
                FakePackageRepository AddFakePackageRepositoryForPackageSource(string source)
 
46
                {
 
47
                        return fakePackageRepositoryFactory.AddFakePackageRepositoryForPackageSource(source);
 
48
                }
 
49
                
 
50
                IPackageRepository CreateRecentPackageRepositoryPassingAggregateRepository()
 
51
                {
 
52
                        recentPackagesPassedToCreateRecentPackageRepository = new RecentPackageInfo[0];
 
53
                        fakeAggregateRepositoryPassedToCreateRecentPackageRepository = new FakePackageRepository();
 
54
                        
 
55
                        return cache.CreateRecentPackageRepository(
 
56
                                recentPackagesPassedToCreateRecentPackageRepository,
 
57
                                fakeAggregateRepositoryPassedToCreateRecentPackageRepository);
 
58
                }
 
59
                
 
60
                RecentPackageInfo AddOneRecentPackage()
 
61
                {
 
62
                        var recentPackage = new RecentPackageInfo("Id", new Version("1.0"));
 
63
                        packageSourcesHelper.Options.RecentPackages.Add(recentPackage);
 
64
                        return recentPackage;
 
65
                }
 
66
 
 
67
                [Test]
 
68
                public void CreateRepository_CacheCastToISharpDevelopPackageRepositoryFactory_CreatesPackageRepositoryUsingPackageRepositoryFactoryPassedInConstructor()
 
69
                {
 
70
                        CreateCache();
 
71
                        var factory = cache as ISharpDevelopPackageRepositoryFactory;
 
72
                        IPackageRepository repository = factory.CreateRepository(nuGetPackageSource.Source);
 
73
                        
 
74
                        Assert.AreEqual(fakePackageRepositoryFactory.FakePackageRepository, repository);
 
75
                }
 
76
                
 
77
                [Test]
 
78
                public void CreateRepository_PackageSourcePassed_PackageSourceUsedToCreateRepository()
 
79
                {
 
80
                        CreateCache();
 
81
                        cache.CreateRepository(nuGetPackageSource.Source);
 
82
                        
 
83
                        string actualPackageSource = fakePackageRepositoryFactory.FirstPackageSourcePassedToCreateRepository;
 
84
                        Assert.AreEqual(nuGetPackageSource.Source, actualPackageSource);
 
85
                }
 
86
                
 
87
                [Test]
 
88
                public void CreateRepository_RepositoryAlreadyCreatedForPackageSource_NoRepositoryCreated()
 
89
                {
 
90
                        CreateCache();
 
91
                        cache.CreateRepository(nuGetPackageSource.Source);
 
92
                        fakePackageRepositoryFactory.PackageSourcesPassedToCreateRepository.Clear();
 
93
                        
 
94
                        cache.CreateRepository(nuGetPackageSource.Source);
 
95
                        
 
96
                        Assert.AreEqual(0, fakePackageRepositoryFactory.PackageSourcesPassedToCreateRepository.Count);
 
97
                }
 
98
                
 
99
                [Test]
 
100
                public void CreateRepository_RepositoryAlreadyCreatedForPackageSource_RepositoryOriginallyCreatedIsReturned()
 
101
                {
 
102
                        CreateCache();
 
103
                        IPackageRepository originallyCreatedRepository = cache.CreateRepository(nuGetPackageSource.Source);
 
104
                        fakePackageRepositoryFactory.PackageSourcesPassedToCreateRepository.Clear();
 
105
                        
 
106
                        IPackageRepository repository = cache.CreateRepository(nuGetPackageSource.Source);
 
107
                        
 
108
                        Assert.AreSame(originallyCreatedRepository, repository);
 
109
                }
 
110
                
 
111
                [Test]
 
112
                public void CreateSharedRepository_MethodCalled_ReturnsSharedPackageRepository()
 
113
                {
 
114
                        CreateCache();
 
115
                        ISharedPackageRepository repository = cache.CreateSharedRepository(null, null);
 
116
                        Assert.IsNotNull(repository);
 
117
                }
 
118
                
 
119
                [Test]
 
120
                public void CreatedSharedRepository_PathResolverPassed_PathResolverUsedToCreatedSharedRepository()
 
121
                {
 
122
                        CreateCache();
 
123
                        FakePackagePathResolver resolver = new FakePackagePathResolver();
 
124
                        cache.CreateSharedRepository(resolver, null);
 
125
                        
 
126
                        Assert.AreEqual(resolver, fakePackageRepositoryFactory.PathResolverPassedToCreateSharedRepository);
 
127
                }
 
128
                
 
129
                [Test]
 
130
                public void CreatedSharedRepository_FileSystemPassed_FileSystemUsedToCreatedSharedRepository()
 
131
                {
 
132
                        CreateCache();
 
133
                        FakeFileSystem fileSystem = new FakeFileSystem();
 
134
                        cache.CreateSharedRepository(null, fileSystem);
 
135
                        
 
136
                        Assert.AreEqual(fileSystem, fakePackageRepositoryFactory.FileSystemPassedToCreateSharedRepository);
 
137
                }
 
138
                
 
139
                [Test]
 
140
                public void CreateAggregatePackageRepository_TwoRegisteredPackageRepositories_ReturnsAggregateRepositoryFromFactory()
 
141
                {
 
142
                        CreatePackageSources();
 
143
                        packageSourcesHelper.AddTwoPackageSources("Source1", "Source2");
 
144
                        CreateCacheUsingPackageSources();
 
145
                        
 
146
                        IPackageRepository aggregateRepository = cache.CreateAggregateRepository();
 
147
                        FakePackageRepository expectedRepository = fakePackageRepositoryFactory.FakeAggregateRepository;
 
148
                        
 
149
                        Assert.AreEqual(expectedRepository, aggregateRepository);
 
150
                }
 
151
                
 
152
                [Test]
 
153
                public void CreateAggregatePackageRepository_TwoRegisteredPackageRepositories_AllRegisteredRepositoriesUsedToCreateAggregateRepositoryFromFactory()
 
154
                {
 
155
                        CreatePackageSources();
 
156
                        packageSourcesHelper.AddTwoPackageSources("Source1", "Source2");
 
157
                        CreateCacheUsingPackageSources();
 
158
                        
 
159
                        FakePackageRepository repository1 = AddFakePackageRepositoryForPackageSource("Source1");
 
160
                        FakePackageRepository repository2 = AddFakePackageRepositoryForPackageSource("Source2");
 
161
                        var expectedRepositories = new FakePackageRepository[] {
 
162
                                repository1,
 
163
                                repository2
 
164
                        };
 
165
                        
 
166
                        cache.CreateAggregateRepository();
 
167
                        
 
168
                        IEnumerable<IPackageRepository> repositoriesUsedToCreateAggregateRepository = 
 
169
                                fakePackageRepositoryFactory.RepositoriesPassedToCreateAggregateRepository;
 
170
                        
 
171
                        var actualRepositoriesAsList = new List<IPackageRepository>(repositoriesUsedToCreateAggregateRepository);
 
172
                        IPackageRepository[] actualRepositories = actualRepositoriesAsList.ToArray();
 
173
                        
 
174
                        CollectionAssert.AreEqual(expectedRepositories, actualRepositories);
 
175
                }
 
176
                
 
177
                [Test]
 
178
                public void CreateAggregatePackageRepository_OnePackageRepositoryPassed_ReturnsAggregateRepositoryFromFactory()
 
179
                {
 
180
                        CreateCache();
 
181
                        
 
182
                        var repositories = new FakePackageRepository[] {
 
183
                                new FakePackageRepository()
 
184
                        };
 
185
                        IPackageRepository aggregateRepository = cache.CreateAggregateRepository(repositories);
 
186
                        
 
187
                        FakePackageRepository expectedRepository = fakePackageRepositoryFactory.FakeAggregateRepository;
 
188
                        
 
189
                        Assert.AreEqual(expectedRepository, aggregateRepository);
 
190
                }
 
191
                
 
192
                [Test]
 
193
                public void CreateAggregatePackageRepository_OnePackageRepositoryPassed_RepositoryUsedToCreateAggregateRepository()
 
194
                {
 
195
                        CreateCache();
 
196
                        
 
197
                        var repositories = new FakePackageRepository[] {
 
198
                                new FakePackageRepository()
 
199
                        };
 
200
                        cache.CreateAggregateRepository(repositories);
 
201
                        
 
202
                        IEnumerable<IPackageRepository> repositoriesUsedToCreateAggregateRepository = 
 
203
                                fakePackageRepositoryFactory.RepositoriesPassedToCreateAggregateRepository;
 
204
                        
 
205
                        Assert.AreEqual(repositories, repositoriesUsedToCreateAggregateRepository);
 
206
                }
 
207
                
 
208
                [Test]
 
209
                public void RecentPackageRepository_NoRecentPackages_ReturnsRecentRepositoryCreatedByFactory()
 
210
                {
 
211
                        CreateCache();
 
212
                        IRecentPackageRepository repository = cache.RecentPackageRepository;
 
213
                        FakeRecentPackageRepository expectedRepository = fakePackageRepositoryFactory.FakeRecentPackageRepository;
 
214
                        
 
215
                        Assert.AreEqual(expectedRepository, repository);
 
216
                }
 
217
                
 
218
                [Test]
 
219
                public void RecentPackageRepository_NoRecentPackages_CreatedWithAggregateRepository()
 
220
                {
 
221
                        CreateCache();
 
222
                        IRecentPackageRepository repository = cache.RecentPackageRepository;
 
223
                        
 
224
                        FakePackageRepository expectedRepository = fakePackageRepositoryFactory.FakeAggregateRepository;
 
225
                        IPackageRepository actualRepository = fakePackageRepositoryFactory.AggregateRepositoryPassedToCreateRecentPackageRepository;
 
226
                        
 
227
                        Assert.AreEqual(expectedRepository, actualRepository);
 
228
                }
 
229
                
 
230
                [Test]
 
231
                public void RecentPackageRepository_OneRecentPackage_RecentPackageUsedToCreateRecentPackageRepository()
 
232
                {
 
233
                        CreateCache();
 
234
                        RecentPackageInfo recentPackage = AddOneRecentPackage();
 
235
                        
 
236
                        IRecentPackageRepository repository = cache.RecentPackageRepository;
 
237
                        
 
238
                        IList<RecentPackageInfo> actualRecentPackages = fakePackageRepositoryFactory.RecentPackagesPassedToCreateRecentPackageRepository;
 
239
                        
 
240
                        var expectedRecentPackages = new RecentPackageInfo[] {
 
241
                                recentPackage
 
242
                        };
 
243
                        
 
244
                        Assert.AreEqual(expectedRecentPackages, actualRecentPackages);
 
245
                }
 
246
                
 
247
                [Test]
 
248
                public void RecentPackageRepository_OnePackageSource_OneRepositoryCreatedForPackageSourceAndUsedToCreateAggregateRepository()
 
249
                {
 
250
                        CreatePackageSources();
 
251
                        packageSourcesHelper.AddOnePackageSource("Source1");
 
252
                        CreateCacheUsingPackageSources();
 
253
                        
 
254
                        FakePackageRepository repository = AddFakePackageRepositoryForPackageSource("Source1");
 
255
                        var expectedRepositories = new FakePackageRepository[] {
 
256
                                repository
 
257
                        };
 
258
                        
 
259
                        IRecentPackageRepository recentRepository = cache.RecentPackageRepository;
 
260
                        
 
261
                        IEnumerable<IPackageRepository> repositoriesUsedToCreateAggregateRepository = 
 
262
                                fakePackageRepositoryFactory.RepositoriesPassedToCreateAggregateRepository;
 
263
                        
 
264
                        var actualRepositoriesAsList = new List<IPackageRepository>(repositoriesUsedToCreateAggregateRepository);
 
265
                        IPackageRepository[] actualRepositories = actualRepositoriesAsList.ToArray();
 
266
                        
 
267
                        CollectionAssert.AreEqual(expectedRepositories, actualRepositories);
 
268
                }
 
269
                
 
270
                [Test]
 
271
                public void RecentPackageRepository_PropertyAccessedTwice_AggregateRepositoryCreatedOnce()
 
272
                {
 
273
                        CreateCache();
 
274
                        IRecentPackageRepository repository = cache.RecentPackageRepository;
 
275
                        fakePackageRepositoryFactory.RepositoriesPassedToCreateAggregateRepository = null;
 
276
                        repository = cache.RecentPackageRepository;
 
277
                        
 
278
                        Assert.IsNull(fakePackageRepositoryFactory.RepositoriesPassedToCreateAggregateRepository);
 
279
                }
 
280
                        
 
281
                [Test]
 
282
                public void CreateRecentPackageRepository_AggregateRepositoryPassedAndNoRecentPackagesPassed_UsesFactoryToCreateRepository()
 
283
                {
 
284
                        CreateCache();
 
285
                        IPackageRepository repository = CreateRecentPackageRepositoryPassingAggregateRepository();
 
286
                        
 
287
                        FakeRecentPackageRepository expectedRepository = fakePackageRepositoryFactory.FakeRecentPackageRepository;
 
288
                        
 
289
                        Assert.AreEqual(expectedRepository, repository);
 
290
                }
 
291
                
 
292
                [Test]
 
293
                public void CreateRecentPackageRepository_AggregateRepositoryPassedAndNoRecentPackagesPassed_AggregateIsUsedToCreateRepository()
 
294
                {
 
295
                        CreateCache();
 
296
                        CreateRecentPackageRepositoryPassingAggregateRepository();
 
297
                        
 
298
                        IPackageRepository actualRepository = fakePackageRepositoryFactory.AggregateRepositoryPassedToCreateRecentPackageRepository;
 
299
                        
 
300
                        Assert.AreEqual(fakeAggregateRepositoryPassedToCreateRecentPackageRepository, actualRepository);
 
301
                }
 
302
                
 
303
                [Test]
 
304
                public void CreateRecentPackageRepository_AggregateRepositoryPassedAndNoRecentPackagesPassed_RecentPackagesUsedToCreateRepository()
 
305
                {
 
306
                        CreateCache();
 
307
                        CreateRecentPackageRepositoryPassingAggregateRepository();
 
308
                        
 
309
                        IList<RecentPackageInfo> recentPackages = fakePackageRepositoryFactory.RecentPackagesPassedToCreateRecentPackageRepository;
 
310
                        
 
311
                        Assert.AreEqual(recentPackagesPassedToCreateRecentPackageRepository, recentPackages);
 
312
                }
 
313
                
 
314
                [Test]
 
315
                public void CreateRecentPackageRepository_MethodCalledTwice_RecentPackageRepositoryCreatedOnce()
 
316
                {
 
317
                        CreateCache();
 
318
                        CreateRecentPackageRepositoryPassingAggregateRepository();
 
319
                        fakePackageRepositoryFactory.AggregateRepositoryPassedToCreateRecentPackageRepository = null;
 
320
                        CreateRecentPackageRepositoryPassingAggregateRepository();
 
321
                        
 
322
                        Assert.IsNull(fakePackageRepositoryFactory.AggregateRepositoryPassedToCreateRecentPackageRepository);
 
323
                }
 
324
        }
 
325
}