Subversion Repositories DevTools

package com.erggroup.buildtool.utf;


import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;

import com.erggroup.buildtool.daemon.BuildDaemon;
import com.erggroup.buildtool.daemon.BuildThread;
import com.erggroup.buildtool.daemon.MasterThread;
import com.erggroup.buildtool.daemon.SlaveThread;
import com.erggroup.buildtool.ripple.BuildFile;
import com.erggroup.buildtool.ripple.BuildFile.BuildFileState;
import com.erggroup.buildtool.ripple.BuildStandard;
import com.erggroup.buildtool.ripple.ReleaseConfig;
import com.erggroup.buildtool.ripple.ReleaseManager;
import com.erggroup.buildtool.ripple.Package;
import com.erggroup.buildtool.ripple.RippleEngine;
import com.erggroup.buildtool.ripple.RunLevelData;
import com.erggroup.buildtool.ripple.RunLevel.BuildState;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.JUnitCore;

import static org.junit.Assert.*;

/**
 * container of Build Daemon test methods
 */
public class DaemonBuildTestCase2
{
    private static final Logger mLogger = LoggerFactory.getLogger(DaemonBuildTestCase2.class);
    myReleaseManager            releaseManager = null;
    RippleEngine                rippleEngine   = null;
    ArrayList<Package> testPackageCollection   = new ArrayList<Package>();
    
    /**
     * Init the package set
     */
    public void initTestPackages(String setName)
    {
        releaseManager.initTestPackages(rippleEngine, testPackageCollection, setName);
    }

    /** Create a WIP for a package in the Release
     * This will mark it as directlyPlanned
     * @param newPvId
     * @param alias
     */
    private Package createWip(int newPvId, String alias) {

        Package wip = ReleaseManager.NULL_PACKAGE;

        for (Iterator<Package> it = testPackageCollection.iterator(); it.hasNext(); )
        {
            Package p = it.next();

            if ( p.mAlias.compareTo( alias ) == 0 )
            {
                wip = new Package(newPvId, p);
                wip.mDirectlyPlanned = true;
                testPackageCollection.add(wip);
                break;
            }
        }
        return wip;
    }
    
    /** Create a basic package
     * 
     */
    private Package createPackage(int idx, String pName) {
        Package  p = new Package(idx, idx * 100, pName, "1.0.0000", ".cr", pName + ".cr" , "CC::/vob/"+pName+".WIP", 'b', 'P');
        BuildStandard bs = new BuildStandard(rippleEngine, "Linux", "Java 1.6");
        p.mBuildStandardCollection.add(bs);
        return p;
    }

    
       
    /** Subclass and override key methods so that the test can control
     *  the data being used
     */
    public class myReleaseManager extends ReleaseManagerUtf
        {
       public myReleaseManager(final String connectionString, final String username, final String password)
                {
           super(connectionString, username, password);
           mLogger.error("Test {}", connectionString);
                }

                public myReleaseManager()
                {
                        super();
                }
                
                @Override
                public void queryPackageVersions(RippleEngine rippleEngine, ArrayList<Package> packageCollection, int baseline) throws SQLException, Exception
                {
                 
                    //    Filter for the packages that are in the release
                    for (Iterator<Package> it = testPackageCollection.iterator(); it.hasNext(); )
                {
                    Package p = it.next();
                    if (!p.mDirectlyPlanned && p.mTestBuildInstruction == 0 && p.mForcedRippleInstruction == 0)
                    {
                        p.mIsNotReleased = false;
                        p.mBuildTime = 90;
                        packageCollection.add(p);
                    }
                }
                }
                
                @Override
        public void queryWips(RippleEngine rippleEngine, ArrayList<Package> packageCollection, int baseline) throws SQLException, Exception
        {
            //    Filter for the packages that are WIPs
            for (Iterator<Package> it = testPackageCollection.iterator(); it.hasNext(); )
            {
                Package p = it.next();
                if (p.mDirectlyPlanned )
                {
                    p.mIsNotReleased = true;
                    p.mDirectlyPlanned = true;
                    p.mBuildReason = BuildReason.NewVersion;
                    p.mBuildTime = 100;
                    packageCollection.add(p);
                }
            }

        }
                
                @Override
        public void queryTest(RippleEngine rippleEngine, ArrayList<Package> packageCollection, int baseline) throws SQLException, Exception
        {
                    //    Filter for the packages that are TEST builds
            for (Iterator<Package> it = testPackageCollection.iterator(); it.hasNext(); )
            {
                    Package p = it.next();
                if (p.mTestBuildInstruction != 0 )
                {
                    p.mIsNotReleased = true;
                    p.mDirectlyPlanned = false;
                    p.mBuildReason = BuildReason.Test;
                    packageCollection.add(p);
                }
            }
        }
                
