Exemplo n.º 1
0
BOOST_FIXTURE_TEST_CASE( updates_created_different_versions, context )
{
    const json::array response = json_multiple_post(
           subscribe_to_node1()
        << asio_mocks::json_msg( "{ 'id': '192.168.210.1:9999/0' }" )
        << boost::bind( defered_update_node, boost::ref( data_ ), node1, json::string( "update1"),
            boost::ref( static_cast< boost::asio::io_service& >( *this ) ) )
        << asio_mocks::json_msg( "{ 'id': '192.168.210.1:9999/0' }" )
        << asio_mocks::disconnect_read() );

    const json::value version1 = response.at( 1u )
        .upcast< json::object >()
        .at( json::string( "update" ) )
        .upcast< json::array >()
        .at( 0 )
        .upcast< json::object >()
        .at( json::string( "version") );

    const json::value version2 = response.at( 2u )
        .upcast< json::object >()
        .at( json::string( "update" ) )
        .upcast< json::array >()
        .at( 0 )
        .upcast< json::object >()
        .at( json::string( "version") );

    BOOST_CHECK_NE( version1, version2 );
}
Exemplo n.º 2
0
	void response_base< Timer >::handle_connect( const json::object& request,
	    const boost::shared_ptr< response_interface >& self, bool last_message )
	{
	    assert( session_ );

	    if ( !check_connection_type( request, session_->session_id() ) )
	        return;

	    // when there are already messages to be send, then there is no point in blocking
	    const bool do_not_block = !bayeux_response_.empty() || !last_message || zero_timeout_advice( request );
	    const json::array messages = do_not_block ? session_->events() : session_->wait_for_events( self );

	    if ( !messages.empty() )
		{
	        bayeux_response_ += messages;
			bayeux_response_.add( build_connect_response( request, session_->session_id() ) );
		}
		else
		{
		    if ( do_not_block )
		    {
                bayeux_response_.add( build_connect_response( request, session_->session_id() ) );
		    }
		    else
		    {
                blocking_connect_ = request;
		    }
		}
	}
void AutoNetServerImpl::HandleSubscribe(websocketpp::connection_hdl hdl) {
  m_Subscribers.insert(hdl);

  Json::array types;
  for(const auto& type : m_AllTypes) {
    types.push_back(type.first);
  }

  SendMessage(hdl, "subscribed", types);

  auto root = GetContext();
  for (auto ctxt : ContextEnumerator{ GetContext() }) {
    // Send update about this newly discovered context
    NewContext(
      ctxt == root ? nullptr : ctxt->GetParentContext().get(),
      *ctxt
    );

    // Build total image of all objects, recursively:
    for (const auto* pObj : ctxt->BuildObjectState())
      NewObject(*ctxt, *pObj);
  }

  // Send breakpoint message
  for(const auto& breakpoint : m_breakpoints)
    SendMessage(hdl, "breakpoint", breakpoint);
}
Exemplo n.º 4
0
/**
 * @test the current behaviour is, that a first update to a subscription is delivered with the a second
 *       http request. Delivering the initial version of the data with the first http request would be
 *       fine too.
 */
BOOST_FIXTURE_TEST_CASE( response_to_subscription, context )
{
    answer_validation_request( node1, true );
    answer_authorization_request( node1, true );
    answer_initialization_request( node1, json::number( 42 ) );

    tools::run( *this );
    const json::array response = json_multiple_post(
           asio_mocks::read_plan()
        << asio_mocks::json_msg( "{ 'cmd': [ { 'subscribe': { 'a':'1' ,'b':'1' } } ] }" )
        << asio_mocks::json_msg( "{ 'id': '192.168.210.1:9999/0' }" )
        << asio_mocks::disconnect_read() );

    BOOST_REQUIRE_EQUAL( response.length(), 2u );
    json::array updates = response.at( 1 ).upcast< json::object >().at( json::string( "update" ) ).upcast< json::array >();

    BOOST_REQUIRE_EQUAL( updates.length(), 1u );
    json::object update = updates.at( 0 ).upcast< json::object >();

    BOOST_CHECK_EQUAL(
        update.at( json::string( "key" ) ),
        json::parse_single_quoted( "{ 'a':'1' ,'b':'1' }" ));

    BOOST_CHECK_EQUAL( update.at( json::string( "data" ) ), json::number( 42 ) );
}
Exemplo n.º 5
0
// durring tests, there was a situation, where after a browser refresh, the server did not respond to a subscription
BOOST_FIXTURE_TEST_CASE( second_subscription_to_invalid_node_must_be_communicated, context )
{
    data_.add_configuration( pubsub::node_group(), pubsub::configurator().authorization_not_required() );

    answer_validation_request( node1, false );

    // create a subscriber, subscribe to node1
    const boost::shared_ptr< pubsub::test::subscriber > first_subscriber( new pubsub::test::subscriber );
    data_.subscribe( first_subscriber, node1 );
    tools::run( *this );

    // make sure, that the subscriber is subscribed
    BOOST_REQUIRE( first_subscriber->on_invalid_node_subscription_called( node1 ) );

    const json::array response = json_multiple_post(
           asio_mocks::read_plan()
        << asio_mocks::json_msg( "{ 'cmd': [ { 'subscribe': { 'a':'1' ,'b':'1' } } ] }" )
        << asio_mocks::json_msg( "{ 'id': '192.168.210.1:9999/0' }" )
        << asio_mocks::disconnect_read() );

    BOOST_REQUIRE_GE( response.length(), 2u );

    // in the first, or the second response, there should be an update of node1
    BOOST_CHECK_NE( response.find( json::parse_single_quoted( "{ "
        "'id'     : '192.168.210.1:9999/0',"
        "'resp'   : [ { "
        "   'subscribe': {'a': '1', 'b': '1'},"
        "   'error'    : 'invalid node' } ]"
    "}" ) ), -1 );
}
Exemplo n.º 6
0
    Json JsonSerializer::Serialize(Colliders &colliders)
    {
        Json::array items;

        for (auto &collider : colliders)
            items.push_back(Serialize(collider));

        return Json(items);
    }
