Added more testing on creating indexes for specific providers

community/kernel/src/main/java/org/neo4j/kernel/impl/api/state/ConstraintIndexCreator.java

@@ -21,6 +21,7 @@
 
 import java.io.IOException;
 import java.util.function.Supplier;
+import javax.annotation.Nullable;
 
 import org.neo4j.internal.kernel.api.CapableIndexReference;
 import org.neo4j.internal.kernel.api.Kernel;
@@ -97,8 +98,8 @@ public ConstraintIndexCreator( Supplier<Kernel> kernelSupplier, IndexingService
      * Btw providerDescriptor is allowed to be null, where default configured will be used.
      */
     public long createUniquenessConstraintIndex( KernelTransactionImplementation transaction,
-            SchemaDescriptor descriptor, IndexProvider.Descriptor providerDescriptor ) throws TransactionFailureException, CreateConstraintFailureException,
-            UniquePropertyValueValidationException, AlreadyConstrainedException
+            SchemaDescriptor descriptor, @Nullable IndexProvider.Descriptor providerDescriptor )
+            throws TransactionFailureException, CreateConstraintFailureException, UniquePropertyValueValidationException, AlreadyConstrainedException
     {
         UniquenessConstraintDescriptor constraint = ConstraintDescriptorFactory.uniqueForSchema( descriptor );
 

community/kernel/src/main/java/org/neo4j/kernel/impl/newapi/Operations.java

@@ -886,7 +886,7 @@ public IndexReference indexCreate( SchemaDescriptor descriptor, String providerN
         assertIndexDoesNotExist( SchemaKernelException.OperationContext.INDEX_CREATION, descriptor );
 
         SchemaIndexDescriptor indexDescriptor = SchemaIndexDescriptorFactory.forSchema( descriptor );
-        IndexProvider.Descriptor providerDescriptor = providerName != null ? indexProviderMap.lookup( providerName ).getProviderDescriptor() : null;
+        IndexProvider.Descriptor providerDescriptor = providerByName( providerName );
         ktx.txState().indexRuleDoAdd( indexDescriptor, providerDescriptor );
         return DefaultIndexReference.fromDescriptor( indexDescriptor );
     }
@@ -939,7 +939,7 @@ public ConstraintDescriptor uniquePropertyConstraintCreate( SchemaDescriptor des
         assertIndexDoesNotExist( SchemaKernelException.OperationContext.CONSTRAINT_CREATION, descriptor );
 
         // Create constraints
-        IndexProvider.Descriptor providerDescriptor = providerName != null ? indexProviderMap.lookup( providerName ).getProviderDescriptor() : null;
+        IndexProvider.Descriptor providerDescriptor = providerByName( providerName );
         indexBackedConstraintCreate( constraint, providerDescriptor );
         return constraint;
     }
@@ -966,7 +966,7 @@ public ConstraintDescriptor nodeKeyConstraintCreate( LabelSchemaDescriptor descr
         }
 
         //create constraint
-        IndexProvider.Descriptor providerDescriptor = providerName != null ? indexProviderMap.lookup( providerName ).getProviderDescriptor() : null;
+        IndexProvider.Descriptor providerDescriptor = providerByName( providerName );
         indexBackedConstraintCreate( constraint, providerDescriptor );
         return constraint;
     }
@@ -1247,4 +1247,9 @@ private void assertValidIndex( IndexReference index ) throws NoSuchIndexExceptio
             throw new NoSuchIndexException( SchemaDescriptorFactory.forLabel( index.label(), index.properties() ) );
         }
     }
+
+    private IndexProvider.Descriptor providerByName( String providerName )
+    {
+        return providerName != null ? indexProviderMap.lookup( providerName ).getProviderDescriptor() : null;
+    }
 }

community/kernel/src/test/java/org/neo4j/kernel/impl/api/integrationtest/KernelIntegrationTest.java

@@ -43,10 +43,10 @@
 import org.neo4j.internal.kernel.api.Transaction;
 import org.neo4j.internal.kernel.api.Write;
 import org.neo4j.internal.kernel.api.exceptions.KernelException;
+import org.neo4j.internal.kernel.api.exceptions.TransactionFailureException;
 import org.neo4j.internal.kernel.api.security.LoginContext;
 import org.neo4j.kernel.api.KernelTransaction;
 import org.neo4j.kernel.api.dbms.DbmsOperations;
-import org.neo4j.internal.kernel.api.exceptions.TransactionFailureException;
 import org.neo4j.kernel.api.security.AnonymousContext;
 import org.neo4j.kernel.impl.api.KernelImpl;
 import org.neo4j.kernel.impl.api.index.IndexingService;
@@ -177,11 +177,16 @@ protected void startDb()
 
     protected GraphDatabaseService createGraphDatabase()
     {
-        GraphDatabaseBuilder graphDatabaseBuilder = new TestGraphDatabaseFactory().setFileSystem( fileSystemRule.get() )
+        GraphDatabaseBuilder graphDatabaseBuilder = createGraphDatabaseFactory().setFileSystem( fileSystemRule.get() )
                 .newEmbeddedDatabaseBuilder( testDir.graphDbDir() );
         return configure( graphDatabaseBuilder ).newGraphDatabase();
     }
 
