def test(self):
truncateTable('submitted_target')
dao = SubmittedTargetDAO(defaultConfigPath())
testIns = submitted_target()
testIns.shape = 'square'
testIns.type = 'standard'
testIns.crop_path = '/another/totally/real/crop/path/ikr.jpg'
testIns.background_color = 'white'
testIns.alphanumeric = "T"
testIns.alphanumeric_color = "orange"
testIns.autonomous = False
testIns.target = 10
self.assertNotEqual(dao.upsertTarget(testIns), -1)
resultingModel = dao.getTarget(10, False)
self.assertIsNotNone(resultingModel)
self.assertEqual(resultingModel.target, 10)
self.assertFalse(resultingModel.autonomous)
self.assertEqual(resultingModel.type, 'standard')
self.assertEqual(resultingModel.crop_path,
'/another/totally/real/crop/path/ikr.jpg')
self.assertEqual(resultingModel.shape, 'square')
self.assertEqual(resultingModel.background_color, 'white')
self.assertEqual(resultingModel.alphanumeric, 'T')
self.assertEqual(resultingModel.alphanumeric_color, 'orange')
self.assertEqual(resultingModel.submitted, 'pending')
self.assertIsNone(resultingModel.latitude)
self.assertIsNone(resultingModel.longitude)
self.assertIsNone(resultingModel.orientation)
def test(self):
model = incoming_image()
model.time_stamp = 1547453775.2
model.focal_length = 16.0
model.image_path = '/im/a/totally/real/path/i/swear.jpg'
model.manual_tap = False
model.autonomous_tap = False
truncateTable('incoming_image')
dao = IncomingImageDAO(defaultConfigPath())
self.assertIsNotNone(dao)
# test with empty table
self.assertIsNone(dao.getImage(1))
resultingId = dao.addImage(model)
self.assertNotEqual(resultingId, -1)
resultingModel = dao.getImage(resultingId)
self.assertIsNotNone(resultingModel)
self.assertAlmostEqual(resultingModel.time_stamp, model.time_stamp)
self.assertEqual(resultingModel.focal_length, model.focal_length)
self.assertEqual(resultingModel.image_path, model.image_path)
self.assertEqual(resultingModel.manual_tap, model.manual_tap)
self.assertEqual(resultingModel.autonomous_tap, model.autonomous_tap)
def test(self):
truncateTable('submitted_target')
dao = SubmittedTargetDAO(defaultConfigPath())
# none should fail to insert
result = dao.upsertTarget(None)
self.assertIsNotNone(result)
self.assertEqual(result, -1)
testIns = submitted_target()
testIns.shape = 'square'
testIns.type = 'standard'
testIns.crop_path = '/another/totally/real/crop/path/ikr.jpg'
testIns.background_color = 'white'
testIns.alphanumeric = "T"
testIns.alphanumeric_color = "orange"
# should fail when we try and upsert an image that doesn't have a target or autonomous field
self.assertEqual(dao.upsertTarget(testIns), -1)
testIns.autonomous = False
# should fail when we try and upsert an image that doesn't have a target field
self.assertEqual(dao.upsertTarget(testIns), -1)
testIns.target = 10
self.assertNotEqual(dao.upsertTarget(testIns), -1)
def test(self):
truncateTable('outgoing_manual')
dao = OutgoingManualDAO(defaultConfigPath())
# see how it works on an empty table
self.assertIsNone(dao.submitAllPendingTargets())
# this will insert records for 2 different targets from 3 classifications:
testIns = outgoing_manual()
testIns.crop_id = 42
testIns.shape = 'circle'
testIns.background_color = 'white'
testIns.alphanumeric = 'A'
testIns.alphanumeric_color = 'black'
dao.addClassification(testIns)
testIns.crop_id = 43
dao.addClassification(testIns)
testIns.crop_id = 44
testIns.alphanumeric = 'C'
testIns.submitted = 'submitted' # this wont work -> it should still be unsubmitted
dao.addClassification(testIns)
result = dao.submitAllPendingTargets()
self.assertIsNotNone(result)
self.assertEqual(len(result), 2) # should have 2 targets
def test(self):
testIns = outgoing_manual()
testIns.crop_id = 42
testIns.type = 'standard'
testIns.orientation = 'NE'
testIns.shape = 'star'
testIns.background_color = 'blue'
testIns.alphanumeric = 'A'
testIns.alphanumeric_color = 'purple'
testIns.latitude = 40.11111
testIns.longitude = -111.222222
truncateTable('outgoing_manual')
dao = OutgoingManualDAO(defaultConfigPath())
id = dao.addClassification(testIns)
self.assertNotEqual(id, -1)
model = dao.getClassification(id)
self.assertIsNotNone(model)
classOut = dao.submitPendingTarget(model.target)
self.assertIsNotNone(classOut)
imgPath = os.path.dirname(os.path.realpath(__file__)) + '/assets/star.png'
targetOut = submitted_target(outgoingManualOrAutonomous=classOut, autonomous_in=False)
targetOut.crop_path = imgPath
auvsiDao = AuvsiOdlcDao()
auvsiDao.addTarget(targetOut)
def test(self):
# insert some targets
dao = OutgoingManualDAO(defaultConfigPath())
truncateTable('outgoing_manual')
# see what it does with an empty table:
self.assertIsNone(dao.submitPendingTarget(1))
testIns = outgoing_manual()
testIns.crop_id = 42
testIns.latitude = 40.111
testIns.longitude = -111.111
testIns.orientation = 'N'
testIns.shape = 'circle'
testIns.background_color = 'white'
testIns.alphanumeric = 'A'
testIns.alphanumeric_color = 'black'
self.assertIsNot(dao.addClassification(testIns), -1)
testIns.crop_id = 43
testIns.latitude = 40.222
testIns.longitude = -111.222
testIns.orientation = 'NE'
testIns.background_color = 'orange'
self.assertIsNot(dao.addClassification(testIns), -1)
testIns.crop_id = 44
testIns.latitude = 40.333
testIns.longitude = -111.333
testIns.alphanumeric_color = 'white'
resultingId = dao.addClassification(testIns)
self.assertIsNot(resultingId, -1)
classResult = dao.getClassification(resultingId)
submissionResult = dao.submitPendingTarget(classResult.target)
self.assertAlmostEqual(submissionResult.latitude, 40.222)
self.assertAlmostEqual(submissionResult.longitude, -111.222)
self.assertEqual(submissionResult.orientation, 'NE')
self.assertEqual(submissionResult.background_color, 'orange')
self.assertEqual(submissionResult.alphanumeric_color, 'black')
self.assertEqual(submissionResult.alphanumeric, 'A')
self.assertEqual(submissionResult.shape, 'circle')
# make sure that when we submit another classification that belongs
# to the same target that its submitted state automatically goes to
# 'inherited_submission'
testIns.crop_id = 45
resultingId = dao.addClassification(testIns)
self.assertNotEqual(resultingId, -1)
classResult = dao.getClassification(resultingId)
self.assertIsNotNone(classResult)
self.assertEqual(classResult.submitted, 'inherited_submission')
def test(self):
truncateTable('incoming_image')
dao = IncomingImageDAO(defaultConfigPath())
self.assertIsNotNone(dao)
# test with empty table
self.assertIsNone(dao.getNextImage(True))
self.assertIsNone(dao.getNextImage(False))
model = incoming_image()
model.time_stamp = 1547453775.2
model.focal_length = 16.0
model.image_path = '/im/a/totally/real/path/i/swear.jpg'
model.manual_tap = False
model.autonomous_tap = False
resultingId = dao.addImage(model)
self.assertNotEqual(resultingId, -1)
# identical timestamps should make no difference
model.focal_length = 16.0
model.image_path = '/im/a/totally/real/path/2/i/swear.jpg'
resultingId2 = dao.addImage(model)
self.assertNotEqual(resultingId2, -1)
resultModel = dao.getNextImage(True)
self.assertIsNotNone(resultModel)
self.assertEqual(resultModel.image_id, resultingId)
self.assertTrue(resultModel.manual_tap)
self.assertFalse(resultModel.autonomous_tap)
resultModel = dao.getNextImage(True)
self.assertIsNotNone(resultModel)
self.assertEqual(resultModel.image_id, resultingId2)
self.assertTrue(resultModel.manual_tap)
self.assertFalse(resultModel.autonomous_tap)
resultModel = dao.getNextImage(False)
self.assertIsNotNone(resultModel)
self.assertEqual(resultModel.image_id, resultingId)
self.assertTrue(resultModel.manual_tap)
self.assertTrue(resultModel.autonomous_tap)
resultModel = dao.getNextImage(True)
self.assertIsNone(resultModel)
resultModel = dao.getNextImage(False)
self.assertIsNotNone(resultModel)
self.assertEqual(resultModel.image_id, resultingId2)
self.assertTrue(resultModel.manual_tap)
self.assertTrue(resultModel.autonomous_tap)
resultModel = dao.getNextImage(False)
self.assertIsNone(resultModel)
def test(self):
model = incoming_state()
model.time_stamp = 1547453775.2
model.roll = 40.111
model.pitch = -111.222
model.yaw = 12.3
truncateTable('incoming_state')
dao = IncomingStateDAO(defaultConfigPath())
self.assertIsNotNone(dao)
resultingId = dao.addState(model)
self.assertIsNotNone(resultingId)
self.assertNotEqual(resultingId, -1)
def test(self):
model = incoming_gps()
model.time_stamp = 1547453775.2
model.lat = 40.111
model.lon = -111.222
model.alt = 1234.5
truncateTable('incoming_gps')
dao = IncomingGpsDAO(defaultConfigPath())
resultingId = dao.addGps(model)
self.assertIsNotNone(resultingId)
self.assertNotEqual(resultingId, -1)
def test(self):
# Note: the closest TS function doesnt work by absolute closest,
# but instead for ease, speed and readability, just checks <=
# These tests reflect this type of functionality and would probably have
# to be redone if true closest TS was ever implemented
truncateTable('incoming_gps')
dao = IncomingGpsDAO(defaultConfigPath())
self.assertIsNotNone(dao)
baseTs = 1547453775.2
# test on empty table
resultModel = dao.getGpsByClosestTS(baseTs)
self.assertIsNone(resultModel)
model = incoming_gps()
model.time_stamp = baseTs
model.lat = 40.111
model.lon = -111.222
model.alt = 1234.5
resultingId1 = dao.addGps(model)
self.assertNotEqual(resultingId1, -1)
model.time_stamp = baseTs + 20000
model.lat = 40.222
model.lon = -111.333
model.alt = 5678.9
resultingId2 = dao.addGps(model)
self.assertNotEqual(resultingId2, -1)
# as explained above, this should return None
resultModel = dao.getGpsByClosestTS(baseTs - 10000)
self.assertIsNone(resultModel)
resultModel = dao.getGpsByClosestTS(baseTs + 1000)
self.assertIsNotNone(resultModel)
self.assertEqual(resultModel.id, resultingId1)
# while this is absolutely closer to id2, we should
# still get id1 for the spec reasons described at the
# top of this method
resultModel = dao.getGpsByClosestTS(baseTs + 15000)
self.assertIsNotNone(resultModel)
self.assertEqual(resultModel.id, resultingId1)
# test when time is exactly equal
resultModel = dao.getGpsByClosestTS(baseTs + 20000)
self.assertIsNotNone(resultModel)
self.assertEqual(resultModel.id, resultingId2)
def test(self):
truncateTable('outgoing_manual')
dao = OutgoingManualDAO(defaultConfigPath())
testIns = outgoing_manual()
testIns.crop_id = 42
testIns.shape = 'circle'
testIns.background_color = 'white'
testIns.alphanumeric = 'A'
testIns.alphanumeric_color = 'black'
self.assertNotEqual(dao.addClassification(testIns), -1)
# should now fail to insert a duplicate crop_id
self.assertEqual(dao.addClassification(testIns), -1)
self.assertIsNotNone(dao.getClassificationByUID(42))
def test(self):
truncateTable("incoming_gps")
dao = IncomingGpsDAO(defaultConfigPath())
# empty table
self.assertIsNone(dao.getAll())
# insert a couple rows
model = incoming_gps()
baseTs = 1547453775.2
model.time_stamp = baseTs
model.lat = 40.111
model.lon = -111.222
model.alt = 1234.5
resultingId1 = dao.addGps(model)
self.assertNotEqual(resultingId1, -1)
model.time_stamp = baseTs + 20000
model.lat = 40.222
model.lon = -111.333
model.alt = 5678.9
resultingId2 = dao.addGps(model)
self.assertNotEqual(resultingId2, -1)
results = dao.getAll()
self.assertIsNotNone(results)
self.assertEqual(len(results), 2)
if results[0].id == resultingId1:
self.assertAlmostEqual(results[0].lat, 40.111)
self.assertAlmostEqual(results[0].lon, -111.222)
self.assertAlmostEqual(results[0].alt, 1234.5)
self.assertAlmostEqual(results[1].lat, 40.222)
self.assertAlmostEqual(results[1].lon, -111.333)
self.assertAlmostEqual(results[1].alt, 5678.9)
elif results[0].id == resultingId2:
self.assertAlmostEqual(results[1].lat, 40.111)
self.assertAlmostEqual(results[1].lon, -111.222)
self.assertAlmostEqual(results[1].alt, 1234.5)
self.assertAlmostEqual(results[0].lat, 40.222)
self.assertAlmostEqual(results[0].lon, -111.333)
self.assertAlmostEqual(results[0].alt, 5678.9)
else:
self.fail("dont recognize one of the ids returned by gps.getAll")
def test(self):
truncateTable('outgoing_autonomous')
dao = OutgoingAutonomousDAO(defaultConfigPath())
testIns = outgoing_autonomous()
testIns.crop_id = 42
testIns.shape = 'circle'
testIns.background_color = 'white'
testIns.alphanumeric = 'A'
testIns.alphanumeric_color = 'black'
resultingId = dao.addClassification(testIns)
self.assertNotEqual(resultingId, -1)
# should not be able to insert a duplicate record
self.assertEqual(dao.addClassification(testIns), -1)
self.assertIsNotNone(dao.getClassification(resultingId))
def setupClientRestTestDb():
# truncate all the tables:
truncateTable('incoming_image')
truncateTable('incoming_gps')
truncateTable('incoming_state')
truncateTable('outgoing_manual')
truncateTable('outgoing_autonomous')
# figure out the absolute path to our raw test image:
rawImg = os.path.abspath(
os.path.dirname(os.path.realpath(__file__)) +
'/test/assets/rawFrame.jpg')
# setup incoming tables
setupIncomingImageTable(rawImg)
setupIncomingGpsTable()
setupIncomingStateTable()
def test(self):
truncateTable('submitted_target')
dao = SubmittedTargetDAO(defaultConfigPath())
# empty table
self.assertIsNone(dao.getAllTargets(False))
self.assertIsNone(dao.getAllTargets(True))
testIns = submitted_target()
testIns.shape = 'square'
testIns.type = 'standard'
testIns.crop_path = '/another/totally/real/crop/path/ikr.jpg'
testIns.background_color = 'white'
testIns.alphanumeric = "T"
testIns.alphanumeric_color = "orange"
testIns.autonomous = False
testIns.target = 10
self.assertNotEqual(dao.upsertTarget(testIns), -1)
testIns.shape = 'circle'
testIns.target = 15
self.assertNotEqual(dao.upsertTarget(testIns), -1)
testIns.autonomous = True
testIns.alphanumeric = "Y"
testIns.alphanumeric_color = 'purple'
self.assertNotEqual(dao.upsertTarget(testIns), -1)
targetList = dao.getAllTargets(False)
self.assertIsNotNone(targetList)
self.assertEqual(len(targetList), 2)
# spot check a couple values to confirm the thing was really added to list properly
self.assertEqual(targetList[0].type, 'standard')
self.assertEqual(targetList[1].type, 'standard')
self.assertEqual(targetList[0].crop_path,
'/another/totally/real/crop/path/ikr.jpg')
self.assertEqual(targetList[1].crop_path,
'/another/totally/real/crop/path/ikr.jpg')
self.assertFalse(targetList[0].autonomous)
self.assertFalse(targetList[1].autonomous)
# get the one autonomous target
targetList = dao.getAllTargets(True)
self.assertIsNotNone(targetList)
self.assertEqual(len(targetList), 1)
def test(self):
truncateTable("cropped_manual")
dao = CroppedManualDAO(defaultConfigPath())
model = cropped_manual()
model.image_id = 123
model.time_stamp = 1547453775.2
model.cropped_path = '/im/a/totally/real/cropped/path/i/swear.jpg'
model.crop_coordinate_br = "(12,34)"
model.crop_coordinate_tl = "(56,78)"
resultingId = dao.upsertCropped(model)
self.assertNotEqual(resultingId, -1)
updateContent = {
"time_stamp": model.time_stamp + 1000,
"image_id": 456
}
# confirm update to bad id does nothing
self.assertIsNone(dao.updateImage(resultingId + 20, updateContent))
resultingModel = dao.getImage(resultingId)
# confirm that nothing was changed in our one row:
self.assertIsNotNone(resultingModel)
self.assertEqual(resultingId, resultingModel.crop_id)
self.assertEqual(model.time_stamp, resultingModel.time_stamp)
self.assertEqual(model.image_id, resultingModel.image_id)
self.assertEqual(model.cropped_path, resultingModel.cropped_path)
self.assertEqual(model.crop_coordinate_br.__str__(),
resultingModel.crop_coordinate_br.__str__())
self.assertEqual(model.crop_coordinate_tl.__str__(),
resultingModel.crop_coordinate_tl.__str__())
self.assertFalse(resultingModel.tapped)
# do a legit update now:
resultingModel = dao.updateImage(resultingId, updateContent)
self.assertIsNotNone(resultingModel)
self.assertEqual(resultingId, resultingModel.crop_id)
self.assertEqual(resultingModel.image_id, 456)
self.assertEqual(model.time_stamp + 1000, resultingModel.time_stamp)
self.assertEqual(model.cropped_path, resultingModel.cropped_path)
self.assertEqual(model.crop_coordinate_br.__str__(),
resultingModel.crop_coordinate_br.__str__())
self.assertEqual(model.crop_coordinate_tl.__str__(),
resultingModel.crop_coordinate_tl.__str__())
self.assertFalse(resultingModel.tapped)
def test(self):
"""
Currently the method that we're testing here isnt used by the api, but
its good to test andways since it exists, and is pretty basic - meaning it
will catch some simpler errors before we go to the complicated ones
"""
model = cropped_manual()
model.image_id = 123
model.time_stamp = 1547453775.2
model.cropped_path = '/im/a/totally/real/cropped/path/i/swear.jpg'
truncateTable('cropped_manual')
dao = CroppedManualDAO(defaultConfigPath())
self.assertEqual(dao.addImage(None), -1)
resultingId = dao.addImage(model)
self.assertIsNotNone(resultingId)
self.assertNotEqual(resultingId, -1)
def test(self):
truncateTable('cropped_manual')
dao = CroppedManualDAO(defaultConfigPath())
self.assertIsNone(dao.getNextImage())
model = cropped_manual()
model.image_id = 123
model.time_stamp = 1547453775.2
model.cropped_path = '/im/a/totally/real/cropped/path/i/swear.jpg'
model.crop_coordinate_br = "(12,34)"
model.crop_coordinate_tl = "(56,78)"
resultingId = dao.upsertCropped(model)
self.assertNotEqual(resultingId, -1)
model.cropped_path = '/im/a/totally/real/cropped/path/2/i/swear.jpg'
model.image_id = 456
resultingId2 = dao.upsertCropped(model)
self.assertNotEqual(resultingId2, -1)
resultModel = dao.getNextImage()
self.assertIsNotNone(resultModel)
self.assertEqual(resultModel.crop_id, resultingId)
self.assertTrue(resultModel.tapped)
self.assertEqual(resultModel.image_id, 123)
self.assertEqual(resultModel.crop_coordinate_tl.__str__(),
model.crop_coordinate_tl)
self.assertEqual(resultModel.crop_coordinate_br.__str__(),
model.crop_coordinate_br)
resultModel = dao.getNextImage()
self.assertIsNotNone(resultModel)
self.assertEqual(resultModel.crop_id, resultingId2)
self.assertTrue(resultModel.tapped)
self.assertEqual(resultModel.image_id, model.image_id)
self.assertEqual(resultModel.cropped_path, model.cropped_path)
self.assertEqual(resultModel.crop_coordinate_tl.__str__(),
model.crop_coordinate_tl)
self.assertEqual(resultModel.crop_coordinate_br.__str__(),
model.crop_coordinate_br)
self.assertIsNone(dao.getNextImage())
def test(self):
model = incoming_state()
model.time_stamp = 1547453775.2
model.roll = 40.111
model.pitch = -111.222
model.yaw = 12.3
truncateTable('incoming_state')
dao = IncomingStateDAO(defaultConfigPath())
self.assertIsNotNone(dao)
resultingId = dao.addState(model)
self.assertNotEqual(resultingId, -1)
gottenMeas = dao.getStateById(resultingId)
self.assertIsNotNone(gottenMeas)
self.assertEqual(gottenMeas.id, resultingId)
self.assertAlmostEqual(gottenMeas.time_stamp, 1547453775.2)
self.assertAlmostEqual(gottenMeas.roll, 40.111)
self.assertAlmostEqual(gottenMeas.pitch, -111.222)
self.assertAlmostEqual(gottenMeas.yaw, 12.3)
def test(self):
model = incoming_gps()
model.time_stamp = 1547453775.2
model.lat = 40.111
model.lon = -111.222
model.alt = 1234.5
truncateTable('incoming_gps')
dao = IncomingGpsDAO(defaultConfigPath())
self.assertIsNotNone(dao)
resultingId = dao.addGps(model)
self.assertNotEqual(resultingId, -1)
gottenMeas = dao.getGpsById(resultingId)
self.assertIsNotNone(gottenMeas)
self.assertEqual(gottenMeas.id, resultingId)
self.assertAlmostEqual(gottenMeas.time_stamp, 1547453775.2)
self.assertAlmostEqual(gottenMeas.lat, 40.111)
self.assertAlmostEqual(gottenMeas.lon, -111.222)
self.assertAlmostEqual(gottenMeas.alt, 1234.5)
def test(self):
truncateTable('outgoing_manual')
dao = OutgoingManualDAO(defaultConfigPath())
testIns = outgoing_manual()
testIns.crop_id = 42
testIns.shape = 'circle'
testIns.background_color = 'white'
testIns.alphanumeric = 'A'
testIns.alphanumeric_color = 'black'
resultingId = dao.addClassification(testIns)
self.assertNotEqual(resultingId, -1)
insResult = dao.getClassification(resultingId)
self.assertIsNotNone(insResult.target)
self.assertNotEqual(insResult.target, -1)
testIns.crop_id = 43
resultingId = dao.addClassification(testIns)
self.assertNotEqual(resultingId, -1)
insResult2 = dao.getClassification(resultingId)
self.assertEqual(insResult.target, insResult2.target)
testIns.crop_id = 44
testIns.alphanumeric = 'C'
testIns.submitted = 'submitted' # this wont work -> it should still be unsubmitted
resultingId = dao.addClassification(testIns)
self.assertNotEqual(resultingId, -1)
insResult3 = dao.getClassification(resultingId)
self.assertNotEqual(insResult3.target, insResult2.target)
# the target id should change on this update
testIns.crop_id = 42
testIns.alphanumeric = 'C'
testIns.submitted = 'unsubmitted'
result = dao.updateClassificationByUID(testIns.crop_id,
testIns.toDict())
self.assertNotEqual(result.class_id, -1)
self.assertEqual(result.target, insResult3.target)
def test(self):
truncateTable('submitted_target')
dao = SubmittedTargetDAO(defaultConfigPath())
self.assertFalse(dao.removeTarget(10, False))
self.assertFalse(dao.removeTarget(10, True))
testIns = submitted_target()
testIns.shape = 'square'
testIns.type = 'standard'
testIns.crop_path = '/another/totally/real/crop/path/ikr.jpg'
testIns.background_color = 'white'
testIns.alphanumeric = "T"
testIns.alphanumeric_color = "orange"
testIns.autonomous = False
testIns.target = 10
self.assertNotEqual(dao.upsertTarget(testIns), -1)
testIns.shape = 'circle'
testIns.target = 15
self.assertNotEqual(dao.upsertTarget(testIns), -1)
self.assertFalse(dao.removeTarget(10, True))
self.assertFalse(dao.removeTarget(12, False))
self.assertTrue(dao.removeTarget(10, False))
# confirm it got deleted
self.assertIsNone(dao.getTarget(10, False))
targetList = dao.getAllTargets(False)
self.assertIsNotNone(targetList)
self.assertEqual(len(targetList), 1)
self.assertEqual(targetList[0].target, 15)
self.assertEqual(targetList[0].shape, 'circle')
self.assertTrue(dao.removeTarget(15, False))
# confirm the table is now empty
self.assertIsNone(dao.getAllTargets(False))
self.assertIsNone(dao.getAllTargets(True))
def test(self):
# insert some targets
dao = OutgoingManualDAO(defaultConfigPath())
truncateTable('outgoing_manual')
# make sure if fails when we try and remove on empty table:
deleteResult = dao.removeClassification(100)
self.assertFalse(deleteResult)
testIns = outgoing_manual()
testIns.crop_id = 42
testIns.latitude = 40.111
testIns.longitude = -111.111
testIns.orientation = 'N'
testIns.shape = 'circle'
testIns.background_color = 'white'
testIns.alphanumeric = 'A'
testIns.alphanumeric_color = 'black'
resultingId = dao.addClassification(testIns)
self.assertIsNot(resultingId, -1)
testIns.crop_id = 44
otherId = dao.addClassification(testIns)
self.assertNotEqual(otherId, -1)
# make sure it doesn't delete everything:
deleteResult = dao.removeClassification(
otherId + 5) # give bogus id that should fail
self.assertFalse(deleteResult)
self.assertEqual(len(dao.getAll()),
2) # make sure there's still 2 records
deleteResult = dao.removeClassification(resultingId)
self.assertTrue(deleteResult)
self.assertEqual(len(dao.getAll()), 1) # should still be 1 record left
self.assertIsNotNone(dao.getClassification(
otherId)) # make sure the otherId wasn't deleted on accident
def test(self):
model = cropped_manual()
model.image_id = 123
model.time_stamp = 1547453775.2
model.cropped_path = '/im/a/totally/real/cropped/path/i/swear.jpg'
model.crop_coordinate_br = "(12, 34)"
model.crop_coordinate_tl = "(56, 78)"
truncateTable('cropped_manual')
dao = CroppedManualDAO(defaultConfigPath())
self.assertEqual(dao.upsertCropped(None), -1)
self.assertEqual(dao.upsertCropped(cropped_manual()), -1)
resultingId = dao.upsertCropped(model)
self.assertIsNotNone(resultingId)
self.assertNotEqual(resultingId, -1)
model.crop_coordinate_br = "(56, 78)"
model.crop_id = resultingId
resultingId2 = dao.upsertCropped(model)
self.assertNotEqual(resultingId2, -1)
self.assertEqual(resultingId, resultingId2)
def test(self):
truncateTable('cropped_manual')
dao = CroppedManualDAO(defaultConfigPath())
self.assertEqual(dao.getAll(), [])
model = cropped_manual()
model.image_id = 123
model.time_stamp = 1547453775.2
model.cropped_path = '/im/a/totally/real/cropped/path/i/swear.jpg'
model.crop_coordinate_br = "(12,34)"
model.crop_coordinate_tl = "(56,78)"
resultingId = dao.upsertCropped(model)
self.assertNotEqual(resultingId, -1)
model.cropped_path = '/im/a/totally/real/cropped/path/2/i/swear.jpg'
model.image_id = 456
resultingId2 = dao.upsertCropped(model)
self.assertNotEqual(resultingId2, -1)
result = dao.getAll()
self.assertEqual(len(result), 2)
def test(self):
truncateTable('outgoing_autonomous')
dao = OutgoingAutonomousDAO(defaultConfigPath())
# empty table
self.assertIsNone(dao.getUnlocatedClassifications())
# populate with two classifications that need geo, one that doesnt
testIns = outgoing_manual()
testIns.crop_id = 42
testIns.shape = 'circle'
testIns.background_color = 'white'
testIns.alphanumeric = 'A'
testIns.alphanumeric_color = 'black'
resultingId = dao.addClassification(testIns)
self.assertNotEqual(resultingId, -1)
testIns.crop_id = 43
testIns.background_color = 'orange'
resultingId2 = dao.addClassification(testIns)
self.assertNotEqual(resultingId2, -1)
testIns.crop_id = 44
testIns.latitude = 40.111
testIns.longitude = -111.222
resultingId3 = dao.addClassification(testIns)
self.assertNotEqual(resultingId3, -1)
unlocated = dao.getUnlocatedClassifications()
self.assertIsNotNone(unlocated)
self.assertEqual(len(unlocated), 2)
# the two models in the list should be our first two inserts and have
# crop ids 42 and 43
self.assertLess(unlocated[0].crop_id, 44)
self.assertLess(unlocated[1].crop_id, 44)
def test(self):
truncateTable('incoming_image')
truncateTable('cropped_autonomous')
truncateTable('outgoing_autonomous')
dao = OutgoingAutonomousDAO(defaultConfigPath())
testIns = outgoing_autonomous()
testIns.crop_id = 42
testIns.shape = 'circle'
testIns.background_color = 'white'
testIns.alphanumeric = 'A'
testIns.alphanumeric_color = 'black'
self.assertNotEqual(dao.addClassification(testIns), -1)
dao = CroppedAutonomousDAO(defaultConfigPath())
model = cropped_autonomous()
model.image_id = 123
model.time_stamp = 1547453775.2
model.cropped_path = '/im/a/totally/real/cropped/path/i/swear.jpg'
model.crop_coordinate_br = "(12, 34)"
model.crop_coordinate_tl = "(56, 78)"
self.assertNotEqual(dao.addImage(model), -1)
dao = IncomingImageDAO(defaultConfigPath())
model = incoming_image()
model.time_stamp = 1547453775.2
model.focal_length = 16.0
model.image_path = '/im/a/totally/real/path/i/swear.jpg'
model.manual_tap = True
model.autonomous_tap = True
resultingId = dao.addImage(model)
self.assertNotEqual(resultingId, -1)
util = UtilDAO(defaultConfigPath())
util.resetAutonomousDB()
resultingModel = dao.getImage(resultingId)
self.assertIsNotNone(resultingModel)
self.assertFalse(resultingModel.autonomous_tap)
self.assertTrue(resultingModel.manual_tap)
self.assertEqual(resultingModel.image_path, model.image_path)
self.assertEqual(resultingModel.focal_length, model.focal_length)
dao = CroppedAutonomousDAO(defaultConfigPath())
self.assertEqual(len(dao.getAll()), 0)
dao = OutgoingAutonomousDAO(defaultConfigPath())
self.assertEqual(len(dao.getAll()), 0)
def test(self):
truncateTable('outgoing_manual')
dao = OutgoingManualDAO(defaultConfigPath())
# at this point we should've already passed a bunch of tests
# relating to target submission above, so we can just test the
# classification specification feature here
testIns = outgoing_manual()
testIns.crop_id = 42
testIns.latitude = 40.111
testIns.longitude = -111.111
testIns.orientation = 'N'
testIns.shape = 'circle'
testIns.background_color = 'white'
testIns.alphanumeric = 'A'
testIns.alphanumeric_color = 'black'
firstClass = dao.addClassification(testIns)
self.assertNotEqual(firstClass, -1)
testIns.crop_id = 43
testIns.latitude = 40.222
testIns.longitude = -111.222
testIns.orientation = 'NE'
testIns.background_color = 'orange'
secondClass = dao.addClassification(testIns)
self.assertNotEqual(secondClass, -1)
testIns.crop_id = 44
testIns.latitude = 40.333
testIns.longitude = -111.333
testIns.alphanumeric_color = 'white'
thirdClass = dao.addClassification(testIns)
self.assertNotEqual(thirdClass, -1)
specs = {
'orientation': secondClass,
'crop_id': firstClass,
'alphanumeric_color': thirdClass
}
classResult = dao.getClassification(secondClass)
submissionResult = dao.submitPendingTarget(classResult.target, specs)
self.assertIsNotNone(submissionResult)
self.assertEqual(submissionResult.orientation, 'NE')
self.assertEqual(submissionResult.crop_id, 42)
self.assertEqual(submissionResult.alphanumeric_color, 'white')
self.assertEqual(submissionResult.background_color, 'orange')
self.assertEqual(submissionResult.alphanumeric, 'A')
truncateTable('outgoing_manual')
############################################
# test what happens when we put garbage in specs:
############################################
testIns = outgoing_manual()
testIns.crop_id = 42
testIns.latitude = 40.111
testIns.longitude = -111.111
testIns.orientation = 'S'
testIns.shape = 'circle'
testIns.background_color = 'white'
testIns.alphanumeric = 'Q'
testIns.alphanumeric_color = 'black'
self.assertNotEqual(dao.addClassification(testIns), -1)
testIns.crop_id = 43
testIns.latitude = 40.222
testIns.longitude = -111.222
testIns.orientation = 'W'
testIns.background_color = 'orange'
secondClass = dao.addClassification(testIns)
self.assertNotEqual(secondClass, -1)
testIns.crop_id = 44
testIns.latitude = 40.333
testIns.longitude = -111.333
testIns.alphanumeric_color = 'white'
self.assertNotEqual(dao.addClassification(testIns), -1)
specs = {
'orientation': secondClass,
'crop_id': None,
'alphanumeric_color': 'wasdf'
}
classResult = dao.getClassification(secondClass)
submissionResult = dao.submitPendingTarget(classResult.target, specs)
# Even though we fed a bunch of garbage in specs, submission should
# still succeed, defaulting to most common value, for the garbage stuff
self.assertIsNotNone(submissionResult)
self.assertEqual(submissionResult.orientation, 'W')
self.assertEqual(submissionResult.alphanumeric_color, 'black')
self.assertEqual(submissionResult.background_color, 'orange')
self.assertEqual(submissionResult.alphanumeric, 'Q')
