Subversion Repositories DevTools

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
7070 dpurdie 1 
package com.erggroup.buildtool.utf;
2 
 
3 
 
4 
import java.sql.SQLException;
5 
import java.util.ArrayList;
6 
import java.util.Iterator;
7 
 
8 
import com.erggroup.buildtool.ripple.BuildFile;
9 
import com.erggroup.buildtool.ripple.BuildFile.BuildFileState;
10 
import com.erggroup.buildtool.ripple.BuildStandard;
11 
import com.erggroup.buildtool.ripple.ReleaseManager;
12 
import com.erggroup.buildtool.ripple.Package;
13 
import com.erggroup.buildtool.ripple.RippleEngine;
14 
import org.slf4j.Logger;
15 
import org.slf4j.LoggerFactory;
16 
import org.junit.AfterClass;
17 
import org.junit.BeforeClass;
18 
import org.junit.After;
19 
import org.junit.Before;
20 
import org.junit.Test;
21 
import org.junit.runner.JUnitCore;
22 
 
23 
import static org.junit.Assert.*;
24 
 
25 
/**
26 
 * container of Build Daemon test methods
27 
 */
28 
public class DaemonBuildTestCase2
29 
{
30 
    private static final Logger mLogger = LoggerFactory.getLogger(DaemonBuildTestCase2.class);
31 
    myReleaseManager            releaseManager = null;
32 
    RippleEngine                rippleEngine   = null;
33 
    ArrayList<Package> testPackageCollection   = new ArrayList<Package>();
34 
 
35 
    /**
36 
     * Init the package set
37 
     */
38 
    public void initTestPackages(String setName)
39 
    {
7071 dpurdie 40 
 
41 
        /*    A basic set of packages
42 
         *    All buildable
43 
         */
44 
         Package  p1 = createPackage(1, setName + "1");
45 
         Package  p2 = createPackage(2, setName + "2");
46 
         Package  p3 = createPackage(3, setName + "3");
47 
         Package  p4 = createPackage(4, setName + "4");
48 
         Package  p5 = createPackage(5, setName + "5");
49 
         Package  p6 = createPackage(6, setName + "6");
50 
         Package  p7 = createPackage(7, setName + "7");
51 
 
52 
         testPackageCollection.add(p1);
53 
         testPackageCollection.add(p2);
54 
         testPackageCollection.add(p3);
55 
         testPackageCollection.add(p4);
56 
         testPackageCollection.add(p5);
57 
         testPackageCollection.add(p6);
58 
         testPackageCollection.add(p7);
59 
 
60 
         p2.addDependency(p1);
61 
         p3.addDependency(p1);
62 
         p4.addDependency(p2).addDependency(p3);
63 
         p5.addDependency(p2).addDependency(p4);
64 
         p6.addDependency(p3).addDependency(p4);
65 
         p7.addDependency(p5).addDependency(p6);
66 
 
7070 dpurdie 67 
    }
68 
 
69 
    /** Create a WIP for a package in the Release
70 
     * This will mark it as directlyPlanned
71 
     * @param newPvId
72 
     * @param alias
73 
     */
74 
    private Package createWip(int newPvId, String alias) {
75 
 
76 
        Package wip = ReleaseManager.NULL_PACKAGE;
77 
 
78 
        for (Iterator<Package> it = testPackageCollection.iterator(); it.hasNext(); )
79 
        {
80 
            Package p = it.next();
81 
 
82 
            if ( p.mAlias.compareTo( alias ) == 0 )
83 
            {
84 
                wip = new Package(newPvId, p);
85 
                wip.mDirectlyPlanned = true;
86 
                testPackageCollection.add(wip);
87 
                break;
88 
            }
89 
        }
90 
        return wip;
91 
    }
92 
 
7071 dpurdie 93 
    /** Create a TEST for a package in the Release
94 
     * This will mark it as test package
95 
     * @param newPvId <0 - use PVID of the base package
96 
     * @param alias
97 
     */
98 
    private Package createTest(int newPvId, String alias) {
99 
 
100 
        Package wip = ReleaseManager.NULL_PACKAGE;
101 
 
102 
        for (Iterator<Package> it = testPackageCollection.iterator(); it.hasNext(); )
103 
        {
104 
            Package p = it.next();
105 
 
106 
            if ( p.mAlias.compareTo( alias ) == 0 )
107 
            {
108 
                if (newPvId < 0 )
109 
                    newPvId = p.mId;
110 
                wip = new Package(newPvId, p);
111 
                wip.mTestBuildInstruction = 1;
112 
                testPackageCollection.add(wip);
113 
                break;
114 
            }
115 
        }
116 
        return wip;
117 
    }
118 
 
119 
    /** Create a RippleRequest for a package in the Release
120 
     * This will mark it as ripple request
121 
     * @param alias
122 
     */
123 
    private Package requestRipple(String alias) {
124 
 
125 
        Package wip = ReleaseManager.NULL_PACKAGE;
126 
 
127 
        for (Iterator<Package> it = testPackageCollection.iterator(); it.hasNext(); )
128 
        {
129 
            Package p = it.next();
130 
 
131 
            if ( p.mAlias.compareTo( alias ) == 0 )
132 
            {
133 
                wip = new Package(p.mId, p);
134 
                wip.mForcedRippleInstruction = 1;
135 
                testPackageCollection.add(wip);
136 
                break;
137 
            }
138 
        }
139 
        return wip;
140 
    }
141 
 
7070 dpurdie 142 
    /** Create a basic package
143 
     *
144 
     */
145 
    private Package createPackage(int idx, String pName) {
146 
        Package  p = new Package(idx, idx * 100, pName, "1.0.0000", ".cr", pName + ".cr" , "CC::/vob/"+pName+".WIP", 'b', 'P');
147 
        BuildStandard bs = new BuildStandard(rippleEngine, "Linux", "Java 1.6");
148 
        p.mBuildStandardCollection.add(bs);
7071 dpurdie 149 
        p.mBuildTime = 100;
7070 dpurdie 150 
        return p;
151 
    }
7071 dpurdie 152 
 
153 
    /** Update build time for a package
154 
     *
155 
     *  @param alias
156 
     *  @param buildTime - Set a new build time
157 
     */
158 
    private Package setBuildTime(String alias, int buildTime) {
7070 dpurdie 159 
 
7071 dpurdie 160 
        Package wip = ReleaseManager.NULL_PACKAGE;
161 
 
162 
        for (Iterator<Package> it = testPackageCollection.iterator(); it.hasNext(); )
163 
        {
164 
            Package p = it.next();
165 
 
166 
            if ( p.mAlias.compareTo( alias ) == 0 )
167 
            {
168 
                p.mBuildTime = buildTime;
169 
                break;
170 
            }
171 
        }
172 
        return wip;
173 
    }
7070 dpurdie 174 
 
7071 dpurdie 175 
    /** Setup a package so that it will be detected as being rippled
176 
     *      Change its pvid so that consumers will see that they need to be rippled
177 
     */
178 
    private Package ripplePackage(String alias) {
179 
 
180 
        Package wip = ReleaseManager.NULL_PACKAGE;
181 
 
182 
        for (Iterator<Package> it = testPackageCollection.iterator(); it.hasNext(); )
183 
        {
184 
            Package p = it.next();
185 
 
186 
            if ( p.mAlias.compareTo( alias ) == 0 )
187 
            {
188 
                p.mId += 10000;
189 
                break;
190 
            }
191 
        }
192 
        return wip;
193 
    }
194 
 
195 
 
7070 dpurdie 196 
 
197 
    /** Subclass and override key methods so that the test can control
198 
     *  the data being used
199 
     */
200 
    public class myReleaseManager extends ReleaseManagerUtf
201 
	{
202 
       public myReleaseManager(final String connectionString, final String username, final String password)
203 
		{
204 
           super(connectionString, username, password);
205 
           mLogger.error("Test {}", connectionString);
206 
		}
207 
 
208 
		public myReleaseManager()
209 
		{
210 
			super();
211 
		}
212 
 
213 
		@Override
214 
		public void queryPackageVersions(RippleEngine rippleEngine, ArrayList<Package> packageCollection, int baseline) throws SQLException, Exception
215 
		{
216 
 
217 
		    //    Filter for the packages that are in the release
218 
		    for (Iterator<Package> it = testPackageCollection.iterator(); it.hasNext(); )
219 
	        {
220 
	            Package p = it.next();
221 
	            if (!p.mDirectlyPlanned && p.mTestBuildInstruction == 0 && p.mForcedRippleInstruction == 0)
222 
	            {
223 
	                p.mIsNotReleased = false;
224 
	                packageCollection.add(p);
225 
	            }
226 
	        }
227 
		}
228 
 
229 
		@Override
230 
        public void queryWips(RippleEngine rippleEngine, ArrayList<Package> packageCollection, int baseline) throws SQLException, Exception
231 
        {
232 
            //    Filter for the packages that are WIPs
233 
            for (Iterator<Package> it = testPackageCollection.iterator(); it.hasNext(); )
234 
            {
235 
                Package p = it.next();
236 
                if (p.mDirectlyPlanned )
237 
                {
238 
                    p.mIsNotReleased = true;
239 
                    p.mDirectlyPlanned = true;
240 
                    p.mBuildReason = BuildReason.NewVersion;
241 
                    packageCollection.add(p);
242 
                }
243 
            }
244 
 
245 
        }
246 
 
247 
		@Override
248 
        public void queryTest(RippleEngine rippleEngine, ArrayList<Package> packageCollection, int baseline) throws SQLException, Exception
249 
        {
250 
		    //    Filter for the packages that are TEST builds
251 
            for (Iterator<Package> it = testPackageCollection.iterator(); it.hasNext(); )
252 
            {
253 
    		    Package p = it.next();
254 
                if (p.mTestBuildInstruction != 0 )
255 
                {
256 
                    p.mIsNotReleased = true;
257 
                    p.mDirectlyPlanned = false;
258 
                    p.mBuildReason = BuildReason.Test;
259 
                    packageCollection.add(p);
260 
                }
261 
            }
262 
        }
263 
 
264 
		@Override
265 
        public void queryRipples(RippleEngine rippleEngine, ArrayList<Package> packageCollection, int baseline) throws SQLException, Exception
266 
        {
267 
		    //    Filter for the packages that are forced Ripples
268 
            for (Iterator<Package> it = testPackageCollection.iterator(); it.hasNext(); )
269 
            {
270 
    		    Package p = it.next();
271 
                if (p.mForcedRippleInstruction != 0)
272 
                {
273 
                    p.mIsNotReleased = true;
274 
                    p.mDirectlyPlanned = false;
275 
                    p.mBuildReason = BuildReason.Ripple;
276 
                    p.mBuildTime = 3;
277 
                    packageCollection.add(p);
278 
                }
279 
            }
280 
        }
281 
 
282 
	}
283 
 
284 
 
285 
    public DaemonBuildTestCase2()
286 
    {
287 
        mLogger.debug("DaemonBuildTestCase2");
288 
    }
289 
 
290 
    /**
291 
     * Test Case main line
292 
     */
293 
    public static void main(String[] args)
294 
    {
295 
        mLogger.debug("main");
296 
        JUnitCore.main("com.erggroup.buildtool.utf.DaemonBuildTestCase2");
297 
    }
298 
 
299 
    /**
300 
     * set up performed prior to any test method
301 
     */
302 
    @BeforeClass
303 
    public static void TestCaseSetUp()
304 
    {
305 
        mLogger.debug("TestCaseSetUp");
306 
    }
307 
 
308 
    /**
309 
     * tear down performed after test methods
310 
     */
311 
    @AfterClass
312 
    public static void TestCaseTearDown()
313 
    {
314 
        mLogger.debug("TestCaseTearDown");
315 
    }
316 
 
317 
    /**
318 
     * set up performed prior to each test method
319 
     */
320 
    @Before
321 
    public void TestSetUp()
322 
    {
323 
        mLogger.debug("TestSetUp");
324 
        System.setProperty("vix.utf.name", "DaemonBuildTestCase2");
325 
        Package.mGenericMachtype = "win32";
326 
        Package.mGbeDpkg = ".";
327 
    }
328 
 
329 
    /**
330 
     * tear down performed after each test method
331 
     */
332 
    @After
333 
    public void TestTearDown()
334 
    {
335 
        mLogger.debug("TestTearDown");
336 
    }
337 
 
7071 dpurdie 338 
    /** Check the build file contents
339 
     *  @param expectedName - Name of the expected output file
340 
     */
341 
    private void checkBuildFile(String expectedName) {
342 
        boolean rv;
343 
        BuildFile buildFile;
344 
 
345 
        buildFile = rippleEngine.getFirstBuildFileContent();
346 
        assertTrue(buildFile != null);
347 
        assertTrue(buildFile.state != BuildFileState.Dummy);
348 
        assertTrue(buildFile.state != BuildFileState.Empty);
349 
 
350 
        rv = Utilities.checkBuildfile(buildFile.content, expectedName);
351 
        assertTrue(rv);
352 
    }
353 
 
7070 dpurdie 354 
    /**
7071 dpurdie 355 
     *  Create a mesh of packages
356 
     *  Ripple the one at the bottom
7070 dpurdie 357 
     */
358 
    @Test
359 
    public void TestPlanRelease_1()
360 
    {
361 
        mLogger.debug("TestPlanRelease - Iteration 1");
362 
        System.out.println("TestPlanRelease - Iteration 1");
363 
        releaseManager = new myReleaseManager("iteration1", "not used", "not used");
364 
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
365 
 
366 
        try
367 
        {
368 
            rippleEngine.collectMetaData();
369 
 
370 
            //  Generate basic test set and then tweak for this test
7071 dpurdie 371 
            initTestPackages("p");
7070 dpurdie 372 
 
373 
            createWip(2000, "p1.cr");
374 
            rippleEngine.planRelease(false);
375 
        }
376 
        catch (Exception e)
377 
        {
378 
        }
379 
 
7071 dpurdie 380 
        checkBuildFile("ripple1");
381 
 
382 
    }
383 
 
384 
    /**
385 
     *  Create a mesh of packages
386 
     *  Ripple the one not at the bottom
387 
     */
388 
    @Test
389 
    public void TestPlanRelease_2()
390 
    {
391 
        mLogger.debug("TestPlanRelease - Iteration 2");
392 
        System.out.println("TestPlanRelease - Iteration 2");
393 
        releaseManager = new myReleaseManager("iteration2", "not used", "not used");
394 
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
395 
 
396 
        try
397 
        {
398 
            rippleEngine.collectMetaData();
399 
 
400 
            //  Generate basic test set and then tweak for this test
401 
            initTestPackages("p");
402 
 
403 
            createWip(2000, "p2.cr");
404 
            rippleEngine.planRelease(false);
405 
        }
406 
        catch (Exception e)
407 
        {
408 
        }
7070 dpurdie 409 
 
7071 dpurdie 410 
        checkBuildFile("ripple2");
411 
    }
7070 dpurdie 412 
 
7078 dpurdie 413 
 
414 
 
7071 dpurdie 415 
    /**
7078 dpurdie 416 
     *  Create a mesh of packages
417 
     *  Create a package that will feed into the mesh
418 
     *  Mark bottom of the mesh as being rippled
419 
     *  Mark create a WIP on the package feeding the mesh such that the additional time < 20%
420 
     *
7071 dpurdie 421 
     */
422 
    @Test
423 
    public void TestPlanRelease_3()
424 
    {
7078 dpurdie 425 
        String tName = "ripple3";
426 
        mLogger.debug("TestPlanRelease {}", tName);
427 
        System.out.println("TestPlanRelease " + tName);
428 
        releaseManager = new myReleaseManager(tName, "not used", "not used");
7071 dpurdie 429 
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
7070 dpurdie 430 
 
7071 dpurdie 431 
        try
432 
        {
433 
            rippleEngine.collectMetaData();
434 
 
435 
            //  Generate basic test set and then tweak for this test
436 
            initTestPackages("p");
437 
 
7078 dpurdie 438 
            Package p1 = ripplePackage("p1.cr");
7071 dpurdie 439 
 
7078 dpurdie 440 
            Package  p0 = createPackage(20, "p0");
441 
            testPackageCollection.add(p0);
442 
            setBuildTime("p0.cr", 10);
443 
            p1.addDependency(p0);
444 
            createWip(21, "p0.cr");
445 
 
7071 dpurdie 446 
            rippleEngine.planRelease(false);
447 
        }
448 
        catch (Exception e)
449 
        {
450 
        }
451 
 
7078 dpurdie 452 
        checkBuildFile(tName);
7070 dpurdie 453 
    }
7071 dpurdie 454 
 
455 
    /**
7078 dpurdie 456 
     *  Create a mesh of packages
457 
     *  Create a package that will feed into the mesh
458 
     *  Mark bottom of the mesh as being rippled
459 
     *  Mark create a WIP on the package feeding the mesh such that the additional time > 20%
460 
     *
7071 dpurdie 461 
     */
462 
    @Test
463 
    public void TestPlanRelease_4()
464 
    {
7078 dpurdie 465 
        String tName = "ripple4";
466 
        mLogger.debug("TestPlanRelease {}", tName);
467 
        System.out.println("TestPlanRelease " + tName);
468 
        releaseManager = new myReleaseManager(tName, "not used", "not used");
7071 dpurdie 469 
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
470 
 
471 
        try
472 
        {
473 
            rippleEngine.collectMetaData();
474 
 
475 
            //  Generate basic test set and then tweak for this test
476 
            initTestPackages("p");
477 
 
7078 dpurdie 478 
            Package p1 = ripplePackage("p1.cr");
7071 dpurdie 479 
 
7078 dpurdie 480 
            Package  p0 = createPackage(20, "p0");
481 
            testPackageCollection.add(p0);
482 
            setBuildTime("p0.cr", 200);
483 
            p1.addDependency(p0);
484 
            createWip(21, "p0.cr");
485 
 
7071 dpurdie 486 
            rippleEngine.planRelease(false);
487 
        }
488 
        catch (Exception e)
489 
        {
490 
        }
7070 dpurdie 491 
 
7078 dpurdie 492 
        checkBuildFile(tName);
493 
    }
494 
 
7070 dpurdie 495 
 
7071 dpurdie 496 
    /**
497 
     *  Create a mesh of packages
498 
     *      Create a test package
499 
     *      Create a WIP
500 
     *      Test should be built first
501 
     */
502 
    @Test
503 
    public void TestPlanRelease_5()
504 
    {
505 
        String tName = "ripple5";
506 
        mLogger.debug("TestPlanRelease {}", tName);
507 
        System.out.println("TestPlanRelease " + tName);
508 
        releaseManager = new myReleaseManager(tName, "not used", "not used");
509 
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
510 
 
511 
        try
512 
        {
513 
            rippleEngine.collectMetaData();
514 
 
515 
            //  Generate basic test set and then tweak for this test
516 
            initTestPackages("p");
517 
 
518 
            createWip (2000, "p1.cr");
519 
            createTest(3333, "p5.cr");
520 
            createTest(-1  , "p4.cr");
521 
            rippleEngine.planRelease(false);
522 
        }
523 
        catch (Exception e)
524 
        {
525 
        }
7070 dpurdie 526 
 
7071 dpurdie 527 
        checkBuildFile(tName);
528 
    }
529 
 
530 
    /**
531 
     *  Create a mesh of packages
532 
     *  Request a ripple (daemon Instruction)
533 
     */
534 
    @Test
535 
    public void TestPlanRelease_6()
536 
    {
537 
        String tName = "ripple6";
538 
        mLogger.debug("TestPlanRelease {}", tName);
539 
        System.out.println("TestPlanRelease " + tName);
540 
        releaseManager = new myReleaseManager(tName, "not used", "not used");
541 
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
542 
 
543 
        try
544 
        {
545 
            rippleEngine.collectMetaData();
546 
 
547 
            //  Generate basic test set and then tweak for this test
548 
            initTestPackages("p");
549 
 
550 
            requestRipple("p5.cr");
551 
            rippleEngine.planRelease(false);
552 
        }
553 
        catch (Exception e)
554 
        {
555 
        }
556 
 
557 
        checkBuildFile(tName);
558 
    }
559 
 
560 
    /**
561 
     * Create a mesh of packages
562 
     * Create a circular dependency
563 
     * Create a WIP to 'fix' the circular dependency
564 
     */
565 
    @Test
566 
    public void TestPlanRelease_7()
567 
    {
568 
        String tName = "ripple7";
569 
        mLogger.debug("TestPlanRelease {}", tName);
570 
        System.out.println("TestPlanRelease " + tName);
571 
        releaseManager = new myReleaseManager(tName, "not used", "not used");
572 
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
573 
 
574 
        try
575 
        {
576 
            rippleEngine.collectMetaData();
577 
 
578 
            //  Generate basic test set and then tweak for this test
579 
            /*    A basic set of packages
580 
             */
581 
             Package  p1 = createPackage(1, "p1");
582 
             Package  p2 = createPackage(2, "p2");
583 
             Package  p3 = createPackage(3, "p3");
584 
             Package  p4 = createPackage(4, "p4");
585 
 
586 
             testPackageCollection.add(p1);
587 
             testPackageCollection.add(p2);
588 
             testPackageCollection.add(p3);
589 
             testPackageCollection.add(p4);
590 
 
591 
             // Create circular dependency
592 
             p2.addDependency(p1);
593 
             p3.addDependency(p2);
594 
             p4.addDependency(p3);
595 
             p1.addDependency(p4);
596 
 
597 
 
598 
             Package  p1fixed = createWip(400, "p1.cr");
599 
             p1fixed.resetDependencies();
600 
             testPackageCollection.add(p1fixed);
601 
 
602 
 
603 
            rippleEngine.planRelease(false);
604 
        }
605 
        catch (Exception e)
606 
        {
607 
        }
608 
 
609 
        checkBuildFile(tName);
610 
    }
611 
 
612 
    /**
613 
     * Create a mesh of packages
614 
     * Create a dependencies
615 
     * Create a WIP to 'create' a circular dependency
616 
     *
7078 dpurdie 617 
     * Should detect that added package will create issue
618 
     *
7071 dpurdie 619 
     */
620 
    @Test
621 
    public void TestPlanRelease_8()
622 
    {
623 
        String tName = "ripple8";
624 
        mLogger.debug("TestPlanRelease {}", tName);
625 
        System.out.println("TestPlanRelease " + tName);
626 
        releaseManager = new myReleaseManager(tName, "not used", "not used");
627 
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
628 
 
629 
        try
630 
        {
631 
            rippleEngine.collectMetaData();
632 
 
633 
            //  Generate basic test set and then tweak for this test
634 
            /*    A basic set of packages
635 
             */
636 
             Package  p1 = createPackage(1, "p1");
637 
             Package  p2 = createPackage(2, "p2");
638 
             Package  p3 = createPackage(3, "p3");
639 
             Package  p4 = createPackage(4, "p4");
640 
 
641 
             testPackageCollection.add(p1);
642 
             testPackageCollection.add(p2);
643 
             testPackageCollection.add(p3);
644 
             testPackageCollection.add(p4);
645 
 
646 
             // Create dependency
647 
             p2.addDependency(p1);
648 
             p3.addDependency(p2);
649 
             p4.addDependency(p3);
650 
 
651 
             Package  p1Broken = createWip(400, "p1.cr");
652 
             p1Broken.resetDependencies().addDependency(p4);
7078 dpurdie 653 
 
654 
          // Create a ripple, so we get some output
655 
             Package  p5 = createPackage(5, "p5");
656 
             testPackageCollection.add(p5);
657 
             requestRipple("p5.cr");
7071 dpurdie 658 
 
659 
            rippleEngine.planRelease(false);
660 
        }
661 
        catch (Exception e)
662 
        {
663 
        }
664 
 
665 
        checkBuildFile(tName);
666 
    }
667 
 
668 
    /**
669 
     * Create a WIP that will fail applyPV
670 
     *      Expect it to be rejected
671 
     *      Expect an email
672 
     */
673 
    @Test
674 
    public void TestPlanRelease_9()
675 
    {
676 
        String tName = "ripple9";
677 
        mLogger.debug("TestPlanRelease {}", tName);
678 
        System.out.println("TestPlanRelease " + tName);
679 
        releaseManager = new myReleaseManager(tName, "not used", "not used");
680 
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
681 
 
682 
        try
683 
        {
684 
            rippleEngine.collectMetaData();
685 
 
686 
            //  Generate basic test set and then tweak for this test
687 
            /*    A basic set of packages
688 
             */
689 
             Package  p1 = createPackage(1, "p1");
690 
             Package  p2 = createPackage(2, "p2");
691 
             Package  p3 = createPackage(3, "p3");
692 
             Package  p4 = createPackage(4, "p4");
693 
 
694 
             testPackageCollection.add(p1);
695 
             testPackageCollection.add(p2);
696 
             testPackageCollection.add(p3);
697 
             testPackageCollection.add(p4);
698 
 
699 
             p2.addDependency(p1);
700 
 
701 
             Package  p1Broken = createWip(400, "p1.cr");
702 
             p1Broken.mVersion = "BadVersion";
703 
 
704 
             // Create a ripple, so we get some output
705 
             requestRipple("p4.cr");
706 
 
707 
            rippleEngine.planRelease(false);
708 
        }
709 
        catch (Exception e)
710 
        {
711 
        }
712 
 
713 
        checkBuildFile(tName);
714 
    }
715 
 
716 
 
717 
    /**
718 
     *  Create a mesh of packages
719 
     *  Mark bottom as being rippled
7078 dpurdie 720 
     *
721 
     *  Expect a single plan with the next two two candidate packages
7071 dpurdie 722 
     */
723 
    @Test
7078 dpurdie 724 
    public void TestPlanRelease_10()
7071 dpurdie 725 
    {
7078 dpurdie 726 
        String tName = "ripple10";
7071 dpurdie 727 
        mLogger.debug("TestPlanRelease {}", tName);
728 
        System.out.println("TestPlanRelease " + tName);
729 
        releaseManager = new myReleaseManager(tName, "not used", "not used");
730 
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
731 
 
732 
        try
733 
        {
734 
            rippleEngine.collectMetaData();
735 
 
736 
            //  Generate basic test set and then tweak for this test
737 
            initTestPackages("p");
738 
 
739 
            ripplePackage("p1.cr");
740 
            rippleEngine.planRelease(false);
741 
        }
742 
        catch (Exception e)
743 
        {
744 
        }
745 
 
746 
        checkBuildFile(tName);
747 
    }
7078 dpurdie 748 
 
749 
    /**
750 
     *  Create two meshes of packages
751 
     *  Create a ripple in both
752 
     */
753 
    @Test
754 
    public void TestPlanRelease_11()
755 
    {
756 
        String tName = "ripple11";
757 
        mLogger.debug("TestPlanRelease {}", tName);
758 
        System.out.println("TestPlanRelease " + tName);
759 
        releaseManager = new myReleaseManager(tName, "not used", "not used");
760 
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
761 
 
762 
        try
763 
        {
764 
            rippleEngine.collectMetaData();
765 
 
766 
            //  Generate basic test set and then tweak for this test
767 
            initTestPackages("p");
768 
            initTestPackages("z");
769 
            setBuildTime("z4.cr", 200);
770 
 
771 
            createWip(2000, "p1.cr");
772 
            createWip(2000, "z1.cr");
773 
 
774 
            rippleEngine.planRelease(false);
775 
        }
776 
        catch (Exception e)
777 
        {
778 
        }
7071 dpurdie 779 
 
7078 dpurdie 780 
        checkBuildFile(tName);
781 
    }
782 
 
783 
    /**
784 
     *  Create a simple dependency chain
785 
     *  Mark one of the packages as an SDK
786 
     *  Ensure that a ripple will not affect the SDK package
787 
     *
788 
     */
789 
    @Test
790 
    public void TestPlanRelease_12()
791 
    {
792 
        String tName = "ripple12";
793 
        mLogger.debug("TestPlanRelease {}", tName);
794 
        System.out.println("TestPlanRelease " + tName);
795 
        releaseManager = new myReleaseManager(tName, "not used", "not used");
796 
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
797 
 
798 
        try
799 
        {
800 
            rippleEngine.collectMetaData();
801 
 
802 
            /*    A basic set of packages
803 
             */
804 
             Package  p1 = createPackage(1, "p1");
805 
             Package  p2 = createPackage(2, "p2");
806 
             Package  p3 = createPackage(3, "p3");
807 
             Package  p4 = createPackage(4, "p4");
808 
             Package  p5 = createPackage(4, "p5");
809 
 
810 
             testPackageCollection.add(p1);
811 
             testPackageCollection.add(p2);
812 
             testPackageCollection.add(p3);
813 
             testPackageCollection.add(p4);
814 
             testPackageCollection.add(p5);
815 
 
816 
             p2.addDependency(p1);
817 
             p3.addDependency(p1);
818 
             p4.addDependency(p3).addDependency(p2);
819 
             p5.addDependency(p3);
820 
 
821 
             // Mark SDK
822 
             p3.mIsSdk = true;
823 
 
824 
             // Create a ripple, so we get some output
825 
             requestRipple("p1.cr");
826 
 
827 
            rippleEngine.planRelease(false);
828 
        }
829 
        catch (Exception e)
830 
        {
831 
        }
832 
 
833 
        checkBuildFile(tName);
834 
    }
835 
 
836 
    /**
837 
     *  Create a simple dependency chain
838 
     *  Mark one of the packages as having a rippleStop
839 
     *  Ensure that a ripple will not affect the SDK package
840 
     *
841 
     */
842 
    @Test
843 
    public void TestPlanRelease_13()
844 
    {
845 
        String tName = "ripple13";
846 
        mLogger.debug("TestPlanRelease {}", tName);
847 
        System.out.println("TestPlanRelease " + tName);
848 
        releaseManager = new myReleaseManager(tName, "not used", "not used");
849 
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
850 
 
851 
        try
852 
        {
853 
            rippleEngine.collectMetaData();
854 
 
855 
            /*    A basic set of packages
856 
             */
857 
             Package  p1 = createPackage(1, "p1");
858 
             Package  p2 = createPackage(2, "p2");
859 
             Package  p3 = createPackage(3, "p3");
860 
             Package  p4 = createPackage(4, "p4");
861 
             Package  p5 = createPackage(4, "p5");
862 
 
863 
             testPackageCollection.add(p1);
864 
             testPackageCollection.add(p2);
865 
             testPackageCollection.add(p3);
866 
             testPackageCollection.add(p4);
867 
             testPackageCollection.add(p5);
868 
 
869 
             p2.addDependency(p1);
870 
             p3.addDependency(p1);
871 
             p4.addDependency(p3).addDependency(p2);
872 
             p5.addDependency(p3);
873 
 
874 
             // Mark SDK
875 
             p3.mRippleStop = 's';
876 
 
877 
             // Create a ripple, so we get some output
878 
             requestRipple("p1.cr");
879 
 
880 
            rippleEngine.planRelease(false);
881 
        }
882 
        catch (Exception e)
883 
        {
884 
        }
885 
 
886 
        checkBuildFile(tName);
887 
    }
888 
 
7070 dpurdie 889 
}