locking: Change locking order, move NAL after instances

[ganeti-local] / test / ganeti.cli_unittest.py

diff --git a/test/ganeti.cli_unittest.py b/test/ganeti.cli_unittest.py
index 2231c29..5cb4869 100755 (executable)
--- a/test/ganeti.cli_unittest.py
+++ b/test/ganeti.cli_unittest.py
@@ -22,6 +22,7 @@
 """Script for unittesting the cli module"""
 
 import unittest
 """Script for unittesting the cli module"""
 
 import unittest

+import time

 from cStringIO import StringIO
 
 import ganeti
 from cStringIO import StringIO
 
 import ganeti

@@ -42,14 +43,14 @@ class TestParseTimespec(unittest.TestCase):
   def testValidTimes(self):
     """Test valid timespecs"""
     test_data = [
   def testValidTimes(self):
     """Test valid timespecs"""
     test_data = [

-      ('1s', 1),
-      ('1', 1),
-      ('1m', 60),
-      ('1h', 60 * 60),
-      ('1d', 60 * 60 * 24),
-      ('1w', 60 * 60 * 24 * 7),
-      ('4h', 4 * 60 * 60),
-      ('61m', 61 * 60),
+      ("1s", 1),
+      ("1", 1),
+      ("1m", 60),
+      ("1h", 60 * 60),
+      ("1d", 60 * 60 * 24),
+      ("1w", 60 * 60 * 24 * 7),
+      ("4h", 4 * 60 * 60),
+      ("61m", 61 * 60),

       ]
     for value, expected_result in test_data:
       self.failUnlessEqual(cli.ParseTimespec(value), expected_result)
       ]
     for value, expected_result in test_data:
       self.failUnlessEqual(cli.ParseTimespec(value), expected_result)

@@ -57,10 +58,10 @@ class TestParseTimespec(unittest.TestCase):
   def testInvalidTime(self):
     """Test invalid timespecs"""
     test_data = [
   def testInvalidTime(self):
     """Test invalid timespecs"""
     test_data = [

-      '1y',
-      '',
-      'aaa',
-      's',
+      "1y",
+      "",
+      "aaa",
+      "s",

       ]
     for value in test_data:
       self.failUnlessRaises(OpPrereqError, cli.ParseTimespec, value)
       ]
     for value in test_data:
       self.failUnlessRaises(OpPrereqError, cli.ParseTimespec, value)

@@ -85,6 +86,7 @@ class TestSplitKeyVal(unittest.TestCase):
     """Test how we handle splitting an empty string"""
     self.failUnlessEqual(cli._SplitKeyVal("option", ""), {})
 
     """Test how we handle splitting an empty string"""
     self.failUnlessEqual(cli._SplitKeyVal("option", ""), {})
 

+

 class TestIdentKeyVal(unittest.TestCase):
   """Testing case for cli.check_ident_key_val"""
 
 class TestIdentKeyVal(unittest.TestCase):
   """Testing case for cli.check_ident_key_val"""
 

@@ -102,6 +104,17 @@ class TestIdentKeyVal(unittest.TestCase):
     self.assertEqual(cikv("-foo"), ("foo", None))
     self.assertRaises(ParameterError, cikv, "-foo:a=c")
 
     self.assertEqual(cikv("-foo"), ("foo", None))
     self.assertRaises(ParameterError, cikv, "-foo:a=c")
 

+    # Check negative numbers
+    self.assertEqual(cikv("-1:remove"), ("-1", {
+      "remove": True,
+      }))
+    self.assertEqual(cikv("-29447:add,size=4G"), ("-29447", {
+      "add": True,
+      "size": "4G",
+      }))
+    for i in ["-:", "-"]:
+      self.assertEqual(cikv(i), ("", None))
+

 
 class TestToStream(unittest.TestCase):
   """Test the ToStream functions"""
 
 class TestToStream(unittest.TestCase):
   """Test the ToStream functions"""

@@ -115,7 +128,7 @@ class TestToStream(unittest.TestCase):
                  ]:
       buf = StringIO()
       cli._ToStream(buf, data)
                  ]:
       buf = StringIO()
       cli._ToStream(buf, data)

