diff --git a/driver/src/test/java/org/neo4j/driver/v1/tck/CypherComplianceSteps.java b/driver/src/test/java/org/neo4j/driver/v1/tck/CypherComplianceSteps.java index e6b2fa3069..c5f800f923 100644 --- a/driver/src/test/java/org/neo4j/driver/v1/tck/CypherComplianceSteps.java +++ b/driver/src/test/java/org/neo4j/driver/v1/tck/CypherComplianceSteps.java @@ -28,6 +28,7 @@ import java.util.List; import java.util.Map; +import org.neo4j.driver.v1.Session; import org.neo4j.driver.v1.Record; import org.neo4j.driver.v1.StatementResult; import org.neo4j.driver.v1.Value; @@ -36,8 +37,8 @@ import org.neo4j.driver.v1.tck.tck.util.runners.StringRunner; import static org.junit.Assert.assertTrue; +import static org.neo4j.driver.v1.tck.Environment.driver; import static org.neo4j.driver.v1.Values.ofValue; -import static org.neo4j.driver.v1.tck.DriverComplianceIT.session; import static org.neo4j.driver.v1.tck.Environment.runners; import static org.neo4j.driver.v1.tck.tck.util.ResultParser.parseExpected; import static org.neo4j.driver.v1.tck.tck.util.ResultParser.parseGiven; @@ -48,7 +49,10 @@ public class CypherComplianceSteps @Given( "^init: (.*)$" ) public void init_( String statement ) throws Throwable { - session.run( statement ); + try ( Session session = driver.session()) + { + session.run( statement ); + } } @When( "^running: (.*)$" ) diff --git a/driver/src/test/java/org/neo4j/driver/v1/tck/DriverComplianceIT.java b/driver/src/test/java/org/neo4j/driver/v1/tck/DriverComplianceIT.java index 479d1dc66a..4c46078a96 100644 --- a/driver/src/test/java/org/neo4j/driver/v1/tck/DriverComplianceIT.java +++ b/driver/src/test/java/org/neo4j/driver/v1/tck/DriverComplianceIT.java @@ -22,9 +22,11 @@ import org.junit.ClassRule; import org.junit.runner.RunWith; +import java.io.File; import java.io.IOException; -import org.neo4j.driver.v1.util.TestNeo4jSession; +import org.neo4j.driver.v1.util.Neo4jSettings; +import org.neo4j.driver.v1.util.TestNeo4j; /** * The base class to run all cucumber tests @@ -34,14 +36,20 @@ public class DriverComplianceIT { @ClassRule - public static TestNeo4jSession session = new TestNeo4jSession(); + public static TestNeo4j neo4j = new TestNeo4j(); public DriverComplianceIT() throws IOException { } - public static TestNeo4jSession session() + public static void updateEncryptionKeyAndCert( File key, File cert ) throws Exception { - return session; + neo4j.restartServerOnEmptyDatabase( + Neo4jSettings.DEFAULT.usingEncryptionKeyAndCert( key, cert ) ); + } + + public static void useDefaultEncryptionKeyAndCert() throws Exception + { + neo4j.restartServerOnEmptyDatabase( Neo4jSettings.DEFAULT ); } } diff --git a/driver/src/test/java/org/neo4j/driver/v1/tck/DriverComplianceSteps.java b/driver/src/test/java/org/neo4j/driver/v1/tck/DriverComplianceSteps.java index 6fcf7adeb3..85b41574e4 100644 --- a/driver/src/test/java/org/neo4j/driver/v1/tck/DriverComplianceSteps.java +++ b/driver/src/test/java/org/neo4j/driver/v1/tck/DriverComplianceSteps.java @@ -32,19 +32,18 @@ import java.util.Random; import org.neo4j.driver.v1.Record; +import org.neo4j.driver.v1.Session; import org.neo4j.driver.v1.Statement; import org.neo4j.driver.v1.Value; import org.neo4j.driver.v1.Values; -import org.neo4j.driver.v1.tck.tck.util.Types; import org.neo4j.driver.v1.tck.tck.util.runners.CypherStatementRunner; -import org.neo4j.driver.v1.tck.tck.util.runners.MappedParametersRunner; import org.neo4j.driver.v1.tck.tck.util.runners.StatementRunner; import org.neo4j.driver.v1.tck.tck.util.runners.StringRunner; import static org.hamcrest.core.IsEqual.equalTo; import static org.junit.Assert.assertThat; +import static org.neo4j.driver.v1.tck.Environment.driver; import static org.neo4j.driver.v1.Values.parameters; -import static org.neo4j.driver.v1.tck.DriverComplianceIT.session; import static org.neo4j.driver.v1.tck.Environment.expectedBoltValue; import static org.neo4j.driver.v1.tck.Environment.expectedJavaValue; import static org.neo4j.driver.v1.tck.Environment.listOfObjects; @@ -53,12 +52,10 @@ import static org.neo4j.driver.v1.tck.Environment.runners; import static org.neo4j.driver.v1.tck.Environment.statementRunner; import static org.neo4j.driver.v1.tck.Environment.stringRunner; -import static org.neo4j.driver.v1.tck.tck.util.ResultParser.getList; -import static org.neo4j.driver.v1.tck.tck.util.ResultParser.getMapOfObjects; -import static org.neo4j.driver.v1.tck.tck.util.ResultParser.isList; -import static org.neo4j.driver.v1.tck.tck.util.ResultParser.isMap; +import static org.neo4j.driver.v1.tck.tck.util.ResultParser.getJavaValueIntAsLong; import static org.neo4j.driver.v1.tck.tck.util.Types.Type; import static org.neo4j.driver.v1.tck.tck.util.Types.getType; +import static org.neo4j.driver.v1.tck.tck.util.runners.MappedParametersRunner.createParameterRunner; public class DriverComplianceSteps @@ -73,10 +70,9 @@ public void A_running_database() throws Throwable } @Given( "^a value (.*)$" ) - public void a_value( String value ) - throws Throwable + public void a_value( String value ) throws Throwable { - expectedJavaValue = getJavaValue( value ); + expectedJavaValue = getJavaValueIntAsLong( value ); expectedBoltValue = Values.value( expectedJavaValue ); } @@ -112,7 +108,7 @@ public void the_expected_result_is_a_of( String type, String value ) throws Thro public void the_driver_asks_the_server_to_echo_this_value_back() throws Throwable { stringRunner = new StringRunner( "RETURN " + expectedBoltValue.toString() ); - mappedParametersRunner = new MappedParametersRunner( "RETURN {input}", "input", expectedBoltValue ); + mappedParametersRunner = createParameterRunner( "RETURN {input}", "input", expectedBoltValue ); statementRunner = new StatementRunner( new Statement( "RETURN {input}", parameters( "input", expectedBoltValue ) ) ); @@ -143,12 +139,12 @@ public void the_driver_asks_the_server_to_echo_this_map_back() throws Throwable } @Given( "^a list containing$" ) - public void a_list_containing( List table ) throws Throwable + public static void a_list_containing( List table ) throws Throwable { List content = table.subList( 1, table.size() - 1 ); for ( String value : content ) { - listOfObjects.add( getJavaValue( value ) ); + listOfObjects.add( getJavaValueIntAsLong( value ) ); } } @@ -159,14 +155,14 @@ public void adding_this_list_to_itself() throws Throwable } @Given( "^a map containing$" ) - public void a_map_containing( DataTable table ) throws Throwable + public static void a_map_containing( DataTable table ) throws Throwable { Map map = table.asMap( String.class, String.class ); for ( String key : map.keySet() ) { if ( !key.equals( "key" ) ) { - mapOfObjects.put( (String) Type.String.getJavaValue( key ), getJavaValue( map.get( key ) ) ); + mapOfObjects.put( (String) Type.String.getJavaValue( key ), getJavaValueIntAsLong( map.get( key ) ) ); } } } @@ -193,27 +189,6 @@ public void result_should_be_equal_to_a_single_Type_of_Input() throws Throwable } } - public Object getJavaValue( String value ) - { - if ( isList( value ) ) - { - ArrayList values = new ArrayList<>(); - for ( String val : getList( value ) ) - { - values.add( Types.asObject( val ) ); - } - return values; - } - else if ( isMap( value ) ) - { - return getMapOfObjects( value ); - } - else - { - return Types.asObject( value ); - } - } - public String getRandomString( long size ) { StringBuilder stringBuilder = new StringBuilder(); @@ -249,7 +224,10 @@ public Map getMapOfRandomsOfTypes( Type type, long size ) public boolean databaseRunning() { - return session() != null; - } + try ( Session session = driver.session()) + { + return session.run( "RETURN 1" ).single().get( 0 ).asInt() == 1; + } + } } diff --git a/driver/src/test/java/org/neo4j/driver/v1/tck/DriverEqualitySteps.java b/driver/src/test/java/org/neo4j/driver/v1/tck/DriverEqualitySteps.java new file mode 100644 index 0000000000..e94b2f76d7 --- /dev/null +++ b/driver/src/test/java/org/neo4j/driver/v1/tck/DriverEqualitySteps.java @@ -0,0 +1,79 @@ +/** + * Copyright (c) 2002-2016 "Neo Technology," + * Network Engine for Objects in Lund AB [http://neotechnology.com] + * + * This file is part of Neo4j. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.neo4j.driver.v1.tck; + +import cucumber.api.java.en.And; +import cucumber.api.java.en.Then; + +import java.util.Collection; +import java.util.HashMap; +import java.util.Iterator; + +import org.neo4j.driver.v1.Record; +import org.neo4j.driver.v1.Session; +import org.neo4j.driver.v1.Value; + +import static org.hamcrest.CoreMatchers.equalTo; +import static org.hamcrest.CoreMatchers.not; +import static org.junit.Assert.assertThat; +import static org.junit.Assert.assertTrue; +import static org.neo4j.driver.v1.tck.Environment.driver; + +public class DriverEqualitySteps +{ + HashMap savedValues = new HashMap<>(); + + @And( "^`(.*)` is single value result of: (.*)$" ) + public void valueIsSingleValueResultOfMATCHNLabelRETURNN( String key, String statement ) throws Throwable + { + try ( Session session = driver.session()) + { + Record r = session.run( statement ).single(); + assertThat( r.size(), equalTo( 1 ) ); + savedValues.put( key, r.get( 0 ) ); + } + } + + + @Then( "^saved values should all equal$" ) + public void savedValuesShouldAllEqual() throws Throwable + { + assertTrue( savedValues.values().size() > 1 ); + Collection values = savedValues.values(); + Iterator itr = values.iterator(); + Value v = itr.next(); + while ( itr.hasNext() ) + { + assertThat( v, equalTo( itr.next() ) ); + } + } + + @Then( "^none of the saved values should be equal$" ) + public void noneOfTheSavedValuesShouldBeEqual() throws Throwable + { + assertTrue( savedValues.values().size() > 1 ); + Collection values = savedValues.values(); + Iterator itr = values.iterator(); + Value v = itr.next(); + while ( itr.hasNext() ) + { + assertThat( v, not(equalTo( itr.next() ) ) ); + } + } +} diff --git a/driver/src/test/java/org/neo4j/driver/v1/tck/DriverResultApiSteps.java b/driver/src/test/java/org/neo4j/driver/v1/tck/DriverResultApiSteps.java new file mode 100644 index 0000000000..a9c341f332 --- /dev/null +++ b/driver/src/test/java/org/neo4j/driver/v1/tck/DriverResultApiSteps.java @@ -0,0 +1,439 @@ +/** + * Copyright (c) 2002-2016 "Neo Technology," + * Network Engine for Objects in Lund AB [http://neotechnology.com] + * + * This file is part of Neo4j. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.neo4j.driver.v1.tck; + +import cucumber.api.DataTable; +import cucumber.api.java.en.And; +import cucumber.api.java.en.Then; +import cucumber.api.java.en.When; +import cucumber.runtime.table.DiffableRow; +import org.hamcrest.CoreMatchers; +import org.hamcrest.core.IsInstanceOf; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import org.neo4j.driver.v1.Statement; +import org.neo4j.driver.v1.Value; +import org.neo4j.driver.v1.exceptions.ClientException; +import org.neo4j.driver.v1.summary.InputPosition; +import org.neo4j.driver.v1.summary.Notification; +import org.neo4j.driver.v1.summary.Plan; +import org.neo4j.driver.v1.summary.ProfiledPlan; +import org.neo4j.driver.v1.summary.ResultSummary; +import org.neo4j.driver.v1.summary.StatementType; +import org.neo4j.driver.v1.summary.SummaryCounters; +import org.neo4j.driver.v1.tck.tck.util.runners.CypherStatementRunner; + +import static org.hamcrest.CoreMatchers.equalTo; +import static org.hamcrest.CoreMatchers.instanceOf; +import static org.hamcrest.MatcherAssert.assertThat; +import static org.neo4j.driver.v1.tck.Environment.runners; +import static org.neo4j.driver.v1.tck.tck.util.ResultParser.getJavaValueIntAsLong; +import static org.neo4j.driver.v1.tck.tck.util.ResultParser.getJavaValueNormalInts; + +public class DriverResultApiSteps +{ + List summaries; + List statements; + + @When( "^the `Statement Result` is consumed a `Result Summary` is returned$" ) + public void the_result_is_summerized() throws Throwable + { + summaries = new ArrayList<>(); + for ( CypherStatementRunner runner : runners ) + { + summaries.add( runner.result().consume() ); + } + ResultSummary first = summaries.get( 0 ); + for ( ResultSummary resultSummary : summaries ) + { + assertThat( resultSummary, equalTo( first ) ); + } + } + + @Then( "^the `Statement Result` is closed$" ) + public void theResultCursorIsFullyConsumed() throws Throwable + { + for ( CypherStatementRunner runner : runners ) + { + try + { + runner.result().peek(); + } + catch ( ClientException e ) + { + return; + } + assertThat( runner.result().hasNext(), equalTo( false ) ); + } + } + + @And( "^I request a `Statement` from the `Result Summary`$" ) + public void iRequestAStatementFromTheResultSummary() throws Throwable + { + statements = new ArrayList<>(); + for ( ResultSummary resultSummary : summaries ) + { + statements.add( resultSummary.statement() ); + } + } + + @Then( "^requesting the `Statement` as text should give: (.*)$" ) + public void requestingTheStatementAsTextShouldGive( String expected ) throws Throwable + { + for ( Statement statement : statements ) + { + assertThat( statement.text(), equalTo( expected ) ); + } + } + + @And( "^requesting the `Statement` parameter should give: (.*)$" ) + public void requestingTheStatementAsParameterShouldGiveNull( String expected ) throws Throwable + { + for ( int i = 0; i < statements.size(); i++ ) + { + assertThat( statements.get( i ).parameters(), equalTo( runners.get( i ).parameters() ) ); + } + } + + @Then( "^requesting `Counters` from `Result Summary` should give$" ) + public void iShouldGetUpdateStatisticsContaining( DataTable expectedStatistics ) throws Throwable + { + for ( ResultSummary resultSummary : summaries ) + { + checkStatistics( resultSummary.counters(), tableToValueMap( expectedStatistics ) ); + } + } + + @Then( "^requesting the `Statement Type` should give (.*)$" ) + public void theStatementTypeShouldBeType( String expectedType ) throws Throwable + { + StatementType expected; + switch ( expectedType ) + { + case "read only": + expected = StatementType.READ_ONLY; + break; + case "write only": + expected = StatementType.WRITE_ONLY; + break; + case "read write": + expected = StatementType.READ_WRITE; + break; + case "schema write": + expected = StatementType.SCHEMA_WRITE; + break; + default: + throw new IllegalArgumentException( "Nu such type: " + expectedType ); + } + for ( ResultSummary summary : summaries ) + { + assertThat( summary.statementType(), equalTo( expected ) ); + } + } + + @Then( "^the `Result Summary` has a `Plan`$" ) + public void theSummaryHasAPlan() throws Throwable + { + for ( ResultSummary summary : summaries ) + { + assertThat( summary.hasPlan(), equalTo( true ) ); + } + } + + @Then( "^the `Result Summary` does not have a `Plan`$" ) + public void theSummaryDoesNotHaveAPlan() throws Throwable + { + for ( ResultSummary summary : summaries ) + { + assertThat( summary.hasPlan(), equalTo( false ) ); + } + } + + @Then( "^the `Result Summary` has a `Profile`$" ) + public void theSummaryHasAProfile() throws Throwable + { + for ( ResultSummary summary : summaries ) + { + assertThat( summary.hasProfile(), equalTo( true ) ); + } + } + + @And( "^the `Result Summary` does not have a `Profile`$" ) + public void theSummaryDoesNotHaveAPriofile() throws Throwable + { + for ( ResultSummary summary : summaries ) + { + assertThat( summary.hasProfile(), equalTo( false ) ); + } + } + + @Then( "^requesting the `Plan` it contains$" ) + public void thePlanContains( DataTable expectedTable ) throws Throwable + { + HashMap expectedMap = tableToValueMap( expectedTable ); + for ( ResultSummary summary : summaries ) + { + checkPlansValues( expectedMap, summary.plan() ); + } + + } + + @Then( "^requesting the `Profile` it contains:$" ) + public void theProfileContains( DataTable expectedTable ) throws Throwable + { + HashMap expectedMap = tableToValueMap( expectedTable ); + for ( ResultSummary summary : summaries ) + { + checkPlansValues( expectedMap, summary.profile() ); + } + } + + @And( "^the `Plan` also contains method calls for:$" ) + public void alsoContainsMethodCallsFor( DataTable expectedTable ) throws Throwable + { + HashMap expectedMap = tableToMap( expectedTable ); + for ( ResultSummary summary : summaries ) + { + checkPlanMethods( expectedMap, summary.plan() ); + } + } + + @And( "^the `Profile` also contains method calls for:$" ) + public void profileAlsoContainsMethodCallsFor( DataTable expectedTable ) throws Throwable + { + HashMap expectedMap = tableToMap( expectedTable ); + for ( ResultSummary summary : summaries ) + { + checkPlanMethods( expectedMap, summary.profile() ); + } + } + + @And( "^the `Result Summary` `Notifications` is empty$" ) + public void theSummaryDoesNotHaveAnyNotifications() throws Throwable + { + for ( ResultSummary summary : summaries ) + { + assertThat( summary.notifications().size(), equalTo( 0 ) ); + } + } + + @And( "^the `Result Summary` `Notifications` has one notification with$" ) + public void theSummaryHasNotifications( DataTable table ) throws Throwable + { + HashMap expected = new HashMap<>(); + for ( int i = 1; i < table.diffableRows().size(); i++ ) + { + DiffableRow row = table.diffableRows().get( i ); + String key = row.convertedRow.get( 0 ); + Object value = getJavaValueNormalInts( row.convertedRow.get( 1 ) ); + expected.put( key, value ); + } + for ( ResultSummary summary : summaries ) + { + assertThat( summary.notifications().size() == 1, equalTo( true ) ); + Notification notification = summary.notifications().get( 0 ); + for ( String key : expected.keySet() ) + { + switch ( key ) + { + case "code": + compareNotificationValue( notification.code(), expected.get( key ) ); + break; + case "title": + compareNotificationValue( notification.title(), expected.get( key ) ); + break; + case "description": + compareNotificationValue( notification.description(), expected.get( key ) ); + break; + case "severity": + compareNotificationValue( notification.severity(), expected.get( key ) ); + break; + case "position": + Map expectedPosition = (Map) expected.get( key ); + InputPosition position = notification.position(); + for ( String positionKey : expectedPosition.keySet() ) + { + switch ( positionKey ) + { + case "offset": + compareNotificationValue( position.offset(), expectedPosition.get( positionKey ) ); + break; + case "line": + compareNotificationValue( position.line(), expectedPosition.get( positionKey ) ); + break; + case "column": + compareNotificationValue( position.column(), expectedPosition.get( positionKey ) ); + break; + } + } + break; + default: + throw new IllegalArgumentException( "No case for " + key ); + } + + + + } + } + } + + private void compareNotificationValue(Object given, Object expected ) + { + assertThat( given, IsInstanceOf.instanceOf( expected.getClass() ) ); + assertThat( given, CoreMatchers.equalTo( expected ) ); + } + + public HashMap tableToValueMap( DataTable table ) + { + HashMap map = new HashMap<>(); + for ( int i = 1; i < table.diffableRows().size(); i++ ) + { + List row = table.diffableRows().get( i ).convertedRow; + map.put( row.get( 0 ), getJavaValueIntAsLong( row.get( 1 ) ) ); + } + return map; + } + + public HashMap tableToMap( DataTable table ) + { + HashMap map = new HashMap<>(); + for ( int i = 1; i < table.diffableRows().size(); i++ ) + { + List row = table.diffableRows().get( i ).convertedRow; + map.put( row.get( 0 ), row.get( 1 ) ); + } + return map; + } + + private void checkPlansValues( HashMap expected, Plan p ) + { + for ( String key : expected.keySet() ) + { + Object givenValue; + switch ( key ) + { + case "identifiers": + givenValue = p.identifiers(); + break; + case "operator type": + givenValue = p.operatorType(); + break; + case "db hits": + assertThat( p, instanceOf( ProfiledPlan.class ) ); + givenValue = ((ProfiledPlan) p).dbHits(); + break; + case "records": + assertThat( p, instanceOf( ProfiledPlan.class ) ); + givenValue = ((ProfiledPlan) p).records(); + break; + default: + throw new IllegalArgumentException( "Nu such plan method: " + key ); + } + assertThat( key + "- does not match", givenValue, equalTo( expected.get( key ) ) ); + } + } + + private void checkPlanMethods( HashMap expected, Plan plan ) + { + for ( String key : expected.keySet() ) + { + switch ( key ) + { + case "children": + assertThat( plan.children(), instanceOf( List.class ) ); + for ( Plan p : plan.children() ) + { + assertThat( p, instanceOf( Plan.class ) ); + break; + } + break; + case "arguments": + assertThat( plan.arguments(), instanceOf( Map.class ) ); + for ( String k : plan.arguments().keySet() ) + { + assertThat( k, instanceOf( String.class ) ); + assertThat( plan.arguments().get( k ), instanceOf( Value.class ) ); + break; + } + break; + default: + throw new IllegalArgumentException( "There is no case for handeling method type: " + key ); + } + } + } + + private void checkStatistics( SummaryCounters statistics, Map expectedStatisticsMap ) + { + for ( String key : expectedStatisticsMap.keySet() ) + { + Object expectedValue = expectedStatisticsMap.get( key ); + Object givenValue; + switch ( key ) + { + case "nodes created": + givenValue = statistics.nodesCreated(); + break; + case "nodes deleted": + givenValue = statistics.nodesDeleted(); + break; + case "relationships created": + givenValue = statistics.relationshipsCreated(); + break; + case "relationships deleted": + givenValue = statistics.relationshipsDeleted(); + break; + case "properties set": + givenValue = statistics.propertiesSet(); + break; + case "labels added": + givenValue = statistics.labelsAdded(); + break; + case "labels removed": + givenValue = statistics.labelsRemoved(); + break; + case "indexes added": + givenValue = statistics.indexesAdded(); + break; + case "indexes removed": + givenValue = statistics.indexesRemoved(); + break; + case "constraints added": + givenValue = statistics.constraintsAdded(); + break; + case "constraints removed": + givenValue = statistics.constraintsRemoved(); + break; + case "contains updates": + givenValue = statistics.containsUpdates(); + break; + default: + throw new IllegalArgumentException( "No function mapped to expression: " + key ); + } + if ( givenValue instanceof Integer ) + { + givenValue = Long.valueOf( (Integer) givenValue ); + } + assertThat( key + " - did not match", givenValue, equalTo( expectedValue ) ); + } + } +} diff --git a/driver/src/test/java/org/neo4j/driver/v1/tck/DriverSecurityComplianceIT.java b/driver/src/test/java/org/neo4j/driver/v1/tck/DriverSecurityComplianceIT.java deleted file mode 100644 index 25bb5ecdb6..0000000000 --- a/driver/src/test/java/org/neo4j/driver/v1/tck/DriverSecurityComplianceIT.java +++ /dev/null @@ -1,56 +0,0 @@ -/** - * Copyright (c) 2002-2016 "Neo Technology," - * Network Engine for Objects in Lund AB [http://neotechnology.com] - * - * This file is part of Neo4j. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package org.neo4j.driver.v1.tck; - -import cucumber.api.CucumberOptions; -import org.junit.ClassRule; -import org.junit.runner.RunWith; - -import java.io.File; -import java.io.IOException; - -import org.neo4j.driver.v1.util.Neo4jSettings; -import org.neo4j.driver.v1.util.TestNeo4j; - -/** - * The tls tck needs to access the server rather than a session, therefore we pull tls tck outside specially - */ -@RunWith( DriverCucumberAdapter.class ) -@CucumberOptions( - features = {"target/resources/features/TransportLayerSecurity.feature"}, - tags={"@tls"}, - format = {"pretty"}) -public class DriverSecurityComplianceIT -{ - @ClassRule - public static TestNeo4j neo4j = new TestNeo4j(); - - public DriverSecurityComplianceIT() throws IOException {} - - public static void updateEncryptionKeyAndCert( File key, File cert ) throws Exception - { - neo4j.restartServerOnEmptyDatabase( - Neo4jSettings.DEFAULT.usingEncryptionKeyAndCert( key, cert ) ); - } - - public static void useDefaultEncryptionKeyAndCert() throws Exception - { - neo4j.restartServerOnEmptyDatabase( Neo4jSettings.DEFAULT ); - } -} diff --git a/driver/src/test/java/org/neo4j/driver/v1/tck/DriverSecurityComplianceSteps.java b/driver/src/test/java/org/neo4j/driver/v1/tck/DriverSecurityComplianceSteps.java index 2f5d2c6ece..67f8b35307 100644 --- a/driver/src/test/java/org/neo4j/driver/v1/tck/DriverSecurityComplianceSteps.java +++ b/driver/src/test/java/org/neo4j/driver/v1/tck/DriverSecurityComplianceSteps.java @@ -48,8 +48,8 @@ import static org.neo4j.driver.internal.util.CertificateTool.saveX509Cert; import static org.neo4j.driver.v1.Config.TrustStrategy.trustOnFirstUse; import static org.neo4j.driver.v1.Config.TrustStrategy.trustSignedBy; -import static org.neo4j.driver.v1.tck.DriverSecurityComplianceIT.updateEncryptionKeyAndCert; -import static org.neo4j.driver.v1.tck.DriverSecurityComplianceIT.useDefaultEncryptionKeyAndCert; +import static org.neo4j.driver.v1.tck.DriverComplianceIT.updateEncryptionKeyAndCert; +import static org.neo4j.driver.v1.tck.DriverComplianceIT.useDefaultEncryptionKeyAndCert; import static org.neo4j.driver.v1.util.CertificateToolTest.generateSelfSignedCertificate; public class DriverSecurityComplianceSteps diff --git a/driver/src/test/java/org/neo4j/driver/v1/tck/Environment.java b/driver/src/test/java/org/neo4j/driver/v1/tck/Environment.java index 524188ee9a..fa493fa572 100644 --- a/driver/src/test/java/org/neo4j/driver/v1/tck/Environment.java +++ b/driver/src/test/java/org/neo4j/driver/v1/tck/Environment.java @@ -18,6 +18,7 @@ */ package org.neo4j.driver.v1.tck; +import cucumber.api.java.After; import cucumber.api.java.Before; import java.util.ArrayList; @@ -25,6 +26,8 @@ import java.util.List; import java.util.Map; +import org.neo4j.driver.v1.Driver; +import org.neo4j.driver.v1.Session; import org.neo4j.driver.v1.Value; import org.neo4j.driver.v1.tck.tck.util.Types; import org.neo4j.driver.v1.tck.tck.util.runners.CypherStatementRunner; @@ -32,7 +35,7 @@ import org.neo4j.driver.v1.tck.tck.util.runners.StatementRunner; import org.neo4j.driver.v1.tck.tck.util.runners.StringRunner; -import static org.neo4j.driver.v1.tck.DriverComplianceIT.session; +import static org.neo4j.driver.v1.tck.DriverComplianceIT.neo4j; public class Environment { @@ -46,6 +49,8 @@ public class Environment public static Map mapOfObjects; public static Map mappedTypes; + public static Driver driver = neo4j.driver(); + @Before public void resetValues() @@ -61,9 +66,21 @@ public void resetValues() mappedTypes = new HashMap<>( ); } + @After + public void closeRunners() + { + for (CypherStatementRunner runner : runners) + { + runner.close(); + } + } + @Before("@reset_database") public void emptyDatabase() { - session.run( "MATCH (n) DETACH DELETE n" ); + try ( Session session = driver.session()) + { + session.run( "MATCH (n) DETACH DELETE n" ); + } } } diff --git a/driver/src/test/java/org/neo4j/driver/v1/tck/tck/util/ResultParser.java b/driver/src/test/java/org/neo4j/driver/v1/tck/tck/util/ResultParser.java index 5e5a8b346f..26c564751f 100644 --- a/driver/src/test/java/org/neo4j/driver/v1/tck/tck/util/ResultParser.java +++ b/driver/src/test/java/org/neo4j/driver/v1/tck/tck/util/ResultParser.java @@ -195,7 +195,7 @@ private static Collection getLabels( String input ) private static Map getProperties( String input ) { - Map result = getMapOfObjects( input ); + Map result = getMapOfObjects( input, false ); HashMap properties = new HashMap<>(); for ( String key : result.keySet() ) { @@ -289,6 +289,38 @@ else if ( TYPE_SYSTEM.PATH().isTypeOf( input ) ) } } + public static Object getJavaValueIntAsLong( String value ) + { + return getJavaValue( value, false ); + } + + public static Object getJavaValueNormalInts( String value ) + { + return getJavaValue( value, true ); + + } + + private static Object getJavaValue( String value, boolean normalInts ) + { + if ( isList( value ) ) + { + ArrayList values = new ArrayList<>(); + for ( String val : getList( value ) ) + { + values.add( Types.asObject( val ) ); + } + return values; + } + else if ( isMap( value ) ) + { + return getMapOfObjects( value, normalInts ); + } + else + { + return Types.asObject( value ); + } + } + public static Map parseExpected( Collection input, List keys ) { assertEquals( keys.size(), input.size() ); @@ -323,7 +355,7 @@ public static String[] getList( String resultValue ) return resultValue.substring( 1, resultValue.length() - 1 ).split( ", " ); } - public static Map getMapOfObjects( String input ) + public static Map getMapOfObjects( String input, boolean normalInts ) { Map properties = new HashMap<>(); int i1 = input.indexOf( "{" ); @@ -335,8 +367,8 @@ public static Map getMapOfObjects( String input ) input = input.substring( i1, i2 + 1 ); try { - ObjectMapper mapper = new ObjectMapper( ); - mapper.configure( DeserializationFeature.USE_LONG_FOR_INTS, true ); + ObjectMapper mapper = new ObjectMapper(); + mapper.configure( DeserializationFeature.USE_LONG_FOR_INTS, !normalInts ); properties = mapper.readValue( input, HashMap.class ); } catch ( IOException e ) diff --git a/driver/src/test/java/org/neo4j/driver/v1/tck/tck/util/TestNodeValue.java b/driver/src/test/java/org/neo4j/driver/v1/tck/tck/util/TestNodeValue.java index ad995d87d6..99de6d5bda 100644 --- a/driver/src/test/java/org/neo4j/driver/v1/tck/tck/util/TestNodeValue.java +++ b/driver/src/test/java/org/neo4j/driver/v1/tck/tck/util/TestNodeValue.java @@ -53,8 +53,8 @@ public boolean equals( Object o ) return false; } NodeValue value = (NodeValue) o; - return (value.asNode().labels().equals( this.asNode().labels() ) && value.asMap().toString() - .equals( this.asMap().toString() )); + return (value.asNode().labels().equals( this.asNode().labels() ) && value.asMap() + .equals( this.asMap() )); } @Override diff --git a/driver/src/test/java/org/neo4j/driver/v1/tck/tck/util/TestRelationshipValue.java b/driver/src/test/java/org/neo4j/driver/v1/tck/tck/util/TestRelationshipValue.java index a7de164636..ad7ff5009e 100644 --- a/driver/src/test/java/org/neo4j/driver/v1/tck/tck/util/TestRelationshipValue.java +++ b/driver/src/test/java/org/neo4j/driver/v1/tck/tck/util/TestRelationshipValue.java @@ -51,8 +51,7 @@ public boolean equals( Object o ) } RelationshipValue value = (RelationshipValue) o; return (value.asRelationship().type().equals( this.asRelationship().type() ) && - value.asMap().toString() - .equals( this.asMap().toString() )); + value.asMap().equals( this.asMap() )); } @Override diff --git a/driver/src/test/java/org/neo4j/driver/v1/tck/tck/util/Types.java b/driver/src/test/java/org/neo4j/driver/v1/tck/tck/util/Types.java index 619bbc60ad..a65ea8019c 100644 --- a/driver/src/test/java/org/neo4j/driver/v1/tck/tck/util/Types.java +++ b/driver/src/test/java/org/neo4j/driver/v1/tck/tck/util/Types.java @@ -38,13 +38,17 @@ public static Type getType( String stringType ) throw new IllegalArgumentException( format( "There is no type: %s", stringType ) ); } - public static Object asObject(String object) + public static Object asObject( String object ) { return getTypeFromStringConstellation( object ).getJavaValue( object ); } public static Type getTypeFromStringConstellation( String object ) { + if ( object.length() == 0 ) + { + throw new IllegalArgumentException( "Cannot find matching type for expression: " + object ); + } if ( object.startsWith( "[:" ) && object.endsWith( "]" ) ) { return Type.Relationship; diff --git a/driver/src/test/java/org/neo4j/driver/v1/tck/tck/util/runners/CypherStatementRunner.java b/driver/src/test/java/org/neo4j/driver/v1/tck/tck/util/runners/CypherStatementRunner.java index 0ddb636b39..e7572c89af 100644 --- a/driver/src/test/java/org/neo4j/driver/v1/tck/tck/util/runners/CypherStatementRunner.java +++ b/driver/src/test/java/org/neo4j/driver/v1/tck/tck/util/runners/CypherStatementRunner.java @@ -19,10 +19,15 @@ package org.neo4j.driver.v1.tck.tck.util.runners; import org.neo4j.driver.v1.StatementResult; +import org.neo4j.driver.v1.Value; public interface CypherStatementRunner { CypherStatementRunner runCypherStatement(); StatementResult result(); + + Value parameters(); + + void close(); } diff --git a/driver/src/test/java/org/neo4j/driver/v1/tck/tck/util/runners/MappedParametersRunner.java b/driver/src/test/java/org/neo4j/driver/v1/tck/tck/util/runners/MappedParametersRunner.java index aa38978461..943b66d13a 100644 --- a/driver/src/test/java/org/neo4j/driver/v1/tck/tck/util/runners/MappedParametersRunner.java +++ b/driver/src/test/java/org/neo4j/driver/v1/tck/tck/util/runners/MappedParametersRunner.java @@ -18,38 +18,41 @@ */ package org.neo4j.driver.v1.tck.tck.util.runners; +import java.util.Collections; import java.util.Map; +import org.neo4j.driver.v1.Session; +import org.neo4j.driver.v1.Statement; import org.neo4j.driver.v1.StatementResult; import org.neo4j.driver.v1.Value; import org.neo4j.driver.v1.Values; -import static org.junit.Assert.assertNotNull; -import static org.neo4j.driver.v1.tck.DriverComplianceIT.session; +import static org.neo4j.driver.v1.tck.Environment.driver; public class MappedParametersRunner implements CypherStatementRunner { - private String statement; + private String query; + private Session session; private Value parameters; private StatementResult result; - public MappedParametersRunner( String st, String key, Value value ) + public static MappedParametersRunner createParameterRunner( String st, String key, Value value ) { - statement = st; - parameters = Values.parameters( key, value ); + return new MappedParametersRunner(st, Collections.singletonMap( key, value )); } public MappedParametersRunner( String st, Map params ) { - statement = st; + session = driver.session(); + query = st; parameters = Values.value(params); } @Override public CypherStatementRunner runCypherStatement() { - assertNotNull( session() ); - result = session.run( statement, parameters ); + + result = session.run( new Statement( query, parameters ) ); return this; } @@ -58,4 +61,16 @@ public StatementResult result() { return result; } + + @Override + public Value parameters() + { + return parameters; + } + + @Override + public void close() + { + session.close(); + } } diff --git a/driver/src/test/java/org/neo4j/driver/v1/tck/tck/util/runners/StatementRunner.java b/driver/src/test/java/org/neo4j/driver/v1/tck/tck/util/runners/StatementRunner.java index 6005384f7c..435ae72dcb 100644 --- a/driver/src/test/java/org/neo4j/driver/v1/tck/tck/util/runners/StatementRunner.java +++ b/driver/src/test/java/org/neo4j/driver/v1/tck/tck/util/runners/StatementRunner.java @@ -18,26 +18,28 @@ */ package org.neo4j.driver.v1.tck.tck.util.runners; -import org.neo4j.driver.v1.StatementResult; +import org.neo4j.driver.v1.Session; import org.neo4j.driver.v1.Statement; +import org.neo4j.driver.v1.StatementResult; +import org.neo4j.driver.v1.Value; -import static org.junit.Assert.assertNotNull; -import static org.neo4j.driver.v1.tck.DriverComplianceIT.session; +import static org.neo4j.driver.v1.tck.Environment.driver; public class StatementRunner implements CypherStatementRunner { private Statement statement; private StatementResult result; + private Session session; public StatementRunner( Statement st ) { + session = driver.session(); statement = st; } @Override public CypherStatementRunner runCypherStatement() { - assertNotNull( session() ); result = session.run( statement ); return this; } @@ -47,4 +49,16 @@ public StatementResult result() { return result; } + + @Override + public Value parameters() + { + return statement.parameters(); + } + + @Override + public void close() + { + session.close(); + } } \ No newline at end of file diff --git a/driver/src/test/java/org/neo4j/driver/v1/tck/tck/util/runners/StringRunner.java b/driver/src/test/java/org/neo4j/driver/v1/tck/tck/util/runners/StringRunner.java index ee68cac35c..755a81ac6a 100644 --- a/driver/src/test/java/org/neo4j/driver/v1/tck/tck/util/runners/StringRunner.java +++ b/driver/src/test/java/org/neo4j/driver/v1/tck/tck/util/runners/StringRunner.java @@ -18,25 +18,30 @@ */ package org.neo4j.driver.v1.tck.tck.util.runners; +import java.util.HashMap; + +import org.neo4j.driver.internal.value.MapValue; +import org.neo4j.driver.v1.Session; import org.neo4j.driver.v1.StatementResult; +import org.neo4j.driver.v1.Value; -import static org.junit.Assert.assertNotNull; -import static org.neo4j.driver.v1.tck.DriverComplianceIT.session; +import static org.neo4j.driver.v1.tck.Environment.driver; public class StringRunner implements CypherStatementRunner { private String statement; private StatementResult result; + private Session session; public StringRunner( String st ) { + session = driver.session(); statement = st; } @Override public CypherStatementRunner runCypherStatement() { - assertNotNull( session() ); result = session.run( statement ); return this; } @@ -46,4 +51,16 @@ public StatementResult result() { return result; } + + @Override + public Value parameters() + { + return new MapValue(new HashMap( )); + } + + @Override + public void close() + { + session.close(); + } } \ No newline at end of file