Added stream command using simple syntax.

Author: ed7coyne

modem/commands.h

@@ -66,6 +66,13 @@ class BeginCommand : public Command {
   std::unique_ptr<Firebase> new_firebase_;
 };
 
+class StreamCommand : public Command {
+ public:
+  StreamCommand(Firebase* fbase) : Command(fbase) {}
+
+  bool execute(const String& command, InputStream* in, OutputStream* out);
+};
+
 }  // modem
 }  // firebase
 

modem/input-stream.h

@@ -12,6 +12,7 @@ class InputStream {
   // This call consumes the terminator.
   virtual String readStringUntil(const char terminator) = 0;
   virtual void drain() = 0;
+  virtual bool available() = 0;
 };
 
 class ArduinoInputStream : public InputStream {
@@ -35,6 +36,10 @@ class ArduinoInputStream : public InputStream {
     }
   }
 
+  bool available() {
+    return stream_->available();
+  }
+
  private:
   Stream* stream_;
 };

modem/output-stream.h

@@ -10,6 +10,7 @@ namespace modem {
 class OutputStream {
  public:
   virtual int println(const String& string) = 0;
+  virtual int println(const int value) = 0;
   virtual int print(const String& string) = 0;
 };
 
@@ -21,6 +22,10 @@ class ArduinoOutputStream : public OutputStream {
     return stream_->println(string.c_str());
   }
 
+  int println(const int value) override {
+    return stream_->println(value);
+  }
+
   int print(const String& string) override {
     return stream_->print(string.c_str());
   }

modem/stream-command.cpp

@@ -0,0 +1,50 @@
+#include "modem/commands.h"
+
+namespace firebase {
+namespace modem {
+
+bool StreamCommand::execute(const String& command,
+                            InputStream* in, OutputStream* out) {
+  if (in == nullptr || out == nullptr) {
+    return false;
+  }
+
+  if (command != "BEGIN_STREAM") {
+    return false;
+  }
+
+  String path = in->readLine();
+  std::unique_ptr<FirebaseStream> stream(fbase().streamPtr(path));
+
+  if (stream->error()) {
+    out->print("-FAIL ");
+    out->println(stream->error().message());
+    return false;
+  }
+
+  bool running = true;
+  while(running) {
+    if (stream->available()) {
+      String json;
+      FirebaseStream::Event event = stream->read(json);
+      out->print("+");
+      out->print(FirebaseStream::EventToName(event) + " ");
+      // TODO(edcoyne): add json parsing and get real path.
+      out->println("/dummy/path");
+      out->println(json.length());
+      out->println(json);
+    } else if (in->available()) {
+      String command = in->readLine();
+      if (command == "END_STREAM") {
+        running = false;
+      } else {
+        out->println("-FAIL Cannot call any command but END_STREAM.");
+      }
+    }
+  }
+
+  return true;
+}
+
+}  // modem
+}  // firebase

modem/test/Makefile

@@ -48,7 +48,7 @@ CXXFLAGS += -g -Wall -Wextra -pthread -std=c++11
 # All tests produced by this Makefile.  Remember to add new tests you
 # created to the list.
 TESTS = get-command_test set-command_test remove-command_test \
-	push-command_test begin-command_test
+	push-command_test begin-command_test stream-command_test
 
 # All Google Test headers.  Usually you shouldn't change this
 # definition.
@@ -183,4 +183,13 @@ begin-command_test : begin-command.o begin-command_test.o Firebase.o FirebaseHtt
 		arduino_mock_all.a
 	$(CXX) $(CPPFLAGS) $(CXXFLAGS) -lpthread $^ -o $@
 
+stream-command.o : $(PROJECT_ROOT)/modem/stream-command.cpp
+	$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(PROJECT_ROOT)/modem/stream-command.cpp
+
+stream-command_test.o : $(TEST_DIR)/stream-command_test.cpp $(GMOCK_HEADERS)
+	$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $(TEST_DIR)/stream-command_test.cpp
+
+stream-command_test : stream-command.o stream-command_test.o Firebase.o FirebaseHttpClient_dummy.o gmock_main.a \
+		arduino_mock_all.a
+	$(CXX) $(CPPFLAGS) $(CXXFLAGS) -lpthread $^ -o $@
 

modem/test/begin-command_test.cpp

@@ -12,6 +12,7 @@ using ::testing::Return;
 using ::testing::ByMove;
 using ::testing::ReturnRef;
 using ::testing::StartsWith;
+using ::testing::Matcher;
 using ::testing::_;
 
 class BeginCommandTest : public ::testing::Test {
@@ -32,7 +33,9 @@ class BeginCommandTest : public ::testing::Test {
   }
 
   void ExpectOutputStartsWith(const String& output) {
-    EXPECT_CALL(out_, println(StartsWith(output)))
+    // We have to be explicit here due to the polymorphic nature of println().
+    const Matcher<const String&> matcher = StartsWith(output);
+    EXPECT_CALL(out_, println(matcher))
         .WillOnce(Return(3));
   }
 

modem/test/mock-input-stream.h

@@ -12,6 +12,7 @@ class MockInputStream : public InputStream {
   MOCK_METHOD0(readLine, String ());
   MOCK_METHOD1(readStringUntil, String (const char));
   MOCK_METHOD0(drain, void ());
+  MOCK_METHOD0(available, bool ());
 };
 
 }  // modem

modem/test/mock-output-stream.h

@@ -10,6 +10,7 @@ namespace modem {
 class MockOutputStream : public OutputStream {
  public:
   MOCK_METHOD1(println, int (const String&));
+  MOCK_METHOD1(println, int (const int));
   MOCK_METHOD1(print, int (const String&));
 };
 

modem/test/stream-command_test.cpp

@@ -0,0 +1,91 @@
+#include "Firebase.h"
+#include "gtest/gtest.h"
+#include "modem/commands.h"
+#include "modem/test/mock-input-stream.h"
+#include "modem/test/mock-output-stream.h"
+#include "test/mock-firebase.h"
+
+namespace firebase {
+namespace modem {
+
+using ::testing::Return;
+using ::testing::Invoke;
+using ::testing::ByMove;
+using ::testing::ReturnRef;
+using ::testing::_;
+
+class StreamCommandTest : public ::testing::Test {
+ protected:
+  void SetUp() override {
+    stream_.reset(new MockFirebaseStream());
+  }
+
+  bool RunCommand(const FirebaseError& error) {
+    EXPECT_CALL(*stream_, error())
+      .WillRepeatedly(ReturnRef(error));
+
+    EXPECT_CALL(fbase_, streamPtr(_))
+        .WillOnce(Return(ByMove(std::move(stream_))));
+
+    StreamCommand cmd(&fbase_);
+    return cmd.execute("BEGIN_STREAM", &in_, &out_);
+  }
+
+  MockInputStream in_;
+  MockOutputStream out_;
+  MockFirebase fbase_;
+  std::unique_ptr<MockFirebaseStream> stream_;
+};
+
+TEST_F(StreamCommandTest, streams) {
+  const String path("/test/path");
+  EXPECT_CALL(in_, available())
+      .WillRepeatedly(Return(true));
+
+  EXPECT_CALL(in_, readLine())
+      .WillOnce(Return(path))
+      .WillOnce(Return("END_STREAM"));
+
+
+  const String value("Test value");
+  EXPECT_CALL(*stream_, available())
+      .WillOnce(Return(true))
+      .WillRepeatedly(Return(false));
+
+  EXPECT_CALL(*stream_, read(_))
+      .WillOnce(Invoke([&value](String& json) {
+        json = value;
+        return FirebaseStream::PUT;
+      }));
+
+  EXPECT_CALL(out_, print(String("+")))
+      .WillOnce(Return(1));
+  EXPECT_CALL(out_, print(String("PUT ")))
+      .WillOnce(Return(1));
+  EXPECT_CALL(out_, println(String("/dummy/path")))
+      .WillOnce(Return(1));
+
+  EXPECT_CALL(out_, println(value.length()))
+      .WillOnce(Return(1));
+  EXPECT_CALL(out_, println(value))
+      .WillOnce(Return(1));
+
+  ASSERT_TRUE(RunCommand(FirebaseError()));
+}
+
+TEST_F(StreamCommandTest, handlesError) {
+  FirebaseError error(-200, "Test Error.");
+  const String path("/test/path");
+  EXPECT_CALL(in_, readLine())
+      .WillOnce(Return(path));
+
+  EXPECT_CALL(out_, print(String("-FAIL ")))
+      .WillOnce(Return(1));
+
+  EXPECT_CALL(out_, println(error.message()))
+      .WillOnce(Return(1));
+  ASSERT_FALSE(RunCommand(error));
+}
+
+}  // modem
+}  // firebase