src/sys/activity/activity_tracker_connection_test.cc

// Copyright 2019 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/sys/activity/activity_tracker_connection.h"

#include <fuchsia/ui/activity/cpp/fidl.h>

#include <memory>

#include "garnet/public/lib/gtest/test_loop_fixture.h"
#include "src/sys/activity/state_machine_driver.h"

namespace {

fuchsia::ui::activity::DiscreteActivity DiscreteActivity() {
  fuchsia::ui::activity::GenericActivity generic;
  fuchsia::ui::activity::DiscreteActivity activity;
  activity.set_generic(std::move(generic));
  return activity;
};

fuchsia::ui::activity::OngoingActivity OngoingActivity() {
  fuchsia::ui::activity::GenericActivity generic;
  fuchsia::ui::activity::OngoingActivity activity;
  activity.set_generic(std::move(generic));
  return activity;
};

}  // namespace

namespace activity {

class ActivityTrackerConnectionTest : public ::gtest::TestLoopFixture {
 public:
  ActivityTrackerConnectionTest() : driver_(dispatcher()) {}

  void SetUp() override {
    conn_ = std::make_unique<ActivityTrackerConnection>(&driver_, dispatcher(),
                                                        client_.NewRequest(dispatcher()));
    // Some tests rely on subtracting from Now(), so advance to a nonzero time
    RunLoopFor(zx::hour(1));
  }

