Telegram: initial commit

- tdlib moved to telegram dir

1 files changed, 837 insertions, 0 deletions

diff --git a/protocols/Telegram/tdlib/td/test/tdclient.cpp b/protocols/Telegram/tdlib/td/test/tdclient.cpp
new file mode 100644
index 0000000000..7cef0fcbc0
--- /dev/null
+++ b/protocols/Telegram/tdlib/td/test/tdclient.cpp
@@ -0,0 +1,837 @@
+//
+// Copyright Aliaksei Levin (levlam@telegram.org), Arseny Smirnov (arseny30@gmail.com) 2014-2018
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+#include "data.h"
+
+#include "td/actor/PromiseFuture.h"
+
+#include "td/telegram/ClientActor.h"
+
+#include "td/telegram/td_api.h"
+
+#include "td/utils/base64.h"
+#include "td/utils/BufferedFd.h"
+#include "td/utils/filesystem.h"
+#include "td/utils/format.h"
+#include "td/utils/logging.h"
+#include "td/utils/misc.h"
+#include "td/utils/port/FileFd.h"
+#include "td/utils/port/path.h"
+#include "td/utils/Random.h"
+#include "td/utils/Slice.h"
+#include "td/utils/Status.h"
+#include "td/utils/tests.h"
+
+#include <cstdio>
+#include <functional>
+#include <map>
+#include <memory>
+#include <utility>
+
+REGISTER_TESTS(tdclient);
+
+namespace td {
+
+template <class T>
+static void check_td_error(T &result) {
+  CHECK(result->get_id() != td_api::error::ID) << to_string(result);
+}
+
+static void rmrf(CSlice path) {
+  td::walk_path(path, [](CSlice path, bool is_dir) {
+    if (is_dir) {
+      td::rmdir(path).ignore();
+    } else {
+      td::unlink(path).ignore();
+    }
+  });
+}
+
+class TestClient : public Actor {
+ public:
+  explicit TestClient(string name) : name_(std::move(name)) {
+  }
+  struct Update {
+    uint64 id;
+    tl_object_ptr<td_api::Object> object;
+    Update(uint64 id, tl_object_ptr<td_api::Object> object) : id(id), object(std::move(object)) {
+    }
+  };
+  class Listener {
+   public:
+    Listener() = default;
+    Listener(const Listener &) = delete;
+    Listener &operator=(const Listener &) = delete;
+    Listener(Listener &&) = delete;
+    Listener &operator=(Listener &&) = delete;
+    virtual ~Listener() = default;
+    virtual void start_listen(TestClient *client) {
+    }
+    virtual void stop_listen() {
+    }
+    virtual void on_update(std::shared_ptr<Update> update) = 0;
+  };
+  void close(Promise<> close_promise) {
+    close_promise_ = std::move(close_promise);
+    td_.reset();
+  }
+
+  unique_ptr<TdCallback> make_td_callback() {
+    class TdCallbackImpl : public TdCallback {
+     public:
+      explicit TdCallbackImpl(ActorId<TestClient> client) : client_(client) {
+      }
+      void on_result(uint64 id, tl_object_ptr<td_api::Object> result) override {
+        send_closure(client_, &TestClient::on_result, id, std::move(result));
+      }
+      void on_error(uint64 id, tl_object_ptr<td_api::error> error) override {
+        send_closure(client_, &TestClient::on_error, id, std::move(error));
+      }
+      void on_closed() override {
+        send_closure(client_, &TestClient::on_closed);
+      }
+
+     private:
+      ActorId<TestClient> client_;
+    };
+    return make_unique<TdCallbackImpl>(actor_id(this));
+  }
+
+  void add_listener(std::unique_ptr<Listener> listener) {
+    auto *ptr = listener.get();
+    listeners_.push_back(std::move(listener));
+    ptr->start_listen(this);
+  }
+  void remove_listener(Listener *listener) {
+    pending_remove_.push_back(listener);
+  }
+  void do_pending_remove_listeners() {
+    for (auto listener : pending_remove_) {
+      do_remove_listener(listener);
+    }
+    pending_remove_.clear();
+  }
+  void do_remove_listener(Listener *listener) {
+    for (size_t i = 0; i < listeners_.size(); i++) {
+      if (listeners_[i].get() == listener) {
+        listener->stop_listen();
+        listeners_.erase(listeners_.begin() + i);
+        break;
+      }
+    }
+  }
+
+  void on_result(uint64 id, tl_object_ptr<td_api::Object> result) {
+    on_update(std::make_shared<Update>(id, std::move(result)));
+  }
+  void on_error(uint64 id, tl_object_ptr<td_api::error> error) {
+    on_update(std::make_shared<Update>(id, std::move(error)));
+  }
+  void on_update(std::shared_ptr<Update> update) {
+    for (auto &listener : listeners_) {
+      listener->on_update(update);
+    }
+    do_pending_remove_listeners();
+  }
+
+  void on_closed() {
+    stop();
+  }
+
+  void start_up() override {
+    rmrf(name_);
+    set_context(std::make_shared<td::ActorContext>());
+    set_tag(name_);
+    LOG(INFO) << "START UP!";
+
+    td_ = create_actor<ClientActor>("Td-proxy", make_td_callback());
+  }
+
+  ActorOwn<ClientActor> td_;
+
+  string name_;
+
+ private:
+  std::vector<std::unique_ptr<Listener>> listeners_;
+  std::vector<Listener *> pending_remove_;
+
+  Promise<> close_promise_;
+};
+
+class Task : public TestClient::Listener {
+ public:
+  void on_update(std::shared_ptr<TestClient::Update> update) override {
+    auto it = sent_queries_.find(update->id);
+    if (it != sent_queries_.end()) {
+      it->second(std::move(update->object));
+      sent_queries_.erase(it);
+    }
+    process_update(update);
+  }
+  void start_listen(TestClient *client) override {
+    client_ = client;
+    start_up();
+  }
+  virtual void process_update(std::shared_ptr<TestClient::Update> update) {
+  }
+
+  template <class F>
+  void send_query(tl_object_ptr<td_api::Function> function, F callback) {
+    auto id = current_query_id_++;
+    sent_queries_[id] = std::forward<F>(callback);
+    send_closure(client_->td_, &ClientActor::request, id, std::move(function));
+  }
+
+ protected:
+  std::map<uint64, std::function<void(tl_object_ptr<td_api::Object>)>> sent_queries_;
+  TestClient *client_;
+  uint64 current_query_id_ = 1;
+
+  virtual void start_up() {
+  }
+  void stop() {
+    client_->remove_listener(this);
+  }
+};
+
+class DoAuthentication : public Task {
+ public:
+  DoAuthentication(string name, string phone, string code, Promise<> promise)
+      : name_(std::move(name)), phone_(std::move(phone)), code_(std::move(code)), promise_(std::move(promise)) {
+  }
+  void start_up() override {
+    send_query(make_tl_object<td_api::getAuthorizationState>(),
+               [this](auto res) { this->process_authorization_state(std::move(res)); });
+  }
+  void process_authorization_state(tl_object_ptr<td_api::Object> authorization_state) {
+    start_flag_ = true;
+    tl_object_ptr<td_api::Function> function;
+    switch (authorization_state->get_id()) {
+      case td_api::authorizationStateWaitEncryptionKey::ID:
+        function = make_tl_object<td_api::checkDatabaseEncryptionKey>();
+        break;
+      case td_api::authorizationStateWaitPhoneNumber::ID:
+        function = make_tl_object<td_api::setAuthenticationPhoneNumber>(phone_, false, true);
+        break;
+      case td_api::authorizationStateWaitCode::ID:
+        function = make_tl_object<td_api::checkAuthenticationCode>(code_, name_, "");
+        break;
+      case td_api::authorizationStateWaitTdlibParameters::ID: {
+        auto parameters = td_api::make_object<td_api::tdlibParameters>();
+        parameters->use_test_dc_ = true;
+        parameters->database_directory_ = name_ + TD_DIR_SLASH;
+        parameters->use_message_database_ = true;
+        parameters->use_secret_chats_ = true;
+        parameters->api_id_ = 94575;
+        parameters->api_hash_ = "a3406de8d171bb422bb6ddf3bbd800e2";
+        parameters->system_language_code_ = "en";
+        parameters->device_model_ = "Desktop";
+        parameters->system_version_ = "Unknown";
+        parameters->application_version_ = "tdclient-test";
+        parameters->ignore_file_names_ = false;
+        parameters->enable_storage_optimizer_ = true;
+        function = td_api::make_object<td_api::setTdlibParameters>(std::move(parameters));
+        break;
+      }
+      case td_api::authorizationStateReady::ID:
+        on_authorization_ready();
+        return;
+      default:
+        CHECK(false) << "Unexpected authorization state " << to_string(authorization_state);
+    }
+    send_query(std::move(function), [this](auto res) { CHECK(res->get_id() == td_api::ok::ID) << to_string(res); });
+  }
+  void on_authorization_ready() {
+    LOG(INFO) << "GOT AUTHORIZED";
+    stop();
+  }
+
+ private:
+  string name_;
+  string phone_;
+  string code_;
+  Promise<> promise_;
+  bool start_flag_{false};
+  void process_update(std::shared_ptr<TestClient::Update> update) override {
+    if (!start_flag_) {
+      return;
+    }
+    if (!update->object) {
+      return;
+    }
+    if (update->object->get_id() == td_api::updateAuthorizationState::ID) {
+      auto o = std::move(update->object);
+      process_authorization_state(std::move(static_cast<td_api::updateAuthorizationState &>(*o).authorization_state_));
+    }
+  }
+};
+
+class SetUsername : public Task {
+ public:
+  SetUsername(string username, Promise<> promise) : username_(std::move(username)), promise_(std::move(promise)) {
+  }
+
+ private:
+  string username_;
+  Promise<> promise_;
+  int32 self_id_;
+  string tag_;
+
+  void start_up() override {
+    send_query(make_tl_object<td_api::getMe>(), [this](auto res) { this->process_me_user(std::move(res)); });
+  }
+
+  void process_me_user(tl_object_ptr<td_api::Object> res) {
+    CHECK(res->get_id() == td_api::user::ID);
+    auto user = move_tl_object_as<td_api::user>(res);
+    self_id_ = user->id_;
+    if (user->username_ != username_) {
+      LOG(INFO) << "SET USERNAME: " << username_;
+      send_query(make_tl_object<td_api::setUsername>(username_), [this](auto res) {
+        CHECK(res->get_id() == td_api::ok::ID);
+        this->send_self_message();
+      });
+    } else {
+      send_self_message();
+    }
+  }
+  void send_self_message() {
+    tag_ = PSTRING() << format::as_hex(Random::secure_int64());
+
+    send_query(make_tl_object<td_api::createPrivateChat>(self_id_, false), [this](auto res) {
+      CHECK(res->get_id() == td_api::chat::ID);
+      auto chat = move_tl_object_as<td_api::chat>(res);
+      this->send_query(
+          make_tl_object<td_api::sendMessage>(
+              chat->id_, 0, false, false, nullptr,
+              make_tl_object<td_api::inputMessageText>(
+                  make_tl_object<td_api::formattedText>(PSTRING() << tag_ << " INIT", Auto()), false, false)),
+          [](auto res) {});
+    });
+  }
+
+  void process_update(std::shared_ptr<TestClient::Update> update) override {
+    if (!update->object) {
+      return;
+    }
+    if (update->object->get_id() == td_api::updateMessageSendSucceeded::ID) {
+      auto updateNewMessage = move_tl_object_as<td_api::updateMessageSendSucceeded>(update->object);
+      auto &message = updateNewMessage->message_;
+      if (message->content_->get_id() == td_api::messageText::ID) {
+        auto messageText = move_tl_object_as<td_api::messageText>(message->content_);
+        auto text = messageText->text_->text_;
+        if (text.substr(0, tag_.size()) == tag_) {
+          LOG(INFO) << "GOT SELF MESSAGE";
+          return stop();
+        }
+      }
+    }
+  }
+};
+
+class CheckTestA : public Task {
+ public:
+  CheckTestA(string tag, Promise<> promise) : tag_(std::move(tag)), promise_(std::move(promise)) {
+  }
+
+ private:
+  string tag_;
+  Promise<> promise_;
+  string previous_text_;
+  int cnt_ = 20;
+  void process_update(std::shared_ptr<TestClient::Update> update) override {
+    if (update->object->get_id() == td_api::updateNewMessage::ID) {
+      auto updateNewMessage = move_tl_object_as<td_api::updateNewMessage>(update->object);
+      auto &message = updateNewMessage->message_;
+      if (message->content_->get_id() == td_api::messageText::ID) {
+        auto messageText = move_tl_object_as<td_api::messageText>(message->content_);
+        auto text = messageText->text_->text_;
+        if (text.substr(0, tag_.size()) == tag_) {
+          CHECK(text > previous_text_) << tag("now", text) << tag("previous", previous_text_);
+          previous_text_ = text;
+          cnt_--;
+          LOG(INFO) << "GOT " << tag("text", text) << tag("left", cnt_);
+          if (cnt_ == 0) {
+            return stop();
+          }
+        }
+      }
+    }
+  }
+};
+
+class TestA : public Task {
+ public:
+  TestA(string tag, string username) : tag_(std::move(tag)), username_(std::move(username)) {
+  }
+  void start_up() override {
+    send_query(make_tl_object<td_api::searchPublicChat>(username_), [this](auto res) {
+      CHECK(res->get_id() == td_api::chat::ID);
+      auto chat = move_tl_object_as<td_api::chat>(res);
+      for (int i = 0; i < 20; i++) {
+        this->send_query(make_tl_object<td_api::sendMessage>(
+                             chat->id_, 0, false, false, nullptr,
+                             make_tl_object<td_api::inputMessageText>(
+                                 make_tl_object<td_api::formattedText>(PSTRING() << tag_ << " " << (1000 + i), Auto()),
+                                 false, false)),
+                         [&](auto res) { this->stop(); });
+      }
+    });
+  }
+
+ private:
+  string tag_;
+  string username_;
+};
+
+class TestSecretChat : public Task {
+ public:
+  TestSecretChat(string tag, string username) : tag_(std::move(tag)), username_(std::move(username)) {
+  }
+
+  void start_up() override {
+    auto f = [this](auto res) {
+      CHECK(res->get_id() == td_api::chat::ID);
+      auto chat = move_tl_object_as<td_api::chat>(res);
+      this->chat_id_ = chat->id_;
+      this->secret_chat_id_ = move_tl_object_as<td_api::chatTypeSecret>(chat->type_)->secret_chat_id_;
+    };
+    send_query(make_tl_object<td_api::searchPublicChat>(username_), [this, f = std::move(f)](auto res) mutable {
+      CHECK(res->get_id() == td_api::chat::ID);
+      auto chat = move_tl_object_as<td_api::chat>(res);
+      CHECK(chat->type_->get_id() == td_api::chatTypePrivate::ID);
+      auto info = move_tl_object_as<td_api::chatTypePrivate>(chat->type_);
+      this->send_query(make_tl_object<td_api::createNewSecretChat>(info->user_id_), std::move(f));
+    });
+  }
+
+  void process_update(std::shared_ptr<TestClient::Update> update) override {
+    if (!update->object) {
+      return;
+    }
+    if (update->object->get_id() == td_api::updateSecretChat::ID) {
+      auto update_secret_chat = move_tl_object_as<td_api::updateSecretChat>(update->object);
+      if (update_secret_chat->secret_chat_->id_ != secret_chat_id_ ||
+          update_secret_chat->secret_chat_->state_->get_id() != td_api::secretChatStateReady::ID) {
+        return;
+      }
+      LOG(INFO) << "SEND ENCRYPTED MESSAGES";
+      for (int i = 0; i < 20; i++) {
+        send_query(make_tl_object<td_api::sendMessage>(
+                       chat_id_, 0, false, false, nullptr,
+                       make_tl_object<td_api::inputMessageText>(
+                           make_tl_object<td_api::formattedText>(PSTRING() << tag_ << " " << (1000 + i), Auto()), false,
+                           false)),
+                   [](auto res) {});
+      }
+    }
+  }
+
+ private:
+  string tag_;
+  string username_;
+  int64 secret_chat_id_ = 0;
+  int64 chat_id_ = 0;
+};
+
+class TestFileGenerated : public Task {
+ public:
+  TestFileGenerated(string tag, string username) : tag_(std::move(tag)), username_(std::move(username)) {
+  }
+
+  void start_up() override {
+  }
+
+  void process_update(std::shared_ptr<TestClient::Update> update) override {
+    if (!update->object) {
+      return;
+    }
+    if (update->object->get_id() == td_api::updateNewMessage::ID) {
+      auto updateNewMessage = move_tl_object_as<td_api::updateNewMessage>(update->object);
+      auto &message = updateNewMessage->message_;
+      chat_id_ = message->chat_id_;
+      if (message->content_->get_id() == td_api::messageText::ID) {
+        auto messageText = move_tl_object_as<td_api::messageText>(message->content_);
+        auto text = messageText->text_->text_;
+        if (text.substr(0, tag_.size()) == tag_) {
+          if (text.substr(tag_.size() + 1) == "ONE_FILE") {
+            return one_file();
+          }
+        }
+      }
+    } else if (update->object->get_id() == td_api::updateFileGenerationStart::ID) {
+      auto info = move_tl_object_as<td_api::updateFileGenerationStart>(update->object);
+      generate_file(info->generation_id_, info->original_path_, info->destination_path_, info->conversion_);
+    } else if (update->object->get_id() == td_api::updateFile::ID) {
+      auto file = move_tl_object_as<td_api::updateFile>(update->object);
+      LOG(INFO) << to_string(file);
+    }
+  }
+  void one_file() {
+    LOG(ERROR) << "Start ONE_FILE test";
+    string file_path = string("test_documents") + TD_DIR_SLASH + "a.txt";
+    mkpath(file_path).ensure();
+    auto raw_file =
+        FileFd::open(file_path, FileFd::Flags::Create | FileFd::Flags::Truncate | FileFd::Flags::Write).move_as_ok();
+    auto file = BufferedFd<FileFd>(std::move(raw_file));
+    for (int i = 1; i < 100000; i++) {
+      file.write(PSLICE() << i << "\n").ensure();
+    }
+    file.flush_write().ensure();  // important
+    file.close();
+    this->send_query(make_tl_object<td_api::sendMessage>(
+                         chat_id_, 0, false, false, nullptr,
+                         make_tl_object<td_api::inputMessageDocument>(
+                             make_tl_object<td_api::inputFileGenerated>(file_path, "square", 0),
+                             make_tl_object<td_api::inputThumbnail>(
+                                 make_tl_object<td_api::inputFileGenerated>(file_path, "thumbnail", 0), 0, 0),
+                             make_tl_object<td_api::formattedText>(tag_, Auto()))),
+                     [](auto res) { check_td_error(res); });
+
+    this->send_query(
+        make_tl_object<td_api::sendMessage>(chat_id_, 0, false, false, nullptr,
+                                            make_tl_object<td_api::inputMessageDocument>(
+                                                make_tl_object<td_api::inputFileGenerated>(file_path, "square", 0),
+                                                nullptr, make_tl_object<td_api::formattedText>(tag_, Auto()))),
+        [](auto res) { check_td_error(res); });
+  }
+
+  friend class GenerateFile;
+  class GenerateFile : public Actor {
+   public:
+    GenerateFile(Task *parent, int64 id, string original_path, string destination_path, string conversion)
+        : parent_(parent)
+        , id_(id)
+        , original_path_(std::move(original_path))
+        , destination_path_(std::move(destination_path))
+        , conversion_(std::move(conversion)) {
+    }
+
+   private:
+    Task *parent_;
+    int64 id_;
+    string original_path_;
+    string destination_path_;
+    string conversion_;
+
+    FILE *from = nullptr;
+    FILE *to = nullptr;
+
+    void start_up() override {
+      from = std::fopen(original_path_.c_str(), "rb");
+      CHECK(from);
+      to = std::fopen(destination_path_.c_str(), "wb");
+      CHECK(to);
+      yield();
+    }
+    void loop() override {
+      int cnt = 0;
+      while (true) {
+        uint32 x;
+        auto r = std::fscanf(from, "%u", &x);
+        if (r != 1) {
+          return stop();
+        }
+        std::fprintf(to, "%u\n", x * x);
+        if (++cnt >= 10000) {
+          break;
+        }
+      }
+      auto ready = std::ftell(to);
+      LOG(ERROR) << "READY: " << ready;
+      parent_->send_query(make_tl_object<td_api::setFileGenerationProgress>(
+                              id_, 1039823 /*yeah, exact size of this file*/, narrow_cast<int32>(ready)),
+                          [](auto result) { check_td_error(result); });
+      set_timeout_in(0.02);
+    }
+    void tear_down() override {
+      std::fclose(from);
+      std::fclose(to);
+      parent_->send_query(make_tl_object<td_api::finishFileGeneration>(id_, nullptr),
+                          [](auto result) { check_td_error(result); });
+    }
+  };
+  void generate_file(int64 id, string original_path, string destination_path, string conversion) {
+    LOG(ERROR) << "Generate file " << tag("id", id) << tag("original_path", original_path)
+               << tag("destination_path", destination_path) << tag("conversion", conversion);
+    if (conversion == "square") {
+      create_actor<GenerateFile>("GenerateFile", this, id, original_path, destination_path, conversion).release();
+    } else if (conversion == "thumbnail") {
+      write_file(destination_path, base64url_decode(Slice(thumbnail, thumbnail_size)).ok()).ensure();
+      this->send_query(make_tl_object<td_api::finishFileGeneration>(id, nullptr),
+                       [](auto result) { check_td_error(result); });
+    } else {
+      LOG(FATAL) << "unknown " << tag("conversion", conversion);
+    }
+  }
+
+ private:
+  string tag_;
+  string username_;
+  int64 chat_id_ = 0;
+};
+
+class CheckTestC : public Task {
+ public:
+  CheckTestC(string username, string tag, Promise<> promise)
+      : username_(std::move(username)), tag_(std::move(tag)), promise_(std::move(promise)) {
+  }
+
+  void start_up() override {
+    send_query(make_tl_object<td_api::searchPublicChat>(username_), [this](auto res) {
+      CHECK(res->get_id() == td_api::chat::ID);
+      auto chat = move_tl_object_as<td_api::chat>(res);
+      chat_id_ = chat->id_;
+      this->one_file();
+    });
+  }
+
+ private:
+  string username_;
+  string tag_;
+  Promise<> promise_;
+  int64 chat_id_;
+
+  void one_file() {
+    this->send_query(
+        make_tl_object<td_api::sendMessage>(
+            chat_id_, 0, false, false, nullptr,
+            make_tl_object<td_api::inputMessageText>(
+                make_tl_object<td_api::formattedText>(PSTRING() << tag_ << " ONE_FILE", Auto()), false, false)),
+        [](auto res) { check_td_error(res); });
+  }
+
+  void process_update(std::shared_ptr<TestClient::Update> update) override {
+    if (!update->object) {
+      return;
+    }
+    if (update->object->get_id() == td_api::updateNewMessage::ID) {
+      auto updateNewMessage = move_tl_object_as<td_api::updateNewMessage>(update->object);
+      auto &message = updateNewMessage->message_;
+      if (message->content_->get_id() == td_api::messageDocument::ID) {
+        auto messageDocument = move_tl_object_as<td_api::messageDocument>(message->content_);
+        auto text = messageDocument->caption_->text_;
+        if (text.substr(0, tag_.size()) == tag_) {
+          file_id_to_check_ = messageDocument->document_->document_->id_;
+          LOG(ERROR) << "GOT FILE " << to_string(messageDocument->document_->document_);
+          this->send_query(make_tl_object<td_api::downloadFile>(file_id_to_check_, 1),
+                           [](auto res) { check_td_error(res); });
+        }
+      }
+    } else if (update->object->get_id() == td_api::updateFile::ID) {
+      auto updateFile = move_tl_object_as<td_api::updateFile>(update->object);
+      if (updateFile->file_->id_ == file_id_to_check_ && (updateFile->file_->local_->is_downloading_completed_)) {
+        check_file(updateFile->file_->local_->path_);
+      }
+    }
+  }
+
+  void check_file(CSlice path) {
+    FILE *from = std::fopen(path.c_str(), "rb");
+    CHECK(from);
+    uint32 x;
+    uint32 y = 1;
+    while (std::fscanf(from, "%u", &x) == 1) {
+      CHECK(x == y * y);
+      y++;
+    }
+    std::fclose(from);
+    stop();
+  }
+  int32 file_id_to_check_ = 0;
+};
+
+class LoginTestActor : public Actor {
+ public:
+  explicit LoginTestActor(Status *status) : status_(status) {
+    *status_ = Status::OK();
+  }
+
+ private:
+  Status *status_;
+  ActorOwn<TestClient> alice_;
+  ActorOwn<TestClient> bob_;
+
+  string alice_phone_ = "9996636437";
+  string bob_phone_ = "9996636438";
+  string alice_username_ = "alice_" + alice_phone_;
+  string bob_username_ = "bob_" + bob_phone_;
+
+  string stage_name_;
+
+  void begin_stage(string stage_name, double timeout) {
+    LOG(WARNING) << "Begin stage '" << stage_name << "'";
+    stage_name_ = std::move(stage_name);
+    set_timeout_in(timeout);
+  }
+
+  void start_up() override {
+    begin_stage("Logging in", 160);
+    alice_ = create_actor<TestClient>("AliceClient", "alice");
+    bob_ = create_actor<TestClient>("BobClient", "bob");
+
+    send_closure(alice_, &TestClient::add_listener,
+                 std::make_unique<DoAuthentication>(
+                     "alice", alice_phone_, "33333",
+                     PromiseCreator::event(self_closure(this, &LoginTestActor::start_up_fence_dec))));
+
+    send_closure(bob_, &TestClient::add_listener,
+                 std::make_unique<DoAuthentication>(
+                     "bob", bob_phone_, "33333",
+                     PromiseCreator::event(self_closure(this, &LoginTestActor::start_up_fence_dec))));
+  }
+
+  int start_up_fence_ = 3;
+  void start_up_fence_dec() {
+    --start_up_fence_;
+    if (start_up_fence_ == 0) {
+      init();
+    } else if (start_up_fence_ == 1) {
+      return init();
+      class WaitActor : public Actor {
+       public:
+        WaitActor(double timeout, Promise<> promise) : timeout_(timeout), promise_(std::move(promise)) {
+        }
+        void start_up() override {
+          set_timeout_in(timeout_);
+        }
+        void timeout_expired() override {
+          stop();
+        }
+
+       private:
+        double timeout_;
+        Promise<> promise_;
+      };
+      create_actor<WaitActor>("WaitActor", 2,
+                              PromiseCreator::event(self_closure(this, &LoginTestActor::start_up_fence_dec)))
+          .release();
+    }
+  }
+
+  void init() {
+    send_closure(alice_, &TestClient::add_listener,
+                 std::make_unique<SetUsername>(
+                     alice_username_, PromiseCreator::event(self_closure(this, &LoginTestActor::init_fence_dec))));
+    send_closure(bob_, &TestClient::add_listener,
+                 std::make_unique<SetUsername>(
+                     bob_username_, PromiseCreator::event(self_closure(this, &LoginTestActor::init_fence_dec))));
+  }
+
+  int init_fence_ = 2;
+  void init_fence_dec() {
+    if (--init_fence_ == 0) {
+      test_a();
+    }
+  }
+
+  int32 test_a_fence_ = 2;
+  void test_a_fence() {
+    if (--test_a_fence_ == 0) {
+      test_b();
+    }
+  }
+
+  void test_a() {
+    begin_stage("Ready to create chats", 80);
+    string alice_tag = PSTRING() << format::as_hex(Random::secure_int64());
+    string bob_tag = PSTRING() << format::as_hex(Random::secure_int64());
+
+    send_closure(bob_, &TestClient::add_listener,
+                 std::make_unique<CheckTestA>(
+                     alice_tag, PromiseCreator::event(self_closure(this, &LoginTestActor::test_a_fence))));
+    send_closure(alice_, &TestClient::add_listener,
+                 std::make_unique<CheckTestA>(
+                     bob_tag, PromiseCreator::event(self_closure(this, &LoginTestActor::test_a_fence))));
+
+    send_closure(alice_, &TestClient::add_listener, std::make_unique<TestA>(alice_tag, bob_username_));
+    send_closure(bob_, &TestClient::add_listener, std::make_unique<TestA>(bob_tag, alice_username_));
+    // send_closure(alice_, &TestClient::add_listener, std::make_unique<TestChat>(bob_username_));
+  }
+
+  void timeout_expired() override {
+    LOG(FATAL) << "Timeout expired in stage '" << stage_name_ << "'";
+  }
+
+  int32 test_b_fence_ = 1;
+  void test_b_fence() {
+    if (--test_b_fence_ == 0) {
+      test_c();
+    }
+  }
+
+  int32 test_c_fence_ = 1;
+  void test_c_fence() {
+    if (--test_c_fence_ == 0) {
+      finish();
+    }
+  }
+
+  void test_b() {
+    begin_stage("Create secret chat", 40);
+    string tag = PSTRING() << format::as_hex(Random::secure_int64());
+
+    send_closure(
+        bob_, &TestClient::add_listener,
+        std::make_unique<CheckTestA>(tag, PromiseCreator::event(self_closure(this, &LoginTestActor::test_b_fence))));
+    send_closure(alice_, &TestClient::add_listener, std::make_unique<TestSecretChat>(tag, bob_username_));
+  }
+
+  void test_c() {
+    begin_stage("Send generated file", 240);
+    string tag = PSTRING() << format::as_hex(Random::secure_int64());
+
+    send_closure(bob_, &TestClient::add_listener,
+                 std::make_unique<CheckTestC>(
+                     alice_username_, tag, PromiseCreator::event(self_closure(this, &LoginTestActor::test_c_fence))));
+    send_closure(alice_, &TestClient::add_listener, std::make_unique<TestFileGenerated>(tag, bob_username_));
+  }
+
+  int32 finish_fence_ = 2;
+  void finish_fence() {
+    finish_fence_--;
+    if (finish_fence_ == 0) {
+      Scheduler::instance()->finish();
+      stop();
+    }
+  }
+  void finish() {
+    send_closure(alice_, &TestClient::close, PromiseCreator::event(self_closure(this, &LoginTestActor::finish_fence)));
+    send_closure(bob_, &TestClient::close, PromiseCreator::event(self_closure(this, &LoginTestActor::finish_fence)));
+  }
+};
+
+class Tdclient_login : public td::Test {
+ public:
+  using Test::Test;
+  bool step() final {
+    if (!is_inited_) {
+      SET_VERBOSITY_LEVEL(VERBOSITY_NAME(DEBUG) + 2);
+      sched_.init(4);
+      sched_.create_actor_unsafe<LoginTestActor>(0, "LoginTestActor", &result_).release();
+      sched_.start();
+      is_inited_ = true;
+    }
+
+    bool ret = sched_.run_main(10);
+    if (ret) {
+      return true;
+    }
+    sched_.finish();
+    if (result_.is_error()) {
+      LOG(ERROR) << result_;
+    }
+    ASSERT_TRUE(result_.is_ok());
+    return false;
+  }
+
+ private:
+  bool is_inited_ = false;
+  ConcurrentScheduler sched_;
+  Status result_;
+};
+Tdclient_login Tdclient_login("Tdclient_login");
+};  // namespace td