#include "worker.h"

#include <string>

#include "gmock/gmock.h"

#include "gtest/gtest.h"

namespace Envoy {

namespace Server {

using ::testing::_;

using ::testing::Invoke;

MockWorker::MockWorker() {

  ON_CALL(*this, addListener(_, _, _, _, _))

      .WillByDefault(

          Invoke([this](absl::optional<uint64_t> overridden_listener,

                        Network::ListenerConfig& config, AddListenerCompletion completion,

                        Runtime::Loader&, Random::RandomGenerator&) -> void {

            UNREFERENCED_PARAMETER(overridden_listener);

            config.listenSocketFactories()[0]->getListenSocket(0);

            EXPECT_EQ(nullptr, add_listener_completion_);

            add_listener_completion_ = completion;

          }));

  ON_CALL(*this, removeListener(_, _))

      .WillByDefault(

          Invoke([this](Network::ListenerConfig&, std::function<void()> completion) -> void {

            EXPECT_EQ(nullptr, remove_listener_completion_);

            remove_listener_completion_ = completion;

          }));

  ON_CALL(*this, stopListener(_, _, _))

      .WillByDefault(

          Invoke([](Network::ListenerConfig&, const Network::ExtraShutdownListenerOptions&,

                    std::function<void()> completion) -> void {

            if (completion != nullptr) {

              completion();

            }

          }));

  ON_CALL(*this, removeFilterChains(_, _, _))

      .WillByDefault(Invoke([this](uint64_t, const std::list<const Network::FilterChain*>&,

                                   std::function<void()> completion) -> void {

        EXPECT_EQ(nullptr, remove_filter_chains_completion_);

        remove_filter_chains_completion_ = completion;

      }));

  ON_CALL(*this, start(_, _))

      .WillByDefault(

          Invoke([](OptRef<GuardDog>, const std::function<void()>& cb) -> void { cb(); }));

}

MockWorker::~MockWorker() = default;

} // namespace Server

} // namespace Envoy