handlerchainprocessortests.java

来自「开源的axis2框架的源码。用于开发WEBSERVER」· Java 代码 · 共 1,016 行 · 第 1/3 页

        logicalhandler1_MessageResultDesired = ResultDesired.TRUE;
        logicalhandler1_FaultResultDesired = ResultDesired.TRUE;
        logicalhandler2_MessageResultDesired = ResultDesired.TRUE;
        logicalhandler2_FaultResultDesired = ResultDesired.TRUE;

        HandlerChainProcessor processor = new HandlerChainProcessor(handlers, Protocol.soap11);
        MessageContext mc1 = new MessageContext();
        mc1.setMEPContext(new MEPContext(mc1));
        processor.processChain(mc1.getMEPContext(),
                               HandlerChainProcessor.Direction.OUT,
                               HandlerChainProcessor.MEP.REQUEST,
                               false);

        assertEquals("L2m:L1m:S1m:S2m:S2c:S1c:L1c:L2c:", result);
    }

    /*
     * outgoing response (we must be on the server), response expected (ignored)
     * processing expected:  Logical and SOAP, normal order, close
     */
    public void testHandleMessage_true6() {

        // reset result
        result = "";

        // we want all good responses:
        soaphandler1_MessageResultDesired = ResultDesired.TRUE;
        soaphandler1_FaultResultDesired = ResultDesired.TRUE;
        soaphandler2_MessageResultDesired = ResultDesired.TRUE;
        soaphandler2_FaultResultDesired = ResultDesired.TRUE;
        logicalhandler1_MessageResultDesired = ResultDesired.TRUE;
        logicalhandler1_FaultResultDesired = ResultDesired.TRUE;
        logicalhandler2_MessageResultDesired = ResultDesired.TRUE;
        logicalhandler2_FaultResultDesired = ResultDesired.TRUE;

        HandlerChainProcessor processor = new HandlerChainProcessor(handlers, Protocol.soap11);
        MessageContext mc1 = new MessageContext();
        mc1.setMEPContext(new MEPContext(mc1));
        processor.processChain(mc1.getMEPContext(),
                               HandlerChainProcessor.Direction.OUT,
                               HandlerChainProcessor.MEP.RESPONSE,
                               true);

        /*
         * since this is server outbound response, the original inbound invocation
         * would have been S2m:S1m:L1m:L2m, so the closes would be L2c:L1c:S1c:S2c
         */

        assertEquals("L2m:L1m:S1m:S2m:L2c:L1c:S1c:S2c:", result);
    }

    /*
     * At this point we know the sorting and closing logic is all good,
     * all that's left is to make sure the SOAP handlers are excluded when
     * we're in a LogicalMessageContext.
     * 
     * outgoing response (we must be on the server), response expected (ignored)
     * processing expected:  Logical only, normal order, close
     */
    public void testHandleMessage_true7() {

        // reset result
        result = "";

        // we want all good responses:
        soaphandler1_MessageResultDesired = ResultDesired.TRUE;
        soaphandler1_FaultResultDesired = ResultDesired.TRUE;
        soaphandler2_MessageResultDesired = ResultDesired.TRUE;
        soaphandler2_FaultResultDesired = ResultDesired.TRUE;
        logicalhandler1_MessageResultDesired = ResultDesired.TRUE;
        logicalhandler1_FaultResultDesired = ResultDesired.TRUE;
        logicalhandler2_MessageResultDesired = ResultDesired.TRUE;
        logicalhandler2_FaultResultDesired = ResultDesired.TRUE;

        HandlerChainProcessor processor = new HandlerChainProcessor(handlers, Protocol.soap11);
        MessageContext mc1 = new MessageContext();
        mc1.setMEPContext(new MEPContext(mc1));
        processor.processChain(mc1.getMEPContext(),
                               HandlerChainProcessor.Direction.OUT,
                               HandlerChainProcessor.MEP.RESPONSE,
                               true);

        /*
         * since this is server outbound response, the original invocation
         * would have been S2m:S1m:L1m:L2m, so the closes would be L2c:L1c:S1c:S2c
         */

        assertEquals("L2m:L1m:S1m:S2m:L2c:L1c:S1c:S2c:", result);
    }

    /*
     * incoming request (we must be on the server), response expected
     * a middle Handler.handleMessage returns false
     * processing expected:  Logical and SOAP, reverse order, message reversed, close
     */
    public void testHandleMessage_false1() {

        // reset result
        result = "";

        // we want one false response:
        soaphandler1_MessageResultDesired = ResultDesired.TRUE;
        soaphandler1_FaultResultDesired = ResultDesired.TRUE;
        soaphandler2_MessageResultDesired = ResultDesired.TRUE;
        soaphandler2_FaultResultDesired = ResultDesired.TRUE;
        logicalhandler1_MessageResultDesired = ResultDesired.FALSE;
        logicalhandler1_FaultResultDesired = ResultDesired.TRUE;
        logicalhandler2_MessageResultDesired = ResultDesired.TRUE;
        logicalhandler2_FaultResultDesired = ResultDesired.TRUE;

        HandlerChainProcessor processor = new HandlerChainProcessor(handlers, Protocol.soap11);
        MessageContext mc1 = new MessageContext();
        mc1.setMEPContext(new MEPContext(mc1));
        processor.processChain(mc1.getMEPContext(),
                               HandlerChainProcessor.Direction.IN,
                               HandlerChainProcessor.MEP.REQUEST,
                               true);

        assertEquals("S2m:S1m:L1m:S1m:S2m:L1c:S1c:S2c:", result);
    }

    /*
     * outgoing request (we must be on the client), response expected
     * a middle Handler.handleMessage returns false
     * processing expected:  Logical and SOAP, normal order, message reversed, close
     */
    public void testHandleMessage_false2() {

        // reset result
        result = "";

        // we want one false response:
        soaphandler1_MessageResultDesired = ResultDesired.TRUE;
        soaphandler1_FaultResultDesired = ResultDesired.TRUE;
        soaphandler2_MessageResultDesired = ResultDesired.TRUE;
        soaphandler2_FaultResultDesired = ResultDesired.TRUE;
        logicalhandler1_MessageResultDesired = ResultDesired.FALSE;
        logicalhandler1_FaultResultDesired = ResultDesired.TRUE;
        logicalhandler2_MessageResultDesired = ResultDesired.TRUE;
        logicalhandler2_FaultResultDesired = ResultDesired.TRUE;

        HandlerChainProcessor processor = new HandlerChainProcessor(handlers, Protocol.soap11);
        MessageContext mc1 = new MessageContext();
        mc1.setMEPContext(new MEPContext(mc1));
        processor.processChain(mc1.getMEPContext(),
                               HandlerChainProcessor.Direction.OUT,
                               HandlerChainProcessor.MEP.REQUEST,
                               true);

        assertEquals("L2m:L1m:L2m:L1c:L2c:", result);
    }

    /*
     * outgoing request (we must be on the client), response NOT expected
     * a middle Handler.handleMessage returns false
     * processing expected:  Logical and SOAP, normal order, message NOT reversed, close
     */
    public void testHandleMessage_false3() {

        // reset result
        result = "";

        // we want one false response:
        soaphandler1_MessageResultDesired = ResultDesired.TRUE;
        soaphandler1_FaultResultDesired = ResultDesired.TRUE;
        soaphandler2_MessageResultDesired = ResultDesired.TRUE;
        soaphandler2_FaultResultDesired = ResultDesired.TRUE;
        logicalhandler1_MessageResultDesired = ResultDesired.FALSE;
        logicalhandler1_FaultResultDesired = ResultDesired.TRUE;
        logicalhandler2_MessageResultDesired = ResultDesired.TRUE;
        logicalhandler2_FaultResultDesired = ResultDesired.TRUE;

        HandlerChainProcessor processor = new HandlerChainProcessor(handlers, Protocol.soap11);
        MessageContext mc1 = new MessageContext();
        mc1.setMEPContext(new MEPContext(mc1));
        processor.processChain(mc1.getMEPContext(),
                               HandlerChainProcessor.Direction.OUT,
                               HandlerChainProcessor.MEP.REQUEST,
                               false);

        assertEquals("L2m:L1m:L1c:L2c:", result);
    }

    /*
     * incoming request (we must be on the server), response expected
     * a middle Handler.handleMessage throws ProtocolException
     * processing expected:  Logical and SOAP, reverse order, message reversed, handleFault, close
     */
    public void testHandleMessage_protocolex_true1() {

        // reset result
        result = "";

        // we want one false response:
        soaphandler1_MessageResultDesired = ResultDesired.TRUE;
        soaphandler1_FaultResultDesired = ResultDesired.TRUE;
        soaphandler2_MessageResultDesired = ResultDesired.TRUE;
        soaphandler2_FaultResultDesired = ResultDesired.TRUE;
        logicalhandler1_MessageResultDesired = ResultDesired.PROTOCOL_EXCEPTION;
        logicalhandler1_FaultResultDesired = ResultDesired.TRUE;
        logicalhandler2_MessageResultDesired = ResultDesired.TRUE;
        logicalhandler2_FaultResultDesired = ResultDesired.TRUE;

        HandlerChainProcessor processor = new HandlerChainProcessor(handlers, Protocol.soap11);
        MessageContext mc1 = new MessageContext();
        mc1.setMEPContext(new MEPContext(mc1));
        processor.processChain(mc1.getMEPContext(),
                               HandlerChainProcessor.Direction.IN,
                               HandlerChainProcessor.MEP.REQUEST,
                               true);

        // handleFault processing
        assertEquals("S2m:S1m:L1m:S1f:S2f:L1c:S1c:S2c:", result);
    }

    /*
     * incoming request (we must be on the server), response NOT expected
     * a middle Handler.handleMessage throws ProtocolException
     * processing expected:  Logical and SOAP, reverse order, message NOT reversed, close
     */
    public void testHandleMessage_protocolex_true2() {

        // reset result
        result = "";

        // we want one false response:
        soaphandler1_MessageResultDesired = ResultDesired.TRUE;
        soaphandler1_FaultResultDesired = ResultDesired.TRUE;
        soaphandler2_MessageResultDesired = ResultDesired.TRUE;
        soaphandler2_FaultResultDesired = ResultDesired.TRUE;
        logicalhandler1_MessageResultDesired = ResultDesired.PROTOCOL_EXCEPTION;
        logicalhandler1_FaultResultDesired = ResultDesired.TRUE;
        logicalhandler2_MessageResultDesired = ResultDesired.TRUE;
        logicalhandler2_FaultResultDesired = ResultDesired.TRUE;

        HandlerChainProcessor processor = new HandlerChainProcessor(handlers, Protocol.soap11);
        MessageContext mc1 = new MessageContext();
        mc1.setMEPContext(new MEPContext(mc1));
        processor.processChain(mc1.getMEPContext(),
                               HandlerChainProcessor.Direction.IN,
                               HandlerChainProcessor.MEP.REQUEST,
                               false);

        // no handleFault calls
        assertEquals("S2m:S1m:L1m:L1c:S1c:S2c:", result);
    }

    /*
     * incoming request (we must be on the server), response expected
     * a middle Handler.handleMessage throws RuntimeException
     * processing expected:  Logical and SOAP, reverse order, message reversed, (no handleFault), close
     */
    public void testHandleMessage_runtimeex_true() {

        // reset result
        result = "";

        // we want one false response:
        soaphandler1_MessageResultDesired = ResultDesired.TRUE;
        soaphandler1_FaultResultDesired = ResultDesired.TRUE;
        soaphandler2_MessageResultDesired = ResultDesired.TRUE;
        soaphandler2_FaultResultDesired = ResultDesired.TRUE;
        logicalhandler1_MessageResultDesired = ResultDesired.OTHER_EXCEPTION;
        logicalhandler1_FaultResultDesired = ResultDesired.TRUE;
        logicalhandler2_MessageResultDesired = ResultDesired.TRUE;
        logicalhandler2_FaultResultDesired = ResultDesired.TRUE;

        HandlerChainProcessor processor = new HandlerChainProcessor(handlers, Protocol.soap11);
        MessageContext mc1 = new MessageContext();
        mc1.setMEPContext(new MEPContext(mc1));
        Exception e = null;
        try {
            processor.processChain(mc1.getMEPContext(),
                                   HandlerChainProcessor.Direction.IN,
                                   HandlerChainProcessor.MEP.REQUEST,
                                   true);
        } catch (RuntimeException re) {
            e = re;
        }

        assertNotNull(e);
        // no handleFault calls
        assertEquals("S2m:S1m:L1m:L1c:S1c:S2c:", result);
    }

    /*
     * incoming request (we must be on the server), response expected
     * a middle Handler.handleMessage throws ProtocolException, later a Handler.handleFault returns false
     * processing expected:  Logical and SOAP, reverse order, message reversed, handleFault, close
     */
    public void testHandleMessage_protocolex_false() {

        // reset result
        result = "";

        // we want one false response:
        soaphandler1_MessageResultDesired = ResultDesired.TRUE;
        soaphandler1_FaultResultDesired = ResultDesired.FALSE;
        soaphandler2_MessageResultDesired = ResultDesired.TRUE;
        soaphandler2_FaultResultDesired = ResultDesired.TRUE;
        logicalhandler1_MessageResultDesired = ResultDesired.PROTOCOL_EXCEPTION;
        logicalhandler1_FaultResultDesired = ResultDesired.TRUE;
        logicalhandler2_MessageResultDesired = ResultDesired.TRUE;
        logicalhandler2_FaultResultDesired = ResultDesired.TRUE;

        HandlerChainProcessor processor = new HandlerChainProcessor(handlers, Protocol.soap11);
        MessageContext mc1 = new MessageContext();
        mc1.setMEPContext(new MEPContext(mc1));
        processor.processChain(mc1.getMEPContext(),
                               HandlerChainProcessor.Direction.IN,
                               HandlerChainProcessor.MEP.REQUEST,
                               true);

        // handleFault processing, but notice S2f does not get called
        assertEquals("S2m:S1m:L1m:S1f:L1c:S1c:S2c:", result);
    }

    /*
     * incoming request (we must be on the server), response expected
     * a middle Handler.handleMessage throws ProtocolException, later a Handler.handleFault throws ProtocolException
     * processing expected:  Logical and SOAP, reverse order, message reversed, handleFault, close
     */
    public void testHandleMessage_protocolex_protocolex() {

        // reset result
        result = "";

        // we want one false response:
        soaphandler1_MessageResultDesired = ResultDesired.TRUE;
        soaphandler1_FaultResultDesired = ResultDesired.PROTOCOL_EXCEPTION;
        soaphandler2_MessageResultDesired = ResultDesired.TRUE;
        soaphandler2_FaultResultDesired = ResultDesired.TRUE;
        logicalhandler1_MessageResultDesired = ResultDesired.PROTOCOL_EXCEPTION;
        logicalhandler1_FaultResultDesired = ResultDesired.TRUE;
        logicalhandler2_MessageResultDesired = ResultDesired.TRUE;
        logicalhandler2_FaultResultDesired = ResultDesired.TRUE;

        HandlerChainProcessor processor = new HandlerChainProcessor(handlers, Protocol.soap11);
        MessageContext mc1 = new MessageContext();