Implementation:Tensorflow Serving Aspired Versions Manager Test

Knowledge Sources	Tensorflow_Serving
Domains	Testing, Core Management
Last Updated	2026-02-13 00:00 GMT

Overview

Test suite validating the AspiredVersionsManager which manages servable lifecycle based on aspired version sets and version policies.

Description

This test file exercises the AspiredVersionsManager class, the central component that manages loading, unloading, and transitioning of servable versions based on aspired version callbacks and pluggable version policies. The AspiredVersionsManagerTest fixture is parameterized on thread pool sizes (inline vs. threaded load/unload) and the enable_reload_servables_with_error flag. It sets up two servable streams with two versions each, using FakeLoader, MockLoader, EventBus, and ServableStateMonitor for comprehensive state tracking. Tests use AspiredVersionsManagerTestAccess to manually trigger policy actions.

Usage

Run these tests to verify correct servable lifecycle management: loading, unloading, error handling, retry logic, event bus notifications, version reversion, and custom sort actions. Essential after changes to the manager, version policies, or loader harness integration.

Code Reference

Source Location

• Repository: Tensorflow_Serving
• File: tensorflow_serving/core/aspired_versions_manager_test.cc
• Lines: 1-1387

Test Fixture

struct ThreadPoolSizes {
  uint64_t num_load_threads;
  uint64_t num_unload_threads;
};

class AspiredVersionsManagerTest
    : public ::testing::TestWithParam<std::tuple<ThreadPoolSizes, bool>> {
 protected:
  AspiredVersionsManagerTest()
      : servable_event_bus_(EventBus<ServableState>::CreateEventBus()),
        servable_state_monitor_(servable_event_bus_.get()),
        thread_pool_sizes_(std::get<0>(GetParam())),
        enable_reload_servables_with_error_(std::get<1>(GetParam())) {
    AspiredVersionsManager::Options manager_options;
    manager_options.num_load_threads = thread_pool_sizes_.num_load_threads;
    manager_options.num_unload_threads = thread_pool_sizes_.num_unload_threads;
    manager_options.manage_state_interval_micros = -1;
    manager_options.aspired_version_policy.reset(
        new AvailabilityPreservingPolicy());
    manager_options.servable_event_bus = servable_event_bus_.get();
    manager_options.max_num_load_retries = max_num_load_retries_;
    TF_CHECK_OK(AspiredVersionsManager::Create(
        std::move(manager_options), &manager_));
  }

  void SetUp() override {
    // Sets up two servable streams (kServableName, kServableName2)
    // each with versions 0 and 1, all loaded and available
  }

  std::shared_ptr<EventBus<ServableState>> servable_event_bus_;
  ServableStateMonitor servable_state_monitor_;
  ThreadPoolSizes thread_pool_sizes_;
  bool enable_reload_servables_with_error_;
  std::unique_ptr<AspiredVersionsManager> manager_;
};

Build Target

bazel test //tensorflow_serving/core:aspired_versions_manager_test

Test Coverage

Key Test Cases

Test Name	Category	Description
ServableHandleNotFoundMissingLoaderName	Error Handling	Verifies NOT_FOUND for a non-existent servable name
ServableHandleNotFoundMissingVersion	Error Handling	Verifies NOT_FOUND for a non-existent version
ServableHandleInvalidArgument	Validation	Tests INVALID_ARGUMENT when requesting with wrong type
ServableHandleLatest	Handle Retrieval	Verifies latest version handle retrieval
ServableHandleLatestVersionIsZero	Handle Retrieval	Tests handle retrieval when the latest version is 0
ReloadAspiredError	Error Recovery	Tests reloading behavior for servables in error state
ServableHandleSpecificVersion	Handle Retrieval	Verifies retrieval of a specific version handle
ListAvailableServableIds	Listing	Tests listing of all available servable IDs
GetAvailableServableHandles	Handle Retrieval	Validates bulk retrieval of available handles
AspiredRemovedFull	Lifecycle	Tests full removal of all aspired versions for a servable
AspiredRemovedPartial	Lifecycle	Tests partial removal of aspired versions
RevertToSmallerVersionNumber	Lifecycle	Validates reverting to a smaller version number
AspiredAndManageStateLoad	Policy	Tests aspired versions callback triggering loads via policy
AspiredAndManageStateUnload	Policy	Tests aspired versions callback triggering unloads via policy
ManagerPrefersUnloadOverLoad	Policy	Verifies manager prioritizes unloads over loads
CustomSortActions	Policy	Tests custom action sorting in the version policy
ErroneousAspiredVersion	Error Handling	Tests handling of aspired versions with errors
DestructOnNonServingThread	Lifecycle	Ensures safe destruction from a non-serving thread
EventBusServableLifecycle	Events	Validates full lifecycle events on the event bus
RetryOnLoadErrorFinallySucceeds	Retry	Tests retry logic that eventually succeeds
RetryOnLoadErrorFinallyFails	Retry	Tests retry logic that eventually fails
UnaspireThenImmediatelyReaspire	Lifecycle	Tests rapid un-aspire and re-aspire sequence
CallPolicyWithAllVersions	Policy	Verifies the policy is called with all version information

Usage Examples

Test Pattern

// Creates an aspired-versions entry with 'id' and a FakeLoader
// whose servable is id.version.
ServableData<std::unique_ptr<Loader>> CreateAspiredVersion(
    const ServableId& id) {
  std::unique_ptr<Loader> loader(new FakeLoader(id.version));
  return CreateServableData(id, std::move(loader));
}

TEST_P(AspiredVersionsManagerTest, ServableHandleLatest) {
  ServableHandle<int64_t> handle;
  TF_ASSERT_OK(manager_->GetServableHandle(
      ServableRequest::Latest(kServableName), &handle));
  EXPECT_EQ(kNumVersionsPerServable - 1, *handle);
}

Related Pages

• Implementation:Tensorflow_Serving_Aspired_Versions_Manager_Benchmark
• Implementation:Tensorflow_Serving_Basic_Manager_Test