Example #1
0
    def testNoTable(self):
        pdir = os.path.join(testEupsStack, "Linux", "newprod")
        pdir11 = os.path.join(pdir, "1.1")

        cmd = "-r %s newprod" % pdir11
        hooks.config.Eups.defaultTags = dict(pre=[], post=[]) # disable any defined in the startup.py file
        cmd = eups.setupcmd.EupsSetup(args=cmd.split(), toolname=prog)
        self.assertEqual(cmd.run(), 0)
Example #2
0
    def testInstall(self):
        prod = Eups().findProduct("lssteups")
        self.assert_(prod is None)

        cmd = "distrib install lssteups 1.1 -q -r " + self.lsstroot
        cmd = eups.cmd.EupsCmd(args=cmd.split(), toolname=prog)
        self.assertEqual(cmd.run(), 0)

        prod = Eups().findProduct("lssteups")
        self.assert_(prod is not None)
        self.assertEqual(prod.version, "1.1")
        self.assert_(prod.dir.endswith("lssteups/1.1"))
        self.assert_(os.path.exists(prod.dir))
        pdir = prod.dir

        cmd = "remove lssteups 1.1"
        cmd = eups.cmd.EupsCmd(args=cmd.split(), toolname=prog)
        self.assertEqual(cmd.run(), 0)

        prod = Eups().findProduct("lssteups")
        self.assert_(prod is None)

        cmd = "distrib install lssteups 1.1 --noclean -q -r " + self.lsstroot
        cmd = eups.cmd.EupsCmd(args=cmd.split(), toolname=prog)
        self.assertEqual(cmd.run(), 0)

        prod = Eups().findProduct("lssteups")
        self.assert_(prod is not None)
        bdir = os.path.join(testEupsStack, "EupsBuildDir", self.flavor,
                            "lssteups-1.1")
        self.assert_(os.path.exists(bdir), "%s does not exist" % bdir)

        cmd = "distrib clean lssteups 1.1 -r " + self.lsstroot
        cmd = eups.cmd.EupsCmd(args=cmd.split(), toolname=prog)
        self.assertEqual(cmd.run(), 0)
        self.assert_(not os.path.exists(bdir), "%s still exists" % bdir)

        cmd = "distrib clean lssteups 1.1 -q -R -r " + self.lsstroot
        cmd = eups.cmd.EupsCmd(args=cmd.split(), toolname=prog)
        self.assertEqual(cmd.run(), 0)
        self.assert_(not os.path.exists(bdir), "%s still exists" % bdir)

        prod = Eups().findProduct("lssteups")
        self.assert_(prod is None)
        self.assert_(not os.path.exists(pdir))
Example #3
0
    def testNoTable(self):
        pdir = os.path.join(testEupsStack, "Linux", "newprod")
        pdir11 = os.path.join(pdir, "1.1")

        cmd = "-r %s newprod" % pdir11
        hooks.config.Eups.defaultTags = dict(
            pre=[], post=[])  # disable any defined in the startup.py file
        cmd = eups.setupcmd.EupsSetup(args=cmd.split(), toolname=prog)
        self.assertEqual(cmd.run(), 0)
