1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
|
// Copyright 2015 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "extensions/common/manifest_handlers/kiosk_mode_info.h"
#include <algorithm>
#include <map>
#include "components/version_info/channel.h"
#include "extensions/common/features/feature_channel.h"
#include "extensions/common/manifest_constants.h"
#include "extensions/common/manifest_test.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace extensions {
using KioskModeInfoManifestTest = ManifestTest;
namespace {
enum class EnabledOnLaunchState { kUndefined, kEnabled, kDisabled };
std::map<std::string, EnabledOnLaunchState> GetSecondaryApps(
const std::vector<SecondaryKioskAppInfo>& info) {
std::map<std::string, EnabledOnLaunchState> mapped_info;
for (const auto& app : info) {
EXPECT_EQ(0u, mapped_info.count(app.id)) << "Duplicate entry " << app.id;
EnabledOnLaunchState enabled_on_launch = EnabledOnLaunchState::kUndefined;
if (app.enabled_on_launch.has_value()) {
enabled_on_launch = app.enabled_on_launch.value()
? EnabledOnLaunchState::kEnabled
: EnabledOnLaunchState::kDisabled;
}
mapped_info.emplace(app.id, enabled_on_launch);
}
return mapped_info;
}
} // namespace
TEST_F(KioskModeInfoManifestTest, NoSecondaryApps) {
scoped_refptr<Extension> extension(
LoadAndExpectSuccess("kiosk_secondary_app_no_secondary_app.json"));
EXPECT_FALSE(KioskModeInfo::HasSecondaryApps(extension.get()));
}
TEST_F(KioskModeInfoManifestTest, MultipleSecondaryApps) {
extensions::ScopedCurrentChannel channel(version_info::Channel::DEV);
scoped_refptr<Extension> extension(
LoadAndExpectSuccess("kiosk_secondary_app_multi_apps.json"));
EXPECT_TRUE(KioskModeInfo::HasSecondaryApps(extension.get()));
KioskModeInfo* info = KioskModeInfo::Get(extension.get());
ASSERT_TRUE(info);
std::map<std::string, EnabledOnLaunchState> expected_secondary_apps = {
{"ihplaomghjbeafnpnjkhppmfpnmdihgd", EnabledOnLaunchState::kUndefined},
{"abcdabcdabcdabcdabcdabcdabcdabcd", EnabledOnLaunchState::kDisabled},
{"fiehokkcgaojmbhfhlpiheggjhaedjoc", EnabledOnLaunchState::kEnabled}};
EXPECT_EQ(expected_secondary_apps, GetSecondaryApps(info->secondary_apps));
}
TEST_F(KioskModeInfoManifestTest, MultipleSecondaryAppsWithRepeatedEntries) {
extensions::ScopedCurrentChannel channel(version_info::Channel::DEV);
LoadAndExpectError("kiosk_secondary_app_multi_apps_repeated_entries.json",
manifest_errors::kInvalidKioskSecondaryAppsDuplicateApp);
}
TEST_F(KioskModeInfoManifestTest, MultipleSecondaryApps_StableChannel) {
extensions::ScopedCurrentChannel channel(version_info::Channel::STABLE);
LoadAndExpectError(
"kiosk_secondary_app_multi_apps.json",
manifest_errors::kInvalidKioskSecondaryAppsPropertyUnavailable);
}
TEST_F(KioskModeInfoManifestTest,
RequiredPlatformVersionAndAlwaysUpdateAreOptional) {
scoped_refptr<Extension> extension(
LoadAndExpectSuccess("kiosk_required_platform_version_not_present.json"));
KioskModeInfo* info = KioskModeInfo::Get(extension.get());
EXPECT_TRUE(info->required_platform_version.empty());
EXPECT_FALSE(info->always_update);
}
TEST_F(KioskModeInfoManifestTest, RequiredPlatformVersion) {
scoped_refptr<Extension> extension(
LoadAndExpectSuccess("kiosk_required_platform_version.json"));
KioskModeInfo* info = KioskModeInfo::Get(extension.get());
EXPECT_EQ("1234.0.0", info->required_platform_version);
}
TEST_F(KioskModeInfoManifestTest, RequiredPlatformVersionInvalid) {
LoadAndExpectError("kiosk_required_platform_version_empty.json",
manifest_errors::kInvalidKioskRequiredPlatformVersion);
LoadAndExpectError("kiosk_required_platform_version_invalid.json",
manifest_errors::kInvalidKioskRequiredPlatformVersion);
}
TEST_F(KioskModeInfoManifestTest, AlwaysUpdate) {
scoped_refptr<Extension> extension(
LoadAndExpectSuccess("kiosk_always_update.json"));
KioskModeInfo* info = KioskModeInfo::Get(extension.get());
EXPECT_TRUE(info->always_update);
}
TEST_F(KioskModeInfoManifestTest, AlwaysUpdateFalse) {
scoped_refptr<Extension> extension(
LoadAndExpectSuccess("kiosk_always_update_false.json"));
KioskModeInfo* info = KioskModeInfo::Get(extension.get());
EXPECT_FALSE(info->always_update);
}
TEST_F(KioskModeInfoManifestTest, AlwaysUpdateInvalid) {
LoadAndExpectError("kiosk_always_update_invalid.json",
manifest_errors::kInvalidKioskAlwaysUpdate);
}
} // namespace extensions
|
