gemfire-core/src/test/java/com/gemstone/gemfire/cache30/CacheWriterTestCase.java

/*=========================================================================
 * Copyright (c) 2010-2014 Pivotal Software, Inc. All Rights Reserved.
 * This product is protected by U.S. and international copyright
 * and intellectual property laws. Pivotal products are covered by
 * one or more patents listed at http://www.pivotal.io/patents.
 *=========================================================================
 */
package com.gemstone.gemfire.cache30;

import com.gemstone.gemfire.cache.*;
//import com.gemstone.gemfire.cache.util.*;
//import java.util.*;

/**
 * An abstract class whose test methods test the functionality of
 * {@link CacheWriter}s that are invoked locally.
 *
 * @see MultiVMRegionTestCase#testRemoteCacheWriter
 *
 * @author David Whitlock
 *
 * @since 3.0
 */
public abstract class CacheWriterTestCase
  extends RegionAttributesTestCase {

  public CacheWriterTestCase(String name) {
    super(name);
  }

  ///////////////////////  Test Methods  ///////////////////////

  /**
   * Tests that the <code>CacheWriter</code> is called before an entry
   * is {@linkplain CacheWriter#beforeCreate created}.
   */
  public void testCacheWriterBeforeCreate() throws CacheException {
    String name = this.getUniqueName();
    final Object key = this.getUniqueName();
    final Object value = new Integer(42);
    final Object arg = "ARG";
    final String exception = "EXCEPTION";

    TestCacheWriter writer = new TestCacheWriter() {
        public void beforeCreate2(EntryEvent event)
          throws CacheWriterException {

          assertEquals(key, event.getKey());
          assertEquals(value, event.getNewValue());
          assertNull(event.getOldValue());
          assertTrue(event.getOperation().isCreate());
          assertFalse(event.getOperation().isLoad());
          assertFalse(event.getOperation().isLocalLoad());
          assertFalse(event.getOperation().isNetLoad());
          assertFalse(event.getOperation().isNetSearch());

          Object argument = event.getCallbackArgument();
          if (argument != null) {
            if (argument.equals(exception)) {
              String s = "Test CacheWriterException";
              throw new CacheWriterException(s);

            } else {
              assertEquals(arg, argument);
            }
          }
        }

        public void beforeDestroy2(EntryEvent event)
          throws CacheWriterException {
          // This method will get invoked when the region is populated
        }
      };

    AttributesFactory factory =
      new AttributesFactory(getRegionAttributes());
    factory.setCacheWriter(writer);
    Region region =
      createRegion(name, factory.create());

    region.create(key, value);
    assertTrue(writer.wasInvoked());
    region.destroy(key);
    assertTrue(writer.wasInvoked());

    region.put(key, value);
    assertTrue(writer.wasInvoked());
    region.destroy(key);
    assertTrue(writer.wasInvoked());

    region.create(key, value, arg);
    assertTrue(writer.wasInvoked());
    region.destroy(key);
    assertTrue(writer.wasInvoked());

    region.put(key, value, arg);
    assertTrue(writer.wasInvoked());
    region.destroy(key);
    assertTrue(writer.wasInvoked());

    try {
      region.create(key, value, exception);
      fail("Should have thrown a CacheWriterException");

    } catch (CacheWriterException ex) {
      // pass...
      assertTrue(writer.wasInvoked());
    }

    try {
      region.put(key, value, exception);
      fail("Should have thrown a CacheWriterException");

    } catch (CacheWriterException ex) {
      // pass...
      assertTrue(writer.wasInvoked());
    }

  }

  /**
   * Tests that the <code>CacheWriter</code> is called before an entry
   * is {@linkplain CacheWriter#beforeUpdate updated}.
   */
  public void testCacheWriterBeforeUpdate() throws CacheException {
    String name = this.getUniqueName();
    final Object key = this.getUniqueName();
    final Object oldValue = new Integer(42);
    final Object newValue = new Integer(43);
    final Object arg = "ARG";
    final String exception = "EXCEPTION";

    TestCacheWriter writer = new TestCacheWriter() {
        public void beforeCreate2(EntryEvent event)
          throws CacheWriterException {
          // This method will get invoked when the region is populated
        }

        public void beforeDestroy2(EntryEvent event)
          throws CacheWriterException {
          // This method will get invoked when the region is populated
        }

        public void beforeUpdate2(EntryEvent event)
          throws CacheWriterException {

          assertEquals(key, event.getKey());
          assertEquals(newValue, event.getNewValue());
          assertEquals(oldValue, event.getOldValue());
          assertTrue(event.getOperation().isUpdate());
          assertFalse(event.getOperation().isLoad());
          assertFalse(event.getOperation().isLocalLoad());
          assertFalse(event.getOperation().isNetLoad());
          assertFalse(event.getOperation().isNetSearch());

          Object argument = event.getCallbackArgument();
          if (argument != null) {
            if (argument.equals(exception)) {
              String s = "Test CacheWriterException";
              throw new CacheWriterException(s);

            } else {
              assertEquals(arg, argument);
            }
          }
        }
      };

    AttributesFactory factory =
      new AttributesFactory(getRegionAttributes());
    factory.setCacheWriter(writer);
    Region region =
      createRegion(name, factory.create());

    region.create(key, oldValue);
    assertTrue(writer.wasInvoked());
    region.put(key, newValue);
    assertTrue(writer.wasInvoked());
    region.destroy(key);
    assertTrue(writer.wasInvoked());

    region.put(key, oldValue);
    assertTrue(writer.wasInvoked());
    region.put(key, newValue);
    assertTrue(writer.wasInvoked());
    region.destroy(key);
    assertTrue(writer.wasInvoked());

    region.create(key, oldValue);
    assertTrue(writer.wasInvoked());
    region.put(key, newValue, arg);
    assertTrue(writer.wasInvoked());
    region.destroy(key);
    assertTrue(writer.wasInvoked());

    region.put(key, oldValue);
    assertTrue(writer.wasInvoked());
    region.put(key, newValue, arg);
    assertTrue(writer.wasInvoked());
    region.destroy(key);
    assertTrue(writer.wasInvoked());

    region.create(key, oldValue);
    assertTrue(writer.wasInvoked());
    try {
      region.put(key, newValue, exception);
      fail("Should have thrown a CacheWriterException");

    } catch (CacheWriterException ex) {
      // pass...
      assertTrue(writer.wasInvoked());
    }
    region.destroy(key);
    assertTrue(writer.wasInvoked());

    region.create(key, oldValue);
    assertTrue(writer.wasInvoked());
    try {
      region.put(key, newValue, exception);
      fail("Should have thrown a CacheWriterException");

    } catch (CacheWriterException ex) {
      // pass...
      assertTrue(writer.wasInvoked());
    }

  }

  /**
   * Tests that the <code>CacheWriter</code> is called before an entry
   * is {@linkplain CacheWriter#beforeDestroy destroyed}.
   */
  public void testCacheWriterBeforeDestroy() throws CacheException {
    String name = this.getUniqueName();
    final Object key = this.getUniqueName();
    final Object value = new Integer(42);
    final Object arg = "ARG";
    final String exception = "EXCEPTION";

    TestCacheWriter writer = new TestCacheWriter() {
        public void beforeCreate2(EntryEvent event)
          throws CacheWriterException {
          // This method will get invoked when the region is populated
        }

        public void beforeDestroy2(EntryEvent event)
          throws CacheWriterException {

          assertEquals(key, event.getKey());
          assertEquals(value, event.getOldValue());
          assertNull(event.getNewValue());
          assertTrue(event.getOperation().isDestroy());
          assertFalse(event.getOperation().isLoad());
          assertFalse(event.getOperation().isLocalLoad());
          assertFalse(event.getOperation().isNetLoad());
          assertFalse(event.getOperation().isNetSearch());

          Object argument = event.getCallbackArgument();
          if (argument != null) {
            if (argument.equals(exception)) {
              String s = "Test CacheWriterException";
              throw new CacheWriterException(s);

            } else {
              assertEquals(arg, argument);
            }
          }
        }
      };

    AttributesFactory factory =
      new AttributesFactory(getRegionAttributes());
    factory.setCacheWriter(writer);
    Region region =
      createRegion(name, factory.create());

    region.create(key, value);
    assertTrue(writer.wasInvoked());
    region.destroy(key);
    assertTrue(writer.wasInvoked());

    region.create(key, value);
    assertTrue(writer.wasInvoked());
    region.destroy(key, arg);
    assertTrue(writer.wasInvoked());

    region.create(key, value);
    assertTrue(writer.wasInvoked());
    try {
      region.destroy(key, exception);
      fail("Should have thrown a CacheWriterException");

    } catch (CacheWriterException ex) {
      // pass...
      assertTrue(writer.wasInvoked());
    }
  }

  /**
   * Tests that the <code>CacheWriter</code> is called before a region
   * is destroyed.
   * 
   * @see CacheWriter#beforeRegionDestroy
   * @see CacheWriter#close
   */
  public void testCacheWriterBeforeRegionDestroy()
    throws CacheException {

    final String name = this.getUniqueName();
    final Object arg = "ARG";
    final String exception = "EXCEPTION";

    TestCacheWriter writer = new TestCacheWriter() {
        private boolean closed = false;
        private boolean destroyed = false;

        public boolean wasInvoked() {
          boolean value = closed && destroyed;
          super.wasInvoked();
          return value;
        }
        
        public void close2() {
          this.closed = true;
        }

        public void beforeRegionDestroy2(RegionEvent event)
          throws CacheWriterException {

          assertEquals(name, event.getRegion().getName());
          // this should be a distributed destroy unless the region
          // is local scope
          assertTrue(event.getOperation().isRegionDestroy());
          assertFalse(event.getOperation().isExpiration());
          assertFalse(event.isOriginRemote());

          Object argument = event.getCallbackArgument();
          if (argument != null) {
            if (argument.equals(exception)) {
              String s = "Test CacheWriterException";
              throw new CacheWriterException(s);

            } else {
              assertEquals(arg, argument);
            }
          }

          this.destroyed = true;
        }
      };

    AttributesFactory factory =
      new AttributesFactory(getRegionAttributes());
    factory.setCacheWriter(writer);
    RegionAttributes attrs = factory.create();
    Region region;

    region = createRegion(name, attrs);
    region.destroyRegion();
    assertTrue(region.isDestroyed());
    assertTrue(writer.wasInvoked());


    region = createRegion(name, attrs);
    region.destroyRegion(arg);
    assertTrue(writer.wasInvoked());
    assertTrue(region.isDestroyed());


    try {
      region = createRegion(name, attrs);
      region.destroyRegion(exception);
      fail("Should have thrown a CacheWriterException");

    } catch (CacheWriterException ex) {
      // pass...
      assertTrue(writer.wasInvoked());
      assertFalse(region.isDestroyed());
      assertNull(region.getSubregion(name));
    }
  }

  /**
   * Tests that a <code>CacheWriter</code> is <I>not</I> invoked on a
   * {@linkplain Region#localDestroyRegion local destroy}.
   */
  public void testCacheWriterLocalDestroy() throws CacheException {
    final String name = this.getUniqueName();

    // If any of the writer's callback methods are invoked
    TestCacheWriter writer = new TestCacheWriter() { };

    AttributesFactory factory =
      new AttributesFactory(getRegionAttributes());
    factory.setCacheWriter(writer);
    RegionAttributes attrs = factory.create();
    Region region = createRegion(name, attrs);
    region.localDestroyRegion();
  }

  /**
   * Tests that a {@link CacheWriter} throwing a {@link
   * CacheWriterException} aborts the operation.
   */
  public void testCacheWriterExceptionAborts() throws CacheException {
    final String name = this.getUniqueName();
    final String exception = "EXCEPTION";

    TestCacheWriter writer = new TestCacheWriter() {
        private void handleEvent(Object argument)
          throws CacheWriterException {

          if (exception.equals(argument)) {
            String s = "Test Exception";
            throw new CacheWriterException(s);
          }
        }

        public void beforeCreate2(EntryEvent event)
          throws CacheWriterException {

          handleEvent(event.getCallbackArgument());
        }

        public void beforeUpdate2(EntryEvent event)
          throws CacheWriterException {

          handleEvent(event.getCallbackArgument());
        }

        public void beforeDestroy2(EntryEvent event)
          throws CacheWriterException {

          handleEvent(event.getCallbackArgument());
        }

        public void beforeRegionDestroy2(RegionEvent event)
          throws CacheWriterException {

          handleEvent(event.getCallbackArgument());
        }
      };

    AttributesFactory factory =
      new AttributesFactory(getRegionAttributes());
    factory.setCacheWriter(writer);
    RegionAttributes attrs = factory.create();
    Region region;

    region = createRegion(name, attrs);
    Object value = new Integer(42);

    String p1 = "Test Exception";
    getCache().getLogger().info("<ExpectedException action=add>"
        + p1 + "</ExpectedException>");
    try {
      region.put(name, value, exception);
      fail("Should have thrown a CacheWriterException");

    } catch (CacheWriterException ex) {
      assertNull(region.getEntry(name));
    } finally {
      getCache().getLogger().info("<ExpectedException action=remove>"
          + p1 + "</ExpectedException>");
    }

    region.put(name, value);

    try {
      region.put(name, "NEVER SEEN", exception);
      fail("Should have thrown a CacheWriterException");

    } catch (CacheWriterException ex) {
      Region.Entry entry = region.getEntry(name);
      assertNotNull(entry);
      assertEquals(value, entry.getValue());
    }

    try {
      region.destroy(name, exception);
      fail("Should have thrown a CacheWriterException");

    } catch (CacheWriterException ex) {
      Region.Entry entry = region.getEntry(name);
      assertNotNull(entry);
      assertEquals(value, entry.getValue());
    }

    try {
      region.destroyRegion(exception);

    } catch (CacheWriterException ex) {
      assertTrue(!region.isDestroyed());
      assertNotNull(region.getParentRegion().getSubregion(name));
    }
  }

}