Example #4
0
    def testInstall(self):
        prod = Eups().findProduct("lssteups")
        self.assert_(prod is None)

        cmd = "distrib install lssteups 1.1 -q -r " + self.lsstroot
        cmd = eups.cmd.EupsCmd(args=cmd.split(), toolname=prog)
        self.assertEqual(cmd.run(), 0)

        prod = Eups().findProduct("lssteups")
        self.assert_(prod is not None)
        self.assertEquals(prod.version, "1.1")
        self.assert_(prod.dir.endswith("lssteups/1.1"))
        self.assert_(os.path.exists(prod.dir))
        pdir = prod.dir

        cmd = "remove lssteups 1.1"
        cmd = eups.cmd.EupsCmd(args=cmd.split(), toolname=prog)
        self.assertEqual(cmd.run(), 0)

        prod = Eups().findProduct("lssteups")
        self.assert_(prod is None)
        
        cmd = "distrib install lssteups 1.1 --noclean -q -r " + self.lsstroot
        cmd = eups.cmd.EupsCmd(args=cmd.split(), toolname=prog)
        self.assertEqual(cmd.run(), 0)

        prod = Eups().findProduct("lssteups")
        self.assert_(prod is not None)
        bdir = os.path.join(testEupsStack,"EupsBuildDir",self.flavor,"lssteups-1.1")
        self.assert_(os.path.exists(bdir), "%s does not exist" % bdir)

        cmd = "distrib clean lssteups 1.1 -r " + self.lsstroot
        cmd = eups.cmd.EupsCmd(args=cmd.split(), toolname=prog)
        self.assertEqual(cmd.run(), 0)
        self.assert_(not os.path.exists(bdir), "%s still exists" % bdir)

        cmd = "distrib clean lssteups 1.1 -q -R -r " + self.lsstroot
        cmd = eups.cmd.EupsCmd(args=cmd.split(), toolname=prog)
        self.assertEqual(cmd.run(), 0)
        self.assert_(not os.path.exists(bdir), "%s still exists" % bdir)

        prod = Eups().findProduct("lssteups")
        self.assert_(prod is None)
        self.assert_(not os.path.exists(pdir))
Example #5
0
    def testDeclare(self):
        pdir = os.path.join(testEupsStack, "Linux", "newprod")
        pdir10 = os.path.join(pdir, "1.0")
        table = os.path.join(pdir10, "ups", "newprod.table")
        newprod = os.path.join(self.dbpath,"newprod")

        cmdargs = ["declare", "newprod", "1.0", "-r", pdir10, "-m", table]
        cmd = eups.cmd.EupsCmd(args=cmdargs, toolname=prog)
        self.assertEqual(cmd.run(), 0)
        self.assertEquals(self.err.getvalue(), "")
        self.assertEquals(self.out.getvalue(), "")
        
        myeups = eups.Eups()
        prod = myeups.findProduct("newprod")
        self.assertIsNotNone(prod, msg="Failed to declare product")
        self.assertEquals(prod.name,    "newprod")
        self.assertEquals(prod.version, "1.0")
        self.assertEquals(len(prod.tags), 1)   # current is tagged by default
        self.assertIn("current", prod.tags)
        self.assertTrue(os.path.isdir(newprod))

        # make sure user cannot set a server tag
        self._resetOut()
        cmd = "declare newprod 1.0 -t latest"
        cmd = eups.cmd.EupsCmd(args=cmd.split(), toolname=prog)
        self.assertNotEqual(cmd.run(), 0)
        self.assertNotEqual(self.err.getvalue(), "")
        self.assertEquals(self.out.getvalue(), "")
        
        self._resetOut()
        cmd = "declare -F newprod 1.0 -t current"
        cmd = eups.cmd.EupsCmd(args=cmd.split(), toolname=prog)
        self.assertEqual(cmd.run(), 0)
        self.assertEquals(self.err.getvalue(), "")
        self.assertEquals(self.out.getvalue(), "")
        
        myeups = eups.Eups()
        prod = myeups.findProduct("newprod")
        self.assertIsNotNone(prod, msg="product went missing after tagging")
        self.assertIn("current", prod.tags)
        
        self._resetOut()
        cmd = "undeclare newprod 1.0"
        cmd = eups.cmd.EupsCmd(args=cmd.split(), toolname=prog)
        self.assertEqual(cmd.run(), 0)
        self.assertEquals(self.err.getvalue(), "")
        self.assertEquals(self.out.getvalue(), "")

        myeups = eups.Eups()
        prod = myeups.findProduct("newprod")
        self.assertIsNone(prod, "Failed to undeclare product")
        self.assertFalse(os.path.isdir(newprod))

        self._resetOut()
        cmdargs = ["declare", "newprod", "1.0", "-F", "-r", pdir10, "-m", table, "-t", "current"]
        cmd = eups.cmd.EupsCmd(args=cmdargs, toolname=prog)
        self.assertEqual(cmd.run(), 0)
        self.assertEquals(self.err.getvalue(), "")
        self.assertEquals(self.out.getvalue(), "")
        
        myeups = eups.Eups()
        prod = myeups.findProduct("newprod")
        self.assertIsNotNone(prod, msg="Failed to declare product")
        self.assertEquals(prod.name,    "newprod")
        self.assertEquals(prod.version, "1.0")
        self.assertEquals(len(prod.tags), 1)
        self.assertIn("current", prod.tags)
        self.assertTrue(os.path.isdir(newprod))
        
        self._resetOut()
        cmd = "undeclare newprod 1.0"
        cmd = eups.cmd.EupsCmd(args=cmd.split(), toolname=prog)
        self.assertEqual(cmd.run(), 0)
        self.assertEquals(self.err.getvalue(), "")
        self.assertEquals(self.out.getvalue(), "")

        myeups = eups.Eups()
        prod = myeups.findProduct("newprod", Tag("current"))
        self.assertIsNone(prod, msg="Failed to undeclare product")
