← Back to branch summary

~halega/+junk/sharpdevelop

« back to all changes in this revision

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

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

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/AddIns/Misc/PackageManagement/Test/Src/Scripting/PackageInitializationScriptsTests.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 ICSharpCode.PackageManagement.Design;
 
6
using ICSharpCode.PackageManagement.Scripting;
 
7
using NuGet;
 
8
using NUnit.Framework;
 
9
using PackageManagement.Tests.Helpers;
 
10
 
 
11
namespace PackageManagement.Tests.Scripting
 
12
{
 
13
        [TestFixture]
 
14
        public class PackageInitializationScriptsTests
 
15
        {
 
16
                PackageInitializationScripts scripts;
 
17
                FakePackageScriptFactory fakeScriptFactory;
 
18
                FakeSolutionPackageRepository fakeSolutionPackageRepository;
 
19
                FakePackageScriptSession fakeSession;
 
20
                FakePackageScriptFactoryWithPredefinedPackageScripts fakeScriptFactoryWithPredefinedPackageScripts;
 
21
                
 
22
                void CreateScripts()
 
23
                {
 
24
                        fakeScriptFactory = new FakePackageScriptFactory();
 
25
                        CreateScripts(fakeScriptFactory);
 
26
                }
 
27
                
 
28
                void CreateScripts(IPackageScriptFactory scriptFactory)
 
29
                {
 
30
                        fakeSolutionPackageRepository = new FakeSolutionPackageRepository();
 
31
                        fakeSession = new FakePackageScriptSession();
 
32
                        scripts = new PackageInitializationScripts(fakeSolutionPackageRepository, scriptFactory);
 
33
                }
 
34
                
 
35
                FakePackage AddPackageToRepository(string packageId)
 
36
                {
 
37
                        var package = new FakePackage(packageId);
 
38
                        fakeSolutionPackageRepository.FakePackages.Add(package);
 
39
                        return package;
 
40
                }
 
41
                
 
42
                void CreateScriptsUsingScriptFactoryWithPredefinedScripts()
 
43
                {
 
44
                        fakeScriptFactoryWithPredefinedPackageScripts = new FakePackageScriptFactoryWithPredefinedPackageScripts();
 
45
                        CreateScripts(fakeScriptFactoryWithPredefinedPackageScripts);
 
46
                }
 
47
                
 
48
                void CreateScriptsWithTwoPackagesInRepositoryAndLastPackageScriptFileExistsButNotFirst()
 
49
                {
 
50
                        CreateScriptsUsingScriptFactoryWithPredefinedScripts();
 
51
                        AddPackageToRepository("A");
 
52
                        AddPackageToRepository("B");
 
53
                        
 
54
                        var scriptForPackageA = fakeScriptFactoryWithPredefinedPackageScripts.AddFakeInitializationScript();
 
55
                        scriptForPackageA.ExistsReturnValue = false;
 
56
                        
 
57
                        var scriptForPackageB = fakeScriptFactoryWithPredefinedPackageScripts.AddFakeInitializationScript();
 
58
                        scriptForPackageB.ExistsReturnValue = true;                     
 
59
                }
 
60
                
 
61
                [Test]
 
62
                public void Run_OnePackageInRepository_OnePackageScriptIsRun()
 
63
                {
 
64
                        CreateScripts();
 
65
                        AddPackageToRepository("Test");
 
66
                        scripts.Run(fakeSession);
 
67
                        
 
68
                        IPackageScriptSession session = fakeScriptFactory.FirstPackageInitializeScriptCreated.SessionPassedToRun;
 
69
                        FakePackageScriptSession expectedSession = fakeSession;
 
70
                        
 
71
                        Assert.AreEqual(expectedSession, session);
 
72
                }
 
73
                
 
74
                [Test]
 
75
                public void Run_OnePackageInRepository_PackageInitScriptCreatedForPackage()
 
76
                {
 
77
                        CreateScripts();
 
78
                        AddPackageToRepository("Test");
 
79
                        string expectedDirectory = @"d:\projects\myproject\packages\Test.1.0";
 
80
                        fakeSolutionPackageRepository.InstallPathToReturn = expectedDirectory;
 
81
                        
 
82
                        scripts.Run(fakeSession);
 
83
                        
 
84
                        string actualDirectory = fakeScriptFactory.FirstPackageInstallDirectoryPassed;
 
85
                        
 
86
                        Assert.AreEqual(expectedDirectory, actualDirectory);
 
87
                }
 
88
                
 
89
                [Test]
 
90
                public void Run_OnePackageInRepository_PackageUsedToDetermineInstallPath()
 
91
                {
 
92
                        CreateScripts();
 
93
                        FakePackage package = AddPackageToRepository("Test");                   
 
94
                        scripts.Run(fakeSession);
 
95
                        
 
96
                        IPackage actualPackage = fakeSolutionPackageRepository.PackagePassedToGetInstallPath;
 
97
                        
 
98
                        Assert.AreEqual(package, actualPackage);
 
99
                }
 
100
                
 
101
                [Test]
 
102
                public void Run_TwoPackagesInRepository_SecondScriptIsRun()
 
103
                {
 
104
                        CreateScripts();
 
105
                        AddPackageToRepository("A");
 
106
                        AddPackageToRepository("B");
 
107
                        scripts.Run(fakeSession);
 
108
                        
 
109
                        IPackageScriptSession session = fakeScriptFactory.FakePackageInitializeScriptsCreated[1].SessionPassedToRun;
 
110
                        FakePackageScriptSession expectedSession = fakeSession;
 
111
                        
 
112
                        Assert.AreEqual(expectedSession, session);
 
113
                }
 
114
                
 
115
                [Test]
 
116
                public void Any_OnePackageInRepositoryAndScriptFileExists_ReturnsTrue()
 
117
                {
 
118
                        CreateScripts();
 
119
                        AddPackageToRepository("A");
 
120
                        fakeScriptFactory.ScriptFileExistsReturnValue = true;
 
121
                        
 
122
                        bool result = scripts.Any();
 
123
                        
 
124
                        Assert.IsTrue(result);
 
125
                }
 
126
                
 
127
                [Test]
 
128
                public void Any_OnePackageInRepositoryAndScriptFileDoesNotExist_ReturnsFalse()
 
129
                {
 
130
                        CreateScripts();
 
131
                        AddPackageToRepository("A");
 
132
                        fakeScriptFactory.ScriptFileExistsReturnValue = false;
 
133
                        
 
134
                        bool result = scripts.Any();
 
135
                        
 
136
                        Assert.IsFalse(result);
 
137
                }
 
138
                
 
139
                [Test]
 
140
                public void Any_TwoPackagesInRepositoryAndLastPackageScriptFileExistsButNotFirst_ReturnsTrue()
 
141
                {
 
142
                        CreateScriptsWithTwoPackagesInRepositoryAndLastPackageScriptFileExistsButNotFirst();
 
143
                        
 
144
                        bool result = scripts.Any();
 
145
                        
 
146
                        Assert.IsTrue(result);
 
147
                }
 
148
                
 
149
                [Test]
 
150
                public void Run_TwoPackagesInRepositoryAndLastPackageScriptFileExistsButNotFirst_FirstScriptNotRun()
 
151
                {
 
152
                        CreateScriptsWithTwoPackagesInRepositoryAndLastPackageScriptFileExistsButNotFirst();
 
153
                        FakePackageScript firstScript = fakeScriptFactoryWithPredefinedPackageScripts.FakeInitializeScripts[0];
 
154
                        scripts.Run(fakeSession);
 
155
                        
 
156
                        bool run = firstScript.IsRun;
 
157
                        
 
158
                        Assert.IsFalse(run);
 
159
                }
 
160
                
 
161
                [Test]
 
162
                public void Run_OnePackageInRepository_PackageScriptSetsPackageInSession()
 
163
                {
 
164
                        CreateScripts();
 
165
                        FakePackage expectedPackage = AddPackageToRepository("Test");
 
166
                        scripts.Run(fakeSession);
 
167
                        
 
168
                        var package = fakeScriptFactory.FirstPackageInitializeScriptCreated.Package;
 
169
                        
 
170
                        Assert.AreEqual(expectedPackage, package);
 
171
                }
 
172
        }
 
173
}