com.smartitengineering.cms.spi.impl.content.GroovyGeneratorTest.java Source code

Java tutorial

Introduction

Here is the source code for com.smartitengineering.cms.spi.impl.content.GroovyGeneratorTest.java

Source

/*
 *
 * This is a simple Content Management System (CMS)
 * Copyright (C) 2010  Imran M Yousuf (imyousuf@smartitengineering.com)
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
package com.smartitengineering.cms.spi.impl.content;

import com.smartitengineering.cms.api.common.TemplateType;
import com.smartitengineering.cms.api.content.Content;
import com.smartitengineering.cms.api.content.ContentId;
import com.smartitengineering.cms.api.content.Field;
import com.smartitengineering.cms.api.content.FieldValue;
import com.smartitengineering.cms.api.content.Representation;
import com.smartitengineering.cms.api.content.Variation;
import com.smartitengineering.cms.api.factory.SmartContentAPI;
import com.smartitengineering.cms.api.factory.content.ContentLoader;
import com.smartitengineering.cms.api.factory.workspace.WorkspaceAPI;
import com.smartitengineering.cms.api.impl.content.RepresentationImpl;
import com.smartitengineering.cms.api.impl.content.VariationImpl;
import com.smartitengineering.cms.api.impl.workspace.WorkspaceAPIImpl;
import com.smartitengineering.cms.api.type.ContentType;
import com.smartitengineering.cms.api.type.FieldDef;
import com.smartitengineering.cms.api.type.RepresentationDef;
import com.smartitengineering.cms.api.type.ResourceUri;
import com.smartitengineering.cms.api.type.ValidatorDef;
import com.smartitengineering.cms.api.type.ValidatorType;
import com.smartitengineering.cms.api.type.VariationDef;
import com.smartitengineering.cms.api.workspace.RepresentationTemplate;
import com.smartitengineering.cms.api.workspace.ValidatorTemplate;
import com.smartitengineering.cms.api.workspace.VariationTemplate;
import com.smartitengineering.cms.api.workspace.WorkspaceId;
import com.smartitengineering.cms.spi.content.RepresentationProvider;
import com.smartitengineering.cms.spi.content.ValidatorProvider;
import com.smartitengineering.cms.spi.content.VariationProvider;
import com.smartitengineering.cms.spi.content.template.TypeFieldValidator;
import com.smartitengineering.cms.spi.content.template.TypeRepresentationGenerator;
import com.smartitengineering.cms.spi.content.template.TypeVariationGenerator;
import com.smartitengineering.cms.spi.impl.content.VelocityGeneratorTest.Threads;
import com.smartitengineering.cms.spi.impl.content.template.GroovyRepresentationGenerator;
import com.smartitengineering.cms.spi.impl.content.template.GroovyValidatorGenerator;
import com.smartitengineering.cms.spi.impl.content.template.GroovyVariationGenerator;
import com.smartitengineering.util.bean.BeanFactoryRegistrar;
import com.smartitengineering.util.bean.SimpleBeanFactory;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Set;
import java.util.concurrent.atomic.AtomicInteger;
import org.apache.commons.codec.binary.StringUtils;
import org.apache.commons.io.IOUtils;
import org.jmock.Expectations;
import org.jmock.Mockery;
import org.jmock.integration.junit3.JUnit3Mockery;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 *
 * @author imyousuf
 */
public class GroovyGeneratorTest {

    public static final String CONTENT = "content";
    private Mockery mockery;
    public static final String REP_NAME = "test";
    public static final String MIME_TYPE = "application/json";
    private final transient Logger logger = LoggerFactory.getLogger(getClass());

    @Before
    public void setupAPIAndSPI() throws ClassNotFoundException {
        mockery = new JUnit3Mockery();
        setupAPI(mockery);
    }

    public static void setupAPI(final Mockery mockery) throws ClassNotFoundException {
        final ContentLoader mock = mockery.mock(ContentLoader.class);
        mockery.checking(new Expectations() {

            {
                allowing(mock)
                        .createMutableRepresentation(this.<ContentId>with(Expectations.<ContentId>anything()));
                will(returnValue(new RepresentationImpl(null)));
                allowing(mock).createMutableVariation(this.<ContentId>with(Expectations.<ContentId>anything()),
                        this.<FieldDef>with(Expectations.<FieldDef>anything()));
                will(returnValue(new VariationImpl(null, null)));
            }
        });
        SimpleBeanFactory simpleBeanFactory = new SimpleBeanFactory(
                Collections.<String, Object>singletonMap("apiContentLoader", mock));
        BeanFactoryRegistrar.registerBeanFactory(SmartContentAPI.CONTEXT_NAME, simpleBeanFactory);
    }

