org.apache.cxf.jaxws.JaxWsProxyFactoryBean Java Examples

/**
 * Standard service initialization. Concrete implementations can change the
 * client initialization logic
 */
@SuppressWarnings("unchecked")
protected void initClient(Class<T> serviceClass, int gzipThreshold, boolean log) {
	// Needed to get rig of CXF exception
	// "Cannot create a secure XMLInputFactory"
	System.setProperty("org.apache.cxf.stax.allowInsecureParser", "true");

	JaxWsProxyFactoryBean factory = new JaxWsProxyFactoryBean();
	if (log) {
		factory.getInInterceptors().add(new LoggingInInterceptor());
		factory.getOutInterceptors().add(new LoggingOutInterceptor());
	}

	if (gzipThreshold >= 0) {
		factory.getInInterceptors().add(new GZIPInInterceptor());
		factory.getOutInterceptors().add(new GZIPOutInterceptor(gzipThreshold));
	}

	factory.setServiceClass(serviceClass);
	factory.setAddress(endpoint);
	client = (T) factory.create();
}
 

protected Resource createClient(ReferenceParametersType refParams) {
    JaxWsProxyFactoryBean factory = new JaxWsProxyFactoryBean();

    Map<String, Object> props = factory.getProperties();
    if (props == null) {
        props = new HashMap<>();
    }
    props.put("jaxb.additionalContextClasses",
            ExpressionType.class);
    factory.setProperties(props);

    factory.setBus(bus);
    factory.setServiceClass(Resource.class);
    factory.setAddress(RESOURCE_ADDRESS);
    Resource proxy = (Resource) factory.create();

    // Add reference parameters
    AddressingProperties addrProps = new AddressingProperties();
    EndpointReferenceType endpoint = new EndpointReferenceType();
    endpoint.setReferenceParameters(refParams);
    endpoint.setAddress(ContextUtils.getAttributedURI(RESOURCE_ADDRESS));
    addrProps.setTo(endpoint);
    ((BindingProvider) proxy).getRequestContext().put(JAXWSAConstants.CLIENT_ADDRESSING_PROPERTIES, addrProps);

    return proxy;
}
 

@Test
public void testWs(final MockTracer tracer) {
  final String msg = "hello";

  // prepare server
  final JaxWsServerFactoryBean serverFactory = new JaxWsServerFactoryBean();
  serverFactory.setServiceClass(Echo.class);
  serverFactory.setAddress(BASE_URI);
  serverFactory.setServiceBean(new EchoImpl());
  final Server server = serverFactory.create();

  // prepare client
  final JaxWsProxyFactoryBean clientFactory = new JaxWsProxyFactoryBean();
  clientFactory.setServiceClass(Echo.class);
  clientFactory.setAddress(BASE_URI);
  final Echo echo = (Echo)clientFactory.create();

  final String response = echo.echo(msg);

  assertEquals(msg, response);
  assertEquals(2, tracer.finishedSpans().size());

  server.destroy();
  serverFactory.getBus().shutdown(true);
}
 

@Test
public void testReturnMap() throws Exception {

    JaxWsServerFactoryBean sf = new JaxWsServerFactoryBean();
    sf.setServiceClass(StudentService.class);
    sf.setServiceBean(new StudentServiceImpl());
    sf.setAddress("local://StudentService");
    setupAegis(sf);
    Server server = sf.create();
    server.start();

    JaxWsProxyFactoryBean proxyFac = new JaxWsProxyFactoryBean();
    proxyFac.setAddress("local://StudentService");
    proxyFac.setBus(getBus());
    setupAegis(proxyFac.getClientFactoryBean());

    StudentService clientInterface = proxyFac.create(StudentService.class);
    Map<Long, Student> fullMap = clientInterface.getStudentsMap();
    assertNotNull(fullMap);
    Student one = fullMap.get(Long.valueOf(1));
    assertNotNull(one);
    assertEquals("Student1", one.getName());

    Map<String, ?> wildMap = clientInterface.getWildcardMap();
    assertEquals("valuestring", wildMap.get("keystring"));
}
 