-      self.failUnlessEqual(buf.getvalue(), data+'\n')
+      self.failUnlessEqual(buf.getvalue(), data + "\n")

 
   def testParams(self):
       buf = StringIO()
 
   def testParams(self):
       buf = StringIO()

@@ -896,5 +909,106 @@ class TestGetOnlineNodes(unittest.TestCase):
     self.assertEqual(cl.CountPending(), 0)
 
 
     self.assertEqual(cl.CountPending(), 0)
 
 

-if __name__ == '__main__':
+class TestFormatTimestamp(unittest.TestCase):
+  def testGood(self):
+    self.assertEqual(cli.FormatTimestamp((0, 1)),
+                     time.strftime("%F %T", time.localtime(0)) + ".000001")
+    self.assertEqual(cli.FormatTimestamp((1332944009, 17376)),
+                     (time.strftime("%F %T", time.localtime(1332944009)) +
+                      ".017376"))
+
+  def testWrong(self):
+    for i in [0, [], {}, "", [1]]:
+      self.assertEqual(cli.FormatTimestamp(i), "?")
+
+
+class TestFormatUsage(unittest.TestCase):
+  def test(self):
+    binary = "gnt-unittest"
+    commands = {
+      "cmdA":
+        (NotImplemented, NotImplemented, NotImplemented, NotImplemented,
+         "description of A"),
+      "bbb":
+        (NotImplemented, NotImplemented, NotImplemented, NotImplemented,
+         "Hello World," * 10),
+      "longname":
+        (NotImplemented, NotImplemented, NotImplemented, NotImplemented,
+         "Another description"),
+      }
+
+    self.assertEqual(list(cli._FormatUsage(binary, commands)), [
+      "Usage: gnt-unittest {command} [options...] [argument...]",
+      "gnt-unittest <command> --help to see details, or man gnt-unittest",
+      "",
+      "Commands:",
+      (" bbb      - Hello World,Hello World,Hello World,Hello World,Hello"
+       " World,Hello"),
+      "            World,Hello World,Hello World,Hello World,Hello World,",
+      " cmdA     - description of A",
+      " longname - Another description",
+      "",
+      ])
+
+
+class TestParseArgs(unittest.TestCase):
+  def testNoArguments(self):
+    for argv in [[], ["gnt-unittest"]]:
+      try:
+        cli._ParseArgs("gnt-unittest", argv, {}, {}, set())
+      except cli._ShowUsage, err:
+        self.assertTrue(err.exit_error)
+      else:
+        self.fail("Did not raise exception")
+
+  def testVersion(self):
+    for argv in [["test", "--version"], ["test", "--version", "somethingelse"]]:
+      try:
+        cli._ParseArgs("test", argv, {}, {}, set())
+      except cli._ShowVersion:
+        pass
+      else:
+        self.fail("Did not raise exception")
+
+  def testHelp(self):
+    for argv in [["test", "--help"], ["test", "--help", "somethingelse"]]:
+      try:
+        cli._ParseArgs("test", argv, {}, {}, set())
+      except cli._ShowUsage, err:
+        self.assertFalse(err.exit_error)
+      else:
+        self.fail("Did not raise exception")
+
+  def testUnknownCommandOrAlias(self):
+    for argv in [["test", "list"], ["test", "somethingelse", "--help"]]:
+      try:
+        cli._ParseArgs("test", argv, {}, {}, set())
+      except cli._ShowUsage, err:
+        self.assertTrue(err.exit_error)
+      else:
+        self.fail("Did not raise exception")
+
+  def testInvalidAliasList(self):
+    cmd = {
+      "list": NotImplemented,
+      "foo": NotImplemented,
+      }
+    aliases = {
+      "list": NotImplemented,
+      "foo": NotImplemented,
+      }
+    assert sorted(cmd.keys()) == sorted(aliases.keys())
+    self.assertRaises(AssertionError, cli._ParseArgs, "test",
+                      ["test", "list"], cmd, aliases, set())
+
+  def testAliasForNonExistantCommand(self):
+    cmd = {}
+    aliases = {
+      "list": NotImplemented,
+      }
+    self.assertRaises(errors.ProgrammerError, cli._ParseArgs, "test",
+                      ["test", "list"], cmd, aliases, set())
+
+
+if __name__ == "__main__":

   testutils.GanetiTestProgram()
   testutils.GanetiTestProgram()