[get/post] /config/last_update | [get/post] /config/mac_address

pyheatpump/config.py

@@ -3,6 +3,7 @@ import os
 import re
 from datetime import datetime
 from configparser import ConfigParser
+from starlette.requests import Request
 from starlette.routing import Route, Router
 from starlette.responses import PlainTextResponse, JSONResponse
 from pprint import pprint
@@ -52,19 +53,16 @@ API_HOST=config.get('api', 'host')
 API_PORT=config.get('api', 'port')
 
 def save_config():
-    print(get_config_dict())
-    with open(CONFIG_FILES[1], 'w') as conf_file:
+    with open(CONFIG_FILES[-1], 'w') as conf_file:
         config.write(conf_file)
 
 
 def get_mac():
-    config.read(filenames=CONFIG_FILES)
-    return config.get('heatpump', 'mac_address')
+    return get_config_dict()['heatpump', 'mac_address']
 
 
 def mac_address_init():
     from netifaces import gateways, ifaddresses, AF_INET, AF_LINK
-    global config
 
     interface = gateways()['default'][AF_INET][1]
     if len(ifaddresses(interface)) == 0:
@@ -78,7 +76,6 @@ def mac_address_init():
     addr = ifaddresses(interface)[AF_LINK][0]['addr']
     config.set('heatpump', 'mac_address', addr)
     save_config()
-
     return addr
 
 
@@ -92,18 +89,18 @@ async def get_config(request):
 
 
 async def set_config(request):
-    global config
     body = await request.json()
+    d_body = json.loads(body)
     #return PlainTextResponse(body)
 
-    for sect in body.keys():
-        if type(body[sect]) is not dict:
+    for sect in d_body.keys():
+        if type(d_body[sect]) is not dict:
             continue
-        for item in body[sect].keys():
+        for item in d_body[sect].keys():
             if not config.has_option(sect, item):
                 raise HTTPException(404, f'The option {sect}.{item} does not exists')
             else:
-                config.set(sect, item, value=body[sect][item])
+                config.set(sect, item, value=d_body[sect][item])
 
     save_config()
     return PlainTextResponse('OK')
@@ -116,7 +113,6 @@ async def config_route(request, *args, **kwargs):
 
 
 async def mac_route(request, *args, **kwargs):
-    global config
     if request['method'] == 'GET':
         return PlainTextResponse(get_mac())
     elif request['method'] == 'POST':
@@ -130,6 +126,8 @@ async def mac_route(request, *args, **kwargs):
 
             config.set('heatpump','mac_address',mac_address)
             save_config()