                @Override
        public void queryRipples(RippleEngine rippleEngine, ArrayList<Package> packageCollection, int baseline) throws SQLException, Exception
        {
                    //    Filter for the packages that are forced Ripples
            for (Iterator<Package> it = testPackageCollection.iterator(); it.hasNext(); )
            {               
                    Package p = it.next();
                if (p.mForcedRippleInstruction != 0)
                {
                    p.mIsNotReleased = true;
                    p.mDirectlyPlanned = false;
                    p.mBuildReason = BuildReason.Ripple;
                    p.mBuildTime = 3;
                    packageCollection.add(p);
                } 
            }
        }
                
                 
                 /** Build a single package collection
                     * It will be split up when requested by the classes under test 
                     * 
                     * @param packageCollection
                     */
                    private void initTestPackages(RippleEngine rippleEngine, ArrayList<Package> packageCollection, String setName)
                    {
                        packageCollection.clear();
                        
                        /*    A basic set of packages
                         *    All buildable
                         */
                 Package  p1 = createPackage(1, "p1");
                 Package  p2 = createPackage(2, "p2");
                 Package  p3 = createPackage(3, "p3");
                 Package  p4 = createPackage(4, "p4");
                 Package  p5 = createPackage(5, "p5");
                 Package  p6 = createPackage(6, "p6");
                 Package  p7 = createPackage(7, "p7");
                 
                 packageCollection.add(p1);
                 packageCollection.add(p2);
                 packageCollection.add(p3);
                 packageCollection.add(p4);
                 packageCollection.add(p5);
                 packageCollection.add(p6);
                 packageCollection.add(p7);
                 
                 
                 p2.addDependency(p1);
                 p3.addDependency(p1);
                 p4.addDependency(p2).addDependency(p3);
                 p5.addDependency(p2).addDependency(p4);
                 p6.addDependency(p3).addDependency(p4);
                 p7.addDependency(p5).addDependency(p6);
                
                    }
                 
        }


    public DaemonBuildTestCase2()
    {
        mLogger.debug("DaemonBuildTestCase2");
    }

    /**
     * Test Case main line
     */
    public static void main(String[] args)
    {
        mLogger.debug("main");
        JUnitCore.main("com.erggroup.buildtool.utf.DaemonBuildTestCase2");
    }

    /**
     * set up performed prior to any test method
     */
    @BeforeClass
    public static void TestCaseSetUp()
    {
        mLogger.debug("TestCaseSetUp");
    }

    /**
     * tear down performed after test methods
     */
    @AfterClass
    public static void TestCaseTearDown()
    {
        mLogger.debug("TestCaseTearDown");
    }

    /**
     * set up performed prior to each test method
     */
    @Before
    public void TestSetUp()
    {
        mLogger.debug("TestSetUp");
        System.setProperty("vix.utf.name", "DaemonBuildTestCase2");
        Package.mGenericMachtype = "win32";
        Package.mGbeDpkg = ".";
    }

    /**
     * tear down performed after each test method
     */
    @After
    public void TestTearDown()
    {
        mLogger.debug("TestTearDown");
    }

    /**
     * I'm guessing as to the function of this test
     * Test for:
     *      Circular dependencies
     *      Build Dependency not in the release
     *      Package has no build environment
     *      Package not built for configured platforms
     *      A package is selected to be built
     * 
     */
    @Test
    public void TestPlanRelease_1()
    {
        mLogger.debug("TestPlanRelease - Iteration 1");
        System.out.println("TestPlanRelease - Iteration 1");
        releaseManager = new myReleaseManager("iteration1", "not used", "not used");
        rippleEngine = new RippleEngine(releaseManager, 11111, true);
        
        try
        {
            rippleEngine.collectMetaData();
            
            //  Generate basic test set and then tweak for this test
            initTestPackages(releaseManager.mConnectionString);
            
            createWip(2000, "p1.cr");
            rippleEngine.planRelease(false);
        }
        catch (Exception e)
        {
        }

        boolean rv;
        BuildFile buildFile;

        buildFile = rippleEngine.getFirstBuildFileContent();
        assertTrue(buildFile != null);
        assertTrue(buildFile.state != BuildFileState.Dummy);
        assertTrue(buildFile.state != BuildFileState.Empty);

        rv = Utilities.checkBuildfile(buildFile.content, "ripple1");
        assertTrue(rv);
        
        buildFile = rippleEngine.getNextBuildFileContent();
        assertTrue(buildFile != null);
        assertTrue(buildFile.state == BuildFileState.Empty);
    }



}