Exemple #1
0
    def testDeprecatedProduct(self):
        prod = Product(Eups(), "newprod", noInit=True)
        self.assert_(prod is not None)
        self.assert_(newerr.getvalue().find("deprecated") >= 0)

        self.assertEqual(prod.envarDirName(), "NEWPROD_DIR")
        self.assertEqual(prod.envarSetupName(), "SETUP_NEWPROD")
Exemple #2
0
    def testGetVersions(self):
        vers = self.stack.getVersions("afw")
        self.assertEquals(len(vers), 0)

        vers = self.stack.getVersions("fw")
        self.assertEquals(len(vers), 1)
        self.assertEquals(vers[0], '1.2')

        self.stack.addProduct(Product("fw", "1.3", "Linux", 
                                      "/opt/sw/Linux/fw/1.3", "none"))
        vers = self.stack.getVersions("fw")
        self.assertEquals(len(vers), 2)
        expected = "1.2 1.3".split()
        for ver in expected:
            self.assert_(ver in vers)

        vers = self.stack.getVersions("fw", "Linux")
        self.assertEquals(len(vers), 1)
        self.assertEquals(vers[0], '1.3')

        self.stack.addProduct(Product("fw", "1.2", "Linux", 
                                      "/opt/sw/Linux/fw/1.2", "none"))
        vers = self.stack.getVersions("fw")
        self.assertEquals(len(vers), 2)
        for ver in expected:
            self.assert_(ver in vers)
        vers = self.stack.getVersions("fw", "Linux")
        self.assertEquals(len(vers), 2)
        for ver in expected:
            self.assert_(ver in vers)
Exemple #3
0
    def makeProduct(self, flavor, eupsPathDir=None, dbpath=None):
        """
        create a Product instance for the given flavor.  If the product has 
        not been declared for the flavor, a  ProductNotFound exception is 
        raised.

        @param flavor      : the desired flavor for the Product.  
        @param eupsPathDir : the product stack path to assume that product is 
                             installed under.  If the product install directory
                             is a relative path (product.dir), this eupsPathDir 
                             will be prepended in the output.  If None, no 
                             alterations of the product install directory will 
                             be done.
        @param dbpath      : the product database directory to store into 
                             the output product.db attribute.  If None, it will 
                             default to eupsPathDir/ups_db; if eupsPathDir is 
                             None, the product.db field will not be set.
        @return Product : a Product instance representing the product data
        """
        if flavor not in self.info:
            raise ProductNotFound(self.name, self.version, flavor)

        if eupsPathDir and not dbpath:
            dbpath = os.path.join(eupsPathDir, "ups_db")

        info = self.info[flavor]
        out = Product(self.name, self.version, flavor, 
                      info.get("productDir"), info.get("table_file"), 
                      db=dbpath, ups_dir=info.get("ups_dir"))
        out.resolvePaths()

        return out
Exemple #4
0
    def testAddProduct(self):
        self.assertRaises(TypeError, 
                          self.stack.addProduct, "fw", "1.2", "Linux")
        self.assertRaises(TypeError, self.stack.addProduct, "fw")
        prod = Product("fw", "1.2")
        self.assertRaises(UnderSpecifiedProduct, self.stack.addProduct, prod)

        prod = Product("afw", "1.2", "Darwin", "/opt/sw/Darwin/afw/1.2", "none")
        self.stack.addProduct(prod)
        self.assert_(self.stack.hasProduct("afw"))
        p = self.stack.getProduct("afw", "1.2", "Darwin")
        self.assertEquals(p.name, prod.name)
        self.assertEquals(p.version, prod.version)
        self.assertEquals(p.flavor, prod.flavor)
        self.assertEquals(p.dir, prod.dir)
        self.assertEquals(p.tablefile, prod.tablefile)
        self.assertEquals(p.db, os.path.join(testEupsStack, "ups_db"))
        self.assertEquals(len(p.tags), 0)

        self.assertRaises(ProductNotFound, 
                          self.stack.getProduct, "afw", "1.2", "Linux")
        self.assertRaises(ProductNotFound, 
                          self.stack.getProduct, "afw", "1.3", "Darwin")

        self.stack.removeProduct("afw", "Darwin", "1.2")
        self.assert_(not self.stack.hasProduct("afw"))
        self.assert_(not self.stack.removeProduct("afw", "Darwin", "1.2"))