Example #6
0
    def testDeclare(self):
        pdir = os.path.join(testEupsStack, "Linux", "newprod")
        pdir10 = os.path.join(pdir, "1.0")
        pdir11 = os.path.join(pdir, "1.1")
        table = os.path.join(pdir10, "ups", "newprod.table")
        newprod = os.path.join(self.dbpath,"newprod")

        cmd = "declare newprod 1.0 -r %s -m %s" % (pdir10, table)
        cmd = eups.cmd.EupsCmd(args=cmd.split(), toolname=prog)
        self.assertEqual(cmd.run(), 0)
        self.assertEquals(self.err.getvalue(), "")
        self.assertEquals(self.out.getvalue(), "")
        
        myeups = eups.Eups()
        prod = myeups.findProduct("newprod")
        self.assert_(prod is not None, "Failed to declare product")
        self.assertEquals(prod.name,    "newprod")
        self.assertEquals(prod.version, "1.0")
        self.assertEquals(len(prod.tags), 1)   # current is tagged by default
        self.assert_("current" in prod.tags)
        self.assert_(os.path.isdir(newprod))

        # make sure user cannot set a server tag
        self._resetOut()
        cmd = "declare newprod 1.0 -t newest"
        cmd = eups.cmd.EupsCmd(args=cmd.split(), toolname=prog)
        self.assertNotEqual(cmd.run(), 0)
        self.assertNotEqual(self.err.getvalue(), "")
        self.assertEquals(self.out.getvalue(), "")
        
        self._resetOut()
        cmd = "declare -F newprod 1.0 -t current"
        cmd = eups.cmd.EupsCmd(args=cmd.split(), toolname=prog)
        self.assertEqual(cmd.run(), 0)
        self.assertEquals(self.err.getvalue(), "")
        self.assertEquals(self.out.getvalue(), "")
        
        myeups = eups.Eups()
        prod = myeups.findProduct("newprod")
        self.assert_(prod is not None, "product went missing after tagging")
        self.assert_("current" in prod.tags)
        
        self._resetOut()
        cmd = "undeclare newprod 1.0"
        cmd = eups.cmd.EupsCmd(args=cmd.split(), toolname=prog)
        self.assertEqual(cmd.run(), 0)
        self.assertEquals(self.err.getvalue(), "")
        self.assertEquals(self.out.getvalue(), "")

        myeups = eups.Eups()
        prod = myeups.findProduct("newprod")
        self.assert_(prod is None, "Failed to undeclare product")
        self.assert_(not os.path.isdir(newprod))

        self._resetOut()
        cmd = "declare newprod 1.0 -F -r %s -m %s -t current" % (pdir10, table)
        cmd = eups.cmd.EupsCmd(args=cmd.split(), toolname=prog)
        self.assertEqual(cmd.run(), 0)
        self.assertEquals(self.err.getvalue(), "")
        self.assertEquals(self.out.getvalue(), "")
        
        myeups = eups.Eups()
        prod = myeups.findProduct("newprod")
        self.assert_(prod is not None, "Failed to declare product")
        self.assertEquals(prod.name,    "newprod")
        self.assertEquals(prod.version, "1.0")
        self.assertEquals(len(prod.tags), 1)
        self.assert_("current" in prod.tags)
        self.assert_(os.path.isdir(newprod))
        
        self._resetOut()
        cmd = "undeclare newprod 1.0"
        cmd = eups.cmd.EupsCmd(args=cmd.split(), toolname=prog)
        self.assertEqual(cmd.run(), 0)
        self.assertEquals(self.err.getvalue(), "")
        self.assertEquals(self.out.getvalue(), "")

        myeups = eups.Eups()
        prod = myeups.findProduct("newprod", Tag("current"))
        self.assert_(prod is None, "Failed to undeclare product")
