# some imports

from tango.test_context import DeviceTestContext

@pytest.fixture(scope="class")
def tango_context(request):

# code to get klass name

properties = {'DeviceB_FQDN': 'tango://test/device/b'}

tango_context = DeviceTestContext(klass, properties=properties)
tango_context.start()

"""Client tests that run against the standard TangoTest device.

Due to a TANGO 9 issue (#821), the device is run without any database.
Note that this means that various features won't work:

 * No device configuration via properties.
 * No event generated by the server.
 * No memorized attributes.
 * No device attribute configuration via the database.

So don't even try to test anything of the above as it will not work
and is even likely to crash the device (!)

"""

from tango import DeviceProxy, DevState
from tango.server import Device
from tango.server import command, attribute, device_property
from tango.test_utils import DeviceTestContext


def test_multiple_devices():

    class DeviceA(Device):
        b_address = device_property(dtype='str')

        @command(dtype_in='str')
        def SetAttrOnDeviceB(self, arg):
            dp = DeviceProxy(self.b_address)
            dp.SetAttr(arg)

    class DeviceB(Device):

        def init_device(self):
            self._attr = '123'

        @attribute(dtype='str')
        def attr(self):
            return self._attr

        @command(dtype_in='str')
        def SetAttr(self, arg):
            self._attr = arg

    # As we will launch multiple test devices, we need to set process=True
    # See https://github.com/tango-controls/pytango/pull/77
    context_b = DeviceTestContext(DeviceB, process=True)
    with context_b as proxy_b:
        # test accessing DeviceB directly
        assert proxy_b.attr == '123'
        proxy_b.SetAttr('456')
        assert proxy_b.attr == '456'

        # get address for DeviceB (changes for every test run)
        properties = {'b_address': context_b.get_device_access()}
        context_a = DeviceTestContext(DeviceA, properties=properties, process=True)
        with context_a as proxy_a:
            # test accessing DeviceB via DeviceA
            proxy_a.SetAttrOnDeviceB('789')
            assert proxy_b.attr == '789'


def test_device_property_on_init():

    class TestDevice(Device):
        my_property = device_property(dtype='str')

        def init_device(self):
            super(TestDevice, self).init_device()
            assert self.my_property == 'Testing123'

    # get address for DeviceB (changes for every test run)
    properties = {'my_property': 'Testing123'}
    with DeviceTestContext(TestDevice, properties=properties) as proxy:
        # Check state just to ensure device started up
        assert proxy.state() == DevState.UNKNOWN

import socket
import time

from tango import DeviceProxy, EventType
from tango.server import Device
from tango.server import command, attribute, device_property
from tango.test_utils import DeviceTestContext


def get_open_port():
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.bind(("", 0))
    s.listen(1)
    port = s.getsockname()[1]
    s.close()
    return port


def test_subscribe_change_events():

    MAX_RETRIES = 10
    TIME_PER_RETRY = 0.1

    class DeviceA(Device):
        b_address = device_property(dtype='str')

        def init_device(self):
            super(DeviceA, self).init_device()
            self._sub_id = None
            self._sub_proxy = None
            self._results = []

        @attribute(dtype=('str',), max_dim_x=10)
        def results(self):
            return self._results

        def _event_callback(self, evt):
            if evt.attr_value:
                self._results.append(evt.attr_value.value)
            else:
                print('bad event: %s' % evt)

        @command(dtype_in='str')
        def SetAttrOnDeviceB(self, arg):
            dp = DeviceProxy(self.b_address)
            dp.SetAttr(arg)

        @command()
        def SubscribeToAttrOnDeviceB(self):
            assert self._sub_id is None, "Already subscribed!"
            dp = DeviceProxy(self.b_address)
            self._sub_id = dp.subscribe_event(
                "attr", EventType.CHANGE_EVENT, self._event_callback, wait=True)
            self._sub_proxy = dp
            # Note:
            # - need to keep a reference to the device proxy if we want to unsubscribe
            # - subscribing triggers _event_callback with the current value

        @command()
        def UnsubscribeFromAttrOnDeviceB(self):
            assert self._sub_id is not None, "Not subscribed!"
            # unsubscribing can only be done using the same device proxy instance
            self._sub_proxy.unsubscribe_event(self._sub_id)

    class DeviceB(Device):

        def init_device(self):
            super(DeviceB, self).init_device()
            self._attr = '123'
            self.set_change_event("attr", True, False)  # manually triggered

        @attribute(dtype='str')
        def attr(self):
            return self._attr

        @command(dtype_in='str')
        def SetAttr(self, arg):
            self._attr = arg
            self.push_change_event("attr", arg)

    # events from test context device only work if a port is specified (ZMQ related)
    port = get_open_port()
    context_b = DeviceTestContext(DeviceB, port=port, process=True)
    with context_b:
        # get address for DeviceB (changes for every test run)
        properties = {'b_address': context_b.get_device_access()}
        context_a = DeviceTestContext(DeviceA, properties=properties, process=True)
        with context_a as proxy_a:
            # set up the subscription once - this will provide the initial value
            proxy_a.SubscribeToAttrOnDeviceB()
            assert proxy_a.results == ('123', )

            # trigger events on DeviceB via DeviceA
            proxy_a.SetAttrOnDeviceB('456')
            proxy_a.SetAttrOnDeviceB('789')
            # wait for events
            for _ in range(MAX_RETRIES):
                results = proxy_a.results
                if len(results) >= 3:
                    break
                time.sleep(TIME_PER_RETRY)
            # Check the event values
            assert results == ('123', '456', '789')

            # unsubscribe (e.g., if the event is no longer required)
            proxy_a.UnsubscribeFromAttrOnDeviceB()

            # test the events have stopped
            proxy_a.SetAttrOnDeviceB('000')
            # wait for events
            for _ in range(MAX_RETRIES):
                new_results = proxy_a.results
                if len(new_results) > 3:
                    break
                time.sleep(TIME_PER_RETRY)
            # Check the event values haven't changed
            assert new_results == results