private static BookStoreService createJaxWsService(final Map<String, List<String>> headers,
        final Feature feature) {

    JaxWsProxyFactoryBean factory = new JaxWsProxyFactoryBean();
    factory.getOutInterceptors().add(new LoggingOutInterceptor());
    factory.getInInterceptors().add(new LoggingInInterceptor());
    factory.setServiceClass(BookStoreService.class);
    factory.setAddress("http://localhost:" + PORT + "/BookStore");

    if (feature != null) {
        factory.getFeatures().add(feature);
    }

    final BookStoreService service = (BookStoreService) factory.create();
    final Client proxy = ClientProxy.getClient(service);
    proxy.getRequestContext().put(Message.PROTOCOL_HEADERS, headers);

    return service;
}
 

@Bean(name = "ticketAgentProxyBean")
public TicketAgent ticketAgent() {
  JaxWsProxyFactoryBean jaxWsProxyFactoryBean =
      new JaxWsProxyFactoryBean();
  jaxWsProxyFactoryBean.setServiceClass(TicketAgent.class);
  jaxWsProxyFactoryBean.setAddress(address);

  // add the WSS4J OUT interceptor to sign the request message
  jaxWsProxyFactoryBean.getOutInterceptors().add(clientWssOut());
  // add the WSS4J IN interceptor to verify the signature on the response message
  jaxWsProxyFactoryBean.getInInterceptors().add(clientWssIn());

  // log the request and response messages
  jaxWsProxyFactoryBean.getInInterceptors()
      .add(loggingInInterceptor());
  jaxWsProxyFactoryBean.getOutInterceptors()
      .add(loggingOutInterceptor());

  return (TicketAgent) jaxWsProxyFactoryBean.create();
}
 

@Test(expected = HelloException.class)
public void testJaxws() throws Exception {
    JaxWsServerFactoryBean sfbean = new JaxWsServerFactoryBean();
    sfbean.setServiceClass(ExceptionService.class);
    setupAegis(sfbean);
    sfbean.setAddress("local://ExceptionService4");
    Server server = sfbean.create();
    Service service = server.getEndpoint().getService();
    service.setInvoker(new BeanInvoker(new ExceptionServiceImpl()));

    JaxWsProxyFactoryBean proxyFac = new JaxWsProxyFactoryBean();
    proxyFac.setAddress("local://ExceptionService4");
    proxyFac.setBus(getBus());
    setupAegis(proxyFac.getClientFactoryBean());
    ExceptionService clientInterface = proxyFac.create(ExceptionService.class);

    clientInterface.sayHiWithException();
}
 

@Bean(name = "ticketAgentProxy")
public TicketAgent ticketAgentProxy() {
  JaxWsProxyFactoryBean jaxWsProxyFactoryBean =
      new JaxWsProxyFactoryBean();
  jaxWsProxyFactoryBean.setServiceClass(TicketAgent.class);
  jaxWsProxyFactoryBean.setAddress(address);

  // add an interceptor to log the outgoing request messages
  jaxWsProxyFactoryBean.getOutInterceptors()
      .add(loggingOutInterceptor());
  // add an interceptor to log the incoming response messages
  jaxWsProxyFactoryBean.getInInterceptors()
      .add(loggingInInterceptor());
  // add an interceptor to log the incoming fault messages
  jaxWsProxyFactoryBean.getInFaultInterceptors()
      .add(loggingInInterceptor());

  return (TicketAgent) jaxWsProxyFactoryBean.create();
}
 

public void connect(TokenHolder tokenHolder) {
	for (Class<? extends PublicInterface> interface1 : interfaces) {
		JaxWsProxyFactoryBean cpfb = new JaxWsProxyFactoryBean();
		cpfb.setServiceClass(interface1);
		cpfb.setAddress(address + "/" + interface1.getSimpleName());
		Map<String, Object> properties = new HashMap<String, Object>();
		properties.put("mtom-enabled", Boolean.TRUE);
		cpfb.setProperties(properties);
		
		PublicInterface serviceInterface = (PublicInterface) cpfb.create();
		
		client = ClientProxy.getClient(serviceInterface);
		HTTPConduit http = (HTTPConduit) client.getConduit();
		http.getClient().setConnectionTimeout(360000);
		http.getClient().setAllowChunking(false);
		http.getClient().setReceiveTimeout(320000);
		
		if (!useSoapHeaderSessions) {
			((BindingProvider) serviceInterface).getRequestContext().put(BindingProvider.SESSION_MAINTAIN_PROPERTY, Boolean.TRUE);
		}
		add(interface1.getName(), serviceInterface);
	}
	tokenHolder.registerTokenChangeListener(this);
	notifyOfConnect();
}
 

