Skip to content
This repository was archived by the owner on Jul 6, 2023. It is now read-only.

Commit 76b5c64

Browse files
praveenagpraveenag
authored
Merge pull request #117 from praveenag/lambda-returns
update params display to show new params setting
2 parents bc796f7 + eb3fec3 commit 76b5c64

File tree

6 files changed

+81
-32
lines changed

6 files changed

+81
-32
lines changed

‎cypher-shell/src/integration-test/java/org/neo4j/shell/commands/CypherShellVerboseIntegrationTest.java‎

Lines changed: 5 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -170,19 +170,22 @@ public void paramsAndListVariables() throws CommandException {
170170
assertTrue(shell.getAll().isEmpty());
171171

172172
long randomLong = System.currentTimeMillis();
173+
String stringInput = "\"randomString\"";
174+
shell.set("string", stringInput);
173175
Optional result = shell.set("bob", String.valueOf(randomLong));
174176
assertTrue(result.isPresent());
175177
assertEquals(randomLong, result.get());
176178

177-
shell.execute("RETURN { bob }");
179+
shell.execute("RETURN { bob }, $string");
178180

179181
ArgumentCaptor<String> captor = ArgumentCaptor.forClass(String.class);
180182
verify(logger).printOut(captor.capture());
181183

182184
List<String> queryResult = captor.getAllValues();
183185
assertThat(queryResult.get(0), containsString("| { bob }"));
184-
assertThat(queryResult.get(0), containsString("\n| " + randomLong+ " |\n"));
186+
assertThat(queryResult.get(0), containsString("| " + randomLong + " | " + stringInput + " |"));
185187
assertEquals(randomLong, shell.getAll().get("bob"));
188+
assertEquals("randomString", shell.getAll().get("string"));
186189
}
187190

188191
@Test

‎cypher-shell/src/main/java/org/neo4j/shell/CypherShell.java‎

Lines changed: 17 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -10,22 +10,25 @@
1010
import org.neo4j.shell.prettyprint.PrettyPrinter;
1111
import org.neo4j.shell.state.BoltResult;
1212
import org.neo4j.shell.state.BoltStateHandler;
13+
import org.neo4j.shell.state.ParamValue;
1314

1415
import javax.annotation.Nonnull;
16+
import java.util.AbstractMap;
1517
import java.util.HashMap;
1618
import java.util.List;
1719
import java.util.Map;
1820
import java.util.Optional;
1921
import java.util.regex.Matcher;
2022
import java.util.regex.Pattern;
23+
import java.util.stream.Collectors;
2124

2225
/**
2326
* A possibly interactive shell for evaluating cypher statements.
2427
*/
2528
public class CypherShell implements StatementExecuter, Connector, TransactionHandler, VariableHolder {
2629
// Final space to catch newline
2730
protected static final Pattern cmdNamePattern = Pattern.compile("^\\s*(?<name>[^\\s]+)\\b(?<args>.*)\\s*$");
28-
protected final Map<String, Object> queryParams = new HashMap<>();
31+
protected final Map<String, ParamValue> queryParams = new HashMap<>();
2932
private final Logger logger;
3033
private final BoltStateHandler boltStateHandler;
3134
private final PrettyPrinter prettyPrinter;
@@ -80,7 +83,7 @@ public void execute(@Nonnull final String cmdString) throws ExitException, Comma
8083
* @param cypher non-empty cypher text to executeLine
8184
*/
8285
protected void executeCypher(@Nonnull final String cypher) throws CommandException {
83-
final Optional<BoltResult> result = boltStateHandler.runCypher(cypher, queryParams);
86+
final Optional<BoltResult> result = boltStateHandler.runCypher(cypher, getAll());
8487
result.ifPresent(boltResult -> logger.printOut(prettyPrinter.format(boltResult)));
8588
}
8689

@@ -156,13 +159,13 @@ public Optional set(@Nonnull String name, @Nonnull String valueString) throws Co
156159
final BoltResult result = setParamsAndValidate(name, valueString);
157160
String parameterName = CypherVariablesFormatter.unescapedCypherVariable(name);
158161
final Object value = result.getRecords().get(0).get(parameterName).asObject();
159-
queryParams.put(parameterName, value);
162+
queryParams.put(parameterName, new ParamValue(valueString, value));
160163
return Optional.ofNullable(value);
161164
}
162165

