END_TEST
START_TEST (test_cometd_process_connect_takes_advice_when_it_exists)
{
cometd_conn* conn = g_instance->conn;
cometd_conn_set_client_id(conn, "testid");
cometd_conn_set_transport(conn, &TEST_TRANSPORT);
// set advice
JsonNode* msg = cometd_msg_connect_new(g_instance);
cometd_advice* advice = cometd_advice_new();
cometd_msg_set_advice(msg, advice);
cometd_process_connect(g_instance, msg);
// no advice
JsonNode* bad_connect = cometd_msg_bad_connect_new(g_instance);
cometd_process_connect(g_instance, bad_connect);
// assert advice exists
fail_unless(cometd_conn_advice(conn)->reconnect == COMETD_RECONNECT_NONE);
cometd_advice_destroy(advice);
json_node_free(msg);
json_node_free(bad_connect);
}
void
_cockpit_assert_json_eq_msg (const char *domain,
const char *file,
int line,
const char *func,
JsonObject *object,
const gchar *expect)
{
GError *error = NULL;
JsonNode *node;
JsonNode *exnode;
gchar *escaped;
gchar *msg;
node = json_node_init_object (json_node_alloc (), object);
exnode = cockpit_json_parse (expect, -1, &error);
if (error)
g_assertion_message_error (domain, file, line, func, "error", error, 0, 0);
g_assert (exnode);
if (!cockpit_json_equal (exnode, node))
{
escaped = cockpit_json_write (node, NULL);
msg = g_strdup_printf ("%s != %s", escaped, expect);
g_assertion_message (domain, file, line, func, msg);
g_free (escaped);
g_free (msg);
}
json_node_free (node);
json_node_free (exnode);
}
static JSValueRef
js_emit (JSContextRef ctx, JSObjectRef object, JSObjectRef thisObject,
size_t argumentCount, const JSValueRef arguments[],
JSValueRef * exception)
{
JsonObject *obj;
JsonNode *node;
gchar *buffer;
if (argumentCount != 1)
{
*exception = JSValueMakeNumber (ctx, 1);
return NULL;
}
if (JSValueIsObject (ctx, arguments[0]) == false)
{
*exception = JSValueMakeNumber (ctx, 1);
return NULL;
}
obj = json_object_new();
js_value (ctx, (JSObjectRef) arguments[0], &node);
json_object_set_member (obj, "emit", node);
JsonNode *node1 = json_node_new (JSON_NODE_OBJECT);
if (node1 == NULL)
{
json_object_unref (obj);
return NULL;
}
json_node_set_object (node1, obj);
JsonGenerator *gen = json_generator_new();
if (gen == NULL)
{
json_node_free (node1);
return NULL;
}
json_generator_set_root (gen, node1 );
buffer = json_generator_to_data (gen,NULL);
if (buffer == NULL)
{
json_node_free (node1);
g_object_unref (gen);
return NULL;
}
json_node_free (node1);
g_object_unref (gen);
puts (buffer);
g_free (buffer);
return NULL; /* shouldn't be an object ? */
}
END_TEST
START_TEST (test_cometd_new_publish_message)
{
cometd_conn_set_client_id(g_instance->conn, "testid");
const char* expected_channel = "/baz/bar";
JsonNode* node = cometd_json_str2node("{ \"hey\": \"now\" }");
JsonNode* message = cometd_new_publish_message(g_instance,
expected_channel,
node);
JsonObject* obj = json_node_get_object(message);
const gchar* actual_channel = json_object_get_string_member(obj,
COMETD_MSG_CHANNEL_FIELD);
ck_assert_str_eq(expected_channel, actual_channel);
JsonObject* data = json_object_get_object_member(obj,
COMETD_MSG_DATA_FIELD);
const char* value = json_object_get_string_member(data, "hey");
ck_assert_str_eq("now", value);
json_node_free(message);
json_node_free(node);
}
static gboolean
is_match(char* a, char* b, GList* exclude_props)
{
JsonNode* node_a = cometd_json_str2node(a);
JsonNode* node_b = cometd_json_str2node(b);
gboolean ret = json_node_equal(node_a, node_b, exclude_props);
json_node_free(node_a);
json_node_free(node_b);
return ret;
}
static char *
file_list_to_json (GList *files)
{
JsonNode *root;
JsonArray *array;
GList *ptr;
char *file;
JsonGenerator *gen;
char *json_data;
gsize len;
root = json_node_new (JSON_NODE_ARRAY);
array = json_array_new ();
for (ptr = files; ptr; ptr = ptr->next) {
file = ptr->data;
json_array_add_string_element (array, file);
}
json_node_set_array (root, array);
gen = json_generator_new ();
json_generator_set_root (gen, root);
json_data = json_generator_to_data (gen, &len);
json_node_free (root);
g_object_unref (gen);
return json_data;
}
static void _piwigo_set_account(dt_storage_piwigo_gui_data_t *ui)
{
/// serialize data;
JsonBuilder *builder = json_builder_new();
json_builder_begin_object(builder);
json_builder_set_member_name(builder, "server");
json_builder_add_string_value(builder, gtk_entry_get_text(ui->server_entry));
json_builder_set_member_name(builder, "username");
json_builder_add_string_value(builder, gtk_entry_get_text(ui->user_entry));
json_builder_set_member_name(builder, "password");
json_builder_add_string_value(builder, gtk_entry_get_text(ui->pwd_entry));
json_builder_end_object(builder);
JsonNode *node = json_builder_get_root(builder);
JsonGenerator *generator = json_generator_new();
json_generator_set_root(generator, node);
#if JSON_CHECK_VERSION(0, 14, 0)
json_generator_set_pretty(generator, FALSE);
#endif
gchar *data = json_generator_to_data(generator, NULL);
json_node_free(node);
g_object_unref(generator);
g_object_unref(builder);
GHashTable *table = dt_pwstorage_get("piwigo");
g_hash_table_insert(table, g_strdup(gtk_entry_get_text(ui->server_entry)), data);
dt_pwstorage_set("piwigo", table);
g_hash_table_destroy(table);
}
static void
picasa_web_service_get_user_info_ready_cb (SoupSession *session,
SoupMessage *msg,
gpointer user_data)
{
PicasaWebService *self = user_data;
GSimpleAsyncResult *result;
GError *error = NULL;
JsonNode *node;
result = _web_service_get_result (WEB_SERVICE (self));
if (picasa_web_utils_parse_json_response (msg, &node, &error)) {
OAuthAccount *account;
account = (OAuthAccount *) json_gobject_deserialize (OAUTH_TYPE_ACCOUNT, node);
g_object_set (account,
"token", self->priv->access_token,
"token-secret", self->priv->refresh_token,
NULL);
g_simple_async_result_set_op_res_gpointer (result,
g_object_ref (account),
(GDestroyNotify) g_object_unref);
_g_object_unref (account);
json_node_free (node);
}
else
g_simple_async_result_set_from_error (result, error);
g_simple_async_result_complete_in_idle (result);
}
static void save_account_info(dt_storage_facebook_gui_data_t *ui, FBAccountInfo *accountinfo)
{
FBContext *ctx = ui->facebook_api;
g_return_if_fail(ctx != NULL);
///serialize data;
JsonBuilder *builder = json_builder_new();
json_builder_begin_object(builder);
json_builder_set_member_name(builder, "username");
json_builder_add_string_value(builder, accountinfo->username);
json_builder_set_member_name(builder, "token");
json_builder_add_string_value(builder, accountinfo->token);
json_builder_end_object(builder);
JsonNode *node = json_builder_get_root(builder);
JsonGenerator *generator = json_generator_new();
json_generator_set_root(generator, node);
#if JSON_CHECK_VERSION(0, 14, 0)
json_generator_set_pretty(generator, FALSE);
#endif
gchar *data = json_generator_to_data(generator, NULL);
json_node_free(node);
g_object_unref(generator);
g_object_unref(builder);
GHashTable *table = dt_pwstorage_get("facebook");
g_hash_table_insert(table, accountinfo->id, data);
dt_pwstorage_set("facebook", table);
g_hash_table_destroy(table);
}
int
cometd_unsubscribe(const cometd* h, cometd_subscription* s)
{
g_return_val_if_fail(s != NULL, ECOMETD_UNKNOWN);
g_return_val_if_fail(s->channel != NULL, ECOMETD_UNKNOWN);
const char* channel = s->channel;
int code = ECOMETD_UNKNOWN;
JsonNode* node;
/*
We can't unsubscribe from a remote meta channel and we only
want to remotely unsubscribe if this is the last remaining
listener.
*/
if (cometd_is_meta_channel(channel) == FALSE && cometd_listener_count(h, channel) == 1)
{
JsonNode* node = cometd_new_unsubscribe_message(h, channel);
if (node != NULL)
{
code = cometd_transport_send(h, node);
json_node_free(node);
}
}
// don't remove the local listener if the remote call failed
if (code != COMETD_SUCCESS)
code = cometd_remove_listener(h, s);
return code;
}
static JsonGenerator *
_model_to_generator (MexQueueModel *model)
{
gint i;
JsonArray *json_array;
JsonNode *root;
JsonGenerator *generator;
json_array = json_array_sized_new (mex_model_get_length (MEX_MODEL (model)));
for (i = 0; i < mex_model_get_length (MEX_MODEL (model)); i++)
{
MexContent *content;
JsonNode *content_node;
content = mex_model_get_content (MEX_MODEL (model), i);
content_node = json_gobject_serialize (G_OBJECT (content));
json_array_add_element (json_array, content_node);
}
generator = json_generator_new ();
root = json_node_new (JSON_NODE_ARRAY);
json_node_set_array (root, json_array);
json_generator_set_root (generator, root);
json_array_unref (json_array);
json_node_free (root);
return generator;
}
/**
* json_gobject_to_data:
* @gobject: a #GObject
* @length: (out): return value for the length of the buffer, or %NULL
*
* Serializes a #GObject into a JSON data stream, iterating recursively
* over each property.
*
* If @gobject implements the #JsonSerializableIface interface, it will
* be asked to serialize all its properties; otherwise, the default
* implementation will be use to translate the compatible types into
* JSON native types.
*
* Return value: a JSON data stream representing the passed #GObject
*
* Since: 0.10
*/
gchar *
json_gobject_to_data (GObject *gobject,
gsize *length)
{
JsonGenerator *gen;
JsonNode *root;
gchar *data;
g_return_val_if_fail (G_OBJECT (gobject), NULL);
root = json_gobject_serialize (gobject);
gen = g_object_new (JSON_TYPE_GENERATOR,
"root", root,
"pretty", TRUE,
"indent", 2,
NULL);
data = json_generator_to_data (gen, length);
g_object_unref (gen);
json_node_free (root);
return data;
}
/**
* json_reader_set_root:
* @reader: a #JsonReader
* @root: (allow-none): a #JsonNode
*
* Sets the root #JsonNode to be read by @reader. The @reader will take
* a copy of @root
*
* If another #JsonNode is currently set as root, it will be replaced.
*
* Since: 0.12
*/
void
json_reader_set_root (JsonReader *reader,
JsonNode *root)
{
JsonReaderPrivate *priv;
g_return_if_fail (JSON_IS_READER (reader));
priv = reader->priv;
if (priv->root == root)
return;
if (priv->root != NULL)
{
json_node_free (priv->root);
priv->root = NULL;
priv->current_node = NULL;
priv->previous_node = NULL;
}
if (root != NULL)
{
priv->root = json_node_copy (root);
priv->current_node = priv->root;
priv->previous_node = NULL;
}
g_object_notify_by_pspec (G_OBJECT (reader), reader_properties[PROP_ROOT]);
}
gpointer
cometd_loop_gthread_run(gpointer data)
{
const cometd* h = (const cometd*) data;
cometd_conn* conn = h->conn;
cometd_loop* loop = h->loop;
JsonNode *connect = NULL, *payload = NULL;
long backoff = 0;
guint attempt;
for (attempt = 1; cometd_should_recv(h); ++attempt)
{
cometd_loop_wait(loop, backoff);
payload = cometd_recv(h);
connect = cometd_msg_extract_connect(payload);
cometd_inbox_push(h->inbox, payload);
cometd_process_msg(h, connect);
if (cometd_should_retry_recv(h))
backoff = cometd_get_backoff(h, attempt);
else
backoff = attempt = 0;
json_node_free(payload);
json_node_free(connect);
// bail out if we should no longer backoff
if (backoff == -1)
break;
}
// If we've bailed from the loop, it's because we gave up
// on the COMETD_UNCONNECTED state and we are no longer retrying or we
// have intentially disconnected.
//
// If we gave up retrying, then this ensures that our state gets set correctly
// and it should be a signal to the inbox queue to stop waiting.
cometd_conn_set_state(conn, COMETD_DISCONNECTED);
return NULL;
}
static void trg_request_free(trg_request *req) {
g_free(req->body);
g_free(req->url);
g_free(req->cookie);
if (req->node)
json_node_free(req->node);
}
static JsonNode* create_fault_msg_response(int error_num, const char *message, int id)
{
JsonNode *msg_node = json_node_new(JSON_NODE_VALUE);
json_node_set_string(msg_node, message);
JsonNode *node = create_fault_value_response(error_num, msg_node, id);
json_node_free(msg_node);
return node;
}
static gchar* do_get_action(IpcamIAjax *iajax, GList *item_list)
{
JsonBuilder *builder;
JsonNode *res_node = NULL;
GList *item;
JsonGenerator *generator;
builder = json_builder_new();
generator = json_generator_new();
json_builder_begin_object(builder);
json_builder_set_member_name(builder, "items");
json_builder_begin_object(builder);
for (item = g_list_first(item_list); item; item = g_list_next(item))
{
const gchar *name = item->data;
if (g_str_equal(name, "method"))
{
GVariant *value = NULL;
value = ipcam_iajax_get_configuration(iajax, "network:method");
if (value)
{
add_value(builder, name, value);
g_variant_unref(value);
}
}
else if (g_str_equal(name, "address"))
{
do_get_action_address(iajax, builder);
}
else if (g_str_equal(name, "pppoe"))
{
do_get_action_pppoe(iajax, builder);
}
else if (g_str_equal(name, "port"))
{
do_get_action_port(iajax, builder);
}
else
{
g_warn_if_reached();
}
}
json_builder_end_object(builder);
json_builder_end_object(builder);
res_node = json_builder_get_root(builder);
json_generator_set_root(generator, res_node);
json_generator_set_pretty(generator, TRUE);
gchar *result = json_generator_to_data(generator, NULL);;
json_node_free(res_node);
g_object_unref(G_OBJECT(builder));
g_object_unref(G_OBJECT(generator));
return result;
}
void
snarf_alert_free(snarf_alert_t *alert)
{
json_node_free (alert->msg);
g_free (alert);
}
/**
* json_array_remove_element:
* @array: a #JsonArray
* @index_: the position of the element to be removed
*
* Removes the #JsonNode inside @array at @index_ freeing its allocated
* resources.
*/
void
json_array_remove_element (JsonArray *array,
guint index_)
{
g_return_if_fail (array != NULL);
g_return_if_fail (index_ < array->elements->len);
json_node_free (g_ptr_array_remove_index (array->elements, index_));
}
static void
glide_window_set_copy_buffer (GlideWindow *w, GlideActor *copy)
{
w->priv->keep_buffer = TRUE;
if (w->priv->copy_buffer)
json_node_free (w->priv->copy_buffer);
w->priv->copy_buffer = glide_actor_serialize (copy);
}
END_TEST
START_TEST (test_cometd_msg_advice_null)
{
JsonNode* n = json_from_fixture("advice_reconnect_null");
cometd_advice* advice = cometd_msg_advice(n);
fail_unless(advice == NULL);
json_node_free(n);
}
trg_response *dispatch(TrgClient * tc, JsonNode * req)
{
gchar *serialized = trg_serialize(req);
json_node_free(req);
#ifdef DEBUG
if (g_getenv("TRG_SHOW_OUTGOING"))
g_debug("=>(OUTgoing)=>: %s", serialized);
#endif
return dispatch_str(tc, serialized);
}
static void
assert_bool_node_func(char *str,
gboolean (*cb)(JsonNode* n),
gboolean expected)
{
JsonNode* n = cometd_json_str2node(str);
gboolean ret = cb(n);
fail_unless(ret == expected);
json_node_free(n);
}
int main(int argc, char *argv[])
{
JSONNode *root = json_loads_from_data(JSON);
if (root == NULL) {
printf("invalid format!\n");
return -1;
}
json_print(root, 0);
json_node_free(root);
return 0;
}
END_TEST
START_TEST (test_cometd_msg_client_id)
{
JsonNode* n = cometd_json_str2node("{ \"clientId\": \"abcd\" }");
gchar* client_id = cometd_msg_client_id(n);
ck_assert_str_eq("abcd", client_id);
json_node_free(n);
g_free(client_id);
}
END_TEST
START_TEST (test_cometd_msg_advice_retry)
{
JsonNode* n = json_from_fixture("advice_reconnect_retry");
cometd_advice* advice = cometd_msg_advice(n);
ck_assert_int_eq(COMETD_RECONNECT_RETRY, advice->reconnect);
ck_assert_int_eq(100, advice->interval);
cometd_advice_destroy(advice);
json_node_free(n);
}
END_TEST
START_TEST (test_cometd_transport_send_fires_outgoing_ext)
{
cometd_conn_set_transport(g_instance->conn, &TEST_TRANSPORT);
JsonNode* expected = cometd_json_str2node("{ \"foo\": 1}");
gboolean ret = FALSE;
cometd_ext* ext = cometd_ext_new();
ext->outgoing = add_foo;
cometd_ext_add(&g_instance->exts, ext);
JsonNode* node = cometd_json_str2node("{}");
cometd_transport_send(g_instance, node);
ret = json_node_equal(expected, node, NULL);
fail_unless(ret);
json_node_free(node);
json_node_free(expected);
}
END_TEST
START_TEST (test_cometd_new_handshake_message) {
long seed = g_instance->conn->msg_id_seed;
JsonNode* msg = cometd_new_handshake_message(g_instance);
JsonObject* obj = json_node_get_object(msg);
int id = json_object_get_int_member(obj, COMETD_MSG_ID_FIELD);
json_node_free(msg);
fail_unless(id == 1);
}
END_TEST
START_TEST (test_cometd_msg_extract_connect)
{
JsonNode* payload = json_from_fixture("connect_payload");
JsonNode* connect = cometd_msg_extract_connect(payload);
JsonNode* expected_connect = cometd_json_str2node(" \
{ \"channel\": \"/meta/connect\", \
\"clientId\": \"Un1q31d3nt1f13r\", \
\"connectionType\": \"long-polling\", \
\"successful\": true }");
fail_unless(json_node_equal(expected_connect, connect, NULL));
JsonNode* expected_payload = cometd_json_str2node("[{ \"channel\": \"/foo/bar\"}]");
fail_unless(json_node_equal(expected_payload, payload, NULL));
json_node_free(payload);
json_node_free(connect);
json_node_free(expected_payload);
json_node_free(expected_connect);
}
static JsonNode *
melo_jsonrpc_build_response_node (JsonNode *result, JsonNode *error,
const gchar *id, gint64 nid)
{
JsonBuilder *builder;
JsonNode *node;
/* Create new builder */
builder = json_builder_new ();
if (!builder)
return NULL;
/* Begin a new object */
json_builder_begin_object (builder);
/* Add jsonrpc member */
json_builder_set_member_name (builder, "jsonrpc");
json_builder_add_string_value (builder, "2.0");
/* Set result or error */
if (error) {
/* Add error member */
json_builder_set_member_name (builder, "error");
json_builder_add_value (builder, error);
/* Free result if exists */
if (result)
json_node_free (result);
} else if (result) {
/* Add result member */
json_builder_set_member_name (builder, "result");
json_builder_add_value (builder, result);
}
/* Add id member: we assume ID cannot be negative */
json_builder_set_member_name (builder, "id");
if (nid < 0 || id)
json_builder_add_string_value (builder, id);
else
json_builder_add_int_value (builder, nid);
json_builder_end_object (builder);
/* Get final object */
node = json_builder_get_root (builder);
/* Free builder */
g_object_unref (builder);
return node;
}
