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