components/fuchsia_component_support/annotations_manager_unittest.cc - chromium/src - Git at Google

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

 #include "components/fuchsia_component_support/annotations_manager.h"

 #include "base/fuchsia/mem_buffer_util.h"
 #include "base/test/gtest_util.h"
 #include "base/test/task_environment.h"
 #include "testing/gtest/include/gtest/gtest.h"

 namespace fuchsia_component_support {

 namespace {

 class AnnotationsManagerTest : public testing::Test {
  protected:
   AnnotationsManagerTest() = default;

   base::test::SingleThreadTaskEnvironment task_environment_{
       base::test::SingleThreadTaskEnvironment::MainThreadType::IO};
 };

 constexpr char kGlobalNamespace[] = "global";

 constexpr char kAnnotationName1[] = "annotation1";
 constexpr char kAnnotationName2[] = "annotation2";

 constexpr char kAnnotationValue1[] = "annotation_value1";
 constexpr char kAnnotationValue2[] = "annotation_value2";

 TEST(MakeAnnotationTest, KeyNamespaceAndName) {
   auto annotation = MakeAnnotation(kAnnotationName1, "ignored");
   EXPECT_EQ(annotation.key.namespace_, kGlobalNamespace);
   EXPECT_EQ(annotation.key.value, kAnnotationName1);
 }

 TEST(MakeAnnotationTest, BooleanValue) {
   auto annotation = MakeBoolAnnotation(kAnnotationName1, true);
   ASSERT_TRUE(annotation.value.is_text());
   EXPECT_EQ(annotation.value.text(), "true");
 }

 TEST(MakeAnnotationTest, IntegerValue) {
   auto annotation = MakeIntAnnotation(kAnnotationName1, 12345678);
   ASSERT_TRUE(annotation.value.is_text());
   EXPECT_EQ(annotation.value.text(), "12345678");
 }

 TEST(MakeAnnotationTest, TextValue) {
   constexpr char kSmallText[] = "This is a short text annotation";
   auto annotation = MakeAnnotation(kAnnotationName1, kSmallText);
   ASSERT_TRUE(annotation.value.is_text());
   EXPECT_EQ(annotation.value.text(), kSmallText);
 }

 TEST(MakeAnnotationTest, LargeTextValue) {
   const std::string large_text(1024, 'a');
   auto annotation = MakeAnnotation(kAnnotationName1, large_text);
   ASSERT_TRUE(annotation.value.is_buffer());
   auto value = base::StringFromMemBuffer(annotation.value.buffer());
   EXPECT_EQ(value, large_text);
 }

 // Basic verification that a single client can connect.
 TEST_F(AnnotationsManagerTest, SingleClient) {
   AnnotationsManager annotations;

   fuchsia::element::AnnotationControllerPtr ptr;
   annotations.Connect(ptr.NewRequest());
 }

 // Verifies that multiple clients can connect.
 TEST_F(AnnotationsManagerTest, MultipleClients) {
   AnnotationsManager annotations;

   fuchsia::element::AnnotationControllerPtr ptr1;
   annotations.Connect(ptr1.NewRequest());
   fuchsia::element::AnnotationControllerPtr ptr2;
   annotations.Connect(ptr2.NewRequest());
 }

 // Verifies that WatchAnnotations() hanging-get behaviour:
 // - first call returns all annotations.
 // - watch when nothing has changed "hangs" until the next change.
 // - watch after a change returns immediately.
 TEST_F(AnnotationsManagerTest, WatchAnnotationsHangingGet) {
   AnnotationsManager annotations;

   fuchsia::element::AnnotationControllerPtr controller;
   annotations.Connect(controller.NewRequest());

   // Dispatch an initial watch, that will return immediately.
   bool received_annotations = false;
   controller->WatchAnnotations([&received_annotations](auto annotations) {
     EXPECT_EQ(annotations.response().annotations.size(), 0u);
     received_annotations = true;
   });
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(received_annotations);

   // Set a new watch, which should not return immediately, since nothing has
   // changed.
   received_annotations = false;
   controller->WatchAnnotations([&received_annotations](auto annotations) {
     EXPECT_EQ(annotations.response().annotations.size(), 1u);
     received_annotations = true;
   });
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(received_annotations);

   // Set an annotation and spin the loop, to verify that the update is reported.
   std::vector<fuchsia::element::Annotation> to_set;
   to_set.push_back(MakeAnnotation(kAnnotationName1, kAnnotationValue1));
   annotations.UpdateAnnotations(std::move(to_set));
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(received_annotations);

   // Change the annotation and spin the loop, then call WatchAnnotations() to
   // verify that it returns immediately.
   to_set.clear();
   to_set.push_back(MakeAnnotation(kAnnotationName1, kAnnotationValue2));
   annotations.UpdateAnnotations(std::move(to_set));
   received_annotations = false;
   controller->WatchAnnotations([&received_annotations](auto annotations) {
     EXPECT_EQ(annotations.response().annotations.size(), 1u);
     received_annotations = true;
   });
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(received_annotations);
 }

 // Verifies that WatchAnnotations() returns all annotations when any annotation
 // is updated, not just the changed one.
 TEST_F(AnnotationsManagerTest, WatchAnnotationsReturnsAllAnnotations) {
   AnnotationsManager annotations;

   fuchsia::element::AnnotationControllerPtr controller;
   annotations.Connect(controller.NewRequest());

   // Set multiple annotations.
   std::vector<fuchsia::element::Annotation> annotations_to_set;
   annotations_to_set.push_back(
       MakeAnnotation(kAnnotationName1, kAnnotationValue1));
   annotations_to_set.push_back(
       MakeAnnotation(kAnnotationName2, kAnnotationValue2));
   annotations.UpdateAnnotations(std::move(annotations_to_set));

   // Dispatch an initial watch, that will return immediately.
   bool received_annotations = false;
   controller->WatchAnnotations([&received_annotations](auto annotations) {
     EXPECT_EQ(annotations.response().annotations.size(), 2u);
     received_annotations = true;
   });
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(received_annotations);

   // Update a single annotation, then call WatchAnnotations() again to verify
   // that all annotations including unchanged ones are returned.
   std::vector<fuchsia::element::Annotation> to_set;
   to_set.push_back(MakeAnnotation(kAnnotationName1, kAnnotationValue2));
   annotations.UpdateAnnotations(std::move(to_set));
   received_annotations = false;
   controller->WatchAnnotations([&received_annotations](auto annotations) {
     EXPECT_EQ(annotations.response().annotations.size(), 2u);
     received_annotations = true;
   });
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(received_annotations);
 }

 // Verifies insertion of a new annotation via UpdateAnnotations().
 TEST_F(AnnotationsManagerTest, UpdateAnnotationsSetsAnnotations) {
   AnnotationsManager annotations;

   auto all_annotations = annotations.GetAnnotations();
   ASSERT_EQ(all_annotations.size(), 0u);

   std::vector<fuchsia::element::Annotation> to_set;
   to_set.push_back(MakeAnnotation(kAnnotationName1, kAnnotationValue1));
   annotations.UpdateAnnotations(std::move(to_set));

   all_annotations = annotations.GetAnnotations();
   ASSERT_EQ(all_annotations.size(), 1u);
   EXPECT_EQ(all_annotations[0].key.value, kAnnotationName1);
   ASSERT_TRUE(all_annotations[0].value.is_text());
   EXPECT_EQ(all_annotations[0].value.text(), kAnnotationValue1);
 }

 // Verifies update of existing annotation via UpdateAnnotations().
 TEST_F(AnnotationsManagerTest, UpdateAnnotationsUpdatesAnnotations) {
   AnnotationsManager annotations;

   std::vector<fuchsia::element::Annotation> to_set;
   to_set.push_back(MakeAnnotation(kAnnotationName1, kAnnotationValue1));
   annotations.UpdateAnnotations(std::move(to_set));
   to_set.push_back(MakeAnnotation(kAnnotationName1, kAnnotationValue2));
   annotations.UpdateAnnotations(std::move(to_set));

   auto all_annotations = annotations.GetAnnotations();
   ASSERT_EQ(all_annotations.size(), 1u);
   EXPECT_EQ(all_annotations[0].key.value, kAnnotationName1);
   ASSERT_TRUE(all_annotations[0].value.is_text());
   EXPECT_EQ(all_annotations[0].value.text(), kAnnotationValue2);
 }

 // Verifies that multiple annotations can be updated or insert in a single call.
 TEST_F(AnnotationsManagerTest, UpdateAnnotationsMultipleAnnotations) {
   AnnotationsManager annotations;

   std::vector<fuchsia::element::Annotation> annotations_to_set;
   annotations_to_set.push_back(
       MakeAnnotation(kAnnotationName1, kAnnotationValue1));
   annotations_to_set.push_back(
       MakeAnnotation(kAnnotationName2, kAnnotationValue2));
   annotations.UpdateAnnotations(std::move(annotations_to_set));

   auto all_annotations = annotations.GetAnnotations();
   ASSERT_EQ(all_annotations.size(), 2u);
   EXPECT_EQ(all_annotations[0].key.value, kAnnotationName1);
   ASSERT_TRUE(all_annotations[0].value.is_text());
   EXPECT_EQ(all_annotations[0].value.text(), kAnnotationValue1);
   EXPECT_EQ(all_annotations[1].key.value, kAnnotationName2);
   ASSERT_TRUE(all_annotations[1].value.is_text());
   EXPECT_EQ(all_annotations[1].value.text(), kAnnotationValue2);
 }

 // Verifies that the controller fails the operation if duplicate annotations
 // appear in the same bulk-UpdateAnnotations operation.
 TEST_F(AnnotationsManagerTest,
        UpdateAnnotationsMultipleAnnotations_WithDuplicate) {
   AnnotationsManager annotations;

   std::vector<fuchsia::element::Annotation> annotations_to_set;
   annotations_to_set.push_back(
       MakeAnnotation(kAnnotationName1, kAnnotationValue1));
   annotations_to_set.push_back(
       MakeAnnotation(kAnnotationName1, kAnnotationValue2));

   EXPECT_FALSE(annotations.UpdateAnnotations(std::move(annotations_to_set)));
 }

 }  // namespace

 }  // namespace fuchsia_component_support
	// Copyright 2022 The Chromium Authors
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "components/fuchsia_component_support/annotations_manager.h"

	#include "base/fuchsia/mem_buffer_util.h"
	#include "base/test/gtest_util.h"
	#include "base/test/task_environment.h"
	#include "testing/gtest/include/gtest/gtest.h"

	namespace fuchsia_component_support {

	namespace {

	class AnnotationsManagerTest : public testing::Test {
	protected:
	AnnotationsManagerTest() = default;

	base::test::SingleThreadTaskEnvironment task_environment_{
	base::test::SingleThreadTaskEnvironment::MainThreadType::IO};
	};

	constexpr char kGlobalNamespace[] = "global";

	constexpr char kAnnotationName1[] = "annotation1";
	constexpr char kAnnotationName2[] = "annotation2";

	constexpr char kAnnotationValue1[] = "annotation_value1";
	constexpr char kAnnotationValue2[] = "annotation_value2";

	TEST(MakeAnnotationTest, KeyNamespaceAndName) {
	auto annotation = MakeAnnotation(kAnnotationName1, "ignored");
	EXPECT_EQ(annotation.key.namespace_, kGlobalNamespace);
	EXPECT_EQ(annotation.key.value, kAnnotationName1);
	}

	TEST(MakeAnnotationTest, BooleanValue) {
	auto annotation = MakeBoolAnnotation(kAnnotationName1, true);
	ASSERT_TRUE(annotation.value.is_text());
	EXPECT_EQ(annotation.value.text(), "true");
	}

	TEST(MakeAnnotationTest, IntegerValue) {
	auto annotation = MakeIntAnnotation(kAnnotationName1, 12345678);
	ASSERT_TRUE(annotation.value.is_text());
	EXPECT_EQ(annotation.value.text(), "12345678");
	}

	TEST(MakeAnnotationTest, TextValue) {
	constexpr char kSmallText[] = "This is a short text annotation";
	auto annotation = MakeAnnotation(kAnnotationName1, kSmallText);
	ASSERT_TRUE(annotation.value.is_text());
	EXPECT_EQ(annotation.value.text(), kSmallText);
	}

	TEST(MakeAnnotationTest, LargeTextValue) {
	const std::string large_text(1024, 'a');
	auto annotation = MakeAnnotation(kAnnotationName1, large_text);
	ASSERT_TRUE(annotation.value.is_buffer());
	auto value = base::StringFromMemBuffer(annotation.value.buffer());
	EXPECT_EQ(value, large_text);
	}

	// Basic verification that a single client can connect.
	TEST_F(AnnotationsManagerTest, SingleClient) {
	AnnotationsManager annotations;

	fuchsia::element::AnnotationControllerPtr ptr;
	annotations.Connect(ptr.NewRequest());
	}

	// Verifies that multiple clients can connect.
	TEST_F(AnnotationsManagerTest, MultipleClients) {
	AnnotationsManager annotations;

	fuchsia::element::AnnotationControllerPtr ptr1;
	annotations.Connect(ptr1.NewRequest());
	fuchsia::element::AnnotationControllerPtr ptr2;
	annotations.Connect(ptr2.NewRequest());
	}

	// Verifies that WatchAnnotations() hanging-get behaviour:
	// - first call returns all annotations.
	// - watch when nothing has changed "hangs" until the next change.
	// - watch after a change returns immediately.
	TEST_F(AnnotationsManagerTest, WatchAnnotationsHangingGet) {
	AnnotationsManager annotations;

	fuchsia::element::AnnotationControllerPtr controller;
	annotations.Connect(controller.NewRequest());

	// Dispatch an initial watch, that will return immediately.
	bool received_annotations = false;
	controller->WatchAnnotations([&received_annotations](auto annotations) {
	EXPECT_EQ(annotations.response().annotations.size(), 0u);
	received_annotations = true;
	});
	base::RunLoop().RunUntilIdle();
	EXPECT_TRUE(received_annotations);

	// Set a new watch, which should not return immediately, since nothing has
	// changed.
	received_annotations = false;
	controller->WatchAnnotations([&received_annotations](auto annotations) {
	EXPECT_EQ(annotations.response().annotations.size(), 1u);
	received_annotations = true;
	});
	base::RunLoop().RunUntilIdle();
	EXPECT_FALSE(received_annotations);

	// Set an annotation and spin the loop, to verify that the update is reported.
	std::vector<fuchsia::element::Annotation> to_set;
	to_set.push_back(MakeAnnotation(kAnnotationName1, kAnnotationValue1));
	annotations.UpdateAnnotations(std::move(to_set));
	base::RunLoop().RunUntilIdle();
	EXPECT_TRUE(received_annotations);

	// Change the annotation and spin the loop, then call WatchAnnotations() to
	// verify that it returns immediately.
	to_set.clear();
	to_set.push_back(MakeAnnotation(kAnnotationName1, kAnnotationValue2));
	annotations.UpdateAnnotations(std::move(to_set));
	received_annotations = false;
	controller->WatchAnnotations([&received_annotations](auto annotations) {
	EXPECT_EQ(annotations.response().annotations.size(), 1u);
	received_annotations = true;
	});
	base::RunLoop().RunUntilIdle();
	EXPECT_TRUE(received_annotations);
	}

	// Verifies that WatchAnnotations() returns all annotations when any annotation
	// is updated, not just the changed one.
	TEST_F(AnnotationsManagerTest, WatchAnnotationsReturnsAllAnnotations) {
	AnnotationsManager annotations;

	fuchsia::element::AnnotationControllerPtr controller;
	annotations.Connect(controller.NewRequest());

	// Set multiple annotations.
	std::vector<fuchsia::element::Annotation> annotations_to_set;
	annotations_to_set.push_back(
	MakeAnnotation(kAnnotationName1, kAnnotationValue1));
	annotations_to_set.push_back(
	MakeAnnotation(kAnnotationName2, kAnnotationValue2));
	annotations.UpdateAnnotations(std::move(annotations_to_set));

	// Dispatch an initial watch, that will return immediately.
	bool received_annotations = false;
	controller->WatchAnnotations([&received_annotations](auto annotations) {
	EXPECT_EQ(annotations.response().annotations.size(), 2u);
	received_annotations = true;
	});
	base::RunLoop().RunUntilIdle();
	EXPECT_TRUE(received_annotations);

	// Update a single annotation, then call WatchAnnotations() again to verify
	// that all annotations including unchanged ones are returned.
	std::vector<fuchsia::element::Annotation> to_set;
	to_set.push_back(MakeAnnotation(kAnnotationName1, kAnnotationValue2));
	annotations.UpdateAnnotations(std::move(to_set));
	received_annotations = false;
	controller->WatchAnnotations([&received_annotations](auto annotations) {
	EXPECT_EQ(annotations.response().annotations.size(), 2u);
	received_annotations = true;
	});
	base::RunLoop().RunUntilIdle();
	EXPECT_TRUE(received_annotations);
	}

	// Verifies insertion of a new annotation via UpdateAnnotations().
	TEST_F(AnnotationsManagerTest, UpdateAnnotationsSetsAnnotations) {
	AnnotationsManager annotations;

	auto all_annotations = annotations.GetAnnotations();
	ASSERT_EQ(all_annotations.size(), 0u);

	std::vector<fuchsia::element::Annotation> to_set;
	to_set.push_back(MakeAnnotation(kAnnotationName1, kAnnotationValue1));
	annotations.UpdateAnnotations(std::move(to_set));

	all_annotations = annotations.GetAnnotations();
	ASSERT_EQ(all_annotations.size(), 1u);
	EXPECT_EQ(all_annotations[0].key.value, kAnnotationName1);
	ASSERT_TRUE(all_annotations[0].value.is_text());
	EXPECT_EQ(all_annotations[0].value.text(), kAnnotationValue1);
	}

	// Verifies update of existing annotation via UpdateAnnotations().
	TEST_F(AnnotationsManagerTest, UpdateAnnotationsUpdatesAnnotations) {
	AnnotationsManager annotations;

	std::vector<fuchsia::element::Annotation> to_set;
	to_set.push_back(MakeAnnotation(kAnnotationName1, kAnnotationValue1));
	annotations.UpdateAnnotations(std::move(to_set));
	to_set.push_back(MakeAnnotation(kAnnotationName1, kAnnotationValue2));
	annotations.UpdateAnnotations(std::move(to_set));

	auto all_annotations = annotations.GetAnnotations();
	ASSERT_EQ(all_annotations.size(), 1u);
	EXPECT_EQ(all_annotations[0].key.value, kAnnotationName1);
	ASSERT_TRUE(all_annotations[0].value.is_text());
	EXPECT_EQ(all_annotations[0].value.text(), kAnnotationValue2);
	}

	// Verifies that multiple annotations can be updated or insert in a single call.
	TEST_F(AnnotationsManagerTest, UpdateAnnotationsMultipleAnnotations) {
	AnnotationsManager annotations;

	std::vector<fuchsia::element::Annotation> annotations_to_set;
	annotations_to_set.push_back(
	MakeAnnotation(kAnnotationName1, kAnnotationValue1));
	annotations_to_set.push_back(
	MakeAnnotation(kAnnotationName2, kAnnotationValue2));
	annotations.UpdateAnnotations(std::move(annotations_to_set));

	auto all_annotations = annotations.GetAnnotations();
	ASSERT_EQ(all_annotations.size(), 2u);
	EXPECT_EQ(all_annotations[0].key.value, kAnnotationName1);
	ASSERT_TRUE(all_annotations[0].value.is_text());
	EXPECT_EQ(all_annotations[0].value.text(), kAnnotationValue1);
	EXPECT_EQ(all_annotations[1].key.value, kAnnotationName2);
	ASSERT_TRUE(all_annotations[1].value.is_text());
	EXPECT_EQ(all_annotations[1].value.text(), kAnnotationValue2);
	}

	// Verifies that the controller fails the operation if duplicate annotations
	// appear in the same bulk-UpdateAnnotations operation.
	TEST_F(AnnotationsManagerTest,
	UpdateAnnotationsMultipleAnnotations_WithDuplicate) {
	AnnotationsManager annotations;

	std::vector<fuchsia::element::Annotation> annotations_to_set;
	annotations_to_set.push_back(
	MakeAnnotation(kAnnotationName1, kAnnotationValue1));
	annotations_to_set.push_back(
	MakeAnnotation(kAnnotationName1, kAnnotationValue2));

	EXPECT_FALSE(annotations.UpdateAnnotations(std::move(annotations_to_set)));
	}

	} // namespace

	} // namespace fuchsia_component_support