    @Test
    public void testGroovyRepGeneration() throws IOException {
        TypeRepresentationGenerator generator = new GroovyRepresentationGenerator();
        final RepresentationTemplate template = mockery.mock(RepresentationTemplate.class);
        WorkspaceAPIImpl impl = new WorkspaceAPIImpl() {

            @Override
            public RepresentationTemplate getRepresentationTemplate(WorkspaceId id, String name) {
                return template;
            }
        };
        impl.setRepresentationGenerators(Collections.singletonMap(TemplateType.GROOVY, generator));
        RepresentationProvider provider = new RepresentationProviderImpl();
        final WorkspaceAPI api = impl;
        registerBeanFactory(api);
        final Content content = mockery.mock(Content.class);
        final Field field = mockery.mock(Field.class);
        final FieldValue value = mockery.mock(FieldValue.class);
        final ContentType type = mockery.mock(ContentType.class);
        final Map<String, RepresentationDef> reps = mockery.mock(Map.class, "repMap");
        final RepresentationDef def = mockery.mock(RepresentationDef.class);
        mockery.checking(new Expectations() {

            {
                exactly(1).of(template).getTemplateType();
                will(returnValue(TemplateType.GROOVY));
                exactly(1).of(template).getTemplate();
                will(returnValue(IOUtils.toByteArray(getClass().getClassLoader()
                        .getResourceAsStream("scripts/groovy/GroovyTestRepresentationGenerator.groovy"))));
                exactly(1).of(template).getName();
                will(returnValue(REP_NAME));
                exactly(1).of(value).getValue();
                will(returnValue(CONTENT));
                exactly(1).of(field).getValue();
                will(returnValue(value));
                exactly(1).of(content).getField(this.<String>with(Expectations.<String>anything()));
                will(returnValue(field));
                exactly(1).of(content).getContentDefinition();
                will(returnValue(type));
                final ContentId contentId = mockery.mock(ContentId.class);
                exactly(2).of(content).getContentId();
                will(returnValue(contentId));
                final WorkspaceId wId = mockery.mock(WorkspaceId.class);
                exactly(1).of(contentId).getWorkspaceId();
                will(returnValue(wId));
                exactly(2).of(type).getRepresentationDefs();
                will(returnValue(reps));
                exactly(2).of(reps).get(with(REP_NAME));
                will(returnValue(def));
                exactly(1).of(def).getParameters();
                will(returnValue(Collections.emptyMap()));
                exactly(1).of(def).getMIMEType();
                will(returnValue(GroovyGeneratorTest.MIME_TYPE));
                final ResourceUri rUri = mockery.mock(ResourceUri.class);
                exactly(1).of(def).getResourceUri();
                will(returnValue(rUri));
                exactly(1).of(rUri).getValue();
                will(returnValue("iUri"));
            }
        });
        Representation representation = provider.getRepresentation(REP_NAME, type, content);
        Assert.assertNotNull(representation);
        Assert.assertEquals(REP_NAME, representation.getName());
        Assert.assertEquals(GroovyGeneratorTest.MIME_TYPE, representation.getMimeType());
        Assert.assertEquals(CONTENT, StringUtils.newStringUtf8(representation.getRepresentation()));
    }

    protected void registerBeanFactory(final WorkspaceAPI api) {
        try {
            SmartContentAPI mainApi = SmartContentAPI.getInstance();
            Class apiClass = mainApi.getClass();
            java.lang.reflect.Field field = apiClass.getDeclaredField("workspaceApi");
            field.setAccessible(true);
            field.set(mainApi, api);
        } catch (Exception ex) {
            throw new IllegalArgumentException(ex);
        }
    }

