def test_edit_single_log(self):
        log_id, execute_time = self._add_single_log()

        #create test delete log
        logs = []
        value_upd = "120"
        log = self._get_sample_edit_log(log_id, TEST_USER_ID, value_upd, execute_time)
        logs.append(log)

        body = JSONParser.to_json(logs)
        raw_response = self.rest_post("http://localhost:7080/2/logs/edit", body)
        print raw_response
        response = JSONParser.to_collection(raw_response)

        print response
        assert response != None
        assert response["status"] == STATUS_SUCCESS

        #check write-only logs db
        log_dao = self.get_dao_builder().build_log_dao()
        edited_log_id = response["data"][0]
        found_log = log_dao.get_log_by_id(edited_log_id)
        assert found_log != None
        assert found_log["oper"] == "u"
        assert found_log["nodes"][0]["value"] == value_upd

    def test_edit_pin(self):
        """
        Sample API-1 request/response:

        http://qaapi.wikilife.org/1/account/pin/edit.json
        POST:
        {"pin": "7777", "user_id": "CSQTMG", "new_pin": "7776"}

        RESP:
        {"status": "OK", "message": "User pin changed successfully"}
        """

        url = self.get_service_url("/1/account/pin/edit.json")
        new_pin = "%s_upd" % TEST_USER_NAME
        user_info = {"user_id": TEST_USER_NAME, "pin": TEST_USER_NAME, "new_pin": new_pin}

        #invoke ws
        try:
            body = JSONParser.to_json(user_info)
            raw_response = self.rest_post(url, body)
            print raw_response
            response = JSONParser.to_collection(raw_response)
        except Exception, e:
            print e
            assert False

    def _post_twitter_settings(self, internal_user_id, twitter_settings):
        url = self.get_service_url(SRV_ROUTE_TPL %internal_user_id)

        try:
            body = JSONParser.to_json(twitter_settings)
            raw_response = self.rest_post(url, body)
            print raw_response 
            response = JSONParser.to_collection(raw_response)

        except Exception, e:
            print e
            assert False

    def _add_test_log(self):
        root_slug = "exercise"
        nodes = [{"node_id": 298, "value": "60"}]
        execute_time = "2012-03-19 19:15:43 -0300"
        logs = []
        log = self._get_sample_log(TEST_USER_ID, root_slug, nodes, execute_time)
        logs.append(log)
        body = JSONParser.to_json(logs)
        url = self.get_service_url("/2/logs/add.json")
        raw_response = self.rest_post(url, body)
        response = JSONParser.to_collection(raw_response)
        added_log_id = response["data"][0]
        found_log = self.get_log_mgr().get_log_by_id(added_log_id)

        return found_log

 def post(self, developer_id):
     """
     Add app
     """
     dto = JSONParser.to_collection(self.sanitize_raw_data(self.request.body))
     app = self._app_srv.add_app(dto["name"], dto["callbackUrl"], developer_id)
     self.success(app)

 def put(self, app_id, developer_id):
     """
     Update app
     """
     dto = JSONParser.to_collection(self.sanitize_raw_data(self.request.body))
     updated_app = self._app_srv.update_app(app_id, dto["name"], dto["callbackUrl"], developer_id)
     self.success(updated_app)

    def post(self):
        """
        Creates user account

        Request::

            {
              "userName": "docApi",
              "pin": "1234",
              "city": "Bahia Blanca",
              "timezone": "America\/Argentina\/San_Luis",
              "gender": "Male",
              "height": "1.70",
              "weight": "69.9",
              "device_id": "317a129728d554ff9e14dd72280fcf0000000000",
              "region": "Buenos Aires",
              "birthdate": "1995-10-29",
              "country": "ARG"
            }

        Response::

        """
        account_srv = self._services["account"]
        user_info = JSONParser.to_collection(self.request.body)
        self.add_user_source(user_info, self.request.headers)
        account_srv.create_account(user_info)
        self.success()

    def test_meta_node_ancestors(self):
        node_id = 10
        expected = [
            {
                "name": "Exercise",
                "parentIds": [
                    1
                ],
                "origId": 49,
                "otherNames": "",
                "type": "MetaNode",
                "id": 6
            },
            {
                "name": "Life Variable",
                "parentIds": [ ],
                "origId": 1,
                "otherNames": "Wikilife",
                "type": "MetaNode",
                "id": 1
            }
        ]

        url = self.get_service_url("/4/meta/ancestors/%s" %node_id)
        response_code, response_headers, response_body = self.rest_get(url)
        result = JSONParser.to_collection(response_body)

        self.assertEquals(response_code, 200)
        self.assertListEqual(expected, result)

 def success(self, response=None, status_code=200, user_message=None, dev_message=None):
     self.set_header("Content-Type", "application/json; charset=UTF-8")
     if user_message is not None:
         self.set_header("X-User-Message", user_message)
     if dev_message is not None:
         self.set_header("X-Dev-Message", dev_message)
     self.write(JSONParser.to_json(response))

    def test_meta_search_by_name(self):
        expected = {
            "items": [
                {
                    "name": "Lower Abdominal Pain",
                    "parentIds": [
                        15
                    ],
                    "origId": 253273,
                    "otherNames": "Lower abdominal pain, R10.3",
                    "type": "MetaNode",
                    "id": 1251
                }
            ],
            "pageIndex": 0,
            "pageSize": 25,
            "pageCount": 1
        }

        params = {"name": "Lower Abdominal Pain"}
        url = self.get_service_url("/4/meta/search/")
        response_code, response_headers, response_body = self.rest_get(url, params)
        result = JSONParser.to_collection(response_body)

        self.assertEquals(response_code, 200)
        self.assertDictEqual(expected, result)

    def test_delete_single_log(self):
        log_id = self._add_single_log()
        
        #create test delete log
        logs = []
        log = self._get_sample_delete_log(log_id, TEST_USER_ID)
        logs.append(log)

        body = JSONParser.to_json(logs)
        raw_response = self.rest_post("http://localhost:7080/2/logs/delete", body)
        print raw_response
        response = JSONParser.to_collection(raw_response)

        print response
        assert response != None
        assert response["status"] == STATUS_SUCCESS

    def test_meta_search_large_results(self):
        params = {"name": "a"}
        url = self.get_service_url("/4/meta/search/")
        response_code, response_headers, response_body = self.rest_get(url, params)
        result = JSONParser.to_collection(response_body)

        self.assertEquals(response_code, 200)
        self.assertGreaterEqual(result["pageCount"], 2)

    def _add_single_log(self):
        root_slug = "exercise"
        nodes = [{"node_id": 298, "value": "60"}]
        execute_time = "2012-02-02 19:15:43 -0300"

        #create test log
        logs = []
        log = self._get_sample_log(TEST_USER_ID, root_slug, nodes, execute_time)
        logs.append(log)

        body = JSONParser.to_json(logs)
        raw_response = self.rest_post("http://localhost:7080/2/logs/add", body)
        print raw_response
        response = JSONParser.to_collection(raw_response)

        added_log_id = response["data"][0]
        return added_log_id

    def post(self, user_id):
        """
        Request body:
        {"roots":[""],"active":True,"access_token_secret":"","access_token_key":""}
        """

        twitter_settings = JSONParser.to_collection(self.request.body)
        self._twitter_user_srv.set_twitter_settings(user_id, twitter_settings)
        self.success()

    def _add_single_log(self):
        root_slug = "exercise"
        nodes = [{"node_id": 298, "value": "60"}]
        current_date_local = DateUtils.get_datetime_local("America/Argentina/Buenos_Aires")
        execute_time = DateFormatter.to_datetime(current_date_local)

        #create test log
        logs = []
        log = self._get_sample_log(TEST_USER_ID, root_slug, nodes, execute_time)
        logs.append(log)

        body = JSONParser.to_json(logs)
        raw_response = self.rest_post("http://localhost:7080/2/logs/add", body)
        print raw_response
        response = JSONParser.to_collection(raw_response)

        added_log_id = response["data"][0]
        return added_log_id, execute_time

    def get_logs(self, request_body, user_id):
        logs = JSONParser.to_collection(self.request.body)

        for log in logs:
            log["userId"] = user_id

        self.add_log_source(logs, self.request.headers)
        
        return logs

    def test_add_single_log(self):
        root_slug = "exercise"
        nodes = [{"node_id": 298, "value": "60"}]
        #loggable_id = 296
        execute_time = "2013-01-05 19:15:30 -0300"

        #create test log
        logs = []
        log = self._get_sample_log(TEST_USER_ID, root_slug, nodes, execute_time, "t4")
        logs.append(log)

        #invoke ws
        try:
            body = JSONParser.to_json(logs)
            raw_response = self.rest_post("http://localhost:7080/2/logs/add", body)
            print raw_response
            response = JSONParser.to_collection(raw_response)
        except Exception, e:
            print e
            assert False

    def _internal_callback(self, ch, method, properties, body):
        try:
            data = JSONParser.to_collection(body)
            success = self._callback(data)

            if success:
                ch.basic_ack(delivery_tag=method.delivery_tag)

        except JSONParserException, e:
            self._logger.error(e)
            ch.basic_ack(delivery_tag=method.delivery_tag)

    def test_get_notification(self):

        url = self.get_service_url("/1/notifications.json")
        params = {"client_id": "317A1297-28D5-54FF-9E14-DD72280FCF00", "client_version": "0.9.1.6", "client_tree_version": "meta_11.0.0", "client_api_version": "R11.0.0"}

        #invoke ws
        try:
            raw_response = self.rest_get(url, params)
            print raw_response
            response = JSONParser.to_collection(raw_response)
        except Exception, e:
            print e
            assert False

    def _add_test_answer(self, user, question, answer_value):

        dto = {
            "answer": {
                "execute_time": "2012-03-19 12:13:01 -0300",
                "answer_value": answer_value,
                "question_id": question["pk"],
                "answer_id": 0
            },
            "user_id": user["user_id"],
            "answer_type": "1"
        }

        body = JSONParser.to_json(dto)
        url = self.get_service_url("/2/questions/answer/add.json")
        raw_response = self.rest_post(url, body)
        response = JSONParser.to_collection(raw_response)
        answer = response["data"]["answer"]
        log_id = answer["log_id"]
        answer_log = self.get_log_mgr().get_log_by_id(log_id)

        return answer, answer_log