714 lines
26 KiB
C++
714 lines
26 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#include "nsWindowsShellServiceInternal.h"
|
|
#include "gtest/gtest.h"
|
|
#include "gtest/FOGFixture.h"
|
|
#include "mozilla/glean/fog_ffi_generated.h"
|
|
#include <iostream>
|
|
|
|
using namespace mozilla;
|
|
using namespace mozilla::glean::impl;
|
|
using namespace mozilla::glean::pinning_windows;
|
|
|
|
namespace telemetry_event {
|
|
|
|
template <typename event_type>
|
|
bool IsValidButEmpty(const event_type& event) {
|
|
auto value = event.TestGetValue();
|
|
if (!value.isOk()) {
|
|
return false;
|
|
}
|
|
|
|
if (value.unwrap().isSome()) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
template <typename event_type>
|
|
bool CountsMatch(const event_type& event, size_t count) {
|
|
auto value = event.TestGetValue();
|
|
if (!value.isOk()) {
|
|
return false;
|
|
}
|
|
|
|
auto unwrapped = value.unwrap();
|
|
if (!unwrapped.isSome()) {
|
|
return false;
|
|
}
|
|
|
|
if (unwrapped.ref().Length() != count) {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
} // namespace telemetry_event
|
|
|
|
template <typename event_extra_type>
|
|
static std::map<nsCString, nsCString> CreateKeyValuePairs(
|
|
const event_extra_type& eventExtras) {
|
|
auto serializedExtras = eventExtras.ToFfiExtra();
|
|
auto keys = std::move(std::get<0>(serializedExtras));
|
|
auto values = std::move(std::get<1>(serializedExtras));
|
|
|
|
if (keys.Length() != values.Length()) {
|
|
MOZ_ASSERT(false);
|
|
return std::map<nsCString, nsCString>();
|
|
}
|
|
|
|
std::map<nsCString, nsCString> result;
|
|
for (size_t i = 0; i < keys.Length(); i++) {
|
|
result[keys[i]] = values[i];
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
template <typename extra_type>
|
|
bool IsEqual(const extra_type& control,
|
|
mozilla::glean::impl::RecordedEvent& event) {
|
|
// generate a map from the control data
|
|
std::map<nsCString, nsCString> controlMap = CreateKeyValuePairs(control);
|
|
|
|
if (controlMap.size() != event.mExtra.Length()) {
|
|
return false;
|
|
}
|
|
|
|
// now walk through the event data and check
|
|
for (size_t i = 0; i < event.mExtra.Length(); i++) {
|
|
const auto& key = std::get<0>(event.mExtra[i]);
|
|
const auto& value = std::get<1>(event.mExtra[i]);
|
|
|
|
auto iterator = controlMap.find(key);
|
|
if (iterator == controlMap.end()) {
|
|
return false;
|
|
}
|
|
|
|
if (iterator->second != value) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
template <typename extra_type>
|
|
bool IsEqual(const extra_type& control, const extra_type& generated) {
|
|
std::map<nsCString, nsCString> controlMap = CreateKeyValuePairs(control);
|
|
std::map<nsCString, nsCString> generatedMap = CreateKeyValuePairs(generated);
|
|
|
|
if (controlMap.size() != generatedMap.size()) {
|
|
return false;
|
|
}
|
|
|
|
for (auto i : controlMap) {
|
|
auto found = generatedMap.find(i.first);
|
|
if (found == generatedMap.end()) {
|
|
return false;
|
|
}
|
|
|
|
if (found->second != i.second) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
class WindowsPinningShortcutTestFixture : public FOGFixture {};
|
|
|
|
MOZ_DEFINE_ENUM_CLASS(PinningShortcutOperation,
|
|
(Succeed, FailFileNotFound, FailError, FailEmptyOnFind));
|
|
|
|
static const char* EnumName(PinningShortcutOperation operation) {
|
|
switch (operation) {
|
|
case PinningShortcutOperation::Succeed:
|
|
return "PinningShortcutOperation::Succeed";
|
|
|
|
case PinningShortcutOperation::FailFileNotFound:
|
|
return "PinningShortcutOperation::FailFileNotFound";
|
|
|
|
case PinningShortcutOperation::FailError:
|
|
return "PinningShortcutOperation::FailError";
|
|
|
|
case PinningShortcutOperation::FailEmptyOnFind:
|
|
return "PinningShortcutOperation::FailEmptyOnFind";
|
|
|
|
default:
|
|
MOZ_ASSERT(false);
|
|
return "PinningShortcutOperation::UNDEFINED";
|
|
}
|
|
}
|
|
|
|
MOZ_DEFINE_ENUM_CLASS(PinningFallbackOperation, (Succeed, Fail));
|
|
|
|
static const char* EnumName(PinningFallbackOperation operation) {
|
|
switch (operation) {
|
|
case PinningFallbackOperation::Succeed:
|
|
return "PinningFallbackOperation::Succeed";
|
|
|
|
case PinningFallbackOperation::Fail:
|
|
return "PinningFallbackOperation::Fail";
|
|
|
|
default:
|
|
MOZ_ASSERT(false);
|
|
return "PinningFallbackOperation::UNDEFINED";
|
|
}
|
|
}
|
|
|
|
static const char* EnumName(Win11PinToTaskBarResultStatus operation) {
|
|
switch (operation) {
|
|
case Win11PinToTaskBarResultStatus::Success:
|
|
return "Win11PinToTaskBarResultStatus::Success";
|
|
|
|
case Win11PinToTaskBarResultStatus::Failed:
|
|
return "Win11PinToTaskBarResultStatus::Failed";
|
|
|
|
case Win11PinToTaskBarResultStatus::NotCurrentlyAllowed:
|
|
return "Win11PinToTaskBarResultStatus::NotCurrentlyAllowed";
|
|
|
|
case Win11PinToTaskBarResultStatus::AlreadyPinned:
|
|
return "Win11PinToTaskBarResultStatus::AlreadyPinned";
|
|
|
|
case Win11PinToTaskBarResultStatus::NotSupported:
|
|
return "Win11PinToTaskBarResultStatus::NotSupported";
|
|
|
|
case Win11PinToTaskBarResultStatus::ErrorLimitedAccessFeatures:
|
|
return "Win11PinToTaskBarResultStatus::ErrorLimitedAccessFeatures";
|
|
|
|
case Win11PinToTaskBarResultStatus::LimitedAccessFeaturesLocked:
|
|
return "Win11PinToTaskBarResultStatus::LimitedAccessFeaturesLocked";
|
|
|
|
default:
|
|
MOZ_ASSERT(false);
|
|
return "Win11PinToTaskBarResultStatus::UNDEFINED";
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Mock version of PinCurrentAppToTaskbarHelper.
|
|
*
|
|
* Takes the values to return from the methods and returns them
|
|
* to mock results for testing telemetry events are generated
|
|
* properly by PinCurrentAppToTaskbarImpl.
|
|
*/
|
|
class PinCurrentAppToTaskbarHelperMetricsTesting
|
|
: public PinCurrentAppToTaskbarHelper {
|
|
public:
|
|
PinCurrentAppToTaskbarHelperMetricsTesting(
|
|
PinningShortcutOperation shortcutOperation,
|
|
Win11PinToTaskBarResultStatus apiOperation,
|
|
PinningFallbackOperation fallbackOperation);
|
|
|
|
void CheckNotMainThread() override {}
|
|
|
|
mozilla::Result<bool, nsresult> CreateShortcutForTaskbar(
|
|
bool aCheckOnly, bool aPrivateBrowsing, const nsAString& aAppUserModelId,
|
|
const nsAString& aShortcutName, const nsAString& aShortcutSubstring,
|
|
nsIFile* aShortcutsLogDir, nsIFile* aGreDir, nsIFile* aProgramsDir,
|
|
nsAutoString& aShortcutPath) override;
|
|
|
|
Win11PinToTaskBarResult PinCurrentAppViaAPI(
|
|
bool aCheckOnly, const nsAString& aAppUserModelId,
|
|
nsAutoString aShortcutPath) override;
|
|
|
|
nsresult PinCurrentAppFallback(bool aCheckOnly,
|
|
const nsAString& aAppUserModelId,
|
|
const nsAString& aShortcutPath) override;
|
|
|
|
private:
|
|
PinningShortcutOperation mShortcutOperation;
|
|
Win11PinToTaskBarResultStatus mApiOperation;
|
|
PinningFallbackOperation mFallbackOperation;
|
|
};
|
|
|
|
inline PinCurrentAppToTaskbarHelperMetricsTesting::
|
|
PinCurrentAppToTaskbarHelperMetricsTesting(
|
|
PinningShortcutOperation shortcutOperation,
|
|
Win11PinToTaskBarResultStatus apiOperation,
|
|
PinningFallbackOperation fallbackOperation)
|
|
: mShortcutOperation(shortcutOperation),
|
|
mApiOperation(apiOperation),
|
|
mFallbackOperation(fallbackOperation) {}
|
|
|
|
inline mozilla::Result<bool, nsresult>
|
|
PinCurrentAppToTaskbarHelperMetricsTesting::CreateShortcutForTaskbar(
|
|
bool aCheckOnly, bool aPrivateBrowsing, const nsAString& aAppUserModelId,
|
|
const nsAString& aShortcutName, const nsAString& aShortcutSubstring,
|
|
nsIFile* aShortcutsLogDir, nsIFile* aGreDir, nsIFile* aProgramsDir,
|
|
nsAutoString& aShortcutPath) {
|
|
using namespace mozilla;
|
|
|
|
switch (mShortcutOperation) {
|
|
case PinningShortcutOperation::Succeed:
|
|
return true;
|
|
|
|
case PinningShortcutOperation::FailFileNotFound:
|
|
return Err(NS_ERROR_FILE_NOT_FOUND);
|
|
|
|
case PinningShortcutOperation::FailError:
|
|
return Err(NS_ERROR_FAILURE);
|
|
|
|
case PinningShortcutOperation::FailEmptyOnFind:
|
|
return false;
|
|
|
|
default:
|
|
MOZ_ASSERT(false);
|
|
return Err(NS_ERROR_FAILURE);
|
|
}
|
|
}
|
|
|
|
inline Win11PinToTaskBarResult
|
|
PinCurrentAppToTaskbarHelperMetricsTesting::PinCurrentAppViaAPI(
|
|
bool aCheckOnly, const nsAString& aAppUserModelId,
|
|
nsAutoString aShortcutPath) {
|
|
const int numAttempts = 1;
|
|
return {S_OK, mApiOperation, numAttempts};
|
|
}
|
|
|
|
inline nsresult
|
|
PinCurrentAppToTaskbarHelperMetricsTesting::PinCurrentAppFallback(
|
|
bool aCheckOnly, const nsAString& aAppUserModelId,
|
|
const nsAString& aShortcutPath) {
|
|
switch (mFallbackOperation) {
|
|
case PinningFallbackOperation::Fail:
|
|
return NS_ERROR_FAILURE;
|
|
|
|
case PinningFallbackOperation::Succeed:
|
|
return NS_OK;
|
|
|
|
default:
|
|
MOZ_ASSERT(false);
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
}
|
|
|
|
static void TestPinning(bool aCheckOnly,
|
|
PinningShortcutOperation shortcutOperation,
|
|
Win11PinToTaskBarResultStatus apiOperation,
|
|
PinningFallbackOperation fallbackOperation,
|
|
bool privateBrowsing = false) {
|
|
UniquePtr<PinCurrentAppToTaskbarHelper> helper(
|
|
new PinCurrentAppToTaskbarHelperMetricsTesting(
|
|
shortcutOperation, apiOperation, fallbackOperation));
|
|
|
|
auto appUserModelId = u""_ns;
|
|
auto shortcutName = u""_ns;
|
|
auto shortcutSubstring = u""_ns;
|
|
nsIFile* shortcutsLogDir = nullptr;
|
|
nsIFile* greDir = nullptr;
|
|
nsIFile* programsDir = nullptr;
|
|
PinCurrentAppToTaskbarImpl(aCheckOnly, privateBrowsing, appUserModelId,
|
|
shortcutName, shortcutSubstring, shortcutsLogDir,
|
|
greDir, programsDir, std::move(helper));
|
|
}
|
|
|
|
struct ShortcutTestCase {
|
|
PinningShortcutOperation operation;
|
|
nsresult expectedResult;
|
|
ShortcutCreatedExtra expectedExtras;
|
|
|
|
friend void PrintTo(const ShortcutTestCase& testCase, std::ostream* os) {
|
|
*os << "(With operation " << EnumName(testCase.operation)
|
|
<< ", expected result event text == " << int(testCase.expectedResult)
|
|
<< " and expectedExtras with result text == "
|
|
<< testCase.expectedExtras.result << ")";
|
|
}
|
|
};
|
|
|
|
class WindowsPinningShortcuts : public FOGFixtureWithParam<ShortcutTestCase> {};
|
|
|
|
TEST_P(
|
|
WindowsPinningShortcuts,
|
|
WindowsPinningTestShortcutTelemetryEventCreationCheckOnlyPrivateBrowsingOn) {
|
|
auto testCase = GetParam();
|
|
const bool checkOnly = true;
|
|
const bool privateBrowsing = true;
|
|
testCase.expectedExtras.privateBrowsing = Some(privateBrowsing);
|
|
|
|
TestPinning(checkOnly, testCase.operation,
|
|
Win11PinToTaskBarResultStatus::Success,
|
|
PinningFallbackOperation::Succeed, privateBrowsing);
|
|
|
|
EXPECT_TRUE(telemetry_event::IsValidButEmpty(shortcut_created));
|
|
}
|
|
|
|
TEST_P(
|
|
WindowsPinningShortcuts,
|
|
WindowsPinningTestShortcutTelemetryEventCreationCheckOnlyPrivateBrowsingOff) {
|
|
auto testCase = GetParam();
|
|
const bool checkOnly = true;
|
|
const bool privateBrowsing = false;
|
|
testCase.expectedExtras.privateBrowsing = Some(privateBrowsing);
|
|
|
|
TestPinning(checkOnly, testCase.operation,
|
|
Win11PinToTaskBarResultStatus::Success,
|
|
PinningFallbackOperation::Succeed, privateBrowsing);
|
|
|
|
EXPECT_TRUE(telemetry_event::IsValidButEmpty(shortcut_created));
|
|
}
|
|
|
|
TEST_P(WindowsPinningShortcuts,
|
|
WindowsPinningTestShortcutTelemetryEventCreationPrivateBrowsingOn) {
|
|
auto testCase = GetParam();
|
|
const bool doFullPinningFlow = false;
|
|
const bool privateBrowsing = true;
|
|
testCase.expectedExtras.privateBrowsing = Some(privateBrowsing);
|
|
|
|
TestPinning(doFullPinningFlow, testCase.operation,
|
|
Win11PinToTaskBarResultStatus::Success,
|
|
PinningFallbackOperation::Succeed, privateBrowsing);
|
|
|
|
auto extras = telemetry::shortcut::CreateEventExtra(testCase.expectedResult,
|
|
privateBrowsing);
|
|
|
|
// confirm that the event extras creation works as expected
|
|
EXPECT_TRUE(IsEqual(testCase.expectedExtras, extras));
|
|
|
|
size_t one = 1;
|
|
EXPECT_TRUE(telemetry_event::CountsMatch(shortcut_created, one));
|
|
|
|
auto metricsEvents = shortcut_created.TestGetValue().unwrap().ref();
|
|
|
|
auto control = testCase.expectedExtras;
|
|
EXPECT_TRUE(IsEqual(control, metricsEvents[0]));
|
|
}
|
|
|
|
TEST_P(WindowsPinningShortcuts,
|
|
WindowsPinningTestShortcutTelemetryEventCreationPrivateBrowsingOff) {
|
|
auto testCase = GetParam();
|
|
const bool doFullPinningFlow = false;
|
|
const bool privateBrowsing = false;
|
|
testCase.expectedExtras.privateBrowsing = Some(privateBrowsing);
|
|
|
|
TestPinning(doFullPinningFlow, testCase.operation,
|
|
Win11PinToTaskBarResultStatus::Success,
|
|
PinningFallbackOperation::Succeed, privateBrowsing);
|
|
|
|
auto extras = telemetry::shortcut::CreateEventExtra(testCase.expectedResult,
|
|
privateBrowsing);
|
|
|
|
// confirm that the event extras creation works as expected
|
|
EXPECT_TRUE(IsEqual(testCase.expectedExtras, extras));
|
|
|
|
size_t one = 1;
|
|
EXPECT_TRUE(telemetry_event::CountsMatch(shortcut_created, one));
|
|
|
|
auto metricsEvents = shortcut_created.TestGetValue().unwrap().ref();
|
|
|
|
auto control = testCase.expectedExtras;
|
|
EXPECT_TRUE(IsEqual(control, metricsEvents[0]));
|
|
}
|
|
|
|
static const ShortcutTestCase shortcutTestCases[] = {
|
|
{.operation = PinningShortcutOperation::FailFileNotFound,
|
|
.expectedResult = NS_ERROR_FILE_NOT_FOUND,
|
|
.expectedExtras = {.fileNotFound = Some(true),
|
|
.privateBrowsing = Some(false),
|
|
.result = Some(
|
|
telemetry::shortcut::TELEMETRY_FILE_NOT_FOUND)}},
|
|
{.operation = PinningShortcutOperation::FailError,
|
|
.expectedResult = NS_ERROR_FAILURE,
|
|
.expectedExtras = {.error = Some(true),
|
|
.privateBrowsing = Some(false),
|
|
.result = Some(telemetry::shortcut::TELEMETRY_ERROR)}},
|
|
{.operation = PinningShortcutOperation::Succeed,
|
|
.expectedResult = NS_OK,
|
|
.expectedExtras = {.privateBrowsing = Some(false),
|
|
.result = Some(telemetry::shortcut::TELEMETRY_SUCCESS),
|
|
.success = Some(true)}},
|
|
};
|
|
|
|
INSTANTIATE_TEST_SUITE_P(WindowsPinningShortcutTelemetryTests,
|
|
WindowsPinningShortcuts,
|
|
::testing::ValuesIn(shortcutTestCases));
|
|
|
|
TEST_F(WindowsPinningShortcutTestFixture,
|
|
TestShortcutFailOnEmptyFindPrivateBrowsingOn) {
|
|
const bool privateBrowsing = true;
|
|
|
|
// special case FailEmptyOnFind. That should not generate an event at all
|
|
TestPinning(true, PinningShortcutOperation::FailEmptyOnFind,
|
|
Win11PinToTaskBarResultStatus::Success,
|
|
PinningFallbackOperation::Succeed, privateBrowsing);
|
|
EXPECT_TRUE(telemetry_event::IsValidButEmpty(shortcut_created));
|
|
|
|
TestResetFOG();
|
|
|
|
TestPinning(false, PinningShortcutOperation::FailEmptyOnFind,
|
|
Win11PinToTaskBarResultStatus::Success,
|
|
PinningFallbackOperation::Succeed, privateBrowsing);
|
|
EXPECT_TRUE(telemetry_event::IsValidButEmpty(shortcut_created));
|
|
}
|
|
|
|
TEST_F(WindowsPinningShortcutTestFixture,
|
|
TestShortcutFailOnEmptyFindPrivateBrowsingOff) {
|
|
const bool privateBrowsing = false;
|
|
|
|
// special case FailEmptyOnFind. That should not generate an event at all
|
|
TestPinning(true, PinningShortcutOperation::FailEmptyOnFind,
|
|
Win11PinToTaskBarResultStatus::Success,
|
|
PinningFallbackOperation::Succeed, privateBrowsing);
|
|
EXPECT_TRUE(telemetry_event::IsValidButEmpty(shortcut_created));
|
|
|
|
TestResetFOG();
|
|
|
|
TestPinning(false, PinningShortcutOperation::FailEmptyOnFind,
|
|
Win11PinToTaskBarResultStatus::Success,
|
|
PinningFallbackOperation::Succeed, privateBrowsing);
|
|
EXPECT_TRUE(telemetry_event::IsValidButEmpty(shortcut_created));
|
|
}
|
|
|
|
struct PinningAPITestCase {
|
|
Win11PinToTaskBarResultStatus result;
|
|
PinnedToTaskbarExtra expectedExtras;
|
|
|
|
friend void PrintTo(const PinningAPITestCase& testCase, std::ostream* os) {
|
|
*os << "(For pinning api operation == " << EnumName(testCase.result)
|
|
<< ", expectedExtras result text should == "
|
|
<< testCase.expectedExtras.result << ")";
|
|
}
|
|
};
|
|
|
|
class WindowsPinningAPIFixture
|
|
: public FOGFixtureWithParam<PinningAPITestCase> {};
|
|
|
|
TEST_P(WindowsPinningAPIFixture,
|
|
WindowsPinningTestTelemetryEventCreationCheckOnlyPrivateBrowsingOn) {
|
|
const auto testCase = GetParam();
|
|
const bool checkOnly = true;
|
|
const bool privateBrowsing = true;
|
|
TestPinning(checkOnly, PinningShortcutOperation::Succeed, testCase.result,
|
|
PinningFallbackOperation::Succeed, privateBrowsing);
|
|
|
|
// confirm we don't generate events when checking only
|
|
EXPECT_TRUE(telemetry_event::IsValidButEmpty(pinned_to_taskbar));
|
|
}
|
|
|
|
TEST_P(WindowsPinningAPIFixture,
|
|
WindowsPinningTestTelemetryEventCreationCheckOnlyPrivateBrowsingOff) {
|
|
const auto testCase = GetParam();
|
|
const bool checkOnly = true;
|
|
const bool privateBrowsing = false;
|
|
TestPinning(checkOnly, PinningShortcutOperation::Succeed, testCase.result,
|
|
PinningFallbackOperation::Succeed, privateBrowsing);
|
|
|
|
// confirm we don't generate events when checking only
|
|
EXPECT_TRUE(telemetry_event::IsValidButEmpty(pinned_to_taskbar));
|
|
}
|
|
|
|
static bool isFallbackSuccess(Win11PinToTaskBarResultStatus result) {
|
|
// fallback fails when the api succeeds
|
|
return (result != Win11PinToTaskBarResultStatus::Success) &&
|
|
(result != Win11PinToTaskBarResultStatus::AlreadyPinned);
|
|
}
|
|
|
|
TEST_P(WindowsPinningAPIFixture,
|
|
WindowsPinningTestTelemetryEventCreationPrivateBrowsingOn) {
|
|
auto testCase = GetParam();
|
|
const bool checkOnly = false;
|
|
const bool privateBrowsing = true;
|
|
testCase.expectedExtras.privateBrowsing = Some(privateBrowsing);
|
|
|
|
TestPinning(checkOnly, PinningShortcutOperation::Succeed, testCase.result,
|
|
PinningFallbackOperation::Succeed, privateBrowsing);
|
|
|
|
const bool fallbackSucceeded = isFallbackSuccess(testCase.result);
|
|
auto extras = telemetry::pinning::CreateEventExtra(
|
|
{S_OK, testCase.result, 1}, privateBrowsing, fallbackSucceeded);
|
|
|
|
EXPECT_TRUE(IsEqual(testCase.expectedExtras, extras));
|
|
|
|
size_t one = 1;
|
|
|
|
EXPECT_TRUE(telemetry_event::CountsMatch(pinned_to_taskbar, one));
|
|
|
|
auto metricsEvents = pinned_to_taskbar.TestGetValue().unwrap().ref();
|
|
auto control = testCase.expectedExtras;
|
|
EXPECT_TRUE(IsEqual(control, metricsEvents[0]));
|
|
}
|
|
|
|
TEST_P(WindowsPinningAPIFixture,
|
|
WindowsPinningTestTelemetryEventCreationPrivateBrowsingOff) {
|
|
auto testCase = GetParam();
|
|
const bool checkOnly = false;
|
|
const bool privateBrowsing = false;
|
|
testCase.expectedExtras.privateBrowsing = Some(privateBrowsing);
|
|
|
|
TestPinning(checkOnly, PinningShortcutOperation::Succeed, testCase.result,
|
|
PinningFallbackOperation::Succeed, privateBrowsing);
|
|
|
|
// fallback fails when the api succeeds
|
|
const bool fallbackSucceeded = isFallbackSuccess(testCase.result);
|
|
auto extras = telemetry::pinning::CreateEventExtra(
|
|
{S_OK, testCase.result, 1}, privateBrowsing, fallbackSucceeded);
|
|
|
|
EXPECT_TRUE(IsEqual(testCase.expectedExtras, extras));
|
|
|
|
size_t one = 1;
|
|
|
|
EXPECT_TRUE(telemetry_event::CountsMatch(pinned_to_taskbar, one));
|
|
|
|
auto metricsEvents = pinned_to_taskbar.TestGetValue().unwrap().ref();
|
|
auto control = testCase.expectedExtras;
|
|
EXPECT_TRUE(IsEqual(control, metricsEvents[0]));
|
|
}
|
|
|
|
static const PinningAPITestCase apiValidationTestCases[] = {
|
|
{.result = Win11PinToTaskBarResultStatus::NotSupported,
|
|
.expectedExtras = {.fallbackPinningSuccess =
|
|
Some(telemetry::pinning::TELEMETRY_SUCCESS),
|
|
.notSupported = Some(true),
|
|
.numberOfAttempts = Some(1),
|
|
.result =
|
|
Some(telemetry::pinning::TELEMETRY_NOT_SUPPORTED)}},
|
|
{.result = Win11PinToTaskBarResultStatus::Success,
|
|
.expectedExtras = {.fallbackPinningSuccess =
|
|
Some(telemetry::pinning::TELEMETRY_ERROR),
|
|
.numberOfAttempts = Some(1),
|
|
.result = Some(telemetry::pinning::TELEMETRY_SUCCESS),
|
|
.success = Some(true)}},
|
|
{.result = Win11PinToTaskBarResultStatus::AlreadyPinned,
|
|
.expectedExtras = {.alreadyPinned = Some(true),
|
|
.fallbackPinningSuccess =
|
|
Some(telemetry::pinning::TELEMETRY_ERROR),
|
|
.numberOfAttempts = Some(1),
|
|
.result = Some(
|
|
telemetry::pinning::TELEMETRY_ALREADY_PINNED)}},
|
|
{.result = Win11PinToTaskBarResultStatus::NotCurrentlyAllowed,
|
|
.expectedExtras =
|
|
{.fallbackPinningSuccess = Some(telemetry::pinning::TELEMETRY_SUCCESS),
|
|
.notCurrentlyAllowed = Some(true),
|
|
.numberOfAttempts = Some(1),
|
|
.result = Some(telemetry::pinning::TELEMETRY_NOT_CURRENTLY_ALLOWED)}},
|
|
{.result = Win11PinToTaskBarResultStatus::Failed,
|
|
.expectedExtras = {.error = Some(true),
|
|
.fallbackPinningSuccess =
|
|
Some(telemetry::pinning::TELEMETRY_SUCCESS),
|
|
.numberOfAttempts = Some(1),
|
|
.result = Some(telemetry::pinning::TELEMETRY_ERROR)}},
|
|
{.result = Win11PinToTaskBarResultStatus::ErrorLimitedAccessFeatures,
|
|
.expectedExtras =
|
|
{.errorLimitedAccessFeatures = Some(true),
|
|
.fallbackPinningSuccess = Some(telemetry::pinning::TELEMETRY_SUCCESS),
|
|
.numberOfAttempts = Some(1),
|
|
.result = Some(
|
|
telemetry::pinning::TELEMETRY_ERROR_LIMITED_ACCESS_FEATURES)}},
|
|
{.result = Win11PinToTaskBarResultStatus::LimitedAccessFeaturesLocked,
|
|
.expectedExtras =
|
|
{.fallbackPinningSuccess = Some(telemetry::pinning::TELEMETRY_SUCCESS),
|
|
.limitedAccessFeaturesLocked = Some(true),
|
|
.numberOfAttempts = Some(1),
|
|
.result = Some(
|
|
telemetry::pinning::TELEMETRY_LIMITED_ACCESS_FEATURES_LOCKED)}},
|
|
};
|
|
|
|
INSTANTIATE_TEST_SUITE_P(WindowsPinningAPITelemetryTests,
|
|
WindowsPinningAPIFixture,
|
|
::testing::ValuesIn(apiValidationTestCases));
|
|
|
|
class WindowsPinningAPIFallbackFixture
|
|
: public FOGFixtureWithParam<PinningAPITestCase> {};
|
|
|
|
TEST_P(WindowsPinningAPIFallbackFixture,
|
|
WindowsPinningTestFallbackFailsEventPrivateBrowsingOn) {
|
|
auto testCase = GetParam();
|
|
const bool checkOnly = false;
|
|
const bool privateBrowsing = true;
|
|
testCase.expectedExtras.privateBrowsing = Some(privateBrowsing);
|
|
|
|
TestPinning(checkOnly, PinningShortcutOperation::Succeed, testCase.result,
|
|
PinningFallbackOperation::Fail, privateBrowsing);
|
|
|
|
const bool fallbackSucceeded = false;
|
|
auto extras = telemetry::pinning::CreateEventExtra(
|
|
{S_OK, testCase.result, 1}, privateBrowsing, fallbackSucceeded);
|
|
|
|
EXPECT_TRUE(IsEqual(testCase.expectedExtras, extras));
|
|
|
|
auto metricsEvents = pinned_to_taskbar.TestGetValue().unwrap().ref();
|
|
auto control = testCase.expectedExtras;
|
|
EXPECT_TRUE(IsEqual(control, metricsEvents[0]));
|
|
}
|
|
|
|
TEST_P(WindowsPinningAPIFallbackFixture,
|
|
WindowsPinningTestFallbackFailsEventPrivateBrowsingOff) {
|
|
auto testCase = GetParam();
|
|
const bool checkOnly = false;
|
|
const bool privateBrowsing = false;
|
|
testCase.expectedExtras.privateBrowsing = Some(privateBrowsing);
|
|
|
|
TestPinning(checkOnly, PinningShortcutOperation::Succeed, testCase.result,
|
|
PinningFallbackOperation::Fail, privateBrowsing);
|
|
|
|
const bool fallbackSucceeded = false;
|
|
auto extras = telemetry::pinning::CreateEventExtra(
|
|
{S_OK, testCase.result, 1}, privateBrowsing, fallbackSucceeded);
|
|
|
|
EXPECT_TRUE(IsEqual(testCase.expectedExtras, extras));
|
|
|
|
auto metricsEvents = pinned_to_taskbar.TestGetValue().unwrap().ref();
|
|
auto control = testCase.expectedExtras;
|
|
EXPECT_TRUE(IsEqual(control, metricsEvents[0]));
|
|
}
|
|
|
|
static const PinningAPITestCase fallbackFailedTestCases[] = {
|
|
{.result = Win11PinToTaskBarResultStatus::NotSupported,
|
|
.expectedExtras = {.fallbackPinningSuccess =
|
|
Some(telemetry::pinning::TELEMETRY_ERROR),
|
|
.notSupported = Some(true),
|
|
.numberOfAttempts = Some(1),
|
|
.result =
|
|
Some(telemetry::pinning::TELEMETRY_NOT_SUPPORTED)}},
|
|
{.result = Win11PinToTaskBarResultStatus::Success,
|
|
.expectedExtras = {.fallbackPinningSuccess =
|
|
Some(telemetry::pinning::TELEMETRY_ERROR),
|
|
.numberOfAttempts = Some(1),
|
|
.result = Some(telemetry::pinning::TELEMETRY_SUCCESS),
|
|
.success = Some(true)}},
|
|
{.result = Win11PinToTaskBarResultStatus::AlreadyPinned,
|
|
.expectedExtras = {.alreadyPinned = Some(true),
|
|
.fallbackPinningSuccess =
|
|
Some(telemetry::pinning::TELEMETRY_ERROR),
|
|
.numberOfAttempts = Some(1),
|
|
.result = Some(
|
|
telemetry::pinning::TELEMETRY_ALREADY_PINNED)}},
|
|
{.result = Win11PinToTaskBarResultStatus::NotCurrentlyAllowed,
|
|
.expectedExtras =
|
|
{.fallbackPinningSuccess = Some(telemetry::pinning::TELEMETRY_ERROR),
|
|
.notCurrentlyAllowed = Some(true),
|
|
.numberOfAttempts = Some(1),
|
|
.result = Some(telemetry::pinning::TELEMETRY_NOT_CURRENTLY_ALLOWED)}},
|
|
{.result = Win11PinToTaskBarResultStatus::Failed,
|
|
.expectedExtras = {.error = Some(true),
|
|
.fallbackPinningSuccess =
|
|
Some(telemetry::pinning::TELEMETRY_ERROR),
|
|
.numberOfAttempts = Some(1),
|
|
.result = Some(telemetry::pinning::TELEMETRY_ERROR)}},
|
|
{.result = Win11PinToTaskBarResultStatus::ErrorLimitedAccessFeatures,
|
|
.expectedExtras =
|
|
{.errorLimitedAccessFeatures = Some(true),
|
|
.fallbackPinningSuccess = Some(telemetry::pinning::TELEMETRY_ERROR),
|
|
.numberOfAttempts = Some(1),
|
|
.result = Some(
|
|
telemetry::pinning::TELEMETRY_ERROR_LIMITED_ACCESS_FEATURES)}},
|
|
{.result = Win11PinToTaskBarResultStatus::LimitedAccessFeaturesLocked,
|
|
.expectedExtras =
|
|
{.fallbackPinningSuccess = Some(telemetry::pinning::TELEMETRY_ERROR),
|
|
.limitedAccessFeaturesLocked = Some(true),
|
|
.numberOfAttempts = Some(1),
|
|
.result = Some(
|
|
telemetry::pinning::TELEMETRY_LIMITED_ACCESS_FEATURES_LOCKED)}},
|
|
};
|
|
|
|
INSTANTIATE_TEST_SUITE_P(WindowsPinningFallbackTelemetryTests,
|
|
WindowsPinningAPIFallbackFixture,
|
|
::testing::ValuesIn(fallbackFailedTestCases));
|