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