Even more tests. Also improved code quality with a refactoring for better testing.

4 files changed, 449 insertions, 82 deletions

diff --git a/tests/node.d/fronius.chart.spec.js b/tests/node.d/fronius.chart.spec.js
index c9c75f9c3c..c10bbe09a7 100644
--- a/tests/node.d/fronius.chart.spec.js
+++ b/tests/node.d/fronius.chart.spec.js
@@ -5,17 +5,23 @@ var netdata = require("../../node.d/node_modules/netdata");
 var subject = require("../../node.d/fronius.node");
 
 var service = netdata.service({
-    name: "fronius",
+    name: "chart",
     module: this
 });
 
 describe("fronius chart creation", function () {
 
+    var chartPrefix = "fronius_chart.";
+
     beforeAll(function () {
         // change this to enable debug log
         netdata.options.DEBUG = false;
     });
 
+    afterAll(function () {
+        deleteProperties(subject.charts)
+    });
+
     it("should return a basic chart dimension", function () {
         var result = subject.createBasicDimension("id", "name", 2);
 
@@ -26,10 +32,10 @@ describe("fronius chart creation", function () {
     });
 
     it("should return the power chart definition", function () {
-        var id = "power";
-        var result = subject.getSitePowerChart(service, id);
+        var suffix = "power";
+        var result = subject.getSitePowerChart(service, suffix);
 
-        expect(result.id).toBe(id);
+        expect(result.id).toBe(chartPrefix + suffix);
         expect(result.units).toBe("W");
         expect(result.type).toBe(netdata.chartTypes.area);
         expect(result.family).toBe("power");
@@ -41,10 +47,10 @@ describe("fronius chart creation", function () {
     });
 
     it("should return the consumption chart definition", function () {
-        var id = "Load";
-        var result = subject.getSiteConsumptionChart(service, id);
+        var suffix = "Load";
+        var result = subject.getSiteConsumptionChart(service, suffix);
 
-        expect(result.id).toBe(id);
+        expect(result.id).toBe(chartPrefix + suffix);
         expect(result.units).toBe("W");
         expect(result.type).toBe(netdata.chartTypes.area);
         expect(result.family).toBe("consumption");
@@ -54,10 +60,10 @@ describe("fronius chart creation", function () {
     });
 
     it("should return the autonomy chart definition", function () {
-        var id = "Autonomy";
-        var result = subject.getSiteAutonomyChart(service, id);
+        var suffix = "Autonomy";
+        var result = subject.getSiteAutonomyChart(service, suffix);
 
-        expect(result.id).toBe(id);
+        expect(result.id).toBe(chartPrefix + suffix);
         expect(result.units).toBe("%");
         expect(result.type).toBe(netdata.chartTypes.area);
         expect(result.family).toBe("autonomy");
@@ -68,10 +74,10 @@ describe("fronius chart creation", function () {
     });
 
     it("should return the energy today chart definition", function () {
-        var id = "Energy today";
-        var result = subject.getSiteEnergyTodayChart(service, id);
+        var suffix = "Energy today";
+        var result = subject.getSiteEnergyTodayChart(service, suffix);
 
-        expect(result.id).toBe(id);
+        expect(result.id).toBe(chartPrefix + suffix);
         expect(result.units).toBe("kWh");
         expect(result.type).toBe(netdata.chartTypes.area);
         expect(result.family).toBe("energy");
@@ -81,10 +87,10 @@ describe("fronius chart creation", function () {
     });
 
     it("should return the energy year chart definition", function () {
-        var id = "Energy year";
-        var result = subject.getSiteEnergyYearChart(service, id);
+        var suffix = "Energy year";
+        var result = subject.getSiteEnergyYearChart(service, suffix);
 
-        expect(result.id).toBe(id);
+        expect(result.id).toBe(chartPrefix + suffix);
         expect(result.units).toBe("kWh");
         expect(result.type).toBe(netdata.chartTypes.area);
         expect(result.family).toBe("energy");
@@ -93,6 +99,59 @@ describe("fronius chart creation", function () {
         expect(result.dimensions[subject.energyYearId].name).toBe("Year");
     });
 
+    it("should return the inverter chart definition with a single numerical inverter", function () {
+        var inverters = {
+            "1": {}
+        };
+        var suffix = "numerical";
+        var result = subject.getInverterPowerChart(service, suffix, inverters);
+
+        expect(result.id).toBe(chartPrefix + suffix);
+        expect(result.units).toBe("W");
+        expect(result.type).toBe(netdata.chartTypes.stacked);
+        expect(result.family).toBe("inverters");
+        expect(result.context).toBe("fronius.inverter.output");
+        expect(Object.keys(result.dimensions).length).toBe(1);
+        expect(result.dimensions["1"].name).toBe("Inverter 1");
+    });
+
+    it("should return the inverter chart definition with a single alphabetical inverter", function () {
+        var key = "Cellar";
+        var inverters = {
+            "Cellar": {}
+        };
+        var suffix = "alphabetical";
+        var result = subject.getInverterPowerChart(service, suffix, inverters);
+
+        expect(result.id).toBe(chartPrefix + suffix);
+        expect(result.units).toBe("W");
+        expect(result.type).toBe(netdata.chartTypes.stacked);
+        expect(result.family).toBe("inverters");
+        expect(result.context).toBe("fronius.inverter.output");
+        expect(Object.keys(result.dimensions).length).toBe(1);
+        expect(result.dimensions[key].name).toBe(key);
+    });
+
+    it("should return the inverter chart definition with multiple alphanumerical inverter", function () {
+        var alpha = "Cellar";
+        var numerical = 1;
+        var inverters = {
+            "Cellar": {},
+            "1": {}
+        };
+        var suffix = "alphanumerical";
+        var result = subject.getInverterPowerChart(service, suffix, inverters);
+
+        expect(result.id).toBe(chartPrefix + suffix);
+        expect(result.units).toBe("W");
+        expect(result.type).toBe(netdata.chartTypes.stacked);
+        expect(result.family).toBe("inverters");
+        expect(result.context).toBe("fronius.inverter.output");
+        expect(Object.keys(result.dimensions).length).toBe(2);
+        expect(result.dimensions[alpha].name).toBe(alpha);
+        expect(result.dimensions[numerical].name).toBe("Inverter " + numerical);
+    });
+
     it("should return the same chart definition on second call for lazy loading", function () {
         var first = subject.getSitePowerChart(service, "id");
         var second = subject.getSitePowerChart(service, "id");
diff --git a/tests/node.d/fronius.parse.spec.js b/tests/node.d/fronius.parse.spec.js
index a6f1cee305..9c371ad98a 100644
--- a/tests/node.d/fronius.parse.spec.js
+++ b/tests/node.d/fronius.parse.spec.js
@@ -5,63 +5,301 @@ var netdata = require("../../node.d/node_modules/netdata");
 var subject = require("../../node.d/fronius.node");
 
 var service = netdata.service({
-    name: "fronius",
+    name: "parse",
     module: this
 });
 
-describe("fronius data parsing", function () {
-
-    var fakeResponse = {
-        "Head" : {
-            "RequestArguments" : {},
-            "Status" : {
-                "Code" : 0,
-                "Reason" : "",
-                "UserMessage" : ""
-            },
-            "Timestamp" : "2017-07-17T16:01:04+02:00"
-        },
-        "Body" : {
-            "Data" : {
-                "Site" : {
-                    "Mode" : "meter",
-                    "P_Grid" : -3430.729923,
-                    "P_Load" : -910.270077,
-                    "P_Akku" : null,
-                    "P_PV" : 4341,
-                    "rel_SelfConsumption" : 20.969133,
-                    "rel_Autonomy" : 100,
-                    "E_Day" : 57230,
-                    "E_Year" : 6425915.5,
-                    "E_Total" : 15388710,
-                    "Meter_Location" : "grid"
-                },
-                "Inverters" : {
-                    "1" : {
-                        "DT" : 123,
-                        "P" : 4341,
-                        "E_Day" : 57230,
-                        "E_Year" : 6425915.5,
-                        "E_Total" : 15388710
-                    }
-                }
-            }
+var root = {
+    "Body": {
+        "Data": {
+            "Site": {},
+            "Inverters": {}
         }
-    };
+    }
+};
 
-    beforeAll(function () {
-        // change this to enable debug log
-        netdata.options.DEBUG = false;
+describe("fronius parsing for power chart", function () {
+
+    var site = root.Body.Data.Site;
+
+    afterEach(function () {
+        deleteProperties(site);
+    });
+
+    it("should return 3000 for P_Grid when rounded", function () {
+        site.P_Grid = 2999.501;
+        var result = subject.parsePowerChart(service, site).dimensions[0];
+
+        expect(result.name).toBe(subject.powerGridId);
+        expect(result.value).toBe(3000);
+    });
+
+    it("should return -3000 for P_Grid", function () {
+        site.P_Grid = -3000;
+        var result = subject.parsePowerChart(service, site).dimensions[0];
+
+        expect(result.name).toBe(subject.powerGridId);
+        expect(result.value).toBe(-3000);
+    });
+
+    it("should return 0 for P_Grid if it is null", function () {
+        site.P_Grid = null;
+        var result = subject.parsePowerChart(service, site).dimensions[0];
+
+        expect(result.name).toBe(subject.powerGridId);
+        expect(result.value).toBe(0);
+    });
+
+    it("should return 0 for P_Grid if it is zero", function () {
+        site.P_Grid = 0;
+        var result = subject.parsePowerChart(service, site).dimensions[0];
+
+        expect(result.name).toBe(subject.powerGridId);
+        expect(result.value).toBe(0);
+    });
+
+    it("should return -100 for P_Akku", function () {
+        // it is unclear whether negative values are possible for p_akku (couln't test, nor any API docs found).
+        site.P_Akku = -100;
+        var result = subject.parsePowerChart(service, site).dimensions[2];
+
+        expect(result.name).toBe(subject.powerAccuId);
+        expect(result.value).toBe(-100);
+    });
+
+    it("should return 0 for P_Akku if it is null", function () {
+        site.P_Akku = null;
+        var result = subject.parsePowerChart(service, site).dimensions[2];
+
+        expect(result.name).toBe(subject.powerAccuId);
+        expect(result.value).toBe(0);
+    });
+
+    it("should return 0 for P_Akku if it is zero", function () {
+        site.P_Akku = 0;
+        var result = subject.parsePowerChart(service, site).dimensions[2];
+
+        expect(result.name).toBe(subject.powerAccuId);
+        expect(result.value).toBe(0);
+    });
+
+    it("should return 100 for P_PV", function () {
+        site.P_PV = 100;
+        var result = subject.parsePowerChart(service, site).dimensions[1];
+
+        expect(result.name).toBe(subject.powerPvId);
+        expect(result.value).toBe(100);
+    });
+
+    it("should return 0 for P_PV if it is zero", function () {
+        site.P_PV = 0;
+        var result = subject.parsePowerChart(service, site).dimensions[1];
+
+        expect(result.name).toBe(subject.powerPvId);
+        expect(result.value).toBe(0);
+    });
+
+    it("should return 0 for P_PV if it is null", function () {
+        site.P_PV = null;
+        var result = subject.parsePowerChart(service, site).dimensions[1];
+
+        expect(result.name).toBe(subject.powerPvId);
+        expect(result.value).toBe(0);
+    });
+
+    it("should return 0 for P_PV if it is negative", function () {
+        // solar panels shouldn't consume anything, only produce.
+        site.P_PV = -1;
+        var result = subject.parsePowerChart(service, site).dimensions[1];
+
+        expect(result.name).toBe(subject.powerPvId);
+        expect(result.value).toBe(0);
+    });
+
+});
+
+describe("fronius parsing for consumption", function () {
+
+    var site = root.Body.Data.Site;
+
+    afterEach(function () {
+        deleteProperties(site);
+    });
+
+    it("should return 1000 for P_Load when rounded", function () {
+        site.P_Load = 1000.499;
+        var result = subject.parseConsumptionChart(service, site).dimensions[0];
+
+        expect(result.name).toBe(subject.consumptionLoadId);
+        expect(result.value).toBe(1000);
+    });
+
+    it("should return absolute value for P_Load when negative", function () {
+        /*
+         with firmware 3.7.4 it is sometimes possible that negative values are returned for P_Load,
+         which makes absolutely no sense. There is always a device that consumes some electricity around the clock.
+         Best we can do is to make it a positive value, since 0 also doesn't make much sense.
+         This "workaround" seems to work, as there couldn't be any strange peaks observed during long-time testing.
+         */
+        site.P_Load = -50;
+        var result = subject.parseConsumptionChart(service, site).dimensions[0];
+
+        expect(result.name).toBe(subject.consumptionLoadId);
+        expect(result.value).toBe(50);
+    });
+
+    it("should return 0 for P_Load if it is null", function () {
+        site.P_Load = null;
+        var result = subject.parseConsumptionChart(service, site).dimensions[0];
+
+        expect(result.name).toBe(subject.consumptionLoadId);
+        expect(result.value).toBe(0);
+    });
+
+    it("should return 0 for P_Load if it is zero", function () {
+        site.P_Load = 0;
+        var result = subject.parseConsumptionChart(service, site).dimensions[0];
+
+        expect(result.name).toBe(subject.consumptionLoadId);
+        expect(result.value).toBe(0);
+    });
+
+});
+
+describe("fronius parsing for autonomy", function () {
+
+    var site = root.Body.Data.Site;
+
+    afterEach(function () {
+        deleteProperties(site);
+    });
+
+    it("should return 100 for rel_Autonomy", function () {
+        site.rel_Autonomy = 100;
+        var result = subject.parseAutonomyChart(service, site).dimensions[0];
+
+        expect(result.name).toBe(subject.autonomyId);
+        expect(result.value).toBe(100);
+    });
+
+    it("should return 0 for rel_Autonomy if it is zero", function () {
+        site.rel_Autonomy = 0;
+        var result = subject.parseAutonomyChart(service, site).dimensions[0];
+
+        expect(result.name).toBe(subject.autonomyId);
+        expect(result.value).toBe(0);
     });
 
-    it("should return a parsed value", function () {
-        // arrange
-        netdata.send = jasmine.createSpy("send");
-        // act
-        subject.processResponse(service, fakeResponse);
-        var result = netdata.send.calls.argsFor(0)[0];
-        // assert
-        expect(result).toContain("SET p_grid = -3431");
+    it("should return 0 for rel_Autonomy if it is null", function () {
+        site.rel_Autonomy = null;
+        var result = subject.parseAutonomyChart(service, site).dimensions[0];
+
+        expect(result.name).toBe(subject.autonomyId);
+        expect(result.value).toBe(0);
     });
 
+    it("should return 20 for rel_Autonomy if it is 20", function () {
+        site.rel_Autonomy = 20.1;
+        var result = subject.parseAutonomyChart(service, site).dimensions[0];
+
+        expect(result.name).toBe(subject.autonomyId);
+        expect(result.value).toBe(20);
+    });
+
+    it("should return 20 for rel_SelfConsumption if it is 19.5", function () {
+        site.rel_SelfConsumption = 19.5;
+        var result = subject.parseAutonomyChart(service, site).dimensions[1];
+
+        expect(result.name).toBe(subject.consumptionSelfId);
+        expect(result.value).toBe(20);
+    });
+
+    it("should return 100 for rel_SelfConsumption if it is null", function () {
+        /*
+         During testing it could be observed that the API is delivering null if the solar panels
+         do not produce enough energy to supply the local load. But in this case it should be 100, since all
+         the produced energy is directly consumed.
+         */
+        site.rel_SelfConsumption = null;
+        var result = subject.parseAutonomyChart(service, site).dimensions[1];
+
+        expect(result.name).toBe(subject.consumptionSelfId);
+        expect(result.value).toBe(100);
+    });
+
+    it("should return 0 for rel_SelfConsumption if it is zero", function () {
+        site.rel_SelfConsumption = 0;
+        var result = subject.parseAutonomyChart(service, site).dimensions[1];
+
+        expect(result.name).toBe(subject.consumptionSelfId);
+        expect(result.value).toBe(0);
+    });
 });
+
+describe("fronius parsing for energy", function () {
+
+    var site = root.Body.Data.Site;
+
+    afterEach(function () {
+        deleteProperties(site);
+    });
+
+    it("should return 10000 for E_Day", function () {
+        site.E_Day = 10000;
+        var result = subject.parseEnergyTodayChart(service, site).dimensions[0];
+
+        expect(result.name).toBe(subject.energyTodayId);
+        expect(result.value).toBe(10000);
+    });
+
+    it("should return 0 for E_Day if it is negative", function () {
+        /*
+         The solar panels can't produce negative energy, really. It would be a fault of the API.
+         */
+        site.E_Day = -0.4;
+        var result = subject.parseEnergyTodayChart(service, site).dimensions[0];
+
+        expect(result.name).toBe(subject.energyTodayId);
+        expect(result.value).toBe(0);
+    });
+
+    it("should return 100'000 for E_Year", function () {
+        site.E_Year = 100000.4;
+        var result = subject.parseEnergyYearChart(service, site).dimensions[0];
+
+        expect(result.name).toBe(subject.energyYearId);
+        expect(result.value).toBe(100000);
+    });
+
+    it("should return 0 for E_Year if it is negative", function () {
+        /*
+         A return value of 0 only makes sense in the silvester night anyway, when the counter is being reset.
+         A negative value is a fault from the API though. It wouldn't make sense.
+         */
+        site.E_Year = -1;
+        var result = subject.parseEnergyYearChart(service, site).dimensions[0];
+
+        expect(result.name).toBe(subject.energyYearId);
+        expect(result.value).toBe(0);
+    });
+});
+
+describe("fronius parsing for inverters", function () {
+
+    var inverters = root.Body.Data.Inverters;
+
+    afterEach(function () {
+        deleteProperties(inverters);
+    });
+
+    it("should return 1000 for P for inverter with name", function () {
+       inverters["cellar"] = {
+           P: 1000
+       };
+       var result = subject.parseInverterChart(service, inverters).dimensions[0];
+
+       expect(result.name).toBe("cellar");
+       expect(result.value).toBe(1000);
+    });
+
+});
\ No newline at end of file
diff --git a/tests/node.d/fronius.process.spec.js b/tests/node.d/fronius.process.spec.js
new file mode 100644
index 0000000000..daa84f3903
--- /dev/null
+++ b/tests/node.d/fronius.process.spec.js
@@ -0,0 +1,74 @@
+"use strict";
+
+var netdata = require("../../node.d/node_modules/netdata");
+// remember: subject will be a singleton!
+var subject = require("../../node.d/fronius.node");
+
+var service = netdata.service({
+    name: "process",
+    module: this
+});
+
+var exampleResponse = {
+    "Body": {
+        "Data": {
+            "Site": {
+                "Mode": "meter",
+                "P_Grid": -3430.729923,
+                "P_Load": -910.270077,
+                "P_Akku": null,
+                "P_PV": 4341,
+                "rel_SelfConsumption": 20.969133,
+                "rel_Autonomy": 100,
+                "E_Day": 57230,
+                "E_Year": 6425915.5,
+                "E_Total": 15388710,
+                "Meter_Location": "grid"
+            },
+            "Inverters": {
+                "1": {
+                    "DT": 123,
+                    "P": 4341,
+                    "E_Day": 57230,
+                    "E_Year": 6425915.5,
+                    "E_Total": 15388710
+                }
+            }
+        }
+    }
+};
+
+describe("fronius main processing", function () {
+
+    beforeAll(function () {
+        // change this to enable debug log
+        netdata.options.DEBUG = false;
+    });
+
+    beforeEach(function () {
+        deleteProperties(subject.charts);
+    });
+
+    it("should send parsed values to netdata", function () {
+        netdata.send = jasmine.createSpy("send");
+
+        subject.processResponse(service, exampleResponse);
+
+        expect(netdata.send.calls.count()).toBe(6);
+
+        // check if some parsed values were sent.
+        var powerChart = netdata.send.calls.argsFor(5)[0];
+
+        expect(powerChart).toContain("SET p_grid = -3431");
+        expect(powerChart).toContain("SET p_pv = 4341");
+
+        var inverterChart = netdata.send.calls.argsFor(0)[0];
+
+        expect(inverterChart).toContain("SET 1 = 4341");
+
+        var autonomyChart = netdata.send.calls.argsFor(3)[0];
+        expect(autonomyChart).toContain("SET rel_selfconsumption = 21");
+    });
+
+
+});
\ No newline at end of file
diff --git a/tests/node.d/fronius.validation.spec.js b/tests/node.d/fronius.validation.spec.js
index 06241f3ceb..08b7e430f2 100644
--- a/tests/node.d/fronius.validation.spec.js
+++ b/tests/node.d/fronius.validation.spec.js
@@ -5,26 +5,12 @@ var netdata = require("../../node.d/node_modules/netdata");
 var subject = require("../../node.d/fronius.node");
 
 var service = netdata.service({
-    name: "fronius",
+    name: "validation",
     module: this
 });
 
 describe("fronius response validation", function () {
 
-    // this is a faked JSON response from the server.
-    // Used with freeformatter.com/json-escape.html to escape the json and turn it into a string.
-    var fakeResponse = "{\r\n\t\"Head\" : {\r\n\t\t\"RequestArguments\" : {},\r\n\t\t\"Status\" " +
-        ": {\r\n\t\t\t\"Code\" : 0,\r\n\t\t\t\"Reason\" : \"\",\r\n\t\t\t\"UserMessage\" : " +
-        "\"\"\r\n\t\t},\r\n\t\t\"Timestamp\" : \"2017-07-17T16:01:04+02:00\"\r\n\t},\r\n\t\"Body\" : " +
-        "{\r\n\t\t\"Data\" : {\r\n\t\t\t\"Site\" : {\r\n\t\t\t\t\"Mode\" : \"meter\",\r\n\t\t\t\t\"P_Grid\" " +
-        ": -3430.729923,\r\n\t\t\t\t\"P_Load\" : -910.270077,\r\n\t\t\t\t\"P_Akku\" : " +
-        "null,\r\n\t\t\t\t\"P_PV\" : 4341,\r\n\t\t\t\t\"rel_SelfConsumption\" : " +
-        "20.969133,\r\n\t\t\t\t\"rel_Autonomy\" : 100,\r\n\t\t\t\t\"E_Day\" : 57230,\r\n\t\t\t\t\"E_Year\" " +
-        ": 6425915.5,\r\n\t\t\t\t\"E_Total\" : 15388710,\r\n\t\t\t\t\"Meter_Location\" : " +
-        "\"grid\"\r\n\t\t\t},\r\n\t\t\t\"Inverters\" : {\r\n\t\t\t\t\"1\" : {\r\n\t\t\t\t\t\"DT\" : " +
-        "123,\r\n\t\t\t\t\t\"P\" : 4341,\r\n\t\t\t\t\t\"E_Day\" : 57230,\r\n\t\t\t\t\t\"E_Year\" : " +
-        "6425915.5,\r\n\t\t\t\t\t\"E_Total\" : 15388710\r\n\t\t\t\t}\r\n\t\t\t}\r\n\t\t}\r\n\t}\r\n}";
-
     it("should do nothing if response is null", function () {
         netdata.send = jasmine.createSpy("send");
 
@@ -35,9 +21,19 @@ describe("fronius response validation", function () {
     });
 
     it("should return null if response is null", function () {
-        var result = subject.parseResponse(null);
+        var result = subject.convertToJson(null);
+
+        expect(result).toBeNull();
+    });
+
+    it("should return null and log error if response cannot be parsed", function () {
+        netdata.error = jasmine.createSpy("error");
+
+        // trailing commas are enough to create syntax exceptions
+        var result = subject.convertToJson("{name,}");
 
         expect(result).toBeNull();
+        expect(netdata.error.calls.count()).toBe(1);
     });
 
     it("should return true if response is valid", function () {