+        else:
+            print(f'Wrong mac format : {mac_address}')
 
         return PlainTextResponse(' '.join((
             'Current ->',
@@ -142,8 +140,7 @@ def get_last_update():
 
 
 def set_last_update(last_update: int=0):
-    global config
-    config.set('supervisor', 'last_update', last_update)
+    config.set('supervisor', 'last_update', str(last_update))
     save_config()
     return get_last_update()
 
@@ -155,18 +152,21 @@ async def last_update_route(request, *args, **kwargs):
         < 0 : since current_date + last_update - interval
         > 0 : since current_data - last_update - interval (same behaviour as < 0) 
     """
-    global config
-    if request['method'] == 'GET':
+    if type(request) != Request or request['method'] == 'GET':
         return PlainTextResponse(get_last_update())
 
     elif request['method'] == 'POST':
         body = await request.body()
         last_update = int(body.decode() or 0)
-        if int(body.decode() or 0):
+        print(f'Last update set : {last_update}')
+        if last_update == 0:
+            print('Reset last update to current time')
             last_update = int(datetime.now().strftime('%s'))
         elif last_update <= 0:
+            print('Forward of {last_update} seconds')
             last_update = int(datetime.now().strftime('%s')) + last_update
         else:
+            print('Rewind of {last_update} seconds')
             last_update = int(datetime.now().strftime('%s')) - last_update
 
 
@@ -175,7 +175,8 @@ async def last_update_route(request, *args, **kwargs):
 
 ROUTES=[
     Route('/', config_route, methods=['GET', 'POST']),
-    Route('/mac', mac_route, methods=['GET', 'POST'])
+    Route('/mac', mac_route, methods=['GET', 'POST']),
+    Route('/last_update', last_update_route, methods=['GET', 'POST'])
 ]
 
 app = Router(routes=ROUTES)

tests/test_config.py

@@ -3,7 +3,7 @@ import pytest
 from starlette.authentication import UnauthenticatedUser
 from starlette.testclient import TestClient
 from pyheatpump.config import app, config, default_config, \
-    CONFIG_FILES, get_config, set_config, config_route, ROUTES, \
+    CONFIG_FILES, get_config, get_config_dict, set_config, config_route, ROUTES, \
     mac_address_init, save_config, get_last_update, set_last_update, \
     last_update_route
 from unittest.mock import patch, MagicMock
@@ -13,6 +13,8 @@ from tempfile import mkstemp
 from configparser import ConfigParser
 import os
 from requests import Request
+from uuid import uuid4
+from datetime import datetime
 
 @pytest.fixture
 def tmpconf(testdir):
@@ -24,12 +26,12 @@ def tmpconf(testdir):
 
     with open(tmp_conf_filepath, 'w') as f:
         f.write("[heatpump]\nmac_address = 'None'")
-        CONFIG_FILES = [tmp_conf_filepath]
+        #CONFIG_FILES = [tmp_conf_filepath]
         config.read(filenames=CONFIG_FILES)
 
     return config
 
-def test_get_():
+def test_get_(tmpconf):
     c = TestClient(app)
     r = c.get('/')
     assert r.status_code == 200
@@ -41,24 +43,26 @@ class RequestMock(MagicMock):
             return 'GET'
 
 
-@pytest.mark.asyncio
-async def test_get_config():
-    resp = await get_config(RequestMock())
+def test_get_config(tmpconf):
+    c = TestClient(app)
+    resp = c.get('/') 
     assert resp.status_code  == 200
-    d_resp = json.loads(resp.body.decode())
+    d_resp = resp.json()
+    assert type(d_resp) == dict
     for sect in default_config.keys():
         assert sect in d_resp.keys()
         for item in default_config[sect].keys():
             assert item in d_resp[sect].keys()
 
 
-def test_set_config():
+def test_set_config(tmpconf):
     c = TestClient(app)
     _, tmpconf = mkstemp()
-    CONFIG_FILES.insert(0, tmpconf)
+    CONFIG_FILES.append(tmpconf)
+    rand = str(uuid4())
     r = c.post('/', json=json.dumps({
         'supervisor': {
-            'scheme':'test'
+            'scheme':rand
         }
     }))
 
@@ -66,28 +70,31 @@ def test_set_config():
     config.read(filenames=[tmpconf])
 
     assert r.status_code == 200
-    assert config.get('supervisor', 'scheme') == 'test'
+    assert config.get('supervisor', 'scheme') == rand
+    assert type(get_config_dict()) == dict
+    d_config =get_config_dict()
+    assert 'supervisor' in d_config.keys()
+    assert 'scheme' in d_config['supervisor'].keys()
+    assert d_config['supervisor']['scheme'] == rand
 
     os.unlink(tmpconf)
 
 
 def test_mac_address(testdir, tmpconf):
-    try:
-        assert tmpconf.get('heatpump', 'mac_address') is 'None'
-        mac_address = mac_address_init()
-        config_mac_address = tmpconf.get('heatpump', 'mac_address')
-        assert config_mac_address == mac_address
-    except Exception as e:
-        raise e
-
-
-@pytest.mark.asyncio
-async def test_last_update(testdir, tmpconf):
-    req = Request()
-    req.method = 'POST'
-    res = await last_update_route(req)
-    last_update_0 = int(res.body)
-
-    res = await get_last_update(req)
-    last_update_1 = int(res.body)
+    mac_address = mac_address_init()
+    assert type(get_config_dict()) == dict
+    d_config =get_config_dict()
+
+    assert d_config['heatpump']['mac_address'] == mac_address
+
+
+def test_last_update(testdir, tmpconf):
+    c = TestClient(app)
+    resp = c.get('/last_update')
+    last_update_0 = int(resp.content.decode())
+    print(f'update0 {last_update_0}')
+
+    resp = c.post('/last_update', str(datetime.now().strftime('%s')))
+    last_update_1 = int(resp.content.decode())
+    print(f'update1 {last_update_1}')
     assert last_update_0 == last_update_1