1 /*
2 * Copyright 2018 Google LLC
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "fcp/secagg/client/secagg_client_aborted_state.h"
18
19 #include <string>
20 #include <unordered_map>
21
22 #include "gmock/gmock.h"
23 #include "gtest/gtest.h"
24 #include "absl/container/node_hash_map.h"
25 #include "fcp/base/monitoring.h"
26 #include "fcp/secagg/shared/secagg_messages.pb.h"
27 #include "fcp/secagg/shared/secagg_vector.h"
28 #include "fcp/secagg/testing/mock_send_to_server_interface.h"
29 #include "fcp/secagg/testing/mock_state_transition_listener.h"
30
31 namespace fcp {
32 namespace secagg {
33 namespace {
34
35 using ::testing::Eq;
36 using ::testing::StrEq;
37
TEST(SecAggClientAbortedStateTest,IsAbortedReturnsTrue)38 TEST(SecAggClientAbortedStateTest, IsAbortedReturnsTrue) {
39 std::string test_reason = "test reason";
40 MockSendToServerInterface* sender = new MockSendToServerInterface();
41 MockStateTransitionListener* transition_listener =
42 new MockStateTransitionListener();
43 SecAggClientAbortedState aborted_state(
44 test_reason, std::unique_ptr<SendToServerInterface>{sender},
45 std::unique_ptr<StateTransitionListenerInterface>{transition_listener});
46 EXPECT_THAT(aborted_state.IsAborted(), Eq(true));
47 }
48
TEST(SecAggClientAbortedStateTest,IsCompletedSuccessfullyReturnsFalse)49 TEST(SecAggClientAbortedStateTest, IsCompletedSuccessfullyReturnsFalse) {
50 std::string test_reason = "test reason";
51 MockSendToServerInterface* sender = new MockSendToServerInterface();
52 MockStateTransitionListener* transition_listener =
53 new MockStateTransitionListener();
54 SecAggClientAbortedState aborted_state(
55 test_reason, std::unique_ptr<SendToServerInterface>{sender},
56 std::unique_ptr<StateTransitionListenerInterface>{transition_listener});
57 EXPECT_THAT(aborted_state.IsCompletedSuccessfully(), Eq(false));
58 }
59
TEST(SecAggClientAbortedStateTest,ErrorMessageReturnsSelectedMessage)60 TEST(SecAggClientAbortedStateTest, ErrorMessageReturnsSelectedMessage) {
61 std::string test_reason = "test reason";
62 MockSendToServerInterface* sender = new MockSendToServerInterface();
63 MockStateTransitionListener* transition_listener =
64 new MockStateTransitionListener();
65 SecAggClientAbortedState aborted_state(
66 test_reason, std::unique_ptr<SendToServerInterface>{sender},
67 std::unique_ptr<StateTransitionListenerInterface>{transition_listener});
68 ASSERT_THAT(aborted_state.ErrorMessage().ok(), Eq(true));
69 EXPECT_THAT(aborted_state.ErrorMessage().value(), StrEq(test_reason));
70 }
71
TEST(SecAggClientAbortedStateTest,StartRaisesErrorStatus)72 TEST(SecAggClientAbortedStateTest, StartRaisesErrorStatus) {
73 std::string test_reason = "test reason";
74 MockSendToServerInterface* sender = new MockSendToServerInterface();
75 MockStateTransitionListener* transition_listener =
76 new MockStateTransitionListener();
77 SecAggClientAbortedState aborted_state(
78 test_reason, std::unique_ptr<SendToServerInterface>{sender},
79 std::unique_ptr<StateTransitionListenerInterface>{transition_listener});
80 EXPECT_THAT(aborted_state.Start().ok(), Eq(false));
81 }
82
TEST(SecAggClientAbortedStateTest,HandleMessageRaisesErrorStatus)83 TEST(SecAggClientAbortedStateTest, HandleMessageRaisesErrorStatus) {
84 std::string test_reason = "test reason";
85 MockSendToServerInterface* sender = new MockSendToServerInterface();
86 MockStateTransitionListener* transition_listener =
87 new MockStateTransitionListener();
88 SecAggClientAbortedState aborted_state(
89 test_reason, std::unique_ptr<SendToServerInterface>{sender},
90 std::unique_ptr<StateTransitionListenerInterface>{transition_listener});
91 EXPECT_THAT(
92 aborted_state
93 .HandleMessage(ServerToClientWrapperMessage::default_instance())
94 .ok(),
95 Eq(false));
96 }
97
TEST(SecAggClientAbortedStateTest,SetInputRaisesErrorStatus)98 TEST(SecAggClientAbortedStateTest, SetInputRaisesErrorStatus) {
99 std::string test_reason = "test reason";
100 MockSendToServerInterface* sender = new MockSendToServerInterface();
101 MockStateTransitionListener* transition_listener =
102 new MockStateTransitionListener();
103 SecAggClientAbortedState aborted_state(
104 test_reason, std::unique_ptr<SendToServerInterface>{sender},
105 std::unique_ptr<StateTransitionListenerInterface>{transition_listener});
106 EXPECT_THAT(aborted_state.SetInput(std::make_unique<SecAggVectorMap>()).ok(),
107 Eq(false));
108 }
109
TEST(SecAggClientAbortedStateTest,AbortRaisesErrorStatus)110 TEST(SecAggClientAbortedStateTest, AbortRaisesErrorStatus) {
111 std::string test_reason = "test reason";
112 MockSendToServerInterface* sender = new MockSendToServerInterface();
113 MockStateTransitionListener* transition_listener =
114 new MockStateTransitionListener();
115 SecAggClientAbortedState aborted_state(
116 test_reason, std::unique_ptr<SendToServerInterface>{sender},
117 std::unique_ptr<StateTransitionListenerInterface>{transition_listener});
118 EXPECT_THAT(aborted_state.Abort(test_reason).ok(), Eq(false));
119 }
120
121 } // namespace
122 } // namespace secagg
123 } // namespace fcp
124