    @Test
    public void testGroovyVarGeneration() throws IOException {
        TypeVariationGenerator generator = new GroovyVariationGenerator();
        final VariationTemplate template = mockery.mock(VariationTemplate.class);
        WorkspaceAPIImpl impl = new WorkspaceAPIImpl() {

            @Override
            public VariationTemplate getVariationTemplate(WorkspaceId id, String name) {
                return template;
            }
        };
        impl.setVariationGenerators(Collections.singletonMap(TemplateType.GROOVY, generator));
        VariationProvider provider = new VariationProviderImpl();
        registerBeanFactory(impl);
        final Field field = mockery.mock(Field.class, "varField");
        final FieldValue value = mockery.mock(FieldValue.class, "varFieldVal");
        final Content content = mockery.mock(Content.class, "varContent");
        final FieldDef fieldDef = mockery.mock(FieldDef.class);
        final Map<String, VariationDef> vars = mockery.mock(Map.class, "varMap");
        final VariationDef def = mockery.mock(VariationDef.class);
        mockery.checking(new Expectations() {

            {
                exactly(1).of(template).getTemplateType();
                will(returnValue(TemplateType.GROOVY));
                exactly(1).of(template).getTemplate();
                will(returnValue(IOUtils.toByteArray(getClass().getClassLoader()
                        .getResourceAsStream("scripts/groovy/GroovyTestVariationGenerator.groovy"))));
                exactly(1).of(template).getName();
                will(returnValue(REP_NAME));
                exactly(1).of(value).getValue();
                will(returnValue(CONTENT));
                exactly(1).of(field).getValue();
                will(returnValue(value));
                exactly(1).of(field).getFieldDef();
                will(returnValue(fieldDef));
                final ContentId contentId = mockery.mock(ContentId.class, "varId");
                exactly(2).of(content).getContentId();
                will(returnValue(contentId));
                final WorkspaceId wId = mockery.mock(WorkspaceId.class, "varWId");
                exactly(1).of(contentId).getWorkspaceId();
                will(returnValue(wId));
                exactly(1).of(fieldDef).getVariations();
                will(returnValue(vars));
                exactly(1).of(vars).get(with(REP_NAME));
                will(returnValue(def));
                exactly(1).of(def).getParameters();
                will(returnValue(Collections.emptyMap()));
                exactly(1).of(def).getMIMEType();
                will(returnValue(GroovyGeneratorTest.MIME_TYPE));
                final ResourceUri rUri = mockery.mock(ResourceUri.class, "varRUri");
                exactly(1).of(def).getResourceUri();
                will(returnValue(rUri));
                exactly(1).of(rUri).getValue();
                will(returnValue("iUri"));
            }
        });
        Variation representation = provider.getVariation(REP_NAME, content, field);
        Assert.assertNotNull(representation);
        Assert.assertEquals(REP_NAME, representation.getName());
        Assert.assertEquals(GroovyGeneratorTest.MIME_TYPE, representation.getMimeType());
        Assert.assertEquals(CONTENT, StringUtils.newStringUtf8(representation.getVariation()));
    }

    @Test
    public void testGroovyValGeneration() throws IOException {
        TypeFieldValidator generator = new GroovyValidatorGenerator();
        final ValidatorTemplate template = mockery.mock(ValidatorTemplate.class);
        WorkspaceAPIImpl impl = new WorkspaceAPIImpl() {

            @Override
            public ValidatorTemplate getValidatorTemplate(WorkspaceId workspaceId, String name) {
                return template;
            }
        };
        impl.setValidatorGenerators(Collections.singletonMap(ValidatorType.GROOVY, generator));
        ValidatorProvider provider = new ValidatorProviderImpl();
        registerBeanFactory(impl);
        final Content content = mockery.mock(Content.class, "valContent");
        final Field field = mockery.mock(Field.class, "valField");
        final FieldValue value = mockery.mock(FieldValue.class, "valFieldVal");
        mockery.checking(new Expectations() {

            {
                exactly(1).of(template).getTemplate();
                will(returnValue(IOUtils.toByteArray(getClass().getClassLoader()
                        .getResourceAsStream("scripts/groovy/GroovyTestValidatorGenerator.groovy"))));
                exactly(1).of(value).getValue();
                will(returnValue(CONTENT));
                exactly(1).of(field).getValue();
                will(returnValue(value));
                FieldDef fieldDef = mockery.mock(FieldDef.class, "valFieldDef");
                exactly(1).of(field).getFieldDef();
                will(returnValue(fieldDef));
                ValidatorDef valDef = mockery.mock(ValidatorDef.class, "valDef");
                exactly(1).of(fieldDef).getCustomValidators();
                will(returnValue(Collections.singleton(valDef)));
                exactly(1).of(field).getName();
                will(returnValue(REP_NAME));
                final ResourceUri rUri = mockery.mock(ResourceUri.class, "valRUri");
                exactly(1).of(valDef).getUri();
                will(returnValue(rUri));
                exactly(1).of(rUri).getValue();
                will(returnValue("iUri"));
                exactly(1).of(rUri).getType();
                will(returnValue(ResourceUri.Type.INTERNAL));
                final ContentId contentId = mockery.mock(ContentId.class, "valContentId");
                exactly(1).of(content).getContentId();
                will(returnValue(contentId));
                final WorkspaceId wId = mockery.mock(WorkspaceId.class, "valWId");
                exactly(1).of(contentId).getWorkspaceId();
                will(returnValue(wId));
                exactly(1).of(template).getTemplateType();
                will(returnValue(ValidatorType.GROOVY));
                exactly(1).of(valDef).getParameters();
                will(returnValue(Collections.emptyMap()));
            }
        });
        Assert.assertFalse(provider.isValidField(content, field));
    }

