update po file

* add links to add-on urls

* Add translations

* set app.testing to get exceptions during test

* improve unit-tests for the web-UI

* update changelog

* extend languages tests

* workaround for github runner

.github/workflows/python-app.yml

@@ -5,7 +5,7 @@ name: Python application
 
 on:
   push:
-    branches: [ "main", "dev-*", "*/issue*" ]
+    branches: [ "main", "dev-*", "*/issue*", "releases/*" ]
     paths-ignore:
     - '**.md' # Do no build on *.md changes
     - '**.yml' # Do no build on *.yml changes
@@ -18,7 +18,7 @@ on:
     - '**.dockerfile' # Do no build on *.dockerfile changes
     - '**.sh' # Do no build on *.sh changes     
   pull_request:
-    branches: [ "main", "dev-*" ]
+    branches: [ "main", "dev-*", "releases/*" ]
 
 permissions:
   contents: read

.python-version

@@ -1 +1 @@
-3.13.2
+3.13.5

CHANGELOG.md

@@ -7,6 +7,21 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [unreleased]
 
+- add-on: add links to config and log-file to the web-UI
+- fix some SonarQube warnings
+- remove unused 32-bit architectures
+- Babel don't build new po file if only the pot creation-date was changed
+- Improve Makefile
+- Update dependency pytest-asyncio to v1
+
+## [0.14.1] - 2025-05-31
+
+- handle missing MQTT addon [#438](https://github.com/s-allius/tsun-gen3-proxy/issues/438)
+
+## [0.14.0] - 2025-05-29
+
+- add-on: bump python to version 3.12.10-r1
+- set no of pv modules for MS800 GEN3PLUS inverters
 - fix the paths to copy the config.example.toml file during proxy start
 - add MQTT topic `dcu_power` for setting output power on DCUs
 - Update ghcr.io/hassio-addons/base Docker tag to v17.2.5

Makefile

@@ -1,27 +1,37 @@
-.PHONY: build babel clean addon-dev addon-debug addon-rc addon-rel debug dev preview rc rel check-docker-compose install
+.PHONY: help build babel clean addon-dev addon-debug addon-rc addon-rel debug dev preview rc rel check-docker-compose install
 
-babel:
+help: ## show help message
+	@awk 'BEGIN {FS = ":.*##"; printf "\nUsage:\n  make \033[36m\033[0m\n"} /^[$$()% a-zA-Z0-9_-]+:.*?##/ { printf "  \033[36m%-15s\033[0m %s\n", $$1, $$2 } /^##@/ { printf "\n\033[1m%s\033[0m\n", substr($$0, 5) } ' $(MAKEFILE_LIST)
+
+babel:            ## build language files
 	$(MAKE) -C app $@
 
 build:
 	$(MAKE) -C ha_addons $@ 
 
-clean:
+clean:             ## delete all built files
 	$(MAKE) -C app $@
 	$(MAKE) -C ha_addons $@ 
 
-debug dev preview rc rel:
+debug dev preview rc rel:  ## build docker container in <dev|debg|rc|rel> version
 	$(MAKE) -C app babel
 	$(MAKE) -C app $@
 
-addon-dev addon-debug addon-rc addon-rel:
+addon-dev addon-debug addon-rc addon-rel: ## build HA add-on in <dev|debg|rc|rel> version
 	$(MAKE) -C app babel
 	$(MAKE) -C ha_addons $(patsubst addon-%,%,$@)
 
-check-docker-compose:
+check-docker-compose: ## check the docker-compose file
 	docker-compose config -q
 
-install:
-	python3 -m pip install --upgrade pip
-	python3 -m pip install -r requirements.txt
-	python3 -m pip install -r requirements-test.txt
+PY_VER := $(shell cat .python-version)
+
+install:           ## install requirements into the pyenv and switch to proper venv
+	@pyenv local $(PY_VER) || { pyenv install $(PY_VER) && pyenv local $(PY_VER) || exit 1; }
+	@pyenv exec pip install --upgrade pip
+	@pyenv exec pip install -r requirements.txt
+	@pyenv exec pip install -r requirements-test.txt
+	pyenv exec python --version
+
+run:  ## run proxy locally out of the actual venv
+	pyenv exec python app/src/server.py -c /app/src/cnf

app/.version

@@ -1 +1 @@
-0.14.0
+0.15.0

app/Makefile

@@ -55,7 +55,7 @@ $(BABEL_TRANSLATIONS)/%.pot : $(SRC)/.babel.cfg $(BABEL_INPUT)
 
 $(BABEL_TRANSLATIONS)/%/LC_MESSAGES/messages.po : $(BABEL_TRANSLATIONS)/messages.pot
 	@mkdir -p $(@D)
-	@pybabel update  --init-missing -i $< -d $(BABEL_TRANSLATIONS) -l $*
+	@pybabel update  --init-missing --ignore-pot-creation-date -i $< -d $(BABEL_TRANSLATIONS) -l $*
 
 $(BABEL_TRANSLATIONS)/%/LC_MESSAGES/messages.mo : $(BABEL_TRANSLATIONS)/%/LC_MESSAGES/messages.po
 	@pybabel compile  -d $(BABEL_TRANSLATIONS) -l $*

app/docker-bake.hcl

@@ -53,7 +53,7 @@ target "_common" {
   ]
 
   no-cache = false
-  platforms = ["linux/amd64", "linux/arm64", "linux/arm/v7"]
+  platforms = ["linux/amd64", "linux/arm64"]
 }
 
 target "_debug" {

app/requirements-test.txt

@@ -1,8 +1,8 @@
-    flake8==7.2.0
-    pytest==8.3.5
-    pytest-asyncio==0.26.0
-    pytest-cov==6.1.1
+    flake8==7.3.0
+    pytest==8.4.1
+    pytest-asyncio==1.0.0
+    pytest-cov==6.2.1
     python-dotenv==1.1.0
     mock==5.2.0
-    coverage==7.8.1
+    coverage==7.9.1
     jinja2-cli==0.8.2

app/src/gen3plus/infos_g3p.py

@@ -216,7 +216,7 @@ class InfosG3P(Infos):
         self.set_db_def_value(Register.MANUFACTURER, 'TSUN')
         self.set_db_def_value(Register.EQUIPMENT_MODEL, 'TSOL-MSxx00')
         self.set_db_def_value(Register.CHIP_TYPE, 'IGEN TECH')
-        self.set_db_def_value(Register.NO_INPUTS, 4)
+        self.set_db_def_value(Register.NO_INPUTS, 2)
 
     def __hide_topic(self, row: dict) -> bool:
         if 'dep' in row:

app/src/gen3plus/solarman_v5.py

@@ -341,9 +341,9 @@ class SolarmanV5(SolarmanBase):
         self.log_lvl.clear()
         super().close()
 
-    async def send_start_cmd(self, snr: int, host: str,
-                             forward: bool,
-                             start_timeout=MB_CLIENT_DATA_UP):
+    def send_start_cmd(self, snr: int, host: str,
+                       forward: bool,
+                       start_timeout=MB_CLIENT_DATA_UP):
         self.no_forwarding = True
         self.establish_inv_emu = forward
         self.snr = snr
@@ -562,12 +562,17 @@ class SolarmanV5(SolarmanBase):
         rated = db.get_db_value(Register.RATED_POWER, 0)
         model = None
         if max_pow == 2000:
+            db.set_db_def_value(Register.NO_INPUTS, 4)
             if rated == 800 or rated == 600:
                 model = f'TSOL-MS{max_pow}({rated})'
             else:
                 model = f'TSOL-MS{max_pow}'
         elif max_pow == 1800 or max_pow == 1600:
+            db.set_db_def_value(Register.NO_INPUTS, 4)
             model = f'TSOL-MS{max_pow}'
+        elif max_pow <= 800:
+            model = f'TSOL-MS{max_pow}'
+
         if model:
             logger.info(f'Model: {model}')
             self.db.set_db_def_value(Register.EQUIPMENT_MODEL, model)

app/src/messages.py

@@ -193,7 +193,7 @@ class Message(ProtocolIfc):
             return
         self.mb.build_msg(dev_id, func, addr, val, log_lvl)
 
-    async def send_modbus_cmd(self, func, addr, val, log_lvl) -> None:
+    def send_modbus_cmd(self, func, addr, val, log_lvl) -> None:
         self._send_modbus_cmd(Modbus.INV_ADDR, func, addr, val, log_lvl)
 
     def _send_modbus_scan(self):

app/src/modbus_tcp.py

@@ -66,7 +66,7 @@ class ModbusTcp():
             try:
                 async with ModbusConn(host, port) as inverter:
                     stream = inverter.local.stream
-                    await stream.send_start_cmd(snr, host, forward)
+                    stream.send_start_cmd(snr, host, forward)
                     await stream.ifc.loop()
                     logger.info(f'[{stream.node_id}:{stream.conn_no}] '
                                 f'Connection closed - Shutdown: '

app/src/mqtt.py

@@ -112,7 +112,7 @@ class Mqtt(metaclass=Singleton):
             except asyncio.CancelledError:
                 logger_mqtt.debug("MQTT task cancelled")
                 self.__client = None
-                return
+                raise
             except Exception:
                 # self.inc_counter('SW_Exception')   # fixme
                 self.ctime = None
@@ -151,7 +151,7 @@ class Mqtt(metaclass=Singleton):
             if self.__cb_mqtt_is_up:
                 await self.__cb_mqtt_is_up()
 
-    async def _out_coeff(self, message):
+    def _out_coeff(self, message):
         payload = message.payload.decode("UTF-8")
         try:
             val = round(float(payload) * 1024/100)
@@ -160,9 +160,9 @@ class Mqtt(metaclass=Singleton):
                                   'the range 0..100,'
                                   f' got: {payload}')
             else:
-                await self._modbus_cmd(message,
-                                       Modbus.WRITE_SINGLE_REG,
-                                       0, 0x202c, val)
+                self._modbus_cmd(message,
+                                 Modbus.WRITE_SINGLE_REG,
+                                 0, 0x202c, val)
         except Exception:
             pass
 
@@ -182,7 +182,7 @@ class Mqtt(metaclass=Singleton):
         else:
             logger_mqtt.warning(f'Node_id: {node_id} not found')
 
-    async def _modbus_cmd(self, message, func, params=0, addr=0, val=0):
+    def _modbus_cmd(self, message, func, params=0, addr=0, val=0):
         payload = message.payload.decode("UTF-8")
         for fnc in self.each_inverter(message, "send_modbus_cmd"):
             res = payload.split(',')
@@ -195,7 +195,7 @@ class Mqtt(metaclass=Singleton):
             elif params == 2:
                 addr = int(res[0], base=16)
                 val = int(res[1])  # lenght
-            await fnc(func, addr, val, logging.INFO)
+            fnc(func, addr, val, logging.INFO)
 
     async def _at_cmd(self, message):
         payload = message.payload.decode("UTF-8")

app/src/scheduler.py

@@ -12,7 +12,7 @@ class Schedule:
     count = 0
 
     @classmethod
-    def start(cls) -> None:
+    def start(cls) -> None:    # pragma: no cover
         '''Start the scheduler and schedule the tasks (cron jobs)'''
         logging.debug("Scheduler init")
         cls.mqtt = Mqtt(None)
@@ -20,7 +20,7 @@ class Schedule:
         crontab('0 0 * * *', func=cls.atmidnight, start=True)
 
     @classmethod
-    async def atmidnight(cls) -> None:
+    async def atmidnight(cls) -> None:    # pragma: no cover
         '''Clear daily counters at midnight'''
         logging.info("Clear daily counters at midnight")
 

app/src/server.py

@@ -60,7 +60,16 @@ class Server():
 
         @app.context_processor
         def utility_processor():
-            return dict(version=self.version)
+            var = {'version': self.version,
+                   'slug': os.getenv("SLUG"),
+                   'hostname': os.getenv("HOSTNAME"),
+                   }
+            if var['slug']:
+                var['hassio'] = True
+                slug_len = len(var['slug'])
+                var['addonname'] = var['slug'] + '_' + \
+                    var['hostname'][slug_len+1:]
+            return var
 
     def parse_args(self, arg_list: list[str] | None):
         parser = argparse.ArgumentParser()

app/src/web/i18n.py

@@ -29,9 +29,9 @@ def get_tz():
 
 @web.context_processor
 def utility_processor():
-    return dict(lang=babel_get_locale(),
-                lang_str=LANGUAGES.get(str(babel_get_locale()), "English"),
-                languages=LANGUAGES)
+    return {'lang': babel_get_locale(),
+            'lang_str': LANGUAGES.get(str(babel_get_locale()), "English"),
+            'languages': LANGUAGES}
 
 
 @web.route('/language/<language>')

app/src/web/log_handler.py

@@ -22,3 +22,6 @@ class LogHandler(Handler, metaclass=Singleton):
 
     def get_buffer(self, elms=0) -> list:
         return list(self.buffer)[-elms:]
+
+    def clear(self):
+        self.buffer.clear()

app/src/web/pages.py

@@ -30,3 +30,9 @@ async def logging():
     return await render_template(
         'page_logging.html.j2',
         fetch_url=url_for('.file_fetch'))
+
+
+@web.route('/network_tests')
+async def network_tests():
+    return await render_template(
+        'page_network_tests.html.j2')

app/src/web/static/font-awesome/css/all.min.css

@@ -7,3 +7,4 @@
 .fa-rotate-right:before{content:"\f01e"}
 .fa-cloud-arrow-down-alt:before{content:"\f381"}
 .fa-cloud-arrow-up-alt:before{content:"\f382"}
+.fa-gear:before{content:"\f013"}

app/src/web/templates/base.html.j2

@@ -59,6 +59,12 @@
         <a href="{{ url_for('.mqtt')}}" class="w3-bar-item w3-button w3-padding {% block menu2_class %}{% endblock %}"><i class="fa fa-database fa-fw"></i>  MQTT</a>
         <a href="{{ url_for('.notes')}}" class="w3-bar-item w3-button w3-padding {% block menu3_class %}{% endblock %}"><i class="fa fa-info fa-fw"></i>  {{_('Important Messages')}}</a>
         <a href="{{ url_for('.logging')}}" class="w3-bar-item w3-button w3-padding {% block menu4_class %}{% endblock %}"><i class="fa fa-file-export fa-fw"></i>  {{_('Log Files')}}</a>
+        <a href="{{ url_for('.network_tests')}}" class="w3-bar-item w3-button w3-padding {% block menu5_class %}{% endblock %}"><i class="fa fa-file-export fa-fw"></i>  {{_('Network Tests')}}</a>
+        {% if hassio is defined %}
+        <br>
+        <a href="/hassio/addon/{{addonname}}/config" target="_top" class="w3-bar-item w3-button w3-padding"><i class="fa fa-gear fa-fw"></i>  {{_('Add-on Config')}}</a>
+        <a href="/hassio/addon/{{addonname}}/logs" target="_top" class="w3-bar-item w3-button w3-padding"><i class="fa fa-file fa-fw"></i>  {{_('Add-on Log')}}</a>
+        {% endif %}
       </div>
     </nav>
   

app/src/web/templates/page_network_tests.html.j2

@@ -0,0 +1,31 @@
+{% extends 'base.html.j2' %}
+
+{% block title %}{{_("TSUN Proxy - Network Tests")}}{% endblock title %}
+{% block menu5_class %}w3-blue{% endblock %}
+{% block headline %}<i class="fa fa-file-export fa-fw"></i>  {{_('Network Tests')}}{% endblock headline %}
+{% block content %}
+
+  <script>
+    url = "http://127.0.0.1:10000"
+    const req = new XMLHttpRequest();
+    req.open("POST", url, true);
+    //req.setRequestHeader("RESOLVE", "bla.com")
+    req.onload = (event) => {
+      // Uploaded
+    };
+
+    const blob = new Blob(["abc123"], { type: "text/plain" });
+
+    req.send(blob);
+
+    ws = new WebSocket("ws://127.0.0.1:10000");
+    // ws.open()
+    ws.onopen = () => {
+      console.log("Connection opened")
+      ws.send("Hi server, please send me the score of yesterday's game")
+    }
+
+  </script>
+{% endblock content%}
+
+{% block footer %}{% endblock footer %}

app/tests/log/test.txt

@@ -1,19 +1,19 @@
 2025-04-30 00:01:23  INFO | root | Server "proxy - unknown" will be started
-2025-04-30 00:01:23  INFO | root | current dir: /Users/sallius/tsun/tsun-gen3-proxy
-2025-04-30 00:01:23  INFO | root | config_path: ./config/
-2025-04-30 00:01:23  INFO | root | json_config: None
-2025-04-30 00:01:23  INFO | root | toml_config: None
-2025-04-30 00:01:23  INFO | root | trans_path:  ../translations/
-2025-04-30 00:01:23  INFO | root | rel_urls:    False
-2025-04-30 00:01:23  INFO | root | log_path:    ./log/
-2025-04-30 00:01:23  INFO | root | log_backups: unlimited
-2025-04-30 00:01:23  INFO | root | LOG_LVL    : None
-2025-04-30 00:01:23  INFO | root | ******
-2025-04-30 00:01:23  INFO | root | Read from /Users/sallius/tsun/tsun-gen3-proxy/app/src/cnf/default_config.toml => ok
-2025-04-30 00:01:23  INFO | root | Read from environment => ok
-2025-04-30 00:01:23  INFO | root | Read from ./config/config.json => n/a
-2025-04-30 00:01:23  INFO | root | Read from ./config/config.toml => n/a
-2025-04-30 00:01:23  INFO | root | ******
-2025-04-30 00:01:23  INFO | root | listen on port: 5005 for inverters
-2025-04-30 00:01:23  INFO | root | listen on port: 10000 for inverters
-2025-04-30 00:01:23  INFO | root | Start Quart
+2025-04-30 00:01:24  INFO | root | current dir: /Users/sallius/tsun/tsun-gen3-proxy
+2025-04-30 00:01:25  INFO | root | config_path: ./config/
+2025-04-30 00:01:26  INFO | root | json_config: None
+2025-04-30 00:01:27  INFO | root | toml_config: None
+2025-04-30 00:01:28  INFO | root | trans_path:  ../translations/
+2025-04-30 00:01:29  INFO | root | rel_urls:    False
+2025-04-30 00:01:30  INFO | root | log_path:    ./log/
+2025-04-30 00:01:31  INFO | root | log_backups: unlimited
+2025-04-30 00:01:32  INFO | root | LOG_LVL    : None
+2025-04-30 00:01:33  INFO | root | ******
+2025-04-30 00:01:34  INFO | root | Read from /Users/sallius/tsun/tsun-gen3-proxy/app/src/cnf/default_config.toml => ok
+2025-04-30 00:01:35  INFO | root | Read from environment => ok
+2025-04-30 00:01:36  INFO | root | Read from ./config/config.json => n/a
+2025-04-30 00:01:37  INFO | root | Read from ./config/config.toml => n/a
+2025-04-30 00:01:38  INFO | root | ******
+2025-04-30 00:01:39  INFO | root | listen on port: 5005 for inverters
+2025-04-30 00:01:40  INFO | root | listen on port: 10000 for inverters
+2025-04-30 00:01:41  INFO | root | Start Quart

app/tests/test_infos_g3p.py

@@ -109,7 +109,7 @@ def test_default_db():
     i = InfosG3P(client_mode=False)
     
     assert json.dumps(i.db) == json.dumps({
-        "inverter": {"Manufacturer": "TSUN", "Equipment_Model": "TSOL-MSxx00", "No_Inputs": 4}, 
+        "inverter": {"Manufacturer": "TSUN", "Equipment_Model": "TSOL-MSxx00", "No_Inputs": 2}, 
         "collector": {"Chip_Type": "IGEN TECH"},
         })
 
@@ -271,7 +271,7 @@ def test_build_ha_conf1():
         elif id == 'inv_count_456':
             assert False
 
-    assert tests==7
+    assert tests==5
 
 def test_build_ha_conf2():
     i = InfosG3P(client_mode=False)
@@ -346,7 +346,7 @@ def test_build_ha_conf3():
         elif id == 'inv_count_456':
             assert False
 
-    assert tests==7
+    assert tests==5
 
 def test_build_ha_conf4():
     i = InfosG3P(client_mode=True)

app/tests/test_mqtt.py

@@ -3,7 +3,8 @@ import pytest
 import asyncio
 import aiomqtt
 import logging
-from aiomqtt import MqttError
+from aiomqtt import MqttError, MessagesIterator
+from aiomqtt import Message as AiomqttMessage
 from mock import patch, Mock
 
 from async_stream import AsyncIfcImpl
@@ -34,6 +35,26 @@ def test_hostname():
     # else:
         return 'test.mosquitto.org'
 
+@pytest.fixture(scope="function")
+def aiomqtt_mock(monkeypatch):
+    recv_que = asyncio.Queue()
+        
+    async def my_aenter(self):
+        return self
+    async def my_subscribe(self, *arg):
+        return
+    async def my_anext(self):
+        return await recv_que.get()
+    async def my_receive(self, topic: str, payload: bytes):
+        msg = AiomqttMessage(topic, payload,qos=0, retain=False, mid=0, properties=None)
+        await recv_que.put(msg)
+        await asyncio.sleep(0)  # dispath the msg
+
+    monkeypatch.setattr(aiomqtt.Client, "__aenter__", my_aenter)
+    monkeypatch.setattr(aiomqtt.Client, "subscribe", my_subscribe)
+    monkeypatch.setattr(MessagesIterator, "__anext__", my_anext)
+    monkeypatch.setattr(Mqtt, "receive", my_receive, False)
+
 @pytest.fixture
 def config_mqtt_conn(test_hostname, test_port):
     Config.act_config = {'mqtt':{'host': test_hostname, 'port': test_port, 'user': '', 'passwd': ''},
@@ -161,13 +182,17 @@ async def test_ha_reconnect(config_mqtt_conn):
         await m.close()
 
 @pytest.mark.asyncio
-async def test_mqtt_no_config(config_no_conn):
+async def test_mqtt_no_config(config_no_conn, monkeypatch):
     _ = config_no_conn
     assert asyncio.get_running_loop()
 
     on_connect =  asyncio.Event()
     async def cb():
         on_connect.set()
+    async def my_publish(*args):
+        return
+
+    monkeypatch.setattr(aiomqtt.Client, "publish", my_publish)
 
     try:
         m = Mqtt(cb)
@@ -176,9 +201,9 @@ async def test_mqtt_no_config(config_no_conn):
         assert not on_connect.is_set()
         try:
             await m.publish('homeassistant/status', 'online')
-            assert False
+            assert m.published == 1
         except Exception:
-            pass          
+            assert False          
     except TimeoutError:
         assert False
     finally:
@@ -250,92 +275,119 @@ async def test_mqtt_except_def_config(config_def_conn, monkeypatch, caplog):
     assert 'MQTT is unconfigured; Check your config.toml!' in caplog.text
 
 @pytest.mark.asyncio
-async def test_msg_dispatch(config_mqtt_conn, spy_modbus_cmd):
+async def test_mqtt_dispatch(config_mqtt_conn, aiomqtt_mock, spy_modbus_cmd):
     _ = config_mqtt_conn
+    _ = aiomqtt_mock
     spy = spy_modbus_cmd
     try:
         m = Mqtt(None)
-        msg = aiomqtt.Message(topic= 'homeassistant/status', payload= b'online', qos= 0, retain = False, mid= 0, properties= None)
-        await m.dispatch_msg(msg)
+        assert m.ha_restarts == 0
+        await m.receive('homeassistant/status', b'online')  # send the message
         assert m.ha_restarts == 1
 
-        msg = aiomqtt.Message(topic= 'tsun/inv_1/rated_load', payload= b'2', qos= 0, retain = False, mid= 0, properties= None)
-        await m.dispatch_msg(msg)
-        spy.assert_awaited_once_with(Modbus.WRITE_SINGLE_REG, 0x2008, 2, logging.INFO)
-        
-        spy.reset_mock()
-        msg = aiomqtt.Message(topic= 'tsun/inv_1/out_coeff', payload= b'100', qos= 0, retain = False, mid= 0, properties= None)
-        await m.dispatch_msg(msg)
-        spy.assert_awaited_once_with(Modbus.WRITE_SINGLE_REG, 0x202c, 1024, logging.INFO)
-        
-        spy.reset_mock()
-        msg = aiomqtt.Message(topic= 'tsun/inv_1/out_coeff', payload= b'50', qos= 0, retain = False, mid= 0, properties= None)
-        await m.dispatch_msg(msg)
-        spy.assert_awaited_once_with(Modbus.WRITE_SINGLE_REG, 0x202c, 512, logging.INFO)
-    
-        spy.reset_mock()
-        msg = aiomqtt.Message(topic= 'tsun/inv_1/modbus_read_regs', payload= b'0x3000, 10', qos= 0, retain = False, mid= 0, properties= None)
-        await m.dispatch_msg(msg)
-        spy.assert_awaited_once_with(Modbus.READ_REGS, 0x3000, 10, logging.INFO)
+        await m.receive(topic= 'tsun/inv_1/rated_load', payload= b'2')
+        spy.assert_called_once_with(Modbus.WRITE_SINGLE_REG, 0x2008, 2, logging.INFO)
 
         spy.reset_mock()
-        msg = aiomqtt.Message(topic= 'tsun/inv_1/modbus_read_inputs', payload= b'0x3000, 10', qos= 0, retain = False, mid= 0, properties= None)
-        await m.dispatch_msg(msg)
-        spy.assert_awaited_once_with(Modbus.READ_INPUTS, 0x3000, 10, logging.INFO)
+        await m.receive(topic= 'tsun/inv_1/out_coeff', payload= b'100')
+        spy.assert_called_once_with(Modbus.WRITE_SINGLE_REG, 0x202c, 1024, logging.INFO)
+        
+        spy.reset_mock()
+        await m.receive(topic= 'tsun/inv_1/out_coeff', payload= b'50')
+        spy.assert_called_once_with(Modbus.WRITE_SINGLE_REG, 0x202c, 512, logging.INFO)
+    
+        spy.reset_mock()
+        await m.receive(topic= 'tsun/inv_1/modbus_read_regs', payload= b'0x3000, 10')
+        spy.assert_called_once_with(Modbus.READ_REGS, 0x3000, 10, logging.INFO)
+
+        spy.reset_mock()
+        await m.receive(topic= 'tsun/inv_1/modbus_read_inputs', payload= b'0x3000, 10')
+        spy.assert_called_once_with(Modbus.READ_INPUTS, 0x3000, 10, logging.INFO)
 
         # test dispatching with empty mapping table
         m.topic_defs.clear()
         spy.reset_mock()
-        msg = aiomqtt.Message(topic= 'tsun/inv_1/modbus_read_inputs', payload= b'0x3000, 10', qos= 0, retain = False, mid= 0, properties= None)
-        await m.dispatch_msg(msg)
+        await m.receive(topic= 'tsun/inv_1/modbus_read_inputs', payload= b'0x3000, 10')
         spy.assert_not_called()
 
         # test dispatching with incomplete mapping table - invalid fnc defined
         m.topic_defs.append(
             {'prefix': 'entity_prefix', 'topic': '/+/modbus_read_inputs',
-             'full_topic': 'tsun/+/modbus_read_inputs', 'fnc': 'invalid'}
+             'full_topic': 'tsun/+/modbus_read_inputs', 'fnc': 'addr'}
         )
         spy.reset_mock()
-        msg = aiomqtt.Message(topic= 'tsun/inv_1/modbus_read_inputs', payload= b'0x3000, 10', qos= 0, retain = False, mid= 0, properties= None)
-        await m.dispatch_msg(msg)
+        await m.receive(topic= 'tsun/inv_1/modbus_read_inputs', payload= b'0x3000, 10')
         spy.assert_not_called()
 
+    except MqttError:
+        assert False
+    except Exception:
+        assert False          
     finally:
         await m.close()
 
 @pytest.mark.asyncio
-async def test_msg_dispatch_err(config_mqtt_conn, spy_modbus_cmd):
+async def test_mqtt_dispatch_cb(config_mqtt_conn, aiomqtt_mock):
     _ = config_mqtt_conn
+    _ = aiomqtt_mock
+
+    on_connect =  asyncio.Event()
+    async def cb():
+        on_connect.set()
+    try:
+        m = Mqtt(cb)
+        assert m.ha_restarts == 0
+        await m.receive('homeassistant/status', b'online')  # send the message
+        assert on_connect.is_set()
+        assert m.ha_restarts == 1
+
+    except MqttError:
+        assert False
+    except Exception:
+        assert False          
+    finally:
+        await m.close()
+
+@pytest.mark.asyncio
+async def test_mqtt_dispatch_err(config_mqtt_conn, aiomqtt_mock, spy_modbus_cmd, caplog):
+    _ = config_mqtt_conn
+    _ = aiomqtt_mock
     spy = spy_modbus_cmd
+
+    LOGGER = logging.getLogger("mqtt")
+    LOGGER.propagate = True
+    LOGGER.setLevel(logging.INFO)
+
     try:
         m = Mqtt(None)
+
         # test out of range param
-        msg = aiomqtt.Message(topic= 'tsun/inv_1/out_coeff', payload= b'-1', qos= 0, retain = False, mid= 0, properties= None)
-        await m.dispatch_msg(msg)
+        await m.receive(topic= 'tsun/inv_1/out_coeff', payload= b'-1')
         spy.assert_not_called()
 
         # test unknown node_id
-        spy.reset_mock()
-        msg = aiomqtt.Message(topic= 'tsun/inv_2/out_coeff', payload= b'2', qos= 0, retain = False, mid= 0, properties= None)
-        await m.dispatch_msg(msg)
+        await m.receive(topic= 'tsun/inv_2/out_coeff', payload= b'2')
         spy.assert_not_called()
 
         # test invalid fload param
-        spy.reset_mock()
-        msg = aiomqtt.Message(topic= 'tsun/inv_1/out_coeff', payload= b'2, 3', qos= 0, retain = False, mid= 0, properties= None)
-        await m.dispatch_msg(msg)
+        await m.receive(topic= 'tsun/inv_1/out_coeff', payload= b'2, 3')
+        spy.assert_not_called()
+    
+        await m.receive(topic= 'tsun/inv_1/modbus_read_regs', payload= b'0x3000, 10, 7')
         spy.assert_not_called()
 
-        spy.reset_mock()
-        msg = aiomqtt.Message(topic= 'tsun/inv_1/modbus_read_regs', payload= b'0x3000, 10, 7', qos= 0, retain = False, mid= 0, properties= None)
-        await m.dispatch_msg(msg)
-        spy.assert_not_called()
-
-        spy.reset_mock()
-        msg = aiomqtt.Message(topic= 'tsun/inv_1/dcu_power', payload= b'100W', qos= 0, retain = False, mid= 0, properties= None)
-        await m.dispatch_msg(msg)
+        await m.receive(topic= 'tsun/inv_1/dcu_power', payload= b'100W')
         spy.assert_not_called()
 
+        with caplog.at_level(logging.INFO):
+            msg = aiomqtt.Message(topic= 'tsun/inv_1/out_coeff', payload= b'2', qos= 0, retain = False, mid= 0, properties= None)
+            for _ in m.each_inverter(msg, "addr"):
+                pass  # do nothing here
+        assert 'Cmd not supported by: inv_1/' in caplog.text
+    except MqttError:
+        assert False
+    except Exception:
+        assert False          
     finally:
         await m.close()
 

app/tests/test_server.py

@@ -4,6 +4,10 @@ import logging
 import os
 from mock import patch
 from server import app, Server, ProxyState, HypercornLogHndl
+from inverter_base import InverterBase
+from gen3.talent import Talent
+
+from test_inverter_base import FakeReader, FakeWriter
 
 pytest_plugins = ('pytest_asyncio',)
 
@@ -108,20 +112,20 @@ class TestServerClass:
         assert logging.getLogger('hypercorn.access').level == logging.INFO
         assert logging.getLogger('hypercorn.error').level == logging.INFO
 
-        os.environ["LOG_LVL"] = "WARN"
-        s.parse_args(['--log_backups', '3'])
-        s.init_logging_system()
-        assert s.log_backups == 3
-        assert s.log_level == logging.WARNING
-        assert logging.handlers.log_backups == 3
-        assert logging.getLogger().level == s.log_level
-        assert logging.getLogger('msg').level == s.log_level
-        assert logging.getLogger('conn').level == s.log_level
-        assert logging.getLogger('data').level == s.log_level
-        assert logging.getLogger('tracer').level == s.log_level
-        assert logging.getLogger('asyncio').level == s.log_level
-        assert logging.getLogger('hypercorn.access').level == logging.INFO
-        assert logging.getLogger('hypercorn.error').level == logging.INFO
+        with patch.dict(os.environ, {'LOG_LVL': 'WARN'}):
+            s.parse_args(['--log_backups', '3'])
+            s.init_logging_system()
+            assert s.log_backups == 3
+            assert s.log_level == logging.WARNING
+            assert logging.handlers.log_backups == 3
+            assert logging.getLogger().level == s.log_level
+            assert logging.getLogger('msg').level == s.log_level
+            assert logging.getLogger('conn').level == s.log_level
+            assert logging.getLogger('data').level == s.log_level
+            assert logging.getLogger('tracer').level == s.log_level
+            assert logging.getLogger('asyncio').level == s.log_level
+            assert logging.getLogger('hypercorn.access').level == logging.INFO
+            assert logging.getLogger('hypercorn.error').level == logging.INFO
 
     def test_build_config_error(self, caplog):
         s = self.FakeServer()
@@ -187,6 +191,7 @@ class TestApp:
         """Test the ready route."""
 
         ProxyState.set_up(False)
+        app.testing = True
         client = app.test_client()
         response = await client.get('/-/ready')
         assert response.status_code == 503
@@ -202,17 +207,84 @@ class TestApp:
     @pytest.mark.asyncio
     async def test_healthy(self):
         """Test the healthy route."""
+        reader = FakeReader()
+        writer =  FakeWriter()
 
-        ProxyState.set_up(False)
-        client = app.test_client()
-        response = await client.get('/-/healthy')
-        assert response.status_code == 200
-        result = await response.get_data()
-        assert result == b"I'm fine"
+        with InverterBase(reader, writer, 'tsun', Talent):
+            ProxyState.set_up(False)
+            app.testing = True
+            client = app.test_client()
+            response = await client.get('/-/healthy')
+            assert response.status_code == 200
+            result = await response.get_data()
+            assert result == b"I'm fine"
 
-        ProxyState.set_up(True)
-        response = await client.get('/-/healthy')
-        assert response.status_code == 200
-        result = await response.get_data()
-        assert result == b"I'm fine"
+            ProxyState.set_up(True)
+            response = await client.get('/-/healthy')
+            assert response.status_code == 200
+            result = await response.get_data()
+            assert result == b"I'm fine"
 
+    @pytest.mark.asyncio
+    async def test_unhealthy(self, monkeypatch, caplog):
+        """Test the healthy route."""
+        def result_false(self):
+            return False
+        
+        LOGGER = logging.getLogger("mqtt")
+        LOGGER.propagate = True
+        LOGGER.setLevel(logging.INFO)
+
+        monkeypatch.setattr(InverterBase, "healthy", result_false)
+        InverterBase._registry.clear()
+        reader = FakeReader()
+        writer = FakeWriter()
+
+        with caplog.at_level(logging.INFO) and InverterBase(reader, writer, 'tsun', Talent):
+            ProxyState.set_up(False)
+            app.testing = True
+            client = app.test_client()
+            response = await client.get('/-/healthy')
+            assert response.status_code == 200
+            result = await response.get_data()
+            assert result == b"I'm fine"
+            assert "" == caplog.text
+
+            ProxyState.set_up(True)
+            response = await client.get('/-/healthy')
+            assert response.status_code == 503
+            result = await response.get_data()
+            assert result == b"I have a problem"
+            assert "" == caplog.text
+
+    @pytest.mark.asyncio
+    async def test_healthy_exception(self, monkeypatch, caplog):
+        """Test the healthy route."""
+        def result_except(self):
+            raise ValueError
+        
+        LOGGER = logging.getLogger("mqtt")
+        LOGGER.propagate = True
+        LOGGER.setLevel(logging.INFO)
+
+        monkeypatch.setattr(InverterBase, "healthy", result_except)
+        InverterBase._registry.clear()
+        reader = FakeReader()
+        writer = FakeWriter()
+
+        with caplog.at_level(logging.INFO) and InverterBase(reader, writer, 'tsun', Talent):
+            ProxyState.set_up(False)
+            app.testing = True
+            client = app.test_client()
+            response = await client.get('/-/healthy')
+            assert response.status_code == 200
+            result = await response.get_data()
+            assert result == b"I'm fine"
+            assert "" == caplog.text
+
+            ProxyState.set_up(True)
+            response = await client.get('/-/healthy')
+            assert response.status_code == 200
+            result = await response.get_data()
+            assert result == b"I'm fine"
+            assert "Exception:" in caplog.text

app/tests/test_solarman.py

@@ -462,6 +462,39 @@ def inverter_ind_msg800():  # 0x4210 rated Power 800W
     msg += b'\x15'
     return msg
 
+@pytest.fixture
+def inverter_ind_msg900():  # 0x4210 rated Power 900W 
+    msg  = b'\xa5\x99\x01\x10\x42\xe6\x9e' +get_sn()  +b'\x01\xb0\x02\xbc\xc8'
+    msg += b'\x24\x32\x6c\x1f\x00\x00\xa0\x47\xe4\x33\x01\x00\x03\x08\x00\x00'
+    msg += b'\x59\x31\x37\x45\x37\x41\x30\x46\x30\x31\x30\x42\x30\x31\x33\x45'
+    msg += b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+    msg += b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+    msg += b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+    msg += b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+    msg += b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+    msg += b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+    msg += b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+    msg += b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+    msg += b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+    msg += b'\x00\x01\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
+    msg +=  b'\x40\x10\x08\xc8\x00\x49\x13\x8d\x00\x36\x00\x00\x03\x84\x06\x7a'
+    msg += b'\x01\x61\x00\xa8\x02\x54\x01\x5a\x00\x8a\x01\xe4\x01\x5a\x00\xbd'
+    msg += b'\x02\x8f\x00\x11\x00\x01\x00\x00\x00\x0b\x00\x00\x27\x98\x00\x04'
+    msg += b'\x00\x00\x0c\x04\x00\x03\x00\x00\x0a\xe7\x00\x05\x00\x00\x0c\x75'
+    msg += b'\x00\x00\x00\x00\x06\x16\x02\x00\x00\x00\x55\xaa\x00\x01\x00\x00'
+    msg +=  b'\x00\x00\x00\x00\xff\xff\x03\x84\x00\x03\x04\x00\x04\x00\x04\x00'
+    msg += b'\x04\x00\x00\x01\xff\xff\x00\x01\x00\x06\x00\x68\x00\x68\x05\x00'
+    msg += b'\x09\xcd\x07\xb6\x13\x9c\x13\x24\x00\x01\x07\xae\x04\x0f\x00\x41'
+    msg += b'\x00\x0f\x0a\x64\x0a\x64\x00\x06\x00\x06\x09\xf6\x12\x8c\x12\x8c'
+    msg += b'\x00\x10\x00\x10\x14\x52\x14\x52\x00\x10\x00\x10\x01\x51\x00\x05'
+    msg += b'\x04\x00\x00\x01\x13\x9c\x0f\xa0\x00\x4e\x00\x66\x03\xe8\x04\x00'
+    msg += b'\x09\xce\x07\xa8\x13\x9c\x13\x26\x00\x00\x00\x00\x00\x00\x00\x00'
+    msg += b'\x00\x00\x00\x00\x04\x00\x04\x00\x00\x00\x00\x00\xff\xff\x00\x00'
+    msg += b'\x00\x00\x00\x00'
+    msg += correct_checksum(msg)
+    msg += b'\x15'
+    return msg
+
 @pytest.fixture
 def inverter_ind_msg_81():  # 0x4210 fcode 0x81
     msg  = b'\xa5\x99\x01\x10\x42\x02\x03' +get_sn()  +b'\x81\xb0\x02\xbc\xc8'
@@ -676,6 +709,19 @@ def msg_modbus_rsp():  # 0x1510
     msg += b'\x15'
     return msg
 
+@pytest.fixture
+def msg_modbus_rsp_mb_4():  # 0x1510, MODBUS Type:4
+    msg  = b'\xa5\x3b\x00\x10\x15\x03\x03' +get_sn()  +b'\x02\x01'
+    msg += total()  
+    msg += hb()
+    msg += b'\x0a\xe2\xfa\x33\x01\x04\x28\x40\x10\x08\xd8'
+    msg += b'\x00\x00\x13\x87\x00\x31\x00\x68\x02\x58\x00\x00\x01\x53\x00\x02'
+    msg += b'\x00\x00\x01\x52\x00\x02\x00\x00\x01\x53\x00\x03\x00\x00\x00\x04'
+    msg += b'\x00\x01\x00\x00\x9e\xa4'
+    msg += correct_checksum(msg)
+    msg += b'\x15'
+    return msg
+
 @pytest.fixture
 def msg_modbus_interim_rsp():  # 0x0510
     msg  = b'\xa5\x3b\x00\x10\x15\x03\x03' +get_sn()  +b'\x02\x01'
@@ -1435,6 +1481,7 @@ async def test_build_modell_600(my_loop, config_tsun_allow_all, inverter_ind_msg
     m.read()         # read complete msg, and dispatch msg
     assert 2000 == m.db.get_db_value(Register.MAX_DESIGNED_POWER, 0)
     assert 600 == m.db.get_db_value(Register.RATED_POWER, 0)
+    assert 4 == m.db.get_db_value(Register.NO_INPUTS, 0)
     assert 'TSOL-MS2000(600)' == m.db.get_db_value(Register.EQUIPMENT_MODEL, 0)
     assert '02b0' == m.db.get_db_value(Register.SENSOR_LIST, None)
     assert 0 == m.sensor_list   # must not been set by an inverter data ind
@@ -1454,6 +1501,7 @@ async def test_build_modell_1600(my_loop, config_tsun_allow_all, inverter_ind_ms
     m.read()         # read complete msg, and dispatch msg
     assert 1600 == m.db.get_db_value(Register.MAX_DESIGNED_POWER, 0)
     assert 1600 == m.db.get_db_value(Register.RATED_POWER, 0)
+    assert 4 == m.db.get_db_value(Register.NO_INPUTS, 0)
     assert 'TSOL-MS1600' == m.db.get_db_value(Register.EQUIPMENT_MODEL, 0)
     m.close()
 
@@ -1467,6 +1515,7 @@ async def test_build_modell_1800(my_loop, config_tsun_allow_all, inverter_ind_ms
     m.read()         # read complete msg, and dispatch msg
     assert 1800 == m.db.get_db_value(Register.MAX_DESIGNED_POWER, 0)
     assert 1800 == m.db.get_db_value(Register.RATED_POWER, 0)
+    assert 4 == m.db.get_db_value(Register.NO_INPUTS, 0)
     assert 'TSOL-MS1800' == m.db.get_db_value(Register.EQUIPMENT_MODEL, 0)
     m.close()
 
@@ -1480,6 +1529,7 @@ async def test_build_modell_2000(my_loop, config_tsun_allow_all, inverter_ind_ms
     m.read()         # read complete msg, and dispatch msg
     assert 2000 == m.db.get_db_value(Register.MAX_DESIGNED_POWER, 0)
     assert 2000 == m.db.get_db_value(Register.RATED_POWER, 0)
+    assert 4 == m.db.get_db_value(Register.NO_INPUTS, 0)
     assert 'TSOL-MS2000' == m.db.get_db_value(Register.EQUIPMENT_MODEL, 0)
     m.close()
 
@@ -1493,6 +1543,21 @@ async def test_build_modell_800(my_loop, config_tsun_allow_all, inverter_ind_msg
     m.read()         # read complete msg, and dispatch msg
     assert 800 == m.db.get_db_value(Register.MAX_DESIGNED_POWER, 0)
     assert 800 == m.db.get_db_value(Register.RATED_POWER, 0)
+    assert 2 == m.db.get_db_value(Register.NO_INPUTS, 0)
+    assert 'TSOL-MS800' == m.db.get_db_value(Register.EQUIPMENT_MODEL, 0)
+    m.close()
+
+@pytest.mark.asyncio
+async def test_build_modell_900(my_loop, config_tsun_allow_all, inverter_ind_msg900):
+    _ = config_tsun_allow_all
+    m = MemoryStream(inverter_ind_msg900, (0,))
+    assert 0 == m.db.get_db_value(Register.MAX_DESIGNED_POWER, 0)
+    assert None == m.db.get_db_value(Register.RATED_POWER, None)
+    assert None == m.db.get_db_value(Register.INVERTER_TEMP, None)
+    m.read()         # read complete msg, and dispatch msg
+    assert 900 == m.db.get_db_value(Register.MAX_DESIGNED_POWER, 0)
+    assert 900 == m.db.get_db_value(Register.RATED_POWER, 0)
+    assert 2 == m.db.get_db_value(Register.NO_INPUTS, 0)
     assert 'TSOL-MSxx00' == m.db.get_db_value(Register.EQUIPMENT_MODEL, 0)
     m.close()
 
@@ -1559,7 +1624,7 @@ async def test_msg_build_modbus_req(my_loop, config_tsun_inv1, device_ind_msg, d
     assert m.ifc.tx_fifo.get()==device_rsp_msg
     assert m.ifc.fwd_fifo.get()==device_ind_msg
 
-    await m.send_modbus_cmd(Modbus.WRITE_SINGLE_REG, 0x2008, 0, logging.DEBUG)
+    m.send_modbus_cmd(Modbus.WRITE_SINGLE_REG, 0x2008, 0, logging.DEBUG)
     assert 0 == m.send_msg_ofs
     assert m.ifc.fwd_fifo.get() == b''
     assert m.sent_pdu == b'' # modbus command must be ignore, cause connection is still not up
@@ -1577,7 +1642,7 @@ async def test_msg_build_modbus_req(my_loop, config_tsun_inv1, device_ind_msg, d
     assert m.ifc.tx_fifo.get()==inverter_rsp_msg
     assert m.ifc.fwd_fifo.get()==inverter_ind_msg
 
-    await m.send_modbus_cmd(Modbus.WRITE_SINGLE_REG, 0x2008, 0, logging.DEBUG)
+    m.send_modbus_cmd(Modbus.WRITE_SINGLE_REG, 0x2008, 0, logging.DEBUG)
     assert 0 == m.send_msg_ofs
     assert m.ifc.fwd_fifo.get() == b''
     assert m.sent_pdu == msg_modbus_cmd
@@ -2189,6 +2254,61 @@ async def test_modbus_scaning(config_tsun_scan, heartbeat_ind_msg, heartbeat_rsp
     assert next(m.mb_timer.exp_count) == 3
     m.close()
 
+@pytest.mark.asyncio
+async def test_modbus_scaning_inv_rsp(config_tsun_scan, heartbeat_ind_msg, heartbeat_rsp_msg, msg_modbus_rsp_mb_4):
+    _ = config_tsun_scan
+    assert asyncio.get_running_loop()
+
+    m = MemoryStream(heartbeat_ind_msg, (0x15,0x56,0))
+    m.append_msg(msg_modbus_rsp_mb_4)
+    assert m.mb_scan == False
+    assert asyncio.get_running_loop() == m.mb_timer.loop
+    m.db.stat['proxy']['Unknown_Ctrl'] = 0
+    assert m.mb_timer.tim == None
+    m.read()         # read complete msg, and dispatch msg
+    assert m.mb_scan == True
+    assert m.mb_start_reg == 0xff80
+    assert m.mb_step == 0x40
+    assert m.mb_bytes == 0x14
+    assert asyncio.get_running_loop() == m.mb_timer.loop
+ 
+    assert not m.header_valid  # must be invalid, since msg was handled and buffer flushed
+    assert m.msg_count == 1
+    assert m.snr == 2070233889
+    assert m.control == 0x4710
+     
+    assert m.msg_recvd[0]['control']==0x4710
+    assert m.msg_recvd[0]['seq']=='84:11'
+    assert m.msg_recvd[0]['data_len']==0x1
+
+    assert m.ifc.tx_fifo.get()==heartbeat_rsp_msg
+    assert m.ifc.fwd_fifo.get()==heartbeat_ind_msg
+    assert m.db.stat['proxy']['Unknown_Ctrl'] == 0
+
+    m.ifc.tx_clear() # clear send buffer for next test
+    assert isclose(m.mb_timeout, 0.5)
+    assert next(m.mb_timer.exp_count) == 0
+    
+    await asyncio.sleep(0.5)
+    assert m.sent_pdu==b'\xa5\x17\x00\x10E\x12\x84!Ce{\x02\xb0\x02\x00\x00\x00\x00\x00\x00' \
+                       b'\x00\x00\x00\x00\x00\x00\x01\x03\xff\xc0\x00\x14\x75\xed\x33\x15'
+    assert m.ifc.tx_fifo.get()==b''
+
+    m.read()         # read complete msg, and dispatch msg
+    assert not m.header_valid  # must be invalid, since msg was handled and buffer flushed
+    assert m.msg_count == 2
+    assert m.msg_recvd[1]['control']==0x1510
+    assert m.msg_recvd[1]['seq']=='03:03'
+    assert m.msg_recvd[1]['data_len']==0x3b
+    assert m.mb.last_addr == 1
+    assert m.mb.last_fcode == 3   
+    assert m.mb.last_reg == 0xffc0   # mb_start_reg + mb_step
+    assert m.mb.last_len == 20
+    assert m.mb.err == 3
+
+    assert next(m.mb_timer.exp_count) == 2
+    m.close()
+
 @pytest.mark.asyncio
 async def test_start_client_mode(my_loop, config_tsun_inv1, str_test_ip):
     _ = config_tsun_inv1
@@ -2198,7 +2318,7 @@ async def test_start_client_mode(my_loop, config_tsun_inv1, str_test_ip):
     assert m.no_forwarding == False
     assert m.mb_timer.tim == None
     assert asyncio.get_running_loop() == m.mb_timer.loop
-    await m.send_start_cmd(get_sn_int(), str_test_ip, False, m.mb_first_timeout)
+    m.send_start_cmd(get_sn_int(), str_test_ip, False, m.mb_first_timeout)
     assert m.sent_pdu==bytearray(b'\xa5\x17\x00\x10E\x01\x00!Ce{\x02\xb0\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x030\x00\x000J\xde\xf1\x15')
     assert m.db.get_db_value(Register.IP_ADDRESS) == str_test_ip
     assert isclose(m.db.get_db_value(Register.POLLING_INTERVAL), 0.5)
@@ -2231,7 +2351,7 @@ async def test_start_client_mode_scan(config_tsun_scan_dcu, str_test_ip, dcu_mod
     assert m.no_forwarding == False
     assert m.mb_timer.tim == None
     assert asyncio.get_running_loop() == m.mb_timer.loop
-    await m.send_start_cmd(get_dcu_sn_int(), str_test_ip, False, m.mb_first_timeout)
+    m.send_start_cmd(get_dcu_sn_int(), str_test_ip, False, m.mb_first_timeout)
     assert m.mb_start_reg == 0x0000
     assert m.mb_step == 0x100
     assert m.mb_bytes == 0x2d
@@ -2542,6 +2662,7 @@ async def test_proxy_dcu_cmd(my_loop, config_tsun_dcu1, patch_open_connection, d
         assert l.db.stat['proxy']['AT_Command'] == 0
         assert l.db.stat['proxy']['AT_Command_Blocked'] == 0
         assert l.db.stat['proxy']['Modbus_Command'] == 0
+        assert 2 == l.db.get_db_value(Register.NO_INPUTS, 0)
 
         l.append_msg(dcu_command_rsp_msg)
         l.read() # read at resp

app/tests/test_solarman_emu.py

@@ -144,7 +144,7 @@ async def test_emu_start(my_loop, config_tsun_inv1, msg_modbus_rsp, str_test_ip,
     inv = InvStream(msg_modbus_rsp)
 
     assert asyncio.get_running_loop() == inv.mb_timer.loop
-    await inv.send_start_cmd(get_sn_int(), str_test_ip, True, inv.mb_first_timeout)
+    inv.send_start_cmd(get_sn_int(), str_test_ip, True, inv.mb_first_timeout)
     inv.read()         # read complete msg, and dispatch msg
     assert not inv.header_valid  # must be invalid, since msg was handled and buffer flushed
     assert inv.msg_count == 1
@@ -161,7 +161,7 @@ async def test_snd_hb(my_loop, config_tsun_inv1, heartbeat_ind):
     inv = InvStream()
     cld = CldStream(inv)
 
-    # await inv.send_start_cmd(get_sn_int(), str_test_ip, False, inv.mb_first_timeout)
+    # inv.send_start_cmd(get_sn_int(), str_test_ip, False, inv.mb_first_timeout)
     cld.send_heartbeat_cb(0)
     assert cld.ifc.tx_fifo.peek() == heartbeat_ind
     cld.close()
@@ -178,7 +178,7 @@ async def test_snd_inv_data(my_loop, config_tsun_inv1, inverter_ind_msg, inverte
     inv.db.set_db_def_value(Register.GRID_FREQUENCY, 50.05)
     inv.db.set_db_def_value(Register.PROD_COMPL_TYPE, 6)
     assert asyncio.get_running_loop() == inv.mb_timer.loop
-    await inv.send_start_cmd(get_sn_int(), str_test_ip, False, inv.mb_first_timeout)
+    inv.send_start_cmd(get_sn_int(), str_test_ip, False, inv.mb_first_timeout)
     inv.db.set_db_def_value(Register.DATA_UP_INTERVAL, 17)  # set test value
 
     cld = CldStream(inv)
@@ -213,7 +213,7 @@ async def test_rcv_invalid(my_loop, config_tsun_inv1, inverter_ind_msg, inverter
     _ = config_tsun_inv1
     inv = InvStream()
     assert asyncio.get_running_loop() == inv.mb_timer.loop
-    await inv.send_start_cmd(get_sn_int(), str_test_ip, False, inv.mb_first_timeout)
+    inv.send_start_cmd(get_sn_int(), str_test_ip, False, inv.mb_first_timeout)
     inv.db.set_db_def_value(Register.DATA_UP_INTERVAL, 17)  # set test value
 
     cld = CldStream(inv)

app/tests/test_talent.py

@@ -2411,14 +2411,14 @@ async def test_msg_build_modbus_req(config_tsun_inv1, msg_modbus_cmd):
     _ = config_tsun_inv1
     m = MemoryStream(b'', (0,), True)
     m.id_str = b"R170000000000001" 
-    await m.send_modbus_cmd(Modbus.WRITE_SINGLE_REG, 0x2008, 0, logging.DEBUG)
+    m.send_modbus_cmd(Modbus.WRITE_SINGLE_REG, 0x2008, 0, logging.DEBUG)
     assert 0 == m.send_msg_ofs
     assert m.ifc.fwd_fifo.get() == b''
     assert m.ifc.tx_fifo.get() == b''
     assert m.sent_pdu == b''
 
     m.state = State.up
-    await m.send_modbus_cmd(Modbus.WRITE_SINGLE_REG, 0x2008, 0, logging.DEBUG)
+    m.send_modbus_cmd(Modbus.WRITE_SINGLE_REG, 0x2008, 0, logging.DEBUG)
     assert 0 == m.send_msg_ofs
     assert m.ifc.fwd_fifo.get() == b''
     assert m.ifc.tx_fifo.get() == b''

app/tests/test_web_route.py

@@ -1,22 +1,37 @@
 # test_with_pytest.py
 import pytest
-from server import app
-from web import Web, web
+import logging
+import os, errno
+import datetime
+from os import DirEntry, stat_result
+from quart import current_app
+from mock import patch
+
+from server import app as my_app
+from server import Server
+from web import web
 from async_stream import AsyncStreamClient
 from gen3plus.inverter_g3p import InverterG3P
+from web.log_handler import LogHandler
 from test_inverter_g3p import FakeReader, FakeWriter, config_conn
 from cnf.config import Config
-from mock import patch
 from proxy import Proxy
-import os, errno
-from os import DirEntry, stat_result
-import datetime
+
+
+class FakeServer(Server):
+    def __init__(self):
+        pass  # don't call the suoer(.__init__ for unit tests
+
 
 pytest_plugins = ('pytest_asyncio',)
+@pytest.fixture(scope="session")
+def app():
+    yield my_app
 
 @pytest.fixture(scope="session")
-def client():
+def client(app):
     app.secret_key = 'super secret key'
+    app.testing = True
     return app.test_client()
 
 @pytest.fixture
@@ -52,6 +67,7 @@ async def test_home(client):
     response = await client.get('/')
     assert response.status_code == 200
     assert response.mimetype == 'text/html'
+    assert b"<title>TSUN Proxy - Connections</title>" in await response.data
 
 @pytest.mark.asyncio
 async def test_page(client):
@@ -59,14 +75,17 @@ async def test_page(client):
     response = await client.get('/mqtt')
     assert response.status_code == 200
     assert response.mimetype == 'text/html'
+    assert b"<title>TSUN Proxy - MQTT Status</title>" in await response.data
+    assert b'fetch("/mqtt-fetch")' in await response.data
 
 @pytest.mark.asyncio
 async def test_rel_page(client):
-    """Test the mqtt route."""
+    """Test the mqtt route with relative paths."""
     web.build_relative_urls = True
     response = await client.get('/mqtt')
     assert response.status_code == 200
     assert response.mimetype == 'text/html'
+    assert b'fetch("./mqtt-fetch")' in await response.data
     web.build_relative_urls = False
 
 @pytest.mark.asyncio
@@ -75,6 +94,7 @@ async def test_notes(client):
     response = await client.get('/notes')
     assert response.status_code == 200
     assert response.mimetype == 'text/html'
+    assert b"<title>TSUN Proxy - Important Messages</title>" in await response.data
 
 @pytest.mark.asyncio
 async def test_logging(client):
@@ -82,6 +102,7 @@ async def test_logging(client):
     response = await client.get('/logging')
     assert response.status_code == 200
     assert response.mimetype == 'text/html'
+    assert b"<title>TSUN Proxy - Log Files</title>" in await response.data
 
 @pytest.mark.asyncio
 async def test_favicon96(client):
@@ -119,37 +140,37 @@ async def test_manifest(client):
     assert response.mimetype == 'application/manifest+json'
 
 @pytest.mark.asyncio
-async def test_data_fetch(create_inverter):
+async def test_data_fetch(client, create_inverter):
     """Test the data-fetch route."""
     _ = create_inverter
-    client = app.test_client()
     response = await client.get('/data-fetch')
     assert response.status_code == 200
 
     response = await client.get('/data-fetch')
     assert response.status_code == 200
+    assert b'<h5>Connections</h5>' in await response.data
 
 @pytest.mark.asyncio
-async def test_data_fetch1(create_inverter_server):
+async def test_data_fetch1(client, create_inverter_server):
     """Test the data-fetch route with server connection."""
     _ = create_inverter_server
-    client = app.test_client()
     response = await client.get('/data-fetch')
     assert response.status_code == 200
 
     response = await client.get('/data-fetch')
     assert response.status_code == 200
+    assert b'<h5>Connections</h5>' in await response.data
 
 @pytest.mark.asyncio
-async def test_data_fetch2(create_inverter_client):
+async def test_data_fetch2(client, create_inverter_client):
     """Test the data-fetch route with client connection."""
     _ = create_inverter_client
-    client = app.test_client()
     response = await client.get('/data-fetch')
     assert response.status_code == 200
 
     response = await client.get('/data-fetch')
     assert response.status_code == 200
+    assert b'<h5>Connections</h5>' in await response.data
 
 @pytest.mark.asyncio
 async def test_language_en(client):
@@ -159,21 +180,44 @@ async def test_language_en(client):
     assert response.content_language.pop() == 'en'
     assert response.location == '/index'
     assert response.mimetype == 'text/html'
+    assert b'<html lang=en' in await response.data
+    assert b'<title>Redirecting...</title>' in await response.data
 
     client.set_cookie('test', key='language', value='de')
-    response = await client.get('/mqtt')
+    response = await client.get('/')
     assert response.status_code == 200
     assert response.mimetype == 'text/html'
+    assert b'<html lang="en"' in await response.data
+    assert b'<title>TSUN Proxy - Connections</title>' in await response.data
 
 @pytest.mark.asyncio
 async def test_language_de(client):
     """Test the language/de route."""
+
     response = await client.get('/language/de', headers={'referer': '/'})
     assert response.status_code == 302
     assert response.content_language.pop() == 'de'
     assert response.location == '/'
     assert response.mimetype == 'text/html'
+    assert b'<html lang=en>' in await response.data
+    assert b'<title>Redirecting...</title>' in await response.data
 
+    client.set_cookie('test', key='language', value='en')
+    response = await client.get('/')
+    assert response.status_code == 200
+    assert response.mimetype == 'text/html'
+    assert b'<html lang="de"' in await response.data
+    # the following assert fails on github runner, since the translation to german fails
+    # assert b'<title>TSUN Proxy - Verbindungen</title>' in await response.data 
+
+    """Switch back to english"""
+    response = await client.get('/language/en', headers={'referer': '/index'})
+    assert response.status_code == 302
+    assert response.content_language.pop() == 'en'
+    assert response.location == '/index'
+    assert response.mimetype == 'text/html'
+    assert b'<html lang=en>' in await response.data
+    assert b'<title>Redirecting...</title>' in await response.data
 
 @pytest.mark.asyncio
 async def test_language_unknown(client):
@@ -182,6 +226,12 @@ async def test_language_unknown(client):
     assert response.status_code == 404
     assert response.mimetype == 'text/html'
 
+    client.set_cookie('test', key='language', value='en')
+    response = await client.get('/')
+    assert response.status_code == 200
+    assert response.mimetype == 'text/html'
+    assert b'<title>TSUN Proxy - Connections</title>' in await response.data
+
 
 @pytest.mark.asyncio
 async def test_mqtt_fetch(client, create_inverter):
@@ -191,15 +241,47 @@ async def test_mqtt_fetch(client, create_inverter):
 
     response = await client.get('/mqtt-fetch')
     assert response.status_code == 200
+    assert b'<h5>MQTT devices</h5>' in await response.data
 
 
 @pytest.mark.asyncio
 async def test_notes_fetch(client, config_conn):
     """Test the notes-fetch route."""
-    _ = create_inverter
+    _ = config_conn
 
+    s = FakeServer()
+    s.src_dir = 'app/src/'
+    s.init_logging_system()
+
+    # First clear log and test Well done message
+    logh = LogHandler()
+    logh.clear()
     response = await client.get('/notes-fetch')
     assert response.status_code == 200
+    assert b'<h2>Well done!</h2>' in await response.data
+
+    # Check info logs which must be ignored here
+    logging.info('config_info')
+    logh.flush()
+    response = await client.get('/notes-fetch')
+    assert response.status_code == 200
+    assert b'<h2>Well done!</h2>' in await response.data
+
+    # Check warning logs which must be added to the note list
+    logging.warning('config_warning')
+    logh.flush()
+    response = await client.get('/notes-fetch')
+    assert response.status_code == 200
+    assert b'WARNING' in await response.data
+    assert b'config_warning' in await response.data
+
+    # Check error logs which must be added to the note list
+    logging.error('config_err')
+    logh.flush()
+    response = await client.get('/notes-fetch')
+    assert response.status_code == 200
+    assert b'ERROR' in await response.data
+    assert b'config_err' in await response.data
 
 
 @pytest.mark.asyncio
@@ -229,6 +311,7 @@ async def test_file_fetch(client, config_conn, monkeypatch):
     monkeypatch.delattr(stat_result, "st_birthtime")
     response = await client.get('/file-fetch')
     assert response.status_code == 200
+    assert b'<h4>test.txt</h4>' in await response.data
 
 @pytest.mark.asyncio
 async def test_send_file(client, config_conn):
@@ -237,6 +320,7 @@ async def test_send_file(client, config_conn):
     assert Config.log_path == 'app/tests/log/'
     response = await client.get('/send-file/test.txt')
     assert response.status_code == 200
+    assert b'2025-04-30 00:01:23' in await response.data
 
 
 @pytest.mark.asyncio
@@ -291,3 +375,20 @@ async def test_del_file_err(client, config_conn, patch_os_remove_err):
     assert Config.log_path == 'app/tests/log/'
     response = await client.delete ('/del-file/test.txt')
     assert response.status_code == 404
+
+@pytest.mark.asyncio
+async def test_addon_links(client):
+    """Test links to HA add-on config/log in UI"""
+    with patch.dict(os.environ, {'SLUG': 'c676133d', 'HOSTNAME': 'c676133d-tsun-proxy'}):
+        response = await client.get('/')
+        assert response.status_code == 200
+        assert response.mimetype == 'text/html'
+        assert b'Add-on Config' in await response.data
+        assert b'href="/hassio/addon/c676133d_tsun-proxy/logs' in await response.data
+        assert b'href="/hassio/addon/c676133d_tsun-proxy/config' in await response.data
+
+    # check that links are not available if env vars SLUG and HOSTNAME are not defined (docker version)    
+    response = await client.get('/')
+    assert response.status_code == 200
+    assert response.mimetype == 'text/html'
+    assert b'Add-on Config' not in await response.data

app/translations/de/LC_MESSAGES/messages.po

@@ -8,7 +8,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: tsun-gen3-proxy 0.14.0\n"
 "Report-Msgid-Bugs-To: EMAIL@ADDRESS\n"
-"POT-Creation-Date: 2025-05-13 22:34+0200\n"
+"POT-Creation-Date: 2025-06-21 10:54+0200\n"
 "PO-Revision-Date: 2025-04-18 16:24+0200\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 "Language: de\n"
@@ -75,6 +75,19 @@ msgstr "Wichtige Hinweise"
 msgid "Log Files"
 msgstr "Log Dateien"
 
+#: src/web/templates/base.html.j2:62
+#: src/web/templates/page_network_tests.html.j2:5
+msgid "Network Tests"
+msgstr ""
+
+#: src/web/templates/base.html.j2:65
+msgid "Add-on Config"
+msgstr "Add-on Konfiguration"
+
+#: src/web/templates/base.html.j2:66
+msgid "Add-on Log"
+msgstr "Add-on Protokoll"
+
 #: src/web/templates/page_index.html.j2:3
 msgid "TSUN Proxy - Connections"
 msgstr "TSUN Proxy - Verbindungen"
@@ -120,6 +133,7 @@ msgid "TSUN Proxy - Log Files"
 msgstr "TSUN Proxy - Log Dateien"
 
 #: src/web/templates/page_logging.html.j2:10
+#, python-format
 msgid "Do you really want to delete the log file: <br>%(file)s ?"
 msgstr "Soll die Datei: <br>%(file)s<br>wirklich gelöscht werden?"
 
@@ -163,6 +177,11 @@ msgstr "Empfangene Topics"
 msgid "Number of topics received"
 msgstr "Anzahl der empfangenen Topics"
 
+#: src/web/templates/page_network_tests.html.j2:3
+#, fuzzy
+msgid "TSUN Proxy - Network Tests"
+msgstr "TSUN Proxy - Verbindungen"
+
 #: src/web/templates/page_notes.html.j2:3
 msgid "TSUN Proxy - Important Messages"
 msgstr "TSUN Proxy - Wichtige Hinweise"

ha_addons/Makefile

@@ -192,7 +192,7 @@ $(repro_all_subdirs) :
 	mkdir -p $@
 
 $(repro_all_templates) : $(INST_BASE)/ha_addon_%/config.yaml: $(TEMPL)/config.jinja $(TEMPL)/%_data.json $(SRC)/.version FORCE
-	$(JINJA) --strict -D AppVersion=$(VERSION)-$* -D BuildID=$(BUILD_ID) $< $(filter %.json,$^) -o $@
+	$(JINJA) --strict -D AppVersion=$(VERSION)-$*$(RC) -D BuildID=$(BUILD_ID) $< $(filter %.json,$^) -o $@
 
 $(repro_all_apparmor) : $(INST_BASE)/ha_addon_%/apparmor.txt: $(TEMPL)/apparmor.jinja $(TEMPL)/%_data.json
 	$(JINJA) --strict $< $(filter %.json,$^) -o $@

ha_addons/docker-bake.hcl

@@ -59,7 +59,7 @@ target "_common" {
   ]
 
   no-cache = false
-  platforms = ["linux/amd64", "linux/arm64", "linux/arm/v7"]
+  platforms = ["linux/amd64", "linux/arm64"]
 }
 
 target "_debug" {

ha_addons/ha_addon/Dockerfile

@@ -18,7 +18,7 @@ ARG BUILD_FROM="ghcr.io/hassio-addons/base:17.2.5"
 FROM $BUILD_FROM AS base
 
 # Installiere Python, pip und virtuelle Umgebungstools
-RUN apk add --no-cache python3=3.12.10-r0 py3-pip=24.3.1-r0 && \
+RUN apk add --no-cache python3=3.12.10-r1 py3-pip=24.3.1-r0 && \
     python -m venv /opt/venv && \
     . /opt/venv/bin/activate
 

ha_addons/ha_addon/rootfs/run.sh

@@ -1,18 +1,46 @@
 #!/usr/bin/with-contenv bashio
 
-echo "Add-on environment started"
+bashio::log.blue "-----------------------------------------------------------"
+bashio::log.blue "run.sh: info: setup Add-on environment"
+bashio::cache.flush_all
+MQTT_HOST=""
+SLUG=""
+HOSTNAME=""
+if bashio::supervisor.ping; then
+    bashio::log "run.sh: info: check Home Assistant bashio for config values"
+    if bashio::services.available mqtt; then
+        MQTT_HOST=$(bashio::services mqtt "host")
+        MQTT_PORT=$(bashio::services mqtt "port")
+        MQTT_USER=$(bashio::services mqtt "username")
+        MQTT_PASSWORD=$(bashio::services mqtt "password")
+    else
+        bashio::log.yellow "run.sh: info: Home Assistant MQTT service not available!"
+    fi
+    SLUG=$(bashio::addon.repository)
+    HOSTNAME=$(bashio::addon.hostname)
+else
+    bashio::log.red "run.sh: error: Home Assistant Supervisor API not available!"
+fi
 
-echo "check for Home Assistant MQTT"
-MQTT_HOST=$(bashio::services mqtt "host")
-MQTT_PORT=$(bashio::services mqtt "port")
-MQTT_USER=$(bashio::services mqtt "username")
-MQTT_PASSWORD=$(bashio::services mqtt "password")
+if [ -z "$SLUG" ]; then
+    bashio::log.yellow "run.sh: info: addon slug not found"
+else
+    bashio::log.green "run.sh: info: found addon slug: $SLUG"
+    export SLUG
+
+fi
+if [ -z "$HOSTNAME" ]; then
+    bashio::log.yellow "run.sh: info: addon hostname not found"
+else
+    bashio::log.green "run.sh: info: found addon hostname: $HOSTNAME"
+    export HOSTNAME
+fi
 
 # if a MQTT was/not found, drop a note
 if [ -z "$MQTT_HOST" ]; then
-    echo "MQTT not found"
+    bashio::log.yellow "run.sh: info: MQTT config not found"
 else
-    echo "MQTT found"
+    bashio::log.green "run.sh: info: found MQTT config"
     export MQTT_HOST
     export MQTT_PORT
     export MQTT_USER
@@ -29,5 +57,6 @@ cd /home/proxy || exit
 
 export VERSION=$(cat /proxy-version.txt)
 
-echo "Start Proxyserver..."
+bashio::log.blue "run.sh: info: Start Proxyserver..."
+bashio::log.blue "-----------------------------------------------------------"
 python3 server.py --rel_urls --json_config=/data/options.json  --log_path=/homeassistant/tsun-proxy/logs/ --config_path=/homeassistant/tsun-proxy/ --log_backups=2

ha_addons/templates/rc_data.json

@@ -2,7 +2,6 @@
 {
     "name": "TSUN-Proxy (Release Candidate)",
     "description": "MQTT Proxy for TSUN Photovoltaic Inverters",
-    "version": "rc",
     "image": "ghcr.io/s-allius/tsun-gen3-addon",
     "slug": "tsun-proxy-rc",
     "advanced": true,