Exemple #5
0
    def getProduct(self, version, dbpath=None, flavor=None):
        """
        return the Product of the requested version or None if not found.
        This returned Product's db attribute will be set to None.

        @param version : the desired version
        @param dbpath    a database path to set on the returned product
        @param flavor    a platform flavor to set on the returned product
        @return    the product description as a Product instance
        """
        try:
            versdata = self.versions[version]
            tags = map(lambda item: item[0],
                       filter(lambda x: x[1] == version, self.tags.items()))
            out = Product(
                self.name,
                version,
                flavor,
                versdata[0],  # the install directory
                versdata[1],  # the table file
                tags,
                dbpath)
            if versdata[2]:
                out._table = versdata[2]
            return out

        except KeyError:
            raise ProductNotFound(self.name, version)
Exemple #6
0
    def makeProduct(self, flavor, eupsPathDir=None, dbpath=None):
        """
        create a Product instance for the given flavor.  If the product has
        not been declared for the flavor, a  ProductNotFound exception is
        raised.

        @param flavor      : the desired flavor for the Product.
        @param eupsPathDir : the product stack path to assume that product is
                             installed under.  If the product install directory
                             is a relative path (product.dir), this eupsPathDir
                             will be prepended in the output.  If None, no
                             alterations of the product install directory will
                             be done.
        @param dbpath      : the product database directory to store into
                             the output product.db attribute.  If None, it will
                             default to eupsPathDir/ups_db; if eupsPathDir is
                             None, the product.db field will not be set.
        @return Product : a Product instance representing the product data
        """
        if flavor not in self.info:
            raise ProductNotFound(self.name, self.version, flavor)

        if eupsPathDir and not dbpath:
            dbpath = os.path.join(eupsPathDir, "ups_db")

        info = self.info[flavor]
        out = Product(self.name, self.version, flavor,
                      info.get("productDir"), info.get("table_file"),
                      db=dbpath, ups_dir=info.get("ups_dir"))
        out.resolvePaths()

        return out
Exemple #7
0
class ProductTestCase(unittest.TestCase):
    """test the Product container class"""
    def setUp(self):
        self.prod = Product("eups", "1.0", dir=testEupsStack)

    def testToString(self):
        self.assertEqual(str(self.prod), "Product: eups 1.0")

    def testInit(self):
        self.assertEqual(self.prod.name, "eups")
        self.assertEqual(self.prod.version, "1.0")
        self.assertEqual(self.prod.dir, testEupsStack)
        self.assert_(self.prod.db is None)
        self.assert_(self.prod._table is None)
        self.assert_(self.prod.tablefile is None)
        self.assert_(self.prod._prodStack is None)

        db = os.path.join(os.environ["PWD"], "ups_db")
        p = Product("eups",
                    "1.0",
                    dir=os.environ["PWD"],
                    tags="stable mine".split(),
                    db=db)
        self.assertEqual(p.db, db)
        self.assertEqual(len(p.tags), 2)
        self.assertIn("stable", p.tags)
        self.assertIn("mine", p.tags)

    def testStackRoot(self):
        self.assert_(self.prod.stackRoot() is None)
        self.prod.db = os.path.join(self.prod.dir, "ups_db")
        self.assertEqual(self.prod.stackRoot(), self.prod.dir)

    def testTableFileName(self):
        path = self.prod.tableFileName()
        self.assertEqual(path, os.path.join(testEupsStack, "ups",
                                            "eups.table"))

        self.prod.tablefile = "none"
        self.assert_(self.prod.tableFileName() is None)

        self.prod.tablefile = "/tmp/eups.table"
        self.assertEqual(self.prod.tableFileName(), "/tmp/eups.table")

    def testTableFileName2(self):
        self.prod.name = None
        self.assert_(self.prod.tableFileName() is None)

    def testTableFileName3(self):
        self.prod.dir = None
        self.assert_(self.prod.tableFileName() is None)
        self.prod.dir = "none"
        self.assert_(self.prod.tableFileName() is None)

    def testGetTable(self):
        self.assertRaises(TableFileNotFound, self.prod.getTable)

    def tearDown(self):
        if os.path.exists("test_product.pickle"):
            os.remove("test_product.pickle")
