Rename _accessControlBlackList into _accessRevocationList

Remove "unblock" command.
Remove "size" state property.

BUG: 27313743
Change-Id: I21d8e589d1777c49be98e20bef6f2c151ae27591
Reviewed-on: https://weave-review.googlesource.com/2709
Reviewed-by: Alex Vakulenko <avakulenko@google.com>

3 files changed, 21 insertions, 107 deletions

diff --git a/src/access_api_handler.cc b/src/access_api_handler.cc
index 7c39b20..9d97d9e 100644
--- a/src/access_api_handler.cc
+++ b/src/access_api_handler.cc
@@ -17,13 +17,12 @@ namespace weave {
 namespace {
 
 const char kComponent[] = "accessControl";
-const char kTrait[] = "_accessControlBlackList";
-const char kStateSize[] = "_accessControlBlackList.size";
-const char kStateCapacity[] = "_accessControlBlackList.capacity";
+const char kTrait[] = "_accessRevocationList";
+const char kStateCapacity[] = "_accessRevocationList.capacity";
 const char kUserId[] = "userId";
 const char kApplicationId[] = "applicationId";
 const char kExpirationTimeout[] = "expirationTimeoutSec";
-const char kBlackList[] = "blackList";
+const char kBlackList[] = "revocationListEntries";
 
 bool GetIds(const base::DictionaryValue& parameters,
             std::vector<uint8_t>* user_id_decoded,
@@ -54,9 +53,9 @@ AccessApiHandler::AccessApiHandler(Device* device,
                                    AccessBlackListManager* manager)
     : device_{device}, manager_{manager} {
   device_->AddTraitDefinitionsFromJson(R"({
-    "_accessControlBlackList": {
+    "_accessRevocationList": {
       "commands": {
-        "block": {
+        "revoke": {
           "minimalRole": "owner",
           "parameters": {
             "userId": {
@@ -70,22 +69,11 @@ AccessApiHandler::AccessApiHandler(Device* device,
             }
           }
         },
-        "unblock": {
-          "minimalRole": "owner",
-          "parameters": {
-            "userId": {
-              "type": "string"
-            },
-            "applicationId": {
-              "type": "string"
-            }
-          }
-        },
         "list": {
           "minimalRole": "owner",
           "parameters": {},
           "results": {
-            "blackList": {
+            "revocationEntriesList": {
               "type": "array",
               "items": {
                 "type": "object",
@@ -104,10 +92,6 @@ AccessApiHandler::AccessApiHandler(Device* device,
         }
       },
       "state": {
-        "size": {
-          "type": "integer",
-          "isRequired": true
-        },
         "capacity": {
           "type": "integer",
           "isRequired": true
@@ -119,13 +103,10 @@ AccessApiHandler::AccessApiHandler(Device* device,
   UpdateState();
 
   device_->AddCommandHandler(
-      kComponent, "_accessControlBlackList.block",
+      kComponent, "_accessRevocationList.revoke",
       base::Bind(&AccessApiHandler::Block, weak_ptr_factory_.GetWeakPtr()));
   device_->AddCommandHandler(
-      kComponent, "_accessControlBlackList.unblock",
-      base::Bind(&AccessApiHandler::Unblock, weak_ptr_factory_.GetWeakPtr()));
-  device_->AddCommandHandler(
-      kComponent, "_accessControlBlackList.list",
+      kComponent, "_accessRevocationList.list",
       base::Bind(&AccessApiHandler::List, weak_ptr_factory_.GetWeakPtr()));
 }
 
@@ -158,29 +139,6 @@ void AccessApiHandler::Block(const std::weak_ptr<Command>& cmd) {
                              weak_ptr_factory_.GetWeakPtr(), cmd));
 }
 
-void AccessApiHandler::Unblock(const std::weak_ptr<Command>& cmd) {
-  auto command = cmd.lock();
-  if (!command)
-    return;
-
-  CHECK(command->GetState() == Command::State::kQueued)
-      << EnumToString(command->GetState());
-  command->SetProgress(base::DictionaryValue{}, nullptr);
-
-  const auto& parameters = command->GetParameters();
-  std::vector<uint8_t> user_id;
-  std::vector<uint8_t> app_id;
-  ErrorPtr error;
-  if (!GetIds(parameters, &user_id, &app_id, &error)) {
-    command->Abort(error.get(), nullptr);
-    return;
-  }
-
-  manager_->Unblock(user_id, app_id,
-                    base::Bind(&AccessApiHandler::OnCommandDone,
-                               weak_ptr_factory_.GetWeakPtr(), cmd));
-}
-
 void AccessApiHandler::List(const std::weak_ptr<Command>& cmd) {
   auto command = cmd.lock();
   if (!command)
@@ -219,7 +177,6 @@ void AccessApiHandler::OnCommandDone(const std::weak_ptr<Command>& cmd,
 
 void AccessApiHandler::UpdateState() {
   base::DictionaryValue state;
-  state.SetInteger(kStateSize, manager_->GetSize());
   state.SetInteger(kStateCapacity, manager_->GetCapacity());
   device_->SetStateProperties(kComponent, state, nullptr);
 }
diff --git a/src/access_api_handler.h b/src/access_api_handler.h
index 821ce02..83f0973 100644
--- a/src/access_api_handler.h
+++ b/src/access_api_handler.h
@@ -29,7 +29,6 @@ class AccessApiHandler final {
 
  private:
   void Block(const std::weak_ptr<Command>& command);
-  void Unblock(const std::weak_ptr<Command>& command);
   void List(const std::weak_ptr<Command>& command);
   void UpdateState();
 
diff --git a/src/access_api_handler_unittest.cc b/src/access_api_handler_unittest.cc
index cec680c..25dd4da 100644
--- a/src/access_api_handler_unittest.cc
+++ b/src/access_api_handler_unittest.cc
@@ -44,9 +44,8 @@ class AccessApiHandlerTest : public ::testing::Test {
         }));
 
     EXPECT_CALL(device_,
-                AddCommandHandler(_, AnyOf("_accessControlBlackList.block",
-                                           "_accessControlBlackList.unblock",
-                                           "_accessControlBlackList.list"),
+                AddCommandHandler(_, AnyOf("_accessRevocationList.revoke",
+                                           "_accessRevocationList.list"),
                                   _))
         .WillRepeatedly(
             Invoke(&component_manager_, &ComponentManager::AddCommandHandler));
@@ -72,13 +71,13 @@ class AccessApiHandlerTest : public ::testing::Test {
 
   std::unique_ptr<base::DictionaryValue> GetState() {
     std::string path =
-        component_manager_.FindComponentWithTrait("_accessControlBlackList");
+        component_manager_.FindComponentWithTrait("_accessRevocationList");
     EXPECT_FALSE(path.empty());
     const auto* component = component_manager_.FindComponent(path, nullptr);
     EXPECT_TRUE(component);
     const base::DictionaryValue* state = nullptr;
     EXPECT_TRUE(
-        component->GetDictionary("state._accessControlBlackList", &state));
+        component->GetDictionary("state._accessRevocationList", &state));
     return std::unique_ptr<base::DictionaryValue>{state->DeepCopy()};
   }
 
@@ -92,11 +91,11 @@ class AccessApiHandlerTest : public ::testing::Test {
 TEST_F(AccessApiHandlerTest, Initialization) {
   const base::DictionaryValue* trait = nullptr;
   ASSERT_TRUE(component_manager_.GetTraits().GetDictionary(
-      "_accessControlBlackList", &trait));
+      "_accessRevocationList", &trait));
 
   auto expected = R"({
     "commands": {
-      "block": {
+      "revoke": {
         "minimalRole": "owner",
         "parameters": {
           "userId": {
@@ -110,22 +109,11 @@ TEST_F(AccessApiHandlerTest, Initialization) {
           }
         }
       },
-      "unblock": {
-        "minimalRole": "owner",
-        "parameters": {
-          "userId": {
-            "type": "string"
-          },
-          "applicationId": {
-            "type": "string"
-          }
-        }
-      },
       "list": {
         "minimalRole": "owner",
         "parameters": {},
         "results": {
-          "blackList": {
+          "revocationEntriesList": {
             "type": "array",
             "items": {
               "type": "object",
@@ -144,10 +132,6 @@ TEST_F(AccessApiHandlerTest, Initialization) {
       }
     },
     "state": {
-      "size": {
-        "type": "integer",
-        "isRequired": true
-      },
       "capacity": {
         "type": "integer",
         "isRequired": true
@@ -157,13 +141,12 @@ TEST_F(AccessApiHandlerTest, Initialization) {
   EXPECT_JSON_EQ(expected, *trait);
 
   expected = R"({
-    "capacity": 10,
-    "size": 0
+    "capacity": 10
   })";
   EXPECT_JSON_EQ(expected, *GetState());
 }
 
-TEST_F(AccessApiHandlerTest, Block) {
+TEST_F(AccessApiHandlerTest, Revoke) {
   EXPECT_CALL(access_manager_, Block(std::vector<uint8_t>{1, 2, 3},
                                      std::vector<uint8_t>{3, 4, 5}, _, _))
       .WillOnce(WithArgs<3>(
@@ -171,31 +154,7 @@ TEST_F(AccessApiHandlerTest, Block) {
   EXPECT_CALL(access_manager_, GetSize()).WillRepeatedly(Return(1));
 
   AddCommand(R"({
-    'name' : '_accessControlBlackList.block',
-    'component': 'accessControl',
-    'parameters': {
-      'userId': 'AQID',
-      'applicationId': 'AwQF',
-      'expirationTimeoutSec': 1234
-    }
-  })");
-
-  auto expected = R"({
-    "capacity": 10,
-    "size": 1
-  })";
-  EXPECT_JSON_EQ(expected, *GetState());
-}
-
-TEST_F(AccessApiHandlerTest, Unblock) {
-  EXPECT_CALL(access_manager_, Unblock(std::vector<uint8_t>{1, 2, 3},
-                                       std::vector<uint8_t>{3, 4, 5}, _))
-      .WillOnce(WithArgs<2>(
-          Invoke([](const DoneCallback& callback) { callback.Run(nullptr); })));
-  EXPECT_CALL(access_manager_, GetSize()).WillRepeatedly(Return(4));
-
-  AddCommand(R"({
-    'name' : '_accessControlBlackList.unblock',
+    'name' : '_accessRevocationList.revoke',
     'component': 'accessControl',
     'parameters': {
       'userId': 'AQID',
@@ -205,8 +164,7 @@ TEST_F(AccessApiHandlerTest, Unblock) {
   })");
 
   auto expected = R"({
-    "capacity": 10,
-    "size": 4
+    "capacity": 10
   })";
   EXPECT_JSON_EQ(expected, *GetState());
 }
@@ -220,7 +178,7 @@ TEST_F(AccessApiHandlerTest, List) {
   EXPECT_CALL(access_manager_, GetSize()).WillRepeatedly(Return(4));
 
   auto expected = R"({
-    "blackList": [ {
+    "revocationListEntries": [ {
       "applicationId": "FRYX",
       "userId": "CwwN"
     }, {
@@ -230,7 +188,7 @@ TEST_F(AccessApiHandlerTest, List) {
   })";
 
   const auto& results = AddCommand(R"({
-    'name' : '_accessControlBlackList.list',
+    'name' : '_accessRevocationList.list',
     'component': 'accessControl',
     'parameters': {
     }