design/designer-base/src/test/java/com/fr/plugin/designer/toolbar/TemplateTransformerTest.java

package com.fr.plugin.designer.toolbar;

import com.fr.base.FRContext;
import com.fr.base.operator.common.CommonOperator;
import com.fr.file.FILE;
import com.fr.file.filetree.FileNodes;
import com.fr.invoke.Reflect;
import org.easymock.EasyMock;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.powermock.api.easymock.PowerMock;
import org.powermock.core.classloader.annotations.PowerMockIgnore;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;

import static com.fr.plugin.designer.toolbar.TemplateTransformer.OTHER;
import static com.fr.plugin.designer.toolbar.TemplateTransformer.TO_CPT;
import static com.fr.plugin.designer.toolbar.TemplateTransformer.TO_CPTX;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;

@RunWith(PowerMockRunner.class)
@PrepareForTest({FRContext.class})
@PowerMockIgnore({"sun.tools.attach.*", "com.sun.tools.*", "com.fr.license.*"})
public class TemplateTransformerTest {

    @Test
    public void testParse() {
        assertEquals(TO_CPTX, TemplateTransformer.parse("/sdf/abc.cpt"));
        assertEquals(TO_CPT, TemplateTransformer.parse("/sdf/abc.cptx"));
        assertEquals(OTHER, TemplateTransformer.parse("/sdf/abc.frm"));
        assertEquals(OTHER, TemplateTransformer.parse(null));
        assertEquals(OTHER, TemplateTransformer.parse("abc"));
    }

    @Test
    public void testCompileFailed() {
        TransformResultInfo result = TemplateTransformer.compileCPTX(null, null);
        assertEquals(result.getResult(), TransformResult.FAILED);
    }

    @Test
    public void testGenerateNewPath() {
        assertEquals(generateNewPath("/abc/dd.cpt", ".cpt", ".cptx"), "/abc/dd.cptx");
        assertEquals(generateNewPath("/abc/dd.cptx", ".cpt", ".cptx"), "/abc/dd.cptx");
        assertEquals(generateNewPath("/abc/dd.cptx", ".cptx", ".cpt"), "/abc/dd.cpt");
        assertEquals(generateNewPath("/abc/dd.frm", ".cpt", ".cptx"), "/abc/dd.frm");
        assertNull(generateNewPath(null, null, null));
        assertEquals(generateNewPath("abc", null, null), "abc");
    }

    private String generateNewPath(String oldPath, String oldSuffix, String newSuffix) {
        return Reflect.on(TemplateTransformer.class).call("generateNewPath", oldPath, oldSuffix, newSuffix).get();
    }

    @Test
    public void testCreateOutputFile() {
        CommonOperator commonOperator = EasyMock.mock(CommonOperator.class);
        FileNodes fileNodes = EasyMock.mock(FileNodes.class);
        EasyMock.expect(fileNodes.getSupportedTypes()).andReturn(new String[]{"cptx"}).anyTimes();
        PowerMock.mockStatic(FRContext.class);
        EasyMock.expect(FRContext.getCommonOperator()).andReturn(commonOperator).anyTimes();
        EasyMock.expect(FRContext.getFileNodes()).andReturn(fileNodes).anyTimes();
        EasyMock.expect(commonOperator.getWebRootPath()).andReturn("/WebInf/").anyTimes();
        EasyMock.replay(commonOperator, fileNodes);
        PowerMock.replayAll();
        FILE file1 = TemplateTransformer.createOutputFile("WorkBook1.cpt", ".cpt", ".cptx");
        FILE file2 = TemplateTransformer.createOutputFile("WorkBook1.cpt", ".cptx", ".cpt");
        assertEquals("WorkBook1.cptx", file1.getPath());
        assertEquals("WorkBook1.cpt", file2.getPath());
    }


    @Test
    public void testNeedDoAfterTransformed() {
        Assert.assertTrue(needDoAfterTransformed(TransformResult.SUCCESS));
        Assert.assertTrue(needDoAfterTransformed(TransformResult.UNSUPPORT));
        Assert.assertFalse(needDoAfterTransformed(TransformResult.FAILED));
    }

    private boolean needDoAfterTransformed(TransformResult result) {
        return Reflect.on(TemplateTransformer.class).call("needDoAfterTransformed", result).get();
    }
}