Exemple #8
0
    def testDetectOutOfSync(self):
        ps1 = ProductStack.fromCache(self.dbpath, "Linux", autosave=False, 
                                     updateCache=True, verbose=1)
        ps2 = ProductStack.fromCache(self.dbpath, "Linux", autosave=False, 
                                     updateCache=True, verbose=1)
        time.sleep(1)
        ps1.addProduct(Product("fw", "1.2", "Linux", 
                               "/opt/sw/Darwin/fw/1.2", "none"))
        self.assert_(ps1.cacheIsInSync())
        ps1.save()
        self.assert_(ps1.cacheIsInSync())

        self.assert_(not ps2.cacheIsInSync())
        ps2.addProduct(Product("fw", "1.2", "Linux", 
                               "/opt/sw/Darwin/fw/1.2", "none"))
        self.assertRaises(CacheOutOfSync, ps2.save)
class ProductTestCase(unittest.TestCase):
    """test the Product container class"""

    def setUp(self):
        self.prod = Product("eups", "1.0", dir=testEupsStack)

    def testToString(self):
        self.assertEqual(str(self.prod), "Product: eups 1.0")

    def testInit(self):
        self.assertEqual(self.prod.name, "eups")
        self.assertEqual(self.prod.version, "1.0")
        self.assertEqual(self.prod.dir, testEupsStack)
        self.assert_(self.prod.db is None)
        self.assert_(self.prod._table is None)
        self.assert_(self.prod.tablefile is None)
        self.assert_(self.prod._prodStack is None)

        db = os.path.join(os.environ["PWD"], "ups_db")
        p = Product("eups", "1.0", dir=os.environ["PWD"],
                    tags="stable mine".split(), db=db)
        self.assertEqual(p.db, db)
        self.assertEqual(len(p.tags), 2)
        self.assertIn("stable", p.tags)
        self.assertIn("mine", p.tags)

    def testStackRoot(self):
        self.assert_(self.prod.stackRoot() is None)
        self.prod.db = os.path.join(self.prod.dir, "ups_db")
        self.assertEqual(self.prod.stackRoot(), self.prod.dir)

    def testTableFileName(self):
        path = self.prod.tableFileName()
        self.assertEqual(path, os.path.join(testEupsStack,"ups","eups.table"))

        self.prod.tablefile = "none"
        self.assert_(self.prod.tableFileName() is None)

        self.prod.tablefile = "/tmp/eups.table"
        self.assertEqual(self.prod.tableFileName(), "/tmp/eups.table")

    def testTableFileName2(self):
        self.prod.name = None
        self.assert_(self.prod.tableFileName() is None)

    def testTableFileName3(self):
        self.prod.dir = None
        self.assert_(self.prod.tableFileName() is None)
        self.prod.dir = "none"
        self.assert_(self.prod.tableFileName() is None)

    def testGetTable(self):
        self.assertRaises(TableFileNotFound, self.prod.getTable)

    def tearDown(self):
        if os.path.exists("test_product.pickle"):
            os.remove("test_product.pickle")
Exemple #10
0
    def testLoadTables(self):
        tablefile = os.path.join(testEupsStack,"mwi.table")
        prod = Product("afw", "1.2", "Darwin", "/opt/sw/Darwin/afw/1.2", 
                       tablefile)
        self.stack.addProduct(prod)

        self.stack.loadTables()
        prod = self.stack.getProduct("afw", "1.2", "Darwin")
        self.assert_(prod._table is not None)
Exemple #11
0
 def testGetFlavors(self):
     flavors = self.stack.getFlavors()
     self.assertEquals(len(flavors), 1)
     self.assertEquals(flavors[0], "Darwin")
     prod = Product("afw", "1.2", "Linux", "/opt/sw/Linux/afw/1.2", "none")
     self.stack.addProduct(prod)
     flavors = self.stack.getFlavors()
     self.assertEquals(len(flavors), 2)
     expected = "Darwin Linux".split()
     for flav in expected:
         self.assert_(flav in flavors)
Exemple #12
0
 def testRegen(self):
     ps = ProductStack.fromCache(self.dbpath, "Linux", autosave=True, 
                                 updateCache=True, verbose=False)
     self.assert_(not ps.hasProduct("afw"))
     prod = Product("afw", "1.2", "Darwin", "/opt/sw/Darwin/afw/1.2", "none")
     ps.addProduct(prod)
     ps.reload("Linux")
     self.assert_(ps.hasProduct("afw"))
     del ps
     ps = ProductStack.fromCache(self.dbpath, "Linux", autosave=False, 
                                 updateCache=True, verbose=False)
     self.assert_(not ps.hasProduct("afw"))
