File: mock-server.h

package info (click to toggle)
syslog-ng 3.8.1-10
  • links: PTS, VCS
  • area: main
  • in suites: stretch
  • size: 47,320 kB
  • ctags: 43,937
  • sloc: ansic: 159,432; yacc: 25,059; sh: 13,574; makefile: 4,669; python: 3,468; java: 3,218; xml: 2,309; perl: 318; lex: 316; awk: 184
file content (148 lines) | stat: -rw-r--r-- 5,312 bytes parent folder | download
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
/*
 * Copyright 2015 MongoDB, Inc.
 *
 * Licensed 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 MOCK_SERVER_H
#define MOCK_SERVER_H

#include <bson.h>

#include "mongoc-uri.h"

#ifdef MONGOC_ENABLE_SSL

#include "mongoc-ssl.h"

#endif

#include "request.h"

typedef struct _mock_server_t mock_server_t;
typedef struct _autoresponder_handle_t autoresponder_handle_t;

typedef bool (*autoresponder_t) (request_t *request, void *data);

typedef void (*destructor_t) (void *data);

mock_server_t *mock_server_new ();

mock_server_t *mock_server_with_autoismaster (int32_t max_wire_version);

mock_server_t *mock_server_down (void);

int mock_server_autoresponds (mock_server_t *server,
                              autoresponder_t responder,
                              void *data,
                              destructor_t destructor);

void mock_server_remove_autoresponder (mock_server_t *server,
                                       int id);

int mock_server_auto_ismaster (mock_server_t *server,
                               const char *response_json,
                               ...);

#ifdef MONGOC_ENABLE_SSL

void mock_server_set_ssl_opts (mock_server_t *server,
                               mongoc_ssl_opt_t *opts);

#endif

uint16_t mock_server_run (mock_server_t *server);

const mongoc_uri_t *mock_server_get_uri (mock_server_t *server);

const char *mock_server_get_host_and_port (mock_server_t *server);

uint16_t mock_server_get_port (mock_server_t *server);

bool mock_server_get_verbose (mock_server_t *server);

void mock_server_set_verbose (mock_server_t *server,
                              bool verbose);

int64_t mock_server_get_request_timeout_msec (mock_server_t *server);

void mock_server_set_request_timeout_msec (mock_server_t *server,
                                           int64_t request_timeout_msec);

bool mock_server_get_rand_delay (mock_server_t *server);

void mock_server_set_rand_delay (mock_server_t *server,
                                 bool rand_delay);

double mock_server_get_uptime_sec (mock_server_t *server);

request_t *mock_server_receives_command (mock_server_t *server,
                                         const char *database_name,
                                         mongoc_query_flags_t flags,
                                         const char *command_json,
                                         ...);

request_t *mock_server_receives_ismaster (mock_server_t *server);

request_t *mock_server_receives_gle (mock_server_t *server,
                                     const char *database_name);

request_t *mock_server_receives_query (mock_server_t *server,
                                       const char *ns,
                                       mongoc_query_flags_t flags,
                                       uint32_t skip,
                                       uint32_t n_return,
                                       const char *query_json,
                                       const char *fields_json);

request_t *mock_server_receives_insert (mock_server_t *server,
                                        const char *ns,
                                        mongoc_insert_flags_t flags,
                                        const char *doc_json);

request_t *mock_server_receives_bulk_insert (mock_server_t *server,
                                             const char *ns,
                                             mongoc_insert_flags_t flags,
                                             int n);

request_t *mock_server_receives_update (mock_server_t *server,
                                        const char *ns,
                                        mongoc_update_flags_t flags,
                                        const char *selector_json,
                                        const char *update_json);

request_t * mock_server_receives_delete (mock_server_t *server,
                                         const char *ns,
                                         mongoc_remove_flags_t flags,
                                         const char *selector_json);

request_t *mock_server_receives_kill_cursors (mock_server_t *server,
                                              int64_t cursor_id);

void mock_server_hangs_up (request_t *request);

void mock_server_resets (request_t *request);

void mock_server_replies (request_t *request,
                          uint32_t flags,
                          int64_t cursor_id,
                          int32_t starting_from,
                          int32_t number_returned,
                          const char *docs_json);

void mock_server_replies_simple (request_t *request,
                                 const char *docs_json);

void mock_server_destroy (mock_server_t *server);

#endif //MOCK_SERVER_H