def test_update_acs_client(self):
other_client = PySimpleClient()
other_client.getLogger().setLevel(logging.CRITICAL)
self._front_end.update_acs_client(other_client)
self.assertTrue(self._front_end.is_acs_client_ok)
self._front_end.start_recording()
yet_other_client = PySimpleClient()
yet_other_client.getLogger().setLevel(logging.CRITICAL)
self._front_end.update_acs_client(yet_other_client)
self._front_end.stop_recording()
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 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 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
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 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 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
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()
LINKS
- <a href="../../idl/html/interfaceHelloWorld_1_1HelloWorld.html">HelloWorld IDL Documentation</a>
'''
# Import command-line arguments
from sys import argv
# Import the SimpleClient class
from Acspy.Clients.SimpleClient import PySimpleClient
# Make an instance of the PySimpleClient
simpleClient = PySimpleClient()
# Obtain a reference to a dynamic component using the ContainerServices
# getComponent method.
hwRef = simpleClient.getDynamicComponent(
None, "IDL:alma/acsexmplHelloWorld/HelloWorld:1.0",
"acsexmplHelloWorldImpl", str(argv[1]))
if hwRef != None:
simpleClient.getLogger().logInfo("Retrieved valid reference from manager.")
#Do something useful with the reference.
hwRef.displayMessage()
simpleClient.getLogger().logInfo(
"Method of dynamic component successfully invoked. Have a nice day!")
else:
simpleClient.getLogger().logAlert("Bad reference retrieved from manager")
simpleClient.disconnect()
print "The end __oOo__"
count = count + 1
LOGGER.logInfo('The temperature difference is ' + str(someParam.absoluteDiff))
return
#------------------------------------------------------------------------------
if __name__ == "__main__":
print 'Making sure there is a fridge available...'
#Start publishing events through a C++ Supplier
simpleClient = PySimpleClient()
aFridge = simpleClient.getComponent("FRIDGE1")
aFridge.on()
#Create a FridgeConsumer
simpleClient.getLogger().logInfo('Creating FridgeConsumer')
g = Consumer(FRIDGE.CHANNELNAME_FRIDGE)
#Subscribe to temperatureDataBlockEvent events and register this handler to process
#those events
g.addSubscription(FRIDGE.temperatureDataBlockEvent, fridgeDataHandler)
#Let the Notification Service know we are ready to start processing events.
g.consumerReady()
#After five events have been received, disconnect from the channel
simpleClient.getLogger().logInfo("Waiting for events . . .")
while(count<5):
sleep(1)
simpleClient.getLogger().logInfo("Events all done . . . exiting")
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
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 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
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 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
#------------------------------------------------------------------------------
def negotiate (self, time_to_transmit, desc):
'''
For simplicitys sake, we always return true. If you want more detailed,
information on this method, please see the BACI specs.
Parameters: See the BACI specs.
'''
return TRUE
#------------------------------------------------------------------------------
# Make an instance of the PySimpleClient
simpleClient = PySimpleClient()
# Do something on a device.
simpleClient.getLogger().logInfo("We can directly manipulate a device once we get it, which is easy!!")
# Get the standard MOUNT1 Mount device
mount = simpleClient.getComponent("MOUNT1")
# Get the actAz property
actAzProperty = mount._get_actAz()
# Create a callback monitor for the actAz Property
cbMon = MyMonitor("actAz")
# Activate the callback monitor
cbMonServant = simpleClient.activateOffShoot(cbMon)
# Create the real monitor registered with MOUNT1
desc = ACS.CBDescIn(0L, 0L, 0L)
actMon = actAzProperty.create_monitor(cbMonServant, desc)
# Tell MOUNT1 that the monitor's working method should be invoked 1 once second
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
if self.activate:
self.map.aboutToActivate(self.compName)
else:
self.map.aboutToDeactivate(self.compName)
assert(self.map.isProcessing(self.compName))
self.logger.logInfo(self.name+" processing "+self.compName)
if self.activate:
self.map.activated(self.compName)
else:
self.map.deactivated(self.compName)
self.logger.logInfo(self.name+" processed "+self.compName)
simpleClient = PySimpleClient("acspyTestContainerActivationMap")
map = ContainerActivationMap(simpleClient.getLogger())
# Simulate the starting of the activation of multiple components
simpleClient.getLogger().logInfo("Testing activation of components from the main thread...")
for i in range(1000):
name="TestComponent_"+str(i)
map.aboutToActivate(name)
if not map.isProcessing(name):
simpleClient.getLogger().logError("The map does not contain "+name)
assert(map.numOfProcessingItems()==i+1)
# And then their termination of their activation
for i in range(1000):
name="TestComponent_"+str(i)
map.activated(name)
if map.isProcessing(name):
simpleClient.getLogger().logError("The map should NOT contain "+name)
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 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
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston,
# MA 02111-1307 USA
#
#------------------------------------------------------------------------------
#from loggingts.ACSLogTypeExample import SimpleLog,ComplexLog
from ACSLogTypeExampleLTS import SimpleLog, ComplexLog
# Import the acspy.PySimpleClient class
from Acspy.Clients.SimpleClient import PySimpleClient
# Make an instance of the PySimpleClient
simpleClient = PySimpleClient()
simpleClient.getLogger().logInfo("Starting test client.")
SimpleLog().log()
SimpleLog("Array01", "Antenna01").log()
a = ComplexLog()
a.setsomeDoubleMember(3.14159)
a.setsomeStringMember("test string")
a.setsomeLongMember(42)
a.setsomeBooleanMember(True)
a.log()
b = ComplexLog()
b.setArray("Array01")
b.setAntenna("Antenna01")
class MotorImplTestPy(unittest.TestCase):
################################################
# lifecycle
################################################
def setUp(self):
self.simpleClient = PySimpleClient()
self.componentName = "testInstanceMotorImpl"
self.simpleClient.getLogger().logInfo("pyUnitTestMotorImpl.MotorImplTestPy.setUp()...")
self.simpleClient.getLogger().logInfo("Get component " + self.componentName)
self.component = self.simpleClient.getComponent(self.componentName)
#__pPp__
def tearDown(self):
self.simpleClient.getLogger().logInfo("pyUnitTestMotorImpl.MotorImplTestPy.tearDown()...")
self.simpleClient.getLogger().logInfo("Releasing component " + self.componentName)
self.simpleClient.releaseComponent(self.componentName)
self.simpleClient.disconnect()
#__pPp__
################################################
# test methods
################################################
def testMove(self):
self.simpleClient.getLogger().logInfo("pyUnitTestMotorImpl.MotorImplTestPy.testMove()...")
response = None
response = self.component.move()
# no return is expected, response should be None
assert response is None
#__pPp__
def testStandby(self):
self.simpleClient.getLogger().logInfo("pyUnitTestMotorImpl.MotorImplTestPy.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("pyUnitTestMotorImpl.MotorImplTestPy.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("pyUnitTestMotorImpl.MotorImplTestPy.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("pyUnitTestMotorImpl.MotorImplTestPy.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 FrontEndTest(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()
self._my_acs_client.getLogger().setLevel(logging.CRITICAL)
self._front_end = FrontEnd(RecorderConfig(), self._my_acs_client)
self.__my_component_id = "TEST_PROPERTIES_COMPONENT"
def test_is_acs_client_ok(self):
self.assertTrue(self._front_end.is_acs_client_ok)
def test_update_acs_client(self):
other_client = PySimpleClient()
other_client.getLogger().setLevel(logging.CRITICAL)
self._front_end.update_acs_client(other_client)
self.assertTrue(self._front_end.is_acs_client_ok)
self._front_end.start_recording()
yet_other_client = PySimpleClient()
yet_other_client.getLogger().setLevel(logging.CRITICAL)
self._front_end.update_acs_client(yet_other_client)
self._front_end.stop_recording()
def test_start_recording(self):
self._front_end.start_recording()
self.assertTrue(self._front_end.is_recording)
self._front_end.stop_recording()
self._my_acs_client.getComponent(self.__my_component_id, True)
self._front_end.start_recording()
self.assertTrue(self._front_end.is_recording)
self._front_end.stop_recording()
self._my_acs_client.releaseComponent(self.__my_component_id)
def test_process_component(self):
self._my_acs_client.getComponent(self.__my_component_id, True)
self._front_end.process_component(self.__my_component_id)
self._my_acs_client.releaseComponent(self.__my_component_id)
self.assertRaises(CannotAddComponentException,
self._front_end.process_component, "I_DO_NOT_EXIST")
def test_remove_wrong_components(self):
self._my_acs_client.getComponent(self.__my_component_id, True)
self._front_end.start_recording()
time.sleep(3)
self._my_acs_client.releaseComponent(self.__my_component_id)
time.sleep(10)
self._front_end.stop_recording()
def tearDown(self):
self._front_end.cancel()
self._front_end = None
# Foundation, Inc., 59 Temple Place, Suite 330, Boston,
# MA 02111-1307 USA
#
#------------------------------------------------------------------------------
#from loggingts.ACSLogTypeExample import simpleLog,complexLog
from ACSLogTypeExampleLTS import simpleLog,complexLog
# Import the acspy.PySimpleClient class
from Acspy.Clients.SimpleClient import PySimpleClient
# Make an instance of the PySimpleClient
simpleClient = PySimpleClient()
simpleClient.getLogger().logInfo("Starting test client.")
simpleLog().log()
simpleLog("Array01","Antenna01").log()
a=complexLog()
a.setsomeDoubleMember(3.14159)
a.setsomeStringMember("test string")
a.setsomeLongMember(42)
a.setsomeBooleanMember(True)
a.log()
b=complexLog()
b.setArray("Array01")
b.setAntenna("Antenna01")
def negotiate(self, time_to_transmit, desc):
'''
For simplicitys sake, we always return true. If you want more detailed,
information on this method, please see the BACI specs.
Parameters: See the BACI specs.
'''
return TRUE
#------------------------------------------------------------------------------
# Make an instance of the PySimpleClient
simpleClient = PySimpleClient()
# Do something on a device.
simpleClient.getLogger().logInfo(
"We can directly manipulate a device once we get it, which is easy!!")
# Get the standard MOUNT1 Mount device
mount = simpleClient.getComponent("MOUNT1")
# Get the actAz property
actAzProperty = mount._get_actAz()
# Create a callback monitor for the actAz Property
cbMon = MyMonitor("actAz")
# Activate the callback monitor
cbMonServant = simpleClient.activateOffShoot(cbMon)
# Create the real monitor registered with MOUNT1
desc = ACS.CBDescIn(0L, 0L, 0L)
actMon = actAzProperty.create_monitor(cbMonServant, desc)
# Tell MOUNT1 that the monitor's working method should be invoked 1 once second
LINKS
- <li><a href="../../idl/html/interfaceMOUNT_ACS_1_1Mount.html">Mount IDL Documentation</a>
'''
# Import the acspy.PySimpleClient class
from Acspy.Clients.SimpleClient import PySimpleClient
# Make an instance of the PySimpleClient
simpleClient = PySimpleClient()
# Print information about the available COBs
components = simpleClient.availableComponents()
simpleClient.getLogger().logInfo("COBs available are: ")
for cob in components:
simpleClient.getLogger().logInfo(cob.name + " of type " + cob.type)
# Do something on a device.
simpleClient.getLogger().logInfo("We can directly manipulate a device once we get it, which is easy.")
try:
# Get the standard MOUNT1 Mount device
mount = simpleClient.getComponent("MOUNT1")
# Get the actAz property
actAzProperty = mount._get_actAz()
# Ask the current value of the property
(azm, compl) = actAzProperty.get_sync()
simpleClient.getLogger().logInfo("MOUNT1 actual azimuth: " + str(azm))
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))
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
from subprocess import *
import ACSErrTypeCommon
import ACSErrTypeCommonImpl
import sys
import time
# Import the acspy.PySimpleClient class
from Acspy.Clients.SimpleClient import PySimpleClient
from Acspy.Nc.Consumer import Consumer
from Control import CHANNELNAME_CONTROLSYSTEM
from Control import ExecBlockStartedEvent
from Control import ExecBlockEndedEvent
# Make an instance of the PySimpleClient
simpleClient = PySimpleClient()
simpleClient.getLogger().logInfo("Simple client instantiated.")
global started
global ended
def handlerStarted(event):
global started
started += 1
print event.execId
print event.sbId
print event.sessionId
print event.arrayName
print event.startTime
return
def handlerEnded(event):
- <a href="../../idl/html/interfaceHelloWorld_1_1HelloWorld.html">HelloWorld IDL Documentation</a>
'''
import ACSErrTypeCommon
import ACSErrTypeCommonImpl
# Import the acspy.PySimpleClient class
from Acspy.Clients.SimpleClient import PySimpleClient
# Make an instance of the PySimpleClient
simpleClient = PySimpleClient()
try:
# Get the standard HelloWorld device
hw = simpleClient.getComponent("HELLOWORLD1")
simpleClient.getLogger().logInfo("Trying to invoke bad method")
hw.badMethod()
except ACSErrTypeCommon.UnknownEx, e:
simpleClient.getLogger().logCritical("Caught an ACSException...don't worry because this SHOULD happen.")
helperException = ACSErrTypeCommonImpl.UnknownExImpl(exception=e)
helperException.Print()
helperException.log(simpleClient.getLogger())
# Release it
simpleClient.releaseComponent("HELLOWORLD1")
except Exception, e:
simpleClient.getLogger().logAlert("Caught the wrong type of exception!!!")
simpleClient.getLogger().logDebug("The exception was:" + str(e))
simpleClient.disconnect()
- <a href="../../idl/html/interfaceHelloWorld_1_1HelloWorld.html">HelloWorld IDL Documentation</a>
'''
import ACSErrTypeCommon
import ACSErrTypeCommonImpl
# Import the acspy.PySimpleClient class
from Acspy.Clients.SimpleClient import PySimpleClient
# Make an instance of the PySimpleClient
simpleClient = PySimpleClient()
try:
# Get the standard HelloWorld device
hw = simpleClient.getComponent("HELLOWORLD1")
simpleClient.getLogger().logInfo("Trying to invoke bad method")
hw.badMethod()
except ACSErrTypeCommon.UnknownEx, e:
simpleClient.getLogger().logCritical(
"Caught an ACSException...don't worry because this SHOULD happen.")
helperException = ACSErrTypeCommonImpl.UnknownExImpl(exception=e)
helperException.Print()
helperException.log(simpleClient.getLogger())
# Release it
simpleClient.releaseComponent("HELLOWORLD1")
except Exception, e:
simpleClient.getLogger().logAlert("Caught the wrong type of exception!!!")
simpleClient.getLogger().logDebug("The exception was:" + str(e))
- Manipulating BACI properties
LINKS
- <li><a href="../../idl/html/interfaceMOUNT_ACS_1_1Mount.html">Mount IDL Documentation</a>
'''
# Import the acspy.PySimpleClient class
from Acspy.Clients.SimpleClient import PySimpleClient
# Make an instance of the PySimpleClient
simpleClient = PySimpleClient()
# Print information about the available COBs
components = simpleClient.availableComponents()
simpleClient.getLogger().logInfo("COBs available are: ")
for cob in components:
simpleClient.getLogger().logInfo(cob.name + " of type " + cob.type)
# Do something on a device.
simpleClient.getLogger().logInfo(
"We can directly manipulate a device once we get it, which is easy.")
try:
# Get the standard MOUNT1 Mount device
mount = simpleClient.getComponent("MOUNT1")
# Get the actAz property
actAzProperty = mount._get_actAz()
# Ask the current value of the property
(azm, compl) = actAzProperty.get_sync()
if self.activate:
self.map.aboutToActivate(self.compName)
else:
self.map.aboutToDeactivate(self.compName)
assert (self.map.isProcessing(self.compName))
self.logger.logInfo(self.name + " processing " + self.compName)
if self.activate:
self.map.activated(self.compName)
else:
self.map.deactivated(self.compName)
self.logger.logInfo(self.name + " processed " + self.compName)
simpleClient = PySimpleClient("acspyTestContainerActivationMap")
map = ContainerActivationMap(simpleClient.getLogger())
# Simulate the starting of the activation of multiple components
simpleClient.getLogger().logInfo(
"Testing activation of components from the main thread...")
for i in range(1000):
name = "TestComponent_" + str(i)
map.aboutToActivate(name)
if not map.isProcessing(name):
simpleClient.getLogger().logError("The map does not contain " + name)
assert (map.numOfProcessingItems() == i + 1)
# And then their termination of their activation
for i in range(1000):
name = "TestComponent_" + str(i)
map.activated(name)
if map.isProcessing(name):
# BUGS
#
#------------------------------------------------------------------------
#
# Import the acspy.PySimpleClient class
import time
from Acspy.Clients.SimpleClient import PySimpleClient
# Make an instance of the PySimpleClient
simpleClient = PySimpleClient()
# Print information about the available COBs
# Do something on a device.
simpleClient.getLogger().logInfo(
"We can directly manipulate a device once we get it, which is easy.")
try:
# Get the standard MOUNT1 Mount device
ws = simpleClient.getComponent("MONITOR_COLLECTOR")
# Get the humidity
ws.registerMonitoredDevice("SensorTag", "1")
# Print value
ws.startMonitoring("SensorTag")
raw_input("##################Press enter to quit#########################")
# Release it
simpleClient.releaseComponent("MONITOR_COLLECTOR")
except Exception, e:
simpleClient.getLogger().logCritical(
"Sorry, I expected there to be a Mount in the system and there isn't.")
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
- <a href="../../idl/html/interfaceHelloWorld_1_1HelloWorld.html">HelloWorld IDL Documentation</a>
'''
# Import command-line arguments
from sys import argv
# Import the SimpleClient class
from Acspy.Clients.SimpleClient import PySimpleClient
# Make an instance of the PySimpleClient
simpleClient = PySimpleClient()
# Obtain a reference to a dynamic component using the ContainerServices
# getComponent method.
hwRef = simpleClient.getDynamicComponent(None,
"IDL:alma/acsexmplHelloWorld/HelloWorld:1.0",
"acsexmplHelloWorldImpl",
str(argv[1]))
if hwRef != None:
simpleClient.getLogger().logInfo("Retrieved valid reference from manager.")
#Do something useful with the reference.
hwRef.displayMessage()
simpleClient.getLogger().logInfo("Method of dynamic component successfully invoked. Have a nice day!")
else:
simpleClient.getLogger().logAlert("Bad reference retrieved from manager")
simpleClient.disconnect()
print "The end __oOo__"