Exemple #13
0
    def testPersist(self):
        fd = file("test_product.pickle", "w")
        self.prod.persist(fd)
        fd.close()
        fd = file("test_product.pickle")
        p = Product.unpersist(fd)

        self.assertEqual(self.prod.name, p.name)
        self.assertEqual(self.prod.version, p.version)
        self.assertEqual(self.prod.dir, p.dir)
        self.assertEqual(self.prod.db, p.db)
        self.assert_(self.prod._table is None)
        self.assert_(self.prod.tablefile is None)
Exemple #14
0
    def testPersist(self):
        fd = open("test_product.pickle", "wb")
        self.prod.persist(fd)
        fd.close()
        fd = open("test_product.pickle", "rb")
        p = Product.unpersist(fd)

        self.assertEqual(self.prod.name, p.name)
        self.assertEqual(self.prod.version, p.version)
        self.assertEqual(self.prod.dir, p.dir)
        self.assertEqual(self.prod.db, p.db)
        self.assert_(self.prod._table is None)
        self.assert_(self.prod.tablefile is None)
Exemple #15
0
    def testGetProductNames(self):
        prods = self.stack.getProductNames()
        self.assertEquals(len(prods), 1)
        self.assertEquals(prods[0], 'fw')

        self.stack.addProduct(Product("afw", "1.2", "Linux", 
                                      "/opt/sw/Linux/afw/1.2", "none"))
        prods = self.stack.getProductNames()
        self.assertEquals(len(prods), 2)
        expected = "fw afw".split()
        for prod in expected:
            self.assert_(prod in prods)
        prods = self.stack.getProductNames("Linux")
        self.assertEquals(len(prods), 1)
        self.assertEquals(prods[0], 'afw')

        self.stack.addProduct(Product("fw", "1.2", "Linux", 
                                      "/opt/sw/Linux/fw/1.2", "none"))
        prods = self.stack.getProductNames()
        self.assertEquals(len(prods), 2)
        for prod in expected:
            self.assert_(prod in prods)
Exemple #16
0
    def testTags(self):
        self.assertEquals(len(self.stack.getTags()), 0)

        prod = Product("afw", "1.2", "Linux", "/opt/sw/Linux/afw/1.2", "none")
        prod.tags = ["current", "beta"]
        self.stack.addProduct(prod)
        self.assertEquals(len(self.stack.getTags()), 2)
        prod.version = "1.3"
        prod.tags = []
        self.stack.addProduct(prod)
        tags = self.stack.getTags()
        self.assertEquals(len(tags), 2)
        self.assertEquals(tags[0], "beta")
        self.assertEquals(tags[1], "current")
        prod = self.stack.getTaggedProduct("afw", "Linux", "stable")
        self.assert_(prod is None)
        prod = self.stack.getTaggedProduct("afw", "Linux", "beta")
        self.assertEqual(prod.version, "1.2")
        self.assertEqual(prod.flavor, "Linux")
        self.assertEqual(prod.db, self.dbpath)

        self.assertRaises(ProductNotFound, 
                          self.stack.assignTag, "gurn", "goober", "2")
        self.stack.assignTag("beta", "afw", "1.3")
        tags = self.stack.getTags()
        self.assertEquals(len(tags), 2)
        self.assertEquals(tags[0], "beta")
        self.assertEquals(tags[1], "current")
        prod = self.stack.getTaggedProduct("afw", "Linux", "beta")
        self.assertEqual(prod.version, "1.3")
        self.assertEqual(prod.flavor, "Linux")
        self.assertEqual(prod.db, self.dbpath)

        self.assert_(not self.stack.unassignTag("gurn", "afw", "Linux"))
        self.assert_(self.stack.unassignTag("beta", "afw"))
        tags = self.stack.getTags()
        self.assertEquals(len(tags), 1)
        self.assertEquals(tags[0], "current")
Exemple #17
0
    def getProduct(self, version, dbpath=None, flavor=None):
        """
        return the Product of the requested version or None if not found.
        This returned Product's db attribute will be set to None.

        @param version : the desired version
        @param dbpath    a database path to set on the returned product
        @param flavor    a platform flavor to set on the returned product
        @return    the product description as a Product instance
        """
        try:
            versdata = self.versions[version]
            tags = [item[0] for item in [x for x in self.tags.items() if x[1] == version]]
            out = Product(self.name, version, flavor, 
                          versdata[0],    # the install directory
                          versdata[1],    # the table file
                          tags, dbpath)
            if versdata[2]:
                out._table = versdata[2]
            return out
                           
        except KeyError:
            raise ProductNotFound(self.name, version)
