class prsComponentCppImplTestPy(unittest.TestCase):
################################################
# lifecycle
################################################
def setUp(self):
self.simpleClient = PySimpleClient()
self.componentName = "testInstanceprsComponentCppImpl"
self.simpleClient.getLogger().logInfo("pyUnitTestprsComponentCppImpl.prsComponentCppImplTestPy.setUp()...")
self.simpleClient.getLogger().logInfo("Get component " + self.componentName)
self.component = self.simpleClient.getComponent(self.componentName)
#__pPp__
def tearDown(self):
self.simpleClient.getLogger().logInfo("pyUnitTestprsComponentCppImpl.prsComponentCppImplTestPy.tearDown()...")
self.simpleClient.getLogger().logInfo("Releasing component " + self.componentName)
self.simpleClient.releaseComponent(self.componentName)
self.simpleClient.disconnect()
#__pPp__
################################################
# test methods
################################################
def testPark(self):
self.simpleClient.getLogger().logInfo("pyUnitTestprsComponentCppImpl.prsComponentCppImplTestPy.testPark()...")
response = None
response = self.component.Park()
# no return is expected, response should be None
assert response is None
class StopWatchLightImplTestPy(unittest.TestCase):
################################################
# lifecycle
################################################
def setUp(self):
self.simpleClient = PySimpleClient()
self.componentName = "testInstanceStopWatchLightImpl"
self.simpleClient.getLogger().logInfo("pyUnitTestStopWatchLightImpl.StopWatchLightImplTestPy.setUp()...")
self.simpleClient.getLogger().logInfo("Get component " + self.componentName)
self.component = self.simpleClient.getComponent(self.componentName)
#__pPp__
def tearDown(self):
self.simpleClient.getLogger().logInfo("pyUnitTestStopWatchLightImpl.StopWatchLightImplTestPy.tearDown()...")
self.simpleClient.getLogger().logInfo("Releasing component " + self.componentName)
self.simpleClient.releaseComponent(self.componentName)
self.simpleClient.disconnect()
#__pPp__
################################################
# test methods
################################################
def testGetDisplay(self):
self.simpleClient.getLogger().logInfo("pyUnitTestStopWatchLightImpl.StopWatchLightImplTestPy.testGetDisplay()...")
response = None
response = self.component.getDisplay()
# a return is expected, response should be not None
assert response is not None
class MasterComponentImplTestPy(unittest.TestCase):
################################################
# lifecycle
################################################
def setUp(self):
self.simpleClient = PySimpleClient()
self.componentName = "testInstanceMasterComponentImpl"
self.simpleClient.getLogger().logInfo("pyUnitTestMasterComponentImpl.MasterComponentImplTestPy.setUp()...")
self.simpleClient.getLogger().logInfo("Get component " + self.componentName)
self.component = self.simpleClient.getComponent(self.componentName)
#__pPp__
def tearDown(self):
self.simpleClient.getLogger().logInfo("pyUnitTestMasterComponentImpl.MasterComponentImplTestPy.tearDown()...")
self.simpleClient.getLogger().logInfo("Releasing component " + self.componentName)
self.simpleClient.releaseComponent(self.componentName)
self.simpleClient.disconnect()
#__pPp__
################################################
# test methods
################################################
def testDoTransition(self):
self.simpleClient.getLogger().logInfo("pyUnitTestMasterComponentImpl.MasterComponentImplTestPy.testDoTransition()...")
response = None
event = SubsystemStateEvent()
response = self.component.doTransition(event)
# no return is expected, response should be None
assert response is None
class TSJavaImpTestPy(unittest.TestCase):
################################################
# lifecycle
################################################
def setUp(self):
self.simpleClient = PySimpleClient()
self.componentName = "testInstanceTSJavaImp"
self.simpleClient.getLogger().logInfo("pyUnitTestTSJavaImp.TSJavaImpTestPy.setUp()...")
self.simpleClient.getLogger().logInfo("Get component " + self.componentName)
self.component = self.simpleClient.getComponent(self.componentName)
#__pPp__
def tearDown(self):
self.simpleClient.getLogger().logInfo("pyUnitTestTSJavaImp.TSJavaImpTestPy.tearDown()...")
self.simpleClient.getLogger().logInfo("Releasing component " + self.componentName)
self.simpleClient.releaseComponent(self.componentName)
self.simpleClient.disconnect()
#__pPp__
################################################
# test methods
################################################
def testRunManualRAB(self):
self.simpleClient.getLogger().logInfo("pyUnitTestTSJavaImp.TSJavaImpTestPy.testRunManualRAB()...")
response = None
type = 0
pos = position()
response = self.component.runManualRAB(type, pos)
# no return is expected, response should be None
assert response is None
#__pPp__
def testRunAutoRAB(self):
self.simpleClient.getLogger().logInfo("pyUnitTestTSJavaImp.TSJavaImpTestPy.testRunAutoRAB()...")
response = None
type = 0
pos = position()
response = self.component.runAutoRAB(type, pos)
# no return is expected, response should be None
assert response is None
#__pPp__
def testGetRobotsList(self):
self.simpleClient.getLogger().logInfo("pyUnitTestTSJavaImp.TSJavaImpTestPy.testGetRobotsList()...")
response = None
response = self.component.getRobotsList()
# a return is expected, response should be not None
assert response is not None
#__pPp__
def testGetRobotStatus(self):
self.simpleClient.getLogger().logInfo("pyUnitTestTSJavaImp.TSJavaImpTestPy.testGetRobotStatus()...")
response = None
id = 0
response = self.component.getRobotStatus(id)
# a return is expected, response should be not None
assert response is not None
class DCSImplTestPy(unittest.TestCase):
################################################
# lifecycle
################################################
def setUp(self):
self.simpleClient = PySimpleClient()
self.componentName = "testInstanceDCSImpl"
self.simpleClient.getLogger().logInfo("pyUnitTestDCSImpl.DCSImplTestPy.setUp()...")
self.simpleClient.getLogger().logInfo("Get component " + self.componentName)
self.component = self.simpleClient.getComponent(self.componentName)
#__pPp__
def tearDown(self):
self.simpleClient.getLogger().logInfo("pyUnitTestDCSImpl.DCSImplTestPy.tearDown()...")
self.simpleClient.getLogger().logInfo("Releasing component " + self.componentName)
self.simpleClient.releaseComponent(self.componentName)
self.simpleClient.disconnect()
#__pPp__
################################################
# test methods
################################################
def testSendCommand(self):
self.simpleClient.getLogger().logInfo("pyUnitTestDCSImpl.DCSImplTestPy.testSendCommand()...")
response = None
commandName = 'emptyString'
parameterList = 'emptyString'
cb = CBstring()
desc = CBDescIn()
response = self.component.sendCommand(commandName, parameterList, cb, desc)
# a return is expected, response should be not None
assert response is not None
def disconnect(self):
'''
Override this method.
'''
global CALLBACKS
#tell threads to stop
self.running = 0
#give them a few seconds to stop executing
sleep(2)
#first destroy all consumers
self.getLogger().logInfo("Disconnecting all administrative consumers...")
for key in self.channels.keys():
self.channels[key][CONSUMER].disconnect()
#next notify all callbacks that we're shutting down
self.getLogger().logInfo("Disconnecting all registered callbacks...")
for cb in CALLBACKS:
try:
cb.done("The ACSEventAdmin is shutting down.",
Completion(long(0), long(0), long(0), []),
CBDescOut(long(0), long(0)))
except:
self.getLogger().logWarning("Failed to invoke done method on a callback!")
print_exc()
#now delete member data
self.channels = {}
CALLBACKS = []
PySimpleClient.disconnect(self)
return
class TRDJavaImpTestPy(unittest.TestCase):
################################################
# lifecycle
################################################
def setUp(self):
self.simpleClient = PySimpleClient()
self.componentName = "testInstanceTRDJavaImp"
self.simpleClient.getLogger().logInfo("pyUnitTestTRDJavaImp.TRDJavaImpTestPy.setUp()...")
self.simpleClient.getLogger().logInfo("Get component " + self.componentName)
self.component = self.simpleClient.getComponent(self.componentName)
#__pPp__
def tearDown(self):
self.simpleClient.getLogger().logInfo("pyUnitTestTRDJavaImp.TRDJavaImpTestPy.tearDown()...")
self.simpleClient.getLogger().logInfo("Releasing component " + self.componentName)
self.simpleClient.releaseComponent(self.componentName)
self.simpleClient.disconnect()
#__pPp__
################################################
# test methods
################################################
def testGetRAB(self):
self.simpleClient.getLogger().logInfo("pyUnitTestTRDJavaImp.TRDJavaImpTestPy.testGetRAB()...")
response = None
type = 0
response = self.component.getRAB(type)
# a return is expected, response should be not None
assert response is not None
#__pPp__
def testCreateReport(self):
self.simpleClient.getLogger().logInfo("pyUnitTestTRDJavaImp.TRDJavaImpTestPy.testCreateReport()...")
response = None
rep = report()
response = self.component.createReport(rep)
# a return is expected, response should be not None
assert response is not None
#__pPp__
def testGetReportsList(self):
self.simpleClient.getLogger().logInfo("pyUnitTestTRDJavaImp.TRDJavaImpTestPy.testGetReportsList()...")
response = None
response = self.component.getReportsList()
# a return is expected, response should be not None
assert response is not None
#__pPp__
def testGetReport(self):
self.simpleClient.getLogger().logInfo("pyUnitTestTRDJavaImp.TRDJavaImpTestPy.testGetReport()...")
response = None
id = 0
response = self.component.getReport(id)
# a return is expected, response should be not None
assert response is not None
class CCDImagImplTestPy(unittest.TestCase):
################################################
# lifecycle
################################################
def setUp(self):
self.simpleClient = PySimpleClient()
self.componentName = "testInstanceCCDImagImpl"
self.simpleClient.getLogger().logInfo("pyUnitTestCCDImagImpl.CCDImagImplTestPy.setUp()...")
self.simpleClient.getLogger().logInfo("Get component " + self.componentName)
self.component = self.simpleClient.getComponent(self.componentName)
#__pPp__
def tearDown(self):
self.simpleClient.getLogger().logInfo("pyUnitTestCCDImagImpl.CCDImagImplTestPy.tearDown()...")
self.simpleClient.getLogger().logInfo("Releasing component " + self.componentName)
self.simpleClient.releaseComponent(self.componentName)
self.simpleClient.disconnect()
#__pPp__
################################################
# test methods
################################################
def testStandby(self):
self.simpleClient.getLogger().logInfo("pyUnitTestCCDImagImpl.CCDImagImplTestPy.testStandby()...")
response = None
response = self.component.standby()
# no return is expected, response should be None
assert response is None
#__pPp__
def testOnline(self):
self.simpleClient.getLogger().logInfo("pyUnitTestCCDImagImpl.CCDImagImplTestPy.testOnline()...")
response = None
response = self.component.online()
# no return is expected, response should be None
assert response is None
#__pPp__
def testOff(self):
self.simpleClient.getLogger().logInfo("pyUnitTestCCDImagImpl.CCDImagImplTestPy.testOff()...")
response = None
response = self.component.off()
# no return is expected, response should be None
assert response is None
#__pPp__
def testSetup(self):
self.simpleClient.getLogger().logInfo("pyUnitTestCCDImagImpl.CCDImagImplTestPy.testSetup()...")
response = None
val = 'emptyString'
timeout = 0
response = self.component.setup(val, timeout)
# no return is expected, response should be None
assert response is None
class SCJavaImpTestPy(unittest.TestCase):
################################################
# lifecycle
################################################
def setUp(self):
self.simpleClient = PySimpleClient()
self.componentName = "testInstanceSCJavaImp"
self.simpleClient.getLogger().logInfo("pyUnitTestSCJavaImp.SCJavaImpTestPy.setUp()...")
self.simpleClient.getLogger().logInfo("Get component " + self.componentName)
self.component = self.simpleClient.getComponent(self.componentName)
#__pPp__
def tearDown(self):
self.simpleClient.getLogger().logInfo("pyUnitTestSCJavaImp.SCJavaImpTestPy.tearDown()...")
self.simpleClient.getLogger().logInfo("Releasing component " + self.componentName)
self.simpleClient.releaseComponent(self.componentName)
self.simpleClient.disconnect()
#__pPp__
################################################
# test methods
################################################
def testReset(self):
self.simpleClient.getLogger().logInfo("pyUnitTestSCJavaImp.SCJavaImpTestPy.testReset()...")
response = None
response = self.component.reset()
# no return is expected, response should be None
assert response is None
#__pPp__
def testStatus(self):
self.simpleClient.getLogger().logInfo("pyUnitTestSCJavaImp.SCJavaImpTestPy.testStatus()...")
response = None
response = self.component.status()
# a return is expected, response should be not None
assert response is not None
#__pPp__
def testGetPosition(self):
self.simpleClient.getLogger().logInfo("pyUnitTestSCJavaImp.SCJavaImpTestPy.testGetPosition()...")
response = None
response = self.component.getPosition()
# a return is expected, response should be not None
assert response is not None
#__pPp__
def testSensorType(self):
self.simpleClient.getLogger().logInfo("pyUnitTestSCJavaImp.SCJavaImpTestPy.testSensorType()...")
response = None
response = self.component.sensorType()
# a return is expected, response should be not None
assert response is not None
class MoreComponentUtilTest(unittest.TestCase):
"""
Test the integration of the component utilities
"""
def setUp(self):
self._my_acs_client = PySimpleClient()
logger = self._my_acs_client.getLogger()
logger.setLevel(logging.WARNING)
def tearDown(self):
self._my_acs_client.disconnect()
def test_is_characteristic_component(self):
my_component = self._my_acs_client.getComponent(
"TEST_PROPERTIES_COMPONENT", True)
self.assertTrue(
component_util.is_characteristic_component(my_component))
# Now check a component that is not characteristic
my_component2 = self._my_acs_client.getComponent("TIMER1", True)
self.assertFalse(
component_util.is_characteristic_component(my_component2))
def test_is_python_char_component(self):
my_component = self._my_acs_client.getComponent(
"TEST_PROPERTIES_PYTHON", True)
self.assertTrue(component_util.is_python_char_component(my_component))
# Now check a component that is not characteristic
my_component2 = self._my_acs_client.getComponent("TIMER1", True)
self.assertRaises(AttributeError,
component_util.is_python_char_component,
my_component2)
my_component3 = self._my_acs_client.getComponent(
"TEST_PROPERTIES_COMPONENT", True)
self.assertFalse(
component_util.is_python_char_component(my_component3))
def test_is_a_property_recorder_component(self):
my_component = self._my_acs_client.getComponent(
"propertyRecorder1", True)
self.assertTrue(
component_util.is_a_property_recorder_component(my_component))
# Now check a component that is not characteristic
my_component2 = self._my_acs_client.getComponent("TIMER1", True)
self.assertFalse(
component_util.is_a_property_recorder_component(my_component2))
def test_is_component_state_ok(self):
my_component = self._my_acs_client.getComponent(
"TEST_PROPERTIES_COMPONENT", True)
self.assertTrue(component_util.is_component_state_ok(my_component))
class PingerImplTestPy(unittest.TestCase):
################################################
# lifecycle
################################################
def setUp(self):
self.simpleClient = PySimpleClient()
self.componentName = "testInstancePingerImpl"
self.simpleClient.getLogger().logInfo("pyUnitTestPingerImpl.PingerImplTestPy.setUp()...")
self.simpleClient.getLogger().logInfo("Get component " + self.componentName)
self.component = self.simpleClient.getComponent(self.componentName)
#__pPp__
def tearDown(self):
self.simpleClient.getLogger().logInfo("pyUnitTestPingerImpl.PingerImplTestPy.tearDown()...")
self.simpleClient.getLogger().logInfo("Releasing component " + self.componentName)
self.simpleClient.releaseComponent(self.componentName)
self.simpleClient.disconnect()
#__pPp__
################################################
# test methods
################################################
def testSpawnChildren(self):
self.simpleClient.getLogger().logInfo("pyUnitTestPingerImpl.PingerImplTestPy.testSpawnChildren()...")
response = None
howMany = 0
container = 'emptyString'
baseName = 'emptyString'
response = self.component.spawnChildren(howMany, container, baseName)
# no return is expected, response should be None
assert response is None
#__pPp__
def testLogInfo(self):
self.simpleClient.getLogger().logInfo("pyUnitTestPingerImpl.PingerImplTestPy.testLogInfo()...")
response = None
response = self.component.logInfo()
# no return is expected, response should be None
assert response is None
#__pPp__
def testPing(self):
self.simpleClient.getLogger().logInfo("pyUnitTestPingerImpl.PingerImplTestPy.testPing()...")
response = None
fast = False
recursive = False
id = 0
response = self.component.ping(fast, recursive, id)
# a return is expected, response should be not None
assert response is not None
class LegoImplTestPy(unittest.TestCase):
################################################
# lifecycle
################################################
def setUp(self):
self.simpleClient = PySimpleClient()
self.componentName = "testInstanceLegoImpl"
self.simpleClient.getLogger().logInfo("pyUnitTestLegoImpl.LegoImplTestPy.setUp()...")
self.simpleClient.getLogger().logInfo("Get component " + self.componentName)
self.component = self.simpleClient.getComponent(self.componentName)
#__pPp__
def tearDown(self):
self.simpleClient.getLogger().logInfo("pyUnitTestLegoImpl.LegoImplTestPy.tearDown()...")
self.simpleClient.getLogger().logInfo("Releasing component " + self.componentName)
self.simpleClient.releaseComponent(self.componentName)
self.simpleClient.disconnect()
#__pPp__
################################################
# test methods
################################################
def testObserve(self):
self.simpleClient.getLogger().logInfo("pyUnitTestLegoImpl.LegoImplTestPy.testObserve()...")
response = None
coordinates = Position()
exposureTime = 0
response = self.component.observe(coordinates, exposureTime)
# a return is expected, response should be not None
assert response is not None
#__pPp__
def testMoveTo(self):
self.simpleClient.getLogger().logInfo("pyUnitTestLegoImpl.LegoImplTestPy.testMoveTo()...")
response = None
coordinates = Position()
response = self.component.moveTo(coordinates)
# no return is expected, response should be None
assert response is None
#__pPp__
def testGetCurrentPosition(self):
self.simpleClient.getLogger().logInfo("pyUnitTestLegoImpl.LegoImplTestPy.testGetCurrentPosition()...")
response = None
response = self.component.getCurrentPosition()
# a return is expected, response should be not None
assert response is not None
def __init__(self):
try:
#This stuff is only for get the antennas of a manual array
from Acspy.Clients.SimpleClient import PySimpleClient
c = PySimpleClient()
master = c.getComponent('CONTROL/MASTER')
arrayname = master.getManualArrays()
array = c.getComponent('CONTROL/'+arrayname[0])
self.antennalist = array.getAntennas()
self.logger = getLogger()
del master
del array
c.disconnect()
except Exception, e:
print e
class SchedulerImplTestPy(unittest.TestCase):
################################################
# lifecycle
################################################
def setUp(self):
self.simpleClient = PySimpleClient()
self.componentName = "testInstanceSchedulerImpl"
self.simpleClient.getLogger().logInfo("pyUnitTestSchedulerImpl.SchedulerImplTestPy.setUp()...")
self.simpleClient.getLogger().logInfo("Get component " + self.componentName)
self.component = self.simpleClient.getComponent(self.componentName)
#__pPp__
def tearDown(self):
self.simpleClient.getLogger().logInfo("pyUnitTestSchedulerImpl.SchedulerImplTestPy.tearDown()...")
self.simpleClient.getLogger().logInfo("Releasing component " + self.componentName)
self.simpleClient.releaseComponent(self.componentName)
self.simpleClient.disconnect()
#__pPp__
################################################
# test methods
################################################
def testStart(self):
self.simpleClient.getLogger().logInfo("pyUnitTestSchedulerImpl.SchedulerImplTestPy.testStart()...")
response = None
response = self.component.start()
# no return is expected, response should be None
assert response is None
#__pPp__
def testStop(self):
self.simpleClient.getLogger().logInfo("pyUnitTestSchedulerImpl.SchedulerImplTestPy.testStop()...")
response = None
response = self.component.stop()
# no return is expected, response should be None
assert response is None
#__pPp__
def testProposalUnderExecution(self):
self.simpleClient.getLogger().logInfo("pyUnitTestSchedulerImpl.SchedulerImplTestPy.testProposalUnderExecution()...")
response = None
response = self.component.proposalUnderExecution()
# a return is expected, response should be not None
assert response is not None
class EventSubscriberImplTestPy(unittest.TestCase):
################################################
# lifecycle
################################################
def setUp(self):
self.simpleClient = PySimpleClient()
self.componentName = "testInstanceEventSubscriberImpl"
self.simpleClient.getLogger().logInfo("pyUnitTestEventSubscriberImpl.EventSubscriberImplTestPy.setUp()...")
self.simpleClient.getLogger().logInfo("Get component " + self.componentName)
self.component = self.simpleClient.getComponent(self.componentName)
#__pPp__
def tearDown(self):
self.simpleClient.getLogger().logInfo("pyUnitTestEventSubscriberImpl.EventSubscriberImplTestPy.tearDown()...")
self.simpleClient.getLogger().logInfo("Releasing component " + self.componentName)
self.simpleClient.releaseComponent(self.componentName)
self.simpleClient.disconnect()
class BasicAntennaJavaImplTestPy(unittest.TestCase):
################################################
# lifecycle
################################################
def setUp(self):
self.simpleClient = PySimpleClient()
self.componentName = "testInstanceBasicAntennaJavaImpl"
self.simpleClient.getLogger().logInfo("pyUnitTestBasicAntennaJavaImpl.BasicAntennaJavaImplTestPy.setUp()...")
self.simpleClient.getLogger().logInfo("Get component " + self.componentName)
self.component = self.simpleClient.getComponent(self.componentName)
#__pPp__
def tearDown(self):
self.simpleClient.getLogger().logInfo("pyUnitTestBasicAntennaJavaImpl.BasicAntennaJavaImplTestPy.tearDown()...")
self.simpleClient.getLogger().logInfo("Releasing component " + self.componentName)
self.simpleClient.releaseComponent(self.componentName)
self.simpleClient.disconnect()
#__pPp__
################################################
# test methods
################################################
def testSetAntennaPosition(self):
self.simpleClient.getLogger().logInfo("pyUnitTestBasicAntennaJavaImpl.BasicAntennaJavaImplTestPy.testSetAntennaPosition()...")
response = None
pos = position()
response = self.component.setAntennaPosition(pos)
# no return is expected, response should be None
assert response is None
#__pPp__
def testGetAntennaPosition(self):
self.simpleClient.getLogger().logInfo("pyUnitTestBasicAntennaJavaImpl.BasicAntennaJavaImplTestPy.testGetAntennaPosition()...")
response = None
response = self.component.getAntennaPosition()
# a return is expected, response should be not None
assert response is not None
def mostRecentAsdm(date=None) :
if date == None :
date='%4.2d-%2.2d-%2.2d'%(time.gmtime()[0], time.gmtime()[1], time.gmtime()[2])
client = PySimpleClient()
archConn = client.getComponent('ARCHIVE_CONNECTION')
archOp = archConn.getOperational('XMLQueryTest')
uids = archOp.queryRecent('ASDM',date+'T00:00:00.000')
asdm_name=[]
for uid in uids:
result = archOp.retrieveDirty(uid)
dataSet = ArchivedAsdm(result.xmlString)
dateOfCreation = dataSet.getDateOfCreation()
if dataSet.isAsdm() & (dateOfCreation==date):
asdm_name.append("%s \t%s" % (dateOfCreation,uid))
asdm_name.sort()
client.releaseComponent('ARCHIVE_CONNECTION')
client.disconnect()
if len(asdm_name) == 0 :
print 'there are no asdms for %s' % date
return None
else :
return asdm_name[-1].split('\t')[1]
def mostRecentAsdm(date = None):
'''
Get the most recent Asdm, given a date.
If the date is None, it takes the actual hour.
return asdm or None
'''
from Acspy.Clients.SimpleClient import PySimpleClient
from ArchivedAsdm import ArchivedAsdm
if date == None :
date_T = '%4.2d-%2.2d-%2.2dT00:00:00.000' % (gmtime()[0] , gmtime()[1] , gmtime()[2])
date = '%4.2d-%2.2d-%2.2d'% (gmtime()[0] , gmtime()[1] , gmtime()[2])
else:
date_T = '%4.2d-%2.2d-%2.2dT%2.2d:00:00.00' % (date[0] , date[1] , date[2] , date[3])
date = '%4.2d-%2.2d-%2.2d'% (date[0] , date[1] , date[2])
client = PySimpleClient()
archConn = client.getComponent('ARCHIVE_CONNECTION')
archOp = archConn.getOperational('XMLQueryTest')
uids = archOp.queryRecent('ASDM' , date_T)
print "Connection entablish with archive ..."
asdm_name = []
for uid in uids:
print "Checking date of " +str(uid),
result = archOp.retrieveDirty(uid)
dataSet = ArchivedAsdm(result.xmlString)
dateOfCreation = dataSet.getDateOfCreation()
print " created: "+str(dataSet.getDateTimeOfCreation()),
if dataSet.isAsdm() & (dateOfCreation==date):
asdm_name.append("%s \t%s" % (dataSet.getDateTimeOfCreation() , uid))
print " --> is an asdm!",
print ""
asdm_name.sort()
client.releaseComponent('ARCHIVE_CONNECTION')
client.disconnect()
if len(asdm_name) == 0 :
print 'There are no asdms for %s' % date
return None
else :
return asdm_name[-1].split('\t')[1]
class InstrumentImplTestPy(unittest.TestCase):
################################################
# lifecycle
################################################
def setUp(self):
self.simpleClient = PySimpleClient()
self.componentName = "testInstanceInstrumentImpl"
self.simpleClient.getLogger().logInfo("pyUnitTestInstrumentImpl.InstrumentImplTestPy.setUp()...")
self.simpleClient.getLogger().logInfo("Get component " + self.componentName)
self.component = self.simpleClient.getComponent(self.componentName)
#__pPp__
def tearDown(self):
self.simpleClient.getLogger().logInfo("pyUnitTestInstrumentImpl.InstrumentImplTestPy.tearDown()...")
self.simpleClient.getLogger().logInfo("Releasing component " + self.componentName)
self.simpleClient.releaseComponent(self.componentName)
self.simpleClient.disconnect()
#__pPp__
################################################
# test methods
################################################
def testTakeImage(self):
self.simpleClient.getLogger().logInfo("pyUnitTestInstrumentImpl.InstrumentImplTestPy.testTakeImage()...")
response = None
exposureTime = 0
response = self.component.takeImage(exposureTime)
# a return is expected, response should be not None
assert response is not None
#__pPp__
def testCameraOn(self):
self.simpleClient.getLogger().logInfo("pyUnitTestInstrumentImpl.InstrumentImplTestPy.testCameraOn()...")
response = None
response = self.component.cameraOn()
# no return is expected, response should be None
assert response is None
#__pPp__
def testCameraOff(self):
self.simpleClient.getLogger().logInfo("pyUnitTestInstrumentImpl.InstrumentImplTestPy.testCameraOff()...")
response = None
response = self.component.cameraOff()
# no return is expected, response should be None
assert response is None
#__pPp__
def testSetRGB(self):
self.simpleClient.getLogger().logInfo("pyUnitTestInstrumentImpl.InstrumentImplTestPy.testSetRGB()...")
response = None
rgbConfig = RGB()
response = self.component.setRGB(rgbConfig)
# no return is expected, response should be None
assert response is None
#__pPp__
def testSetPixelBias(self):
self.simpleClient.getLogger().logInfo("pyUnitTestInstrumentImpl.InstrumentImplTestPy.testSetPixelBias()...")
response = None
bias = 0
response = self.component.setPixelBias(bias)
# no return is expected, response should be None
assert response is None
#__pPp__
def testSetResetLevel(self):
self.simpleClient.getLogger().logInfo("pyUnitTestInstrumentImpl.InstrumentImplTestPy.testSetResetLevel()...")
response = None
resetLevel = 0
response = self.component.setResetLevel(resetLevel)
# no return is expected, response should be None
assert response is None
class NexstarImplTestPy(unittest.TestCase):
################################################
# lifecycle
################################################
def setUp(self):
self.simpleClient = PySimpleClient()
self.componentName = "testInstanceNexstarImpl"
self.simpleClient.getLogger().logInfo("pyUnitTestNexstarImpl.NexstarImplTestPy.setUp()...")
self.simpleClient.getLogger().logInfo("Get component " + self.componentName)
self.component = self.simpleClient.getComponent(self.componentName)
#__pPp__
def tearDown(self):
self.simpleClient.getLogger().logInfo("pyUnitTestNexstarImpl.NexstarImplTestPy.tearDown()...")
self.simpleClient.getLogger().logInfo("Releasing component " + self.componentName)
self.simpleClient.releaseComponent(self.componentName)
self.simpleClient.disconnect()
#__pPp__
################################################
# test methods
################################################
def testImage(self):
self.simpleClient.getLogger().logInfo("pyUnitTestNexstarImpl.NexstarImplTestPy.testImage()...")
response = None
exposure = double()
response = self.component.image(exposure)
# a return is expected, response should be not None
assert response is not None
#__pPp__
def testLock(self):
self.simpleClient.getLogger().logInfo("pyUnitTestNexstarImpl.NexstarImplTestPy.testLock()...")
response = None
response = self.component.lock()
# no return is expected, response should be None
assert response is None
#__pPp__
def testUnlock(self):
self.simpleClient.getLogger().logInfo("pyUnitTestNexstarImpl.NexstarImplTestPy.testUnlock()...")
response = None
response = self.component.unlock()
# no return is expected, response should be None
assert response is None
#__pPp__
def testOn(self):
self.simpleClient.getLogger().logInfo("pyUnitTestNexstarImpl.NexstarImplTestPy.testOn()...")
response = None
response = self.component.on()
# no return is expected, response should be None
assert response is None
#__pPp__
def testOff(self):
self.simpleClient.getLogger().logInfo("pyUnitTestNexstarImpl.NexstarImplTestPy.testOff()...")
response = None
response = self.component.off()
# no return is expected, response should be None
assert response is None
class ServerRepresentationTest(unittest.TestCase):
"""
Test cases for the Server representation.
"""
#---------------------------------------------------------------------------
def setUp(self):
"""
Test case fixture.
"""
self.client = PySimpleClient("ServerRepresentationTest")
self.simulator = self.client.getComponent("SIMULATION_SERVER")
self.lamp = self.client.getComponent("LAMP_ACCESS")
#---------------------------------------------------------------------------
def tearDown(self):
"""
Test case fixture cleanup.
"""
self.client.releaseComponent("SIMULATION_SERVER")
self.client.releaseComponent("LAMP_ACCESS")
self.client.disconnect()
#---------------------------------------------------------------------------
def testSetupBehavior(self):
"""
Modify the behavior of the simulated LAMP_ACCESS component.
Setup the getLampBrightness function so it returns a constant
number.
"""
code = """LOGGER.logInfo('getLampBrightness called.')
6.8"""
self.simulator.setMethod('LAMP_ACCESS', 'getLampBrightness', code, 0.0)
brightness = self.lamp.getLampBrightness()
assert abs(brightness - 6.8) <= 0.01
#---------------------------------------------------------------------------
def testPersistentData(self):
"""
Data can be left in a global buffer located in the Goodies module.
This allows to get input data to persist between calls to the simulated
component.
As this test case shows, this can be useful to simulate get/set methods.
"""
code = """LOGGER.logInfo('setLampBrightness called; brightness='+str(parameters[0]))
from Acssim.Goodies import setGlobalData
setGlobalData('brightness', parameters[0])
None"""
self.simulator.setMethod('LAMP_ACCESS', 'setLampBrightness', code, 0.0)
code = """LOGGER.logInfo('getLampBrightness called.')
from Acssim.Goodies import setGlobalData
getGlobalData('brightness')"""
self.simulator.setMethod('LAMP_ACCESS', 'getLampBrightness', code, 0.0)
self.lamp.setLampBrightness(3.14)
brightness = self.lamp.getLampBrightness()
assert abs(brightness - 3.14) <= 0.01
#---------------------------------------------------------------------------
def testGetGlobalData(self):
"""
The SIMULATION_SERVER component implements also a getGlobalData() function,
which is tested here.
"""
code = """LOGGER.logInfo('setLampBrightness called; brightness='+str(parameters[0]))
from Acssim.Goodies import setGlobalData
setGlobalData('brightness', parameters[0])
None"""
self.simulator.setMethod('LAMP_ACCESS', 'setLampBrightness', code, 0.0)
self.lamp.setLampBrightness(3.14)
brightness = self.simulator.getGlobalData('brightness')
assert brightness == '3.14'
#---------------------------------------------------------------------------
def testRaiseException(self):
"""
Modify the behaviour of the LAMP_ACCESS component so it raises the
LampUnavailable exception when the getLampBrightness() function is
called.
"""
code = """from demo import LampUnavailable
raise LampUnavailable()"""
self.simulator.setMethod('LAMP_ACCESS', 'getLampBrightness', code, 0.0)
try:
b = self.lamp.getLampBrightness()
except LampUnavailable, ex:
return # Correct exception was raised.
except:
class ConsoleImplTestPy(unittest.TestCase):
################################################
# lifecycle
################################################
def setUp(self):
self.simpleClient = PySimpleClient()
self.componentName = "testInstanceConsoleImpl"
self.simpleClient.getLogger().logInfo("pyUnitTestConsoleImpl.ConsoleImplTestPy.setUp()...")
self.simpleClient.getLogger().logInfo("Get component " + self.componentName)
self.component = self.simpleClient.getComponent(self.componentName)
#__pPp__
def tearDown(self):
self.simpleClient.getLogger().logInfo("pyUnitTestConsoleImpl.ConsoleImplTestPy.tearDown()...")
self.simpleClient.getLogger().logInfo("Releasing component " + self.componentName)
self.simpleClient.releaseComponent(self.componentName)
self.simpleClient.disconnect()
#__pPp__
################################################
# test methods
################################################
def testSetMode(self):
self.simpleClient.getLogger().logInfo("pyUnitTestConsoleImpl.ConsoleImplTestPy.testSetMode()...")
response = None
mode = False
response = self.component.setMode(mode)
# no return is expected, response should be None
assert response is None
#__pPp__
def testGetMode(self):
self.simpleClient.getLogger().logInfo("pyUnitTestConsoleImpl.ConsoleImplTestPy.testGetMode()...")
response = None
response = self.component.getMode()
# a return is expected, response should be not None
assert response is not None
#__pPp__
def testMoveTelescope(self):
self.simpleClient.getLogger().logInfo("pyUnitTestConsoleImpl.ConsoleImplTestPy.testMoveTelescope()...")
response = None
coordinates = Position()
response = self.component.moveTelescope(coordinates)
# no return is expected, response should be None
assert response is None
#__pPp__
def testGetTelescopePosition(self):
self.simpleClient.getLogger().logInfo("pyUnitTestConsoleImpl.ConsoleImplTestPy.testGetTelescopePosition()...")
response = None
response = self.component.getTelescopePosition()
# a return is expected, response should be not None
assert response is not None
#__pPp__
def testGetCameraImage(self):
self.simpleClient.getLogger().logInfo("pyUnitTestConsoleImpl.ConsoleImplTestPy.testGetCameraImage()...")
response = None
response = self.component.getCameraImage()
# a return is expected, response should be not None
assert response is not None
#__pPp__
def testCameraOn(self):
self.simpleClient.getLogger().logInfo("pyUnitTestConsoleImpl.ConsoleImplTestPy.testCameraOn()...")
response = None
response = self.component.cameraOn()
# no return is expected, response should be None
assert response is None
#__pPp__
def testCameraOff(self):
self.simpleClient.getLogger().logInfo("pyUnitTestConsoleImpl.ConsoleImplTestPy.testCameraOff()...")
response = None
response = self.component.cameraOff()
# no return is expected, response should be None
assert response is None
#__pPp__
def testSetRGB(self):
self.simpleClient.getLogger().logInfo("pyUnitTestConsoleImpl.ConsoleImplTestPy.testSetRGB()...")
response = None
rgbConfig = RGB()
response = self.component.setRGB(rgbConfig)
# no return is expected, response should be None
assert response is None
#__pPp__
def testSetPixelBias(self):
self.simpleClient.getLogger().logInfo("pyUnitTestConsoleImpl.ConsoleImplTestPy.testSetPixelBias()...")
response = None
bias = 0
response = self.component.setPixelBias(bias)
# no return is expected, response should be None
assert response is None
#__pPp__
def testSetResetLevel(self):
self.simpleClient.getLogger().logInfo("pyUnitTestConsoleImpl.ConsoleImplTestPy.testSetResetLevel()...")
response = None
resetLevel = 0
response = self.component.setResetLevel(resetLevel)
# no return is expected, response should be None
assert response is None
###############################################################################
count = 0
magicNumber = int(argv[2])
def myHandler(ts, device, parameter, value):
'''
'''
global count
if count < magicNumber:
count = count + 1
return
#create the consumer
myConsumer = ArchiveConsumer(myHandler)
myConsumer.consumerReady()
#activate the component which will publish the events automatically
joe = PySimpleClient()
ps = joe.getComponent("TEST_PS_1")
#give the consumer a chance to receive the events
sleep(int(argv[1]))
#shutdown everything cleanly
myConsumer.disconnect()
joe.releaseComponent("TEST_PS_1")
joe.disconnect()
if count==magicNumber:
print "Test passed!"
else:
print "Test failed:", count
class StandaloneRecorder(object):
"""
A property recorder that works as an stand-alone application
"""
def __init__(self, recorder_config, verbosity):
'''
Ctor
@param recorder_config: the configuration of the recorder
@type recorder_config: RecorderConfig
@param verbosity: the verbosity level
(logging.WARNING, logging.DEBUG, etc) of the logger
@type verbosity: int
'''
self._verbosity = verbosity
self._recorder_config = recorder_config
self._setup_acs_client()
self._setup_front_end()
self.__canceled = False
self._logger.info('Property recorder up')
def _setup_acs_client(self):
self._my_acs_client = PySimpleClient()
self._logger = self._my_acs_client.getLogger()
self._logger.setLevel(self._verbosity)
def _setup_front_end(self):
self._front_end = FrontEnd(self._recorder_config, self._my_acs_client)
def make_new_acs_client(self):
'''
Will make a new ACS client and replace the existing one
To be used to recover from ACS restarts.
@raise CORBAProblemExImpl: if the client cannot be created.
'''
self._setup_acs_client()
self._front_end.update_acs_client(self._my_acs_client)
def start(self):
'''
The property recorded will start to record properties
@raises RuntimeError: if the recorder is cancelled
'''
if self.__canceled:
raise RuntimeError("The recorded is cancelled")
self._front_end.start_recording()
self._logger.info('Recording start')
def stop(self):
'''
The property recorded will stop to record properties
All the monitors are stopped, the components are unregistered
@raises RuntimeError: if the recorder is cancelled
'''
if self.__canceled:
raise RuntimeError("The recorded is cancelled")
self._front_end.stop_recording()
self._logger.info('Recording stop')
def close(self):
'''
Closes the property recorder, ready to be destroyed
All the resources will be freed and the connection with
ACS closed. The recorder will be cancelled from now on,
Meaning that the recorder is not anymore usable and
is ready to be destroyed
'''
if not self.__canceled:
self._logger.info('Switching off property recorder')
self.stop()
self._front_end.cancel()
self._front_end = None
self._recorder_config = None
self._my_acs_client.disconnect()
self._my_acs_client = None
self.__canceled = True
def is_acs_client_ok(self):
'''
Checks if the ACS client is OK or not.
When not OK, this typically means that ACS is
down. This lets the client know when a new client should be created
@return: if the client is OK or not
@rtype: bool
'''
return self._front_end.is_acs_client_ok
def print_config(self):
'''
Prints into the logger the existing configuration
'''
self._logger.debug('Property Recorder Configuration'
'\n--------------------------------------\n' +
pprint.pformat(vars(self._recorder_config)) +
'\n--------------------------------------')
class ComponentUtilTest(unittest.TestCase):
"""
This test requires ACS running with the testacsproperties CDB and
the myC cpp container up
"""
def setUp(self):
self._my_acs_client = PySimpleClient()
logger = self._my_acs_client.getLogger()
logger.setLevel(logging.WARNING)
# disable annoying output from the tests
def tearDown(self):
self._my_acs_client.disconnect()
def test_get_enum_prop_dict(self):
my_component = self._my_acs_client.getComponent(
"TEST_PROPERTIES_COMPONENT", True)
enum_prop = my_component._get_EnumTestROProp()
decoded = component_util.get_enum_prop_dict(enum_prop)
expected_value = {'0': 'STATE1', '1': 'STATE2', '2': 'STATE3'}
self.assertEqual(expected_value, decoded)
enum_prop = my_component._get_EnumTestRWProp()
decoded = component_util.get_enum_prop_dict(enum_prop)
expected_value = {'0': 'STATE1', '1': 'STATE2', '2': 'STATE3'}
self.assertEqual(expected_value, decoded)
self._my_acs_client.releaseComponent("TEST_PROPERTIES_COMPONENT")
def test_get_property_type(self):
my_component = self._my_acs_client.getComponent(
"TEST_PROPERTIES_COMPONENT", True)
self.assertEqual(
component_util.get_property_type(
my_component._get_EnumTestROProp()._NP_RepositoryId),
PropertyType.OBJECT)
self.assertEqual(
component_util.get_property_type(
my_component._get_EnumTestRWProp()._NP_RepositoryId),
PropertyType.OBJECT)
PropertyType.OBJECT
self.assertEqual(
component_util.get_property_type(
my_component._get_doubleROProp()._NP_RepositoryId),
PropertyType.DOUBLE)
self.assertEqual(
component_util.get_property_type(
my_component._get_floatSeqRWProp()._NP_RepositoryId),
PropertyType.FLOAT_SEQ)
self.assertEqual(
component_util.get_property_type(
my_component._get_longSeqRWProp()._NP_RepositoryId),
PropertyType.LONG_SEQ)
self.assertEqual(
component_util.get_property_type(
my_component._get_uLongLongRWProp()._NP_RepositoryId),
PropertyType.LONG_LONG)
self.assertEqual(
component_util.get_property_type(
my_component._get_uLongLongRWProp()._NP_RepositoryId),
PropertyType.LONG_LONG)
self.assertEqual(
component_util.get_property_type(
my_component._get_doubleRWProp()._NP_RepositoryId),
PropertyType.DOUBLE)
self.assertEqual(
component_util.get_property_type(
my_component._get_uLongROProp()._NP_RepositoryId),
PropertyType.LONG)
self.assertEqual(
component_util.get_property_type(
my_component._get_booleanROProp()._NP_RepositoryId),
PropertyType.BOOL)
self.assertEqual(
component_util.get_property_type(
my_component._get_doubleSeqROProp()._NP_RepositoryId),
PropertyType.DOUBLE_SEQ)
self.assertEqual(
component_util.get_property_type(
my_component._get_longLongROProp()._NP_RepositoryId),
PropertyType.LONG_LONG)
self.assertEqual(
component_util.get_property_type(
my_component._get_patternROProp()._NP_RepositoryId),
PropertyType.BIT_FIELD)
self.assertEqual(
component_util.get_property_type(
my_component._get_uLongRWProp()._NP_RepositoryId),
PropertyType.LONG)
self.assertEqual(
component_util.get_property_type(
my_component._get_booleanRWProp()._NP_RepositoryId),
PropertyType.BOOL)
self.assertEqual(
component_util.get_property_type(
my_component._get_doubleSeqRWProp()._NP_RepositoryId),
PropertyType.DOUBLE_SEQ)
self.assertEqual(
component_util.get_property_type(
my_component._get_longLongRWProp()._NP_RepositoryId),
PropertyType.LONG_LONG)
self.assertEqual(
component_util.get_property_type(
my_component._get_patternRWProp()._NP_RepositoryId),
PropertyType.BIT_FIELD)
self.assertEqual(
component_util.get_property_type(
my_component._get_uLongSeqROProp()._NP_RepositoryId),
PropertyType.LONG_SEQ)
self.assertRaises(
UnsupporterPropertyTypeError, component_util.get_property_type,
my_component._get_booleanSeqROProp()._NP_RepositoryId)
self.assertEqual(
component_util.get_property_type(
my_component._get_floatROProp()._NP_RepositoryId),
PropertyType.FLOAT)
self.assertEqual(
component_util.get_property_type(
my_component._get_longROProp()._NP_RepositoryId),
PropertyType.LONG)
self.assertEqual(
component_util.get_property_type(
my_component._get_stringROProp()._NP_RepositoryId),
PropertyType.STRING)
self.assertEqual(
component_util.get_property_type(
my_component._get_uLongSeqRWProp()._NP_RepositoryId),
PropertyType.LONG_SEQ)
self.assertRaises(
UnsupporterPropertyTypeError, component_util.get_property_type,
my_component._get_booleanSeqRWProp()._NP_RepositoryId)
self.assertEqual(
component_util.get_property_type(
my_component._get_floatRWProp()._NP_RepositoryId),
PropertyType.FLOAT)
self.assertEqual(
component_util.get_property_type(
my_component._get_longRWProp()._NP_RepositoryId),
PropertyType.LONG)
self.assertEqual(
component_util.get_property_type(
my_component._get_stringRWProp()._NP_RepositoryId),
PropertyType.STRING)
self.assertEqual(
component_util.get_property_type(
my_component._get_floatSeqROProp()._NP_RepositoryId),
PropertyType.FLOAT_SEQ)
self.assertEqual(
component_util.get_property_type(
my_component._get_longSeqROProp()._NP_RepositoryId),
PropertyType.LONG_SEQ)
self.assertEqual(
component_util.get_property_type(
my_component._get_uLongLongROProp()._NP_RepositoryId),
PropertyType.LONG_LONG)
def test_is_archive_delta_enabled(self):
# First test the cases when it should be false
self.assertFalse(component_util.is_archive_delta_enabled(None))
self.assertFalse(component_util.is_archive_delta_enabled(False))
self.assertFalse(component_util.is_archive_delta_enabled("0"))
self.assertFalse(component_util.is_archive_delta_enabled("0.0"))
self.assertFalse(component_util.is_archive_delta_enabled(0))
self.assertFalse(component_util.is_archive_delta_enabled(0.0))
from time import sleep
from Acspy.Clients.SimpleClient import PySimpleClient
from Acspy.Common.Callbacks import CBvoid
from ACS import CBDescIn
compName = argv[1]
compMethod = argv[2]
print "Parameters to this generic test script are:", argv[1:]
# Make an instance of the PySimpleClient
simpleClient = PySimpleClient()
comp = simpleClient.getComponent(compName)
myCB = CBvoid()
myCorbaCB = simpleClient.activateOffShoot(myCB)
myDescIn = CBDescIn(0L, 0L, 0L)
joe = eval("comp." + compMethod + "(myCorbaCB, myDescIn)")
print "Method executed...now just waiting on CB status"
for i in range(0, 50):
if myCB.status == 'DONE':
print "The callback has finished!"
break
else:
sleep(1)
simpleClient.releaseComponent(compName)
simpleClient.disconnect()
class ServerRepresentationTest(unittest.TestCase):
"""
Test cases for the Server representation.
"""
#---------------------------------------------------------------------------
def setUp(self):
"""
Test case fixture.
"""
self.client = PySimpleClient("ServerRepresentationTest")
self.simulator = self.client.getComponent("SIMULATION_SERVER")
self.lamp = self.client.getComponent("LAMP_ACCESS")
#---------------------------------------------------------------------------
def tearDown(self):
"""
Test case fixture cleanup.
"""
self.client.releaseComponent("SIMULATION_SERVER")
self.client.releaseComponent("LAMP_ACCESS")
self.client.disconnect()
#---------------------------------------------------------------------------
def testSetupBehavior(self):
"""
Modify the behavior of the simulated LAMP_ACCESS component.
Setup the getLampBrightness function so it returns a constant
number.
"""
code = """LOGGER.logInfo('getLampBrightness called.')
6.8"""
self.simulator.setMethod('LAMP_ACCESS', 'getLampBrightness', code, 0.0)
brightness = self.lamp.getLampBrightness()
assert abs(brightness - 6.8) <= 0.01
#---------------------------------------------------------------------------
def testPersistentData(self):
"""
Data can be left in a global buffer located in the Goodies module.
This allows to get input data to persist between calls to the simulated
component.
As this test case shows, this can be useful to simulate get/set methods.
"""
code = """LOGGER.logInfo('setLampBrightness called; brightness='+str(parameters[0]))
from Acssim.Goodies import setGlobalData
setGlobalData('brightness', parameters[0])
None"""
self.simulator.setMethod('LAMP_ACCESS', 'setLampBrightness', code, 0.0)
code = """LOGGER.logInfo('getLampBrightness called.')
from Acssim.Goodies import setGlobalData
getGlobalData('brightness')"""
self.simulator.setMethod('LAMP_ACCESS', 'getLampBrightness', code, 0.0)
self.lamp.setLampBrightness(3.14)
brightness = self.lamp.getLampBrightness()
assert abs(brightness - 3.14) <= 0.01
#---------------------------------------------------------------------------
def testGetGlobalData(self):
"""
The SIMULATION_SERVER component implements also a getGlobalData() function,
which is tested here.
"""
code = """LOGGER.logInfo('setLampBrightness called; brightness='+str(parameters[0]))
from Acssim.Goodies import setGlobalData
setGlobalData('brightness', parameters[0])
None"""
self.simulator.setMethod('LAMP_ACCESS', 'setLampBrightness', code, 0.0)
self.lamp.setLampBrightness(3.14)
brightness = self.simulator.getGlobalData('brightness')
assert brightness == '3.14'
#---------------------------------------------------------------------------
def testRaiseException(self):
"""
Modify the behaviour of the LAMP_ACCESS component so it raises the
LampUnavailable exception when the getLampBrightness() function is
called.
"""
code = """from demo import LampUnavailable
raise LampUnavailable()"""
self.simulator.setMethod('LAMP_ACCESS', 'getLampBrightness', code, 0.0)
try:
b = self.lamp.getLampBrightness()
except LampUnavailable, ex:
return # Correct exception was raised.
except:
class DatabaseImplTestPy(unittest.TestCase):
################################################
# lifecycle
################################################
def setUp(self):
self.simpleClient = PySimpleClient()
self.componentName = "testInstanceDatabaseImpl"
self.simpleClient.getLogger().logInfo("pyUnitTestDatabaseImpl.DatabaseImplTestPy.setUp()...")
self.simpleClient.getLogger().logInfo("Get component " + self.componentName)
self.component = self.simpleClient.getComponent(self.componentName)
#__pPp__
def tearDown(self):
self.simpleClient.getLogger().logInfo("pyUnitTestDatabaseImpl.DatabaseImplTestPy.tearDown()...")
self.simpleClient.getLogger().logInfo("Releasing component " + self.componentName)
self.simpleClient.releaseComponent(self.componentName)
self.simpleClient.disconnect()
#__pPp__
################################################
# test methods
################################################
def testStoreProposal(self):
self.simpleClient.getLogger().logInfo("pyUnitTestDatabaseImpl.DatabaseImplTestPy.testStoreProposal()...")
response = None
targets = Target()
response = self.component.storeProposal(targets)
# a return is expected, response should be not None
assert response is not None
#__pPp__
def testRemoveProposal(self):
self.simpleClient.getLogger().logInfo("pyUnitTestDatabaseImpl.DatabaseImplTestPy.testRemoveProposal()...")
response = None
pid = 0
response = self.component.removeProposal(pid)
# no return is expected, response should be None
assert response is None
#__pPp__
def testGetProposals(self):
self.simpleClient.getLogger().logInfo("pyUnitTestDatabaseImpl.DatabaseImplTestPy.testGetProposals()...")
response = None
response = self.component.getProposals()
# a return is expected, response should be not None
assert response is not None
#__pPp__
def testGetProposalStatus(self):
self.simpleClient.getLogger().logInfo("pyUnitTestDatabaseImpl.DatabaseImplTestPy.testGetProposalStatus()...")
response = None
pid = 0
response = self.component.getProposalStatus(pid)
# a return is expected, response should be not None
assert response is not None
#__pPp__
def testStoreImage(self):
self.simpleClient.getLogger().logInfo("pyUnitTestDatabaseImpl.DatabaseImplTestPy.testStoreImage()...")
response = None
pid = 0
image = ImageType()
response = self.component.storeImage(pid, image)
# no return is expected, response should be None
assert response is None
#__pPp__
def testClean(self):
self.simpleClient.getLogger().logInfo("pyUnitTestDatabaseImpl.DatabaseImplTestPy.testClean()...")
response = None
response = self.component.clean()
# no return is expected, response should be None
assert response is None
#__pPp__
def testSetProposalStatus(self):
self.simpleClient.getLogger().logInfo("pyUnitTestDatabaseImpl.DatabaseImplTestPy.testSetProposalStatus()...")
response = None
pid = 0
status = 0
response = self.component.setProposalStatus(pid, status)
# no return is expected, response should be None
assert response is None
#__pPp__
def testGetProposalObservations(self):
self.simpleClient.getLogger().logInfo("pyUnitTestDatabaseImpl.DatabaseImplTestPy.testGetProposalObservations()...")
response = None
pid = 0
response = self.component.getProposalObservations(pid)
# a return is expected, response should be not None
assert response is not None
clientErrorComponent.TestReceiveRemoteException()
clientErrorComponent.TestReceiveRemoteCompletion()
clientErrorComponent.testExceptionFromCompletion()
clientErrorComponent.testTypeException()
clientErrorComponent.testCORBASystemException()
clientErrorComponent.testCompletionFromCompletion()
clientErrorComponent.testOutCompletion()
except ACSError, ex:
# We should never get here, because the methods in the example
# should be all self contained and none of them should throw
# any exception.
badMethodEx = ACSErrTypeCommonImpl.GenericErrorExImpl(exception=ex)
badMethodEx.setErrorDesc(
"Examples of error handling have thrown an ACS exception")
badMethodEx.log(self.logger)
except Exception, ex:
# We should never get here, because the methods in the example
# should be all self contained and none of them should throw
# any exception.
badMethodEx = pyExceptionToCORBA(ex)
badMethodEx.setData(
"Reason",
"Examples of error handling have thrown an UNEXPECTED exception")
badMethodEx.log(self.logger)
finally:
clientErrorComponent.releaseComponent()
client.disconnect()
g.consumerReady()
sampObj.start()
print " ACS sampling started"
sleep(5)
sampObj.suspend()
print "ACS sampling suspended"
sleep(5)
sampObj.resume()
print "ACS sampling resumed"
sleep(6)
sampObj.stop()
print "ACS sampling stopped"
sleep(2)
sampObj.destroy()
print "ACS sampling destroyed"
#After five events have been received, disconnect from the channel
print "Waiting for events . . ."
while(count<5):
sleep(1)
client.releaseComponent(argv[1])
g.disconnect()
client.disconnect()
#------------------------------------------------------------------------------
# Autoreconnect OFF, Notify Service stopped
def test4():
name = "NamedCh_SUP1"
name_con = "NamedCh_CON1"
consumer = simpleClient.getComponent(name_con)
supplier = simpleClient.getComponent(name)
logger.logAlert("Calling supplier.testReconn1(False,False)")
supplier.testReconn1(False, False)
logger.logAlert("Waiting 10 seconds ...")
sleep(10)
logger.logAlert("Releasing component %s" % (name))
simpleClient.releaseComponent(name)
logger.logAlert("Releasing component %s" % (name_con))
simpleClient.releaseComponent(name_con)
sleep(10)
logger.logAlert('test4 finished')
if num_test == 1:
test1()
elif num_test == 2:
test2()
elif num_test == 3:
test3()
elif num_test == 4:
test4()
simpleClient.disconnect()
magicNumber = int(argv[2])
def myHandler(ts, device, parameter, value):
'''
'''
global count
if count < magicNumber:
count = count + 1
return
#create the consumer
myConsumer = ArchiveConsumer(myHandler)
myConsumer.consumerReady()
#activate the component which will publish the events automatically
joe = PySimpleClient()
ps = joe.getComponent("TEST_PS_1")
#give the consumer a chance to receive the events
sleep(int(argv[1]))
#shutdown everything cleanly
myConsumer.disconnect()
joe.releaseComponent("TEST_PS_1")
joe.disconnect()
if count == magicNumber:
print "Test passed!"
else:
print "Test failed:", count
