def test_restart__should_call_sdk_function(self):
obj = ZKAccess(connstr=self.connstr)
obj.restart()
self.sdk.control_device.assert_called_once_with(
ControlOperation.restart.value, 0, 0, 0, 0)
assert obj.connstr == self.connstr
def test_connect__if_connected_and_trying_connect_with_same_connstr__should_do_nothing(
self):
obj = ZKAccess(connstr=self.connstr)
obj.connect(self.connstr)
self.sdk.connect.assert_not_called()
assert obj.connstr == self.connstr
def test_disconnect__should_call_sdk_function(self):
obj = ZKAccess(connstr=self.connstr)
obj.disconnect()
self.sdk.disconnect.assert_called_once_with()
assert obj.connstr == self.connstr
def test_connect__if_connected_and_trying_connect_with_another_connstr__should_raise_error(
self):
obj = ZKAccess(connstr=self.connstr)
connstr2 = 'protocol=TCP,ipaddress=192.168.1.202,port=4370,timeout=4000,passwd='
with pytest.raises(ValueError):
obj.connect(connstr2)
def test_table__should_return_different_queryset_objects(self, table_name):
obj = ZKAccess(connstr=self.connstr, device_model=ZK400)
res1 = obj.table(table_name)
res2 = obj.table(table_name)
assert res1 is not res2
assert res1._sdk is res2._sdk
def test_change_ip_address__shoudl_call_sdk_function(self):
self.sdk.modify_ip_address.return_value = None
ZKAccess.change_ip('00:17:61:01:88:27', '192.168.1.100',
'255.255.255.0', ChangeIPProtocol.udp, 'path')
self.sdk.modify_ip_address.assert_called_once_with(
'00:17:61:01:88:27', '192.168.1.100', '255.255.255.0', 'UDP')
def test_cancel_alarm__should_call_sdk(self):
self.sdk.control_device.return_value = 0
obj = ZKAccess(connstr=self.connstr)
obj.cancel_alarm()
self.sdk.control_device.assert_called_once_with(
ControlOperation.cancel_alarm.value, 0, 0, 0, 0)
def test_upload_file__should_upload_file(self):
self.sdk.set_device_file_data.return_value = None
obj = ZKAccess(connstr=self.connstr, device_model=ZK400)
data_stream = io.BytesIO(b'file_data!')
obj.upload_file('test_file.dat', data_stream)
self.sdk.set_device_file_data.assert_called_once_with(
'test_file.dat', b'file_data!', 10)
def test_table__should_return_queryset(self, table_name):
obj = ZKAccess(connstr=self.connstr, device_model=ZK400)
res = obj.table(table_name)
assert isinstance(res, QuerySet)
assert res._sdk is obj.sdk
assert res._table_cls == User
assert res._buffer_size is None
def test_table__should_return_instance_of_queryset_class(self):
class QuerySetStub(QuerySet):
pass
obj = ZKAccess(connstr=self.connstr, device_model=ZK400)
obj.queryset_class = QuerySetStub
res = obj.table('User')
assert isinstance(res, QuerySetStub)
def test_connect__should_call_sdk_function(self):
connstr = 'protocol=TCP,ipaddress=192.168.1.201,port=4370,timeout=4000,passwd='
obj = ZKAccess()
self.sdk.handle = None
self.sdk.is_connected = False
obj.connect(connstr)
self.sdk.connect.assert_called_once_with(connstr)
assert obj.connstr == connstr
def test_connect_if_connstr_set_in_contructor(self):
test_connstr = 'protocol=TCP,ipaddress=10.0.3.201,port=4370,timeout=4000,passwd='
# self.obj.connect = Mock()
with patch('ctypes.WinDLL', create=True) as m:
obj = Mock(spec=ZKAccess)
# obj.__init__ = Mock(wraps=ZKAccess.__init__)
ZKAccess.__init__(obj, 'somedll', test_connstr)
obj.connect.assert_called_once_with(test_connstr)
def test_upload_file__should_preserve_stream_pointer_position(self):
self.sdk.set_device_file_data.return_value = None
obj = ZKAccess(connstr=self.connstr, device_model=ZK400)
data_stream = io.BytesIO(b'file_data!')
data_stream.seek(3)
obj.upload_file('test_file.dat', data_stream)
self.sdk.set_device_file_data.assert_called_once_with(
'test_file.dat', b'e_data!', 7)
assert data_stream.tell() == 3
def test_download_file__if_buffer_size_explicitly_set__should_call_sdk_once(
self, buffer_size):
file_data = b'a' * buffer_size
self.sdk.get_device_file_data.return_value = file_data
obj = ZKAccess(connstr=self.connstr, device_model=ZK400)
res = obj.download_file('test_file.dat', buffer_size)
assert isinstance(res, io.BytesIO)
assert res.getvalue() == file_data
self.sdk.get_device_file_data.assert_called_once_with(
'test_file.dat', buffer_size)
def test_download_file__should_download_file_with_default_buffer_size(
self):
file_data = b'file_data!'
self.sdk.get_device_file_data.return_value = file_data
obj = ZKAccess(connstr=self.connstr, device_model=ZK400)
res = obj.download_file('test_file.dat')
assert isinstance(res, io.BytesIO)
assert res.getvalue() == file_data
self.sdk.get_device_file_data.assert_called_once_with(
'test_file.dat', 1 * 1024 * 1024)
def test_init__if_no_autoconnect__should_initialize_default_attributes(self):
obj = ZKAccess()
assert obj.connstr is None
assert obj.device_model == ZK400
assert obj.sdk is self.sdk
assert obj._device is None
def test_device_prop__if_not_connected__should_raise_error(self):
self.sdk.handle = None
self.sdk.is_connected = False
obj = ZKAccess()
with pytest.raises(RuntimeError):
_ = obj.device
def test_parameters_prop__should_return_object_of_device_parameters(self):
obj = ZKAccess(connstr=self.connstr, device_model=ZK200)
res = obj.parameters
assert type(res) == DeviceParameters
assert res._sdk == self.sdk
assert res.device_model == ZK200
def _search_devices():
devices = ZKAccess.search_devices(broadcast_address, dllpath=self._dllpath)
for device in devices:
values = [
device.mac, device.ip, device.serial_number, device.model.name, device.version
]
yield dict(zip(headers, values))
def test_context_manager__should_disconnect_after_exit(self):
obj = ZKAccess(connstr=self.connstr)
with obj:
pass
self.sdk.disconnect.assert_called_once_with()
def test_init__if_no_autoconnect__should_initialize_default_event_log_attributes(self):
obj = ZKAccess()
assert type(obj._event_log) == EventLog
assert obj._event_log._sdk is self.sdk
assert obj._event_log.buffer_size == 4096
assert obj._event_log.data.maxlen is None
assert obj._event_log.only_filters == {}
def test_search_devices__if_other_error_raised__should_reraise_it(self):
self.sdk.search_device.side_effect = ZKSDKError(
"Empty command response", -5)
with pytest.raises(ZKSDKError) as e:
res = ZKAccess.search_devices('192.168.1.255')
assert e.value.err == -5
def test_search_devices__if_no_devices_found_error_raise__should_return_empty_tuple(
self):
self.sdk.search_device.side_effect = ZKSDKError(
"Empty command response", -2)
expect = ()
res = ZKAccess.search_devices('192.168.1.255')
assert res == expect
def test_doors_prop__should_return_object_sequence(self, model, doors_count):
obj = ZKAccess(connstr=self.connstr, device_model=model)
res = obj.doors
assert len(res) == doors_count
assert type(res) == DoorList
assert all(type(x) == Door for x in res)
assert all(obj.number == num for obj, num in zip(res, model.doors_def))
def test_aux_inputs_prop__should_return_object_sequence(self, model, aux_input_count):
obj = ZKAccess(connstr=self.connstr, device_model=model)
res = obj.aux_inputs
assert len(res) == aux_input_count
assert type(res) == AuxInputList
assert all(type(x) == AuxInput for x in res)
assert all(obj.number == num for obj, num in zip(res, model.aux_inputs_def))
def test_relays_prop__should_return_object_sequence(self, model, relay_count):
obj = ZKAccess(connstr=self.connstr, device_model=model)
res = obj.relays
assert len(res) == relay_count
assert type(res) == RelayList
assert all(type(x) == Relay for x in res)
assert all(obj.number == num for obj, num in zip(res, model.relays_def))
assert all(obj.group == group for obj, group in zip(res, model.groups_def))
def test_init__if_device_is_specified__should_override_device_model(self):
device = ZKDevice(mac='00:17:61:C8:EC:17',
ip='192.168.1.201',
serial_number='DGD9190019050335134',
model=ZK100,
version='AC Ver 4.3.4 Apr 28 2017')
obj = ZKAccess(device=device, device_model=ZK200)
assert obj.device_model == ZK200
def test_download_file__if_buffer_got_overflowed__should_repeat_with_double_buffer_size(
self, data_size):
def se(*a, **kw):
return file_data[:a[1]]
file_data = b'a' * data_size
self.sdk.get_device_file_data.side_effect = se
obj = ZKAccess(connstr=self.connstr, device_model=ZK400)
expect_calls = [
call('test_file.dat', 1 * 1024 * 1024),
call('test_file.dat', 2 * 1024 * 1024)
]
res = obj.download_file('test_file.dat')
self.sdk.get_device_file_data.assert_has_calls(expect_calls)
assert isinstance(res, io.BytesIO)
assert res.tell() == 0
assert len(res.getvalue()) == len(file_data)
def change_ip(
self, mac_address: str, new_ip: str, *, broadcast_address: str = '255.255.255.255'
):
"""
Classmethod that changes IP address on a device without
making a connection to it -- by sending broadcast packets to
the given broadcast address. For security reasons, network
settings can be changed by this command on devices with
no password only.
Args:
mac_address: MAC address of a device
new_ip: new IP address to be set on a device
broadcast_address: broadcast network address to send
broadcast packets to
"""
ZKAccess.change_ip(
mac_address, new_ip, broadcast_address, ChangeIPProtocol.udp, self._dllpath
)
def test_device_prop__if_device_was_passed_to_init__should_return_it(self):
device = ZKDevice(mac='00:17:61:C8:EC:17',
ip='192.168.1.201',
serial_number='DGD9190019050335134',
model=ZK100,
version='AC Ver 4.3.4 Apr 28 2017')
obj = ZKAccess(device=device)
res = obj.device
assert res is device
