/doclet/src/test/java/com/atlassian/developer/calliope/doclet/WikiMarkupReferenceRendererTest.java

package com.atlassian.developer.calliope.doclet;

import com.atlassian.developer.calliope.javadoc.Traversal;

import com.sun.javadoc.AnnotationDesc;
import com.sun.javadoc.AnnotationDesc.ElementValuePair;
import com.sun.javadoc.AnnotationTypeDoc;
import com.sun.javadoc.AnnotationTypeElementDoc;
import com.sun.javadoc.AnnotationValue;
import com.sun.javadoc.ClassDoc;
import com.sun.javadoc.ConstructorDoc;
import com.sun.javadoc.FieldDoc;
import com.sun.javadoc.MemberDoc;
import com.sun.javadoc.MethodDoc;
import com.sun.javadoc.PackageDoc;
import com.sun.javadoc.ProgramElementDoc;
import com.sun.javadoc.Type;
import com.sun.javadoc.TypeVariable;

import org.junit.Test;

import static com.atlassian.developer.calliope.doclet.impl.RendererMatcher.rendered;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

public class WikiMarkupReferenceRendererTest
{
    @Test public void assertThatAnnotationDescRenders()
    {
        AnnotationDesc node = mock(AnnotationDesc.class);

        AnnotationTypeDoc annotationType = mock(AnnotationTypeDoc.class);
        when(node.annotationType()).thenReturn(annotationType);
        when(annotationType.simpleTypeName()).thenReturn("Test");
        when(annotationType.qualifiedTypeName()).thenReturn("com.atlassian.Test");

        ElementValuePair[] elementValues = new ElementValuePair[]
                { mock(ElementValuePair.class), mock(ElementValuePair.class) };
        when(node.elementValues()).thenReturn(elementValues);

        AnnotationTypeElementDoc[] elements = new AnnotationTypeElementDoc[]
                { mock(AnnotationTypeElementDoc.class), mock(AnnotationTypeElementDoc.class) };
        AnnotationValue[] values = new AnnotationValue[]
                { mock(AnnotationValue.class), mock(AnnotationValue.class) };

        when(elementValues[0].element()).thenReturn(elements[0]);
        when(elementValues[0].value()).thenReturn(values[0]);
        when(elements[0].name()).thenReturn("element0");
        when(elements[0].containingClass()).thenReturn(annotationType);
        when(values[0].toString()).thenReturn("value0");

        when(elementValues[1].element()).thenReturn(elements[1]);
        when(elementValues[1].value()).thenReturn(values[1]);
        when(elements[1].name()).thenReturn("element1");
        when(elements[1].containingClass()).thenReturn(annotationType);
        when(values[1].toString()).thenReturn("value1");

        qualify(annotationType, elements[0], elements[1]);
        assertThat(traverse(node), rendered(node, "@[Test|com.atlassian.Test]([element0|com.atlassian.Test#element0] = value0, [element1|com.atlassian.Test#element1] = value1)"));
    }

    @Test public void assertThatAnnotationTypeDocRenders()
    {
        assertThatClassDocSubtypeRenders(AnnotationTypeDoc.class);
    }

    @Test public void assertThatAnnotationTypeElementDocRenders()
    {
        assertThatMemberDocSubtypeRenders(AnnotationTypeElementDoc.class);
    }

    @Test public void assertThatClassDocRenders()
    {
        assertThatClassDocSubtypeRenders(ClassDoc.class);
    }

    @Test public void assertThatConstructorDocRenders()
    {
        assertThatMemberDocSubtypeRenders(ConstructorDoc.class);
    }

    @Test public void assertThatFieldDocRenders()
    {
        assertThatMemberDocSubtypeRenders(FieldDoc.class);
    }

    @Test public void assertThatMethodDocRenders()
    {
        assertThatMemberDocSubtypeRenders(MethodDoc.class);
    }

    @Test public void assertThatPackageDocRenders()
    {
        PackageDoc node = mock(PackageDoc.class);
        when(node.name()).thenReturn("com.atlassian.test");

        assertThat(traverse(node), rendered(node, "[com.atlassian.test]"));
    }

    @Test public void assertThatTypeRenders()
    {
        Type node = mock(Type.class);
        when(node.simpleTypeName()).thenReturn("T");

        assertThat(traverse(node), rendered(node, "T"));
    }

    @Test public void assertThatTypeVariableRenders()
    {
        TypeVariable node = mock(TypeVariable.class);
        when(node.simpleTypeName()).thenReturn("T");

        assertThat(traverse(node), rendered(node, "T"));
    }

    private static <T extends ClassDoc> void assertThatClassDocSubtypeRenders(Class<T> clazz)
    {
        T node = mock(clazz);
        when(node.simpleTypeName()).thenReturn("Test");
        when(node.qualifiedTypeName()).thenReturn("com.atlassian.Test");

        qualify(node);
        assertThat(traverse(node), rendered(node, "[Test|com.atlassian.Test]"));
    }

    private static <T extends MemberDoc> void assertThatMemberDocSubtypeRenders(Class<T> clazz)
    {
        T node = mock(clazz);
        when(node.name()).thenReturn("test");

        ClassDoc containingClass = mock(ClassDoc.class);
        when(node.containingClass()).thenReturn(containingClass);
        when(containingClass.qualifiedTypeName()).thenReturn("com.atlassian.Test");

        qualify(node, containingClass);
        assertThat(traverse(node), rendered(node, "[test|com.atlassian.Test#test]"));
    }

    private static WikiMarkupReferenceRenderer traverse(Object node)
    {
        WikiMarkupReferenceRenderer renderer = new WikiMarkupReferenceRenderer();
        Traversal.traverse(node, renderer);
        return renderer;
    }

    private static void qualify(ProgramElementDoc... nodes)
    {
        for (ProgramElementDoc node : nodes)
        {
            PackageDoc containingPackage = mock(PackageDoc.class);
            when(containingPackage.name()).thenReturn("com.atlassian");
            when(node.containingPackage()).thenReturn(containingPackage);
        }
    }
}