Fix test (not yet finished)

.gitignore

@@ -1,2 +1,5 @@
 *~
 src/my_credentials.h
+*.o
+*.swp
+*.out

examples/tinymqtt-test/tinymqtt-test.ino

@@ -40,6 +40,7 @@ std::map<std::string, MqttBroker*> brokers;
 
 void setup()
 {
+	WiFi.persistent(false); // https://github.com/esp8266/Arduino/issues/1054 
   Serial.begin(115200);
 	delay(500);
 	Serial << endl << endl << endl
@@ -399,11 +400,11 @@ void loop()
 					}
 					if (client)
 					{
-						clients.erase(s);
 						for (auto it: clients)
 						{
 							if (it.second != client) continue;
 							Serial << "deleted" << endl;
+							delete (it.second);
 							clients.erase(it.first);
 							break;
 						}
@@ -413,9 +414,9 @@ void loop()
 					{
 						for(auto it: brokers)
 						{
-							Serial << (int32_t)it.second << '/' << (int32_t)broker << endl;
 							if (broker != it.second) continue;
 							Serial << "deleted" << endl;
+							delete (it.second);
 							brokers.erase(it.first);
 							break;
 						}

library.json

@@ -1,12 +1,12 @@
 {
     "name": "TinyMqtt",
     "keywords": "ethernet, mqtt, m2m, iot",
-    "description": "MQTT is a lightweight messaging protocol ideal for small devices. This library allows you to send and receive MQTT messages. It does support MQTT 3.1.1 without any QOS.",
+    "description": "MQTT is a lightweight messaging protocol ideal for small devices. This library allows to send and receive MQTT messages. It does support MQTT 3.1.1 without QOS=0.",
     "repository": {
         "type": "git",
         "url": "https://github.com/hsaturn/TinyMqtt.git"
     },
-    "version": "0.7.1",
+    "version": "0.7.2",
     "exclude": "",
     "examples": "examples/*/*.ino",
     "frameworks": "arduino",

library.properties

@@ -1,10 +1,11 @@
 name=TinyMqtt
-version=0.7.1
+version=0.7.2
 author=Francois BIOT, HSaturn, <hsaturn@gmail.com>
 maintainer=Francois BIOT, HSaturn, <hsaturn@gmail.com>
 sentence=A tiny broker and client library for MQTT messaging.
-paragraph=MQTT is a lightweight messaging protocol ideal for small devices. This library allows you to send and receive MQTT messages and to jhost a broker in your ESP. It does support MQTT 3.1.1 without any QOS.
+paragraph=MQTT is a lightweight messaging protocol ideal for small devices. This library allows to send and receive MQTT messages and to host a broker in your ESP. It does support MQTT 3.1.1 without QoS=0.
 category=Communication
 url=https://github.com/hsaturn/TinyMqtt
 architectures=*
 includes=TinyMqtt.h
+depends=

src/StringIndexer.h

@@ -15,6 +15,16 @@ class StringIndexer
 		std::string str;
 		uint8_t used=0;
 		friend class StringIndexer;
+
+		#if EPOXY_DUINO
+		public:
+		// Workaround to avoid coredump in Indexer::release
+		// when destroying a Topic after the deletion of
+		// StringIndexer::strings map (which can occurs only with AUnit,
+		// never in the ESP itself, because ESP never ends)
+		// (I hate static vars)
+		~StringCounter() { used=255; }
+		#endif
 	};
 	public:
 		using index_t=uint8_t;

src/TinyMqtt.cpp

@@ -19,6 +19,7 @@ MqttBroker::~MqttBroker()
 	{
 		delete clients[0];
 	}
+	server.close();
 }
 
 // private constructor used by broker only
@@ -29,8 +30,8 @@ MqttClient::MqttClient(MqttBroker* parent, WiFiClient& new_client)
 	alive = millis()+5000;	// client expires after 5s if no CONNECT msg
 }
 
-MqttClient::MqttClient(MqttBroker* parent)
+MqttClient::MqttClient(MqttBroker* parent, const std::string& id)
-	: parent(parent)
+	: parent(parent), clientId(id)
 {
 		client = nullptr;
 

src/TinyMqtt.h

@@ -120,9 +120,8 @@ class MqttClient
 		FlagReserved = 1
 	};
 	public:
-		MqttClient(MqttBroker*);
+		MqttClient(MqttBroker* brk = nullptr, const std::string& id="");
-		MqttClient(MqttBroker* brk, const std::string& id) : MqttClient(brk) { clientId=id; }
+		MqttClient(const std::string& id) : MqttClient(nullptr, id){}
-		MqttClient() : MqttClient(nullptr) {};
 
 		~MqttClient();
 
