public static DbRepresentation of( File storeDir, boolean includeIndexes, Config config ) { GraphDatabaseBuilder builder = new TestGraphDatabaseFactory().newEmbeddedDatabaseBuilder( storeDir ); builder.setConfig( config.getRaw() ); GraphDatabaseService db = builder.newGraphDatabase(); try { return of( db, includeIndexes ); } finally { db.shutdown(); } }
@Test void startTestDatabaseOnProvidedNonAbsoluteFile() { File directory = new File( "notAbsoluteDirectory" ); new TestGraphDatabaseFactory().newImpermanentDatabase( directory ).shutdown(); }
@BeforeClass public static void setUpStuff() { graphDb = new TestGraphDatabaseFactory().newImpermanentDatabase(); }
@Test public void mustPreventMultipleInstancesFromStartingOnSameStore() { File storeDir = target.storeDir(); GraphDatabaseService db = new TestGraphDatabaseFactory().newEmbeddedDatabase( storeDir ); try ( Transaction tx = db.beginTx() ) { db.createNode(); tx.success(); } try { new TestGraphDatabaseFactory().newEmbeddedDatabase( storeDir ); fail( "Should not be able to start up another db in the same dir" ); } catch ( Exception e ) { // Good } finally { db.shutdown(); } }
@Test public void shouldReturnASingleNode() { GraphDatabaseFacade graphdb = (GraphDatabaseFacade) new TestGraphDatabaseFactory().newImpermanentDatabase(); Database database = new WrappedDatabase( graphdb ); CypherExecutor executor = new CypherExecutor( database, NullLogProvider.getInstance() ); executor.start(); HttpServletRequest request = mock( HttpServletRequest.class ); when( request.getScheme() ).thenReturn( "http" ); when( request.getRemoteAddr() ).thenReturn( "127.0.0.1" ); when( request.getRemotePort() ).thenReturn( 5678 ); when( request.getServerName() ).thenReturn( "127.0.0.1" ); when( request.getServerPort() ).thenReturn( 7474 ); when( request.getRequestURI() ).thenReturn( "/" ); try { CypherSession session = new CypherSession( executor, NullLogProvider.getInstance(), request ); Pair<String, String> result = session.evaluate( "create (a) return a" ); assertThat( result.first(), containsString( "Node[0]" ) ); } finally { graphdb.shutdown(); } } }
@Test public void testStartEntryWrittenOnceOnRollback() throws Exception { File storeDir = testDirectory.databaseDir(); final GraphDatabaseService db = new TestGraphDatabaseFactory().setFileSystem( fs.get() ).newImpermanentDatabase( storeDir ); createSomeTransactions( db ); EphemeralFileSystemAbstraction snapshot = fs.snapshot( db::shutdown ); new TestGraphDatabaseFactory().setFileSystem( snapshot ).newImpermanentDatabase( storeDir ).shutdown(); }
@Test( timeout = TEST_TIMEOUT ) public void notifyWhenFileWatchingFailToStart() { AssertableLogProvider logProvider = new AssertableLogProvider( true ); GraphDatabaseService db = null; try { db = new TestGraphDatabaseFactory().setInternalLogProvider( logProvider ) .setFileSystem( new NonWatchableFileSystemAbstraction() ) .newEmbeddedDatabase( testDirectory.storeDir( "failed-start-db" ) ); logProvider.assertContainsMessageContaining( "Can not create file watcher for current file system. " + "File monitoring capabilities for store files will be disabled." ); } finally { shutdownDatabaseSilently( db ); } }
private GraphDatabaseService getGraphDatabaseService( File storeDir, String... settings ) { GraphDatabaseBuilder builder = new TestGraphDatabaseFactory().newEmbeddedDatabaseBuilder( storeDir ); builder.setConfig( settings( settings ) ); return builder.newGraphDatabase(); }
@Before public void setUp() { db = new TestGraphDatabaseFactory().newImpermanentDatabaseBuilder().newGraphDatabase(); }
private void prepareEmpty23Database() throws IOException { new TestGraphDatabaseFactory().newEmbeddedDatabase( storeDir ).shutdown(); fileSystem.deleteFile( nativeLabelIndex ); MetaDataStore.setRecord( pageCache, databaseLayout.metadataStore(), Position.STORE_VERSION, versionStringToLong( StandardV2_3.STORE_VERSION ) ); }
private GraphDatabaseService createGraphDatabase( EphemeralFileSystemAbstraction fs ) throws IOException { removePreviousAuthFile(); Map<Setting<?>, String> settings = new HashMap<>(); settings.put( GraphDatabaseSettings.auth_enabled, "true" ); TestGraphDatabaseBuilder graphDatabaseFactory = (TestGraphDatabaseBuilder) new TestGraphDatabaseFactory() .setFileSystem( fs ) .newImpermanentDatabaseBuilder() .setConfig( GraphDatabaseSettings.auth_enabled, "true" ); return graphDatabaseFactory.newGraphDatabase(); }
@Override protected GraphDatabaseService createGraphDatabase() { return new TestGraphDatabaseFactory().newImpermanentDatabaseBuilder() .setConfig( GraphDatabaseSettings.dense_node_threshold, String.valueOf( RELATIONSHIPS_COUNT ) ) .newGraphDatabase(); }
@Test public void schemaTransactionsShouldSurviveRecovery() throws Exception { // given File storeDir = testDirectory.absolutePath(); Process process = new CreateConstraintButDoNotShutDown().start( storeDir ); process.waitForSchemaTransactionCommitted(); SubProcess.kill( process ); // when GraphDatabaseService recoveredDatabase = new TestGraphDatabaseFactory().newEmbeddedDatabase( storeDir ); // then assertEquals(1, constraints( recoveredDatabase ).size()); assertEquals(1, indexes( recoveredDatabase ).size()); recoveredDatabase.shutdown(); }
@Test public void shouldCountCommittedTransactions() throws Exception { GraphDatabaseAPI db = (GraphDatabaseAPI) new TestGraphDatabaseFactory().newImpermanentDatabase(); try { TransactionCounters counts = db.getDependencyResolver().resolveDependency( TransactionCounters.class ); TransactionCountersChecker checker = new TransactionCountersChecker( counts ); try ( Transaction tx = db.beginTx() ) { dbConsumer.accept( db ); tx.success(); } checker.verifyCommitted( isWriteTx, counts ); } finally { db.shutdown(); } }
@Test public void canFormatNode() { GraphDatabaseService db = new TestGraphDatabaseFactory().newImpermanentDatabase(); try ( Transaction transaction = db.beginTx() ) { final Node n = db.createNode(); json.assemble( new NodeRepresentation( n ) ); } finally { db.shutdown(); } assertTrue( stream.toString().contains( "\"self\" : \"http://localhost/node/0\"," ) ); } @Test
@Test public void differentChunksHaveDifferentCursors() { GraphDatabaseAPI database = (GraphDatabaseAPI) new TestGraphDatabaseFactory().newEmbeddedDatabase( testDirectory.storeDir() ); try { RecordStorageEngine recordStorageEngine = database.getDependencyResolver().resolveDependency( RecordStorageEngine.class ); NeoStores neoStores = recordStorageEngine.testAccessNeoStores(); RecordStorageReader storageReader = new RecordStorageReader( neoStores ); TestStoreScanChunk scanChunk1 = new TestStoreScanChunk( storageReader, false ); TestStoreScanChunk scanChunk2 = new TestStoreScanChunk( storageReader, false ); assertNotSame( scanChunk1.getCursor(), scanChunk2.getCursor() ); assertNotSame( scanChunk1.getStorePropertyCursor(), scanChunk2.getStorePropertyCursor() ); } finally { database.shutdown(); } }
@Before public void setup() { databaseLayout = testDirectory.databaseLayout(); storeDir = databaseLayout.databaseDirectory(); fileSystem = fileSystemRule.get(); new TestGraphDatabaseFactory().setFileSystem( fileSystem ).newImpermanentDatabase( storeDir ).shutdown(); }
private GraphDatabaseService createGraphDatabaseService() { return new TestGraphDatabaseFactory() .newEmbeddedDatabaseBuilder( workingDatabaseLayout.databaseDirectory() ) .setConfig( GraphDatabaseSettings.allow_upgrade, "true" ) .newGraphDatabase(); } }
@Before public void init() { db = (GraphDatabaseAPI) new TestGraphDatabaseFactory().newImpermanentDatabase(); }
@BeforeClass public static void startDb() { graphdb = new TestGraphDatabaseFactory().newImpermanentDatabaseBuilder().newGraphDatabase(); }