Exemple #18
0
    def testAutoSave(self):
        self.assert_(self.stack.saveNeeded())

        cache = os.path.join(os.environ["PWD"],
                             ProductStack.persistFilename("Darwin"))
        if os.path.exists(cache):  os.remove(cache)

        stack = ProductStack(os.path.join(testEupsStack, "ups_db"), 
                             os.environ["PWD"], autosave=True)
        self.assert_(not stack.saveNeeded())
        stack.addProduct(Product("fw", "1.2", "Darwin", 
                                 "/opt/sw/Darwin/fw/1.2", "none"))
        self.assert_(not stack.saveNeeded())
        self.assert_(os.path.exists(cache))
        if os.path.exists(cache):  os.remove(cache)
Exemple #19
0
    def testInit(self):
        self.assertEqual(self.prod.name, "eups")
        self.assertEqual(self.prod.version, "1.0")
        self.assertEqual(self.prod.dir, testEupsStack)
        self.assert_(self.prod.db is None)
        self.assert_(self.prod._table is None)
        self.assert_(self.prod.tablefile is None)
        self.assert_(self.prod._prodStack is None)

        db = os.path.join(os.environ["PWD"], "ups_db")
        p = Product("eups", "1.0", dir=os.environ["PWD"], 
                    tags="stable mine".split(), db=db)
        self.assertEqual(p.db, db)
        self.assertEqual(len(p.tags), 2)
        self.assert_("stable" in p.tags)
        self.assert_("mine" in p.tags)
Exemple #20
0
    def testDeclare(self):
        pdir = self.db._productDir("base")
        if os.path.isdir(pdir):
            map(
                lambda r: os.remove(r),
                filter(lambda f: os.path.isfile(f),
                       map(lambda p: os.path.join(pdir, p), os.listdir(pdir))))
            os.removedirs(pdir)
        try:
            self.assert_(not os.path.exists(pdir))
            baseidir = os.path.join(testEupsStack, "Linux/base/1.0")
            base = Product("base",
                           "1.0",
                           "Linux",
                           baseidir,
                           os.path.join(baseidir, "ups/base.table"),
                           tags=["current"])
            self.db.declare(base)
            self.assert_(os.path.isdir(pdir))
            self.assert_(os.path.isfile(os.path.join(pdir, "1.0.version")))
            self.assert_(os.path.isfile(os.path.join(pdir, "current.chain")))
            prods = self.db.findProducts("base")
            self.assertEquals(len(prods), 1)
            self.assertEquals(prods[0].name, "base")
            self.assertEquals(prods[0].version, "1.0")
            self.assertEquals(prods[0].flavor, "Linux")
            self.assertEquals(prods[0].dir, baseidir)
            self.assertEquals(prods[0].tablefile,
                              os.path.join(baseidir, "ups/base.table"))
            self.assertEquals(len(prods[0].tags), 1)
            self.assertEquals(prods[0].tags[0], "current")

            base2 = prods[0].clone()
            base2.version = "2.0"
            base2.tags = []
            self.db.declare(base2)
            self.assertEquals(
                self.db.getTaggedVersion("current", "base", "Linux"), "1.0")
            base3 = prods[0].clone()
            base3.version = "3.0"
            self.db.declare(base3)
            self.assertEquals(
                self.db.getTaggedVersion("current", "base", "Linux"), "3.0")

            self.assertEquals(len(self.db.findProducts("base")), 3)

            self.db.undeclare(base)
            self.assertEquals(self.db.findProduct("base", "1.0", "Linux"),
                              None)
            self.assertEquals(len(self.db.findProducts("base")), 2)
            self.assert_(not os.path.exists(os.path.join(pdir, "1.0.version")))

            self.db.undeclare(base3)
            self.assertEquals(self.db.findProduct("base", "3.0", "Linux"),
                              None)
            self.assertEquals(len(self.db.findProducts("base")), 1)
            self.assert_(not os.path.exists(os.path.join(pdir, "3.0.version")))
            self.assertEquals(
                self.db.getTaggedVersion("current", "base", "Linux"), None)
            self.assert_(
                not os.path.exists(os.path.join(pdir, "current.chain")))
            self.db.undeclare(base2)
            self.assertEquals(len(self.db.findProducts("base")), 0)
            self.assert_(not os.path.exists(pdir))

        except:
            if False:
                if os.path.isdir(pdir):
                    map(
                        lambda r: os.remove(r),
                        filter(
                            lambda f: os.path.isfile(f),
                            map(lambda p: os.path.join(pdir, p),
                                os.listdir(pdir))))
                    os.removedirs(pdir)
            raise
