def test_bad_host_address(self):
from cloudio.common.utils.resource_loader import ResourceLoader
from cloudio.common.utils.resource_loader import prettify
endpoint_config = 'VacuumCleanerEndpoint.properties'
config = ResourceLoader.load_from_locations(endpoint_config, ['home:/.config/cloud.io', ])
self.assertNotEqual(config, dict()) # You must provide the needed config files!
options = mqtt.MqttConnectOptions()
options.ca_file = prettify(config['ch.hevs.cloudio.endpoint.ssl.authorityCert'])
options.client_cert_file = prettify(config['ch.hevs.cloudio.endpoint.ssl.clientCert'])
options.client_key_file = prettify(config['ch.hevs.cloudio.endpoint.ssl.clientKey'])
bad_host_address = 'test.' + config['ch.hevs.cloudio.endpoint.hostUri']
client = mqtt.MqttReconnectClient(host=bad_host_address,
client_id='test-vacuum-cleaner' + '-endpoint-',
clean_session=True,
options=options)
client.start()
client.start() # Start a second time
time.sleep(2)
client.publish('test', 'test')
time.sleep(3)
client.stop()
def test_ssl_options_tls_versions(self):
client = mqtt.MqttReconnectClient(host=None)
options = mqtt.MqttConnectOptions()
options.tls_version = 'tlsv1'
with self.assertRaises(ValueError): # ValueError: Invalid host.
client.connect(options=options)
def test_option_password(self):
client = mqtt.MqttReconnectClient(host=None)
options = mqtt.MqttConnectOptions()
options.username = '******'
options.password = '******'
with self.assertRaises(ValueError): # ValueError: Invalid host.
client.connect(options=options)
options.password = ''
with self.assertRaises(ValueError): # ValueError: Invalid host.
client.connect(options=options)
def test_ssl_options_will(self):
client = mqtt.MqttReconnectClient(host=None)
options = mqtt.MqttConnectOptions()
options.will = {'topic': '', }
with self.assertRaises(KeyError): # KeyError: 'message'
client.connect(options=options)
will_message = 'DEAD'
options.set_will('@offline/VacuumCleanerEndpoint', will_message, 1, False)
with self.assertRaises(ValueError): # ValueError: Invalid host.
client.connect(options=options)
def test_mqtt_async_client_connect_bad_options(self):
import contextlib
ca_file_name = 'ca-file.pem'
client_cert_file_name = 'client-cert-file.pem'
client_key_file_name = 'client-key-file.pem'
# Delete local files
with contextlib.suppress(FileNotFoundError):
os.remove(ca_file_name)
os.remove(client_cert_file_name)
os.remove(client_key_file_name)
client = mqtt.MqttAsyncClient(host=None)
client._create_mqtt_client()
with self.assertRaises(ValueError): # ValueError: Invalid host
options = mqtt.MqttConnectOptions()
client.connect(options=options)
client.disconnect()
with self.assertRaises(RuntimeError): # RuntimeError: CA file 'ca-file.pem' does not exist!
options = mqtt.MqttConnectOptions()
options.ca_file = ca_file_name
client.connect(options=options)
ca_file = open(ca_file_name, 'a')
with self.assertRaises(RuntimeError): # RuntimeError: Client certificate file 'client-cert-file.pem'
# does not exist!
options = mqtt.MqttConnectOptions()
options.ca_file = ca_file_name
options.client_cert_file = client_cert_file_name
client.connect(options=options)
client_cert_file = open(client_cert_file_name, 'a')
with self.assertRaises(RuntimeError): # RuntimeError: Client private key file 'client-key-file.pem'
# does not exist!
options = mqtt.MqttConnectOptions()
options.ca_file = ca_file_name
options.client_cert_file = client_cert_file_name
options.client_key_file = client_key_file_name
client.connect(options=options)
client_key_file = open(client_key_file_name, 'a')
with self.assertRaises(ssl.SSLError): # ssl.SSLError: [SSL] PEM lib
options = mqtt.MqttConnectOptions()
options.ca_file = ca_file_name
options.client_cert_file = client_cert_file_name
options.client_key_file = client_key_file_name
client.connect(options=options)
# Tidy up
ca_file.close()
client_cert_file.close()
client_key_file.close()
with contextlib.suppress(FileNotFoundError):
os.remove(ca_file_name)
os.remove(client_cert_file_name)
os.remove(client_key_file_name)
def test_mqtt_publish_receive_message(self):
from cloudio.common.utils.resource_loader import ResourceLoader
from cloudio.common.utils.resource_loader import prettify
class VacuumCleanerModel(object):
def __init__(self, mqtt_client: mqtt.MqttReconnectClient):
super(VacuumCleanerModel, self).__init__()
self._client = mqtt_client
mqtt_client.set_on_connected_callback(self.on_connected_callback)
mqtt_client.set_on_connection_thread_finished_callback(self.on_connection_thread_finished_callback)
mqtt_client.set_on_message_callback(self.on_message_callback)
mqtt_client.set_on_message_published(self.on_message_published)
self.connected = False
self.conn_thread_finished = False
self.msg_received = False
self.received_topic = ''
self.msg_published = False
def on_connected_callback(self):
self.connected = True
# Subscribe to '@set' message
self._client.subscribe('@set/' + 'VacuumCleanerEndpoint' + '/#', 1)
# Test subscription by sending a '@set' message
self._client.publish('@set/VacuumCleanerEndpoint/test', '{"value":"1" }')
def on_connection_thread_finished_callback(self):
self.conn_thread_finished = True
def on_message_callback(self, client, userdata, msg):
self.msg_received = True
self.received_topic = msg.topic
def on_message_published(self, client, userdata, mid):
self.msg_published = True
endpoint_config = 'VacuumCleanerEndpoint.properties'
config = ResourceLoader.load_from_locations(endpoint_config, ['home:/.config/cloud.io', ])
self.assertNotEqual(config, dict()) # You must provide the needed config files!
options = mqtt.MqttConnectOptions()
options.ca_file = prettify(config['ch.hevs.cloudio.endpoint.ssl.authorityCert'])
options.client_cert_file = prettify(config['ch.hevs.cloudio.endpoint.ssl.clientCert'])
options.client_key_file = prettify(config['ch.hevs.cloudio.endpoint.ssl.clientKey'])
client = mqtt.MqttReconnectClient(host=config['ch.hevs.cloudio.endpoint.hostUri'],
client_id='test-vacuum-cleaner' + '-endpoint-',
clean_session=True,
options=options)
model = VacuumCleanerModel(client)
client.start()
time.sleep(2)
client.stop()
self.assertTrue(model.connected)
self.assertTrue(model.conn_thread_finished)
self.assertTrue(model.msg_received)
self.assertTrue('test' in model.received_topic)
self.assertTrue(model.msg_published)