Exemplo n.º 7
0
BOOST_FIXTURE_TEST_CASE( defered_response_to_subscription_if_validation_was_asynchronous, context )
{
    const json::array responses = json_multiple_post(
           asio_mocks::read_plan()
        << asio_mocks::json_msg( "{ 'cmd': [ { 'subscribe': { 'a':'1' ,'b':'1' } } ] }" )
        << boost::bind( update_node1_to_42, boost::ref( static_cast< pubsub::test::adapter&>( *this ) ), node1 )
        << asio_mocks::json_msg( "{ 'id': '192.168.210.1:9999/0' }" )
        << asio_mocks::disconnect_read() );

    BOOST_REQUIRE_EQUAL( responses.length(), 2u );
    BOOST_CHECK( find_update( responses.at( 1u ).upcast< json::object >(), "{ 'a':'1' ,'b':'1' }", "42" ) );
}
Exemplo n.º 8
0
json::object response_base::build_response( const json::string& session_id, const json::array& response, const json::array& updates ) const
{
    json::object result;
    result.add( id_token, session_id );

    if ( !response.empty() )
        result.add( response_token, response );

    if ( !updates.empty() )
        result.add( update_token, updates );

    return result;
}
Exemplo n.º 9
0
    std::vector< boost::asio::const_buffer > response_base< Timer >::build_response( const json::array& bayeux_response )
	{
		static const char response_header[] =
			"HTTP/1.1 200 OK\r\n"
			"Content-Type: application/json\r\n"
			"Content-Length: ";

		response_buffer_ = tools::as_string( bayeux_response.size() ) + "\r\n\r\n";

		std::vector< boost::asio::const_buffer > result;

		result.push_back( boost::asio::buffer( response_header, sizeof response_header -1 ) );
		result.push_back( boost::asio::buffer( response_buffer_ ) );

		bayeux_response.to_json( result );

		return result;
	}