    @Test
    public void testMultiGroovyRepGeneration() throws IOException {
        TypeRepresentationGenerator generator = new GroovyRepresentationGenerator();
        final RepresentationTemplate template = mockery.mock(RepresentationTemplate.class);
        WorkspaceAPIImpl impl = new WorkspaceAPIImpl() {

            @Override
            public RepresentationTemplate getRepresentationTemplate(WorkspaceId id, String name) {
                return template;
            }
        };
        impl.setRepresentationGenerators(Collections.singletonMap(TemplateType.GROOVY, generator));
        final RepresentationProvider provider = new RepresentationProviderImpl();
        final WorkspaceAPI api = impl;
        registerBeanFactory(api);
        final Content content = mockery.mock(Content.class);
        final Field field = mockery.mock(Field.class);
        final FieldValue value = mockery.mock(FieldValue.class);
        final ContentType type = mockery.mock(ContentType.class);
        final Map<String, RepresentationDef> reps = mockery.mock(Map.class, "repMap");
        final RepresentationDef def = mockery.mock(RepresentationDef.class);
        final int threadCount = new Random().nextInt(100);
        logger.info("Number of parallel threads " + threadCount);
        mockery.checking(new Expectations() {

            {
                exactly(threadCount).of(template).getTemplateType();
                will(returnValue(TemplateType.GROOVY));
                exactly(threadCount).of(template).getTemplate();
                final byte[] toByteArray = IOUtils.toByteArray(getClass().getClassLoader()
                        .getResourceAsStream("scripts/groovy/GroovyTestRepresentationGenerator.groovy"));
                will(returnValue(toByteArray));
                exactly(threadCount).of(template).getName();
                will(returnValue(REP_NAME));
                for (int i = 0; i < threadCount; ++i) {
                    exactly(1).of(value).getValue();
                    will(returnValue(String.valueOf(i)));
                }
                exactly(threadCount).of(field).getValue();
                will(returnValue(value));
                exactly(threadCount).of(content).getField(with(Expectations.<String>anything()));
                will(returnValue(field));
                exactly(threadCount).of(content).getContentDefinition();
                will(returnValue(type));
                final ContentId contentId = mockery.mock(ContentId.class);
                exactly(2 * threadCount).of(content).getContentId();
                will(returnValue(contentId));
                final WorkspaceId wId = mockery.mock(WorkspaceId.class);
                exactly(threadCount).of(contentId).getWorkspaceId();
                will(returnValue(wId));
                exactly(2 * threadCount).of(type).getRepresentationDefs();
                will(returnValue(reps));
                exactly(2 * threadCount).of(reps).get(with(REP_NAME));
                will(returnValue(def));
                exactly(threadCount).of(def).getParameters();
                will(returnValue(Collections.emptyMap()));
                exactly(threadCount).of(def).getMIMEType();
                will(returnValue(GroovyGeneratorTest.MIME_TYPE));
                final ResourceUri rUri = mockery.mock(ResourceUri.class);
                exactly(threadCount).of(def).getResourceUri();
                will(returnValue(rUri));
                exactly(threadCount).of(rUri).getValue();
                will(returnValue("iUri"));
            }
        });
        final Set<String> set = Collections.synchronizedSet(new LinkedHashSet<String>(threadCount));
        final List<String> list = Collections.synchronizedList(new ArrayList<String>(threadCount));
        final AtomicInteger integer = new AtomicInteger(0);
        Threads group = new Threads();
        for (int i = 0; i < threadCount; ++i) {
            group.addThread(new Thread(new Runnable() {

                public void run() {
                    Representation representation = provider.getRepresentation(REP_NAME, type, content);
                    Assert.assertNotNull(representation);
                    Assert.assertEquals(REP_NAME, representation.getName());
                    final String rep = StringUtils.newStringUtf8(representation.getRepresentation());
                    list.add(rep);
                    set.add(rep);
                    Assert.assertEquals(GroovyGeneratorTest.MIME_TYPE, representation.getMimeType());
                    integer.addAndGet(1);
                }
            }));
        }
        group.start();
        try {
            group.join();
        } catch (Exception ex) {
            logger.error(ex.getMessage(), ex);
        }
        logger.info("Generated reps list: " + list);
        logger.info("Generated reps set: " + set);
        Assert.assertEquals(threadCount, integer.get());
        Assert.assertEquals(threadCount, list.size());
        Assert.assertEquals(threadCount, set.size());
    }
}