Exemple #21
0
    def testProd1(self):
        pname = "newprod"
        pver = "2.0"
        pdir = os.path.join(self.eupsPathDir, "Linux", pname, pver)
        prod = Product("newprod", "2.0", "Linux", pdir, db=self.dbpath)

        self.assertEqual(prod.dir, pdir)
        self.assertEqual(prod.db, self.dbpath)
        self.assert_(prod.ups_dir is None)
        self.assert_(prod.tablefile is None)
        self.assertEqual(prod.tableFileName(),
                         os.path.join(pdir, "ups", pname + ".table"))

        # test cloning (we'll use this later)
        clone = prod.clone()
        self.assertEqual(clone.dir, pdir)
        self.assertEqual(clone.db, self.dbpath)
        self.assert_(clone.ups_dir is None)
        self.assert_(clone.tablefile is None)
        self.assertEqual(clone.tableFileName(),
                         os.path.join(pdir, "ups", pname + ".table"))

        # turn to absolute paths
        prod.resolvePaths()
        self.assertEqual(prod.dir, pdir)
        self.assertEqual(prod.db, self.dbpath)
        self.assertEqual(prod.tablefile,
                         os.path.join(pdir, "ups", pname + ".table"))
        self.assertEqual(prod.ups_dir, os.path.join(pdir, "ups"))
        self.assertEqual(prod.tableFileName(),
                         os.path.join(pdir, "ups", pname + ".table"))

        # turn to relative paths
        prod.canonicalizePaths()
        self.assertEqual(prod.dir, "Linux/newprod/2.0")
        self.assertEqual(prod.db, self.dbpath)
        self.assertEqual(prod.tablefile, pname + ".table")
        self.assertEqual(prod.ups_dir, "ups")
        self.assertEqual(prod.tableFileName(),
                         os.path.join(pdir, "ups", pname + ".table"))

        # round trip: turn back to absolute paths
        prod.resolvePaths()
        self.assertEqual(prod.dir, pdir)
        self.assertEqual(prod.db, self.dbpath)
        self.assertEqual(prod.tablefile,
                         os.path.join(pdir, "ups", pname + ".table"))
        self.assertEqual(prod.ups_dir, os.path.join(pdir, "ups"))
        self.assertEqual(prod.tableFileName(),
                         os.path.join(pdir, "ups", pname + ".table"))

        # turn original to relative paths
        clone.canonicalizePaths()
        self.assertEqual(clone.dir, "Linux/newprod/2.0")
        self.assertEqual(clone.db, self.dbpath)
        self.assertEqual(clone.tablefile, pname + ".table")
        self.assertEqual(clone.ups_dir, "ups")
        self.assertEqual(clone.tableFileName(),
                         os.path.join(pdir, "ups", pname + ".table"))

        # back to absolute paths
        clone.resolvePaths()
        self.assertEqual(clone.dir, pdir)
        self.assertEqual(clone.db, self.dbpath)
        self.assertEqual(clone.tablefile,
                         os.path.join(pdir, "ups", pname + ".table"))
        self.assertEqual(clone.ups_dir, os.path.join(pdir, "ups"))
        self.assertEqual(clone.tableFileName(),
                         os.path.join(pdir, "ups", pname + ".table"))
    def testProd2(self):
        """
        Test $UPS_DB transformations
        """
        pname = "newprod"
        pver = "2.0"
        pdir = os.path.join(self.eupsPathDir,"Linux",pname,pver)
        prod = Product("newprod", "2.0", "Linux", pdir, db=self.dbpath,
                       table=os.path.join(self.dbpath,pname,'Linux',
                                          pver+".table"))

        self.assertEqual(prod.dir, pdir)
        self.assertEqual(prod.db, self.dbpath)
        self.assertEqual(prod.tablefile,
                          os.path.join(self.dbpath,"newprod/Linux/2.0.table"))
        self.assert_(prod.ups_dir is None)
        self.assertEqual(prod.tableFileName(),
                          os.path.join(self.dbpath,"newprod/Linux/2.0.table"))

        # test cloning (we'll use this later)
        clone = prod.clone()
        self.assertEqual(clone.dir, pdir)
        self.assertEqual(clone.db, self.dbpath)
        self.assertEqual(clone.tablefile,
                          os.path.join(self.dbpath,"newprod/Linux/2.0.table"))
        self.assert_(clone.ups_dir is None)
        self.assertEqual(clone.tableFileName(),
                          os.path.join(self.dbpath,"newprod/Linux/2.0.table"))

        # turn to absolute paths
        prod.resolvePaths()
        self.assertEqual(prod.dir, pdir)
        self.assertEqual(prod.db, self.dbpath)
        self.assert_(prod.ups_dir is None)
        self.assertEqual(prod.tablefile,
                          os.path.join(self.dbpath,"newprod/Linux/2.0.table"))
        self.assertEqual(prod.tableFileName(),
                          os.path.join(self.dbpath,"newprod/Linux/2.0.table"))

        prod.canonicalizePaths()
        self.assertEqual(prod.dir, "Linux/newprod/2.0")
        self.assertEqual(prod.db, self.dbpath)
        self.assertEqual(prod.ups_dir, "$UPS_DB/newprod/Linux")
        self.assertEqual(prod.tablefile, "2.0.table")
        self.assertEqual(prod.tableFileName(),
                          os.path.join(self.dbpath,"newprod/Linux/2.0.table"))

        # turn original to relative paths
        clone.canonicalizePaths()
        self.assertEqual(clone.dir, "Linux/newprod/2.0")
        self.assertEqual(clone.db, self.dbpath)
        self.assertEqual(clone.ups_dir, "$UPS_DB/newprod/Linux")
        self.assertEqual(clone.tablefile, "2.0.table")
        self.assertEqual(clone.tableFileName(),
                          os.path.join(self.dbpath,"newprod/Linux/2.0.table"))

        # back to absolute paths
        clone.resolvePaths()
        self.assertEqual(clone.dir, pdir)
        self.assertEqual(clone.db, self.dbpath)
        self.assertEqual(clone.ups_dir,
                          os.path.join(self.dbpath,pname,"Linux"))
        self.assertEqual(clone.tablefile,
                          os.path.join(self.dbpath,"newprod/Linux/2.0.table"))
        self.assertEqual(clone.tableFileName(),
                          os.path.join(self.dbpath,"newprod/Linux/2.0.table"))
 def setUp(self):
     self.prod = Product("eups", "1.0", dir=testEupsStack)
