src/developer/debug/zxdb/console/command_context_unittest.cc

// Copyright 2022 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "src/developer/debug/zxdb/console/command_context.h"

#include <gtest/gtest.h>

#include "src/developer/debug/zxdb/client/mock_remote_api.h"
#include "src/developer/debug/zxdb/client/process.h"
#include "src/developer/debug/zxdb/client/thread.h"
#include "src/developer/debug/zxdb/console/console_test.h"

namespace zxdb {

TEST(CommandContext, Empty) {
  bool called = false;
  {
    auto my_context = fxl::MakeRefCounted<OfflineCommandContext>(
        nullptr, [&called](OutputBuffer output, std::vector<Err> errors) {
          called = true;
          EXPECT_TRUE(output.AsString().empty());
          EXPECT_TRUE(errors.empty());
        });
  }
  EXPECT_TRUE(called);
}

TEST(CommandContext, AsyncOutputAndErrors) {
  // This test constructs two AsyncOutputBuffers, one depending on the other. We only keep a
  // reference to the inner one. The ConsoleContext should keep the reference to the outer one
  // to keep it alive as long as it's not complete.
  auto inner_async_output = fxl::MakeRefCounted<AsyncOutputBuffer>();

  bool called = false;
  {
    auto my_context = fxl::MakeRefCounted<OfflineCommandContext>(
        nullptr, [&called](OutputBuffer output, std::vector<Err> errors) {
          called = true;

          EXPECT_EQ("Some error\nSome output\nAsync output\n", output.AsString());

          EXPECT_EQ(1u, errors.size());
          EXPECT_EQ("Some error", errors[0].msg());
        });

    my_context->ReportError(Err("Some error"));
    my_context->Output("Some output\n");

    auto outer_async_output = fxl::MakeRefCounted<AsyncOutputBuffer>();
    outer_async_output->Append(inner_async_output);
    my_context->Output(outer_async_output);
    outer_async_output->Complete();
  }
  // Even though our reference went out-of-scope, the async output is still active.
  EXPECT_FALSE(called);

  inner_async_output->Append("Async output\n");
  inner_async_output->Complete();

  // Marking the async output complete should have marked the context done.
  EXPECT_TRUE(called);
}

class CommandContextTest : public ConsoleTest {};

TEST_F(CommandContextTest, CommandReport) {
  auto cmd_context = fxl::MakeRefCounted<ConsoleCommandContext>(&console());

  // Invalid command should not have anything set other than the error. Parsing is done
  // synchronously, so we don't need to run the message loop here.
  console().ProcessInputLine("1234", cmd_context);
  auto report = cmd_context->GetCommandReport();
  EXPECT_TRUE(cmd_context->has_error());
  EXPECT_TRUE(report.err.has_error());
  EXPECT_EQ(report.err.type(), ErrType::kGeneral);
  EXPECT_EQ(report.err.msg(), "The string \"1234\" is not a valid verb. Did you mean \"bp\"?");
  EXPECT_EQ(static_cast<Verb>(report.verb_id), Verb::kNone);
  EXPECT_TRUE(report.arguments.empty());
  EXPECT_TRUE(report.nouns.empty());
  EXPECT_TRUE(report.switches.empty());

  // Release the previous command context and create a new one for a clean slate.
  cmd_context = fxl::MakeRefCounted<ConsoleCommandContext>(&console());

  debug_ipc::ThreadRecord record;
  record.id.process = process()->GetKoid();
  record.id.thread = thread()->GetKoid();
  record.blocked_reason = debug_ipc::ThreadRecord::BlockedReason::kException;
  record.stack_amount = debug_ipc::ThreadRecord::StackAmount::kNone;

  debug_ipc::ThreadStatusReply reply;
  reply.record = record;
  mock_remote_api()->set_thread_status_reply(reply);

  // A verb with a single argument and no switches. Note the canonical name is always used in the
  // report.
  console().ProcessInputLine("b test.cc:1234", cmd_context);

  loop().RunUntilNoTasks();

  // Grab the report after all tasks are run.
  report = cmd_context->GetCommandReport();
  EXPECT_FALSE(cmd_context->has_error());
  EXPECT_FALSE(report.err.has_error());
  EXPECT_EQ(report.arguments.size(), 1u);
  EXPECT_TRUE(report.nouns.empty());
  EXPECT_TRUE(report.switches.empty());
  EXPECT_EQ(report.verb, "break");
  EXPECT_EQ(static_cast<Verb>(report.verb_id), Verb::kBreak);
  EXPECT_EQ(static_cast<CommandGroup>(report.command_group), CommandGroup::kBreakpoint);
  EXPECT_EQ(report.arguments[0], "test.cc:1234");

  cmd_context = fxl::MakeRefCounted<ConsoleCommandContext>(&console());

  // Now add a switch.
  console().ProcessInputLine("attach --weak component.cm", cmd_context);

  loop().RunUntilNoTasks();

  report = cmd_context->GetCommandReport();
  EXPECT_FALSE(cmd_context->has_error());
  EXPECT_FALSE(report.err.has_error());
  EXPECT_EQ(report.arguments.size(), 1u);
  EXPECT_TRUE(report.nouns.empty());
  EXPECT_EQ(report.switches.size(), 1u);
  EXPECT_EQ(report.verb, "attach");
  EXPECT_EQ(static_cast<Verb>(report.verb_id), Verb::kAttach);
  EXPECT_EQ(static_cast<CommandGroup>(report.command_group), CommandGroup::kProcess);
  EXPECT_EQ(report.arguments[0], "component.cm");
  EXPECT_EQ(report.switches[0].name, "weak");

  cmd_context = fxl::MakeRefCounted<ConsoleCommandContext>(&console());

  // Just nouns, again canonical names are always used, and mixing and matching is acceptable.
  console().ProcessInputLine("t * frame", cmd_context);

  loop().RunUntilNoTasks();

  report = cmd_context->GetCommandReport();
  EXPECT_FALSE(cmd_context->has_error());
  EXPECT_FALSE(report.err.has_error());
  EXPECT_TRUE(report.arguments.empty());
  EXPECT_EQ(report.nouns.size(), 2u);
  EXPECT_TRUE(report.switches.empty());
  EXPECT_EQ(report.verb, "");
  EXPECT_EQ(static_cast<Verb>(report.verb_id), Verb::kNone);
  for (const auto& noun : report.nouns) {
    auto it = GetNouns().find(static_cast<Noun>(noun.id));
    ASSERT_NE(it, GetNouns().end());
    auto noun_record = it->second;

    // Should always match the canonical name.
    EXPECT_EQ(noun_record.aliases[0], noun.name);

    // We gave the thread noun an index, but not frame.
    if (static_cast<Noun>(noun.id) == Noun::kThread) {
      EXPECT_EQ(noun.index, Command::kWildcard);
    } else {
      EXPECT_EQ(noun.index, Command::kNoIndex);
    }
  }

  cmd_context = fxl::MakeRefCounted<ConsoleCommandContext>(&console());

  debug_ipc::PauseReply pause_reply;
  pause_reply.threads.push_back(record);

  mock_remote_api()->set_pause_reply(pause_reply);

  // Noun prefix to a verb.
  console().ProcessInputLine("thread 1 pause", cmd_context);

  loop().RunUntilNoTasks();

  report = cmd_context->GetCommandReport();
  EXPECT_FALSE(cmd_context->has_error());
  EXPECT_FALSE(report.err.has_error());
  EXPECT_TRUE(report.arguments.empty());
  EXPECT_TRUE(report.switches.empty());
  EXPECT_EQ(report.nouns.size(), 1u);
  EXPECT_EQ(report.verb, "pause");
  EXPECT_EQ(static_cast<Verb>(report.verb_id), Verb::kPause);
  EXPECT_EQ(static_cast<Noun>(report.nouns[0].id), Noun::kThread);
  EXPECT_EQ(report.nouns[0].name, "thread");
  EXPECT_EQ(report.nouns[0].index, 1);
}

TEST_F(CommandContextTest, CommandReportElidesPaths) {
  auto cmd_context = fxl::MakeRefCounted<ConsoleCommandContext>(&console());

  console().ProcessInputLine("set symbol-cache=path/to/cache", cmd_context);

  // The command is parsed synchronously, but the actual actions will happen asynchronously.
  loop().RunUntilNoTasks();

  // Grab the report now that all of the async tasks have been completed.
  auto report = cmd_context->GetCommandReport();
  EXPECT_FALSE(cmd_context->has_error());
  EXPECT_FALSE(report.err.has_error());
  EXPECT_TRUE(report.arguments.empty());
  EXPECT_TRUE(report.switches.empty());
  EXPECT_TRUE(report.nouns.empty());
  EXPECT_EQ(report.verb, "set");
  EXPECT_EQ(static_cast<Verb>(report.verb_id), Verb::kSet);

  // Drop the last context and make a new one.
  cmd_context = fxl::MakeRefCounted<ConsoleCommandContext>(&console());

  console().ProcessInputLine("opendump path/to/minidump", cmd_context);
  loop().RunUntilNoTasks();

  // The command will fail because that path doesn't exist, but the rest of the command report will
  // be populated.
  report = cmd_context->GetCommandReport();
  EXPECT_TRUE(cmd_context->has_error());
  EXPECT_TRUE(report.err.has_error());
  EXPECT_TRUE(report.arguments.empty());
  EXPECT_TRUE(report.switches.empty());
  EXPECT_TRUE(report.nouns.empty());
  EXPECT_EQ(report.verb, "opendump");
  EXPECT_EQ(static_cast<Verb>(report.verb_id), Verb::kOpenDump);

  debug_ipc::ThreadRecord record;
  record.id.process = process()->GetKoid();
  record.id.thread = thread()->GetKoid();
  record.blocked_reason = debug_ipc::ThreadRecord::BlockedReason::kException;
  record.stack_amount = debug_ipc::ThreadRecord::StackAmount::kNone;

  debug_ipc::ThreadStatusReply reply;
  reply.record = record;

  debug_ipc::NotifyException notify;
  notify.thread = record;

  InjectException(notify);
  loop().RunUntilNoTasks();

  cmd_context = fxl::MakeRefCounted<ConsoleCommandContext>(&console());

  console().ProcessInputLine("savedump path/to/minidump", cmd_context);

  loop().RunUntilNoTasks();

  // This will also fail, but we're only interested in the command report.
  report = cmd_context->GetCommandReport();
  EXPECT_TRUE(cmd_context->has_error());
  EXPECT_TRUE(report.err.has_error());
  EXPECT_TRUE(report.arguments.empty());
  EXPECT_TRUE(report.switches.empty());
  EXPECT_TRUE(report.nouns.empty());
  EXPECT_EQ(report.verb, "savedump");
  EXPECT_EQ(static_cast<Verb>(report.verb_id), Verb::kSaveDump);
}

}  // namespace zxdb