Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 2014 JBoss, by Red Hat, Inc
   *
   * 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.kie.workbench.common.services.refactoring.backend.server;
 
 import java.io.File;
 import java.net.URI;
 import java.util.List;
 import java.util.Map;
 
 import  org.apache.commons.io.FileUtils;
 import  org.apache.lucene.analysis.Analyzer;
 import  org.guvnor.common.services.project.model.Package;
 import  org.junit.AfterClass;
 import  org.junit.Before;
 import  org.junit.BeforeClass;
 import  org.kie.uberfire.metadata.backend.lucene.LuceneConfig;
 import  org.kie.uberfire.metadata.backend.lucene.LuceneConfigBuilder;
 import  org.kie.uberfire.metadata.io.IOServiceIndexedImpl;
 import  org.kie.uberfire.metadata.io.IndexersFactory;
 import  org.kie.uberfire.metadata.model.KObject;
 import  org.kie.workbench.common.services.shared.project.KieProject;
 import  org.kie.workbench.common.services.shared.project.KieProjectService;
 import  org.uberfire.io.IOService;
 import  org.uberfire.java.nio.file.Path;
 import  org.uberfire.workbench.type.ResourceTypeDefinition;
 
 import static org.junit.Assert.*;
 import static org.mockito.Matchers.any;
 import static org.mockito.Mockito.*;
 
 public abstract class BaseIndexingTest<T extends ResourceTypeDefinition> {
 
     public static final String TEST_PROJECT_ROOT = "/a/mock/project/root";
 
     public static final String TEST_PACKAGE_NAME = "org.kie.workbench.mock.package";
 
     private IOService ioService = null;
     private static LuceneConfig config;
     private static final List<FiletempFiles = new ArrayList<File>();
     private int seed = new Random( 10L ).nextInt();
     private boolean created = false;
 
     protected Path basePath;
 
     @Before
     public void setup() throws IOException {
         if ( ! ) {
             final String repositoryName = getRepositoryName();
             final String path = createTempDirectory().getAbsolutePath();
             System.setProperty"org.uberfire.nio.git.dir",
                                 path );
             ..println".niogit: " + path );
 
             final URI newRepo = URI.create"git://" + repositoryName );
 
             try {
                 ioService().newFileSystem( newRepo,
                                            new HashMap<StringObject>() );
 
                 //Don't ask, but we need to write a single file first in order for indexing to work
                  = getDirectoryPath().resolveSibling( "someNewOtherPath" );
                 ioService().write( .resolve( "dummy" ),
                                    "<none>" );
 
             } catch ( final Exception ex ) {
                 ex.fillInStackTrace();
                 ..printlnex.getMessage() );
             } finally {
                  = true;
             }
         }
     }
 
     @AfterClass
     @BeforeClass
     public static void cleanup() {
         for ( final File tempFile :  ) {
             FileUtils.deleteQuietly( tempFile );
        }
    }
    protected static LuceneConfig getConfig() {
        return ;
    }
    protected abstract String getRepositoryName();
    protected abstract TestIndexer<T> getIndexer();
    protected abstract Map<String, Analyzer> getAnalyzers();
    protected abstract T getResourceTypeDefinition();
    protected Path getDirectoryPath() {
        final String repositoryName = getRepositoryName();
        final Path dir = ioService().get( URI.create"git://" + repositoryName + "/_someDir" +  ) );
        ioService().deleteIfExists( dir );
        return dir;
    }
    protected void loadPropertiesfinal String fileName,
                                   final Path basePath ) throws IOException {
        final Path path = basePath.resolve( fileName );
        final Properties properties = new Properties();
        properties.loadthis.getClass().getResourceAsStreamfileName ) );
        ioService().write( path,
                           propertiesToStringproperties ) );
    }
    protected String loadTextfinal String fileName ) throws IOException {
        final BufferedReader br = new BufferedReadernew InputStreamReaderthis.getClass().getResourceAsStreamfileName ) ) );
        try {
            StringBuilder sb = new StringBuilder();
            String line = br.readLine();
            while ( line != null ) {
                sb.appendline );
                sb.append( System.getProperty"line.separator" ) );
                line = br.readLine();
            }
            return sb.toString();
        } finally {
            br.close();
        }
    }
    protected String propertiesToStringfinal Properties properties ) {
        final StringBuilder sb = new StringBuilder();
        for ( String name : properties.stringPropertyNames() ) {
            sb.appendname ).append"=" ).appendproperties.getPropertyname ) ).append"\n" );
        }
        return sb.toString();
    }
    protected IOService ioService() {
        if (  == null ) {
            final Map<String, Analyzer> analyzers = getAnalyzers();
             = new LuceneConfigBuilder()
                    .withInMemoryMetaModelStore()
                    .usingAnalyzers( analyzers )
                    .useDirectoryBasedIndex()
                    .useInMemoryDirectory()
                    .build();
             = new IOServiceIndexedImpl( .getIndexEngine() );
            final TestIndexer indexer = getIndexer();
            IndexersFactory.addIndexer( indexer );
            //Mock CDI injection and setup
            indexer.setIOService );
            indexer.setProjectServicegetProjectService() );
            indexer.setResourceTypeDefinitiongetResourceTypeDefinition() );
        }
        return ;
    }
    protected KieProjectService getProjectService() {
        final org.uberfire.backend.vfs.Path mockRoot = mock( org.uberfire.backend.vfs.Path.class );
        when( mockRoot.toURI() ).thenReturn(  );
        final KieProject mockProject = mock( KieProject.class );
        when( mockProject.getRootPath() ).thenReturn( mockRoot );
        final org.guvnor.common.services.project.model.Package mockPackage = mockPackage.class );
        when( mockPackage.getPackageName() ).thenReturn(  );
        final KieProjectService mockProjectService = mock( KieProjectService.class );
        when( mockProjectService.resolveProject( any( org.uberfire.backend.vfs.Path.class ) ) ).thenReturn( mockProject );
        when( mockProjectService.resolvePackage( any( org.uberfire.backend.vfs.Path.class ) ) ).thenReturn( mockPackage );
        return mockProjectService;
    }
    protected void assertContainsfinal List<KObject> results,
                                   final Path path ) {
        for ( KObject kObject : results ) {
            final String key = kObject.getKey();
            final String fileName = path.getFileName().toString();
            if ( key.endsWithfileName ) ) {
                return;
            }
        }
        fail( "Results do not contain expected Path '" + path.toUri().toString() );
    }
    private static File createTempDirectory() throws IOException {
        final File temp = File.createTempFile"temp", Long.toString( System.nanoTime() ) );
        if ( !( temp.delete() ) ) {
            throw new IOException"Could not delete temp file: " + temp.getAbsolutePath() );
        }
        if ( !( temp.mkdir() ) ) {
            throw new IOException"Could not create temp directory: " + temp.getAbsolutePath() );
        }
        .addtemp );
        return temp;
    }
New to GrepCode? Check out our FAQ X