View Javadoc

1   package org.apache.maven.shared.dependency.tree.traversal;
2   
3   /*
4    * Licensed to the Apache Software Foundation (ASF) under one
5    * or more contributor license agreements.  See the NOTICE file
6    * distributed with this work for additional information
7    * regarding copyright ownership.  The ASF licenses this file
8    * to you under the Apache License, Version 2.0 (the
9    * "License"); you may not use this file except in compliance
10   * with the License.  You may obtain a copy of the License at
11   *
12   *  http://www.apache.org/licenses/LICENSE-2.0
13   *
14   * Unless required by applicable law or agreed to in writing,
15   * software distributed under the License is distributed on an
16   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
17   * KIND, either express or implied.  See the License for the
18   * specific language governing permissions and limitations
19   * under the License.
20   */
21  
22  import org.apache.maven.shared.dependency.tree.AbstractDependencyNodeTest;
23  import org.apache.maven.shared.dependency.tree.DependencyNode;
24  import org.jmock.Mock;
25  
26  /**
27   * Tests <code>BuildingDependencyNodeVisitor</code>.
28   * 
29   * @author <a href="mailto:markhobson@gmail.com">Mark Hobson</a>
30   * @version $Id: BuildingDependencyNodeVisitorTest.java 1100703 2011-05-08 08:27:33Z hboutemy $
31   * @see BuildingDependencyNodeVisitor
32   */
33  public class BuildingDependencyNodeVisitorTest
34      extends AbstractDependencyNodeTest
35  {
36      // fields -----------------------------------------------------------------
37  
38      private BuildingDependencyNodeVisitor visitor;
39  
40      // tests ------------------------------------------------------------------
41  
42      public void testVisitNode()
43      {
44          DependencyNode sourceNode = createNode( "g:a:t:1" );
45  
46          visitor = new BuildingDependencyNodeVisitor();
47          visitor.visit( sourceNode );
48          visitor.endVisit( sourceNode );
49  
50          DependencyNode resultNode = visitor.getDependencyTree();
51          assertNotSame( sourceNode, resultNode );
52          assertEquals( sourceNode, resultNode );
53      }
54  
55      public void testVisitNodeWithState()
56      {
57          DependencyNode sourceNode = createNode( "g:a:t:1", DependencyNode.OMITTED_FOR_CYCLE );
58  
59          visitor = new BuildingDependencyNodeVisitor();
60          visitor.visit( sourceNode );
61          visitor.endVisit( sourceNode );
62  
63          DependencyNode resultNode = visitor.getDependencyTree();
64          assertNotSame( sourceNode, resultNode );
65          assertEquals( sourceNode, resultNode );
66      }
67  
68      public void testVisitNodeWithRelatedArtifact()
69      {
70          DependencyNode sourceNode = createNode( "g:a:t:1", DependencyNode.OMITTED_FOR_CONFLICT, "g:a:t:2" );
71  
72          visitor = new BuildingDependencyNodeVisitor();
73          visitor.visit( sourceNode );
74          visitor.endVisit( sourceNode );
75  
76          DependencyNode resultNode = visitor.getDependencyTree();
77          assertNotSame( sourceNode, resultNode );
78          assertEquals( sourceNode, resultNode );
79      }
80  
81      public void testVisitNodeWithOriginalScope()
82      {
83          DependencyNode sourceNode = createNode( "g:a:t:1" );
84          sourceNode.setOriginalScope( "x" );
85  
86          visitor = new BuildingDependencyNodeVisitor();
87          visitor.visit( sourceNode );
88          visitor.endVisit( sourceNode );
89  
90          DependencyNode resultNode = visitor.getDependencyTree();
91          assertNotSame( sourceNode, resultNode );
92          assertEquals( sourceNode, resultNode );
93      }
94  
95      public void testVisitNodeWithFailedUpdateScope()
96      {
97          DependencyNode sourceNode = createNode( "g:a:t:1" );
98          sourceNode.setFailedUpdateScope( "x" );
99  
100         visitor = new BuildingDependencyNodeVisitor();
101         visitor.visit( sourceNode );
102         visitor.endVisit( sourceNode );
103 
104         DependencyNode resultNode = visitor.getDependencyTree();
105         assertNotSame( sourceNode, resultNode );
106         assertEquals( sourceNode, resultNode );
107     }
108 
109     public void testVisitNodeWithPremanagedVersion()
110     {
111         DependencyNode sourceNode = createNode( "g:a:t:1" );
112         sourceNode.setPremanagedVersion( "2" );
113 
114         visitor = new BuildingDependencyNodeVisitor();
115         visitor.visit( sourceNode );
116         visitor.endVisit( sourceNode );
117 
118         DependencyNode resultNode = visitor.getDependencyTree();
119         assertNotSame( sourceNode, resultNode );
120         assertEquals( sourceNode, resultNode );
121     }
122 
123     public void testVisitNodeWithPremanagedScope()
124     {
125         DependencyNode sourceNode = createNode( "g:a:t:1" );
126         sourceNode.setPremanagedScope( "x" );
127 
128         visitor = new BuildingDependencyNodeVisitor();
129         visitor.visit( sourceNode );
130         visitor.endVisit( sourceNode );
131 
132         DependencyNode resultNode = visitor.getDependencyTree();
133         assertNotSame( sourceNode, resultNode );
134         assertEquals( sourceNode, resultNode );
135     }
136 
137     public void testVisitNodeWithChild()
138     {
139         DependencyNode sourceNode = createNode( "g:a:t:1" );
140         DependencyNode sourceChildNode = createNode( "g:b:t:1" );
141         sourceNode.addChild( sourceChildNode );
142 
143         visitor = new BuildingDependencyNodeVisitor();
144         visitor.visit( sourceNode );
145         visitor.visit( sourceChildNode );
146         visitor.endVisit( sourceChildNode );
147         visitor.endVisit( sourceNode );
148 
149         DependencyNode resultNode = visitor.getDependencyTree();
150         assertNotSame( sourceNode, resultNode );
151         assertEquals( sourceNode, resultNode );
152     }
153 
154     public void testVisitNodeWithVisitor()
155     {
156         DependencyNode sourceNode = createNode( "g:a:t:1" );
157 
158         Mock nextVisitorMock = mock( DependencyNodeVisitor.class );
159         nextVisitorMock.expects( once() ).method( "visit" ).with( eq( sourceNode ) ).will( returnValue( true ) ).id( "1" );
160         nextVisitorMock.expects( once() ).method( "endVisit" ).with( eq( sourceNode ) ).after( "1" ).will( returnValue( true ) );
161         DependencyNodeVisitor nextVisitor = (DependencyNodeVisitor) nextVisitorMock.proxy();
162 
163         visitor = new BuildingDependencyNodeVisitor( nextVisitor );
164         visitor.visit( sourceNode );
165         visitor.endVisit( sourceNode );
166 
167         DependencyNode resultNode = visitor.getDependencyTree();
168         assertNotSame( sourceNode, resultNode );
169         assertEquals( sourceNode, resultNode );
170     }
171 
172     public void testVisitNodeWithChildAndVisitor()
173     {
174         DependencyNode sourceNode = createNode( "g:a:t:1" );
175         DependencyNode sourceChildNode = createNode( "g:b:t:1" );
176         sourceNode.addChild( sourceChildNode );
177 
178         Mock nextVisitorMock = mock( DependencyNodeVisitor.class );
179         nextVisitorMock.expects( once() ).method( "visit" ).with( eq( sourceNode ) ).will( returnValue( true ) ).id( "1" );
180         nextVisitorMock.expects( once() ).method( "visit" ).with( eq( sourceChildNode ) ).after( "1" ).will( returnValue( true ) ).id( "2" );
181         nextVisitorMock.expects( once() ).method( "endVisit" ).with( eq( sourceChildNode ) ).after( "2" ).will( returnValue( true ) ).id( "3" );
182         nextVisitorMock.expects( once() ).method( "endVisit" ).with( eq( sourceNode ) ).after( "3" ).will( returnValue( true ) );
183         DependencyNodeVisitor nextVisitor = (DependencyNodeVisitor) nextVisitorMock.proxy();
184 
185         visitor = new BuildingDependencyNodeVisitor( nextVisitor );
186         visitor.visit( sourceNode );
187         visitor.visit( sourceChildNode );
188         visitor.endVisit( sourceChildNode );
189         visitor.endVisit( sourceNode );
190 
191         DependencyNode resultNode = visitor.getDependencyTree();
192         assertNotSame( sourceNode, resultNode );
193         assertEquals( sourceNode, resultNode );
194     }
195 }