+    protected TestGraphDatabaseFactory createGraphDatabaseFactory()
+    {
+        return new TestGraphDatabaseFactory();
+    }
+
     protected GraphDatabaseBuilder configure( GraphDatabaseBuilder graphDatabaseBuilder )
     {
         return graphDatabaseBuilder;

community/neo4j/src/test/java/org/neo4j/kernel/impl/index/schema/IndexCreateIT.java

@@ -24,6 +24,7 @@
 import org.neo4j.graphdb.factory.GraphDatabaseSettings;
 import org.neo4j.internal.kernel.api.SchemaWrite;
 import org.neo4j.internal.kernel.api.exceptions.KernelException;
+import org.neo4j.internal.kernel.api.exceptions.schema.SchemaKernelException;
 import org.neo4j.internal.kernel.api.schema.LabelSchemaDescriptor;
 import org.neo4j.kernel.impl.api.integrationtest.KernelIntegrationTest;
 
@@ -36,25 +37,28 @@ public class IndexCreateIT extends KernelIntegrationTest
     @Test
     public void shouldCreateIndexWithSpecificExistingProviderName() throws KernelException
     {
-        int labelId = 0;
-        for ( GraphDatabaseSettings.SchemaIndex indexSetting : GraphDatabaseSettings.SchemaIndex.values() )
-        {
-            // given
-            SchemaWrite schemaWrite = schemaWriteInNewTransaction();
-            String provider = indexSetting.providerName();
-            LabelSchemaDescriptor descriptor = forLabel( labelId++, 0 );
-            schemaWrite.indexCreate( descriptor, provider );
+        shouldCreateWithSpecificExistingProviderName( SchemaWrite::indexCreate );
+    }
 
-            // when
-            commit();
+    @Test
+    public void shouldCreateUniquePropertyConstraintWithSpecificExistingProviderName() throws KernelException
+    {
+        shouldCreateWithSpecificExistingProviderName( SchemaWrite::uniquePropertyConstraintCreate );
+    }
 
-            // then
-            assertEquals( provider, indexingService.getIndexProxy( descriptor ).getProviderDescriptor().name() );
-        }
+    @Test
+    public void shouldFailCreateIndexWithNonExistentProviderName() throws KernelException
+    {
+        shouldFailWithNonExistentProviderName( SchemaWrite::indexCreate );
     }
 
     @Test
-    public void shouldFailOnCreateIndexWithNonExistentProviderName() throws KernelException
+    public void shouldFailCreateUniquePropertyConstraintWithNonExistentProviderName() throws KernelException
+    {
+        shouldFailWithNonExistentProviderName( SchemaWrite::uniquePropertyConstraintCreate );
+    }
+
+    void shouldFailWithNonExistentProviderName( IndexCreator creator ) throws KernelException
     {
         // given
         SchemaWrite schemaWrite = schemaWriteInNewTransaction();
@@ -70,4 +74,28 @@ public void shouldFailOnCreateIndexWithNonExistentProviderName() throws KernelEx
             // then good
         }
     }
+
+    void shouldCreateWithSpecificExistingProviderName( IndexCreator creator ) throws KernelException
+    {
+        int labelId = 0;
+        for ( GraphDatabaseSettings.SchemaIndex indexSetting : GraphDatabaseSettings.SchemaIndex.values() )
+        {
+            // given
+            SchemaWrite schemaWrite = schemaWriteInNewTransaction();
+            String provider = indexSetting.providerName();
+            LabelSchemaDescriptor descriptor = forLabel( labelId++, 0 );
+            creator.create( schemaWrite, descriptor, provider );
+
+            // when
+            commit();
+
+            // then
+            assertEquals( provider, indexingService.getIndexProxy( descriptor ).getProviderDescriptor().name() );
+        }
+    }
+
+    interface IndexCreator
+    {
+        void create( SchemaWrite schemaWrite, LabelSchemaDescriptor descriptor, String providerName ) throws SchemaKernelException;
+    }
 }

enterprise/neo4j-enterprise/src/test/java/org/neo4j/kernel/impl/index/schema/IndexCreateEnterpriseIT.java

@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2002-2018 "Neo Technology,"
+ * Network Engine for Objects in Lund AB [http://neotechnology.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Neo4j is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, either version 3 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.neo4j.kernel.impl.index.schema;
+
+import org.junit.Test;
+
+import org.neo4j.internal.kernel.api.SchemaWrite;
+import org.neo4j.internal.kernel.api.exceptions.KernelException;
+import org.neo4j.test.TestEnterpriseGraphDatabaseFactory;
+import org.neo4j.test.TestGraphDatabaseFactory;
+
+public class IndexCreateEnterpriseIT extends IndexCreateIT
+{
+    @Override
+    protected TestGraphDatabaseFactory createGraphDatabaseFactory()
+    {
+        return new TestEnterpriseGraphDatabaseFactory();
+    }
+
+    @Test
+    public void shouldCreateNodeKeyConstraintWithSpecificExistingProviderName() throws KernelException
+    {
+        shouldCreateWithSpecificExistingProviderName( SchemaWrite::nodeKeyConstraintCreate );
+    }
+
+    @Test
+    public void shouldFailCreateNodeKeyWithNonExistentProviderName() throws KernelException
+    {
+        shouldFailWithNonExistentProviderName( SchemaWrite::nodeKeyConstraintCreate );
+    }
+}