| /* |
| * Copyright 2000-2013 JetBrains s.r.o. |
| * |
| * 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.jetbrains.plugins.groovy.dsl |
| |
| import com.intellij.codeInsight.documentation.DocumentationManager |
| import com.intellij.openapi.module.Module |
| import com.intellij.openapi.roots.ContentEntry |
| import com.intellij.openapi.roots.ModifiableRootModel |
| import com.intellij.psi.PsiClass |
| import com.intellij.psi.PsiFile |
| import com.intellij.testFramework.LightProjectDescriptor |
| import com.intellij.testFramework.PsiTestUtil |
| import com.intellij.testFramework.fixtures.DefaultLightProjectDescriptor |
| import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase |
| import org.jetbrains.annotations.NotNull |
| import org.jetbrains.plugins.groovy.codeInspection.assignment.GroovyAssignabilityCheckInspection |
| import org.jetbrains.plugins.groovy.lang.documentation.GroovyDocumentationProvider |
| import org.jetbrains.plugins.groovy.util.TestUtils |
| /** |
| * @author peter |
| */ |
| public class GroovyDslTest extends LightCodeInsightFixtureTestCase { |
| private static descriptor = new DefaultLightProjectDescriptor() { |
| @Override |
| void configureModule(Module module, ModifiableRootModel model, ContentEntry contentEntry) { |
| PsiTestUtil.addLibrary(module, model, "GROOVY", TestUtils.getMockGroovyLibraryHome(), TestUtils.GROOVY_JAR); |
| } |
| } |
| |
| @NotNull |
| @Override |
| protected LightProjectDescriptor getProjectDescriptor() { |
| descriptor |
| } |
| |
| |
| @Override |
| protected String getBasePath() { |
| TestUtils.testDataPath + "groovy/dsl" |
| } |
| |
| private def doCustomTest(String s) { |
| addGdsl(s) |
| myFixture.testCompletion(getTestName(false) + ".groovy", getTestName(false) + "_after.groovy") |
| } |
| |
| private def addGdsl(String text) { |
| final PsiFile file = myFixture.addFileToProject(getTestName(false) + "Enhancer.gdsl", text); |
| GroovyDslFileIndex.activateUntilModification(file.virtualFile) |
| } |
| |
| public void doTest() throws Throwable { |
| myFixture.testCompletion(getTestName(false) + ".gdsl", getTestName(false) + "_after.gdsl") |
| } |
| |
| public void testCompleteTopLevel() throws Throwable { |
| myFixture.configureByText 'a.gdsl', '<caret>' |
| myFixture.completeBasic() |
| def expected = ['contributor', 'contribute', 'currentType', 'assertVersion'] |
| if (!myFixture.lookupElementStrings.containsAll(expected)) { |
| assertSameElements(expected, myFixture.lookupElementStrings) |
| } |
| } |
| |
| public void testCompleteInContributor() throws Throwable { |
| myFixture.configureByText 'a.gdsl', 'contribute { <caret> }' |
| myFixture.completeBasic() |
| def expected = ['method', 'property', 'parameter'] |
| if (!myFixture.lookupElementStrings.containsAll(expected)) { |
| assertSameElements(expected, myFixture.lookupElementStrings) |
| } |
| } |
| |
| public void testCompleteClassMethod() throws Throwable { |
| doCustomTest(""" |
| def ctx = context(ctype: "java.lang.String") |
| |
| contributor ([ctx], { |
| method name:"zzz", type:"void", params:[:] |
| }) |
| """) |
| } |
| |
| public void "test on anonymous class"() { |
| addGdsl ''' |
| import com.intellij.patterns.PsiJavaPatterns |
| |
| contribute(ctype:PsiJavaPatterns.psiClass()) { |
| method name:'foo' + psiClass.name, type:void, params:[:] |
| }''' |
| myFixture.configureByText 'a.groovy', ''' |
| class Foo<T> { |
| def foo(T t) { |
| t.f<caret> |
| } |
| } |
| ''' |
| myFixture.completeBasic() |
| myFixture.assertPreferredCompletionItems 0, 'finalize', 'fooT' |
| } |
| |
| public void testDelegateToThrowable() throws Throwable { |
| doCustomTest(""" |
| def ctx = context(ctype: "java.lang.String") |
| |
| contributor ctx, { |
| findClass("java.lang.Throwable")?.methods?.each{add it} |
| } |
| """) |
| } |
| |
| public void testDelegateToArgument() throws Throwable { |
| doCustomTest(""" |
| def ctx = context(scope: closureScope(isArgument: true)) |
| |
| contributor(ctx, { |
| def call = enclosingCall("boo") |
| if (call) { |
| def method = call.bind() |
| if ("Runner".equals(method?.containingClass?.qualifiedName)) { |
| delegatesTo(call.arguments[0]?.classType) |
| } |
| } |
| }) |
| """) |
| } |
| |
| public void testDelegateToArgument2() throws Throwable { |
| doCustomTest(""" |
| def ctx = context(scope: closureScope(isArgument: true)) |
| |
| contributor(ctx, { |
| def call = enclosingCall("boo") |
| if (call) { |
| delegatesTo(call.arguments[0]?.classType) |
| } |
| }) |
| """) |
| } |
| |
| public void testClassContext() throws Throwable { |
| addGdsl(""" |
| def ctx = context(scope: classScope(name: /.*WsSecurityConfig/)) |
| |
| contributor ctx, { |
| property name: "auxWsProperty", type: "java.lang.String" |
| } |
| """) |
| myFixture.testCompletionTyping(getTestName(false) + ".groovy", '\n', getTestName(false) + "_after.groovy") |
| } |
| |
| public void testCategoryWhenMethodRenamed() { |
| PsiClass category = myFixture.addClass(""" |
| public class MyCategory { |
| public void foo(String s) {} |
| }""") |
| def foo = category.getMethods()[0] |
| addGdsl(""" |
| contributor([:]){category 'MyCategory'}""") |
| myFixture.renameElement foo, "bar", false, false |
| |
| myFixture.testCompletion(getTestName(false) + ".groovy", getTestName(false) + "_after.groovy") |
| } |
| |
| public void testPathRegexp() { |
| addGdsl "contributor(pathRegexp: '.*aaa.*') { property name:'fffooo', type:'int' }" |
| |
| myFixture.configureFromExistingVirtualFile myFixture.addFileToProject("aaa/foo.groovy", "fff<caret>x").virtualFile |
| myFixture.completeBasic() |
| assert 'fffooo' in myFixture.lookupElementStrings |
| |
| myFixture.configureFromExistingVirtualFile myFixture.addFileToProject("bbb/foo.groovy", "fff<caret>x").virtualFile |
| myFixture.completeBasic() |
| assertEmpty myFixture.lookupElementStrings |
| } |
| |
| public void testNamedParameters() { |
| addGdsl '''contribute(currentType(String.name)) { |
| method name:'foo', type:void, params:[:], namedParams:[ |
| parameter(name:'param1', type:String), |
| parameter(name:'param2', type:Integer), |
| ] |
| }''' |
| myFixture.configureByText 'a.groovy', '"".foo(par<caret>)' |
| myFixture.completeBasic() |
| myFixture.assertPreferredCompletionItems 0, 'param1', 'param2' |
| } |
| |
| public void testNamedParametersGroovyConvention() { |
| addGdsl '''contribute(currentType(String.name)) { |
| method name:'foo', type:void, params:[args:[ |
| parameter(name:'param1', type:String, doc:'My doc'), |
| parameter(name:'param2', type:Integer), |
| ]] |
| }''' |
| myFixture.configureByText 'a.groovy', '"".foo(par<caret>)' |
| myFixture.completeBasic() |
| myFixture.assertPreferredCompletionItems 0, 'param1', 'param2' |
| assert '<pre><b>param1</b>: java.lang.String</pre><p>My doc' == generateDoc() |
| } |
| |
| private String generateDoc() { |
| def element = DocumentationManager.getInstance(project).findTargetElement(myFixture.editor, myFixture.file) |
| return new GroovyDocumentationProvider().generateDoc(element, null) |
| } |
| |
| public void testCheckNamedArgumentTypes() { |
| addGdsl '''contribute(currentType(String.name)) { |
| method name:'foo', type:void, params:[args:[ |
| parameter(name:'param1', type:File), |
| parameter(name:'param2', type:Integer), |
| ]] |
| }''' |
| myFixture.configureByText 'a.groovy', ''' |
| "".foo(param1:<warning descr="Type of argument 'param1' can not be 'Integer'">2</warning>, param2:2) |
| ''' |
| myFixture.enableInspections(new GroovyAssignabilityCheckInspection()) |
| myFixture.checkHighlighting(true, false, false) |
| } |
| |
| public void testMethodDoc() { |
| addGdsl '''contribute(currentType(String.name)) { |
| method name:'foo', type:void, params:[:], doc:'Some doc' |
| }''' |
| myFixture.configureByText 'a.groovy', '"".fo<caret>o' |
| myFixture.completeBasic() |
| assert generateDoc().contains('Some doc') |
| assert generateDoc().contains('foo') |
| assert generateDoc().contains('()') |
| } |
| |
| public void testPropertyDoc() { |
| addGdsl '''contribute(currentType(String.name)) { |
| property name:'foo', type:int, doc:'Some doc2' |
| }''' |
| myFixture.configureByText 'a.groovy', '"".fo<caret>o' |
| myFixture.completeBasic() |
| assert generateDoc().contains('Some doc2') |
| assert generateDoc().contains('getFoo') |
| } |
| |
| public void testVariableInAnnotationClosureContext() { |
| addGdsl ''' |
| contributor(scope: closureScope(annotationName:'Ensures')) { |
| variable(name: 'result', type:'java.lang.Object') |
| } |
| ''' |
| |
| myFixture.configureByText('a.groovy', '''\ |
| @interface Ensures {} |
| |
| @Ensures({re<caret>sult == 2}) |
| def foo() {} |
| ''') |
| |
| assertNotNull(myFixture.getReferenceAtCaretPosition().resolve()) |
| } |
| |
| public void testVariableInMethodCallClosureContext() { |
| addGdsl ''' |
| contributor(scope: closureScope(methodName:'ensures')) { |
| variable(name: 'result', type:'java.lang.Object') |
| } |
| ''' |
| |
| myFixture.configureByText('a.groovy', '''\ |
| ensures{re<caret>sult == 2} |
| ''') |
| |
| assertNotNull(myFixture.getReferenceAtCaretPosition().resolve()) |
| } |
| |
| void testScriptSuperClass() { |
| myFixture.addClass('''\ |
| public class Abc { |
| public void foo() {} |
| } |
| ''') |
| addGdsl(''' |
| scriptSuperClass(pattern: 'a.groovy', superClass: 'Abc') |
| ''') |
| |
| myFixture.configureByText('a.groovy', '''\ |
| fo<caret>o() |
| ''') |
| |
| assertNotNull(myFixture.getReferenceAtCaretPosition().resolve()) |
| } |
| |
| void testEnumConstructor() { |
| myFixture.configureByText('a.groovy', '''\ |
| enum Myenum { |
| a<caret>b(1, 2, 4) |
| } |
| ''') |
| |
| addGdsl(''' |
| contribute(currentType("Myenum")) { |
| constructor params:[foo:Integer, bar:Integer, goo:Integer] |
| }''') |
| assertNotNull(myFixture.getReferenceAtCaretPosition().resolve()) |
| } |
| } |