Exemple #24
0
 def setUp(self):
     self.prod = Product("eups", "1.0", dir=testEupsStack)
Exemple #25
0
    def testProd2(self):
        """
        Test $UPS_DB transformations
        """
        pname = "newprod"
        pver = "2.0"
        pdir = os.path.join(self.eupsPathDir, "Linux", pname, pver)
        prod = Product("newprod",
                       "2.0",
                       "Linux",
                       pdir,
                       db=self.dbpath,
                       table=os.path.join(self.dbpath, pname, 'Linux',
                                          pver + ".table"))

        self.assertEqual(prod.dir, pdir)
        self.assertEqual(prod.db, self.dbpath)
        self.assertEqual(prod.tablefile,
                         os.path.join(self.dbpath, "newprod/Linux/2.0.table"))
        self.assert_(prod.ups_dir is None)
        self.assertEqual(prod.tableFileName(),
                         os.path.join(self.dbpath, "newprod/Linux/2.0.table"))

        # test cloning (we'll use this later)
        clone = prod.clone()
        self.assertEqual(clone.dir, pdir)
        self.assertEqual(clone.db, self.dbpath)
        self.assertEqual(clone.tablefile,
                         os.path.join(self.dbpath, "newprod/Linux/2.0.table"))
        self.assert_(clone.ups_dir is None)
        self.assertEqual(clone.tableFileName(),
                         os.path.join(self.dbpath, "newprod/Linux/2.0.table"))

        # turn to absolute paths
        prod.resolvePaths()
        self.assertEqual(prod.dir, pdir)
        self.assertEqual(prod.db, self.dbpath)
        self.assert_(prod.ups_dir is None)
        self.assertEqual(prod.tablefile,
                         os.path.join(self.dbpath, "newprod/Linux/2.0.table"))
        self.assertEqual(prod.tableFileName(),
                         os.path.join(self.dbpath, "newprod/Linux/2.0.table"))

        prod.canonicalizePaths()
        self.assertEqual(prod.dir, "Linux/newprod/2.0")
        self.assertEqual(prod.db, self.dbpath)
        self.assertEqual(prod.ups_dir, "$UPS_DB/newprod/Linux")
        self.assertEqual(prod.tablefile, "2.0.table")
        self.assertEqual(prod.tableFileName(),
                         os.path.join(self.dbpath, "newprod/Linux/2.0.table"))

        # turn original to relative paths
        clone.canonicalizePaths()
        self.assertEqual(clone.dir, "Linux/newprod/2.0")
        self.assertEqual(clone.db, self.dbpath)
        self.assertEqual(clone.ups_dir, "$UPS_DB/newprod/Linux")
        self.assertEqual(clone.tablefile, "2.0.table")
        self.assertEqual(clone.tableFileName(),
                         os.path.join(self.dbpath, "newprod/Linux/2.0.table"))

        # back to absolute paths
        clone.resolvePaths()
        self.assertEqual(clone.dir, pdir)
        self.assertEqual(clone.db, self.dbpath)
        self.assertEqual(clone.ups_dir,
                         os.path.join(self.dbpath, pname, "Linux"))
        self.assertEqual(clone.tablefile,
                         os.path.join(self.dbpath, "newprod/Linux/2.0.table"))
        self.assertEqual(clone.tableFileName(),
                         os.path.join(self.dbpath, "newprod/Linux/2.0.table"))
    def testProd1(self):
        pname = "newprod"
        pver = "2.0"
        pdir = os.path.join(self.eupsPathDir,"Linux",pname,pver)
        prod = Product("newprod", "2.0", "Linux", pdir, db=self.dbpath)

        self.assertEqual(prod.dir, pdir)
        self.assertEqual(prod.db, self.dbpath)
        self.assert_(prod.ups_dir is None)
        self.assert_(prod.tablefile is None)
        self.assertEqual(prod.tableFileName(),
                          os.path.join(pdir,"ups",pname+".table"))

        # test cloning (we'll use this later)
        clone = prod.clone()
        self.assertEqual(clone.dir, pdir)
        self.assertEqual(clone.db, self.dbpath)
        self.assert_(clone.ups_dir is None)
        self.assert_(clone.tablefile is None)
        self.assertEqual(clone.tableFileName(),
                          os.path.join(pdir,"ups",pname+".table"))

        # turn to absolute paths
        prod.resolvePaths()
        self.assertEqual(prod.dir, pdir)
        self.assertEqual(prod.db, self.dbpath)
        self.assertEqual(prod.tablefile,
                          os.path.join(pdir,"ups",pname+".table"))
        self.assertEqual(prod.ups_dir, os.path.join(pdir,"ups"))
        self.assertEqual(prod.tableFileName(),
                          os.path.join(pdir,"ups",pname+".table"))

        # turn to relative paths
        prod.canonicalizePaths()
        self.assertEqual(prod.dir, "Linux/newprod/2.0")
        self.assertEqual(prod.db, self.dbpath)
        self.assertEqual(prod.tablefile, pname+".table")
        self.assertEqual(prod.ups_dir, "ups")
        self.assertEqual(prod.tableFileName(),
                          os.path.join(pdir,"ups",pname+".table"))

        # round trip: turn back to absolute paths
        prod.resolvePaths()
        self.assertEqual(prod.dir, pdir)
        self.assertEqual(prod.db, self.dbpath)
        self.assertEqual(prod.tablefile,
                          os.path.join(pdir,"ups",pname+".table"))
        self.assertEqual(prod.ups_dir, os.path.join(pdir,"ups"))
        self.assertEqual(prod.tableFileName(),
                          os.path.join(pdir,"ups",pname+".table"))

        # turn original to relative paths
        clone.canonicalizePaths()
        self.assertEqual(clone.dir, "Linux/newprod/2.0")
        self.assertEqual(clone.db, self.dbpath)
        self.assertEqual(clone.tablefile, pname+".table")
        self.assertEqual(clone.ups_dir, "ups")
        self.assertEqual(clone.tableFileName(),
                          os.path.join(pdir,"ups",pname+".table"))

        # back to absolute paths
        clone.resolvePaths()
        self.assertEqual(clone.dir, pdir)
        self.assertEqual(clone.db, self.dbpath)
        self.assertEqual(clone.tablefile,
                          os.path.join(pdir,"ups",pname+".table"))
        self.assertEqual(clone.ups_dir, os.path.join(pdir,"ups"))
        self.assertEqual(clone.tableFileName(),
                          os.path.join(pdir,"ups",pname+".table"))
Exemple #27
0
 def setUp(self):
     self.dbpath = os.path.join(testEupsStack, "ups_db")
     self.stack = ProductStack(self.dbpath, autosave=False)
     self.stack.addProduct(Product("fw", "1.2", "Darwin", 
                                   "/opt/sw/Darwin/fw/1.2", "none"))