@Test
public void testClientFromFactory() throws Exception {
    AbstractFactoryBeanDefinitionParser.setFactoriesAreAbstract(false);
    ClassPathXmlApplicationContext ctx =
        new ClassPathXmlApplicationContext(new String[] {"/org/apache/cxf/jaxws/spring/clients.xml"});


    JaxWsProxyFactoryBean factory = new JaxWsProxyFactoryBean();

    Greeter g = factory.create(Greeter.class);
    ClientImpl c = (ClientImpl)ClientProxy.getClient(g);
    for (Interceptor<? extends Message> i : c.getInInterceptors()) {
        if (i instanceof LoggingInInterceptor) {
            ctx.close();
            return;
        }
    }
    ctx.close();
    fail("Did not configure the client");
}
 

protected PerUserPerServiceClientFactory(final NodeService nodeService,
                                         final Class<T> serviceInterface,
                                         final String userName,
                                         final String password,
                                         final String url,
                                         final long timeout) {
    this.userName = userName;
    this.password = password;
    this.url = url;
    this.timeout = timeout;
    this.factory = new JaxWsProxyFactoryBean();
    this.factory.setServiceClass(serviceInterface);
    this.factory.setAddress(this.url);

    final Slf4JLoggingInInterceptor loggingInInterceptor = new Slf4JLoggingInInterceptor(nodeService);
    loggingInInterceptor.setPrettyLogging(false);
    final Slf4JLoggingOutInterceptor loggingOutInterceptor = new Slf4JLoggingOutInterceptor(nodeService);
    loggingOutInterceptor.setPrettyLogging(false);

    this.factory.getInInterceptors().add(loggingInInterceptor);
    this.factory.getInFaultInterceptors().add(loggingInInterceptor);
    this.factory.getOutInterceptors().add(loggingOutInterceptor);
    this.factory.getOutFaultInterceptors().add(loggingOutInterceptor);
}
 

public void sendRequest() throws Exception {
    JaxWsProxyFactoryBean factory = new JaxWsProxyFactoryBean();
    factory.setServiceClass(HelloWorld.class);
    factory.setAddress("http://localhost:8181/cxf/HelloWorldSecurity");
    HelloWorld client = (HelloWorld) factory.create();
    
    Map<String, Object> outProps = new HashMap<String, Object>();
    outProps.put("action", "UsernameToken");

    //add a CustomerSecurityInterceptor for client side to init wss4j staff
    //retrieve and set user/password,  users can easily add this interceptor
    //through spring configuration also
    ClientProxy.getClient(client).getOutInterceptors().add(new CustomerSecurityInterceptor());
    ClientProxy.getClient(client).getOutInterceptors().add(new WSS4JOutInterceptor());
    String ret = client.sayHi("ffang");
    System.out.println(ret);
}
 

public void sendRequest() throws Exception {
    JaxWsProxyFactoryBean factory = new JaxWsProxyFactoryBean();
    factory.setServiceClass(HelloWorld.class);
    factory.setAddress("http://localhost:8181/cxf/HelloWorldSecurity");
    HelloWorld client = (HelloWorld) factory.create();
    
    Map<String, Object> outProps = new HashMap<String, Object>();
    outProps.put("action", "UsernameToken");

    //add a CustomerSecurityInterceptor for client side to init wss4j staff
    //retrieve and set user/password,  users can easily add this interceptor
    //through spring configuration also
    ClientProxy.getClient(client).getOutInterceptors().add(new CustomerSecurityInterceptor());
    ClientProxy.getClient(client).getOutInterceptors().add(new WSS4JOutInterceptor());
    String ret = client.sayHi("ffang");
    System.out.println(ret);
}
 

