import unittest

class Mock_Alert_Config() :
   def __init__(self) :
      self.cache = {}
      self.level = {}
      self.id = "id"

   def set_level(self, k, v) :
      self.level[k] = v

   def get_level(self, k) :
      if not k in self.level :
         return None
      return self.level[k]

   def init_for_tags(self, *args) :
      pass

   def occurrences(self) :
      return 1

   def get_threshold(self, upper, warning) :
      if warning :
         return None, False
      if upper :
         return 10, True
      else :
         return 0, True

   def get_tags(self) :
      return "tagsC, tagsD".split(", ")

   def set_for_tags(self, key, value) :
      if not key in self.cache :
         self.cache[key] = 0
      self.cache[key] = value

   def get_for_tags(self, key) :
      if not key in self.cache :
         self.cache[key] = 0
      return self.cache[key]

class Mock_Result() :
   def __init__(self) :
      pass

   def __getitem__(self, key) :
      if key == "tags" :
         return self
      else :
         return key

class Mock_Logger() :
   def __init__(self) :
      for k in ["error", "warn", "debug", "info", "warning"] :
         setattr(self, k, self.log)

   def log(self, *args) :
      pass

class Test_Alert(unittest.TestCase) :
   def test_set_tags(self) :
      import alert
      ac = Mock_Alert_Config()
      res = Mock_Result()

      al = alert.Alert(ac, Mock_Logger(), None, None, -1, 11)
      self.assertEqual(al.get_tags(), "instance")

      al = alert.Alert(ac, Mock_Logger(), "tagsA, tagsB", res, -1, 11)
      self.assertEqual(al.get_tags(), "tagsA, tagsB")

      al.set_tags("a, b, c", res)
      self.assertEqual(al.get_tags(), "a, b, c")

      al.set_tags("a, b, c", res)
      self.assertEqual(al.get_tags(), "a, b, c")

   def test_firing(self) :
      import alert
      ac = Mock_Alert_Config()
      res = Mock_Result()
      al = alert.Alert(ac, Mock_Logger(), "tagsA, tagsB", res, -1, 11)
      self.assertTrue(al.get_firing())
      al = alert.Alert(ac, Mock_Logger(), "tagsA, tagsB", res, 1, 11)
      self.assertTrue(al.get_firing())
      al = alert.Alert(ac, Mock_Logger(), "tagsA, tagsB", res, -1, 9)
      self.assertTrue(al.get_firing())
      al = alert.Alert(ac, Mock_Logger(), "tagsA, tagsB", res, 1, 9)
      self.assertFalse(al.get_firing())

   def test_str(self) :
      import alert
      ac = Mock_Alert_Config()
      res = Mock_Result()
      alert = alert.Alert(ac, Mock_Logger(), "tagsA, tagsB", res, 0, 10)

      self.assertEqual(alert.name(), "Metric: id for tagsA, tagsB")
      self.assertEqual(alert.body(), "")

   def test_occurrences(self) :
      import alert
      ac = Mock_Alert_Config()
      res = Mock_Result()
      al = alert.Alert(ac, Mock_Logger(), "tagsA, tagsB", res, 0, 10)
      self.assertEqual(False, al.occurrences_breached)
      al.set_occurrences()
      al.set_occurrences()
      al.set_occurrences()
      self.assertEqual(False, al.occurrences_breached)
      self.assertEqual(0, ac.get_for_tags(al.get_tags()))

      al = alert.Alert(ac, Mock_Logger(), "tagsA, tagsB", res, 0, 11)
      self.assertEqual(True, al.occurrences_breached)
      al.set_occurrences()
      al.set_occurrences()
      al.set_occurrences()
      self.assertEqual(True, al.occurrences_breached)
      self.assertEqual(4, ac.get_for_tags(al.get_tags()))

if __name__ == "__main__" :
   unittest.main()