Example #7
0
    def testDeclare(self):
        pdir = os.path.join(testEupsStack, "Linux", "newprod")
        pdir10 = os.path.join(pdir, "1.0")
        table = os.path.join(pdir10, "ups", "newprod.table")
        newprod = os.path.join(self.dbpath, "newprod")

        cmdargs = ["declare", "newprod", "1.0", "-r", pdir10, "-m", table]
        cmd = eups.cmd.EupsCmd(args=cmdargs, toolname=prog)
        self.assertEqual(cmd.run(), 0)
        self.assertEqual(self.err.getvalue(), "")
        self.assertEqual(self.out.getvalue(), "")

        myeups = eups.Eups()
        prod = myeups.findProduct("newprod")
        self.assertIsNotNone(prod, msg="Failed to declare product")
        self.assertEqual(prod.name, "newprod")
        self.assertEqual(prod.version, "1.0")
        self.assertEqual(len(prod.tags), 1)  # current is tagged by default
        self.assertIn("current", prod.tags)
        self.assertTrue(os.path.isdir(newprod))

        # make sure user cannot set a server tag
        self._resetOut()
        cmd = "declare newprod 1.0 -t latest"
        cmd = eups.cmd.EupsCmd(args=cmd.split(), toolname=prog)
        self.assertNotEqual(cmd.run(), 0)
        self.assertNotEqual(self.err.getvalue(), "")
        self.assertEqual(self.out.getvalue(), "")

        self._resetOut()
        cmd = "declare -F newprod 1.0 -t current"
        cmd = eups.cmd.EupsCmd(args=cmd.split(), toolname=prog)
        self.assertEqual(cmd.run(), 0)
        self.assertEqual(self.err.getvalue(), "")
        self.assertEqual(self.out.getvalue(), "")

        myeups = eups.Eups()
        prod = myeups.findProduct("newprod")
        self.assertIsNotNone(prod, msg="product went missing after tagging")
        self.assertIn("current", prod.tags)

        self._resetOut()
        cmd = "undeclare newprod 1.0"
        cmd = eups.cmd.EupsCmd(args=cmd.split(), toolname=prog)
        self.assertEqual(cmd.run(), 0)
        self.assertEqual(self.err.getvalue(), "")
        self.assertEqual(self.out.getvalue(), "")

        myeups = eups.Eups()
        prod = myeups.findProduct("newprod")
        self.assertIsNone(prod, "Failed to undeclare product")
        self.assertFalse(os.path.isdir(newprod))

        self._resetOut()
        cmdargs = [
            "declare", "newprod", "1.0", "-F", "-r", pdir10, "-m", table, "-t",
            "current"
        ]
        cmd = eups.cmd.EupsCmd(args=cmdargs, toolname=prog)
        self.assertEqual(cmd.run(), 0)
        self.assertEqual(self.err.getvalue(), "")
        self.assertEqual(self.out.getvalue(), "")

        myeups = eups.Eups()
        prod = myeups.findProduct("newprod")
        self.assertIsNotNone(prod, msg="Failed to declare product")
        self.assertEqual(prod.name, "newprod")
        self.assertEqual(prod.version, "1.0")
        self.assertEqual(len(prod.tags), 1)
        self.assertIn("current", prod.tags)
        self.assertTrue(os.path.isdir(newprod))

        self._resetOut()
        cmd = "undeclare newprod 1.0"
        cmd = eups.cmd.EupsCmd(args=cmd.split(), toolname=prog)
        self.assertEqual(cmd.run(), 0)
        self.assertEqual(self.err.getvalue(), "")
        self.assertEqual(self.out.getvalue(), "")

        myeups = eups.Eups()
        prod = myeups.findProduct("newprod", Tag("current"))
        self.assertIsNone(prod, msg="Failed to undeclare product")