private void setupClientAndRhino(String clientProxyFactoryBeanId) throws IOException {
    testUtilities.setBus(getBean(Bus.class, "cxf"));

    testUtilities.initializeRhino();
    testUtilities.readResourceIntoRhino("/org/apache/cxf/javascript/cxf-utils.js");

    clientProxyFactory = getBean(JaxWsProxyFactoryBean.class, clientProxyFactoryBeanId);
    client = clientProxyFactory.getClientFactoryBean().create();
    serviceInfos = client.getEndpoint().getService().getServiceInfos();
    // there can only be one.
    assertEquals(1, serviceInfos.size());
    ServiceInfo serviceInfo = serviceInfos.get(0);
    schemata = serviceInfo.getSchemas();
    nameManager = BasicNameManager.newNameManager(serviceInfo);
    NamespacePrefixAccumulator prefixAccumulator =
        new NamespacePrefixAccumulator(serviceInfo.getXmlSchemaCollection());
    for (SchemaInfo schema : schemata) {
        SchemaJavascriptBuilder builder = new SchemaJavascriptBuilder(serviceInfo
            .getXmlSchemaCollection(), prefixAccumulator, nameManager);
        String allThatJavascript = builder.generateCodeForSchema(schema.getSchema());
        assertNotNull(allThatJavascript);
        testUtilities.readStringIntoRhino(allThatJavascript, schema.toString() + ".js");
    }
}
 

private static <T> T createPort(QName serviceName, QName portName, Class<T> serviceEndpointInterface,
                                boolean enableMTOM) throws Exception {
    JaxWsProxyFactoryBean factory = new JaxWsProxyFactoryBean();
    factory.setBus(bus);
    factory.setServiceName(serviceName);
    factory.setServiceClass(serviceEndpointInterface);
    factory.setWsdlURL(ClientMtomXopTest.class.getResource("/wsdl/mtom_xop.wsdl").toExternalForm());
    factory.setFeatures(Collections.singletonList(cff));
    factory.getInInterceptors().add(new TestMultipartMessageInterceptor());
    factory.getOutInterceptors().add(new TestAttachmentOutInterceptor());
    @SuppressWarnings("unchecked")
    T proxy = (T)factory.create();
    BindingProvider bp = (BindingProvider)proxy;
    SOAPBinding binding = (SOAPBinding)bp.getBinding();
    binding.setMTOMEnabled(true);
    return proxy;
}
 

private void setupClientAndRhino(String clientProxyFactoryBeanId) throws IOException {
    testUtilities.setBus(getBean(Bus.class, "cxf"));

    testUtilities.initializeRhino();
    testUtilities.readResourceIntoRhino("/org/apache/cxf/javascript/cxf-utils.js");

    clientProxyFactory = getBean(JaxWsProxyFactoryBean.class, clientProxyFactoryBeanId);
    client = clientProxyFactory.getClientFactoryBean().create();
    serviceInfos = client.getEndpoint().getService().getServiceInfos();
    // there can only be one.
    assertEquals(1, serviceInfos.size());
    ServiceInfo serviceInfo = serviceInfos.get(0);
    schemata = serviceInfo.getSchemas();
    nameManager = BasicNameManager.newNameManager(serviceInfo);
    NamespacePrefixAccumulator prefixAccumulator =
        new NamespacePrefixAccumulator(serviceInfo.getXmlSchemaCollection());
    for (SchemaInfo schema : schemata) {
        SchemaJavascriptBuilder builder = new SchemaJavascriptBuilder(serviceInfo
            .getXmlSchemaCollection(), prefixAccumulator, nameManager);
        String allThatJavascript = builder.generateCodeForSchema(schema.getSchema());
        assertNotNull(allThatJavascript);
        testUtilities.readStringIntoRhino(allThatJavascript, schema.toString() + ".js");
    }
}
 

@Test
public void testCollection() throws Exception {
    AegisDatabinding aegisBinding = new AegisDatabinding();
    JaxWsProxyFactoryBean proxyFactory = new JaxWsProxyFactoryBean();
    proxyFactory.setDataBinding(aegisBinding);
    proxyFactory.setServiceClass(SportsService.class);
    proxyFactory.setWsdlLocation("http://localhost:" + PORT + "/jaxwsAndAegisSports?wsdl");
    proxyFactory.getInInterceptors().add(new LoggingInInterceptor());
    proxyFactory.getOutInterceptors().add(new LoggingOutInterceptor());
    SportsService service = (SportsService) proxyFactory.create();

    Collection<Team> teams = service.getTeams();
    assertEquals(1, teams.size());
    assertEquals("Patriots", teams.iterator().next().getName());

    //CXF-1251
    String s = service.testForMinOccurs0("A", null, "b");
    assertEquals("Anullb", s);
}
 

