Python Dependency.info方法代码示例

# 需要导入模块: from common.utilities.inversion_of_control import Dependency [as 别名]
# 或者: from common.utilities.inversion_of_control.Dependency import info [as 别名]
def test_baonline_auth_context():
    # get logging dependency
    logger = Dependency("LogManager").value

    # this is how it would look in geoprocessing (without the debugs of course
    with BAOnlineAuthContext() as bao:
        logger.info("get, token: %s, num_auth_requests: %s", bao.token, bao.num_auth_requests)
        response = get_report_templates(bao)
        logger.info("templates: %s", pprint.pformat(response))

# 需要导入模块: from common.utilities.inversion_of_control import Dependency [as 别名]
# 或者: from common.utilities.inversion_of_control.Dependency import info [as 别名]

#.........这里部分代码省略.........
        """
        Adaptor method to make this fit into ArcGIS_report_helper.py
        """
        with self:
            response = self.post(url, request_format)

            if not response.ok:
                #inject potentially useful stuff in the response: the url and params
                response.reason += " | url: %s | GET data: %s" % (url, request_format)
                response.raise_for_status()
            else:
                response_rec = response.json()
                if "error" in response_rec:

                    # if try again, get a new token and try again
                    if try_again:
                        BAOnlineAuthContext.token = ""
                        self.__get_token()
                        return self.generate_report_with_post(request_format, url, False)

                    # otherwise raise an error
                    raise RuntimeError("BA Online Error - get_report_templates(): %s." % response_rec["error"])

            return response

    def download_file(self, url):
        """
        Adaptor method to make this fit into ArcGIS_report_helper.py
        """
        self.__log_request(url)
        return self.rest_provider.download_file(url)

    def __log_request(self, url):
        self.logger.info("BAOnline Request: %s" % url)



    def __get_token(self):
        """
        Authenticate with Business Analyst Online.
        docs: http://help.arcgis.com/en/businessanalyst/apis/rest/reference/GetToken.html
        Store the token in a local plain text file, and read it back from that file on subsequent calls.
        Note that we don't have to use a file for storing the token -- if we use a singleton we can keep it in memory.
        Or we could use something like Redis or MongoDB.
        """

        if not BAOnlineAuthContext.token:
            self.logger.debug("BA Online - Getting new token.")

            url = "https://baoapi.esri.com/rest/authentication"
            payload = {"request": "getToken",
                       "username": self.user_name,
                       "password": self.password,
                       "f": "JSON"}

            response = self.post(url, payload)
            self.num_auth_requests += 1

            if not response.ok:
                #inject potentially useful stuff in the response: the url and POST data payload
                response.reason += " | url: %s | POST data: %s" % (url, payload)
                response.raise_for_status()
            else:
                response_rec = response.json()

                if "error" in response_rec:

# 需要导入模块: from common.utilities.inversion_of_control import Dependency [as 别名]
# 或者: from common.utilities.inversion_of_control.Dependency import info [as 别名]
class TestSQLLoggingHandler(unittest.TestCase):

    def setUp(self):
        # register mocks
        register_mock_dependencies("DEBUG")

        # get other dependencies
        self.data_repository = Dependency("DataRepository").value

        # create config and change values before registering sql handler
        self._config = Dependency("Config").value
        # set the flush to be .5 seconds so that we can test quickly
        self._config.sql_logging_insert_timer = .1
        self._config.app_version = "9.9.9.9"
        self._config.environment = "unit test"

        # create logger with only SQLLoggingHandler
        self.logger = Dependency("LogManager").value
        self.logger.clear_logging_handlers()
        self.sql_handler = self.logger.add_sql_handler()

    def tearDown(self):
        self.sql_handler.wait_for_threads_to_finish()
        dependencies.clear()

    def test_basic_message(self):
        self.logger.debug("test message")

        # you need to sleep for one second so that the logger flushes correctly
        sleep(.3)

        # make sure only one record is present
        self.assertEqual(len(self.data_repository.logging_records), 1)

        # make sure values are correct
        record = self.data_repository.logging_records[0]
        self.assertEqual(record.log_entry_type_id, 5)
        self.assertEqual(record.version, "9.9.9.9")
        self.assertEqual(record.environment, "unit test")
        # process id is 234234234_process
        self.assertRegexpMatches(record.process_id, "\d*_.*")
        self.assertEqual(record.message.strip(), "test message")
        # compare timestamp without seconds
        utc = str(datetime.utcnow())
        self.assertEqual(utc.split()[0], record.time.split()[0])
        self.assertEqual(record.function_name, "test_sql_logging_handler.py__test_basic_message")
        self.assertIsNone(record.elapsed_time)

    def test_basic_message_with_elapsed_time(self):
        self.logger.debug("test message", elapsed_time=20.1)

        # you need to sleep for one second so that the logger flushes correctly
        sleep(.3)

        # make sure only one record is present
        self.assertEqual(len(self.data_repository.logging_records), 1)

        # make sure values are correct
        record = self.data_repository.logging_records[0]
        self.assertEqual(record.log_entry_type_id, 5)
        self.assertEqual(record.version, "9.9.9.9")
        self.assertEqual(record.environment, "unit test")
        # process id is 234234234_process
        self.assertRegexpMatches(record.process_id, "\d*_.*")
        self.assertEqual(record.message.strip(), "test message")
        # compare timestamp without seconds
        utc = str(datetime.utcnow())
        self.assertEqual(utc.split()[0], record.time.split()[0])
        self.assertEqual(record.function_name, "test_sql_logging_handler.py__test_basic_message_with_elapsed_time")
        self.assertEqual(record.elapsed_time, 20.1)

    def test_all_message_levels(self):
        """
        This test combines critical, error, warning, info, and debug together.
        This is done to save time since we have to wait for the flushing operation
        """
        self.logger.debug("test debug", elapsed_time=1.1)
        self.logger.info("test info", elapsed_time=2.2)
        self.logger.warning("test warning", elapsed_time=3.3)
        self.logger.error("test error", elapsed_time=4.4)
        self.logger.critical("test critical", elapsed_time=5.5)

        # you need to sleep for one second so that the logger flushes correctly
        sleep(.3)

        # make sure we have 5 records
        self.assertEqual(len(self.data_repository.logging_records), 5)

        # make sure every record's type is correct
        self.assertEqual(self.data_repository.logging_records[0].log_entry_type_id, 5)
        self.assertEqual(self.data_repository.logging_records[0].message.strip(), "test debug")
        self.assertEqual(self.data_repository.logging_records[0].elapsed_time, 1.1)
        self.assertEqual(self.data_repository.logging_records[1].log_entry_type_id, 4)
        self.assertEqual(self.data_repository.logging_records[1].message.strip(), "test info")
        self.assertEqual(self.data_repository.logging_records[1].elapsed_time, 2.2)
        self.assertEqual(self.data_repository.logging_records[2].log_entry_type_id, 3)
        self.assertEqual(self.data_repository.logging_records[2].message.strip(), "test warning")
        self.assertEqual(self.data_repository.logging_records[2].elapsed_time, 3.3)
        self.assertEqual(self.data_repository.logging_records[3].log_entry_type_id, 2)
        self.assertEqual(self.data_repository.logging_records[3].message.strip(), "test error")
#.........这里部分代码省略.........