← Back to branch summary

~ubuntu-branches/ubuntu/trusty/jenkins/trusty

« back to all changes in this revision

Viewing changes to maven-plugin/src/test/java/hudson/maven/MavenModuleTest.java

  • Committer: Package Import Robot
  • Author(s): James Page
  • Date: 2013-08-13 12:35:19 UTC
  • mfrom: (1.1.13)
  • Revision ID: package-import@ubuntu.com-20130813123519-tizgfxcr70trl7r0
Tags: 1.509.2+dfsg-1
http://bugs.debian.org/706725
http://bugs.debian.org/701163
http://bugs.debian.org/704848
* New upstream release (Closes: #706725):
  - d/control: Update versioned BD's:
    * jenkins-executable-war >= 1.28.
    * jenkins-instance-identity >= 1.3.
    * libjenkins-remoting-java >= 2.23.
    * libjenkins-winstone-java >= 0.9.10-jenkins-44.
    * libstapler-java >= 1.207.
    * libjenkins-json-java >= 2.4-jenkins-1.
    * libstapler-adjunct-timeline-java >= 1.4.
    * libstapler-adjunct-codemirror-java >= 1.2.
    * libmaven-hpi-plugin-java >= 1.93.
    * libjenkins-xstream-java >= 1.4.4-jenkins-3.
  - d/maven.rules: Map to older version of animal-sniffer-maven-plugin.
  - Add patch for compatibility with guava >= 0.14.
  - Add patch to exclude asm4 dependency via jnr-posix.
  - Fixes the following security vulnerabilities:
    CVE-2013-2034, CVE-2013-2033, CVE-2013-2034, CVE-2013-1808
* d/patches/*: Switch to using git patch-queue for managing patches.
* De-duplicate jars between libjenkins-java and jenkins-external-job-monitor
  (Closes: #701163):
  - d/control: Add dependency between jenkins-external-job-monitor ->
    libjenkins-java.
  - d/rules: 
    Drop installation of jenkins-core in jenkins-external-job-monitor.
  - d/jenkins-external-job-monitor.{links,install}: Link to jenkins-core
    in /usr/share/java instead of included version.
* Wait longer for jenkins to stop during restarts (Closes: #704848):
  - d/jenkins.init: Re-sync init script from upstream codebase.

Show diffs side-by-side

added added

removed removed

Lines of Context:
maven-plugin/src/test/java/hudson/maven/MavenModuleTest.java
10
10
import hudson.model.DependencyGraph;
11
11
import hudson.model.MockHelper;
12
12
 
 
13
import java.util.Collection;
13
14
import java.util.Collections;
14
15
import java.util.List;
15
16
 
16
17
import junit.framework.Assert;
17
18
 
18
19
import org.apache.maven.model.Build;
 
20
import org.apache.maven.model.Dependency;
19
21
import org.apache.maven.model.Plugin;
20
22
import org.apache.maven.project.MavenProject;
21
23
import org.junit.Before;
126
128
        
127
129
        when(parent.getModules()).thenReturn(Collections.singleton(mock));
128
130
    }
 
131
    /**
 
132
     * This test is a standard project that has a versioned dependency.
 
133
     */
 
134
    @Test
 
135
    public void testSimpleVersion() {
 
136
        TestComponents testComponents = createTestComponents("1.0.1-SNAPSHOT");
 
137
 
 
138
        DependencyGraph graph = testComponents.graph;
 
139
        MavenModule appMavenModule = testComponents.applicationMavenModule;
 
140
        MavenModule libMavenModule = testComponents.libraryMavenModule;
 
141
 
 
142
        graph.build();
 
143
 
 
144
        List<AbstractProject> appDownstream = graph.getDownstream(appMavenModule);
 
145
        List<AbstractProject> appUpstream = graph.getUpstream(appMavenModule);
 
146
        List<AbstractProject> libDownstream = graph.getDownstream(libMavenModule);
 
147
        List<AbstractProject> libUpstream = graph.getUpstream(libMavenModule);
 
148
 
 
149
        Assert.assertEquals(0, appDownstream.size());
 
150
        Assert.assertEquals(1, appUpstream.size());
 
151
        Assert.assertEquals(1, libDownstream.size());
 
152
        Assert.assertEquals(0, libUpstream.size());
 
153
    }
 
154
 
 
155
    /**
 
156
     * This tests that a version range declaration in the dependency of a top level project
 
157
     * resolves the up and downstream correctly.
 
158
     */
 
159
    @Test
 
160
    public void testSimpleVersionRange() {
 
161
        TestComponents testComponents = createTestComponents("[1.0.0, )");
 
162
 
 
163
        DependencyGraph graph = testComponents.graph;
 
164
        MavenModule appMavenModule = testComponents.applicationMavenModule;
 
165
        MavenModule libMavenModule = testComponents.libraryMavenModule;
 
166
 
 
167
        graph.build();
 
168
 
 
169
        List<AbstractProject> appDownstream = graph.getDownstream(appMavenModule);
 
170
        List<AbstractProject> appUpstream = graph.getUpstream(appMavenModule);
 
171
        List<AbstractProject> libDownstream = graph.getDownstream(libMavenModule);
 
172
        List<AbstractProject> libUpstream = graph.getUpstream(libMavenModule);
 
173
 
 
174
        Assert.assertEquals(0, appDownstream.size());
 
175
        Assert.assertEquals(1, appUpstream.size());
 
176
        Assert.assertEquals(1, libDownstream.size());
 
177
        Assert.assertEquals(0, libUpstream.size());
 
178
    }
 
179
 
 
180
    /**
 
181
     * Test multiple projects with dependencies on differing library versions declared with
 
182
     * multiple version definitions.
 
183
     */
 
184
    @Test
 
185
    public void testMultipleDependencies() {
 
186
 
 
187
        MavenProject projectA = createMavenProject("ProjectA", "test", "projectA", "1.0-SNAPSHOT", "jar");
 
188
        Dependency dependencyA = createDependency("test", "library", "[1.0, 2.0)");
 
189
        projectA.getDependencies().add(dependencyA);
 
190
 
 
191
        MavenProject projectB = createMavenProject("ProjectB", "test", "projectB", "2.0-SNAPSHOT", "jar");
 
192
        Dependency dependencyB = createDependency("test", "library", "[1.1, 2.1]");
 
193
        projectB.getDependencies().add(dependencyB);
 
194
 
 
195
        MavenProject dependX = createMavenProject("DependX-1.1", "test", "library", "1.1.3-SNAPSHOT", "jar");
 
196
        MavenProject dependY = createMavenProject("DependX-1.2", "test", "library", "1.2.1-SNAPSHOT", "jar");
 
197
        MavenProject dependZ = createMavenProject("DependX-2.0", "test", "library", "2.0.1-SNAPSHOT", "jar");
 
198
 
 
199
        MavenModuleSet parent = mock(MavenModuleSet.class);
 
200
        when(parent.isAggregatorStyleBuild()).thenReturn(Boolean.FALSE);
 
201
 
 
202
        //Now create maven modules for all the projects
 
203
        MavenModule mavenModuleA = mockMavenModule(projectA);
 
204
        MavenModule mavenModuleB = mockMavenModule(projectB);
 
205
        MavenModule mavenModuleX = mockMavenModule(dependX);
 
206
        MavenModule mavenModuleY = mockMavenModule(dependY);
 
207
        MavenModule mavenModuleZ = mockMavenModule(dependZ);
 
208
 
 
209
        Collection<AbstractProject<?,?>> allModules = Lists.<AbstractProject<?,?>>newArrayList(mavenModuleA,
 
210
                mavenModuleB, mavenModuleX, mavenModuleY, mavenModuleZ);
 
211
 
 
212
        for (AbstractProject<?, ?> module : allModules) {
 
213
            MavenModule mm = (MavenModule) module;
 
214
            enhanceMavenModuleMock(mm, parent, allModules);
 
215
        }
 
216
 
 
217
        DependencyGraph graph = MockHelper.mockDependencyGraph(allModules);
 
218
        doCallRealMethod().when(graph).getDownstream(Matchers.any(AbstractProject.class));
 
219
        doCallRealMethod().when(graph).getUpstream(Matchers.any(AbstractProject.class));
 
220
        doCallRealMethod().when(graph).compare(Matchers.<AbstractProject>any(), Matchers.<AbstractProject>any());
 
221
        graph.build();
 
222
 
 
223
        List<AbstractProject> downstreamA = graph.getDownstream(mavenModuleA);
 
224
        List<AbstractProject> upstreamA = graph.getUpstream(mavenModuleA);
 
225
 
 
226
        Assert.assertEquals(0, downstreamA.size());
 
227
        Assert.assertEquals(1, upstreamA.size());
 
228
        Assert.assertSame(dependY.getVersion(), ((MavenModule) upstreamA.get(0)).getVersion());
 
229
 
 
230
        List<AbstractProject> downstreamB = graph.getDownstream(mavenModuleB);
 
231
        List<AbstractProject> upstreamB = graph.getUpstream(mavenModuleB);
 
232
 
 
233
        Assert.assertEquals(0, downstreamB.size());
 
234
        Assert.assertEquals(1, upstreamA.size());
 
235
        Assert.assertSame(dependZ.getVersion(), ((MavenModule) upstreamB.get(0)).getVersion());
 
236
    }
 
237
 
 
238
    /**
 
239
     * This tests a project that has a dependency on a specific version of X.
 
240
     * The project X has moved on and so should not have any dependencies on ProjectA.
 
241
     */
 
242
    @Test
 
243
    public void testProjectWithSpecifiedVersionAndNoDependencies() {
 
244
        MavenProject projectA = createMavenProject("ProjectA", "test", "projectA", "1.0-SNAPSHOT", "jar");
 
245
        Dependency dependencyA = createDependency("test", "library", "1.0");
 
246
        projectA.getDependencies().add(dependencyA);
 
247
 
 
248
        MavenProject dependX = createMavenProject("DependX-1.1", "test", "library", "1.2-SNAPSHOT", "jar");
 
249
 
 
250
        MavenModuleSet parent = mock(MavenModuleSet.class);
 
251
        when(parent.isAggregatorStyleBuild()).thenReturn(Boolean.FALSE);
 
252
 
 
253
        //Now create maven modules for all the projects
 
254
        MavenModule mavenModuleA = mockMavenModule(projectA);
 
255
        MavenModule mavenModuleX = mockMavenModule(dependX);
 
256
 
 
257
        Collection<AbstractProject<?,?>> allModules = Lists.<AbstractProject<?,?>>newArrayList(mavenModuleA,
 
258
                mavenModuleX);
 
259
 
 
260
        for (AbstractProject<?, ?> module : allModules) {
 
261
            MavenModule mm = (MavenModule) module;
 
262
            enhanceMavenModuleMock(mm, parent, allModules);
 
263
        }
 
264
 
 
265
        DependencyGraph graph = MockHelper.mockDependencyGraph(allModules);
 
266
        doCallRealMethod().when(graph).getDownstream(Matchers.any(AbstractProject.class));
 
267
        doCallRealMethod().when(graph).getUpstream(Matchers.any(AbstractProject.class));
 
268
        doCallRealMethod().when(graph).compare(Matchers.<AbstractProject>any(), Matchers.<AbstractProject>any());
 
269
        graph.build();
 
270
 
 
271
        List<AbstractProject> downstreamA = graph.getDownstream(mavenModuleA);
 
272
        List<AbstractProject> upstreamA = graph.getUpstream(mavenModuleA);
 
273
 
 
274
        Assert.assertEquals(0, downstreamA.size());
 
275
        Assert.assertEquals(0, upstreamA.size());
 
276
 
 
277
        List<AbstractProject> downstreamX = graph.getDownstream(mavenModuleX);
 
278
        List<AbstractProject> upstreamX = graph.getUpstream(mavenModuleX);
 
279
 
 
280
        Assert.assertEquals(0, downstreamX.size());
 
281
        Assert.assertEquals(0, upstreamX.size());
 
282
    }
 
283
 
 
284
    private TestComponents createTestComponents(String libraryVersion) {
 
285
        MavenProject appProject = createMavenProject("testapp", "test", "application", "1.0-SNAPSHOT", "jar");
 
286
        Dependency dependency = createDependency("test", "library", libraryVersion);
 
287
        appProject.getDependencies().add(dependency);
 
288
 
 
289
        MavenModule appMavenModule = mockMavenModule(appProject);
 
290
 
 
291
        MavenProject libProject = createLibrary();
 
292
        MavenModule libMavenModule = mockMavenModule(libProject);
 
293
 
 
294
        MavenModuleSet parent = mock(MavenModuleSet.class);
 
295
        when(parent.isAggregatorStyleBuild()).thenReturn(Boolean.FALSE);
 
296
        when(appMavenModule.getParent()).thenReturn(parent);
 
297
        when(libMavenModule.getParent()).thenReturn(parent);
 
298
 
 
299
        Collection<MavenModule> projects = Lists.newArrayList(appMavenModule, libMavenModule);
 
300
        when(parent.getModules()).thenReturn(projects);
 
301
        when(appMavenModule.getAllMavenModules()).thenReturn(projects);
 
302
        when(libMavenModule.getAllMavenModules()).thenReturn(projects);
 
303
 
 
304
        DependencyGraph graph = MockHelper.mockDependencyGraph(Lists.<AbstractProject<?,?>>newArrayList(appMavenModule, libMavenModule));
 
305
        doCallRealMethod().when(graph).getDownstream(Matchers.any(AbstractProject.class));
 
306
        doCallRealMethod().when(graph).getUpstream(Matchers.any(AbstractProject.class));
 
307
 
 
308
        TestComponents testComponents = new TestComponents();
 
309
        testComponents.graph = graph;
 
310
        testComponents.applicationMavenModule = appMavenModule;
 
311
        testComponents.libraryMavenModule = libMavenModule;
 
312
 
 
313
        return testComponents;
 
314
    }
 
315
 
 
316
    private static void enhanceMavenModuleMock(MavenModule module,
 
317
                                                      MavenModuleSet parent,
 
318
                                                      Collection allProjects) {
 
319
        when(module.getParent()).thenReturn(parent);
 
320
        when(module.getAllMavenModules()).thenReturn(allProjects);
 
321
    }
 
322
 
 
323
    private static MavenModule mockMavenModule(MavenProject project) {
 
324
        MavenModule mavenModule = mock(MavenModule.class);
 
325
        when(mavenModule.getName()).thenReturn(project.getName());
 
326
        basicMocking(mavenModule);
 
327
        mavenModule.doSetName(project.getGroupId() + '$' + project.getArtifactId());
 
328
 
 
329
        PomInfo pomInfo = new PomInfo(project, null, "relPath");
 
330
        mavenModule.reconfigure(pomInfo);
 
331
 
 
332
        return mavenModule;
 
333
    }
 
334
 
 
335
    private static MavenProject createMavenProject(String name,
 
336
                                                   String groupId,
 
337
                                                   String artifactId,
 
338
                                                   String version,
 
339
                                                   String packaging) {
 
340
        MavenProject proj = new MavenProject();
 
341
        proj.setName(name);
 
342
        proj.setGroupId(groupId);
 
343
        proj.setArtifactId(artifactId);
 
344
        proj.setVersion(version);
 
345
        proj.setPackaging(packaging);
 
346
 
 
347
        return proj;
 
348
    }
 
349
 
 
350
    private static Dependency createDependency(String groupId, String artifactId, String version) {
 
351
        Dependency dependency = new Dependency();
 
352
        dependency.setGroupId(groupId);
 
353
        dependency.setArtifactId(artifactId);
 
354
        dependency.setVersion(version);
 
355
        return dependency;
 
356
    }
 
357
 
 
358
    private static MavenProject createLibrary() {
 
359
        MavenProject proj = createMavenProject("testlib", "test", "library", "1.0.1-SNAPSHOT", "jar");
 
360
 
 
361
        Dependency dependency = new Dependency();
 
362
        dependency.setArtifactId("log4j");
 
363
        dependency.setGroupId("log4j");
 
364
        dependency.setVersion("1.6.15");
 
365
        proj.getDependencies().add(dependency);
 
366
        return proj;
 
367
    }
 
368
 
 
369
    private static class TestComponents {
 
370
        public DependencyGraph graph;
 
371
        public MavenModule applicationMavenModule;
 
372
        public MavenModule libraryMavenModule;
 
373
    }
129
374
}