rulemgt/src/test/java/org/openo/holmes/rulemgt/wrapper/RuleMgtWrapperTest.java

   1 /**\r
   2  * Copyright 2017 ZTE Corporation.\r
   3  *\r
   4  * Licensed under the Apache License, Version 2.0 (the "License");\r
   5  * you may not use this file except in compliance with the License.\r
   6  * You may obtain a copy of the License at\r
   7  *\r
   8  *      http://www.apache.org/licenses/LICENSE-2.0\r
   9  *\r
  10  * Unless required by applicable law or agreed to in writing, software\r
  11  * distributed under the License is distributed on an "AS IS" BASIS,\r
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  13  * See the License for the specific language governing permissions and\r
  14  * limitations under the License.\r
  15  */\r
  16 \r
  17 package org.openo.holmes.rulemgt.wrapper;\r
  18 \r
  19 import static org.hamcrest.MatcherAssert.assertThat;\r
  20 import static org.hamcrest.Matchers.equalTo;\r
  21 import static org.hamcrest.Matchers.is;\r
  22 \r
  23 \r
  24 import java.util.ArrayList;\r
  25 import java.util.Date;\r
  26 import java.util.List;\r
  27 import org.easymock.EasyMock;\r
  28 import org.junit.Before;\r
  29 import org.junit.Rule;\r
  30 import org.junit.Test;\r
  31 import org.junit.rules.ExpectedException;\r
  32 import org.junit.runner.RunWith;\r
  33 import org.openo.holmes.common.api.entity.CorrelationRule;\r
  34 import org.openo.holmes.common.exception.CallException;\r
  35 import org.openo.holmes.common.exception.DataFormatException;\r
  36 import org.openo.holmes.common.exception.DbException;\r
  37 import org.openo.holmes.common.utils.DbDaoUtil;\r
  38 import org.openo.holmes.common.utils.I18nProxy;\r
  39 import org.openo.holmes.rulemgt.bean.request.CorrelationCheckRule4Engine;\r
  40 import org.openo.holmes.rulemgt.bean.request.CorrelationDeployRule4Engine;\r
  41 import org.openo.holmes.rulemgt.bean.request.RuleCreateRequest;\r
  42 import org.openo.holmes.rulemgt.bean.request.RuleDeleteRequest;\r
  43 import org.openo.holmes.rulemgt.bean.request.RuleQueryCondition;\r
  44 import org.openo.holmes.rulemgt.bean.request.RuleUpdateRequest;\r
  45 import org.openo.holmes.rulemgt.bean.response.RuleAddAndUpdateResponse;\r
  46 import org.openo.holmes.rulemgt.bean.response.RuleQueryListResponse;\r
  47 import org.openo.holmes.rulemgt.bolt.enginebolt.EngineWrapper;\r
  48 import org.openo.holmes.rulemgt.db.CorrelationRuleDao;\r
  49 import org.openo.holmes.rulemgt.db.CorrelationRuleQueryDao;\r
  50 import org.powermock.api.easymock.PowerMock;\r
  51 import org.powermock.core.classloader.annotations.SuppressStaticInitializationFor;\r
  52 import org.powermock.modules.junit4.PowerMockRunner;\r
  53 import org.powermock.reflect.Whitebox;\r
  54 \r
  55 @RunWith(PowerMockRunner.class)\r
  56 @SuppressStaticInitializationFor("org.openo.holmes.common.utils.DbDaoUtil")\r
  57 public class RuleMgtWrapperTest {\r
  58 \r
  59     @Rule\r
  60     public ExpectedException thrown = ExpectedException.none();\r
  61 \r
  62     private RuleMgtWrapper ruleMgtWrapper;\r
  63 \r
  64     private EngineWrapper engineWrapperMock;\r
  65 \r
  66     private DbDaoUtil dbDaoUtilMock;\r
  67 \r
  68     private CorrelationRuleQueryDao correlationRuleQueryDaoMock;\r
  69 \r
  70     private CorrelationRuleDao correlationRuleDaoMock;\r
  71 \r
  72     private static final String USER_NAME = "admin";\r
  73 \r
  74     @Before\r
  75     public void setUp() throws Exception {\r
  76 \r
  77         ruleMgtWrapper = new RuleMgtWrapper();\r
  78 \r
  79         engineWrapperMock = PowerMock.createMock(EngineWrapper.class);\r
  80         correlationRuleQueryDaoMock = PowerMock.createMock(CorrelationRuleQueryDao.class);\r
  81         dbDaoUtilMock = PowerMock.createMock(DbDaoUtil.class);\r
  82         correlationRuleDaoMock = PowerMock.createMock(CorrelationRuleDao.class);\r
  83 \r
  84         Whitebox.setInternalState(ruleMgtWrapper, "daoUtil", dbDaoUtilMock);\r
  85         Whitebox.setInternalState(ruleMgtWrapper, "correlationRuleQueryDao", correlationRuleQueryDaoMock);\r
  86         Whitebox.setInternalState(ruleMgtWrapper, "engineWarpper", engineWrapperMock);\r
  87 \r
  88         PowerMock.resetAll();\r
  89     }\r
  90 \r
  91     @Test\r
  92     public void addCorrelationRule_name_is_null() throws Exception {\r
  93         thrown.expect(DbException.class);\r
  94         thrown.expectMessage(I18nProxy.RULE_MANAGEMENT_RULE_NAME_IS_EMPTY);\r
  95 \r
  96         ruleMgtWrapper.addCorrelationRule(USER_NAME, createRuleCreateRequest(null, "This is a rule for testing.",\r
  97                 "Mocked contents.", 0));\r
  98     }\r
  99 \r
 100     @Test\r
 101     public void addCorrelationRule_name_is_empty() throws Exception {\r
 102         thrown.expect(DbException.class);\r
 103         thrown.expectMessage(I18nProxy.RULE_MANAGEMENT_RULE_NAME_IS_EMPTY);\r
 104 \r
 105         ruleMgtWrapper.addCorrelationRule("admin", createRuleCreateRequest("", "This is a rule for testing.",\r
 106                 "Mocked contents.", 0));\r
 107     }\r
 108 \r
 109     @Test\r
 110     public void addCorrelationRule_duplicated_rule() throws Exception {\r
 111 \r
 112         final String ruleName = "Rule-001";\r
 113 \r
 114         RuleCreateRequest ruleCreateRequest = createRuleCreateRequest(ruleName, "This is a rule for testing.",\r
 115                 "Mocked contents.", 0);\r
 116         CorrelationRule correlationRule = convertCreateRequest2CorrelationRule(ruleCreateRequest);\r
 117 \r
 118         thrown.expect(DbException.class);\r
 119         thrown.expectMessage(I18nProxy.RULE_MANAGEMENT_REPEAT_RULE_NAME);\r
 120 \r
 121         EasyMock.expect(dbDaoUtilMock.getJdbiDaoByOnDemand(CorrelationRuleDao.class)).andReturn(\r
 122                 correlationRuleDaoMock);\r
 123         EasyMock.expect(correlationRuleDaoMock.queryRuleByRuleName(ruleName)).andReturn(correlationRule);\r
 124 \r
 125         PowerMock.replayAll();\r
 126 \r
 127         ruleMgtWrapper.addCorrelationRule("admin", ruleCreateRequest);\r
 128 \r
 129         PowerMock.verifyAll();\r
 130     }\r
 131 \r
 132     @Test\r
 133     public void addCorrelationRule_rule_deploy_verify_failure() throws Exception {\r
 134 \r
 135         final String ruleName = "Rule-001";\r
 136 \r
 137         RuleCreateRequest ruleCreateRequest = createRuleCreateRequest(ruleName, "This is a rule for testing.",\r
 138                 "Mocked contents.", 0);\r
 139 \r
 140         thrown.expect(CallException.class);\r
 141         thrown.expectMessage(I18nProxy.RULE_MANAGEMENT__CALL_CHECK_RULE_REST_FAILED);\r
 142 \r
 143         EasyMock.expect(dbDaoUtilMock.getJdbiDaoByOnDemand(CorrelationRuleDao.class)).andReturn(\r
 144                 correlationRuleDaoMock);\r
 145         EasyMock.expect(correlationRuleDaoMock.queryRuleByRuleName(ruleName)).andReturn(null);\r
 146         EasyMock.expect(engineWrapperMock.checkRuleFromEngine(EasyMock.anyObject(CorrelationCheckRule4Engine.class)))\r
 147                 .andThrow(new CallException(I18nProxy.RULE_MANAGEMENT__CALL_CHECK_RULE_REST_FAILED));\r
 148 \r
 149         PowerMock.replayAll();\r
 150 \r
 151         ruleMgtWrapper.addCorrelationRule("admin", ruleCreateRequest);\r
 152 \r
 153         PowerMock.verifyAll();\r
 154     }\r
 155 \r
 156     @Test\r
 157     public void addCorrelationRule_rule_deploy_rule_enabled_failure() throws Exception {\r
 158 \r
 159         final String ruleName = "Rule-001";\r
 160 \r
 161         RuleCreateRequest ruleCreateRequest = createRuleCreateRequest(ruleName, "This is a rule for testing.",\r
 162                 "Mocked contents.", 1);\r
 163 \r
 164         thrown.expect(CallException.class);\r
 165         thrown.expectMessage(I18nProxy.RULE_MANAGEMENT_CALL_DEPLOY_RULE_REST_FAILED);\r
 166 \r
 167         EasyMock.expect(dbDaoUtilMock.getJdbiDaoByOnDemand(CorrelationRuleDao.class)).andReturn(\r
 168                 correlationRuleDaoMock);\r
 169         EasyMock.expect(correlationRuleDaoMock.queryRuleByRuleName(ruleName)).andReturn(null);\r
 170         EasyMock.expect(engineWrapperMock.checkRuleFromEngine(EasyMock.anyObject(CorrelationCheckRule4Engine.class)))\r
 171                 .andReturn(true);\r
 172         EasyMock.expect(engineWrapperMock.deployEngine(EasyMock.anyObject(CorrelationDeployRule4Engine.class)))\r
 173                 .andThrow(new CallException(I18nProxy.RULE_MANAGEMENT_CALL_DEPLOY_RULE_REST_FAILED));\r
 174 \r
 175         PowerMock.replayAll();\r
 176 \r
 177         ruleMgtWrapper.addCorrelationRule("admin", ruleCreateRequest);\r
 178 \r
 179         PowerMock.verifyAll();\r
 180     }\r
 181 \r
 182     @Test\r
 183     public void addCorrelationRule_rule_save_failure() throws Exception {\r
 184         final String ruleName = "Rule-001";\r
 185 \r
 186         RuleCreateRequest ruleCreateRequest = createRuleCreateRequest(ruleName, "This is a rule for testing.",\r
 187                 "Mocked contents.", 1);\r
 188 \r
 189         thrown.expect(DbException.class);\r
 190         thrown.expectMessage(I18nProxy.RULE_MANAGEMENT_CREATE_RULE_FAILED);\r
 191 \r
 192         EasyMock.expect(dbDaoUtilMock.getJdbiDaoByOnDemand(CorrelationRuleDao.class)).andReturn(\r
 193                 correlationRuleDaoMock).times(2);\r
 194         EasyMock.expect(correlationRuleDaoMock.queryRuleByRuleName(ruleName)).andReturn(null);\r
 195         EasyMock.expect(engineWrapperMock.checkRuleFromEngine(EasyMock.anyObject(CorrelationCheckRule4Engine.class)))\r
 196                 .andReturn(true);\r
 197         EasyMock.expect(engineWrapperMock.deployEngine(EasyMock.anyObject(CorrelationDeployRule4Engine.class)))\r
 198                 .andReturn("package-001");\r
 199         EasyMock.expect(correlationRuleDaoMock.saveRule(EasyMock.anyObject(CorrelationRule.class)))\r
 200                 .andThrow(new RuntimeException("any message"));\r
 201 \r
 202         PowerMock.replayAll();\r
 203 \r
 204         ruleMgtWrapper.addCorrelationRule("admin", ruleCreateRequest);\r
 205 \r
 206         PowerMock.verifyAll();\r
 207     }\r
 208 \r
 209     @Test\r
 210     public void addCorrelationRule_normal() throws Exception {\r
 211         final String ruleName = "Rule-001";\r
 212 \r
 213         RuleCreateRequest ruleCreateRequest = createRuleCreateRequest(ruleName, "This is a rule for testing.",\r
 214                 "Mocked contents.", 1);\r
 215 \r
 216         CorrelationRule correlationRuleRet = new CorrelationRule();\r
 217         correlationRuleRet.setRid("rule_" + System.currentTimeMillis());\r
 218 \r
 219         EasyMock.expect(dbDaoUtilMock.getJdbiDaoByOnDemand(CorrelationRuleDao.class)).andReturn(\r
 220                 correlationRuleDaoMock).times(2);\r
 221         EasyMock.expect(correlationRuleDaoMock.queryRuleByRuleName(ruleName)).andReturn(null);\r
 222         EasyMock.expect(engineWrapperMock.checkRuleFromEngine(EasyMock.anyObject(CorrelationCheckRule4Engine.class)))\r
 223                 .andReturn(true);\r
 224         EasyMock.expect(engineWrapperMock.deployEngine(EasyMock.anyObject(CorrelationDeployRule4Engine.class)))\r
 225                 .andReturn("package-001");\r
 226         EasyMock.expect(correlationRuleDaoMock.saveRule(EasyMock.anyObject(CorrelationRule.class)))\r
 227                 .andReturn(correlationRuleRet);\r
 228 \r
 229         PowerMock.replayAll();\r
 230 \r
 231         RuleAddAndUpdateResponse response = ruleMgtWrapper.addCorrelationRule("admin", ruleCreateRequest);\r
 232         assertThat(response.getRuleId(), equalTo(correlationRuleRet.getRid()));\r
 233 \r
 234         PowerMock.verifyAll();\r
 235     }\r
 236 \r
 237     @Test\r
 238     public void updateCorrelationRule_param_null() throws Exception {\r
 239         thrown.expect(DataFormatException.class);\r
 240         thrown.expectMessage(I18nProxy.RULE_MANAGEMENT_REQUEST_OBJECT_IS_EMPTY);\r
 241 \r
 242         ruleMgtWrapper.updateCorrelationRule(USER_NAME, null);\r
 243     }\r
 244 \r
 245     @Test\r
 246     public void updateCorrelationRule_rule_not_exist() throws Exception {\r
 247         thrown.expect(DbException.class);\r
 248         thrown.expectMessage(I18nProxy.RULE_MANAGEMENT_RULE_NOT_EXIST_DATABASE);\r
 249 \r
 250         EasyMock.expect(dbDaoUtilMock.getJdbiDaoByOnDemand(CorrelationRuleDao.class)).andReturn(\r
 251                 correlationRuleDaoMock);\r
 252         EasyMock.expect(correlationRuleDaoMock.getRuleByRid(EasyMock.anyObject(String.class))).andReturn(null);\r
 253 \r
 254         PowerMock.replayAll();\r
 255 \r
 256         ruleMgtWrapper.updateCorrelationRule(USER_NAME, new RuleUpdateRequest());\r
 257 \r
 258         PowerMock.verifyAll();\r
 259     }\r
 260 \r
 261     @Test\r
 262     public void updateCorrelationRule_rule_status_illegal_with_contents() throws Exception {\r
 263         thrown.expect(DataFormatException.class);\r
 264         thrown.expectMessage(I18nProxy.RULE_MANAGEMENT_PARAMETER_ENABLED_ERROR);\r
 265 \r
 266         RuleUpdateRequest ruleUpdateRequest = createRuleUpdateRequest("rule_" + System.currentTimeMillis(),\r
 267                 "desc", "contents", 3);\r
 268         CorrelationRule correlationRule = convertUpdateRequest2CorrelationRule(ruleUpdateRequest);\r
 269         correlationRule.setContent("previous contents");\r
 270 \r
 271         EasyMock.expect(dbDaoUtilMock.getJdbiDaoByOnDemand(CorrelationRuleDao.class)).andReturn(\r
 272                 correlationRuleDaoMock);\r
 273         EasyMock.expect(correlationRuleDaoMock.getRuleByRid(EasyMock.anyObject(String.class)))\r
 274                 .andReturn(correlationRule);\r
 275 \r
 276         PowerMock.replayAll();\r
 277 \r
 278         ruleMgtWrapper.updateCorrelationRule(USER_NAME, ruleUpdateRequest);\r
 279 \r
 280         PowerMock.verifyAll();\r
 281     }\r
 282 \r
 283     @Test\r
 284     public void updateCorrelationRule_rule_status_illegal_with_null_contents() throws Exception {\r
 285         thrown.expect(DataFormatException.class);\r
 286         thrown.expectMessage(I18nProxy.RULE_MANAGEMENT_PARAMETER_ENABLED_ERROR);\r
 287 \r
 288         RuleUpdateRequest ruleUpdateRequest = createRuleUpdateRequest("rule_" + System.currentTimeMillis(),\r
 289                 "desc", null, 3);\r
 290         CorrelationRule correlationRule = convertUpdateRequest2CorrelationRule(ruleUpdateRequest);\r
 291         correlationRule.setContent("previous contents");\r
 292 \r
 293         EasyMock.expect(dbDaoUtilMock.getJdbiDaoByOnDemand(CorrelationRuleDao.class)).andReturn(\r
 294                 correlationRuleDaoMock);\r
 295         EasyMock.expect(correlationRuleDaoMock.getRuleByRid(EasyMock.anyObject(String.class)))\r
 296                 .andReturn(correlationRule);\r
 297 \r
 298         PowerMock.replayAll();\r
 299 \r
 300         ruleMgtWrapper.updateCorrelationRule(USER_NAME, ruleUpdateRequest);\r
 301 \r
 302         PowerMock.verifyAll();\r
 303     }\r
 304 \r
 305     @Test\r
 306     public void updateCorrelationRule_rule_disabled_update_failure() throws Exception {\r
 307         thrown.expect(DbException.class);\r
 308         thrown.expectMessage(I18nProxy.RULE_MANAGEMENT_UPDATE_RULE_FAILED);\r
 309 \r
 310         RuleUpdateRequest ruleUpdateRequest = createRuleUpdateRequest("rule_" + System.currentTimeMillis(),\r
 311                 "desc", "contents", 0);\r
 312         CorrelationRule correlationRuleOld = convertUpdateRequest2CorrelationRule(ruleUpdateRequest);\r
 313         correlationRuleOld.setContent("previous contents");\r
 314 \r
 315         EasyMock.expect(dbDaoUtilMock.getJdbiDaoByOnDemand(CorrelationRuleDao.class)).andReturn(\r
 316                 correlationRuleDaoMock).anyTimes();\r
 317         EasyMock.expect(correlationRuleDaoMock.getRuleByRid(EasyMock.anyObject(String.class)))\r
 318                 .andReturn(correlationRuleOld);\r
 319         correlationRuleDaoMock.updateRule(EasyMock.anyObject(CorrelationRule.class));\r
 320         EasyMock.expectLastCall().andThrow(new RuntimeException("Failed to update the rule."));\r
 321 \r
 322         PowerMock.replayAll();\r
 323 \r
 324         ruleMgtWrapper.updateCorrelationRule(USER_NAME, ruleUpdateRequest);\r
 325 \r
 326         PowerMock.verifyAll();\r
 327     }\r
 328 \r
 329     @Test\r
 330     public void updateCorrelationRule_rule_disabled_deploy_verify_exception() throws Exception {\r
 331         thrown.expect(CallException.class);\r
 332         thrown.expectMessage(I18nProxy.RULE_MANAGEMENT__CALL_CHECK_RULE_REST_FAILED);\r
 333 \r
 334         RuleUpdateRequest ruleUpdateRequest = createRuleUpdateRequest("rule_" + System.currentTimeMillis(),\r
 335                 "desc", null, 0);\r
 336         CorrelationRule correlationRuleOld = convertUpdateRequest2CorrelationRule(ruleUpdateRequest);\r
 337         correlationRuleOld.setContent("previous contents");\r
 338 \r
 339         EasyMock.expect(dbDaoUtilMock.getJdbiDaoByOnDemand(CorrelationRuleDao.class)).andReturn(\r
 340                 correlationRuleDaoMock).anyTimes();\r
 341         EasyMock.expect(correlationRuleDaoMock.getRuleByRid(EasyMock.anyObject(String.class)))\r
 342                 .andReturn(correlationRuleOld);\r
 343         correlationRuleDaoMock.updateRule(EasyMock.anyObject(CorrelationRule.class));\r
 344         EasyMock.expectLastCall();\r
 345         EasyMock.expect(engineWrapperMock.checkRuleFromEngine(EasyMock.anyObject(CorrelationCheckRule4Engine.class)))\r
 346                 .andThrow(new CallException(I18nProxy.RULE_MANAGEMENT__CALL_CHECK_RULE_REST_FAILED));\r
 347 \r
 348         PowerMock.replayAll();\r
 349 \r
 350         ruleMgtWrapper.updateCorrelationRule(USER_NAME, ruleUpdateRequest);\r
 351 \r
 352         PowerMock.verifyAll();\r
 353     }\r
 354 \r
 355     @Test\r
 356     public void updateCorrelationRule_rule_disabled_deploy_verify_false() throws Exception {\r
 357 \r
 358         RuleUpdateRequest ruleUpdateRequest = createRuleUpdateRequest("rule_" + System.currentTimeMillis(),\r
 359                 "desc", null, 0);\r
 360         CorrelationRule correlationRuleOld = convertUpdateRequest2CorrelationRule(ruleUpdateRequest);\r
 361         correlationRuleOld.setContent("previous contents");\r
 362 \r
 363         EasyMock.expect(dbDaoUtilMock.getJdbiDaoByOnDemand(CorrelationRuleDao.class)).andReturn(\r
 364                 correlationRuleDaoMock).anyTimes();\r
 365         EasyMock.expect(correlationRuleDaoMock.getRuleByRid(EasyMock.anyObject(String.class)))\r
 366                 .andReturn(correlationRuleOld);\r
 367         correlationRuleDaoMock.updateRule(EasyMock.anyObject(CorrelationRule.class));\r
 368         EasyMock.expectLastCall();\r
 369         EasyMock.expect(engineWrapperMock.checkRuleFromEngine(EasyMock.anyObject(CorrelationCheckRule4Engine.class)))\r
 370                 .andReturn(false);\r
 371 \r
 372         PowerMock.replayAll();\r
 373 \r
 374         RuleAddAndUpdateResponse response = ruleMgtWrapper.updateCorrelationRule(USER_NAME, ruleUpdateRequest);\r
 375 \r
 376         assertThat(response.getRuleId(), equalTo(ruleUpdateRequest.getRuleId()));\r
 377 \r
 378         PowerMock.verifyAll();\r
 379     }\r
 380 \r
 381     @Test\r
 382     public void updateCorrelationRule_rule_enabled_engine_delete_failure() throws Exception {\r
 383         thrown.expect(DbException.class);\r
 384         thrown.expectMessage(I18nProxy.RULE_MANAGEMENT_UPDATE_RULE_FAILED);\r
 385 \r
 386         RuleUpdateRequest ruleUpdateRequest = createRuleUpdateRequest("rule_" + System.currentTimeMillis(),\r
 387                 "desc", null, 1);\r
 388         CorrelationRule correlationRuleOld = convertUpdateRequest2CorrelationRule(ruleUpdateRequest);\r
 389         correlationRuleOld.setContent("previous contents");\r
 390 \r
 391         EasyMock.expect(dbDaoUtilMock.getJdbiDaoByOnDemand(CorrelationRuleDao.class)).andReturn(\r
 392                 correlationRuleDaoMock).anyTimes();\r
 393         EasyMock.expect(correlationRuleDaoMock.getRuleByRid(EasyMock.anyObject(String.class)))\r
 394                 .andReturn(correlationRuleOld);\r
 395         engineWrapperMock.deleteRuleFromEngine(correlationRuleOld.getPackageName());\r
 396         EasyMock.expectLastCall().andThrow(new RuntimeException("Failed to delete the rule from the engine."));\r
 397 \r
 398         PowerMock.replayAll();\r
 399 \r
 400         ruleMgtWrapper.updateCorrelationRule(USER_NAME, ruleUpdateRequest);\r
 401 \r
 402         PowerMock.verifyAll();\r
 403     }\r
 404 \r
 405     @Test\r
 406     public void updateCorrelationRule_rule_enabled_engine_deploy_failure() throws Exception {\r
 407         thrown.expect(CallException.class);\r
 408         thrown.expectMessage(I18nProxy.RULE_MANAGEMENT_CALL_DEPLOY_RULE_REST_FAILED);\r
 409 \r
 410         RuleUpdateRequest ruleUpdateRequest = createRuleUpdateRequest("rule_" + System.currentTimeMillis(),\r
 411                 "desc", null, 1);\r
 412         CorrelationRule correlationRuleOld = convertUpdateRequest2CorrelationRule(ruleUpdateRequest);\r
 413         correlationRuleOld.setContent("previous contents");\r
 414 \r
 415         EasyMock.expect(dbDaoUtilMock.getJdbiDaoByOnDemand(CorrelationRuleDao.class)).andReturn(\r
 416                 correlationRuleDaoMock).anyTimes();\r
 417         EasyMock.expect(correlationRuleDaoMock.getRuleByRid(EasyMock.anyObject(String.class)))\r
 418                 .andReturn(correlationRuleOld);\r
 419         EasyMock.expect(engineWrapperMock.deleteRuleFromEngine(correlationRuleOld.getPackageName())).andReturn(true);\r
 420         correlationRuleDaoMock.updateRule(EasyMock.anyObject(CorrelationRule.class));\r
 421         EasyMock.expectLastCall();\r
 422         EasyMock.expect(engineWrapperMock.checkRuleFromEngine(EasyMock.anyObject(CorrelationCheckRule4Engine.class)))\r
 423                 .andReturn(true);\r
 424         EasyMock.expect(engineWrapperMock.deployEngine(EasyMock.anyObject(CorrelationDeployRule4Engine.class)))\r
 425                 .andThrow(new CallException(I18nProxy.RULE_MANAGEMENT_CALL_DEPLOY_RULE_REST_FAILED));\r
 426 \r
 427         PowerMock.replayAll();\r
 428 \r
 429         ruleMgtWrapper.updateCorrelationRule(USER_NAME, ruleUpdateRequest);\r
 430 \r
 431         PowerMock.verifyAll();\r
 432     }\r
 433 \r
 434     @Test\r
 435     public void updateCorrelationRule_rule_enabled_deploy_rule_enabled() throws Exception {\r
 436 \r
 437         RuleUpdateRequest ruleUpdateRequest = createRuleUpdateRequest("rule_" + System.currentTimeMillis(),\r
 438                 "desc", null, 1);\r
 439         CorrelationRule correlationRuleOld = convertUpdateRequest2CorrelationRule(ruleUpdateRequest);\r
 440         correlationRuleOld.setContent("previous contents");\r
 441 \r
 442         EasyMock.expect(dbDaoUtilMock.getJdbiDaoByOnDemand(CorrelationRuleDao.class)).andReturn(\r
 443                 correlationRuleDaoMock).anyTimes();\r
 444         EasyMock.expect(correlationRuleDaoMock.getRuleByRid(EasyMock.anyObject(String.class)))\r
 445                 .andReturn(correlationRuleOld);\r
 446         EasyMock.expect(engineWrapperMock.deleteRuleFromEngine(correlationRuleOld.getPackageName())).andReturn(true);\r
 447         correlationRuleDaoMock.updateRule(EasyMock.anyObject(CorrelationRule.class));\r
 448         EasyMock.expectLastCall();\r
 449         EasyMock.expect(engineWrapperMock.checkRuleFromEngine(EasyMock.anyObject(CorrelationCheckRule4Engine.class)))\r
 450                 .andReturn(true);\r
 451         EasyMock.expect(engineWrapperMock.deployEngine(EasyMock.anyObject(CorrelationDeployRule4Engine.class)))\r
 452                 .andReturn("package-name");\r
 453 \r
 454         PowerMock.replayAll();\r
 455 \r
 456         RuleAddAndUpdateResponse response = ruleMgtWrapper.updateCorrelationRule(USER_NAME, ruleUpdateRequest);\r
 457 \r
 458         assertThat(response.getRuleId(), equalTo(ruleUpdateRequest.getRuleId()));\r
 459 \r
 460         PowerMock.verifyAll();\r
 461     }\r
 462 \r
 463     @Test\r
 464     public void checkCorrelation_content_null() throws Exception {\r
 465         RuleUpdateRequest ruleCreateRequest = createRuleUpdateRequest("rule_" + System.currentTimeMillis(),\r
 466                 "desc", null, 0);\r
 467         CorrelationRule correlationRuleOld = convertUpdateRequest2CorrelationRule(ruleCreateRequest);\r
 468         CorrelationRule correlationRuleNew = convertUpdateRequest2CorrelationRule(ruleCreateRequest);\r
 469         correlationRuleOld.setContent("previous contents");\r
 470 \r
 471         ruleMgtWrapper.checkCorrelation(correlationRuleNew, correlationRuleOld);\r
 472 \r
 473         assertThat(correlationRuleNew.getContent(), equalTo(correlationRuleOld.getContent()));\r
 474     }\r
 475 \r
 476     @Test\r
 477     public void checkCorrelation_illegal_status() throws Exception {\r
 478         thrown.expect(DataFormatException.class);\r
 479         thrown.expectMessage(I18nProxy.RULE_MANAGEMENT_PARAMETER_ENABLED_ERROR);\r
 480 \r
 481         RuleUpdateRequest ruleCreateRequest = createRuleUpdateRequest("rule_" + System.currentTimeMillis(),\r
 482                 "desc", null, 2);\r
 483         CorrelationRule correlationRuleOld = convertUpdateRequest2CorrelationRule(ruleCreateRequest);\r
 484         CorrelationRule correlationRuleNew = convertUpdateRequest2CorrelationRule(ruleCreateRequest);\r
 485         correlationRuleOld.setContent("previous contents");\r
 486 \r
 487         ruleMgtWrapper.checkCorrelation(correlationRuleNew, correlationRuleOld);\r
 488     }\r
 489 \r
 490 \r
 491     @Test\r
 492     public void deleteCorrelationRule_request_null() throws Exception {\r
 493         thrown.expect(DataFormatException.class);\r
 494         thrown.expectMessage((I18nProxy.RULE_MANAGEMENT_REQUEST_OBJECT_IS_EMPTY));\r
 495 \r
 496         ruleMgtWrapper.deleteCorrelationRule(null);\r
 497     }\r
 498 \r
 499     @Test\r
 500     public void deleteCorrelationRule_rule_not_exit() throws Exception {\r
 501         thrown.expect(DbException.class);\r
 502         thrown.expectMessage((I18nProxy.RULE_MANAGEMENT_RULE_NOT_EXIST_DATABASE));\r
 503 \r
 504         RuleDeleteRequest ruleDeleteRequest = createRuleDeleteRequest("rule_" + System.currentTimeMillis());\r
 505 \r
 506         EasyMock.expect(dbDaoUtilMock.getJdbiDaoByOnDemand(CorrelationRuleDao.class)).andReturn(\r
 507                 correlationRuleDaoMock).anyTimes();\r
 508         EasyMock.expect(correlationRuleDaoMock.getRuleByRid(ruleDeleteRequest.getRuleId()))\r
 509                 .andReturn(null);\r
 510 \r
 511         PowerMock.replayAll();\r
 512 \r
 513         ruleMgtWrapper.deleteCorrelationRule(ruleDeleteRequest);\r
 514 \r
 515         PowerMock.verifyAll();\r
 516     }\r
 517 \r
 518     @Test\r
 519     public void deleteCorrelationRule_rule_enabled_engine_delete_exception() throws Exception {\r
 520         thrown.expect(DbException.class);\r
 521         thrown.expectMessage((I18nProxy.RULE_MANAGEMENT_DELETE_RULE_FAILED));\r
 522 \r
 523         RuleDeleteRequest ruleDeleteRequest = createRuleDeleteRequest("rule_" + System.currentTimeMillis());\r
 524         RuleUpdateRequest ruleCreateRequest = createRuleUpdateRequest("rule_" + System.currentTimeMillis(),\r
 525                 "desc", "contents", 1);\r
 526         CorrelationRule correlationRule = convertUpdateRequest2CorrelationRule(ruleCreateRequest);\r
 527 \r
 528         EasyMock.expect(dbDaoUtilMock.getJdbiDaoByOnDemand(CorrelationRuleDao.class)).andReturn(\r
 529                 correlationRuleDaoMock).anyTimes();\r
 530         EasyMock.expect(correlationRuleDaoMock.getRuleByRid(ruleDeleteRequest.getRuleId()))\r
 531                 .andReturn(correlationRule);\r
 532         EasyMock.expect(engineWrapperMock.deleteRuleFromEngine(correlationRule.getPackageName()))\r
 533                 .andThrow(new RuntimeException("Failed to delete the rule from the engine"));\r
 534 \r
 535         PowerMock.replayAll();\r
 536 \r
 537         ruleMgtWrapper.deleteCorrelationRule(ruleDeleteRequest);\r
 538 \r
 539         PowerMock.verifyAll();\r
 540     }\r
 541 \r
 542     @Test\r
 543     public void deleteCorrelationRule_rule_disabled_delete_exception() throws Exception {\r
 544         thrown.expect(DbException.class);\r
 545         thrown.expectMessage((I18nProxy.RULE_MANAGEMENT_DELETE_RULE_FAILED));\r
 546 \r
 547         RuleDeleteRequest ruleDeleteRequest = createRuleDeleteRequest("rule_" + System.currentTimeMillis());\r
 548         RuleUpdateRequest ruleCreateRequest = createRuleUpdateRequest("rule_" + System.currentTimeMillis(),\r
 549                 "desc", "contents", 0);\r
 550         CorrelationRule correlationRule = convertUpdateRequest2CorrelationRule(ruleCreateRequest);\r
 551 \r
 552         EasyMock.expect(dbDaoUtilMock.getJdbiDaoByOnDemand(CorrelationRuleDao.class)).andReturn(\r
 553                 correlationRuleDaoMock).anyTimes();\r
 554         EasyMock.expect(correlationRuleDaoMock.getRuleByRid(ruleDeleteRequest.getRuleId()))\r
 555                 .andReturn(correlationRule);\r
 556         correlationRuleDaoMock.deleteRule(correlationRule);\r
 557         EasyMock.expectLastCall().andThrow(new RuntimeException("Failed to delete the rule from the DB"));\r
 558 \r
 559         PowerMock.replayAll();\r
 560 \r
 561         ruleMgtWrapper.deleteCorrelationRule(ruleDeleteRequest);\r
 562 \r
 563         PowerMock.verifyAll();\r
 564     }\r
 565 \r
 566     @Test\r
 567     public void deleteCorrelationRule_normal() throws Exception {\r
 568         RuleDeleteRequest ruleDeleteRequest = createRuleDeleteRequest("rule_" + System.currentTimeMillis());\r
 569         RuleUpdateRequest ruleCreateRequest = createRuleUpdateRequest("rule_" + System.currentTimeMillis(),\r
 570                 "desc", "contents", 1);\r
 571         CorrelationRule correlationRule = convertUpdateRequest2CorrelationRule(ruleCreateRequest);\r
 572 \r
 573         EasyMock.expect(dbDaoUtilMock.getJdbiDaoByOnDemand(CorrelationRuleDao.class)).andReturn(\r
 574                 correlationRuleDaoMock).anyTimes();\r
 575         EasyMock.expect(correlationRuleDaoMock.getRuleByRid(ruleDeleteRequest.getRuleId()))\r
 576                 .andReturn(correlationRule);\r
 577         EasyMock.expect(engineWrapperMock.deleteRuleFromEngine(correlationRule.getPackageName())).andReturn(true);\r
 578         correlationRuleDaoMock.deleteRule(correlationRule);\r
 579         EasyMock.expectLastCall();\r
 580 \r
 581         PowerMock.replayAll();\r
 582 \r
 583         ruleMgtWrapper.deleteCorrelationRule(ruleDeleteRequest);\r
 584 \r
 585         PowerMock.verifyAll();\r
 586     }\r
 587 \r
 588     @Test\r
 589     public void getCorrelationRuleByCondition_data_format_exception() throws Exception {\r
 590         thrown.expect(DataFormatException.class);\r
 591         thrown.expectMessage((I18nProxy.RULE_MANAGEMENT_CREATE_QUERY_SQL_FAILED));\r
 592 \r
 593         EasyMock.expect(correlationRuleQueryDaoMock.getCorrelationRulesByCondition(EasyMock.anyObject(\r
 594                 RuleQueryCondition.class)))\r
 595                 .andThrow(new DataFormatException(I18nProxy.RULE_MANAGEMENT_CREATE_QUERY_SQL_FAILED));\r
 596 \r
 597         PowerMock.replay(correlationRuleQueryDaoMock, CorrelationRuleQueryDao.class);\r
 598 \r
 599         ruleMgtWrapper.getCorrelationRuleByCondition(new RuleQueryCondition());\r
 600 \r
 601         PowerMock.verify(correlationRuleQueryDaoMock, CorrelationRuleQueryDao.class);\r
 602     }\r
 603 \r
 604     @Test\r
 605     public void getCorrelationRuleByCondition_db_exception() throws Exception {\r
 606         thrown.expect(DbException.class);\r
 607         thrown.expectMessage((I18nProxy.RULE_MANAGEMENT_QUERY_RULE_FAILED));\r
 608 \r
 609         EasyMock.expect(correlationRuleQueryDaoMock.getCorrelationRulesByCondition(EasyMock.anyObject(\r
 610                 RuleQueryCondition.class)))\r
 611                 .andThrow(new DbException(I18nProxy.RULE_MANAGEMENT_QUERY_RULE_FAILED));\r
 612 \r
 613         PowerMock.replay(correlationRuleQueryDaoMock, CorrelationRuleQueryDao.class);\r
 614 \r
 615         ruleMgtWrapper.getCorrelationRuleByCondition(new RuleQueryCondition());\r
 616 \r
 617         PowerMock.verify(correlationRuleQueryDaoMock, CorrelationRuleQueryDao.class);\r
 618     }\r
 619 \r
 620     @Test\r
 621     public void getCorrelationRuleByCondition_normal() throws Exception {\r
 622         List<CorrelationRule> correlationRuleList = new ArrayList<CorrelationRule>(10);\r
 623         for (int i = 0; i < 10; ++i) {\r
 624             CorrelationRule correlationRule = new CorrelationRule();\r
 625             correlationRule.setContent("content" + i);\r
 626             correlationRule.setName("name" + i);\r
 627             correlationRule.setRid("rule_" + i);\r
 628             correlationRule.setIsManual(i % 2);\r
 629             correlationRule.setEngineType("engineType" + (i % 2 + 1));\r
 630             correlationRule.setEngineId("engineId" + i);\r
 631             correlationRule.setCreateTime(new Date());\r
 632             correlationRule.setCreator(USER_NAME);\r
 633             correlationRule.setDescription("description" + i);\r
 634             correlationRule.setPackageName("package" + i);\r
 635             correlationRuleList.add(correlationRule);\r
 636         }\r
 637 \r
 638         EasyMock.expect(correlationRuleQueryDaoMock.getCorrelationRulesByCondition(EasyMock.anyObject(\r
 639                 RuleQueryCondition.class))).andReturn(correlationRuleList);\r
 640 \r
 641         PowerMock.replay(correlationRuleQueryDaoMock, CorrelationRuleQueryDao.class);\r
 642 \r
 643         RuleQueryListResponse response = ruleMgtWrapper.getCorrelationRuleByCondition(new RuleQueryCondition());\r
 644 \r
 645         PowerMock.verify(correlationRuleQueryDaoMock, CorrelationRuleQueryDao.class);\r
 646 \r
 647         assertThat(response.getTotalCount(), is(10));\r
 648 \r
 649         for (int i = 0; i < 10; ++i) {\r
 650             assertThat(response.getCorrelationRules().get(i).getRuleId(),\r
 651                     equalTo(correlationRuleList.get(i).getRid()));\r
 652         }\r
 653     }\r
 654 \r
 655     private RuleCreateRequest createRuleCreateRequest(String ruleName, String description, String content,\r
 656             int enabled) {\r
 657         RuleCreateRequest rcr;\r
 658         rcr = new RuleCreateRequest();\r
 659         rcr.setRuleName(ruleName);\r
 660         rcr.setDescription(description);\r
 661         rcr.setContent(content);\r
 662         rcr.setEnabled(enabled);\r
 663         return rcr;\r
 664     }\r
 665 \r
 666     private RuleUpdateRequest createRuleUpdateRequest(String ruleId, String description, String content, int enabled) {\r
 667         RuleUpdateRequest ruleUpdateRequest = new RuleUpdateRequest();\r
 668         ruleUpdateRequest.setRuleId(ruleId);\r
 669         ruleUpdateRequest.setDescription(description);\r
 670         ruleUpdateRequest.setContent(content);\r
 671         ruleUpdateRequest.setEnabled(enabled);\r
 672         return ruleUpdateRequest;\r
 673     }\r
 674 \r
 675     private RuleDeleteRequest createRuleDeleteRequest(String ruleId) {\r
 676         RuleDeleteRequest ruleDeleteRequest = new RuleDeleteRequest();\r
 677         ruleDeleteRequest.setRuleId(ruleId);\r
 678         return ruleDeleteRequest;\r
 679     }\r
 680 \r
 681     private CorrelationRule convertCreateRequest2CorrelationRule(RuleCreateRequest ruleCreateRequest) {\r
 682         CorrelationRule correlationRule = new CorrelationRule();\r
 683         correlationRule.setContent(ruleCreateRequest.getContent());\r
 684         correlationRule.setDescription(ruleCreateRequest.getDescription());\r
 685         correlationRule.setName(ruleCreateRequest.getRuleName());\r
 686         correlationRule.setCreator(USER_NAME);\r
 687         correlationRule.setModifier(USER_NAME);\r
 688         correlationRule.setEnabled(ruleCreateRequest.getEnabled());\r
 689         return correlationRule;\r
 690     }\r
 691 \r
 692     private CorrelationRule convertUpdateRequest2CorrelationRule(RuleUpdateRequest ruleUpdateRequest) {\r
 693         CorrelationRule correlationRule = new CorrelationRule();\r
 694         correlationRule.setRid(ruleUpdateRequest.getRuleId());\r
 695         correlationRule.setContent(ruleUpdateRequest.getContent());\r
 696         correlationRule.setDescription(ruleUpdateRequest.getDescription());\r
 697         correlationRule.setEnabled(ruleUpdateRequest.getEnabled());\r
 698         correlationRule.setUpdateTime(new Date());\r
 699         correlationRule.setModifier(USER_NAME);\r
 700         return correlationRule;\r
 701     }\r
 702 }