def testRemoved(self):
"""Removed should be items in the second set
that are not in the first"""
modelOne = models.SensorType(id=1, name="foo", units="Co2")
modelTwo = models.RoomType(id=1, name="Bedroom")
modelThree = models.SensorType(id=2, name="bar")
modelFour = models.RoomType(id=2, name="Bathroom")
firstDict = {
1: modelOne,
2: modelTwo,
3: modelThree,
}
secondDict = {1: modelOne, 2: modelTwo, 3: modelThree, 4: modelFour}
dd = dictdiff.DictDiff(firstDict, secondDict)
added = dd.added()
removed = dd.removed()
changed = dd.changed()
unchanged = dd.unchanged()
emptySet = set()
testSet = set([4])
self.assertEqual(added, emptySet)
self.assertEqual(removed, testSet)
self.assertEqual(changed, emptySet)
def testEq(self):
"""Test for Equality"""
#Test Equality
item1 = models.SensorType(id=1,
name="Temperture",
code="T",
units="DegC",
c0=0,
c1=1,
c2=0,
c3=1)
item2 = models.SensorType(id=1,
name="Temperture",
code="T",
units="DegC",
c0=0,
c1=1,
c2=0,
c3=1)
self.assertEqual(item1, item2)
self.assertReallyEqual(item1, item2)
#Neither the C0,C1...
item2.c0 = 1
item2.c2 = 1
self.assertEqual(item1, item2)
self.assertReallyEqual(item1, item2)
def testCmp(self):
item1 = models.SensorType(id=1,
name="Temperture",
code="T",
units="DegC",
c0=0,
c1=1,
c2=0,
c3=1)
item2 = models.SensorType(id=1,
name="Temperture",
code="T",
units="DegC",
c0=0,
c1=1,
c2=0,
c3=1)
self.assertEqual(item1, item2)
#CMP on Id
item2.name = "A_Temperature"
self.assertGreater(item1, item2)
item2.name = "Z_Temperature"
self.assertLess(item1, item2)
def testChangedObject(self):
"""Items whose value differes between keys"""
modelOne = models.SensorType(id=1, name="foo", units="Co2")
modelTwo = models.RoomType(id=1, name="Bedroom")
modelThree = models.SensorType(id=2, name="bar")
#RoomType eqality is based on the name not Id
#Thus these two models should be the same
modelFour = models.RoomType(id=2, name="Bathroom")
modelFive = models.RoomType(id=1, name="Bathroom")
self.assertEqual(modelFour, modelFive)
#So for this first test we expect that there will be NO
#Unchanged items.
firstDict = {1: modelOne, 2: modelTwo, 3: modelThree, 4: modelFour}
secondDict = {1: modelOne, 2: modelTwo, 3: modelThree, 4: modelFive}
dd = dictdiff.DictDiff(firstDict, secondDict)
added = dd.added()
removed = dd.removed()
changed = dd.changed()
unchanged = dd.unchanged()
emptySet = set()
testSet = set([4])
self.assertEqual(added, emptySet)
self.assertEqual(removed, emptySet)
self.assertEqual(changed, emptySet)
#However lets run that again when the objects do not come out
#Equal
modelFive = models.RoomType(id=1, name="BathroomA")
self.assertNotEqual(modelFour, modelFive)
firstDict = {1: modelOne, 2: modelTwo, 3: modelThree, 4: modelFour}
secondDict = {1: modelOne, 2: modelTwo, 3: modelThree, 4: modelFive}
dd = dictdiff.DictDiff(firstDict, secondDict)
added = dd.added()
removed = dd.removed()
changed = dd.changed()
unchanged = dd.unchanged()
emptySet = set()
testSet = set([4])
self.assertEqual(added, emptySet)
self.assertEqual(removed, emptySet)
self.assertEqual(changed, testSet)
def test_sensortypes_remote(self):
"""Does Synching of sensortypes work as expected
Sensortypes should be synchronised across all servers.
Additionally, no sensortype should have an id conflict.
"""
#Remove the new objects we have added
rurl = "{0}sensortype/".format(RESTURL)
#First thing to check is that our local version of the database is as
#expected
session = self.Session()
qry = session.query(models.SensorType)
#As many sensor types as expected
self.assertEqual(qry.count(), NUM_SENSORTYPES)
#So Lets delete a couple of sensortypes and check they get added back
qry = session.query(models.SensorType).filter_by(id=1)
qry.delete()
qry = session.query(models.SensorType).filter_by(id=3)
qry.delete()
session.flush()
session.commit()
#So now we have removed the sensortypes we need to check they come back
self.pusher.sync_sensortypes()
session = self.Session()
qry = session.query(models.SensorType)
#As many sensor types as expected
self.assertEqual(qry.count(), NUM_SENSORTYPES)
qry = session.query(
models.SensorType).filter_by(name="Delta Temperature")
item = qry.first()
self.assertTrue(item)
self.assertEquals(item.id, 1)
qry = session.query(models.SensorType).filter_by(name="Delta Humidity")
item = qry.first()
self.assertTrue(item)
self.assertEquals(item.id, 3)
session.flush()
session.commit()
session.close()
"""What happens if we have more on the local server"""
session = self.Session()
sensor = models.SensorType(id=5000, name="Foo Sensor")
session.add(sensor)
session.flush()
session.commit()
#Now push
self.pusher.sync_sensortypes()
qry = requests.get(rurl)
self.assertEqual(len(qry.json()), NUM_SENSORTYPES + 1)
self.assertEqual(qry.json()[NUM_SENSORTYPES]["name"], "Foo Sensor")
def test_Rcv_Sensor(self):
"""Does Recieve work when that sensortype is not in the DB"""
now = datetime.datetime.utcnow()
#Create our bitmask
bs = Bitset(size=Packets.SC_SIZE)
#Try to setup a temperature sample
bs[Packets.SC_D_TEMPERATURE] = True
#Then A packet
packet = StateMsg(addr=4242)
packet.set_ctp_parent_id(101) #Parent Node Id
packet.set_special(0xc7) #Special Id
packet.set_packed_state_mask(bs.a)
packet.set_packed_state([22.5])
self.testbif.receive(packet)
output = self.blogger.mainloop()
self.assertTrue(output)
#Check stuff gets added to the database correctly
session = self.Session()
#Does the sensortype exist now (Apparently its not a FK in Reading)
#qry = session.query(models.SensorType).filter_by(id=1).first()
#self.assertTrue(qry)
#Is the name UNKNOWN
#self.assertEqual(qry.Name, "UNKNOWN")
#NodeState
qry = session.query(models.NodeState).filter_by(nodeId=4242)
self.assertEqual(qry.count(), 1)
qry = qry.first()
self.assertTrue(qry)
tdiff = qry.time - now
self.assertLess(tdiff.seconds, 1.0)
self.assertEqual(qry.parent, 101)
#And Reading
qry = session.query(models.Reading).filter_by(nodeId=4242)
#As we just did temperature there should only be one reading
self.assertEqual(qry.count(), 1)
qry = qry.first()
self.assertTrue(qry)
self.assertEqual(qry.typeId, 1)
self.assertEqual(qry.value, 22.5)
#Reset the sensor type to be as it should
qry = session.query(models.SensorType).filter_by(id=1).first()
if qry is None:
qry = models.SensorType(id=1)
session.add(qry)
qry.name = "Delta Temperature"
qry.code = "dT"
qry.units = "deg.C/s"
def testNEQ(self):
item1 = models.SensorType(id=1,
name="Temperture",
code="T",
units="DegC",
c0=0,
c1=1,
c2=0,
c3=1)
item2 = models.SensorType(id=1,
name="Temperture",
code="T",
units="DegC",
c0=0,
c1=1,
c2=0,
c3=1)
self.assertEqual(item1, item2)
item2.id = 2
self.assertNotEqual(item1, item2)
self.assertReallyNotEqual(item1, item2)
item2.id = 1
item2.name = "FOO"
self.assertNotEqual(item1, item2)
self.assertReallyNotEqual(item1, item2)
item2.name = "Temperature"
item2.code = "C"
self.assertNotEqual(item1, item2)
self.assertReallyNotEqual(item1, item2)
item2.code = "T"
item2.units = "PPM"
self.assertNotEqual(item1, item2)
self.assertReallyNotEqual(item1, item2)
def testEqual(self):
modelOne = models.SensorType(id=1, name="foo", units="Co2")
modelTwo = models.RoomType(id=1, name="Bedroom")
modelThree = models.SensorType(id=2, name="bar")
modelFour = models.RoomType(id=2, name="Bathroom")
firstDict = {1: modelOne, 2: modelTwo, 3: modelThree, 4: modelFour}
secondDict = {1: modelOne, 2: modelTwo, 3: modelThree, 4: modelFour}
dd = dictdiff.DictDiff(firstDict, secondDict)
added = dd.added()
removed = dd.removed()
changed = dd.changed()
unchanged = dd.unchanged()
emptySet = set()
self.assertEqual(added, emptySet)
self.assertEqual(removed, emptySet)
self.assertEqual(changed, emptySet)
def _serialobj(self):
"""Helper Method to provde an object to serialise"""
theItem = models.SensorType(id=1,
name="Temperature",
code="T",
units="DegC",
c0=0,
c1=1,
c2=0,
c3=1)
return theItem
def testChanged(self):
"""Items whose value differes between keys"""
modelOne = models.SensorType(id=1, name="foo", units="Co2")
modelTwo = models.RoomType(id=1, name="Bedroom")
modelThree = models.SensorType(id=2, name="bar")
modelFour = models.RoomType(id=2, name="Bathroom")
firstDict = {1: modelOne, 2: modelTwo, 3: modelThree, 4: modelFour}
secondDict = {1: modelOne, 2: modelTwo, 3: modelThree, 4: modelThree}
dd = dictdiff.DictDiff(firstDict, secondDict)
added = dd.added()
removed = dd.removed()
changed = dd.changed()
unchanged = dd.unchanged()
emptySet = set()
testSet = set([4])
self.assertEqual(added, emptySet)
self.assertEqual(removed, emptySet)
self.assertEqual(changed, testSet)
def __init__(self):
log = logging.getLogger(__name__)
self.log = log
log.debug("Starting Serial connection")
self.con = serial.Serial("/dev/ttyUSB0", 115200, timeout=10)
log.debug("Starting Database Connection")
engine = sqlalchemy.create_engine(DBFILE, echo=False)
#Actually not that fussed in this test code about creating stuff propery
meta.Base.metadata.bind = engine
meta.Base.metadata.create_all(engine)
meta.Session.configure(bind=engine)
log.debug("Populating Data")
#Populate with our intial dataset
models.populateData.init_data()
#And add our local sensor types
session = meta.Session()
sensortype = models.SensorType(id=HOPS, name="CTP hops")
session.merge(sensortype)
sensortype = models.SensorType(id=TX_PWR, name="Tx Power")
session.merge(sensortype)
sensortype = models.SensorType(id=N_COUNT, name="Neighbor Count")
session.merge(sensortype)
sensortype = models.SensorType(id=CTP_SEQ, name="CTP Sequence")
session.merge(sensortype)
sensortype = models.SensorType(id=2000, name="Neigh0")
session.merge(sensortype)
sensortype = models.SensorType(id=2001, name="Neigh1")
session.merge(sensortype)
sensortype = models.SensorType(id=2002, name="Neigh2")
session.merge(sensortype)
sensortype = models.SensorType(id=2003, name="Neigh3")
session.merge(sensortype)
session.flush()
session.commit()
