EventConsumerTest.java

/*
 *
 * This is a simple Content Management System (CMS)
 * Copyright (C) 2012  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.events;

import com.google.inject.AbstractModule;
import com.google.inject.Guice;
import com.google.inject.Injector;
import com.google.inject.TypeLiteral;
import com.google.inject.name.Names;
import com.smartitengineering.cms.api.content.Content;
import com.smartitengineering.cms.api.content.ContentId;
import com.smartitengineering.cms.api.event.Event;
import com.smartitengineering.cms.api.event.Event.EventType;
import com.smartitengineering.cms.api.event.Event.Type;
import com.smartitengineering.cms.api.event.EventListener;
import com.smartitengineering.cms.api.factory.SmartContentAPI;
import com.smartitengineering.cms.api.factory.content.ContentLoader;
import com.smartitengineering.cms.api.factory.event.EventRegistrar;
import com.smartitengineering.cms.api.factory.type.ContentTypeLoader;
import com.smartitengineering.cms.api.factory.workspace.WorkspaceAPI;
import com.smartitengineering.cms.api.type.ContentType;
import com.smartitengineering.cms.api.type.ContentTypeId;
import com.smartitengineering.cms.api.workspace.Sequence;
import com.smartitengineering.cms.api.workspace.SequenceId;
import com.smartitengineering.cms.api.workspace.WorkspaceId;
import com.smartitengineering.cms.spi.SmartContentSPI;
import com.smartitengineering.cms.spi.lock.LockHandler;
import com.smartitengineering.dao.solr.SolrWriteDao;
import com.smartitengineering.events.async.api.EventConsumer;
import com.smartitengineering.util.bean.BeanFactoryRegistrar;
import com.smartitengineering.util.bean.guice.GoogleGuiceBeanFactory;
import java.lang.reflect.Field;
import java.util.Arrays;
import org.apache.commons.codec.binary.Base64;
import org.apache.commons.codec.binary.StringUtils;
import org.hamcrest.BaseMatcher;
import org.hamcrest.Description;
import org.jmock.Expectations;
import org.jmock.Mockery;
import org.junit.Before;
import org.junit.Test;

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

  private final static String MSG_TYPE = "text/plain";
  private Mockery mockery;
  private EventListener<Content> contentListener;
  private EventListener<ContentType> contentTypeListener;
  private EventListener<Sequence> sequenceListener;
  private SolrWriteDao solrWriteDao;
  private ContentTypeLoader contentTypeLoader;
  private ContentLoader contentLoader;
  private WorkspaceAPI workspaceApi;
  private EventRegistrar eventRegistrar;
  private LockHandler lockHandler;
  private Injector injector;

  @Before
  public void setup() throws Exception {
    mockery = new Mockery();
    contentListener = mockery.mock(EventListener.class, "contentEventListener");
    contentTypeListener = mockery.mock(EventListener.class,
                                       "contentTypeEventListener");
    sequenceListener = mockery.mock(EventListener.class, "sequenceEventListener");
    solrWriteDao = mockery.mock(SolrWriteDao.class);
    contentTypeLoader = mockery.mock(ContentTypeLoader.class);
    contentLoader = mockery.mock(ContentLoader.class);
    workspaceApi = mockery.mock(WorkspaceAPI.class);
    eventRegistrar = mockery.mock(EventRegistrar.class);
    lockHandler = mockery.mock(LockHandler.class);
    injector = Guice.createInjector(new EventConsumptionImplModule());
    Field field = SmartContentAPI.class.getDeclaredField("api");
    field.setAccessible(true);
    field.set(null, null);
    field = SmartContentSPI.class.getDeclaredField("spi");
    field.setAccessible(true);
    field.set(null, null);
    final GoogleGuiceBeanFactory googleGuiceBeanFactory = new GoogleGuiceBeanFactory(true, injector);
    BeanFactoryRegistrar.registerBeanFactory(SmartContentAPI.CONTEXT_NAME, googleGuiceBeanFactory);
    BeanFactoryRegistrar.registerBeanFactory(SmartContentSPI.SPI_CONTEXT, googleGuiceBeanFactory);
  }

  @Test(expected = RuntimeException.class)
  public void testInvalidType() {
    mockery.checking(new Expectations() {

      {
      }
    });
    EventConsumer consumer = injector.getInstance(EventConsumer.class);
    consumer.consume(MSG_TYPE, "MY\nCREATE\n" + Base64.encodeBase64URLSafeString(StringUtils.getBytesUtf8(
        "random string\nfor test")));
    mockery.assertIsSatisfied();
  }

  @Test(expected = RuntimeException.class)
  public void testInvalidEventType() {
    mockery.checking(new Expectations() {

      {
      }
    });
    EventConsumer consumer = injector.getInstance(EventConsumer.class);
    consumer.consume(MSG_TYPE, "CONTENT\nCREATER\n" + Base64.encodeBase64URLSafeString(StringUtils.getBytesUtf8(
        "random string\nfor test")));
    mockery.assertIsSatisfied();
  }

  @Test
  public void testContentConsumption() {
    mockery.checking(new Expectations() {

      {
        exactly(1).of(workspaceApi).createWorkspaceId(EventPublisherTest.WORSPACE_NS, EventPublisherTest.WORKSPACE_NAME);
        final WorkspaceId wId = mockery.mock(WorkspaceId.class);
        will(returnValue(wId));
        exactly(1).of(contentLoader).createContentId(with(wId), with(new BaseMatcher<byte[]>() {

          public boolean matches(Object item) {
            return Arrays.equals(StringUtils.getBytesUtf8(EventPublisherTest.CONTENT_ID), (byte[]) item);
          }

          public void describeTo(Description description) {
          }
        }));
        final ContentId contentId = mockery.mock(ContentId.class);
        will(returnValue(contentId));
        exactly(1).of(contentId).getContent();
        final Content content = mockery.mock(Content.class);
        will(returnValue(content));
        exactly(1).of(eventRegistrar).createEvent(EventType.CREATE, Type.CONTENT, content);
        final Event<Content> event = mockery.mock(Event.class);
        will(returnValue(event));
        exactly(1).of(contentListener).notify(event);
      }
    });
    EventConsumer consumer = injector.getInstance(EventConsumer.class);
    consumer.consume(MSG_TYPE, EventPublisherTest.getContentMsg());
    mockery.assertIsSatisfied();
  }

  @Test
  public void testContentConsumptionWithInvalidMessage() {
    mockery.checking(new Expectations() {

      {
      }
    });
    EventConsumer consumer = injector.getInstance(EventConsumer.class);
    consumer.consume(MSG_TYPE, "CONTENT\nCREATE\n" + Base64.encodeBase64URLSafeString(StringUtils.getBytesUtf8(
        "random string\nfor test")));
    mockery.assertIsSatisfied();
  }

  @Test
  public void testContentIgnorance() {
    mockery.checking(new Expectations() {

      {
        exactly(1).of(workspaceApi).createWorkspaceId(EventPublisherTest.WORSPACE_NS, EventPublisherTest.WORKSPACE_NAME);
        final WorkspaceId wId = mockery.mock(WorkspaceId.class);
        will(returnValue(wId));
        exactly(1).of(contentLoader).createContentId(with(wId), with(new BaseMatcher<byte[]>() {

          public boolean matches(Object item) {
            return Arrays.equals(StringUtils.getBytesUtf8(EventPublisherTest.CONTENT_ID), (byte[]) item);
          }

          public void describeTo(Description description) {
          }
        }));
        final ContentId contentId = mockery.mock(ContentId.class);
        will(returnValue(contentId));
        exactly(1).of(contentId).getContent();
        will(returnValue(null));
      }
    });
    EventConsumer consumer = injector.getInstance(EventConsumer.class);
    consumer.consume(MSG_TYPE, EventPublisherTest.getContentMsg());
    mockery.assertIsSatisfied();
  }

  @Test
  public void testContentTypeConsumption() {
    mockery.checking(new Expectations() {

      {
        exactly(1).of(workspaceApi).createWorkspaceId(EventPublisherTest.WORSPACE_NS, EventPublisherTest.WORKSPACE_NAME);
        final WorkspaceId wId = mockery.mock(WorkspaceId.class);
        will(returnValue(wId));
        exactly(1).of(contentTypeLoader).createContentTypeId(wId, EventPublisherTest.CONTENT_TYPE_NS,
                                                             EventPublisherTest.CONTENT_TYPE_NAME);
        final ContentTypeId typeId = mockery.mock(ContentTypeId.class);
        will(returnValue(typeId));
        exactly(1).of(typeId).getContentType();
        final ContentType type = mockery.mock(ContentType.class);
        will(returnValue(type));
        exactly(1).of(eventRegistrar).createEvent(EventType.CREATE, Type.CONTENT_TYPE, type);
        final Event<ContentType> event = mockery.mock(Event.class);
        will(returnValue(event));
        exactly(1).of(contentTypeListener).notify(event);
      }
    });
    EventConsumer consumer = injector.getInstance(EventConsumer.class);
    consumer.consume(MSG_TYPE, EventPublisherTest.getContentTypeMsg());
    mockery.assertIsSatisfied();
  }

  @Test
  public void testContentTypeConsumptionWithInvalidMessage() {
    mockery.checking(new Expectations() {

      {
      }
    });
    EventConsumer consumer = injector.getInstance(EventConsumer.class);
    consumer.consume(MSG_TYPE, "CONTENT_TYPE\nCREATE\n" + Base64.encodeBase64URLSafeString(StringUtils.getBytesUtf8(
        "random string\nfor test\nof content type")));
    mockery.assertIsSatisfied();
  }

  @Test
  public void testContentTypeIgnorance() {
    mockery.checking(new Expectations() {

      {
        exactly(1).of(workspaceApi).createWorkspaceId(EventPublisherTest.WORSPACE_NS, EventPublisherTest.WORKSPACE_NAME);
        final WorkspaceId wId = mockery.mock(WorkspaceId.class);
        will(returnValue(wId));
        exactly(1).of(contentTypeLoader).createContentTypeId(wId, EventPublisherTest.CONTENT_TYPE_NS,
                                                             EventPublisherTest.CONTENT_TYPE_NAME);
        final ContentTypeId typeId = mockery.mock(ContentTypeId.class);
        will(returnValue(typeId));
        exactly(1).of(typeId).getContentType();
        will(returnValue(null));
      }
    });
    EventConsumer consumer = injector.getInstance(EventConsumer.class);
    consumer.consume(MSG_TYPE, EventPublisherTest.getContentTypeMsg());
    mockery.assertIsSatisfied();
  }

  @Test
  public void testSequenceConsumption() {
    mockery.checking(new Expectations() {

      {
        exactly(1).of(workspaceApi).createWorkspaceId(EventPublisherTest.WORSPACE_NS, EventPublisherTest.WORKSPACE_NAME);
        final WorkspaceId wId = mockery.mock(WorkspaceId.class);
        will(returnValue(wId));
        exactly(1).of(workspaceApi).createSequenceId(wId, EventPublisherTest.SEQUENCE_NAME);
        final SequenceId seqId = mockery.mock(SequenceId.class);
        will(returnValue(seqId));
        exactly(1).of(seqId).getSequence();
        final Sequence sequence = mockery.mock(Sequence.class);
        will(returnValue(sequence));
        exactly(1).of(eventRegistrar).createEvent(EventType.CREATE, Type.SEQUENCE, sequence);
        final Event<Sequence> event = mockery.mock(Event.class);
        will(returnValue(event));
        exactly(1).of(sequenceListener).notify(event);
      }
    });
    EventConsumer consumer = injector.getInstance(EventConsumer.class);
    consumer.consume(MSG_TYPE, EventPublisherTest.getSequenceMsg());
    mockery.assertIsSatisfied();
  }

  @Test
  public void testSequenceConsumptionWithInvalidMessage() {
    mockery.checking(new Expectations() {

      {
      }
    });
    EventConsumer consumer = injector.getInstance(EventConsumer.class);
    consumer.consume(MSG_TYPE, "SEQUENCE\nCREATE\n" + Base64.encodeBase64URLSafeString(StringUtils.getBytesUtf8(
        "random string\nfor test")));
    mockery.assertIsSatisfied();
  }

  @Test
  public void testSequenceIgnorance() {
    mockery.checking(new Expectations() {

      {
        exactly(1).of(workspaceApi).createWorkspaceId(EventPublisherTest.WORSPACE_NS, EventPublisherTest.WORKSPACE_NAME);
        final WorkspaceId wId = mockery.mock(WorkspaceId.class);
        will(returnValue(wId));
        exactly(1).of(workspaceApi).createSequenceId(wId, EventPublisherTest.SEQUENCE_NAME);
        final SequenceId seqId = mockery.mock(SequenceId.class);
        will(returnValue(seqId));
        exactly(1).of(seqId).getSequence();
        will(returnValue(null));
      }
    });
    EventConsumer consumer = injector.getInstance(EventConsumer.class);
    consumer.consume(MSG_TYPE, EventPublisherTest.getSequenceMsg());
    mockery.assertIsSatisfied();
  }

  private final class EventConsumptionImplModule extends AbstractModule {

    @Override
    protected void configure() {
      bind(SolrWriteDao.class).toInstance(solrWriteDao);
      bind(new TypeLiteral<EventListener<Content>>() {
      }).toInstance(contentListener);
      bind(new TypeLiteral<EventListener<ContentType>>() {
      }).toInstance(contentTypeListener);
      bind(new TypeLiteral<EventListener<Sequence>>() {
      }).toInstance(sequenceListener);
      bind(EventConsumer.class).to(EventConsumerImpl.class);
      // For SmartContentAPI
      bind(ContentTypeLoader.class).annotatedWith(Names.named("apiContentTypeLoader")).toInstance(contentTypeLoader);
      bind(ContentLoader.class).annotatedWith(Names.named("apiContentLoader")).toInstance(contentLoader);
      bind(WorkspaceAPI.class).annotatedWith(Names.named("apiWorkspaceApi")).toInstance(workspaceApi);
      bind(EventRegistrar.class).annotatedWith(Names.named("apiEventRegistrar")).toInstance(eventRegistrar);
      bind(LockHandler.class).toInstance(lockHandler);
    }
  }
}