Change rule check endpoints (#388)

- Change rule check endpoints to a new structure according to #344. One change from the specification in that issue is that we changed /rule-test/enabled to /rule-test to be like /auth endpoint. Endpoints will now be: "/rule-test/run-single-rule", "/rule-test/run-full-aggregation" and "/rule-test".

Author: erik-edling

src/functionaltests/java/com/ericsson/ei/rules/RuleCheckTestRunner.java renamed to src/functionaltests/java/com/ericsson/ei/rules/RuleTestRunner.java

@@ -1,12 +1,13 @@
 package com.ericsson.ei.rules;
 
+import org.junit.runner.RunWith;
+
 import cucumber.api.CucumberOptions;
 import cucumber.api.junit.Cucumber;
-import org.junit.runner.RunWith;
 
 @RunWith(Cucumber.class)
-@CucumberOptions(features = "src/functionaltests/resources/features/ruleCheck.feature", glue = {
-        "com.ericsson.ei.rules" }, plugin = { "pretty", "html:target/cucumber-reports/TestRuleCheckRunner" })
-public class RuleCheckTestRunner {
+@CucumberOptions(features = "src/functionaltests/resources/features/ruleTest.feature", glue = {
+        "com.ericsson.ei.rules" }, plugin = { "pretty", "html:target/cucumber-reports/RuleTestRunner" })
+public class RuleTestRunner {
 
 }

src/functionaltests/java/com/ericsson/ei/rules/RuleCheckSteps.java renamed to src/functionaltests/java/com/ericsson/ei/rules/RuleTestSteps.java

@@ -16,7 +16,7 @@
 import org.springframework.test.context.TestPropertySource;
 import org.springframework.test.util.ReflectionTestUtils;
 
-import com.ericsson.ei.controller.RuleController;
+import com.ericsson.ei.controller.RuleTestController;
 import com.ericsson.ei.utils.FunctionalTestBase;
 import com.ericsson.ei.utils.HttpRequest;
 import com.ericsson.ei.utils.HttpRequest.HttpMethod;
@@ -27,16 +27,16 @@
 
 @Ignore
 @TestPropertySource(properties = {
-        "spring.data.mongodb.database: RuleCheckSteps",
-        "failed.notification.database-name: RuleCheckSteps-failedNotifications",
-        "rabbitmq.exchange.name: RuleCheckSteps-exchange",
-        "rabbitmq.consumerName: RuleCheckStepsConsumer" })
-public class RuleCheckSteps extends FunctionalTestBase {
+        "spring.data.mongodb.database: RuleTestSteps",
+        "failed.notification.database-name: RuleTestSteps-failedNotifications",
+        "rabbitmq.exchange.name: RuleTestSteps-exchange",
+        "rabbitmq.consumerName: RuleTestStepsConsumer" })
+public class RuleTestSteps extends FunctionalTestBase {
 
     private static final String TEST_RESOURCES_PATH = "src/test/resources";
 
     @Autowired
-    private RuleController ruleController;
+    private RuleTestController ruleTestController;
 
     private String rules;
     private String events;
@@ -48,12 +48,12 @@ public class RuleCheckSteps extends FunctionalTestBase {
 
     @Given("^rules checking is enabled$")
     public void rules_checking_is_enabled() throws Throwable {
-        ReflectionTestUtils.setField(ruleController, "testEnabled", true);
+        ReflectionTestUtils.setField(ruleTestController, "testEnabled", true);
     }
 
     @Given("^rules checking is not enabled$")
     public void rules_checking_is_not_enabled() throws Throwable {
-        ReflectionTestUtils.setField(ruleController, "testEnabled", false);
+        ReflectionTestUtils.setField(ruleTestController, "testEnabled", false);
     }
 
     @Given("^file with JMESPath rules \"([^\"]*)\" and file with events \"([^\"]*)\"$")

src/functionaltests/resources/features/restEndpoints.feature

@@ -2,7 +2,7 @@
 Feature: Test Rest Endpoints
 
 # Note: /query is not tested since it has its own test.
-# /rules/rule-check/aggregation is not tested since it performs an aggregation.
+# /rule-test/run-full-aggregation is not tested since it performs an aggregation.
 
   Scenario Outline: Perform GET request on <endpoint> and expect response code <responsecode>
     Given A GET request is prepared
@@ -24,7 +24,7 @@ Feature: Test Rest Endpoints
     | 404          | /queryMissedNotifications/subs_name    |
     | 404          | /queryAggregatedObject/id              |
     | 200          | /rules                                 |
-    | 200          | /rules/rule-check/testRulePageEnabled  |
+    | 200          | /rule-test  |
 
   @Test_Post_Put_Get_Delete_and_Get_(not_found)_subscription
   Scenario Outline: Perform <type> request on <endpoint> and expect response code <responsecode>
@@ -41,8 +41,8 @@ Feature: Test Rest Endpoints
     | 200          | DELETE | do not  | /subscriptions/test_subscription |
     | 404          | GET    | do not  | /subscriptions/test_subscription |
 
-  Scenario: Test POST on /rules/rule-check endpoint
+  Scenario: Test POST on /rule-test/run-single-rule endpoint
     Given A POST request is prepared
     And Event rule json data is added as body
-    When Perform request on endpoint "/rules/rule-check"
+    When Perform request on endpoint "/rule-test/run-single-rule"
     Then Request should get response code 200

src/functionaltests/resources/features/ruleCheck.feature renamed to src/functionaltests/resources/features/ruleTest.feature

@@ -1,40 +1,40 @@
 #Author: valentin.tyhonov@ericsson.com
 
 @RuleCheck
-Feature: Test Rules Checker
+Feature: Test rule test feature
 
   @ExecuteRuleSingle
   Scenario: Execute JMESPath rule on JSON object
     Given file with JMESPath rules "/ExtractionRule.txt" and file with events "/EiffelArtifactCreatedEvent.json"
-    When make a POST request to the REST API "/rules/rule-check" with a single rule
+    When make a POST request to the REST API "/rule-test/run-single-rule" with a single rule
     Then get response code of 200
     And get content "/ExtractedContent.json"
 
   @ExecuteRuleMultiple
   Scenario: Execute list of JMESPath rules on list of JSON objects
     Given rules checking is enabled
     And file with JMESPath rules "/AggregateListRules.json" and file with events "/AggregateListEvents.json"
-    When make a POST request to the REST API "/rules/rule-check/aggregation"
+    When make a POST request to the REST API "/rule-test/run-full-aggregation"
     Then get response code of 200
     And get content "/AggregateResultObject.json"
 
   @ExecuteIncorrectRule
   Scenario: Execute incorrect list of JMESPath rules on list of JSON objects
     Given rules checking is enabled
     And file with JMESPath rules "/AggregateListRules.json" and file with events "/subscription_single.json"
-    When make a POST request to the REST API "/rules/rule-check/aggregation"
+    When make a POST request to the REST API "/rule-test/run-full-aggregation"
     Then get response code of 400
 
   @ExecuteRuleDisabled
   Scenario: Execute list of JMESPath rules on list of JSON objects, when rules checking is not enabled
     Given rules checking is not enabled
     And file with JMESPath rules "/AggregateListRules.json" and file with events "/AggregateListEvents.json"
-    When make a POST request to the REST API "/rules/rule-check/aggregation"
+    When make a POST request to the REST API "/rule-test/run-full-aggregation"
     Then get response code of 503
 
-  @RuleCheckStatus
+  @RuleTestStatus
   Scenario: Check status of test rule page using REST API
     When rules checking is enabled
-    Then get request from REST API "/rules/rule-check/testRulePageEnabled" return response code of 200 and status as "true"
+    Then get request from REST API "/rule-test" return response code of 200 and status as "true"
     When rules checking is not enabled
-    Then get request from REST API "/rules/rule-check/testRulePageEnabled" return response code of 200 and status as "false"
+    Then get request from REST API "/rule-test" return response code of 200 and status as "false"

src/main/java/com/ericsson/ei/controller/RuleController.java

@@ -2,8 +2,6 @@
 package com.ericsson.ei.controller;
 
 import javax.servlet.http.HttpServletRequest;
-import com.ericsson.ei.controller.model.RuleCheckBody;
-import com.ericsson.ei.controller.model.RulesCheckBody;
 import org.springframework.http.ResponseEntity;
 import org.springframework.validation.annotation.Validated;
 import org.springframework.web.bind.annotation.RequestMapping;
@@ -12,7 +10,7 @@
 
 
 /**
- * This class is used for anything rules related. It's currently used to test rules on Eiffel events and to fetch the active rules file content. Test rules must be enabled in Eiffel Intelligence for the /rule-check endpoints to work.
+ * No description
  * (Generated with springmvc-raml-parser v.2.0.5)
  * 
  */
@@ -29,31 +27,4 @@ public interface RuleController {
     @RequestMapping(value = "", method = RequestMethod.GET)
     public ResponseEntity<?> getRules(HttpServletRequest httpRequest);
 
-    /**
-     * This method extracts data from a single Eiffel event based on the given JMESPath expression.
-     * 
-     */
-    @RequestMapping(value = "/rule-check", method = RequestMethod.POST)
-    public ResponseEntity<?> createRulesRuleCheck(
-        @javax.validation.Valid
-        @org.springframework.web.bind.annotation.RequestBody
-        RuleCheckBody ruleCheckBody, HttpServletRequest httpRequest);
-
-    /**
-     * This method extracts data from the given list of Eiffel events, based on a set of rules and returns an aggregated object.
-     * 
-     */
-    @RequestMapping(value = "/rule-check/aggregation", method = RequestMethod.POST)
-    public ResponseEntity<?> createRuleCheckAggregation(
-        @javax.validation.Valid
-        @org.springframework.web.bind.annotation.RequestBody
-        RulesCheckBody rulesCheckBody, HttpServletRequest httpRequest);
-
-    /**
-     * This method checks if the possibility to test rules has been enabled in Eiffel Intelligence.
-     * 
-     */
-    @RequestMapping(value = "/rule-check/testRulePageEnabled", method = RequestMethod.GET)
-    public ResponseEntity<?> getRuleCheckTestRulePageEnabled(HttpServletRequest httpRequest);
-
 }

src/main/java/com/ericsson/ei/controller/RuleControllerImpl.java

@@ -16,12 +16,8 @@
 */
 package com.ericsson.ei.controller;
 
-import java.io.IOException;
-
 import javax.servlet.http.HttpServletRequest;
 
-import org.json.JSONArray;
-import org.json.JSONException;
 import org.json.JSONObject;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -31,22 +27,15 @@
 import org.springframework.http.ResponseEntity;
 import org.springframework.stereotype.Component;
 import org.springframework.web.bind.annotation.CrossOrigin;
-import org.springframework.web.bind.annotation.RequestBody;
 
-import com.ericsson.ei.controller.model.RuleCheckBody;
-import com.ericsson.ei.controller.model.RulesCheckBody;
-import com.ericsson.ei.jmespath.JmesPathInterface;
 import com.ericsson.ei.rules.RulesHandler;
-import com.ericsson.ei.services.IRuleCheckService;
 import com.ericsson.ei.utils.ResponseMessage;
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
 
 import io.swagger.annotations.Api;
 import io.swagger.annotations.ApiOperation;
-import io.swagger.annotations.ApiParam;
-import lombok.Setter;
 
 @Component
 @CrossOrigin
@@ -55,19 +44,9 @@ public class RuleControllerImpl implements RuleController{
 
     private static final Logger LOGGER = LoggerFactory.getLogger(RuleControllerImpl.class);
 
-    @Autowired
-    private JmesPathInterface jmesPathInterface;
-
-    @Autowired
-    private IRuleCheckService ruleCheckService;
-
     @Autowired
     private RulesHandler rulesHandler;
 
-    @Setter
-    @Value("${testaggregated.enabled:false}")
-    private Boolean testEnabled;
-
     @Value("${rules.path}")
     private String rulesPath;
 
@@ -91,85 +70,4 @@ public ResponseEntity<?> getRules(final HttpServletRequest httpRequest) {
             return new ResponseEntity<>(errorJsonAsString, HttpStatus.INTERNAL_SERVER_ERROR);
         }
     }
-
-    /**
-     * This method interacts with JmesPathInterface class method runRuleOnEvent to
-     * evaluate a rule on JSON object.
-     *
-     * @param rule-
-     *            takes a String as a rule that need to be evaluated on JSON content
-     * @param jsonContent-
-     *            takes JSON object as a String
-     * @return a String object
-     *
-     */
-    @Override
-    @CrossOrigin
-    @ApiOperation(value = "To execute rule on one Eiffel event", response = String.class)
-    public ResponseEntity<?> createRulesRuleCheck(
-            @ApiParam(value = "JSON object", required = true) @RequestBody RuleCheckBody body, final HttpServletRequest httpRequest) {
-        JSONObject rule = new JSONObject(body.getRule().getAdditionalProperties());
-        JSONObject event = new JSONObject(body.getEvent().getAdditionalProperties());
-
-        String ruleString = rule.toString().replaceAll("\"", "");
-        try {
-            String res = jmesPathInterface.runRuleOnEvent(ruleString, event.toString()).toString();
-            LOGGER.debug("Query: {} executed successfully", body.getRule());
-            return new ResponseEntity<>(res, HttpStatus.OK);
-        } catch (Exception e) {
-            String errorMessage = "Failed to run rule on event. Error message:\n" + e.getMessage();
-            LOGGER.error(errorMessage, e);
-            String errorJsonAsString = ResponseMessage.createJsonMessage(errorMessage);
-            return new ResponseEntity<>(errorJsonAsString, HttpStatus.BAD_REQUEST);
-        }
-    }
-
-    @Override
-    @CrossOrigin
-    @ApiOperation(value = "To execute the list of rules on list of Eiffel events. Returns the aggregated object(s)", response = String.class)
-    public ResponseEntity<?> createRuleCheckAggregation(
-            @ApiParam(value = "Object that include list of rules and list of Eiffel events", required = true) @RequestBody RulesCheckBody body,
-            final HttpServletRequest httpRequest) {
-        if (testEnabled) {
-            try {
-                String aggregatedObject = ruleCheckService.prepareAggregatedObject(
-                        new JSONArray(body.getListRulesJson()), new JSONArray(body.getListEventsJson()));
-                if (aggregatedObject != null && !aggregatedObject.equals("[]")) {
-                    return new ResponseEntity<>(aggregatedObject, HttpStatus.OK);
-                } else {
-                    String errorMessage = "Failed to generate aggregated object. List of rules or list of events are not correct";
-                    LOGGER.error(errorMessage);
-                    String errorJsonAsString = ResponseMessage.createJsonMessage(errorMessage);
-                    return new ResponseEntity<>(errorJsonAsString, HttpStatus.BAD_REQUEST);
-                }
-            } catch (JSONException | IOException e) {
-                String errorMessage = "Internal Server Error: Failed to generate aggregated object.";
-                LOGGER.error(errorMessage, e);
-                String errorJsonAsString = ResponseMessage.createJsonMessage(errorMessage);
-                return new ResponseEntity<>(errorJsonAsString, HttpStatus.INTERNAL_SERVER_ERROR);
-            }
-        } else {
-            String errorMessage = "Test rules functionality is disabled in backend server. "
-                    + "Configure \"testaggregated.enabled\" setting in backend servers properties "
-                    + "to enable this functionality. This should normally only be enabled in backend test servers.";
-            LOGGER.error(errorMessage);
-            String errorJsonAsString = ResponseMessage.createJsonMessage(errorMessage);
-            return new ResponseEntity<>(errorJsonAsString, HttpStatus.SERVICE_UNAVAILABLE);
-        }
-    }
-
-    @Override
-    @CrossOrigin
-    @ApiOperation(value = "Check if rules check service is enabled", response = String.class)
-    public ResponseEntity<?> getRuleCheckTestRulePageEnabled(final HttpServletRequest httpRequest) {
-        LOGGER.debug("Getting Enabling Status of Rules Check Service");
-        try {
-            return new ResponseEntity<>(new JSONObject().put("status", testEnabled).toString(), HttpStatus.OK);
-        } catch (Exception e) {
-            String errorMessage = "Internal Server Error: Failed to get status.";
-            LOGGER.error(errorMessage, e);
-            String errorJsonAsString = ResponseMessage.createJsonMessage(errorMessage);
-            return new ResponseEntity<>(errorJsonAsString, HttpStatus.INTERNAL_SERVER_ERROR);
-        }
-    }
 }

src/main/java/com/ericsson/ei/controller/RuleTestController.java

@@ -0,0 +1,52 @@
+
+package com.ericsson.ei.controller;
+
+import javax.servlet.http.HttpServletRequest;
+import com.ericsson.ei.controller.model.RuleCheckBody;
+import com.ericsson.ei.controller.model.RulesCheckBody;
+import org.springframework.http.ResponseEntity;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.RestController;
+
+
+/**
+ * This class is used for anything rule test related. It's currently used to test rules on Eiffel events. Test rules must be enabled in Eiffel Intelligence for the /rule-test endpoints to work.
+ * (Generated with springmvc-raml-parser v.2.0.5)
+ * 
+ */
+@RestController
+@Validated
+@RequestMapping(value = "/rule-test", produces = "application/json")
+public interface RuleTestController {
+
+
+    /**
+     * This method checks if the possibility to test rules has been enabled in Eiffel Intelligence.
+     * 
+     */
+    @RequestMapping(value = "", method = RequestMethod.GET)
+    public ResponseEntity<?> getRuleTest(HttpServletRequest httpRequest);
+
+    /**
+     * This method extracts data from a single Eiffel event based on the given JMESPath expression.
+     * 
+     */
+    @RequestMapping(value = "/run-single-rule", method = RequestMethod.POST)
+    public ResponseEntity<?> createRuleTestRunSingleRule(
+        @javax.validation.Valid
+        @org.springframework.web.bind.annotation.RequestBody
+        RuleCheckBody ruleCheckBody, HttpServletRequest httpRequest);
+
+    /**
+     * This method extracts data from the given list of Eiffel events, based on a set of rules and returns an aggregated object.
+     * 
+     */
+    @RequestMapping(value = "/run-full-aggregation", method = RequestMethod.POST)
+    public ResponseEntity<?> createRuleTestRunFullAggregation(
+        @javax.validation.Valid
+        @org.springframework.web.bind.annotation.RequestBody
+        RulesCheckBody rulesCheckBody, HttpServletRequest httpRequest);
+
+}