Query params per file

language/cypher/src/main/java/com/neueda/jetbrains/plugin/graphdb/language/cypher/file/CypherFileTypeFactory.java

@@ -2,6 +2,7 @@
 
 import com.intellij.openapi.fileTypes.FileTypeConsumer;
 import com.intellij.openapi.fileTypes.FileTypeFactory;
+import com.neueda.jetbrains.plugin.graphdb.language.cypher.util.FileTypeExtensionUtil;
 import org.jetbrains.annotations.NotNull;
 
 /**
@@ -13,6 +14,6 @@ public class CypherFileTypeFactory extends FileTypeFactory {
 
     @Override
     public void createFileTypes(@NotNull FileTypeConsumer fileTypeConsumer) {
-        fileTypeConsumer.consume(CypherFileType.INSTANCE, "cyp;cypher;cql");
+        fileTypeConsumer.consume(CypherFileType.INSTANCE, String.join(";", FileTypeExtensionUtil.EXTENSIONS));
     }
 }

language/cypher/src/main/java/com/neueda/jetbrains/plugin/graphdb/language/cypher/util/FileTypeExtensionUtil.java

@@ -0,0 +1,14 @@
+package com.neueda.jetbrains.plugin.graphdb.language.cypher.util;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class FileTypeExtensionUtil {
+
+    public static final List<String> EXTENSIONS = Arrays.asList("cyp", "cql", "cypher");
+
+    public static boolean isCypherFileTypeExtension(String extension) {
+        return extension != null && EXTENSIONS.contains(extension);
+    }
+
+}

testing/integration-neo4j/src/test/java/com/neueda/jetbrains/plugin/graphdb/test/integration/neo4j/tests/cypher/parameters/CypherParametersProviderTest.java

@@ -8,21 +8,31 @@
 
 import java.util.Map;
 
-import static org.assertj.core.api.Assertions.*;
+import static org.assertj.core.api.Assertions.assertThat;
 
 public class CypherParametersProviderTest extends BaseIntegrationTest {
 
     private class TestParametersProvider implements ParametersProvider {
 
-        private String parametersJson;
+        private String globalParametersJson;
+        private String fileSpecificParametersJson;
 
         @Override
-        public String getParametersJson() {
-            return parametersJson;
+        public String getGlobalParametersJson() {
+            return globalParametersJson;
         }
 
-        public void setParametersJson(String parametersJson) {
-            this.parametersJson = parametersJson;
+        @Override
+        public String getFileSpecificParametersJson() {
+            return fileSpecificParametersJson;
+        }
+
+        public void setGlobalParametersJson(String parametersJson) {
+            this.globalParametersJson = parametersJson;
+        }
+
+        public void setFileSpecificParametersJson(String fileSpecificParametersJson) {
+            this.fileSpecificParametersJson = fileSpecificParametersJson;
         }
     }
 
@@ -38,44 +48,74 @@ public void setUp() throws Exception {
     }
 
     public void testParsingEmptyJsonObject() throws Exception {
-        parametersProvider.setParametersJson("{}");
+        parametersProvider.setGlobalParametersJson("{}");
+        parametersProvider.setFileSpecificParametersJson("{}");
         Map<String, Object> parameters = parametersService.getParameters(getPsiFile("RETURN $param"));
         assertThat(parameters).isEmpty();
     }
 
     public void testParsingEmptyParameters() throws Exception {
-        parametersProvider.setParametersJson("");
+        parametersProvider.setGlobalParametersJson("");
+        parametersProvider.setFileSpecificParametersJson("");
         Map<String, Object> result = parametersService.getParameters(getPsiFile("RETURN $param"));
-
         assertThat(result).isEmpty();
     }
 
+    public void testParsingEmptyGlobalParameters() throws Exception {
+        parametersProvider.setGlobalParametersJson("");
+        parametersProvider.setFileSpecificParametersJson("{\"param\": \"non-empty\"}");
+        Map<String, Object> result = parametersService.getParameters(getPsiFile("RETURN $param"));
+        assertThat(result).containsEntry("param", "non-empty");
+    }
+
+    public void testParsingEmptyFileSpecificParameters() throws Exception {
+        parametersProvider.setGlobalParametersJson("{\"param\": \"non-empty\"}");
+        parametersProvider.setFileSpecificParametersJson("");
+        Map<String, Object> result = parametersService.getParameters(getPsiFile("RETURN $param"));
+        assertThat(result).containsEntry("param", "non-empty");
+    }
+
+
+    public void testParsingEmptyJsonInGlobalParameters() throws Exception {
+        parametersProvider.setGlobalParametersJson("{}");
+        parametersProvider.setFileSpecificParametersJson("{\"param\": \"non-empty\"}");
+        Map<String, Object> result = parametersService.getParameters(getPsiFile("RETURN $param"));
+        assertThat(result).containsEntry("param", "non-empty");
+    }
+
+    public void testParsingEmptyJsonInFileSpecificParameters() throws Exception {
+        parametersProvider.setGlobalParametersJson("{\"param\": \"non-empty\"}");
+        parametersProvider.setFileSpecificParametersJson("{}");
+        Map<String, Object> result = parametersService.getParameters(getPsiFile("RETURN $param"));
+        assertThat(result).containsEntry("param", "non-empty");
+    }
+
     public void testParsingStringParameter() throws Exception {
-        parametersProvider.setParametersJson("{\"name\": \"Anna\"}");
+        parametersProvider.setGlobalParametersJson("{\"name\": \"Anna\"}");
         Map<String, Object> result = parametersService
                 .getParameters(getPsiFile("match (p:Person) where p.name = $name return *"));
 
         assertThat(result).containsEntry("name", "Anna");
     }
 
     public void testParsingIntegerParameter() throws Exception {
-        parametersProvider.setParametersJson("{\"p1\": 17}");
+        parametersProvider.setGlobalParametersJson("{\"p1\": 17}");
         Map<String, Object> result = parametersService
                 .getParameters(getPsiFile("match (p:Person) where p.age = $p1 return *"));
 
         assertThat(result).containsEntry("p1", 17);
     }
 
     public void testParsingBooleanParameter() throws Exception {
-        parametersProvider.setParametersJson("{\"p2\": false}");
+        parametersProvider.setGlobalParametersJson("{\"p2\": false}");
         Map<String, Object> result = parametersService.
                 getParameters(getPsiFile("match (p:Person) where p.is_citizen = $p2 return *"));
 
         assertThat(result).containsEntry("p2", false);
     }
 
     public void testParsingJsonObjectParameter() throws Exception {
-        parametersProvider.setParametersJson("{\"p3\": {\"name\":\"Alex\"}}");
+        parametersProvider.setGlobalParametersJson("{\"p3\": {\"name\":\"Alex\"}}");
         Map<String, Object> result = parametersService.
                 getParameters(getPsiFile("match (p:Person) where p.father = $p3 return *"));
 
@@ -84,55 +124,64 @@ public void testParsingJsonObjectParameter() throws Exception {
     }
 
     public void testParsingMultipleParameters() throws Exception {
-        parametersProvider.setParametersJson("{\"firstName\": \"Kaleb\", \"lastName\": \"Johnson\"}");
+        parametersProvider.setGlobalParametersJson(
+                "{\"firstName\": \"Kaleb\", \'age\': 35, \"city\": \"Paris\", \"country\": \"France\"}"
+        );
+        parametersProvider.setFileSpecificParametersJson(
+                "{\"lastName\": \"Green\", \"age\": 90}"
+        );
+
         Map<String, Object> result = parametersService
                 .getParameters(getPsiFile("match (p:Person)\n" +
                         "where p.first_name = $firstName " +
-                        "   and p.last_name = $lastName return *"));
-
+                        "   and p.last_name = $lastName " +
+                        "   and p.age = $age " +
+                        "   and p.city = $city return *"));
         assertThat(result)
-                .hasSize(2)
+                .hasSize(4)
                 .containsEntry("firstName", "Kaleb")
-                .containsEntry("lastName", "Johnson");
+                .containsEntry("lastName", "Green")
+                .containsEntry("age", 90)
+                .containsEntry("city", "Paris");
     }
 
     public void testParsingCommentOnly() throws Exception {
-        parametersProvider.setParametersJson("// Provide query parameters in JSON format here:");
+        parametersProvider.setGlobalParametersJson("// Provide query parameters in JSON format here:");
         Map<String, Object> result = parametersService.getParameters(getPsiFile("RETURN $param"));
 
         assertThat(result).isEmpty();
     }
 
     public void testParsingCommentWithParameter() throws Exception {
-        parametersProvider.setParametersJson("// Provide query parameters in JSON format here:\n{\"name\": \"Eva\"}");
+        parametersProvider.setGlobalParametersJson("// Provide query parameters in JSON format here:\n{\"name\": \"Eva\"}");
         Map<String, Object> result = parametersService.getParameters(getPsiFile("RETURN $name"));
 
         assertThat(result).hasSize(1);
     }
 
     public void testParsingNumericParameter() throws Exception {
-        parametersProvider.setParametersJson("{\"0\": \"Tom\"}");
+        parametersProvider.setGlobalParametersJson("{\"0\": \"Tom\"}");
         Map<String, Object> result = parametersService.getParameters(getPsiFile("RETURN $0"));
 
         assertThat(result).containsEntry("0", "Tom");
     }
 
     public void testParsingOldStyleStringParameter() throws Exception {
-        parametersProvider.setParametersJson("{\"name\": \"Ethan\"}");
+        parametersProvider.setGlobalParametersJson("{\"name\": \"Ethan\"}");
         Map<String, Object> result = parametersService.getParameters(getPsiFile("RETURN {name}"));
 
         assertThat(result).containsEntry("name", "Ethan");
     }
 
     public void testParsingOldStyleNumericParameter() throws Exception {
-        parametersProvider.setParametersJson("{\"0\": \"Simon\"}");
+        parametersProvider.setGlobalParametersJson("{\"0\": \"Simon\"}");
         Map<String, Object> result = parametersService.getParameters(getPsiFile("RETURN {0}"));
 
         assertThat(result).containsEntry("0", "Simon");
     }
 
     public void testFilteringUsedParameters() throws Exception {
-        parametersProvider.setParametersJson("{\"firstName\": \"Frodo\", \"lastName\": \"Baggins\"}");
+        parametersProvider.setGlobalParametersJson("{\"firstName\": \"Frodo\", \"lastName\": \"Baggins\"}");
         Map<String, Object> result = parametersService.getParameters(getPsiFile("RETURN $lastName"));
 
         assertThat(result)
@@ -142,7 +191,7 @@ public void testFilteringUsedParameters() throws Exception {
 
     public void testParsingJsonArray() throws Exception {
         try {
-            parametersProvider.setParametersJson("// Provide query parameters in JSON format here:\n[\"item1\",\"item2\"]");
+            parametersProvider.setGlobalParametersJson("// Provide query parameters in JSON format here:\n[\"item1\",\"item2\"]");
             parametersService.getParameters(getPsiFile("return 1"));
             fail("JsonMappingException expected because of array in parameters json expected");
         } catch (JsonMappingException e) {
@@ -152,7 +201,7 @@ public void testParsingJsonArray() throws Exception {
 
     public void testParsingNumber() throws Exception {
         try {
-            parametersProvider.setParametersJson("1");
+            parametersProvider.setGlobalParametersJson("1");
             parametersService.getParameters(getPsiFile("return 1"));
             fail("JsonMappingException expected because of number provided instead of parameters map");
         } catch (JsonMappingException e) {
@@ -162,7 +211,7 @@ public void testParsingNumber() throws Exception {
 
     public void testParsingString() throws Exception {
         try {
-            parametersProvider.setParametersJson("\"abc\"");
+            parametersProvider.setGlobalParametersJson("\"abc\"");
             parametersService.getParameters(getPsiFile("return 1"));
             fail("JsonMappingException expected because of string provided instead of parameters map");
         } catch (JsonMappingException e) {
@@ -172,7 +221,7 @@ public void testParsingString() throws Exception {
 
     public void testParsingUnwrappedParameter() throws Exception {
         try {
-            parametersProvider.setParametersJson("\"param1\":\"val1\"");
+            parametersProvider.setGlobalParametersJson("\"param1\":\"val1\"");
             parametersService.getParameters(getPsiFile("return 1"));
             fail("JsonMappingException expected because of parameter not wrapped in curly braces");
         } catch (JsonMappingException e) {

testing/integration-neo4j/src/test/java/com/neueda/jetbrains/plugin/graphdb/test/integration/neo4j/tests/jetbrains/StatementCollectorTest.java

@@ -4,6 +4,7 @@
 import com.intellij.util.messages.MessageBus;
 import com.neueda.jetbrains.plugin.graphdb.jetbrains.actions.execute.StatementCollector;
 import com.neueda.jetbrains.plugin.graphdb.jetbrains.ui.console.event.QueryParametersRetrievalErrorEvent;
+import com.neueda.jetbrains.plugin.graphdb.jetbrains.ui.console.params.ParametersProvider;
 import com.neueda.jetbrains.plugin.graphdb.jetbrains.ui.console.params.ParametersService;
 import com.neueda.jetbrains.plugin.graphdb.test.integration.neo4j.tests.cypher.util.BaseGenericTest;
 import org.mockito.Mockito;
@@ -14,10 +15,11 @@
 public class StatementCollectorTest extends BaseGenericTest {
 
     private static final String EMPTY_PARAMETERS = "{}";
-    private static final String PARAMETERS = "{\"name\": \"Andrew\"}";
+    private static final String VALID_PARAMETERS = "{\"name\": \"Andrew\"}";
     private static final String WRONG_PARAMETERS = "{wrong json}";
     private StatementCollector statementCollector;
     private ParametersService parametersService;
+    private ParametersProvider emptyParametersProvider, validParametersProvider, wrongParametersProvider;
     private MessageBus messageBusMock;
     private QueryParametersRetrievalErrorEvent eventMock;
 
@@ -29,11 +31,44 @@ public void setUp() throws Exception {
         when(messageBusMock.syncPublisher(any())).thenReturn(eventMock);
 
         parametersService = new ParametersService();
+        emptyParametersProvider = new ParametersProvider() {
+            @Override
+            public String getGlobalParametersJson() {
+                return EMPTY_PARAMETERS;
+            }
+
+            @Override
+            public String getFileSpecificParametersJson() {
+                return EMPTY_PARAMETERS;
+            }
+        };
+        validParametersProvider = new ParametersProvider() {
+            @Override
+            public String getGlobalParametersJson() {
+                return VALID_PARAMETERS;
+            }
+
+            @Override
+            public String getFileSpecificParametersJson() {
+                return VALID_PARAMETERS;
+            }
+        };
+        wrongParametersProvider = new ParametersProvider() {
+            @Override
+            public String getGlobalParametersJson() {
+                return WRONG_PARAMETERS;
+            }
+
+            @Override
+            public String getFileSpecificParametersJson() {
+                return WRONG_PARAMETERS;
+            }
+        };
         statementCollector = new StatementCollector(messageBusMock, parametersService);
     }
 
     public void testSingleQuery() {
-        parametersService.registerParametersProvider(() -> EMPTY_PARAMETERS);
+        parametersService.registerParametersProvider(emptyParametersProvider);
         PsiFile psiFile = myFixture.configureByText("test.cyp", "MATCH (n) RETURN n;");
         psiFile.accept(statementCollector);
 
@@ -48,7 +83,7 @@ public void testSingleQuery() {
     }
 
     public void testMultipleQueriesInOneLine() {
-        parametersService.registerParametersProvider(() -> EMPTY_PARAMETERS);
+        parametersService.registerParametersProvider(emptyParametersProvider);
         PsiFile psiFile = myFixture.configureByText("test.cyp", "MATCH (n) RETURN n;MATCH (m) RETURN m;");
         psiFile.acceptChildren(statementCollector);
 
@@ -63,7 +98,7 @@ public void testMultipleQueriesInOneLine() {
     }
 
     public void testOneQueryWithError() {
-        parametersService.registerParametersProvider(() -> EMPTY_PARAMETERS);
+        parametersService.registerParametersProvider(emptyParametersProvider);
         PsiFile psiFile = myFixture.configureByText("test.cyp", "MATCH () ETURN n;");
         psiFile.accept(statementCollector);
 
@@ -78,7 +113,7 @@ public void testOneQueryWithError() {
     }
 
     public void testMultipleQueriesInDifferentLinesWithError() {
-        parametersService.registerParametersProvider(() -> EMPTY_PARAMETERS);
+        parametersService.registerParametersProvider(emptyParametersProvider);
         PsiFile psiFile = myFixture.configureByText("test.cyp", "MATCH (n) RETURN *;\nMATCH () ETURN n;");
         psiFile.accept(statementCollector);
 
@@ -93,7 +128,7 @@ public void testMultipleQueriesInDifferentLinesWithError() {
     }
 
     public void testMultipleCorrectQueriesInDifferentLines() {
-        parametersService.registerParametersProvider(() -> EMPTY_PARAMETERS);
+        parametersService.registerParametersProvider(emptyParametersProvider);
         PsiFile psiFile = myFixture.configureByText("test.cyp", "MATCH (n) RETURN *;\nMATCH (m) RETURN m;");
         psiFile.accept(statementCollector);
 
@@ -108,7 +143,7 @@ public void testMultipleCorrectQueriesInDifferentLines() {
     }
 
     public void testMultipleCorrectQueriesInDifferentLinesWithParameters() {
-        parametersService.registerParametersProvider(() -> PARAMETERS);
+        parametersService.registerParametersProvider(validParametersProvider);
         PsiFile psiFile = myFixture.configureByText("test.cyp", "CREATE (n {name: $name});\nMATCH (m) RETURN m;");
         psiFile.accept(statementCollector);
 
@@ -123,7 +158,7 @@ public void testMultipleCorrectQueriesInDifferentLinesWithParameters() {
     }
 
     public void testParameterExtractionErrorOccurs() {
-        parametersService.registerParametersProvider(() -> WRONG_PARAMETERS);
+        parametersService.registerParametersProvider(wrongParametersProvider);
         PsiFile psiFile = myFixture.configureByText("test.cyp", "CREATE (n {name: $name});\nMATCH (m) RETURN m;");
         psiFile.accept(statementCollector);