@Test
public void testComplexMapResult() throws Exception {
    AegisDatabinding aegisBinding = new AegisDatabinding();
    JaxWsProxyFactoryBean proxyFactory = new JaxWsProxyFactoryBean();
    proxyFactory.setDataBinding(aegisBinding);
    proxyFactory.setServiceClass(SportsService.class);
    proxyFactory.setAddress("http://localhost:" + PORT + "/jaxwsAndAegisSports");
    proxyFactory.getInInterceptors().add(new LoggingInInterceptor());
    proxyFactory.getOutInterceptors().add(new LoggingOutInterceptor());
    SportsService service = (SportsService) proxyFactory.create();
    Map<String, Map<Integer, Integer>> result = service.testComplexMapResult();
    assertEquals(result.size(), 1);
    assertTrue(result.containsKey("key1"));
    assertNotNull(result.get("key1"));
    assertEquals(result.toString(), "{key1={1=3}}");
}
 

public static void main(final String[] args) {
  final String msg = "hello";

  final JaxWsServerFactoryBean serverFactory = new JaxWsServerFactoryBean();
  serverFactory.setAddress(BASE_URI);
  serverFactory.setServiceBean(new EchoImpl());
  final Server server = serverFactory.create();

  final JaxWsProxyFactoryBean clientFactory = new JaxWsProxyFactoryBean();
  clientFactory.setServiceClass(Echo.class);
  clientFactory.setAddress(BASE_URI);
  final Echo echo = (Echo)clientFactory.create();

  echo.echo(msg);

  // CXF Tracing span has no "component" tag, cannot use TestUtil.checkSpan()
  checkSpans(2);

  server.destroy();
  serverFactory.getBus().shutdown(true);
}
 

protected Object getProxy(Class<?> sinkInterface, Class<?>... extraClasses) {
    //needed SOAP handlers
    ReferenceParametersAddingHandler handler = new
            ReferenceParametersAddingHandler(
            target.getNotificationReferenceParams());

    JaxWsProxyFactoryBean service = new JaxWsProxyFactoryBean();
    service.getOutInterceptors().add(new LoggingOutInterceptor());
    service.setServiceClass(sinkInterface);
    service.setAddress(target.getTargetURL());
    service.getHandlers().add(handler);

    // do we need to apply a filter?
    if (target.getFilter() != null && target.getFilter().getContent().size() > 0) {
        service.getOutInterceptors().add(new FilteringInterceptor(target.getFilter()));
    }

    if (extraClasses != null && extraClasses.length > 0) {
        Map<String, Object> props = new HashMap<>();
        props.put("jaxb.additionalContextClasses", extraClasses);
        service.getClientFactoryBean().getServiceFactory().setProperties(props);
    }

    return service.create();
}
 

public Metadata parse(Element element, ParserContext context) {
    String s = element.getLocalName();
    if ("endpoint".equals(s)) {
        return new EndpointDefinitionParser().parse(element, context);
    } else if ("server".equals(s)) {
        return new ServerFactoryBeanDefinitionParser(BPJaxWsServerFactoryBean.class)
            .parse(element, context);
    } else if ("client".equals(s)) {
        return new ClientProxyFactoryBeanDefinitionParser(JaxWsProxyFactoryBean.class)
            .parse(element, context);
    }
    return null;
}
 

public static XKMSPortType create(String endpointAddress, Bus bus) {
    JaxWsProxyFactoryBean factory = new JaxWsProxyFactoryBean();
    factory.setBus(bus);
    factory.setServiceClass(XKMSPortType.class);
    factory.setAddress(endpointAddress);

    Map<String, Object> properties = new HashMap<>();
    properties.put("jaxb.additionalContextClasses",
                   new Class[] {ResultDetails.class});
    factory.setProperties(properties);

    return (XKMSPortType)factory.create();
}
 

@Override
public void executeApp() throws Exception {
    int port = getAvailablePort();
    Endpoint.publish("http://localhost:" + port + "/cxf/helloWorld", new HelloWorldImpl());
    JaxWsProxyFactoryBean factory = new JaxWsProxyFactoryBean();
    factory.setServiceClass(HelloWorld.class);
    factory.setAddress("http://localhost:" + port + "/cxf/helloWorld");
    client = (HelloWorld) factory.create();

    transactionMarker();
}
 

