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
|
// Copyright 2021 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/browser/ash/net/network_diagnostics/arc_ping_routine.h"
#include <memory>
#include "chrome/browser/ash/net/network_diagnostics/network_diagnostics_test_helper.h"
#include "chromeos/ash/experiences/arc/test/fake_net_instance.h"
#include "net/dns/public/dns_protocol.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/cros_system_api/dbus/shill/dbus-constants.h"
namespace ash {
namespace network_diagnostics {
namespace {
namespace mojom = ::chromeos::network_diagnostics::mojom;
const int kNoProblemDelayMs = 1000;
const int kHighLatencyDelayMs = 1600;
} // namespace
class ArcPingRoutineTest : public NetworkDiagnosticsTestHelper {
public:
ArcPingRoutineTest() = default;
ArcPingRoutineTest(const ArcPingRoutineTest&) = delete;
ArcPingRoutineTest& operator=(const ArcPingRoutineTest&) = delete;
~ArcPingRoutineTest() override = default;
void CompareResult(
mojom::RoutineVerdict expected_verdict,
const std::vector<mojom::ArcPingProblem>& expected_problems,
base::OnceClosure quit_closure,
mojom::RoutineResultPtr result) {
EXPECT_EQ(expected_verdict, result->verdict);
EXPECT_EQ(expected_problems, result->problems->get_arc_ping_problems());
std::move(quit_closure).Run();
}
protected:
void RunRoutine(mojom::RoutineVerdict expected_routine_verdict,
const std::vector<mojom::ArcPingProblem>& expected_problems) {
base::RunLoop run_loop;
arc_ping_routine_->RunRoutine(base::BindOnce(
&ArcPingRoutineTest::CompareResult, weak_ptr(),
expected_routine_verdict, expected_problems, run_loop.QuitClosure()));
run_loop.Run();
}
void SetUpRoutine(arc::mojom::ArcPingTestResult result) {
// Set up the fake NetworkInstance service.
fake_net_instance_ = std::make_unique<arc::FakeNetInstance>();
fake_net_instance_->set_ping_test_result(result);
// Set up routine with fake NetworkInstance service.
arc_ping_routine_ = std::make_unique<ArcPingRoutine>(
mojom::RoutineCallSource::kDiagnosticsUI);
arc_ping_routine_->set_net_instance_for_testing(fake_net_instance_.get());
}
base::WeakPtr<ArcPingRoutineTest> weak_ptr() {
return weak_factory_.GetWeakPtr();
}
private:
std::unique_ptr<ArcPingRoutine> arc_ping_routine_;
std::unique_ptr<arc::FakeNetInstance> fake_net_instance_;
base::WeakPtrFactory<ArcPingRoutineTest> weak_factory_{this};
};
TEST_F(ArcPingRoutineTest, TestNoProblem) {
arc::mojom::ArcPingTestResult result;
result.is_successful = true;
result.duration_ms = kNoProblemDelayMs;
SetUpRoutine(result);
SetUpWiFi(shill::kStateOnline);
RunRoutine(mojom::RoutineVerdict::kNoProblem, {});
}
TEST_F(ArcPingRoutineTest, TestUnreachableGateway) {
arc::mojom::ArcPingTestResult result;
result.is_successful = false;
SetUpRoutine(result);
RunRoutine(mojom::RoutineVerdict::kProblem,
{mojom::ArcPingProblem::kUnreachableGateway});
}
TEST_F(ArcPingRoutineTest, TestFailedToPingDefaultGateway) {
arc::mojom::ArcPingTestResult result;
result.is_successful = false;
SetUpRoutine(result);
SetUpWiFi(shill::kStateOnline);
RunRoutine(mojom::RoutineVerdict::kProblem,
{mojom::ArcPingProblem::kFailedToPingDefaultNetwork});
}
TEST_F(ArcPingRoutineTest, TestHighLatencyToPingDefaultGateway) {
arc::mojom::ArcPingTestResult result;
result.is_successful = true;
result.duration_ms = kHighLatencyDelayMs;
SetUpRoutine(result);
SetUpWiFi(shill::kStateOnline);
RunRoutine(mojom::RoutineVerdict::kProblem,
{mojom::ArcPingProblem::kDefaultNetworkAboveLatencyThreshold});
}
} // namespace network_diagnostics
} // namespace ash
|
