Setting OptInStateFilter for publishes and subscribes (b/16324352)

components/copresence/rpc/rpc_handler_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/copresence/rpc/rpc_handler.h"
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/message_loop/message_loop.h"
 #include "components/copresence/handlers/directive_handler.h"
 #include "components/copresence/proto/data.pb.h"
 #include "components/copresence/proto/enums.pb.h"
 #include "components/copresence/proto/rpcs.pb.h"
 #include "net/http/http_status_code.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using google::protobuf::MessageLite;
+using google::protobuf::RepeatedPtrField;
 
 namespace copresence {
 
 namespace {
 
 void AddMessageWithStrategy(ReportRequest* report,
                             BroadcastScanConfiguration strategy) {
   report->mutable_manage_messages_request()->add_message_to_publish()
       ->mutable_token_exchange_strategy()->set_broadcast_scan_configuration(
           strategy);
@@ skipping 62 matching lines @@
       scoped_ptr<MessageLite> request_proto,
       const RpcHandler::PostCleanupCallback& response_callback) {
     rpc_name_ = rpc_name;
     request_proto_ = request_proto.Pass();
   }
 
   void CaptureStatus(CopresenceStatus status) {
     status_ = status;
   }
 
+  inline const ReportRequest* GetReportSent() {
+    return static_cast<ReportRequest*>(request_proto_.get());
+  }
+
 // TODO(ckehoe): Fix this on Windows. See rpc_handler.cc.
 #ifndef OS_WIN
   const TokenTechnology& GetTokenTechnologyFromReport() {
-    ReportRequest* report = static_cast<ReportRequest*>(request_proto_.get());
-    return report->update_signals_request().state().capabilities()
+    return GetReportSent()->update_signals_request().state().capabilities()
         .token_technology(0);
   }
 #endif
 
+  const RepeatedPtrField<PublishedMessage>& GetMessagesPublished() {
+    return GetReportSent()->manage_messages_request().message_to_publish();
+  }
+
+  const RepeatedPtrField<Subscription>& GetSubscriptionsSent() {
+    return GetReportSent()->manage_subscriptions_request().subscription();
+  }
+
   void SetDeviceId(const std::string& device_id) {
     rpc_handler_.device_id_ = device_id;
   }
 
   const std::string& GetDeviceId() {
     return rpc_handler_.device_id_;
   }
 
   void AddInvalidToken(const std::string& token) {
     rpc_handler_.invalid_audio_token_cache_.Add(token, true);
@@ skipping 105 matching lines @@
   report.reset(new ReportRequest);
   AddMessageWithStrategy(report.get(), SCAN_ONLY);
   AddSubscriptionWithStrategy(report.get(), BROADCAST_AND_SCAN);
   rpc_handler_.SendReportRequest(report.Pass());
   token_technology = &GetTokenTechnologyFromReport();
   EXPECT_EQ(TRANSMIT, token_technology->instruction_type(0));
   EXPECT_EQ(RECEIVE, token_technology->instruction_type(1));
 }
 #endif
 
+TEST_F(RpcHandlerTest, AllowOptedOutMessages) {
+  // Request with no filter specified.
+  scoped_ptr<ReportRequest> report(new ReportRequest);
+  report->mutable_manage_messages_request()->add_message_to_publish()
+      ->set_id("message");
+  report->mutable_manage_subscriptions_request()->add_subscription()
+      ->set_id("subscription");
+  rpc_handler_.SendReportRequest(report.Pass());
+  const OptInStateFilter& filter =
+      GetMessagesPublished().Get(0).opt_in_state_filter();
+  ASSERT_EQ(2, filter.allowed_opt_in_state_size());
+  EXPECT_EQ(OPTED_IN, filter.allowed_opt_in_state(0));
+  EXPECT_EQ(OPTED_OUT, filter.allowed_opt_in_state(1));
+  EXPECT_EQ(2, GetSubscriptionsSent().Get(0).opt_in_state_filter()
+      .allowed_opt_in_state_size());
+
+  // Request with filters already specified.
+  report.reset(new ReportRequest);
+  report->mutable_manage_messages_request()->add_message_to_publish()
+      ->mutable_opt_in_state_filter()->add_allowed_opt_in_state(OPTED_IN);
+  report->mutable_manage_subscriptions_request()->add_subscription()
+      ->mutable_opt_in_state_filter()->add_allowed_opt_in_state(OPTED_OUT);
+  rpc_handler_.SendReportRequest(report.Pass());
+  const OptInStateFilter& publish_filter =
+      GetMessagesPublished().Get(0).opt_in_state_filter();
+  ASSERT_EQ(1, publish_filter.allowed_opt_in_state_size());
+  EXPECT_EQ(OPTED_IN, publish_filter.allowed_opt_in_state(0));
+  const OptInStateFilter& subscription_filter =
+      GetSubscriptionsSent().Get(0).opt_in_state_filter();
+  ASSERT_EQ(1, subscription_filter.allowed_opt_in_state_size());
+  EXPECT_EQ(OPTED_OUT, subscription_filter.allowed_opt_in_state(0));
+}
+
 TEST_F(RpcHandlerTest, CreateRequestHeader) {
   SetDeviceId("CreateRequestHeader Device ID");
   rpc_handler_.SendReportRequest(make_scoped_ptr(new ReportRequest),
                                  "CreateRequestHeader App ID",
                                  StatusCallback());
   EXPECT_EQ(RpcHandler::kReportRequestRpcName, rpc_name_);
   ReportRequest* report = static_cast<ReportRequest*>(request_proto_.get());
   EXPECT_TRUE(report->header().has_framework_version());
   EXPECT_EQ("CreateRequestHeader App ID",
             report->header().client_version().client());
@@ skipping 77 matching lines @@
             messages_by_subscription_["Subscription 2"][1].payload());
 
   ASSERT_EQ(2U, directive_handler->added_directives().size());
   EXPECT_EQ("Subscription 1",
             directive_handler->added_directives()[0].subscription_id());
   EXPECT_EQ("Subscription 2",
             directive_handler->added_directives()[1].subscription_id());
 }
 
 }  // namespace copresence