/**
    * This file Copyright (c) 2015-2018 Magnolia International
    * Ltd.  (http://www.magnolia-cms.com). All rights reserved.
    *
    *
    * This file is dual-licensed under both the Magnolia
    * Network Agreement and the GNU General Public License.
    * You may elect to use one or the other of these licenses.
    *
   * This file is distributed in the hope that it will be
   * useful, but AS-IS and WITHOUT ANY WARRANTY; without even the
   * implied warranty of MERCHANTABILITY or FITNESS FOR A
   * PARTICULAR PURPOSE, TITLE, or NONINFRINGEMENT.
   * Redistribution, except as permitted by whichever of the GPL
   * or MNA you select, is prohibited.
   *
   * 1. For the GPL license (GPL), you can redistribute and/or
   * modify this file under the terms of the GNU General
   * Public License, Version 3, as published by the Free Software
   * Foundation.  You should have received a copy of the GNU
   * General Public License, Version 3 along with this program;
   * if not, write to the Free Software Foundation, Inc., 51
   * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   *
   * 2. For the Magnolia Network Agreement (MNA), this file
   * and the accompanying materials are made available under the
   * terms of the MNA which accompanies this distribution, and
   * is available at http://www.magnolia-cms.com/mna.html
   *
   * Any modifications to this file must keep this entire header
   * intact.
   *
   */
  package info.magnolia.resourceloader.jcr;
  
  import static info.magnolia.repository.RepositoryConstants.WEBSITE;
  import static info.magnolia.resourceloader.ResourceOriginChange.Type.*;
  import static info.magnolia.resourceloader.ResourceOriginChangeMatcher.resourceChange;
  import static info.magnolia.resourceloader.jcr.JcrResourceOrigin.*;
  import static org.junit.Assert.*;
  import static org.mockito.Matchers.argThat;
  import static org.mockito.Mockito.*;
  
  import info.magnolia.context.MgnlContext;
  import info.magnolia.context.SystemContext;
  import info.magnolia.jcr.util.NodeTypes;
  import info.magnolia.jcr.util.NodeUtil;
  import info.magnolia.jcr.wrapper.DelegateSessionWrapper;
  import info.magnolia.resourceloader.ResourceChangeHandler;
  import info.magnolia.resourceloader.ResourceOriginChange;
  import info.magnolia.test.RepositoryTestCase;
  import info.magnolia.test.TestUtil;
  
  import javax.jcr.Node;
  import javax.jcr.Session;
  import javax.jcr.nodetype.NodeType;
  import javax.jcr.observation.EventListenerIterator;
  import javax.jcr.observation.ObservationManager;
  import javax.jcr.version.VersionManager;
  
  import org.junit.After;
  import org.junit.Before;
  import org.junit.BeforeClass;
  import org.junit.Test;
  
  /**
   * Repository test for {@link JcrResourceOrigin}, to cover peculiarities of jackrabbit observation.
   */
  public class JcrResourceOriginRepositoryTest extends RepositoryTestCase {
  
      private static final int TIMEOUT = 2000;
  
      private Session session;
      private JcrResourceOrigin jcrOrigin;
  
      @BeforeClass
      public static void shuntSlf4jSimpleLoggerForJackrabbit() {
          TestUtil.shuntLogFor("org.apache.jackrabbit");
          TestUtil.shuntLogFor(info.magnolia.jackrabbit.ProviderImpl.class);
      }
  
      @Override
      @Before
      public void setUp() throws Exception {
          super.setUp();
          final SystemContext ctx = (SystemContext) MgnlContext.getInstance();
  
          this.session = ctx.getJCRSession(RESOURCES_WORKSPACE);
          this.jcrOrigin = new JcrResourceOrigin(() -> ctx, "jcr");
      }
  
      @Override
      @After
      public void tearDown() throws Exception {
          ObservationManager observationManager = session.getWorkspace().getObservationManager();
          EventListenerIterator eventListeners = observationManager.getRegisteredEventListeners();
          while (eventListeners.hasNext()) {
              observationManager.removeEventListener(eventListeners.nextEventListener());
          }
         super.tearDown();
     }
 
     @Override
     protected String getRepositoryConfigFileName() {
         return "test-resource-repositories.xml";
     }
 
     @Test
     public void communicatesFileResourceAddition() throws Exception {
         // GIVEN
         // register a resource change handler
         final ResourceChangeHandler resourceChangeHandler = mock(ResourceChangeHandler.class);
         jcrOrigin.registerResourceChangeHandler(resourceChangeHandler);
 
         // WHEN we create a file node
         NodeUtil.createPath(session.getRootNode(), "foo/dialogs/bar.yaml", NodeTypes.ContentNode.NAME, true);
 
         // THEN handler is notified with a correct change type, path and related origin
         verify(resourceChangeHandler, timeout(TIMEOUT)).onResourceChanged(argThat(resourceChange().inOrigin(jcrOrigin).ofType(ADDED).at("/foo/dialogs/bar.yaml")));
     }
 
     @Test
     public void communicatesFileResourceModification() throws Exception {
         // GIVEN
         // create a node
         final Node barFileNode = NodeUtil.createPath(session.getRootNode(), "foo/dialogs/bar.yaml", NodeTypes.ContentNode.NAME, true);
 
         // register a resource change handler
         final ResourceChangeHandler resourceChangeHandler = mock(ResourceChangeHandler.class);
         jcrOrigin.registerResourceChangeHandler(resourceChangeHandler);
 
         // WHEN we create a file node
         barFileNode.setProperty("qux", "quux");
         session.save();
 
         // THEN handler is notified with a correct change type, path and related origin
         verify(resourceChangeHandler, timeout(TIMEOUT)).onResourceChanged(argThat(resourceChange().inOrigin(jcrOrigin).ofType(MODIFIED).at("/foo/dialogs/bar.yaml")));
 
         assertNotEquals("Original session is released", session, MgnlContext.getJCRSession(RESOURCES_WORKSPACE));
     }
 
     @Test
     public void communicatesFileResourceDeletion() throws Exception {
         // GIVEN
         // create a node
         final Node barFileNode = NodeUtil.createPath(session.getRootNode(), "foo/dialogs/bar.yaml", NodeTypes.ContentNode.NAME, true);
 
         // register a resource change handler
         final ResourceChangeHandler resourceChangeHandler = mock(ResourceChangeHandler.class);
         jcrOrigin.registerResourceChangeHandler(resourceChangeHandler);
 
         // WHEN we create a file node
         barFileNode.remove();
         session.save();
 
         // THEN handler is notified with a correct change type, path and related origin
         verify(resourceChangeHandler, timeout(TIMEOUT)).onResourceChanged(argThat(resourceChange().inOrigin(jcrOrigin).ofType(REMOVED).at("/foo/dialogs/bar.yaml")));
 
         assertNotEquals("Original session is released", session, MgnlContext.getJCRSession(RESOURCES_WORKSPACE));
     }
 
     @Test
     public void communicatesResourceFolderAdditionWithContents() throws Exception {
         // GIVEN
         // register a resource change handler
         final ResourceChangeHandler resourceChangeHandler = mock(ResourceChangeHandler.class);
         jcrOrigin.registerResourceChangeHandler(resourceChangeHandler);
 
         // WHEN we create a file node
         final Node fooDialogs = NodeUtil.createPath(session.getRootNode(), "foo/dialogs", NodeTypes.Folder.NAME);
         NodeUtil.createPath(fooDialogs, "bar.yaml", NodeTypes.ContentNode.NAME);
         NodeUtil.createPath(fooDialogs, "qux.yaml", NodeTypes.ContentNode.NAME);
         session.save();
 
         // THEN handler is notified with a correct change type, path and related origin
         verify(resourceChangeHandler, timeout(TIMEOUT)).onResourceChanged(argThat(resourceChange().inOrigin(jcrOrigin).ofType(ADDED).at("/foo/dialogs")));
         verify(resourceChangeHandler, timeout(TIMEOUT)).onResourceChanged(argThat(resourceChange().inOrigin(jcrOrigin).ofType(ADDED).at("/foo/dialogs/bar.yaml")));
         verify(resourceChangeHandler, timeout(TIMEOUT)).onResourceChanged(argThat(resourceChange().inOrigin(jcrOrigin).ofType(ADDED).at("/foo/dialogs/bar.yaml")));
     }
 
     @Test
     public void communicatesResourceFolderDeletionWithContents() throws Exception {
         // GIVEN
         // create a folder and a couple of sub-nodes
         final Node fooDialogs = NodeUtil.createPath(session.getRootNode(), "foo/dialogs", NodeTypes.Folder.NAME, true);
         NodeUtil.createPath(fooDialogs, "bar.yaml", NodeTypes.ContentNode.NAME, true);
         NodeUtil.createPath(fooDialogs, "qux.yaml", NodeTypes.ContentNode.NAME, true);
 
         // register a resource change handler
         final ResourceChangeHandler resourceChangeHandler = mock(ResourceChangeHandler.class);
         jcrOrigin.registerResourceChangeHandler(resourceChangeHandler);
 
         // WHEN we create a file node
         fooDialogs.remove();
         session.save();
 
         // THEN handler is notified with a correct change type, path and related origin
         verify(resourceChangeHandler, timeout(TIMEOUT)).onResourceChanged(argThat(resourceChange().inOrigin(jcrOrigin).ofType(REMOVED).at("/foo/dialogs")));
         verify(resourceChangeHandler, timeout(TIMEOUT)).onResourceChanged(argThat(resourceChange().inOrigin(jcrOrigin).ofType(REMOVED).at("/foo/dialogs/bar.yaml")));
         verify(resourceChangeHandler, timeout(TIMEOUT)).onResourceChanged(argThat(resourceChange().inOrigin(jcrOrigin).ofType(REMOVED).at("/foo/dialogs/bar.yaml")));
     }
 
     @Test
     public void bypassSetToTrueTreatedAsResourceRemoval() throws Exception {
         // GIVEN
         // create a couple of nodes
         final Node barFileNode = NodeUtil.createPath(session.getRootNode(), "foo/dialogs/bar.yaml", NodeTypes.ContentNode.NAME);
         final Node bazFileNode = NodeUtil.createPath(session.getRootNode(), "foo/dialogs/baz.yaml", NodeTypes.ContentNode.NAME);
         barFileNode.setProperty("bypass", false);
         session.save();
 
         // WHEN register a resource change handler
         final ResourceChangeHandler resourceChangeHandler = mock(ResourceChangeHandler.class);
         jcrOrigin.registerResourceChangeHandler(resourceChangeHandler);
 
         // newly set/added property for baz
         bazFileNode.setProperty("bypass", true);
         // modified property for bar
         barFileNode.setProperty("bypass", true);
         session.save();
 
         // THEN
         verify(resourceChangeHandler, timeout(TIMEOUT)).onResourceChanged(argThat(resourceChange().inOrigin(jcrOrigin).ofType(REMOVED).at("/foo/dialogs/bar.yaml")));
         verify(resourceChangeHandler, timeout(TIMEOUT)).onResourceChanged(argThat(resourceChange().inOrigin(jcrOrigin).ofType(REMOVED).at("/foo/dialogs/baz.yaml")));
 
         assertNotEquals("Original session is released", session, MgnlContext.getJCRSession(RESOURCES_WORKSPACE));
     }
 
     @Test
     public void bypassSetToFalseTreatedAsResourceAddition() throws Exception {
         // GIVEN
         // create a bypassed node
         final Node barFileNode = NodeUtil.createPath(session.getRootNode(), "foo/dialogs/bar.yaml", NodeTypes.ContentNode.NAME);
         barFileNode.setProperty("bypass", true);
         session.save();
 
         // WHEN register a resource change handler
         final ResourceChangeHandler resourceChangeHandler = mock(ResourceChangeHandler.class);
         jcrOrigin.registerResourceChangeHandler(resourceChangeHandler);
 
         barFileNode.setProperty("bypass", false);
         session.save();
 
         // THEN
         verify(resourceChangeHandler, timeout(TIMEOUT)).onResourceChanged(argThat(resourceChange().inOrigin(jcrOrigin).ofType(ADDED).at("/foo/dialogs/bar.yaml")));
     }
 
     @Test
     public void ignoreChangesWhenResourceIsBypassed() throws Exception {
         // Given
         Node folder = NodeUtil.createPath(session.getRootNode(), "myModule/dialogs", NodeTypes.Folder.NAME);
         Node file = folder.addNode("panda.yaml", NodeTypes.Content.NAME);
         file.setProperty(BYPASS_PROPERTY, true);
         session.save();
 
 
         final ResourceChangeHandler resourceChangeHandler = mock(ResourceChangeHandler.class);
         jcrOrigin.registerResourceChangeHandler(resourceChangeHandler);
 
         // When
         file.setProperty("text", "<DUMMY CONTENT>");
         session.save();
 
         // Then
         verify(resourceChangeHandler, after(TIMEOUT).never()).onResourceChanged(anyObject());
     }
 
     @Test
     public void ignoreChangesOnSharedSystemNodesWhenWatchingResourcesRoot() throws Exception {
         // Given we observe root of the resources workspace
         final ResourceChangeHandler resourceChangeHandler = mock(ResourceChangeHandler.class);
         jcrOrigin.registerResourceChangeHandler(resourceChangeHandler);
 
         // versioning typically writes changes in the shared /jcr:system sub-tree, i.e. observation may get events from different workspaces
         Session websiteSession = MgnlContext.getJCRSession(WEBSITE);
         websiteSession.getRootNode().addNode("b", NodeTypes.Content.NAME);
         websiteSession.save();
         VersionManager versionManager = ((DelegateSessionWrapper) websiteSession).unwrap().getWorkspace().getVersionManager();
 
         // When
         websiteSession.getNode("/b").addMixin(NodeType.MIX_VERSIONABLE);
         websiteSession.save();
         versionManager.checkin("/b");
 
         // Then
         // Fail gracefully if after() interrupts test and shuts down repo while the deferred listener is still iterating
         verify(resourceChangeHandler, after(TIMEOUT).never()).onResourceChanged(any(ResourceOriginChange.class));
         verifyZeroInteractions(resourceChangeHandler);
     }
 }