163166
private BoltResult setParamsAndValidate(@Nonnull String name, @Nonnull String valueString) throws CommandException {
164167
String cypher = "RETURN " + valueString + " as " + name;
165-
final Optional<BoltResult> result = boltStateHandler.runCypher(cypher, queryParams);
168+
final Optional<BoltResult> result = boltStateHandler.runCypher(cypher, getAll());
166169
if (!result.isPresent() || result.get().getRecords().isEmpty()) {
167170
throw new CommandException("Failed to set value of parameter");
168171
}
@@ -172,6 +175,16 @@ private BoltResult setParamsAndValidate(@Nonnull String name, @Nonnull String va
172175
@Override
173176
@Nonnull
174177
public Map<String, Object> getAll() {
178+
return queryParams.entrySet()
179+
.stream()
180+
.collect(Collectors.toMap(
181+
Map.Entry::getKey,
182+
value -> value.getValue().getValue()));
183+
}
184+
185+
@Nonnull
186+
@Override
187+
public Map<String, ParamValue> getAllAsUserInput() {
175188
return queryParams;
176189
}
177190

‎cypher-shell/src/main/java/org/neo4j/shell/VariableHolder.java‎

Lines changed: 7 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,7 @@
11
package org.neo4j.shell;
22

33
import org.neo4j.shell.exception.CommandException;
4+
import org.neo4j.shell.state.ParamValue;
45

56
import javax.annotation.Nonnull;
67
import java.util.Map;
@@ -22,4 +23,10 @@ public interface VariableHolder {
2223
*/
2324
@Nonnull
2425
Map<String, Object> getAll();
26+
27+
/**
28+
* @return map of all currently set variables and their values corresponding to the user valueString
29+
*/
30+
@Nonnull
31+
Map<String, ParamValue> getAllAsUserInput();
2532
}

‎cypher-shell/src/main/java/org/neo4j/shell/commands/Params.java‎

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -78,21 +78,21 @@ public void execute(@Nonnull final String argString) throws ExitException, Comma
7878

7979
private void listParam(@Nonnull String name) throws CommandException {
8080
String parameterName = CypherVariablesFormatter.unescapedCypherVariable(name);
81-
if (!variableHolder.getAll().containsKey(parameterName)) {
81+
if (!this.variableHolder.getAllAsUserInput().containsKey(parameterName)) {
8282
throw new CommandException("Unknown parameter: " + name);
8383
}
84-
listParam(name.length(), name, variableHolder.getAll().get(parameterName));
84+
listParam(name.length(), name, this.variableHolder.getAllAsUserInput().get(parameterName).getValueAsString());
8585
}
8686

8787
private void listParam(int leftColWidth, @Nonnull String key, @Nonnull Object value) {
88-
logger.printOut(String.format("%-" + leftColWidth + "s => %s", key, value));
88+
logger.printOut(String.format(":param %-" + leftColWidth + "s => %s", key, value));
8989
}
9090

9191
private void listAllParams() {
92-
List<String> keys = variableHolder.getAll().keySet().stream().sorted().collect(Collectors.toList());
92+
List<String> keys = variableHolder.getAllAsUserInput().keySet().stream().sorted().collect(Collectors.toList());
9393

9494
int leftColWidth = keys.stream().map((s) -> escape(s).length()).reduce(0, Math::max);
9595

96-
keys.stream().forEach(k -> listParam(leftColWidth, escape(k), variableHolder.getAll().get(k)));
96+
keys.forEach(key -> listParam(leftColWidth, escape(key), variableHolder.getAllAsUserInput().get(key).getValueAsString()));
9797
}
9898
}

‎cypher-shell/src/main/java/org/neo4j/shell/state/ParamValue.java‎

Lines changed: 22 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,22 @@
1+
package org.neo4j.shell.state;
2+
3+
/**
4+
* Handles queryparams value and user inputString
5+
*/
6+
public class ParamValue {
7+
private final String valueAsString;
8+
private final Object value;
9+
10+
public ParamValue(String valueAsString, Object value) {
11+
this.valueAsString = valueAsString;
12+
this.value = value;
13+
}
14+
15+
public Object getValue() {
16+
return value;
17+
}
18+
19+
public String getValueAsString() {
20+
return valueAsString;
21+
}
22+
}

‎cypher-shell/src/test/java/org/neo4j/shell/commands/ParamsTest.java‎

Lines changed: 25 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -7,7 +7,9 @@
77
import org.neo4j.shell.VariableHolder;
88
import org.neo4j.shell.exception.CommandException;
99
import org.neo4j.shell.log.Logger;
10+
import org.neo4j.shell.state.ParamValue;
1011

12+
import java.util.AbstractMap;
1113
import java.util.HashMap;
1214

1315
import static org.hamcrest.CoreMatchers.containsString;
@@ -21,7 +23,7 @@ public class ParamsTest {
2123
@Rule
2224
public final ExpectedException thrown = ExpectedException.none();
2325

24-
private HashMap<String, Object> vars;
26+
private HashMap<String, ParamValue> vars;
2527
private Logger logger;
2628
private Params cmd;
2729

@@ -30,7 +32,7 @@ public void setup() throws CommandException {
3032
vars = new HashMap<>();
3133
logger = mock(Logger.class);
3234
VariableHolder shell = mock(VariableHolder.class);
33-
when(shell.getAll()).thenReturn(vars);
35+
when(shell.getAllAsUserInput()).thenReturn(vars);
3436
cmd = new Params(logger, shell);
3537
}
3638

@@ -52,72 +54,74 @@ public void helpNotNull() {
5254
@Test
5355
public void runCommand() throws CommandException {
5456
// given
55-
vars.put("var", 9);
57+
String var = "var";
58+
int value = 9;
59+
vars.put(var, new ParamValue(String.valueOf(value), value));
5660
// when
5761
cmd.execute("");
5862
// then
59-
verify(logger).printOut("var => 9");
63+
verify(logger).printOut(":param var => 9");
6064
verifyNoMoreInteractions(logger);
6165
}
6266

6367
@Test
6468
public void runCommandAlignment() throws CommandException {
6569
// given
66-
vars.put("var", 9);
67-
vars.put("param", 99999);
70+
vars.put("var", new ParamValue(String.valueOf(9), 9));
71+
vars.put("param", new ParamValue(String.valueOf(99999), 99999));
6872
// when
6973
cmd.execute("");
7074
// then
71-
verify(logger).printOut("param => 99999");
72-
verify(logger).printOut("var => 9");
75+
verify(logger).printOut(":param param => 99999");
76+
verify(logger).printOut(":param var => 9");
7377
verifyNoMoreInteractions(logger);
7478
}
7579

7680
@Test
7781
public void runCommandWithArg() throws CommandException {
7882
// given
79-
vars.put("var", 9);
80-
vars.put("param", 9999);
83+
vars.put("var", new ParamValue(String.valueOf(9), 9));
84+
vars.put("param", new ParamValue(String.valueOf(9999), 9999));
8185
// when
8286
cmd.execute("var");
8387
// then
84-
verify(logger).printOut("var => 9");
88+
verify(logger).printOut(":param var => 9");
8589
verifyNoMoreInteractions(logger);
8690
}
8791

8892
@Test
8993
public void runCommandWithArgWithExtraSpace() throws CommandException {
9094
// given
91-
vars.put("var", 9);
92-
vars.put("param", 9999);
95+
vars.put("var", new ParamValue(String.valueOf(9), 9));
96+
vars.put("param", new ParamValue(String.valueOf(9999), 9999));
9397
// when
9498
cmd.execute(" var");
9599
// then
96-
verify(logger).printOut("var => 9");
100+
verify(logger).printOut(":param var => 9");
97101
verifyNoMoreInteractions(logger);
98102
}
99103

100104
@Test
101105
public void runCommandWithArgWithBackticks() throws CommandException {
102106
// given
103-
vars.put("var", 9);
104-
vars.put("param", 9999);
107+
vars.put("var", new ParamValue(String.valueOf(9), 9));
108+
vars.put("param", new ParamValue(String.valueOf(9999), 9999));
105109
// when
106110
cmd.execute("`var`");
107111
// then
108-
verify(logger).printOut("`var` => 9");
112+
verify(logger).printOut(":param `var` => 9");
109113
verifyNoMoreInteractions(logger);
110114
}
111115

112116
@Test
113117
public void runCommandWithSpecialCharacters() throws CommandException {
114118
// given
115-
vars.put("var `", 9);
116-
vars.put("param", 9999);
119+
vars.put("var `", new ParamValue(String.valueOf(9), 9));
120+
vars.put("param", new ParamValue(String.valueOf(9999), 9999));
117121
// when
118122
cmd.execute("`var ```");
119123
// then
120-
verify(logger).printOut("`var ``` => 9");
124+
verify(logger).printOut(":param `var ``` => 9");
121125
verifyNoMoreInteractions(logger);
122126
}
123127

@@ -127,7 +131,7 @@ public void runCommandWithUnknownArg() throws CommandException {
127131
thrown.expect(CommandException.class);
128132
thrown.expectMessage(containsString("Unknown parameter: bob"));
129133
// given
130-
vars.put("var", 9);
134+
vars.put("var", new ParamValue(String.valueOf(9), 9));
131135
// when
132136
cmd.execute("bob");
133137
}

0 commit comments

Comments
 (0)