Untested initial command with tests

Add tests

Added gmock/gtest submodules

Revert "Added gmock/gtest submodules"

This reverts commit b975f3b.

found out googlemock and googletest are now merged, only need one.

Added googletest submodule

Added *Ptr methods to firebase, get test mostly compiling

Broke FirebaseHttpClient out from Firebase to allow greater portability and testability.

re check in commands and add input stream

Working local command test

Added base test for set

Added base test for set (actually this time)

Cleanup set test and add error test

Clean up get test and added failure handling

Added remove command and test

Added push command and test

Minor cleanup to set test

Added begin command and test

Fixed all tests operating on the assumption that readLine() included the \r\n

Author: ed7coyne

FirebaseHttpClient.h

@@ -2,6 +2,11 @@
 #define FIREBASE_HTTP_CLIENT_H
 
 #include "Arduino.h"
+#include "Stream.h"
+
+struct HttpStatus {
+  static const int TEMPORARY_REDIRECT = 302;
+};
 
 class FirebaseHttpClient {
  public:
@@ -14,7 +19,7 @@ class FirebaseHttpClient {
   virtual void end() = 0;
 
   virtual void addHeader(const String& name, const String& value) = 0;
-  virtual void collectHeaders(const String[]& header_keys,
+  virtual void collectHeaders(const String header_keys[],
                               const int header_key_count) = 0;
   virtual String header(const String& name) = 0;
 
@@ -27,9 +32,10 @@ class FirebaseHttpClient {
   virtual String errorToString(int error_code) = 0;
 
  protected:
-  static final String kFirebaseFingerprint = "7A 54 06 9B DC 7A 25 B3 86 8D 66 53 48 2C 0B 96 42 C7 B3 0A";
-  static final const uint16_t kFirebasePort = 443;
-}
+  static const uint16_t kFirebasePort = 443;
+};
 
+static const String kFirebaseFingerprint =
+      "7A 54 06 9B DC 7A 25 B3 86 8D 66 53 48 2C 0B 96 42 C7 B3 0A";
 
 #endif  // FIREBASE_HTTP_CLIENT_H

FirebaseHttpClient_Esp8266.cpp

@@ -66,7 +66,7 @@ class FirebaseHttpClientEsp8266 : public FirebaseHttpClient {
 
  private:
   HTTPClient http_;
-}
+};
 
 Firebase* FirebaseHttpClient::create() {
   return new FirebaseHttpClientEsp8266();

FirebaseHttpClient_dummy.cpp

@@ -1,31 +1,36 @@
+#ifdef __GNUC__
+#  define UNUSED_ARG(x) UNUSED_ ## x __attribute__((__unused__))
+#else
+#  define UNUSED_ARG(x) UNUSED_ ## x
+#endif
 
 #include "FirebaseHttpClient.h"
 
 class FirebaseHttpClientDummy : public FirebaseHttpClient {
  public:
-  void SetReuseConnection(bool reuse) override {
+  void setReuseConnection(bool UNUSED_ARG(reuse)) override {
   }
 
-  void begin(const String& url) override {
+  void begin(const String& UNUSED_ARG(url)) override {
   }
 
-  void begin(const String& host, const String& path) override {
+  void begin(const String& UNUSED_ARG(host), const String& UNUSED_ARG(path)) override {
   }
 
   void end() override {
   }
 
-  void addHeader(const String& name, const String& value) override {
+  void addHeader(const String& UNUSED_ARG(name), const String& UNUSED_ARG(value)) override {
   }
 
-  void collectHeaders(const String[]& header_keys, const int count) override {
+  void collectHeaders(const String UNUSED_ARG(header_keys[]), const int UNUSED_ARG(count)) override {
   }
 
-  String header(const String& name) override {
+  String header(const String& UNUSED_ARG(name)) override {
     return "";
   }
 
-  int sendRequest(const String& method, const String& data) override {
+  int sendRequest(const String& UNUSED_ARG(method), const String& UNUSED_ARG(data)) override {
     return 0;
   }
 
@@ -34,15 +39,15 @@ class FirebaseHttpClientDummy : public FirebaseHttpClient {
   }
 
   Stream* getStreamPtr() override {
-    return http_.getStreamPtr();
+    return nullptr;
   }
 
-  String errorToStream(int error_code) override {
-     return  String(status);
+  String errorToString(int UNUSED_ARG(error_code)) override {
+     return String();
   }
-}
+};
 
-Firebase* FirebaseHttpClient::create() {
+FirebaseHttpClient* FirebaseHttpClient::create() {
   return new FirebaseHttpClientDummy();
 }
 

modem/begin-command.cc

@@ -0,0 +1,52 @@
+#include "modem/commands.h"
+
+namespace firebase {
+namespace modem {
+
+bool BeginCommand::execute(const String& command,
+                         InputStream* in, OutputStream* out) {
+  if (in == nullptr || out == nullptr) {
+    return false;
+  }
+
+  if (command != "BEGIN") {
+    return false;
+  }
+
+  String host;
+  String auth;
+
+  String data(in->readLine());
+  // Remove leading ' '.
+  data = data.substring(1);
+
+  int space_index = data.indexOf(' ');
+  if (space_index == -1) {
+    // host only.
+    host = data;
+  } else {
+    // host and auth.
+    host = data.substr(0, space_index);
+    auth = data.substr(space_index + 1);
+  }
+
+  if (host.empty()) {
+    out->println("-FAIL Missing host");
+    return false;
+  }
+
+  new_firebase_.reset(new Firebase(host));
+  if (!auth.empty()) {
+    new_firebase_->auth(auth);
+  }
+
+  out->println("+OK");
+  return true;
+}
+
+std::unique_ptr<Firebase> BeginCommand::firebase() {
+  return std::move(new_firebase_);
+}
+
+}  // modem
+}  // firebase

modem/commands.h

@@ -0,0 +1,72 @@
+#ifndef MODEM_COMMAND_H
+#define MODEM_COMMAND_H
+
+#include "Firebase.h"
+#include "modem/output-stream.h"
+#include "modem/input-stream.h"
+
+namespace firebase {
+namespace modem {
+
+class Command {
+ public:
+  Command(Firebase* fbase) : fbase_(fbase) {}
+
+  // Execute command, reading any additional data needed from stream.
+  // Return false if execution failed.
+  virtual bool execute(const String& command,
+                       InputStream* in, OutputStream* out) = 0;
+ protected:
+  Firebase& fbase() {
+    return *fbase_;
+  }
+
+ private:
+  Firebase* fbase_;
+};
+
+class GetCommand : public Command {
+ public:
+  GetCommand(Firebase* fbase) : Command(fbase) {}
+
+  bool execute(const String& command, InputStream* in, OutputStream* out);
+};
+
+class SetCommand : public Command {
+ public:
+  SetCommand(Firebase* fbase) : Command(fbase) {}
+
+  bool execute(const String& command, InputStream* in, OutputStream* out);
+};
+
+class RemoveCommand : public Command {
+ public:
+  RemoveCommand(Firebase* fbase) : Command(fbase) {}
+
+  bool execute(const String& command, InputStream* in, OutputStream* out);
+};
+
+class PushCommand : public Command {
+ public:
+  PushCommand(Firebase* fbase) : Command(fbase) {}
+
+  bool execute(const String& command, InputStream* in, OutputStream* out);
+};
+
+class BeginCommand : public Command {
+ public:
+  BeginCommand() : Command(nullptr) {}
+
+  bool execute(const String& command, InputStream* in, OutputStream* out);
+
+  // This can only be called once.
+  std::unique_ptr<Firebase> firebase();
+
+ private:
+  std::unique_ptr<Firebase> new_firebase_;
+};
+
+}  // modem
+}  // firebase
+
+#endif //MODEM_COMMAND_H

modem/get-command.cc

@@ -14,13 +14,18 @@ bool GetCommand::execute(const String& command,
   }
 
   String path = in->readLine();
-  std::unique_ptr<FirebaseGet> get = fbase().getPtr(path);
+  std::unique_ptr<FirebaseGet> get(fbase().getPtr(path));
 
-  String value = get->json();
+  if (get->error()) {
+    out->print("-FAIL ");
+    out->println(get->error().message());
+    return false;
+  }
+
+  String value(get->json());
   // TODO implement json parsing to pull and process value.
   out->print("+");
   out->println(value);
-
   return true;
 }
 

modem/input-stream.h

@@ -0,0 +1,38 @@
+#ifndef MODEM_INPUT_STREAM_H
+#define MODEM_INPUT_STREAM_H
+
+namespace firebase {
+namespace modem {
+
+class InputStream {
+ public:
+  virtual String readLine() = 0;
+  virtual String readStringUntil(const char terminator) = 0;
+};
+
+class SerialInputStream : public InputStream {
+ public:
+  String readLine() override {
+    String out = Serial.readStringUntil('\r');
+    if (Serial.peek() == '\n') {
+      // This should be a '\n' so drop it.
+      Serial.read();
+    } else {
+      // Add \r back, this is not our endline.
+      out += '\r';
+
+      // Recurse until \r\n
+      out += readLine();
+    }
+    return out;
+  }
+  String readStringUntil(const char terminator) {
+    return Serial.readStringUntil(terminator);
+  }
+};
+
+}  // modem
+}  // firebase
+
+#endif  // MODEM_INPUT_STREAM_H
+

modem/push-command.cc

@@ -0,0 +1,37 @@
+#include "modem/commands.h"
+
+namespace firebase {
+namespace modem {
+
+bool PushCommand::execute(const String& command,
+                         InputStream* in, OutputStream* out) {
+  if (in == nullptr || out == nullptr) {
+    return false;
+  }
+
+  if (command != "SET") {
+    return false;
+  }
+
+  String path(in->readStringUntil(' '));
+  String data(in->readLine());
+
+  // First char will be a ' ', drop it.
+  data = data.substring(1);
+
+  // TODO(ed7coyne): encode data as json.
+
+  std::unique_ptr<FirebasePush> push(fbase().pushPtr(path, data));
+
+  if (push->error()) {
+    out->print("-FAIL ");
+    out->println(push->error().message());
+    return false;
+  } else {
+    out->println("+OK");
+    return true;
+  }
+}
+
+}  // modem
+}  // firebase

modem/remove-command.cc

@@ -0,0 +1,30 @@
+#include "modem/commands.h"
+
+namespace firebase {
+namespace modem {
+
+bool RemoveCommand::execute(const String& command,
+                            InputStream* in, OutputStream* out) {
+  if (in == nullptr || out == nullptr) {
+    return false;
+  }
+
+  if (command != "REMOVE") {
+    return false;
+  }
+
+  String path = in->readLine();
+  std::unique_ptr<FirebaseRemove> get(fbase().removePtr(path));
+
+  if (get->error()) {
+    out->print("-FAIL ");
+    out->println(get->error().message());
+    return false;
+  }
+
+  out->print("+OK");
+  return true;
+}
+
+}  // modem
+}  // firebase