Example #8
0
    def testDeclare(self):
        pdir = os.path.join(testEupsStack, "Linux", "newprod")
        pdir10 = os.path.join(pdir, "1.0")
        pdir11 = os.path.join(pdir, "1.1")
        table = os.path.join(pdir10, "ups", "newprod.table")
        newprod = os.path.join(self.dbpath, "newprod")

        cmd = "declare newprod 1.0 -r %s -m %s" % (pdir10, table)
        cmd = eups.cmd.EupsCmd(args=cmd.split(), toolname=prog)
        self.assertEqual(cmd.run(), 0)
        self.assertEquals(self.err.getvalue(), "")
        self.assertEquals(self.out.getvalue(), "")

        myeups = eups.Eups()
        prod = myeups.findProduct("newprod")
        self.assert_(prod is not None, "Failed to declare product")
        self.assertEquals(prod.name, "newprod")
        self.assertEquals(prod.version, "1.0")
        self.assertEquals(len(prod.tags), 1)  # current is tagged by default
        self.assert_("current" in prod.tags)
        self.assert_(os.path.isdir(newprod))

        # make sure user cannot set a server tag
        self._resetOut()
        cmd = "declare newprod 1.0 -t newest"
        cmd = eups.cmd.EupsCmd(args=cmd.split(), toolname=prog)
        self.assertNotEqual(cmd.run(), 0)
        self.assertNotEqual(self.err.getvalue(), "")
        self.assertEquals(self.out.getvalue(), "")

        self._resetOut()
        cmd = "declare -F newprod 1.0 -t current"
        cmd = eups.cmd.EupsCmd(args=cmd.split(), toolname=prog)
        self.assertEqual(cmd.run(), 0)
        self.assertEquals(self.err.getvalue(), "")
        self.assertEquals(self.out.getvalue(), "")

        myeups = eups.Eups()
        prod = myeups.findProduct("newprod")
        self.assert_(prod is not None, "product went missing after tagging")
        self.assert_("current" in prod.tags)

        self._resetOut()
        cmd = "undeclare newprod 1.0"
        cmd = eups.cmd.EupsCmd(args=cmd.split(), toolname=prog)
        self.assertEqual(cmd.run(), 0)
        self.assertEquals(self.err.getvalue(), "")
        self.assertEquals(self.out.getvalue(), "")

        myeups = eups.Eups()
        prod = myeups.findProduct("newprod")
        self.assert_(prod is None, "Failed to undeclare product")
        self.assert_(not os.path.isdir(newprod))

        self._resetOut()
        cmd = "declare newprod 1.0 -F -r %s -m %s -t current" % (pdir10, table)
        cmd = eups.cmd.EupsCmd(args=cmd.split(), toolname=prog)
        self.assertEqual(cmd.run(), 0)
        self.assertEquals(self.err.getvalue(), "")
        self.assertEquals(self.out.getvalue(), "")

        myeups = eups.Eups()
        prod = myeups.findProduct("newprod")
        self.assert_(prod is not None, "Failed to declare product")
        self.assertEquals(prod.name, "newprod")
        self.assertEquals(prod.version, "1.0")
        self.assertEquals(len(prod.tags), 1)
        self.assert_("current" in prod.tags)
        self.assert_(os.path.isdir(newprod))

        self._resetOut()
        cmd = "undeclare newprod 1.0"
        cmd = eups.cmd.EupsCmd(args=cmd.split(), toolname=prog)
        self.assertEqual(cmd.run(), 0)
        self.assertEquals(self.err.getvalue(), "")
        self.assertEquals(self.out.getvalue(), "")

        myeups = eups.Eups()
        prod = myeups.findProduct("newprod", Tag("current"))
        self.assert_(prod is None, "Failed to undeclare product")