DSLDGrailsInferencingTests.java

/*******************************************************************************
 * Copyright (c) 2012 VMWare, Inc.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     VMWare, Inc. - initial API and implementation
 *******************************************************************************/
package org.grails.ide.eclipse.test.inferencing;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.Reader;
import java.net.URL;

import junit.framework.AssertionFailedError;
import junit.framework.Test;

import org.codehaus.groovy.eclipse.dsl.tests.InferencerWorkload;
import org.codehaus.jdt.groovy.model.GroovyCompilationUnit;
import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.Platform;
import org.eclipse.jdt.core.IClasspathContainer;
import org.eclipse.jdt.core.IClasspathEntry;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jdt.core.tests.builder.Problem;
import org.grails.ide.eclipse.commands.GrailsCommandUtils;
import org.grails.ide.eclipse.core.internal.classpath.GrailsClasspathContainer;
import org.grails.ide.eclipse.core.model.GrailsVersion;
import org.grails.ide.eclipse.core.model.IGrailsInstall;
import org.osgi.framework.Bundle;

import org.grails.ide.eclipse.test.GrailsTestsActivator;
import org.grails.ide.eclipse.test.util.GrailsTest;

/**
 * @author Andrew Eisenberg
 * @since 2.9.0
 */
public class DSLDGrailsInferencingTests extends AbstractGrailsInferencingTests {
    public static Test suite() {
        return buildTestSuite(DSLDGrailsInferencingTests.class);
    }

    public DSLDGrailsInferencingTests(String name) {
        super(name);
    }
    
    @Override
    protected void setUp() throws Exception {
        assertTrue("This test assumes Grails 20 but most recent Grails version is "+GrailsVersion.MOST_RECENT, 
                GrailsVersion.MOST_RECENT.compareTo(GrailsVersion.V_2_0_0)>=0);
        GrailsTest.ensureDefaultGrailsVersion(GrailsVersion.MOST_RECENT);
        super.setUp();
    }
    
    public void testDomainClassDSLD1() throws Exception {
        InferencerWorkload workload1 = new InferencerWorkload(GrailsTestsActivator.getResource("DomainClass1.groovy.ext"));
        InferencerWorkload workload2 = new InferencerWorkload(GrailsTestsActivator.getResource("DomainClass2.groovy.ext"));
        InferencerWorkload workload3 = new InferencerWorkload(GrailsTestsActivator.getResource("DomainClass3.groovy.ext"));
        createDomainClass("DomainClass3", workload3.getContents());
        createDomainClass("DomainClass2", workload2.getContents());
        GroovyCompilationUnit unit1 = createDomainClass("DomainClass1", workload1.getContents());
        assertNoErrors(unit1);
        workload1.perform(unit1, true);
    }
    public void testDomainClassDSLD2() throws Exception {
        InferencerWorkload workload1 = new InferencerWorkload(GrailsTestsActivator.getResource("DomainClass1.groovy.ext"));
        InferencerWorkload workload2 = new InferencerWorkload(GrailsTestsActivator.getResource("DomainClass2.groovy.ext"));
        InferencerWorkload workload3 = new InferencerWorkload(GrailsTestsActivator.getResource("DomainClass3.groovy.ext"));
        createDomainClass("DomainClass3", workload3.getContents());
        GroovyCompilationUnit unit2 = createDomainClass("DomainClass2", workload2.getContents());
        createDomainClass("DomainClass1", workload1.getContents());
        assertNoErrors(unit2);
        workload2.perform(unit2, true);
    }
    // Failing on build server.  Can't figure out why.  Disabling
    public void _testDomainClassDSLD3() throws Exception {
        InferencerWorkload workload1 = new InferencerWorkload(GrailsTestsActivator.getResource("DomainClass1.groovy.ext"));
        InferencerWorkload workload2 = new InferencerWorkload(GrailsTestsActivator.getResource("DomainClass2.groovy.ext"));
        InferencerWorkload workload3 = new InferencerWorkload(GrailsTestsActivator.getResource("DomainClass3.groovy.ext"));
        GroovyCompilationUnit unit3 = createDomainClass("DomainClass3", workload3.getContents());
        createDomainClass("DomainClass2", workload2.getContents());
        createDomainClass("DomainClass1", workload1.getContents());
        GrailsCommandUtils.refreshDependencies(unit3.getJavaProject(), true);
        assertNoErrors(unit3);
        try {
            workload3.perform(unit3, true);
        } catch(AssertionFailedError e) {
            fail(printGrailsClasspathContainer() + e.getMessage() + printGrailsDSLD());
        }
    }
    
    // Still need to do controller classes
    
    /**
     * @return
     * @throws Exception 
     */
    private String printGrailsDSLD() throws Exception {
        StringBuilder sb = new StringBuilder();
        sb.append("\n\nContents of Grails.dsld:\n");
        IGrailsInstall install = GrailsVersion.getEclipseGrailsVersion(this.project).getInstall();
        if (install != null && install.getVersion().compareTo(GrailsVersion.V_1_3_7) > 0) {
            Bundle b = Platform.getBundle("org.grails.ide.eclipse.resources");
            if (b != null) {
                URL entry = b.getEntry("dsl-support/dsld/grails.dsld");
                URL resolvedEntry;
                resolvedEntry = FileLocator.resolve(entry);
                sb.append(extractContents(new File(resolvedEntry.toURI())));
            }
        } else {
            sb.append("Not using 2.0\n");
        }
        return sb.toString();
    }
    
