def test_logging_network_logs_successful_responses(http_verb, test_url, access_token, generic_successful_response):
logger = Mock(Logger)
network = LoggingNetwork(logger)
with patch.object(default_network.DefaultNetwork, 'request') as super_request:
super_request.return_value = generic_successful_response
network.request(http_verb, test_url, access_token)
super_request.assert_called_once_with(http_verb, test_url, access_token)
logger.info.assert_called_with(network.SUCCESSFUL_RESPONSE_FORMAT, generic_successful_response.content)
def test_logging_network_logs_successful_responses(http_verb, test_url, access_token, generic_successful_response):
logger = Mock(Logger)
network = LoggingNetwork(logger)
with patch.object(default_network.DefaultNetwork, 'request') as super_request:
super_request.return_value = generic_successful_response
network.request(http_verb, test_url, access_token)
super_request.assert_called_once_with(http_verb, test_url, access_token)
logger.info.assert_called_with(network.SUCCESSFUL_RESPONSE_FORMAT, generic_successful_response.content)
def test_logging_network_does_not_log_download_content(http_verb, test_url, access_token, generic_successful_response):
logger = Mock(Logger)
network = LoggingNetwork(logger)
generic_successful_response.request_response.raw = Mock()
with patch.object(default_network.DefaultNetwork, 'request') as super_request:
super_request.return_value = generic_successful_response
network.request(http_verb, test_url, access_token)
super_request.assert_called_once_with(http_verb, test_url, access_token)
logger.info.assert_called_with(network.SUCCESSFUL_RESPONSE_FORMAT, network.STREAM_CONTENT_NOT_LOGGED)
def test_logging_network_logs_requests(http_verb, test_url, access_token):
logger = Mock(Logger)
network = LoggingNetwork(logger)
with patch.object(logging_network, 'pformat') as pformat:
with patch.object(default_network.DefaultNetwork, 'request') as super_request:
network.request(http_verb, test_url, access_token, custom_kwarg='foo')
kwargs = pformat.return_value
super_request.assert_called_once_with(http_verb, test_url, access_token, custom_kwarg='foo')
pformat.assert_called_once_with(dict(custom_kwarg='foo'))
logger.info.assert_any_call(network.REQUEST_FORMAT, http_verb, test_url, kwargs)
def test_logging_network_logs_requests(http_verb, test_url, access_token):
logger = Mock(Logger)
network = LoggingNetwork(logger)
with patch.object(logging_network, 'pformat') as pformat:
with patch.object(default_network.DefaultNetwork, 'request') as super_request:
network.request(http_verb, test_url, access_token, custom_kwarg='foo')
kwargs = pformat.return_value
super_request.assert_called_once_with(http_verb, test_url, access_token, custom_kwarg='foo')
pformat.assert_called_once_with(dict(custom_kwarg='foo'))
logger.info.assert_any_call(network.REQUEST_FORMAT, http_verb, test_url, kwargs)
def test_logging_network_logs_non_successful_responses(http_verb, test_url, access_token, server_error_response):
logger = Mock(Logger)
network = LoggingNetwork(logger)
with patch.object(logging_network, 'pformat') as pformat:
with patch.object(default_network.DefaultNetwork, 'request') as super_request:
super_request.return_value = server_error_response
network.request(http_verb, test_url, access_token)
super_request.assert_called_once_with(http_verb, test_url, access_token)
pformat.assert_called_with(server_error_response.content)
logger.warning.assert_called_once_with(
network.ERROR_RESPONSE_FORMAT,
server_error_response.status_code,
server_error_response.headers,
pformat.return_value,
)
def test_logging_network_logs_non_successful_responses(http_verb, test_url, access_token, server_error_response):
logger = Mock(Logger)
network = LoggingNetwork(logger)
with patch.object(logging_network, 'pformat') as pformat:
with patch.object(default_network.DefaultNetwork, 'request') as super_request:
super_request.return_value = server_error_response
network.request(http_verb, test_url, access_token)
super_request.assert_called_once_with(http_verb, test_url, access_token)
pformat.assert_called_with(server_error_response.content)
logger.warning.assert_called_once_with(
network.ERROR_RESPONSE_FORMAT,
server_error_response.status_code,
server_error_response.headers,
pformat.return_value,
)
def worker():
# Set up a logging network, but use the LoggingProxy so we can see which PID is generating messages
logger = setup_logging(name='boxsdk.network.{0}'.format(getpid()))
logger_proxy = LoggerProxy(logger)
logging_network = LoggingNetwork(logger)
# Create a coop oauth2 instance.
# Tokens will be retrieved from and stored to the multiprocessing Namespace.
# A multiprocessing Lock will be used to synchronize token refresh.
# The tokens from the master process are used for initial auth.
# Whichever process needs to refresh
oauth2 = CooperativelyManagedOAuth2(
retrieve_tokens=_retrive_tokens,
client_id=CLIENT_ID,
client_secret=CLIENT_SECRET,
store_tokens=_store_tokens,
network_layer=logging_network,
access_token=tokens.access,
refresh_token=tokens.refresh,
refresh_lock=refresh_lock,
)
client = Client(oauth2, network_layer=logging_network)
_do_work(client)
def test_logging_network_does_not_call_setup_logging_if_logger_is_not_none():
logger = Mock(Logger)
with patch.object(logging_network, 'setup_logging') as setup_logging:
network = LoggingNetwork(logger)
setup_logging.assert_never_called()
assert network.logger is logger
def test_logging_network_can_be_initialized_if_logger_is_none():
with patch('logging.getLogger') as get_logger:
get_logger.return_value = Mock(Logger)
network = LoggingNetwork()
assert network.logger is get_logger.return_value
get_logger.assert_called_once_with(LoggingNetwork.LOGGER_NAME)
def test_logging_network_calls_setup_logging_if_logger_is_none():
with patch.object(logging_network, 'setup_logging') as setup_logging:
network = LoggingNetwork()
setup_logging.assert_called_once_with(name=LoggingNetwork.LOGGER_NAME)
assert network.logger is setup_logging.return_value
import os, sys, time, io, json, logging, csv, datetime
from ConfigParser import SafeConfigParser
from boxsdk import OAuth2, JWTAuth, Client
from boxsdk.exception import BoxAPIException
from boxsdk.network.logging_network import LoggingNetwork
client_id = ""
client_secret = ""
enterprise_id = ""
jwt_key_id = ""
rsakey_filename = ""
rsakey_passphrase = None
logger = LoggingNetwork()
start_time = time.time()
auth = JWTAuth(
client_id=client_id,
client_secret=client_secret,
enterprise_id=enterprise_id,
jwt_key_id=jwt_key_id,
rsa_private_key_file_sys_path=rsakey_filename,
rsa_private_key_passphrase=rsakey_passphrase,
network_layer=logger,
)
print "App Admin Token: " + str(auth.access_token)
client = Client(auth)
print '-' * 80
me = client.user(user_id='me').get()
def network_layer(logger):
return LoggingNetwork(logger=logger)
def network(logger):
return LoggingNetwork(logger)
else:
config = SafeConfigParser()
config.read(configfile_name)
CLIENT_ID = config.get('boxCredentials', 'clientID')
CLIENT_SECRET = config.get('boxCredentials', 'clientSecret')
ACCESS_TOKEN = config.get('boxCredentials', 'accessToken')
REFRESH_TOKEN = config.get('boxCredentials', 'refreshToken')
return OAuth2(client_id=CLIENT_ID,
client_secret=CLIENT_SECRET,
access_token=ACCESS_TOKEN,
refresh_token=REFRESH_TOKEN,
store_tokens=APIRefreshListener)
# MAIN
api = initializeAPIConnection()
# Use the network_layer to print out the specific API Requests and Responses
client = Client(api, network_layer=LoggingNetwork())
# Use the SDK object and parse the results
rootFolder = client.folder('0').get_items(1000)
for f in rootFolder:
print f.id + " " + f.name
# Make a direct call against the API and parse the results
apiResponse = client.make_request(
'GET',
"https://api.box.com/2.0/users/me?fields=id,name,login,role").json()
print "Logged-in user " + apiResponse[
'login'] + " is the role: " + apiResponse['role']
