Home | History | Annotate | Download | only in common 
      1 //
      2 // Copyright (C) 2009 The Android Open Source Project
      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 "update_engine/common/action_processor.h"
     18 
     19 #include <string>
     20 
     21 #include <gtest/gtest.h>
     22 
     23 #include "update_engine/common/action.h"
     24 #include "update_engine/common/mock_action.h"
     25 
     26 using std::string;
     27 
     28 namespace chromeos_update_engine {
     29 
     30 using chromeos_update_engine::ActionPipe;
     31 
     32 class ActionProcessorTestAction;
     33 
     34 template<>
     35 class ActionTraits<ActionProcessorTestAction> {
     36  public:
     37   typedef string OutputObjectType;
     38   typedef string InputObjectType;
     39 };
     40 
     41 // This is a simple Action class for testing.
     42 class ActionProcessorTestAction : public Action<ActionProcessorTestAction> {
     43  public:
     44   typedef string InputObjectType;
     45   typedef string OutputObjectType;
     46   ActionPipe<string>* in_pipe() { return in_pipe_.get(); }
     47   ActionPipe<string>* out_pipe() { return out_pipe_.get(); }
     48   ActionProcessor* processor() { return processor_; }
     49   void PerformAction() {}
     50   void CompleteAction() {
     51     ASSERT_TRUE(processor());
     52     processor()->ActionComplete(this, ErrorCode::kSuccess);
     53   }
     54   string Type() const { return "ActionProcessorTestAction"; }
     55 };
     56 
     57 namespace {
     58 class MyActionProcessorDelegate : public ActionProcessorDelegate {
     59  public:
     60   explicit MyActionProcessorDelegate(const ActionProcessor* processor)
     61       : processor_(processor),
     62         processing_done_called_(false),
     63         processing_stopped_called_(false),
     64         action_completed_called_(false),
     65         action_exit_code_(ErrorCode::kError) {}
     66 
     67   virtual void ProcessingDone(const ActionProcessor* processor,
     68                               ErrorCode code) {
     69     EXPECT_EQ(processor_, processor);
     70     EXPECT_FALSE(processing_done_called_);
     71     processing_done_called_ = true;
     72   }
     73   virtual void ProcessingStopped(const ActionProcessor* processor) {
     74     EXPECT_EQ(processor_, processor);
     75     EXPECT_FALSE(processing_stopped_called_);
     76     processing_stopped_called_ = true;
     77   }
     78   virtual void ActionCompleted(ActionProcessor* processor,
     79                                AbstractAction* action,
     80                                ErrorCode code) {
     81     EXPECT_EQ(processor_, processor);
     82     EXPECT_FALSE(action_completed_called_);
     83     action_completed_called_ = true;
     84     action_exit_code_ = code;
     85   }
     86 
     87   const ActionProcessor* processor_;
     88   bool processing_done_called_;
     89   bool processing_stopped_called_;
     90   bool action_completed_called_;
     91   ErrorCode action_exit_code_;
     92 };
     93 }  // namespace
     94 
     95 class ActionProcessorTest : public ::testing::Test {
     96   void SetUp() override {
     97     action_processor_.set_delegate(&delegate_);
     98     // Silence Type() calls used for logging.
     99     EXPECT_CALL(mock_action_, Type()).Times(testing::AnyNumber());
    100   }
    101 
    102   void TearDown() override {
    103     action_processor_.set_delegate(nullptr);
    104   }
    105 
    106  protected:
    107   // The ActionProcessor under test.
    108   ActionProcessor action_processor_;
    109 
    110   MyActionProcessorDelegate delegate_{&action_processor_};
    111 
    112   // Common actions used during most tests.
    113   testing::StrictMock<MockAction> mock_action_;
    114   ActionProcessorTestAction action_;
    115 };
    116 
    117 TEST_F(ActionProcessorTest, SimpleTest) {
    118   EXPECT_FALSE(action_processor_.IsRunning());
    119   action_processor_.EnqueueAction(&action_);
    120   EXPECT_FALSE(action_processor_.IsRunning());
    121   EXPECT_FALSE(action_.IsRunning());
    122   action_processor_.StartProcessing();
    123   EXPECT_TRUE(action_processor_.IsRunning());
    124   EXPECT_TRUE(action_.IsRunning());
    125   EXPECT_EQ(action_processor_.current_action(), &action_);
    126   action_.CompleteAction();
    127   EXPECT_FALSE(action_processor_.IsRunning());
    128   EXPECT_FALSE(action_.IsRunning());
    129 }
    130 
    131 TEST_F(ActionProcessorTest, DelegateTest) {
    132   action_processor_.EnqueueAction(&action_);
    133   action_processor_.StartProcessing();
    134   action_.CompleteAction();
    135   EXPECT_TRUE(delegate_.processing_done_called_);
    136   EXPECT_TRUE(delegate_.action_completed_called_);
    137 }
    138 
    139 TEST_F(ActionProcessorTest, StopProcessingTest) {
    140   action_processor_.EnqueueAction(&action_);
    141   action_processor_.StartProcessing();
    142   action_processor_.StopProcessing();
    143   EXPECT_TRUE(delegate_.processing_stopped_called_);
    144   EXPECT_FALSE(delegate_.action_completed_called_);
    145   EXPECT_FALSE(action_processor_.IsRunning());
    146   EXPECT_EQ(nullptr, action_processor_.current_action());
    147 }
    148 
    149 TEST_F(ActionProcessorTest, ChainActionsTest) {
    150   // This test doesn't use a delegate since it terminates several actions.
    151   action_processor_.set_delegate(nullptr);
    152 
    153   ActionProcessorTestAction action1, action2;
    154   action_processor_.EnqueueAction(&action1);
    155   action_processor_.EnqueueAction(&action2);
    156   action_processor_.StartProcessing();
    157   EXPECT_EQ(&action1, action_processor_.current_action());
    158   EXPECT_TRUE(action_processor_.IsRunning());
    159   action1.CompleteAction();
    160   EXPECT_EQ(&action2, action_processor_.current_action());
    161   EXPECT_TRUE(action_processor_.IsRunning());
    162   action2.CompleteAction();
    163   EXPECT_EQ(nullptr, action_processor_.current_action());
    164   EXPECT_FALSE(action_processor_.IsRunning());
    165 }
    166 
    167 TEST_F(ActionProcessorTest, DtorTest) {
    168   ActionProcessorTestAction action1, action2;
    169   {
    170     ActionProcessor action_processor;
    171     action_processor.EnqueueAction(&action1);
    172     action_processor.EnqueueAction(&action2);
    173     action_processor.StartProcessing();
    174   }
    175   EXPECT_EQ(nullptr, action1.processor());
    176   EXPECT_FALSE(action1.IsRunning());
    177   EXPECT_EQ(nullptr, action2.processor());
    178   EXPECT_FALSE(action2.IsRunning());
    179 }
    180 
    181 TEST_F(ActionProcessorTest, DefaultDelegateTest) {
    182   // Just make sure it doesn't crash
    183   action_processor_.EnqueueAction(&action_);
    184   action_processor_.StartProcessing();
    185   action_.CompleteAction();
    186 
    187   action_processor_.EnqueueAction(&action_);
    188   action_processor_.StartProcessing();
    189   action_processor_.StopProcessing();
    190 }
    191 
    192 // This test suspends and resume the action processor while running one action_.
    193 TEST_F(ActionProcessorTest, SuspendResumeTest) {
    194   action_processor_.EnqueueAction(&mock_action_);
    195 
    196   testing::InSequence s;
    197   EXPECT_CALL(mock_action_, PerformAction());
    198   action_processor_.StartProcessing();
    199 
    200   EXPECT_CALL(mock_action_, SuspendAction());
    201   action_processor_.SuspendProcessing();
    202   // Suspending the processor twice should not suspend the action twice.
    203   action_processor_.SuspendProcessing();
    204 
    205   // IsRunning should return whether there's is an action doing some work, even
    206   // if it is suspended.
    207   EXPECT_TRUE(action_processor_.IsRunning());
    208   EXPECT_EQ(&mock_action_, action_processor_.current_action());
    209 
    210   EXPECT_CALL(mock_action_, ResumeAction());
    211   action_processor_.ResumeProcessing();
    212 
    213   // Calling ResumeProcessing twice should not affect the action_.
    214   action_processor_.ResumeProcessing();
    215 
    216   action_processor_.ActionComplete(&mock_action_, ErrorCode::kSuccess);
    217 }
    218 
    219 // This test suspends an action that presumably doesn't support suspend/resume
    220 // and it finished before being resumed.
    221 TEST_F(ActionProcessorTest, ActionCompletedWhileSuspendedTest) {
    222   action_processor_.EnqueueAction(&mock_action_);
    223 
    224   testing::InSequence s;
    225   EXPECT_CALL(mock_action_, PerformAction());
    226   action_processor_.StartProcessing();
    227 
    228   EXPECT_CALL(mock_action_, SuspendAction());
    229   action_processor_.SuspendProcessing();
    230 
    231   // Simulate the action completion while suspended. No other call to
    232   // |mock_action_| is expected at this point.
    233   action_processor_.ActionComplete(&mock_action_, ErrorCode::kSuccess);
    234 
    235   // The processing should not be done since the ActionProcessor is suspended
    236   // and the processing is considered to be still running until resumed.
    237   EXPECT_FALSE(delegate_.processing_done_called_);
    238   EXPECT_TRUE(action_processor_.IsRunning());
    239 
    240   action_processor_.ResumeProcessing();
    241   EXPECT_TRUE(delegate_.processing_done_called_);
    242   EXPECT_FALSE(delegate_.processing_stopped_called_);
    243 }
    244 
    245 TEST_F(ActionProcessorTest, StoppedWhileSuspendedTest) {
    246   action_processor_.EnqueueAction(&mock_action_);
    247 
    248   testing::InSequence s;
    249   EXPECT_CALL(mock_action_, PerformAction());
    250   action_processor_.StartProcessing();
    251   EXPECT_CALL(mock_action_, SuspendAction());
    252   action_processor_.SuspendProcessing();
    253 
    254   EXPECT_CALL(mock_action_, TerminateProcessing());
    255   action_processor_.StopProcessing();
    256   // Stopping the processing should abort the current execution no matter what.
    257   EXPECT_TRUE(delegate_.processing_stopped_called_);
    258   EXPECT_FALSE(delegate_.processing_done_called_);
    259   EXPECT_FALSE(delegate_.action_completed_called_);
    260   EXPECT_FALSE(action_processor_.IsRunning());
    261   EXPECT_EQ(nullptr, action_processor_.current_action());
    262 }
    263 
    264 }  // namespace chromeos_update_engine
    265