 protected:
  StateMachineDriver driver_;
  std::unique_ptr<ActivityTrackerConnection> conn_;
  fuchsia::ui::activity::TrackerPtr client_;
};

TEST_F(ActivityTrackerConnectionTest, ReportActivity) {
  int callback_invocations = 0;
  auto callback = [&callback_invocations]() { callback_invocations++; };
  client_->ReportDiscreteActivity(DiscreteActivity(), Now().get(), std::move(callback));
  RunLoopUntilIdle();
  EXPECT_EQ(driver_.GetState(), fuchsia::ui::activity::State::ACTIVE);
  EXPECT_EQ(callback_invocations, 1);
}

TEST_F(ActivityTrackerConnectionTest, ReportActivity_StaleEventIgnored) {
  std::optional<zx_status_t> epitaph;
  client_.set_error_handler([&epitaph](zx_status_t status) { epitaph = status; });

  // Send an event and then let the state machine driver time out (returning to IDLE).
  driver_.ReceiveDiscreteActivity(DiscreteActivity(), Now(), []() {});
  RunLoopUntilIdle();
  auto timeout = driver_.state_machine().TimeoutFor(fuchsia::ui::activity::State::ACTIVE);
  ASSERT_NE(timeout, std::nullopt);
  RunLoopFor(*timeout);

  int callback_invocations = 0;
  auto callback = [&callback_invocations]() { callback_invocations++; };
  auto old_time = Now() - zx::duration(zx::sec(5));
  client_->ReportDiscreteActivity(DiscreteActivity(), old_time.get(), std::move(callback));
  RunLoopUntilIdle();

  EXPECT_EQ(driver_.GetState(), fuchsia::ui::activity::State::IDLE);
  // Make sure no channel errors were received and the callback was invoked
  EXPECT_FALSE(epitaph);
  EXPECT_EQ(callback_invocations, 1);
}

TEST_F(ActivityTrackerConnectionTest, ReportActivity_OutOfOrder) {
  std::optional<zx_status_t> epitaph;
  client_.set_error_handler([&epitaph](zx_status_t status) { epitaph = status; });

  int callback1_invocations = 0;
  auto callback1 = [&callback1_invocations]() { callback1_invocations++; };

  client_->ReportDiscreteActivity(DiscreteActivity(), Now().get(), std::move(callback1));
  RunLoopUntilIdle();

  int callback2_invocations = 0;
  auto callback2 = [&callback2_invocations]() { callback2_invocations++; };

  auto old_time = Now() - zx::duration(zx::sec(5));
  client_->ReportDiscreteActivity(DiscreteActivity(), old_time.get(), std::move(callback2));
  RunLoopUntilIdle();

  EXPECT_TRUE(epitaph);
  EXPECT_EQ(*epitaph, ZX_ERR_OUT_OF_RANGE);
  EXPECT_EQ(callback1_invocations, 1);
  EXPECT_EQ(callback2_invocations, 0);
}

TEST_F(ActivityTrackerConnectionTest, StartStopOngoingActivity) {
  int start_callback_invocations = 0;
  auto start_callback = [&start_callback_invocations]() { start_callback_invocations++; };
  const OngoingActivityId activity_id = 1234;
  client_->StartOngoingActivity(activity_id, OngoingActivity(), Now().get(),
                                std::move(start_callback));
  RunLoopUntilIdle();
  EXPECT_EQ(driver_.GetState(), fuchsia::ui::activity::State::ACTIVE);
  EXPECT_EQ(start_callback_invocations, 1);

  // Timeouts should not be processed
  auto timeout = driver_.state_machine().TimeoutFor(fuchsia::ui::activity::State::ACTIVE);
  ASSERT_NE(timeout, std::nullopt);
  RunLoopFor(*timeout);
  EXPECT_EQ(driver_.GetState(), fuchsia::ui::activity::State::ACTIVE);

  int end_callback_invocations = 0;
  auto end_callback = [&end_callback_invocations]() { end_callback_invocations++; };
  client_->EndOngoingActivity(activity_id, Now().get(), std::move(end_callback));
  RunLoopUntilIdle();
  EXPECT_EQ(driver_.GetState(), fuchsia::ui::activity::State::ACTIVE);
  EXPECT_EQ(end_callback_invocations, 1);

  // The activity has ended so timeouts should now be respected
  RunLoopFor(*timeout);
  EXPECT_EQ(driver_.GetState(), fuchsia::ui::activity::State::IDLE);
}

TEST_F(ActivityTrackerConnectionTest, StartOngoingActivity_StaleEventsIgnored) {
  std::optional<zx_status_t> epitaph;
  client_.set_error_handler([&epitaph](zx_status_t status) { epitaph = status; });

  // Send an event and then let the state machine driver time out (returning to IDLE).
  driver_.ReceiveDiscreteActivity(DiscreteActivity(), Now(), []() {});
  RunLoopUntilIdle();
  auto timeout = driver_.state_machine().TimeoutFor(fuchsia::ui::activity::State::ACTIVE);
  ASSERT_NE(timeout, std::nullopt);
  RunLoopFor(*timeout);

  int callback_invocations = 0;
  auto callback = [&callback_invocations]() { callback_invocations++; };
  auto old_time = Now() - zx::duration(zx::sec(5));
  OngoingActivityId id = 1234;
  client_->StartOngoingActivity(id, OngoingActivity(), old_time.get(), std::move(callback));
  RunLoopUntilIdle();

  EXPECT_EQ(driver_.GetState(), fuchsia::ui::activity::State::IDLE);
  // Make sure no channel errors were received and the callback was invoked
  EXPECT_FALSE(epitaph);
  EXPECT_EQ(callback_invocations, 1);
}

TEST_F(ActivityTrackerConnectionTest, StartOngoingActivity_OutOfOrder) {
  // Send a discrete activity to bring the state machine to ACTIVE
  client_->ReportDiscreteActivity(DiscreteActivity(), Now().get(), []() {});
  RunLoopUntilIdle();
  EXPECT_EQ(driver_.GetState(), fuchsia::ui::activity::State::ACTIVE);

  std::optional<zx_status_t> epitaph;
  client_.set_error_handler([&epitaph](zx_status_t status) { epitaph = status; });

  auto old_time = Now() - zx::duration(zx::sec(5));
  client_->StartOngoingActivity(1234, OngoingActivity(), old_time.get(),
                                []() { ASSERT_FALSE("Callback was unexpectedly invoked"); });
  RunLoopUntilIdle();
  EXPECT_EQ(driver_.GetState(), fuchsia::ui::activity::State::ACTIVE);
  ASSERT_TRUE(epitaph);
  EXPECT_EQ(*epitaph, ZX_ERR_OUT_OF_RANGE);

  // Timeouts should still be processed (no ongoing activity should have started)
  auto timeout = driver_.state_machine().TimeoutFor(fuchsia::ui::activity::State::ACTIVE);
  ASSERT_NE(timeout, std::nullopt);
  RunLoopFor(*timeout);

  EXPECT_EQ(driver_.GetState(), fuchsia::ui::activity::State::IDLE);
}

TEST_F(ActivityTrackerConnectionTest, CleansUpOngoingActivitiesOnStop) {
  int callback_invocations = 0;
  client_->StartOngoingActivity(1234, OngoingActivity(), Now().get(),
                                [&callback_invocations]() { callback_invocations = true; });
  RunLoopUntilIdle();
  EXPECT_EQ(driver_.GetState(), fuchsia::ui::activity::State::ACTIVE);
  EXPECT_EQ(callback_invocations, 1);

  conn_->Stop();
  RunLoopUntilIdle();

  // Timeouts will now be processed since the activity was cleaned up
  auto timeout = driver_.state_machine().TimeoutFor(fuchsia::ui::activity::State::ACTIVE);
  ASSERT_NE(timeout, std::nullopt);
  RunLoopFor(*timeout);

  EXPECT_EQ(driver_.GetState(), fuchsia::ui::activity::State::IDLE);
}

TEST_F(ActivityTrackerConnectionTest, CleansUpOngoingActivitiesOnDestruction) {
  int callback_invocations = 0;
  client_->StartOngoingActivity(1234, OngoingActivity(), Now().get(),
                                [&callback_invocations]() { callback_invocations++; });
  RunLoopUntilIdle();
  EXPECT_EQ(driver_.GetState(), fuchsia::ui::activity::State::ACTIVE);
  EXPECT_EQ(callback_invocations, 1);

  conn_.reset();
  RunLoopUntilIdle();

  // Timeouts will now be processed since the activity was cleaned up
  auto timeout = driver_.state_machine().TimeoutFor(fuchsia::ui::activity::State::ACTIVE);
  ASSERT_NE(timeout, std::nullopt);
  RunLoopFor(*timeout);

  EXPECT_EQ(driver_.GetState(), fuchsia::ui::activity::State::IDLE);
}

}  // namespace activity