    private static String extractContents(File workloadDefinitionFile) throws Exception {
        Reader r = new FileReader(workloadDefinitionFile);
        BufferedReader br = new BufferedReader(r);
        StringBuilder sb = new StringBuilder();
        String line;
        while ((line  = br.readLine()) != null) {
            sb.append(line + "\n");
        }
        return sb.toString();
    }


    /**
     * @return
     * @throws JavaModelException 
     */
    private String printGrailsClasspathContainer() throws JavaModelException {
        IJavaProject javaProject = JavaCore.create(project);
        IClasspathContainer container = JavaCore.getClasspathContainer(GrailsClasspathContainer.CLASSPATH_CONTAINER_PATH, javaProject);
        IClasspathEntry[] entries = container.getClasspathEntries();
        StringBuilder sb = new StringBuilder();
        sb.append("Inferencing failed.  Grails classpath container:\n");
        for (IClasspathEntry entry : entries) {
            sb.append("\t" + entry.getPath() + "\n");
        }
        return sb.toString();
    }

    public void testControllerClass1() throws Exception {
        InferencerWorkload workload1 = new InferencerWorkload(GrailsTestsActivator.getResource("DomainClass1.groovy.ext"));
        InferencerWorkload workload2 = new InferencerWorkload(GrailsTestsActivator.getResource("DomainClass2.groovy.ext"));
        InferencerWorkload workload3 = new InferencerWorkload(GrailsTestsActivator.getResource("DomainClass3.groovy.ext"));
        InferencerWorkload workload4 = new InferencerWorkload(GrailsTestsActivator.getResource("OtherController.groovy.ext"));

        createDomainClass("DomainClass3", workload3.getContents());
        createDomainClass("DomainClass2", workload2.getContents());
        createDomainClass("DomainClass1", workload1.getContents());
        GroovyCompilationUnit unit4 = createControllerClass("OtherController", workload4.getContents());
        
        assertNoErrors(unit4);
        workload4.perform(unit4, true);
    }

    /**
     * @param unit4
     */
    public void assertNoErrors(GroovyCompilationUnit unit4) {
        env.fullBuild();
        Problem[] problems = env.getProblemsFor(unit4.getJavaProject().getProject().getFullPath());
        if (problems != null) {
            boolean realProblemFound = false;
            for (int i = 0; i < problems.length; i++) {
                if (problems[i].getMessage().contains("The project cannot be built until build path errors are resolved")) {
                    continue;
                }
                if (problems[i].getMessage().contains("is missing required library:")) {
                    continue;
                }
                realProblemFound = true;
                break;
            }
            if (realProblemFound) {
                // ignore build path errors
                fail("Compile problems found:\n" + arrayToString(problems));
            }
        }
    }
    public void testOther() throws Exception {
        InferencerWorkload workload1 = new InferencerWorkload(GrailsTestsActivator.getResource("DomainClass1.groovy.ext"));
        InferencerWorkload workload2 = new InferencerWorkload(GrailsTestsActivator.getResource("DomainClass2.groovy.ext"));
        InferencerWorkload workload3 = new InferencerWorkload(GrailsTestsActivator.getResource("DomainClass3.groovy.ext"));
        InferencerWorkload workload4 = new InferencerWorkload(GrailsTestsActivator.getResource("OtherController.groovy.ext"));
        InferencerWorkload workload5 = new InferencerWorkload(GrailsTestsActivator.getResource("Other.groovy.ext"));
        
        createDomainClass("DomainClass3", workload3.getContents());
        createDomainClass("DomainClass2", workload2.getContents());
        createDomainClass("DomainClass1", workload1.getContents());
        createControllerClass("OtherController", workload4.getContents());
        GroovyCompilationUnit unit5 = createUnit("Other", workload5.getContents());
        
        assertNoErrors(unit5);
        workload5.perform(unit5, true);
    }
    
    public void testOtherTests() throws Exception {
        InferencerWorkload workload1 = new InferencerWorkload(GrailsTestsActivator.getResource("DomainClass1.groovy.ext"));
        InferencerWorkload workload2 = new InferencerWorkload(GrailsTestsActivator.getResource("DomainClass2.groovy.ext"));
        InferencerWorkload workload3 = new InferencerWorkload(GrailsTestsActivator.getResource("DomainClass3.groovy.ext"));
        InferencerWorkload workload4 = new InferencerWorkload(GrailsTestsActivator.getResource("OtherController.groovy.ext"));
        InferencerWorkload workload5 = new InferencerWorkload(GrailsTestsActivator.getResource("Other.groovy.ext"));
        InferencerWorkload workload6 = new InferencerWorkload(GrailsTestsActivator.getResource("OtherTests.groovy.ext"));
        
        IType findType = JavaCore.create(project).findType("org.codehaus.groovy.grails.compiler.injection.test.TestForTransformation");
        findType.getTypeRoot().isStructureKnown();
        
        createDomainClass("DomainClass3", workload3.getContents());
        createDomainClass("DomainClass2", workload2.getContents());
        createDomainClass("DomainClass1", workload1.getContents());
        createControllerClass("OtherController", workload4.getContents());
        createUnit("Other", workload5.getContents());
        GroovyCompilationUnit unit6 = createTestClass("OtherTests", workload6.getContents());
        
        assertNoErrors(unit6);
        workload6.perform(unit6, true);
    }
}