Merge pull request #11 from codiga/chore/update-ruleset-queries

chore: update get rulesets query

Author: juli1

codiga/git_hook.py

@@ -33,7 +33,7 @@
 import docopt
 
 from .constants import BLANK_SHA, API_TOKEN_ENVIRONMENT_VARIABLE
-from .graphql.rosie import get_rulesets
+from .graphql.rosie import graphql_get_rulesets
 from .model.rosie_rule import RosieRule, convert_rules_to_rosie_rules
 from .model.violation import Violation
 from .rosie.api import analyze_rosie
@@ -111,6 +111,7 @@ def analyze_files(files_with_language: Dict[str, str],
 
     return result
 
+
 def print_violations(files_with_violations: Dict[str, List[Violation]]):
     """
     Print all the violations from all the files.
@@ -166,7 +167,7 @@ def check_push(local_sha: str, remote_sha: str, max_timeout_secs: int):
 
     log.info("using the following rulesets %s", rulesets)
 
-    rules = get_rulesets(api_token, rulesets)
+    rules = graphql_get_rulesets(api_token, rulesets)
     rosie_rules: typing.List[RosieRule] = convert_rules_to_rosie_rules(rules)
 
     log.info("found %s rules", len(rosie_rules))
@@ -226,7 +227,6 @@ def main(argv=None):
         log.error('%s environment variable not defined!', API_TOKEN_ENVIRONMENT_VARIABLE)
         sys.exit(1)
 
-
     if not remote_sha:
         log.error('remote_sha not defined')
         sys.exit(1)

codiga/graphql/rosie.py

@@ -1,27 +1,35 @@
 import typing
+
 """
 All the GraphQL queries for Rosie
 """
 
 from codiga.graphql.common import do_graphql_query
 
 
-def get_rulesets(api_token: str, ruleset_names: typing.List[str]):
-    return list(map(lambda x: get_ruleset(api_token, x), ruleset_names))
+def get_rulesets_name_string(ruleset_names: typing.List[str]):
+    """
+    Converts a List[str] into a string for graphql requests
+    :param ruleset_names: List[str]
+    :return: str
+    """
+    return "[\"" + ("\", \"".join(ruleset_names)) + "\"]"
 
 
-def get_ruleset(api_token: str, ruleset_name: str):
+def graphql_get_rulesets(api_token: str, ruleset_names: typing.List[str]):
     """
-    Get a ruleset by its name
+    Get rulesets by their names
 
     :param api_token: the API token to access the GraphQL API
-    :param ruleset_name: the name of all ruleset to fetch
+    :param ruleset_names: the names of all rulesets to fetch
     """
-    if not ruleset_name or not api_token:
+    if not ruleset_names or not api_token:
         raise ValueError
+
+    ruleset_names_string = get_rulesets_name_string(ruleset_names)
     query = """
         {
-            ruleSet(name: \""""+ruleset_name+"""\"){
+            ruleSetsForClient(names: """ + ruleset_names_string + """){
             id
             name
             rules(howmany: 10000, skip: 0){
@@ -35,11 +43,10 @@ def get_ruleset(api_token: str, ruleset_name: str):
               elementChecked
             }
           }
-        }
-    """
+        }"""
     data = do_graphql_query(api_token, {"query": query})
-    if 'ruleSet' in data:
-        return data['ruleSet']
+    if 'ruleSetsForClient' in data:
+        return data['ruleSetsForClient']
     return None
 
 

tests/graphql/test_rosie.py

@@ -0,0 +1,137 @@
+"""
+Test for methods in graphql/rosie.py
+"""
+
+import unittest
+from unittest.mock import patch
+
+from codiga.graphql.rosie import graphql_get_rulesets, get_rulesets_name_string
+
+
+class TestRosie(unittest.TestCase):
+    """
+    Tests for graphql/rosie.py
+    """
+
+    def setUp(self):
+        pass
+
+    def tearDown(self):
+        pass
+
+    def test_graphql_get_rulesets_invalid_argument(self):
+        """
+        Check that invalid arguments raise an exception
+        :return:
+        """
+        with self.assertRaises(ValueError):
+            graphql_get_rulesets(None, ["daniel-ruleset", "real-ruleset"])
+        with self.assertRaises(ValueError):
+            graphql_get_rulesets("blo", [])
+
+    @patch('codiga.graphql.rosie.do_graphql_query')
+    def test_graphql_get_rulesets_valid_argument(self, do_graphql_query_mock):
+        """
+        Check the value returned when called with valid arguments
+        :return:
+        """
+        fake_data = [
+            {
+                "id": 1,
+                "name": "daniel-ruleset",
+                "rules": [
+                    {
+                        "id": 1,
+                        "name": "rule-1",
+                        "content": "cHJpbnQoIkhlbGxvIFdvcmxkISIp",
+                        "language": "Python",
+                        "ruleType": "Ast",
+                        "pattern": None,
+                        "patternMultiline": None,
+                        "elementChecked": "FunctionCall"
+                    }
+                ]
+            },
+            {
+                "id": 2,
+                "name": "real-ruleset",
+                "rules": [
+                    {
+                        "id": 3,
+                        "name": "rule-3",
+                        "content": "cHJpbnQoIkhlbGxvIFdvcmxkISIp",
+                        "language": "Python",
+                        "ruleType": "Ast",
+                        "pattern": None,
+                        "patternMultiline": None,
+                        "elementChecked": "FunctionCall"
+                    }
+                ]
+            }
+        ]
+        do_graphql_query_mock.return_value = {"ruleSetsForClient": fake_data}
+        data = graphql_get_rulesets("api_token", ["daniel-ruleset", "real-ruleset"])
+        do_graphql_query_mock.assert_called_with("api_token", {"query": """
+        {
+            ruleSetsForClient(names: """ + get_rulesets_name_string(["daniel-ruleset", "real-ruleset"]) + """){
+            id
+            name
+            rules(howmany: 10000, skip: 0){
+              id
+              name
+              content
+              language
+              ruleType
+              pattern
+              patternMultiline
+              elementChecked
+            }
+          }
+        }"""})
+        self.assertEqual(fake_data, data)
+
+    @patch('codiga.graphql.rosie.do_graphql_query')
+    def test_graphql_get_rulesets_call(self, do_graphql_query_mock):
+        """
+        Check that we call the right method when arguments are valid
+        :return:
+        """
+        graphql_get_rulesets("api_token", ["daniel-ruleset", "real-ruleset"])
+        query1 = """
+        {
+            ruleSetsForClient(names: """ + get_rulesets_name_string(["daniel-ruleset", "real-ruleset"]) + """){
+            id
+            name
+            rules(howmany: 10000, skip: 0){
+              id
+              name
+              content
+              language
+              ruleType
+              pattern
+              patternMultiline
+              elementChecked
+            }
+          }
+        }"""
+        do_graphql_query_mock.assert_called_with("api_token", {"query": query1})
+
+        graphql_get_rulesets("api_token", ["real-ruleset"])
+        query2 = """
+        {
+            ruleSetsForClient(names: """ + get_rulesets_name_string(["real-ruleset"]) + """){
+            id
+            name
+            rules(howmany: 10000, skip: 0){
+              id
+              name
+              content
+              language
+              ruleType
+              pattern
+              patternMultiline
+              elementChecked
+            }
+          }
+        }"""
+        do_graphql_query_mock.assert_called_with("api_token", {"query": query2})