/* ====================================================================
* 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.
* ====================================================================
*/
#ifndef TEST_SERF_H
#define TEST_SERF_H
#include "CuTest.h"
#include <apr.h>
#include <apr_pools.h>
#include <apr_uri.h>
#include "serf.h"
#include "server/test_server.h"
/** These macros are provided by APR itself from version 1.3.
* Definitions are provided here for when using older versions of APR.
*/
/** index into an apr_array_header_t */
#ifndef APR_ARRAY_IDX
#define APR_ARRAY_IDX(ary,i,type) (((type *)(ary)->elts)[i])
#endif
/** easier array-pushing syntax */
#ifndef APR_ARRAY_PUSH
#define APR_ARRAY_PUSH(ary,type) (*((type *)apr_array_push(ary)))
#endif
/* CuTest declarations */
CuSuite *getsuite(void);
CuSuite *test_context(void);
CuSuite *test_buckets(void);
CuSuite *test_ssl(void);
CuSuite *test_auth(void);
CuSuite *test_mock_bucket(void);
/* Test setup declarations */
#define CRLF "\r\n"
#define CR "\r"
#define LF "\n"
#define CHUNKED_REQUEST(len, body)\
"GET / HTTP/1.1" CRLF\
"Host: localhost:12345" CRLF\
"Transfer-Encoding: chunked" CRLF\
CRLF\
#len CRLF\
body CRLF\
"0" CRLF\
CRLF
#define CHUNKED_REQUEST_URI(uri, len, body)\
"GET " uri " HTTP/1.1" CRLF\
"Host: localhost:12345" CRLF\
"Transfer-Encoding: chunked" CRLF\
CRLF\
#len CRLF\
body CRLF\
"0" CRLF\
CRLF
#define CHUNKED_RESPONSE(len, body)\
"HTTP/1.1 200 OK" CRLF\
"Transfer-Encoding: chunked" CRLF\
CRLF\
#len CRLF\
body CRLF\
"0" CRLF\
CRLF
#define CHUNKED_EMPTY_RESPONSE\
"HTTP/1.1 200 OK" CRLF\
"Transfer-Encoding: chunked" CRLF\
CRLF\
"0" CRLF\
CRLF
typedef struct {
/* Pool for resource allocation. */
apr_pool_t *pool;
serf_context_t *context;
serf_connection_t *connection;
serf_bucket_alloc_t *bkt_alloc;
serv_ctx_t *serv_ctx;
apr_sockaddr_t *serv_addr;
serv_ctx_t *proxy_ctx;
apr_sockaddr_t *proxy_addr;
/* Cache connection params here so it gets user for a test to switch to a
new connection. */
const char *serv_url;
serf_connection_setup_t conn_setup;
/* Extra batons which can be freely used by tests. */
void *user_baton;
long user_baton_l;
/* Flags that can be used to report situations, e.g. that a callback was
called. */
int result_flags;
apr_array_header_t *accepted_requests, *handled_requests, *sent_requests;
serf_ssl_context_t *ssl_context;
serf_ssl_need_server_cert_t server_cert_cb;
} test_baton_t;
apr_status_t default_https_conn_setup(apr_socket_t *skt,
serf_bucket_t **input_bkt,
serf_bucket_t **output_bkt,
void *setup_baton,
apr_pool_t *pool);
apr_status_t use_new_connection(test_baton_t *tb,
apr_pool_t *pool);
apr_status_t test_https_server_setup(test_baton_t **tb_p,
test_server_message_t *message_list,
apr_size_t message_count,
test_server_action_t *action_list,
apr_size_t action_count,
apr_int32_t options,
serf_connection_setup_t conn_setup,
const char *keyfile,
const char **certfile,
const char *client_cn,
serf_ssl_need_server_cert_t server_cert_cb,
apr_pool_t *pool);
apr_status_t test_http_server_setup(test_baton_t **tb_p,
test_server_message_t *message_list,
apr_size_t message_count,
test_server_action_t *action_list,
apr_size_t action_count,
apr_int32_t options,
serf_connection_setup_t conn_setup,
apr_pool_t *pool);
apr_status_t test_server_proxy_setup(
test_baton_t **tb_p,
test_server_message_t *serv_message_list,
apr_size_t serv_message_count,
test_server_action_t *serv_action_list,
apr_size_t serv_action_count,
test_server_message_t *proxy_message_list,
apr_size_t proxy_message_count,
test_server_action_t *proxy_action_list,
apr_size_t proxy_action_count,
apr_int32_t options,
serf_connection_setup_t conn_setup,
apr_pool_t *pool);
apr_status_t test_https_server_proxy_setup(
test_baton_t **tb_p,
test_server_message_t *serv_message_list,
apr_size_t serv_message_count,
test_server_action_t *serv_action_list,
apr_size_t serv_action_count,
test_server_message_t *proxy_message_list,
apr_size_t proxy_message_count,
test_server_action_t *proxy_action_list,
apr_size_t proxy_action_count,
apr_int32_t options,
serf_connection_setup_t conn_setup,
const char *keyfile,
const char **certfiles,
const char *client_cn,
serf_ssl_need_server_cert_t server_cert_cb,
apr_pool_t *pool);
void *test_setup(void *baton);
void *test_teardown(void *baton);
typedef struct {
serf_response_acceptor_t acceptor;
void *acceptor_baton;
serf_response_handler_t handler;
apr_array_header_t *sent_requests;
apr_array_header_t *accepted_requests;
apr_array_header_t *handled_requests;
int req_id;
const char *method;
const char *path;
/* Use this for a raw request message */
const char *request;
int done;
test_baton_t *tb;
} handler_baton_t;
/* These defines are used with the test_baton_t result_flags variable. */
#define TEST_RESULT_SERVERCERTCB_CALLED 0x0001
#define TEST_RESULT_SERVERCERTCHAINCB_CALLED 0x0002
#define TEST_RESULT_CLIENT_CERTCB_CALLED 0x0004
#define TEST_RESULT_CLIENT_CERTPWCB_CALLED 0x0008
#define TEST_RESULT_AUTHNCB_CALLED 0x001A
apr_status_t
test_helper_run_requests_no_check(CuTest *tc, test_baton_t *tb,
int num_requests,
handler_baton_t handler_ctx[],
apr_pool_t *pool);
void
test_helper_run_requests_expect_ok(CuTest *tc, test_baton_t *tb,
int num_requests,
handler_baton_t handler_ctx[],
apr_pool_t *pool);
serf_bucket_t* accept_response(serf_request_t *request,
serf_bucket_t *stream,
void *acceptor_baton,
apr_pool_t *pool);
apr_status_t setup_request(serf_request_t *request,
void *setup_baton,
serf_bucket_t **req_bkt,
serf_response_acceptor_t *acceptor,
void **acceptor_baton,
serf_response_handler_t *handler,
void **handler_baton,
apr_pool_t *pool);
apr_status_t handle_response(serf_request_t *request,
serf_bucket_t *response,
void *handler_baton,
apr_pool_t *pool);
void setup_handler(test_baton_t *tb, handler_baton_t *handler_ctx,
const char *method, const char *path,
int req_id,
serf_response_handler_t handler);
void create_new_prio_request(test_baton_t *tb,
handler_baton_t *handler_ctx,
const char *method, const char *path,
int req_id);
void create_new_request(test_baton_t *tb,
handler_baton_t *handler_ctx,
const char *method, const char *path,
int req_id);
void
create_new_request_with_resp_hdlr(test_baton_t *tb,
handler_baton_t *handler_ctx,
const char *method, const char *path,
int req_id,
serf_response_handler_t handler);
/* Mock bucket type and constructor */
typedef struct {
int times;
const char *data;
apr_status_t status;
} mockbkt_action;
void read_and_check_bucket(CuTest *tc, serf_bucket_t *bkt,
const char *expected);
void readlines_and_check_bucket(CuTest *tc, serf_bucket_t *bkt,
int acceptable,
const char *expected,
int expected_nr_of_lines);
extern const serf_bucket_type_t serf_bucket_type_mock;
#define SERF_BUCKET_IS_MOCK(b) SERF_BUCKET_CHECK((b), mock)
serf_bucket_t *serf_bucket_mock_create(mockbkt_action *actions,
int len,
serf_bucket_alloc_t *allocator);
apr_status_t serf_bucket_mock_more_data_arrived(serf_bucket_t *bucket);
/* Helper to get a file relative to our source directory by looking at
* 'srcdir' env variable. */
const char * get_srcdir_file(apr_pool_t *pool, const char * file);
#endif /* TEST_SERF_H */