def setUp(self):
self.__log = DozerLogger("DozerGraph_unittest.log",
"test_DozerGraph",
toConsole=True)
self.package = "DummyTestPackage"
self.framework = "RTT"
self.nightly = "dev"
self.install = "build"
self.cmtconfig = "i686-slc4-gcc34-opt"
self.project = "AtlasProduction"
self.jobId = "job_1"
self.channel = DozerChannel("test channel", "test channel description")
self.channel += DozerData("double test data", "Double", "GeV")
self.channel += DozerData("double test data;error", "Double", "GeV")
self.channel += DozerData("int test data", "Int", "counts")
self.channel += DozerData("int test data;uperror", "Double", "counts")
self.channel += DozerData("int test data;downerror", "Double",
"counts")
today = DozerIOV()
self.pointsInTime = []
try:
import random
except ImportError:
exit(0)
for i in range(0, 30):
since = today.lastNDays(i)
until = today.lastNDays(i - 1)
if (i in (5, 10)): continue
chan = DozerChannel.fromXMLDoc(self.channel.xml())
if (i in (15, 20, 25)):
self.pointsInTime.append((since, until, chan))
else:
chan["double test data"].setValue(i + random.gauss(0.0, 3.0))
chan["double test data;error"].setValue(random.gauss(5.0, 5.0))
chan["int test data"].setValue(i + random.randrange(10, 20))
chan["int test data;uperror"].setValue(random.randrange(
10, 15))
chan["int test data;downerror"].setValue(
random.randrange(10, 15))
self.pointsInTime.append((since, until, chan))
print i
self.graph = DozerGraph(self.package, self.framework, self.nightly,
self.install, self.cmtconfig, self.project,
self.jobId, self.pointsInTime)
self.graph.style()
def setUp(self):
self.package = "Dummy"
self.framework = "RTT"
self.nightly = "dev"
self.install = "build"
self.cmtconfig = "i686-slc4-gcc34-opt"
self.project = "AtlasProduction"
self.jobId = "job_1"
globals()["test_DozerRecordSet_logger"] = DozerLogger(
"DozerRecordSet_unittest.log", toConsole=True)
self.__log = globals()["test_DozerRecordSet_logger"]
self.since = DozerIOV.fromRelease("rel_0").AsCool()
self.until = DozerIOV.fromRelease("rel_6").AsCool()
self.payload = DozerRecordSet(self.package, self.framework,
self.nightly, self.install,
self.cmtconfig, self.project, self.jobId,
self.since, self.until)
channel = DozerChannel("test channel", "test channel description")
channel += DozerData("IntDataRTT", "Int", "counts")
channel += DozerData("IntDataRTT;error", "Int", "counts")
channel += DozerData("FloatDataRTT", "Float", "some unit")
channel += DozerData("FloatDataRTT;uperror", "Float", "some unit")
channel += DozerData("FloatDataRTT;downerror", "Float", "some unit")
pointsInTime = {}
today = DozerIOV()
for i in range(30):
since = today.lastNDays(i - 1)
until = today.lastNDays(i)
ichan = DozerChannel.fromXMLDoc(channel.xml())
if (i != 10):
ichan.get("IntDataRTT").setValue(i)
ichan.get("IntDataRTT;error").setValue(5)
if (i % 3 != 0):
ichan.get("FloatDataRTT").setValue(i)
ichan.get("FloatDataRTT;uperror").setValue(i / 2.0)
ichan.get("FloatDataRTT;downerror").setValue(i / 4.0)
pointsInTime[(since, until)] = ichan
for k in sorted(pointsInTime.keys()):
since, until = k
val = pointsInTime[k].get("IntDataRTT").value()
self.__log.info("since %s until %s value %s" %
(str(since), str(until), str(val)))
self.payload += (since, until, pointsInTime[k])
def test_03_iadd_DozerData(self):
data = DozerData("test int data", "Int", "N_{obs}", log=self.__log)
try:
self.chan += data
except:
pass
self.assertEqual(isinstance(self.chan, DozerChannel), True)
def setUp(self):
self.__log = DozerLogger("DozerSchema_unittest.log",
"test_DozerSchema",
toConsole=True)
globals()["test_DozerSchema"] = self.__log
self.schema = DozerSchema("14.2.X.Y", "build", "i686-slc4-gcc34-opt",
"AtlasProduction", "job_1")
self.data1 = DozerData("int data name",
"int",
unit="kB",
log=self.__log)
self.data2 = DozerData("double data name",
"double",
unit="s",
log=self.__log)
self.chan = DozerChannel("data channel",
"channel description",
log=self.__log)
def test_04_in_Operator(self):
try:
data = DozerData("test int data", "Int", "N_{obs}", log=self.__log)
self.chan += data
except:
pass
self.assertEqual("test int data" in self.chan, True)
self.assertEqual(self.chan.keys(), [u"test int data"])
self.assertEqual(self.chan.has_key("test int data"), True)
for dataKey in self.chan:
self.__log.getLogger(self).info(self.chan[dataKey])
def test_05_evolution(self):
rtSchema = DozerSchema("bugfix", "build", "i686-slc4-gcc34-opt",
"AtlasProduction", "evo")
self.db = DozerDB("DummyTestPackage", "RTT", dry=True)
for i in range(1, 6):
self.db.openDB()
newChannel = DozerChannel(str(i), str(i))
newChannel += DozerData(str(i), "Int")
rtSchema += newChannel
self.db += rtSchema
self.db.closeDB()
def test_02_add(self):
channel = DozerChannel("test channel", "test channel description")
channel += DozerData("IntDataRTT", "Int", "counts")
channel += DozerData("IntDataRTT;error", "Int", "counts")
channel += DozerData("FloatDataRTT", "Float", "some unit")
channel += DozerData("FloatDataRTT;uperror", "Float", "some unit")
channel += DozerData("FloatDataRTT;downerror", "Float", "some unit")
print self.payload.since()
print self.payload.until()
pointsInTime = {}
today = DozerIOV()
for i in range(30):
since = today.lastNDays(i - 1)
until = today.lastNDays(i)
ichan = DozerChannel.fromXMLDoc(channel.xml())
ichan.get("IntDataRTT").setValue(i)
ichan.get("IntDataRTT;error").setValue(1)
pointsInTime[(since, until)] = ichan
for k in sorted(pointsInTime.keys()):
since, until = k
val = pointsInTime[k].get("IntDataRTT").value()
self.__log.info("since %s until %s value %s" %
(str(since), str(until), str(val)))
self.payload += (since, until, pointsInTime[k])
self.assertEqual(isinstance(self.payload, DozerRecordSet), True)
self.assertEqual(len(self.payload.dataNames()), 5)
def fromXMLDoc(cls, xmldoc, log=None):
channelNode = xmldoc.documentElement
if (channelNode.tagName == "channel"):
name = channelNode.getAttribute("name")
desc = channelNode.getAttribute("desc")
uuid = channelNode.getAttribute("uuid")
this = cls(name, desc, uuid, log)
for data in channelNode.getElementsByTagName("data"):
this += DozerData.fromXMLString(data.toxml(), log)
return this
else:
raise DozerError(
"cannot deserialize DozerChannel from XML Doc, document element tag (=<%s> isn't a <channel>"
% channelNode.tagName)
def test_07_get_path(self):
data1 = DozerData("test int data", "Int", "N_{obs}", log=self.__log)
data1.setValue(5)
data2 = DozerData("test string data", "String", "", log=self.__log)
data2.setValue("dummy string ! > < & @")
self.chan += data1
self.chan += data2
val = self.chan.get("/test int data").get().value()
self.assertEqual(val, 5)
val = self.chan.get("test int data").get().value()
self.assertEqual(val, 5)
self.__log.getLogger(self).panic("don't panic, this is intentional")
try:
val1 = self.chan.get("/a/b/c/")
except KeyError, value:
self.__log.getLogger(self).epanic(value)
def setUp(self):
self.__log = DozerLogger("test_CoolDozer.log",
"test_DozerDB",
toConsole=True)
self.__log.toConsole(True)
globals()["laoggerdjsfhksdj"] = self.__log
self.dataRTT = DozerData("testDataRTT", "Int", "N_{obs}")
self.chanRTT = DozerChannel("testChannelRTT",
"testChannelDescriptionRTT")
self.scheRTT = DozerSchema("*", "build", "i686-slc4-gcc34-opt",
"AtlasProduction", "job_1")
self.confRTT = DozerConfig("RTT")
self.chanRTT += self.dataRTT
self.scheRTT += self.chanRTT
self.confRTT += self.scheRTT
self.db = DozerDB("DummyTestPackage", "RTT", dry=True)
def test_06_XML_serialisation(self):
data = DozerData("test int data", "Int", "N_{obs}", log=self.__log)
self.chan += data
self.chan["test int data"].setValue(10)
xmldoc = self.chan.xml()
self.assertEqual(isinstance(xmldoc, xml.dom.minidom.Document), True)
self.__log.getLogger(self).info(xmldoc.toxml())
fromXMLDoc = None
try:
fromXMLDoc = DozerChannel.fromXMLDoc(xmldoc)
except:
pass
self.assertEqual(isinstance(fromXMLDoc, DozerChannel), True)
fromXMLString = None
try:
fromXMLString = DozerChannel.fromXMLString(xmldoc.toxml())
except:
pass
self.assertEqual(isinstance(fromXMLString, DozerChannel), True)
self.assertEqual(fromXMLString.xml().toxml(), fromXMLDoc.xml().toxml())
class test_DozerSchema(unittest.TestCase):
## setup test suite
# @param self "Me, myself and Irene"
def setUp(self):
self.__log = DozerLogger("DozerSchema_unittest.log",
"test_DozerSchema",
toConsole=True)
globals()["test_DozerSchema"] = self.__log
self.schema = DozerSchema("14.2.X.Y", "build", "i686-slc4-gcc34-opt",
"AtlasProduction", "job_1")
self.data1 = DozerData("int data name",
"int",
unit="kB",
log=self.__log)
self.data2 = DozerData("double data name",
"double",
unit="s",
log=self.__log)
self.chan = DozerChannel("data channel",
"channel description",
log=self.__log)
## testing __init__()
# @param self "Me, myself and Irene"
def test_01_constructor(self):
try:
self.schema = DozerSchema("14.2.X.Y",
"build",
"i686-slc4-gcc34-opt",
"AtlasProduction",
"job_1",
log=self.__log)
except:
pass
self.assertEqual(isinstance(self.schema, DozerSchema), True)
## testing nightly(), install(), cmtconfig(), project()
# @param self "me, myself and Irene"
def test_02_getters(self):
self.assertEqual(self.schema.nightly(), "14.2.X.Y")
self.assertEqual(self.schema.install(), "build")
self.assertEqual(self.schema.cmtconfig(), "i686-slc4-gcc34-opt")
self.assertEqual(self.schema.project(), "AtlasProduction")
self.assertEqual(self.schema.jobId(), "job_1")
self.assertEqual(self.schema.isExplicit(), True)
## testing +=, -=, in, keys(), []
# @param self "Me, myself and Irene"
def test_03_operators_DozerChannel(self):
try:
self.chan += self.data1
self.chan += self.data2
self.schema += self.chan
except:
pass
print self.schema.items()
print self.schema.iterkeys()
print self.schema.iteritems()
for key in self.schema.keys(byUUID=True):
self.__log.getLogger(self).panic("uuid=%s name=%s" %
(key, self.schema[key].name()))
for k, v in self.schema.iteritems(byUUID=True):
self.__log.getLogger(self).panic("uuid=%s name=%s" % (k, v))
print self.schema.items(byUUID=True)
print self.schema.iterkeys(byUUID=True)
print self.schema.iteritems(byUUID=True)
self.assertEqual(isinstance(self.schema, DozerSchema), True)
self.assertEqual(self.chan.name() in self.schema, True)
self.assertEqual(self.chan.uuid() in self.schema, True)
for key in self.schema:
self.__log.getLogger(self).info("uuid=%s name=%s" %
(key, self.schema[key].name()))
self.schema -= self.chan.name()
try:
self.schema += self.chan
except:
pass
self.schema -= self.chan.uuid()
## testing fromXMLString(), fromXMLDoc(), xml()
# @param self "Me, myself and Irene"
def test_05_XML_serialisation(self):
fromXMLDoc = None
fromXMLString = None
self.chan += self.data1
self.chan += self.data2
self.schema += self.chan
fromXMLDoc = self.schema.xml()
fromXMLString = fromXMLDoc.toxml()
fromXMLDoc = DozerSchema.fromXMLDoc(fromXMLDoc, log=self.__log)
fromXMLString = DozerSchema.fromXMLString(fromXMLString,
log=self.__log)
self.assertEqual(fromXMLDoc.xml().toxml(), fromXMLString.xml().toxml())
self.__log.getLogger(self).info(fromXMLDoc)
self.__log.getLogger(self).info(fromXMLString)
## testing setVersion()
# @param self "Me, myself and Irene"
def test_06_setters(self):
version = int(self.schema.version())
try:
self.schema.setVersion(version + 1)
except:
pass
self.assertEqual(version + 1, int(self.schema.version()))
## testing get()
# @param self "Me, myself and Irene"
def test_07_get(self):
self.chan += self.data1
self.chan += self.data2
self.schema += self.chan
sche = self.schema.get()
self.assertEqual(isinstance(sche, DozerSchema), True)
sche = self.schema.get("")
self.assertEqual(isinstance(sche, DozerSchema), True)
path = self.chan.uuid() + "/"
chan = self.schema.get(path)
self.assertEqual(isinstance(chan, DozerChannel), True)
path = self.chan.uuid() + "/" + self.data1.name()
data = self.schema.get(path)
self.assertEqual(isinstance(data, DozerData), True)
path = self.chan.name() + "/" + self.data2.name()
data = self.schema.get(path)
self.assertEqual(isinstance(data, DozerData), True)
path = self.schema.pathChunk()
print path
def test_05_isub_DozerData(self):
data = DozerData("test int data", "Int", "N_{obs}", log=self.__log)
self.chan += data
self.chan -= "test int data"
self.assertEqual(self.chan.keys(), [])