@Test
public void testClientProxyFactory() {
    JaxWsProxyFactoryBean cf = new JaxWsProxyFactoryBean();
    cf.setAddress("http://localhost:" + PORT + "/test");
    cf.getFeatures().add(new WSAddressingFeature());
    cf.setServiceClass(Greeter.class);
    Greeter greeter = (Greeter) cf.create();
    Client client = ClientProxy.getClient(greeter);
    checkAddressInterceptors(client.getInInterceptors());
}
 

@Test
public void testHelloService() throws Exception {
    JaxWsProxyFactoryBean cpfb = new JaxWsProxyFactoryBean();
    String address = serviceURL + "Hello";
    cpfb.setServiceClass(Hello.class);
    cpfb.setAddress(address);
    Hello hello = (Hello) cpfb.create();
    String reply = hello.sayHi(" Willem");
    assertEquals("Get the wrongreply ", reply, "get Willem");
}
 

public static void main(String[] args) {
    JaxWsProxyFactoryBean factory = new JaxWsProxyFactoryBean();
    factory.getInInterceptors().add(new LoggingInInterceptor());
    factory.getOutInterceptors().add(new LoggingOutInterceptor());
    factory.setServiceClass(Counter.class);
    factory.setAddress("http://localhost:12345/counter");
    Counter counter = (Counter) factory.create();
    counter.inc();
    counter.inc();
    counter.inc();
    counter.inc();
    counter.inc();

    System.out.println(counter.getCount());
}
 

@Test
public void testUseFailOverOnClient() throws Exception {
    List<String> serviceList = new ArrayList<>();
    serviceList.add("http://localhost:" + PORT + "/SoapContext/GreeterPort");

    RandomStrategy strategy = new RandomStrategy();
    strategy.setAlternateAddresses(serviceList);

    FailoverFeature ff = new FailoverFeature();
    ff.setStrategy(strategy);

    // setup the feature by using JAXWS front-end API
    JaxWsProxyFactoryBean factory = new JaxWsProxyFactoryBean();
    // set a fake address to kick off the failover feature
    factory.setAddress("http://localhost:" + PORT2 + "/SoapContext/GreeterPort");
    factory.getFeatures().add(ff);
    factory.setServiceClass(Greeter.class);
    Greeter proxy = factory.create(Greeter.class);

    Response<GreetMeResponse>  response = proxy.greetMeAsync("cxf");
    int waitCount = 0;
    while (!response.isDone() && waitCount < 15) {
        Thread.sleep(1000);
        waitCount++;
    }
    assertTrue("Response still not received.", response.isDone());

}
 

private Echo createClientProxy() {
    JaxWsProxyFactoryBean proxyFac = new JaxWsProxyFactoryBean();
    proxyFac.setServiceClass(Echo.class);
    proxyFac.setAddress("local://Echo");
    proxyFac.getClientFactoryBean().setTransportId(LocalTransportFactory.TRANSPORT_ID);

    return (Echo)proxyFac.create();
}
 

@Test
public void testNoWsaFeature() throws Exception {
    ByteArrayOutputStream input = setupInLogging();
    ByteArrayOutputStream output = setupOutLogging();

    JaxWsProxyFactoryBean factory = new JaxWsProxyFactoryBean();
    factory.setServiceClass(AddNumbersPortType.class);
    factory.setAddress("http://localhost:" + PORT + "/jaxws/add");
    AddNumbersPortType port = (AddNumbersPortType) factory.create();

    assertEquals(3, port.addNumbers(1, 2));

    assertLogNotContains(output.toString(), "//wsa:Address");
    assertLogNotContains(input.toString(), "//wsa:RelatesTo");
}
 

/**
 * 不需要总经理审批
 * @throws ParseException
 */
@Test
public void testFalse() throws ParseException {
    JaxWsProxyFactoryBean factory = new JaxWsProxyFactoryBean();
    factory.getInInterceptors().add(new LoggingInInterceptor());
    factory.getOutInterceptors().add(new LoggingOutInterceptor());
    factory.setServiceClass(LeaveWebService.class);
    factory.setAddress(LeaveWebserviceUtil.WEBSERVICE_URL);
    LeaveWebService leaveWebService = (LeaveWebService) factory.create();
    boolean audit = leaveWebService.generalManagerAudit("2013-01-01 09:00", "2013-01-04 17:30");
    assertFalse(audit);
}