Exemplo n.º 10
0
void Scraper::scrape() {
	bool done = false;
	unsigned int page = 0;
	std::string responseBuffer;
	while (!done) {
		responseBuffer.clear();
		const char *APIBlogUrl = getAPIBlogUrlForUsername("david-meade", page++);
		makeRequest(APIBlogUrl, &responseBuffer);

		std::string error;
		Json resJson = Json::parse(responseBuffer, error)["response"];
		Json blogJson = resJson["blog"];
		Json::array postsJson = resJson["posts"].array_items();
		for(unsigned int i = 0; i < postsJson.size(); i++) {
			Json::object postObj = postsJson[i].object_items();
		}
		done = postsJson.size() < 20;
	};
}
Exemplo n.º 11
0
BOOST_FIXTURE_TEST_CASE( defered_error_message_if_not_authorized, context )
{
    const json::array response = json_multiple_post(
           asio_mocks::read_plan()
        << asio_mocks::json_msg( "{ 'cmd': [ { 'subscribe': { 'a':'1' ,'b':'1' } } ] }" )
        << asio_mocks::json_msg( "{ 'id': '192.168.210.1:9999/0' }" )
        << boost::bind( unauthorized_node_subject, boost::ref( static_cast< pubsub::test::adapter&>( *this ) ), node1 )
        << asio_mocks::disconnect_read() );

    BOOST_REQUIRE_EQUAL( response.length(), 2u );
    json::array resp = response.at( 1 ).upcast< json::object >().at( json::string( "resp" ) ).upcast< json::array >();

    BOOST_REQUIRE_EQUAL( resp.length(), 1u );

    BOOST_CHECK_EQUAL(
        resp.at( 0 ),
        json::parse_single_quoted( "{"
            "'error': 'not allowed'"
            "'subscribe' :{ 'a':'1' ,'b':'1' } }" ) );
}
Exemplo n.º 12
0
BOOST_FIXTURE_TEST_CASE( error_message_if_subscription_subject_is_invalid, context )
{
    answer_validation_request( node1, false );

    const json::array response = json_multiple_post(
           asio_mocks::read_plan()
        << asio_mocks::json_msg( "{ 'cmd': [ { 'subscribe': { 'a':'1' ,'b':'1' } } ] }" )
        << asio_mocks::json_msg( "{ 'id': '192.168.210.1:9999/0' }" )
        << asio_mocks::disconnect_read() );

    BOOST_REQUIRE_EQUAL( response.length(), 2u );
    json::array resp = response.at( 1 ).upcast< json::object >().at( json::string( "resp" ) ).upcast< json::array >();

    BOOST_REQUIRE_EQUAL( resp.length(), 1u );

    BOOST_CHECK_EQUAL(
        resp.at( 0 ),
        json::parse_single_quoted( "{"
            "'error': 'invalid node'"
            "'subscribe' :{ 'a':'1' ,'b':'1' } }" ) );
}
Exemplo n.º 13
0
void AutoNetServerImpl::SendEvent(const std::string& rawEvent, const std::vector<std::string>& args) {
  // Prepend '$' to custum event to avoid namespace collitions with internal events
  std::string event("$");
  event.append(rawEvent);

  Json::array jsonArgs;
  for (const auto& a : args) {
    jsonArgs.push_back(a);
  }

  *this += [this, event, jsonArgs] {
    for(auto hdl : m_Subscribers) {
      Json msg = Json::object{
        {"type", event},
        {"args", jsonArgs}
      };

      m_transport->Send(hdl, msg.dump());
    }
  };
}
Exemplo n.º 14
0
BOOST_FIXTURE_TEST_CASE( failed_initialization, context )
{
    answer_validation_request( node1, true );
    answer_authorization_request( node1, true );
    skip_initialization_request( node1 );

    const json::array response = json_multiple_post(
           asio_mocks::read_plan()
        << asio_mocks::json_msg( "{ 'cmd': [ { 'subscribe': { 'a':'1' ,'b':'1' } } ] }" )
        << asio_mocks::json_msg( "{ 'id': '192.168.210.1:9999/0' }" )
        << asio_mocks::disconnect_read() );

    BOOST_REQUIRE_EQUAL( response.length(), 2u );
    json::array resp = response.at( 1 ).upcast< json::object >().at( json::string( "resp" ) ).upcast< json::array >();

    BOOST_REQUIRE_EQUAL( resp.length(), 1u );

    BOOST_CHECK_EQUAL(
        resp.at( 0 ),
        json::parse_single_quoted( "{"
            "'error': 'node initialization failed'"
            "'subscribe' :{ 'a':'1' ,'b':'1' } }" ) );
}
Exemplo n.º 15
0
BOOST_FIXTURE_TEST_CASE( unsubscribe_from_not_subscribed_node_http, context )
{
    const json::array response = json_multiple_post(
           subscribe_to_node1()
        << asio_mocks::json_msg( "{"
            "   'id': '192.168.210.1:9999/0',  "
            "   'cmd': [ "
            "       { 'unsubscribe': { 'a': '1', 'b': '2' } } "
            "   ]"
            "}" )
        << asio_mocks::disconnect_read() );

    BOOST_REQUIRE_EQUAL( response.length(), 2u );
    BOOST_CHECK_EQUAL(
        response.at( 1u ),
        json::parse_single_quoted(""
            "{"
            "   'id': '192.168.210.1:9999/0',"
            "   'resp': [{"
            "       'unsubscribe': { 'a': '1', 'b': '2' },"
            "       'error': 'not subscribed'"
            "   }]"
            "}" ) );
}
Exemplo n.º 16
0
void AutoNetServerImpl::NewObject(CoreContext& ctxt, const CoreObjectDescriptor& object){
  int contextID = ResolveContextID(&ctxt);

  *this += [this, object, contextID]{
    Json::object objData;
    Json::object types;

    // Add object data
    objData["name"] = autowiring::demangle(object.type);
    objData["id"] = autowiring::demangle(object.value.type());

    // Add slots for this object
    {
      Json::array slots;
      for(const SlotInformation* slot = object.stump->pHead; slot; slot = slot->pFlink) {
        slots.push_back(Json::object{
            {"id", autowiring::demangle(slot->type)},
            {"autoRequired", slot->autoRequired},
            {"offset", int(slot->slotOffset)}
        });
      }
      objData["slots"] = slots;
    }

    // Add type information
    auto member = object.pContextMember;
    if(member) {
      types["contextMember"] = true;
    }

    auto runnable = object.pCoreRunnable;
    if(runnable) {
      types["coreRunnable"] = true;
    }

    auto thread = object.pBasicThread;
    if(thread) {
      // Create slot in map
      m_Threads[thread->GetSelf<BasicThread>()];

      types["thread"] = Json::object{
          {"kernal", 0.0},
          {"user", 0.0}
      };
    }

    // Check if type implements an AutoFilter
    if (!object.subscriber.empty()) {
      Json::object args;
      for (auto pArg = object.subscriber.GetAutoFilterArguments(); *pArg; ++pArg) {
        args[autowiring::demangle(pArg->id)] = Json::object{
          {"id", autowiring::demangle(pArg->id)},
          {"isInput", pArg->is_input},
          {"isOutput", pArg->is_output}
        };
      }
      types["autoFilter"] = args;
    }

    auto filter = object.pFilter;
    if(filter) {
      types["exceptionFilter"] = true;
    }

    auto bolt = object.pBoltBase;
    if(bolt) {
      Json::array sigils;
      for(auto cur = bolt->GetContextSigils(); *cur; cur++){
        sigils.push_back(autowiring::demangle(*cur));
      }
      types["bolt"] = sigils;
    }

    BroadcastMessage("newObject", contextID, types, objData);
  };
}
Exemplo n.º 17
0
Json RiotService::GetMatchFeedByIds::internalCall() {
    Json summoners = _service->_api.getSummonerByIds(_params["ids"]);
    Json::object diff;
    Json::array matches;
    std::string err;
    auto cmp = [](const Json & a, const Json & b) {
        return a["createDate"].number_value() > b["createDate"].number_value();
    };
    for (auto & kv : summoners.object_items()) {
        Json cache = _service->getSummonerInfoCache(kv.first);
        printf("cache : %s\nnew: %s", cache.dump().c_str(), kv.second.dump().c_str());
        if (cache.is_null() || cache["revisionDate"].number_value() < kv.second["revisionDate"].number_value()) {
            diff[kv.first] = kv.second;
        } else {
            matches.insert(matches.end(), cache["games"].array_items().begin(), cache["games"].array_items().end());
        }
    }
    std::sort(matches.begin(), matches.end(), cmp);
    if (!matches.empty()) {
        _onRead(matches);
    }
    for (auto & kv : diff) {
        auto future = std::async(std::launch::async, [this, kv, cmp, &matches]() {
            Json newInfo = _service->_api.getRecentGamesBySummonerId(kv.first);
            if (!newInfo.is_null()) {
                Json::array modifiedMatches;
                for (auto & match : newInfo["games"].array_items()) {
                    auto item = match.object_items();
                    item["summonerId"] = kv.first;
                    item["name"] = kv.second["name"].string_value();
                    modifiedMatches.push_back(item);
                }
                matches.insert(matches.end(), modifiedMatches.begin(), modifiedMatches.end());
                sort(matches.begin(), matches.end(), cmp);
                
                Json::object updateObject(kv.second.object_items());
                updateObject["games"] = modifiedMatches;
                _service->saveSummonerInfo(kv.first, Json(updateObject));
            }
            _onRead(matches);
        });
    }
    return Json(matches);
}
Exemplo n.º 18
0
                LOAD_PARAM(request, req, db, int_value, 0);
                LOAD_PARAM(request, req, raw, bool_value, true);
                /*
                LOAD_PARAM(request, req, url, string_value, "");
                LOAD_PARAM(request, req, content, string_value, "");
                */
                LOAD_PARAM(request, req, type, string_value, "");
                LOAD_PARAM(request, req, K, int_value, -1);
                LOAD_PARAM(request, req, R, number_value, NAN);
                LOAD_PARAM(request, req, hint_K, int_value, -1);
                LOAD_PARAM(request, req, hint_R, number_value, NAN);
                string params_l1;
                LOAD_PARAM1(request, params_l1, params_l1, string_value, "");
                req.params_l1.decode(params_l1);

                Json::array results;
                auto it = request.object_items().find("urls");
                for (auto const &v: it->second.array_items()) {
                    req.url = v.string_value();
                    SearchResponse resp;
                    server->search(req, &resp);
                    Json::array hits;
                    for (auto const &hit: resp.hits) {
                        hits.push_back(Json::object{
                                {"key", hit.key},
                                {"meta", hit.meta},
                                {"details", hit.details},
                                {"score", hit.score}});
                    }
                    results.push_back(Json::object{
                    {"time", resp.time},