test12/src/main/java/org/apache/myfaces/test/mock/lifecycle/MockLifecycle.java

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to you under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.apache.myfaces.test.mock.lifecycle;

import java.util.ArrayList;
import java.util.List;
import javax.faces.FacesException;
import javax.faces.context.FacesContext;
import javax.faces.event.PhaseId;
import javax.faces.event.PhaseListener;
import javax.faces.lifecycle.Lifecycle;

/**
 * <p>Mock implementation of <code>Lifecycle</code>.</p>
 *
 * $Id$
 */

public class MockLifecycle extends Lifecycle {


    // ----------------------------------------------------- Mock Object Methods


    // ------------------------------------------------------ Instance Variables


    /**
     * <p>List of event listeners for this instance.</p>
     */
    private List phaseListenerList = new ArrayList();
    private PhaseExecutor[] lifecycleExecutors;
    private PhaseExecutor renderExecutor;

    public MockLifecycle()
    {
        lifecycleExecutors = new PhaseExecutor[] {
            new RestoreViewExecutor(),
            new ApplyRequestValuesExecutor(),
            new ProcessValidationsExecutor(),
            new UpdateModelValuesExecutor(),
            new InvokeApplicationExecutor()
        };

        renderExecutor = new RenderResponseExecutor();
    }

    // ------------------------------------------------------- Lifecycle Methods


    /** {@inheritDoc} */
    public void addPhaseListener(PhaseListener listener) {

      phaseListenerList.add(listener);

    }


    /** {@inheritDoc} */
    public void execute(FacesContext context) throws FacesException {

        PhaseListenerManager phaseListenerMgr = new PhaseListenerManager(this, context, getPhaseListeners());
        for(int executorIndex = 0;executorIndex < lifecycleExecutors.length;executorIndex++) {
            if(executePhase(context, lifecycleExecutors[executorIndex], phaseListenerMgr)) {
                return;
            }
        }
    }

    private boolean executePhase(FacesContext facesContext, PhaseExecutor executor,
        PhaseListenerManager phaseListenerMgr) throws FacesException {
        boolean skipFurtherProcessing = false;

        try {
            phaseListenerMgr.informPhaseListenersBefore(executor.getPhase());

            if(isResponseComplete(facesContext, executor.getPhase(), true)) {
                // have to return right away
              return true;
            }
            if(shouldRenderResponse(facesContext, executor.getPhase(), true)) {
              skipFurtherProcessing = true;
            }

            if(executor.execute(facesContext)) {
              return true;
            }
        } finally {
            phaseListenerMgr.informPhaseListenersAfter(executor.getPhase());
        }


        if (isResponseComplete(facesContext, executor.getPhase(), false)
            || shouldRenderResponse(facesContext, executor.getPhase(), false)) {
          // since this phase is completed we don't need to return right away even if the response is completed
          skipFurtherProcessing = true;
        }

        return skipFurtherProcessing;
    }


    /** {@inheritDoc} */
    public PhaseListener[] getPhaseListeners() {

        return (PhaseListener[]) phaseListenerList.toArray(new PhaseListener[phaseListenerList.size()]);

    }


    /** {@inheritDoc} */
    public void removePhaseListener(PhaseListener listener) {

      phaseListenerList.remove(listener);

    }


    /** {@inheritDoc} */
    public void render(FacesContext context) throws FacesException {

      // if the response is complete we should not be invoking the phase listeners
      if(isResponseComplete(context, renderExecutor.getPhase(), true)) {
        return;
      }

      PhaseListenerManager phaseListenerMgr = new PhaseListenerManager(this, context, getPhaseListeners());

      try {
          phaseListenerMgr.informPhaseListenersBefore(renderExecutor.getPhase());
          // also possible that one of the listeners completed the response
          if(isResponseComplete(context, renderExecutor.getPhase(), true)) {
            return;
          }

          renderExecutor.execute(context);
      } finally {
          phaseListenerMgr.informPhaseListenersAfter(renderExecutor.getPhase());
      }

    }
    
    private boolean isResponseComplete(FacesContext facesContext, PhaseId phase, boolean before) {
      boolean flag = false;
        if (facesContext.getResponseComplete()) {
            flag = true;
        }
        return flag;
    }

    private boolean shouldRenderResponse(FacesContext facesContext, PhaseId phase, boolean before) {
      boolean flag = false;
      if (facesContext.getRenderResponse()) {
          flag = true;
      }
      return flag;
  }

}