@@ -158,9 +157,8 @@ class MqttClient
 		void dump()
 		{
 			uint32_t ms=millis();
-			Serial << "MqttClient (" << clientId.c_str() << ") p=" << (uint64_t) parent
+			Serial << "MqttClient (" << clientId.c_str() << ") " << (connected() ? " ON " : " OFF");
-				<< " c=" << (uint64_t)client << (connected() ? " ON " : " OFF");
+			Serial << ", alive=" << alive << '/' << ms << ", ka=" << keep_alive;
-			Serial << ", alive=" << (uint32_t)alive << '/' << ms << ", ka=" << keep_alive;
 			Serial << (client && client->connected() ? "" : "dis") << "connected";
             message.hexdump("entrant msg");
 			bool c=false;
@@ -222,9 +220,9 @@ class MqttBroker
 		void begin() { server.begin(); }
 		void loop();
 
-		uint8_t port() const { return server.port(); }
+		uint16_t port() const { return server.port(); }
 
-		void connect(std::string host, uint32_t port=1883);
+		void connect(std::string host, uint16_t port=1883);
 		bool connected() const { return state == Connected; }
 
 		size_t clientsCount() const { return clients.size(); }

tests/local-tests/local-tests.ino

@@ -5,7 +5,10 @@
 /**
 	* TinyMqtt local unit tests.
 	*
-	* No wifi connection unit tests.
+	* Clients are connected to pseudo remote broker
+	* The remote will be 127.0.0.1:1883
+	* We are using 127.0.0.1 because this is simpler to test with a single ESP
+	* Also, this will allow to mock and thus run Action on github
 	**/
 
 using namespace std;
@@ -22,19 +25,23 @@ void onPublish(const MqttClient* srce, const Topic& topic, const char* payload,
 
 test(local_client_should_unregister_when_destroyed)
 {
+return;
 	assertEqual(broker.clientsCount(), (size_t)0);
 	{
-		MqttClient client(&broker);
+		MqttClient client;
-		assertEqual(broker.clientsCount(), (size_t)1);
+		assertEqual(broker.clientsCount(), (size_t)0);	// Ensure client is not yet connected
+		client.connect("127.0.0.1", 1883);
+		assertEqual(broker.clientsCount(), (size_t)1);	// Ensure client is now connected
 	}
 	assertEqual(broker.clientsCount(), (size_t)0);
 }
 
+#if 0
 test(local_connect)
 {
 	assertEqual(broker.clientsCount(), (size_t)0);
 
-	MqttClient client(&broker);
+	MqttClient client;
 	assertTrue(client.connected());
 	assertEqual(broker.clientsCount(), (size_t)1);
 }
@@ -44,12 +51,12 @@ test(local_publish_should_be_dispatched)
 	published.clear();
 	assertEqual(broker.clientsCount(), (size_t)0);
 
-	MqttClient subscriber(&broker);
+	MqttClient subscriber;
 	subscriber.subscribe("a/b");
 	subscriber.subscribe("a/c");
 	subscriber.setCallback(onPublish);
 
-	MqttClient publisher(&broker);
+	MqttClient publisher;
 	publisher.publish("a/b");
 	publisher.publish("a/c");
 	publisher.publish("a/c");
@@ -64,16 +71,16 @@ test(local_publish_should_be_dispatched_to_local_clients)
 	published.clear();
 	assertEqual(broker.clientsCount(), (size_t)0);
 
-	MqttClient subscriber_a(&broker, "A");
+	MqttClient subscriber_a("A");
 	subscriber_a.setCallback(onPublish);
 	subscriber_a.subscribe("a/b");
 	subscriber_a.subscribe("a/c");
 
-	MqttClient subscriber_b(&broker, "B");
+	MqttClient subscriber_b("B");
 	subscriber_b.setCallback(onPublish);
 	subscriber_b.subscribe("a/b");
 
-	MqttClient publisher(&broker);
+	MqttClient publisher;
 	publisher.publish("a/b");
 	publisher.publish("a/c");
 
@@ -89,11 +96,11 @@ test(local_unsubscribe)
 	published.clear();
 	assertEqual(broker.clientsCount(), (size_t)0);
 
-	MqttClient subscriber(&broker);
+	MqttClient subscriber;
 	subscriber.setCallback(onPublish);
 	subscriber.subscribe("a/b");
 
-	MqttClient publisher(&broker);
+	MqttClient publisher;
 	publisher.publish("a/b");
 
 	subscriber.unsubscribe("a/b");
@@ -109,17 +116,19 @@ test(local_nocallback_when_destroyed)
 	published.clear();
 	assertEqual(broker.clientsCount(), (size_t)0);
 
+	MqttClient publisher;
 	{
-		MqttClient subscriber(&broker);
+		MqttClient subscriber;
 		subscriber.setCallback(onPublish);
 		subscriber.subscribe("a/b");
+		publisher.publish("a/b");
 	}
 
-	MqttClient publisher(&broker);
 	publisher.publish("a/b");
 
-	assertEqual(published.size(), (size_t)0);	// Only one publish has been received
+	assertEqual(published.size(), (size_t)1);	// Only one publish has been received
 }
+#endif
 
 //----------------------------------------------------------------------------
 // setup() and loop()

tests/nowifi-tests/Makefile

@@ -0,0 +1,6 @@
+# See https://github.com/bxparks/EpoxyDuino for documentation about this
+# Makefile to compile and run Arduino programs natively on Linux or MacOS.
+
+APP_NAME := nowifi-tests
+ARDUINO_LIBS := AUnit AceCommon AceTime TinyMqtt EspMock
+include ../../../EpoxyDuino/EpoxyDuino.mk

tests/nowifi-tests/nowifi-tests.ino

@@ -0,0 +1,141 @@
+#include <AUnit.h>
+#include <TinyMqtt.h>
+#include <map>
+
+/**
+  * TinyMqtt nowifi unit tests.
+	*
+	* No wifi connection unit tests.
+    * Checks with a local broker. Clients must connect to the local client
+	**/
+
+using namespace std;
+
+MqttBroker broker(1883);
+
+std::map<std::string, std::map<Topic, int>>	published;		// map[client_id] => map[topic] = count
+
+void onPublish(const MqttClient* srce, const Topic& topic, const char* payload, size_t length)
+{
+	if (srce)
+		published[srce->id()][topic]++;
+}
+
+test(nowifi_client_should_unregister_when_destroyed)
+{
+	assertEqual(broker.clientsCount(), (size_t)0);
+	{
+		MqttClient client(&broker);
+		assertEqual(broker.clientsCount(), (size_t)1);
+	}
+	assertEqual(broker.clientsCount(), (size_t)0);
+}
+
+test(nowifi_connect)
+{
+	assertEqual(broker.clientsCount(), (size_t)0);
+
+	MqttClient client(&broker);
+	assertTrue(client.connected());
+	assertEqual(broker.clientsCount(), (size_t)1);
+}
+
+test(nowifi_publish_should_be_dispatched)
+{
+	published.clear();
+	assertEqual(broker.clientsCount(), (size_t)0);
+
+	MqttClient subscriber(&broker);
+	subscriber.subscribe("a/b");
+	subscriber.subscribe("a/c");
+	subscriber.setCallback(onPublish);
+
+	MqttClient publisher(&broker);
+	publisher.publish("a/b");
+	publisher.publish("a/c");
+	publisher.publish("a/c");
+
+	assertEqual(published.size(), (size_t)1);	// 1 client has received something
+	assertTrue(published[""]["a/b"] == 1);
+	assertTrue(published[""]["a/c"] == 2);
+}
+
+test(nowifi_publish_should_be_dispatched_to_nowifi_clients)
+{
+	published.clear();
+	assertEqual(broker.clientsCount(), (size_t)0);
+
+	MqttClient subscriber_a(&broker, "A");
+	subscriber_a.setCallback(onPublish);
+	subscriber_a.subscribe("a/b");
+	subscriber_a.subscribe("a/c");
+
+	MqttClient subscriber_b(&broker, "B");
+	subscriber_b.setCallback(onPublish);
+	subscriber_b.subscribe("a/b");
+
+	MqttClient publisher(&broker);
+	publisher.publish("a/b");
+	publisher.publish("a/c");
+
+	assertEqual(published.size(), (size_t)2);	// 2 clients have received something
+	assertTrue(published["A"]["a/b"] == 1);
+	assertTrue(published["A"]["a/c"] == 1);
+	assertTrue(published["B"]["a/b"] == 1);
+	assertTrue(published["B"]["a/c"] == 0);
+}
+
+test(nowifi_unsubscribe)
+{
+	published.clear();
+	assertEqual(broker.clientsCount(), (size_t)0);
+
+	MqttClient subscriber(&broker);
+	subscriber.setCallback(onPublish);
+	subscriber.subscribe("a/b");
+
+	MqttClient publisher(&broker);
+	publisher.publish("a/b");
+
+	subscriber.unsubscribe("a/b");
+
+	publisher.publish("a/b");
+	publisher.publish("a/b");
+
+	assertTrue(published[""]["a/b"] == 1);	// Only one publish has been received
+}
+
+test(nowifi_nocallback_when_destroyed)
+{
+	published.clear();
+	assertEqual(broker.clientsCount(), (size_t)0);
+
+	MqttClient publisher(&broker);
+
+	{
+		MqttClient subscriber(&broker);
+		subscriber.setCallback(onPublish);
+		subscriber.subscribe("a/b");
+		publisher.publish("a/b");
+	}
+
+	publisher.publish("a/b");
+
+	assertEqual(published.size(), (size_t)1);	// Only one publish has been received
+}
+
+//----------------------------------------------------------------------------
+// setup() and loop()
+void setup() {
+	delay(1000);
+	Serial.begin(115200);
+	while(!Serial);
+
+	Serial.println("=============[ NO WIFI CONNECTION TinyMqtt TESTS ]========================");
+}
+
+void loop() {
+	aunit::TestRunner::run();
+
+	if (Serial.available()) ESP.reset();
+}

tests/result.json

@@ -0,0 +1,6 @@
+{
+    "schemaVersion" : 1,
+    "label" : "tests",
+    "message" : "Message content",
+    "color": "red"
+}

tests/result.yaml

@@ -0,0 +1,2 @@
+result: 1
+insert: "passed"