def test_logs_that_profile_request_properties_are_invalid(self, PoolManagerMock):
logger_mock = Mock()
logger_mock.debug = Mock()
properties = {'$age': TEST_PROPERTY_INVALID_AGE}
submit_profile(TEST_ACTOR_NAME, WRITE_KEY_MOCK, properties, log=logger_mock)
self.assertTrue(logger_mock.debug.called)
def test_logs_that_action_request_properties_are_invalid(self, PoolManagerMock):
logger_mock = Mock()
logger_mock.debug = Mock()
properties = {'$gender': TEST_PROPERTY_INVALID_GENDER}
track_action(TEST_ACTOR_NAME, TEST_ACTION, WRITE_KEY_MOCK, properties, IP_ADDRESS_MOCK, TEST_DATETIME, log=logger_mock)
self.assertTrue(logger_mock.debug.called)
def create_fake_endpoint(name="source", **kw):
ep = Mock()
ep.zone.name = name
ep.secret_key = kw.get("secret", "secret")
ep.access_key = kw.get("access", "access")
ep.port = kw.get("port", 7777)
ep.host = kw.get("host", "localhost")
ep.debug = kw.get("debug", True)
return ep
def create_fake_endpoint(name='source', **kw):
ep = Mock()
ep.zone.name = name
ep.secret_key = kw.get('secret', 'secret')
ep.access_key = kw.get('access', 'access')
ep.port = kw.get('port', 7777)
ep.host = kw.get('host', 'localhost')
ep.debug = kw.get('debug', True)
return ep
def get_obj(self, logger=None):
if not logger:
def print_msg(msg):
print(msg)
logger = Mock()
logger.error = Mock(side_effect=print_msg)
logger.warning = Mock(side_effect=print_msg)
logger.info = Mock(side_effect=print_msg)
logger.debug = Mock(side_effect=print_msg)
return self.test_obj(logger)
def _create_manager(self):
options = Mock()
options.debug = False
options.force_locale = None
options.log_level_file = None
options.proxy_server = None
options.update_site_url = None
options.beta_update_site_url = None
options.nxdrive_home = self.test_folder
manager = Manager(options)
return manager
def setUp(self):
self.folder = tempfile.mkdtemp(u'-nxdrive-tests')
from mock import Mock
options = Mock()
options.debug = False
options.force_locale = None
options.proxy_server = None
options.log_level_file = None
options.update_site_url = None
options.beta_update_site_url = None
options.nxdrive_home = self.folder
self.manager = Manager(options)
def test_should_use_usage_information(self, mock_option_parser_class):
mock_option_parser = Mock()
mock_values = Mock()
mock_values.version = False
mock_values.debug = False
mock_arguments = ["foo", "bar"]
mock_option_parser.parse_args.return_value = (mock_values, mock_arguments)
mock_option_parser_class.return_value = mock_option_parser
parse_arguments([], version="")
mock_option_parser_class.assert_called_with(usage=USAGE_INFORMATION)
def test_should_print_help_screen_and_exit_when_less_than_two_positional_arguments_are_given(self, mock_option_parser_class, mock_exit):
mock_option_parser = Mock()
mock_values = Mock()
mock_values.version = False
mock_values.debug = False
mock_arguments = [""]
mock_option_parser.parse_args.return_value = (mock_values, mock_arguments)
mock_option_parser_class.return_value = mock_option_parser
parse_arguments([], version="")
mock_option_parser.print_help.assert_called_with()
mock_exit.assert_called_with(1)
def get_obj(self, logger=None, setup=None, config=None):
if config is None:
config = lxml.etree.Element("Configuration")
if not logger:
def print_msg(msg):
print(msg)
logger = Mock()
logger.error = Mock(side_effect=print_msg)
logger.warning = Mock(side_effect=print_msg)
logger.info = Mock(side_effect=print_msg)
logger.debug = Mock(side_effect=print_msg)
if not setup:
setup = MagicMock()
return self.test_obj(logger, setup, config)
def get_posix_object(logger=None, setup=None, config=None):
if config is None:
config = lxml.etree.Element("Configuration")
if not logger:
def print_msg(msg):
print(msg)
logger = Mock()
logger.error = Mock(side_effect=print_msg)
logger.warning = Mock(side_effect=print_msg)
logger.info = Mock(side_effect=print_msg)
logger.debug = Mock(side_effect=print_msg)
if not setup:
setup = MagicMock()
return Bcfg2.Client.Tools.POSIX.POSIX(logger, setup, config)
def test_bind_local_folder_on_config_folder(self):
options = Mock()
options.debug = False
options.delay = TEST_DEFAULT_DELAY
options.force_locale = None
options.proxy_server = None
options.log_level_file = None
options.update_site_url = None
options.beta_update_site_url = None
options.nxdrive_home = self.nxdrive_conf_folder
self.manager = Manager(options)
with self.assertRaises(FolderAlreadyUsed):
self.manager.bind_server(self.nxdrive_conf_folder, self.nuxeo_url, self.user,
self.password, start_engine=False)
def setUp(self):
config = types.ModuleType('config')
handler_mock = Mock()
config.HANDLER_CLASS = lambda : handler_mock
logger_mock = Mock()
logger_mock.info = Mock()
logger_mock.error = Mock()
logger_mock.debug = Mock()
config.GET_LOGGER_FUNCTION = lambda : logger_mock
def test_bindings(binder):
binder.bind('cli_service', Mock())
self.driver = CiscoNXOSDriver(config, test_bindings)
def get_obj(self, logger=None, setup=None, config=None):
if config is None:
config = lxml.etree.Element("Configuration")
if not logger:
def print_msg(msg):
print(msg)
logger = Mock()
logger.error = Mock(side_effect=print_msg)
logger.warning = Mock(side_effect=print_msg)
logger.info = Mock(side_effect=print_msg)
logger.debug = Mock(side_effect=print_msg)
if not setup:
setup = MagicMock()
if 'command_timeout' not in setup:
setup['command_timeout'] = None
execs = self.test_obj.__execs__
self.test_obj.__execs__ = []
rv = self.test_obj(logger, setup, config)
self.test_obj.__execs__ = execs
return rv
def test_get_logger_no_config(self, open, getQueueLogger, isdir):
open.return_value = None
isdir.return_value = True
queueLogger = log.QueueLogger('virtwho')
queueLogger.logger.handlers = []
mockQueueLogger = Mock(wraps=queueLogger)
getQueueLogger.return_value = mockQueueLogger
options = Mock()
options.debug = False
options.background = True
options.log_file = log.DEFAULT_LOG_FILE
options.log_dir = log.DEFAULT_LOG_DIR
options.log_per_config = False
log.init(options)
main_logger = log.getLogger(name='main')
self.assertTrue(main_logger.name == 'virtwho.main')
self.assertTrue(len(main_logger.handlers) == 1)
self.assertTrue(isinstance(main_logger.handlers[0], log.QueueHandler))
queue_handlers = queueLogger.logger.handlers
self.assertTrue(len(queue_handlers) == 1)
self.assertEquals(queue_handlers[0].baseFilename, '%s/%s' % (log.DEFAULT_LOG_DIR, log.DEFAULT_LOG_FILE))
def test_get_logger_no_config(self, open, getDefaultQueueLogger, isdir):
open.return_value = None
isdir.return_value = True
queueLogger = log.QueueLogger('virtwho')
queueLogger.logger.handlers = []
mockQueueLogger = Mock(wraps=queueLogger)
getDefaultQueueLogger.return_value = mockQueueLogger
options = Mock()
options.debug = False
options.background = True
options.log_file = log.DEFAULT_LOG_FILE
options.log_dir = log.DEFAULT_LOG_DIR
options.log_per_config = False
main_logger = log.getLogger(options)
self.assertTrue(main_logger.name == 'virtwho.main')
self.assertTrue(len(main_logger.handlers) == 1)
self.assertTrue(isinstance(main_logger.handlers[0], log.QueueHandler))
mockQueueLogger.getHandler.assert_called_with(logging.INFO)
queue_handlers = queueLogger.logger.handlers
self.assertTrue(len(queue_handlers) == 1)
self.assertEquals(queue_handlers[0].baseFilename, '%s/%s' % (log.DEFAULT_LOG_DIR, log.DEFAULT_LOG_FILE))
def test_get_logger_different_log_file(self, getFileHandler, getDefaultQueueLogger):
queueLogger = log.QueueLogger('virtwho')
queueLogger.logger.handlers = []
mockQueueLogger = Mock(wraps=queueLogger)
getDefaultQueueLogger.return_value = mockQueueLogger
config = Mock()
config.name = 'test'
config.log_file = 'test.log'
config.log_dir = '/test/'
options = Mock()
options.debug = False
options.background = True
options.log_per_config = True
options.log_dir = ''
options.log_file = ''
test_logger = log.getLogger(options, config)
self.assertTrue(test_logger.name == 'virtwho.test')
self.assertTrue(len(test_logger.handlers) == 1)
self.assertTrue(len(queueLogger.logger.handlers) == 1)
getFileHandler.assert_called_with(test_logger.name, config.log_file, config.log_dir)
def setUpApp(self, server_profile=None):
# Check the Nuxeo server test environment
self.nuxeo_url = os.environ.get('NXDRIVE_TEST_NUXEO_URL')
self.admin_user = os.environ.get('NXDRIVE_TEST_USER')
self.password = os.environ.get('NXDRIVE_TEST_PASSWORD')
self.build_workspace = os.environ.get('WORKSPACE')
self.result = None
self.tearedDown = False
# Take default parameter if none has been set
if self.nuxeo_url is None:
self.nuxeo_url = "http://localhost:8080/nuxeo"
if self.admin_user is None:
self.admin_user = "******"
if self.password is None:
self.password = "******"
self.tmpdir = None
if self.build_workspace is not None:
self.tmpdir = os.path.join(self.build_workspace, "tmp")
if not os.path.isdir(self.tmpdir):
os.makedirs(self.tmpdir)
if None in (self.nuxeo_url, self.admin_user, self.password):
raise unittest.SkipTest(
"No integration server configuration found in environment.")
# Check the local filesystem test environment
self.local_test_folder_1 = tempfile.mkdtemp(u'-nxdrive-tests-user-1', dir=self.tmpdir)
self.local_test_folder_2 = tempfile.mkdtemp(u'-nxdrive-tests-user-2', dir=self.tmpdir)
self.local_nxdrive_folder_1 = os.path.join(
self.local_test_folder_1, u'Nuxeo Drive')
os.mkdir(self.local_nxdrive_folder_1)
self.local_nxdrive_folder_2 = os.path.join(
self.local_test_folder_2, u'Nuxeo Drive')
os.mkdir(self.local_nxdrive_folder_2)
self.nxdrive_conf_folder_1 = os.path.join(
self.local_test_folder_1, u'nuxeo-drive-conf')
os.mkdir(self.nxdrive_conf_folder_1)
self.nxdrive_conf_folder_2 = os.path.join(
self.local_test_folder_2, u'nuxeo-drive-conf')
os.mkdir(self.nxdrive_conf_folder_2)
from mock import Mock
options = Mock()
options.debug = False
options.delay = TEST_DEFAULT_DELAY
options.force_locale = None
options.proxy_server = None
options.log_level_file = None
options.update_site_url = None
options.beta_update_site_url = None
options.autolock_interval = 30
options.nxdrive_home = self.nxdrive_conf_folder_1
self.manager_1 = Manager(options)
import nxdrive
nxdrive_path = os.path.dirname(nxdrive.__file__)
i18n_path = os.path.join(nxdrive_path, 'tests', 'resources', "i18n.js")
Translator(self.manager_1, i18n_path)
options.nxdrive_home = self.nxdrive_conf_folder_2
Manager._singleton = None
self.manager_2 = Manager(options)
self.version = __version__
# Long timeout for the root client that is responsible for the test
# environment set: this client is doing the first query on the Nuxeo
# server and might need to wait for a long time without failing for
# Nuxeo to finish initialize the repo on the first request after
# startup
root_remote_client = RemoteDocumentClient(
self.nuxeo_url, self.admin_user,
u'nxdrive-test-administrator-device', self.version,
password=self.password, base_folder=u'/', timeout=60)
# Activate given profile if needed, eg. permission hierarchy
if server_profile is not None:
root_remote_client.activate_profile(server_profile)
# Call the Nuxeo operation to setup the integration test environment
credentials = root_remote_client.execute(
"NuxeoDrive.SetupIntegrationTests",
userNames="user_1, user_2", permission='ReadWrite')
credentials = [c.strip().split(u":") for c in credentials.split(u",")]
self.user_1, self.password_1 = credentials[0]
self.user_2, self.password_2 = credentials[1]
self.engine_1 = self.manager_1.bind_server(self.local_nxdrive_folder_1, self.nuxeo_url, self.user_1,
self.password_1, start_engine=False)
self.engine_2 = self.manager_2.bind_server(self.local_nxdrive_folder_2, self.nuxeo_url, self.user_2,
self.password_2, start_engine=False)
self.engine_1.syncCompleted.connect(self.app.sync_completed)
self.engine_1.get_remote_watcher().remoteScanFinished.connect(self.app.remote_scan_completed)
self.engine_1.get_remote_watcher().changesFound.connect(self.app.remote_changes_found)
self.engine_1.get_remote_watcher().noChangesFound.connect(self.app.no_remote_changes_found)
self.engine_2.syncCompleted.connect(self.app.sync_completed)
self.engine_2.get_remote_watcher().remoteScanFinished.connect(self.app.remote_scan_completed)
self.engine_2.get_remote_watcher().changesFound.connect(self.app.remote_changes_found)
self.engine_2.get_remote_watcher().noChangesFound.connect(self.app.no_remote_changes_found)
self.queue_manager_1 = self.engine_1.get_queue_manager()
self.queue_manager_2 = self.engine_2.get_queue_manager()
ws_info = root_remote_client.fetch(TEST_WORKSPACE_PATH)
self.workspace = ws_info[u'uid']
self.workspace_title = ws_info[u'title']
self.sync_root_folder_1 = os.path.join(self.local_nxdrive_folder_1, self.workspace_title)
self.sync_root_folder_2 = os.path.join(self.local_nxdrive_folder_2, self.workspace_title)
self.local_root_client_1 = self.engine_1.get_local_client()
self.local_root_client_2 = self.engine_2.get_local_client()
self.local_client_1 = LocalClient(os.path.join(self.local_nxdrive_folder_1, self.workspace_title))
self.local_client_2 = LocalClient(os.path.join(self.local_nxdrive_folder_2, self.workspace_title))
# Document client to be used to create remote test documents
# and folders
self.upload_tmp_dir = tempfile.mkdtemp(u'-nxdrive-uploads', dir=self.tmpdir)
remote_document_client_1 = RemoteDocumentClient(
self.nuxeo_url, self.user_1, u'nxdrive-test-device-1',
self.version,
password=self.password_1, base_folder=self.workspace,
upload_tmp_dir=self.upload_tmp_dir)
remote_document_client_2 = RemoteDocumentClient(
self.nuxeo_url, self.user_2, u'nxdrive-test-device-2',
self.version,
password=self.password_2, base_folder=self.workspace,
upload_tmp_dir=self.upload_tmp_dir)
# File system client to be used to create remote test documents
# and folders
remote_file_system_client_1 = RemoteFileSystemClient(
self.nuxeo_url, self.user_1, u'nxdrive-test-device-1',
self.version,
password=self.password_1, upload_tmp_dir=self.upload_tmp_dir)
remote_file_system_client_2 = RemoteFileSystemClient(
self.nuxeo_url, self.user_2, u'nxdrive-test-device-2',
self.version,
password=self.password_2, upload_tmp_dir=self.upload_tmp_dir)
self.remote_restapi_client_1 = RestAPIClient(
self.nuxeo_url, self.user_1, u'nxdrive-test-device-1',
self.version,
password=self.password_1
)
self.remote_restapi_client_2 = RestAPIClient(
self.nuxeo_url, self.user_2, u'nxdrive-test-device-2',
self.version,
password=self.password_2
)
# Register root
remote_document_client_1.register_as_root(self.workspace)
remote_document_client_2.register_as_root(self.workspace)
self.root_remote_client = root_remote_client
self.remote_document_client_1 = remote_document_client_1
self.remote_document_client_2 = remote_document_client_2
self.remote_file_system_client_1 = remote_file_system_client_1
self.remote_file_system_client_2 = remote_file_system_client_2
self._wait_sync = {self.engine_1.get_uid(): True, self.engine_2.get_uid(): True}
self._wait_remote_scan = {self.engine_1.get_uid(): True, self.engine_2.get_uid(): True}
self._remote_changes_count = {self.engine_1.get_uid(): 0, self.engine_2.get_uid(): 0}
self._no_remote_changes = {self.engine_1.get_uid(): False, self.engine_2.get_uid(): False}
def test_simple_step():
"""
Tests simple_job()
"""
conn = Mock()
emr_jar_info = namedtuple('TestInfo', 'name bucket version')
mock_jar_info = emr_jar_info(
name='FooName', bucket='FooBucket', version='FooVersion')
input_dir = 's3n://foo_bucket/'
jarargs = []
options = Mock()
options.job_name = None
options.job_log_dir = None
options.slave_spot_instances = None
options.bootstrap = None
options.ami_version = 'FooAMIVersion'
options.classname = 'FooClassName'
options.custom_output = None
options.ninstances = 100
options.isize = 'm1.xlarge'
options.debug = None
options.version = '1.0.3'
options.job_flow_role = 'EMRJobflowDefault'
options.slave_spot_instances = None
options.keep_alive = False
options.visible_to_all_users = False
dummy_key_pair = 'dummy_key_pair'
bootstrap_action_return_value = [Mock()]
mock_bootstrap_action.return_value = bootstrap_action_return_value
job_log_dir = emr_under_test.build_job_log_prefix(
emr_jar_info = mock_jar_info, options = options)
mock_proj_name = emr_under_test._get_project_name(mock_jar_info, options)
step_return_value = Mock()
mock_step.return_value = step_return_value
# Call the actual method under test.
emr_under_test.simple_job(conn, mock_jar_info, input_dir,
jarargs, dummy_key_pair, options)
mock_step.assert_called_with(
mock_proj_name, mock_jar_info,
input_dir, jarargs,
options.classname,
options.custom_output)
conn.run_jobflow.assert_called_with(
name = mock_jar_info.name,
log_uri = job_log_dir,
steps = step_return_value,
num_instances = options.ninstances,
master_instance_type = options.isize,
slave_instance_type = options.isize,
enable_debugging=None,
hadoop_version=options.version,
bootstrap_actions = bootstrap_action_return_value,
instance_groups = None,
ami_version = options.ami_version,
ec2_keyname = dummy_key_pair,
keep_alive = False,
job_flow_role = options.job_flow_role,
visible_to_all_users = False)
class Poloniex(object):
"""The Poloniex Object!"""
def __init__(self,
Key=False,
Secret=False,
timeout=3,
coach=True,
loglevel=False,
extend=False,
retval_wrapper=DotMap,
nolog='returnCompleteBalances returnTicker',
retval_wrapper_args={'_dynamic': False}):
"""
Key = str api key supplied by Poloniex
Secret = str secret hash supplied by Poloniex
retval_wrapper = defaults to DotMap. What to wrap data in.
timeout = int time in sec to wait for an api response
(otherwise 'requests.exceptions.Timeout' is raised)
coach = bool to indicate if the api coach should be used
loglevel = logging level object to set the module at
(changes the requests module as well)
self.apiCoach = object that regulates spacing between api calls
# Time Placeholders # (MONTH == 30*DAYS)
self.MINUTE, self.HOUR, self.DAY, self.WEEK, self.MONTH, self.YEAR
"""
if loglevel:
logging.basicConfig(level=loglevel)
self.logger = logging.getLogger(__name__)
logging.getLogger("requests").setLevel(loglevel)
logging.getLogger("urllib3").setLevel(loglevel)
else:
self.logger = Mock()
self.retval_wrapper = retval_wrapper
self.retval_wrapper_args = retval_wrapper_args
self.nolog = nolog
# Call coach
self.apicoach = Coach()
# Grab keys, set timeout, ditch coach?
self.Key, self.Secret, self.timeout, self._coaching = \
Key, Secret, timeout, coach
# Set time labels
self.MINUTE, self.HOUR, self.DAY, self.WEEK, self.MONTH, self.YEAR = \
60, 60 * 60, 60 * 60 * 24, 60 * 60 * 24 * \
7, 60 * 60 * 24 * 30, 60 * 60 * 24 * 365
# These namespaces are here because poloniex has overlapping
# namespaces. There are 2 "returnTradeHistory" commands, one public and
# one private. Currently if one were to try: polo('returnTradeHistory')
# it would default to the private command and if no api key is defined a
# 'ValueError' will be raise. The workaround is 'marketTradeHist'. It
# returns the public data (bypassing the 'main' api call function). As
# I continued to write this wrapper I found more 'practical' namespaces
# for most of the api commands (at least at the time of writing). So I
# added them here for those who wish to use them.
if extend:
# Public
self.api = self.__call__
self.marketTicker = self.returnTicker
self.marketVolume = self.return24hVolume
self.marketStatus = self.returnCurrencies
self.marketLoans = self.returnLoanOrders
self.marketOrders = self.returnOrderBook
self.marketChart = self.returnChartData
# Private
self.myTradeHist = self.returnTradeHistory
self.myBalances = self.returnBalances
self.myAvailBalances = self.returnAvailableAccountBalances
self.myMarginAccountSummary = self.returnMarginAccountSummary
self.myMarginPosition = self.getMarginPosition
self.myCompleteBalances = self.returnCompleteBalances
self.myAddresses = self.returnDepositAddresses
self.myOrders = self.returnOpenOrders
self.myDepositsWithdraws = self.returnDepositsWithdrawals
self.myTradeableBalances = self.returnTradableBalances
self.myActiveLoans = self.returnActiveLoans
self.myOpenLoanOrders = self.returnOpenLoanOffers
self.myFeeInfo = self.returnFeeInfo
self.myLendingHistory = self.returnLendingHistory
self.orderTrades = self.returnOrderTrades
self.createLoanOrder = self.createLoanOffer
self.cancelLoanOrder = self.cancelLoanOffer
@property
def nonce(self):
r = "{:.6f}".format(time()).replace('.', '')
return r
# -----------------Meat and Potatos---------------------------------------
# https://pypi.python.org/pypi/retry/
@retry(requests.exceptions.RequestException, delay=90)
def __call__(self, command, args={}):
"""
Main Api Function
- encodes and sends <command> with optional [args] to Poloniex api
- raises 'ValueError' if an api key or secret is missing
(and the command is 'private'), or if the <command> is not valid
- returns decoded json api message
"""
global PUBLIC_COMMANDS, PRIVATE_COMMANDS
# check in with the coach
self.apicoach.wait()
# pass the command
args['command'] = command
# private?
if command in PRIVATE_COMMANDS:
# check for keys
if not self.Key or not self.Secret:
raise ValueError("A Key and Secret needed!")
# set nonce
args['nonce'] = self.nonce
try:
# encode arguments for url
postData = _urlencode(args)
# sign postData with our Secret
sign = _new(self.Secret.encode('utf-8'),
postData.encode('utf-8'), _sha512)
# post request
ret = _post('https://poloniex.com/tradingApi',
data=args,
headers={
'Sign': sign.hexdigest(),
'Key': self.Key
},
timeout=self.timeout)
except Exception as e:
raise e
finally:
pass
# return decoded json
try:
text = ret.text
if command not in self.nolog:
self.logger.debug("""
<{0}>
<args>{1}</args>
<RESULT>{2}</RESULT>
</{0}>
""".format(command, args, text, command))
struct = _loads(text, parse_float=unicode)
struct = self.retval_wrapper(struct)
return struct
except NameError:
return _loads(text, parse_float=str)
except:
self.logger.debug("Unexpected error:", sys.exc_info()[0])
self.logger.debug("<error>%s</error>", text)
raise
# public?
elif command in PUBLIC_COMMANDS:
try:
args['nonce'] = self.nonce
ret = _get('https://poloniex.com/public?' + _urlencode(args),
timeout=self.timeout)
except Exception as e:
raise e
try:
text = ret.text
if command not in self.nolog:
self.logger.debug("""
<{0}>
<args>{1}</args>
<result>{2}</result>
</{0}>
""".format(command, args, text, command))
struct = _loads(text, parse_float=unicode)
struct = self.retval_wrapper(struct)
return struct
except NameError:
return _loads(text, parse_float=str)
except:
self.logger.debug("Unexpected error:", sys.exc_info()[0])
self.logger.debug("<error>%s</error>", text)
raise
else:
raise ValueError("Invalid Command!")
# --PUBLIC COMMANDS-------------------------------------------------------
def returnTicker(self):
""" Returns the ticker for all markets """
return self.__call__('returnTicker')
def return24hVolume(self):
""" Returns the volume data for all markets """
return self.__call__('return24hVolume')
def returnCurrencies(self):
""" Returns additional market info for all markets """
return self.__call__('returnCurrencies')
def returnLoanOrders(self, coin):
""" Returns loan order book for <coin> """
return self.__call__('returnLoanOrders',
{'currency': str(coin).upper()})
def returnOrderBook(self, pair='all', depth=20):
"""
Returns orderbook for [pair='all']
at a depth of [depth=20] orders
"""
return self.__call__('returnOrderBook', {
'currencyPair': str(pair).upper(),
'depth': str(depth)
})
def returnChartData(self, pair, period=False, start=False, end=False):
"""
Returns chart data for <pair> with a candle period of
[period=self.DAY] starting from [start=time()-self.YEAR]
and ending at [end=time()]
"""
if not period:
period = self.DAY
if not start:
start = time() - (self.MONTH * 2)
if not end:
end = time()
return self.__call__(
'returnChartData', {
'currencyPair': str(pair).upper(),
'period': str(period),
'start': str(start),
'end': str(end)
})
def marketTradeHist(self, pair, start=False, end=False):
"""
Returns public trade history for <pair>
starting at <start> and ending at [end=time()]
"""
self.apicoach.wait()
if not start:
start = time() - self.HOUR
if not end:
end = time()
try:
ret = _get('https://poloniex.com/public?' +
_urlencode({
'command': 'returnTradeHistory',
'currencyPair': str(pair).upper(),
'start': str(start),
'end': str(end)
}),
timeout=self.timeout)
except Exception as e:
raise e
try:
return _loads(ret.text, parse_float=unicode)
except NameError:
return _loads(ret.text, parse_float=str)
# --PRIVATE COMMANDS------------------------------------------------------
def returnTradeHistory(self, pair):
""" Returns private trade history for <pair> """
return self.__call__('returnTradeHistory',
{'currencyPair': str(pair).upper()})
def returnBalances(self):
""" Returns coin balances """
return self.__call__('returnBalances')
def returnAvailableAccountBalances(self):
""" Returns available account balances """
return self.__call__('returnAvailableAccountBalances')
def returnMarginAccountSummary(self):
""" Returns margin account summary """
return self.__call__('returnMarginAccountSummary')
def getMarginPosition(self, pair='all'):
""" Returns margin position for [pair='all'] """
return self.__call__('getMarginPosition',
{'currencyPair': str(pair).upper()})
def returnCompleteBalances(self, account='all'):
""" Returns complete balances """
return self.__call__('returnCompleteBalances',
{'account': str(account)})
def returnDepositAddresses(self):
""" Returns deposit addresses """
return self.__call__('returnDepositAddresses')
def returnOpenOrders(self, pair='all'):
""" Returns your open orders for [pair='all'] """
self.logger.debug('returnOpenOrders on pair %s', pair)
return self.__call__('returnOpenOrders',
{'currencyPair': str(pair).upper()})
def returnDepositsWithdrawals(self, start=False, end=False):
""" Returns deposit/withdraw history """
if not start:
start = time() - self.MONTH
if not end:
end = time()
args = {'start': str(start), 'end': str(end)}
return self.__call__('returnDepositsWithdrawals', args)
def returnTradableBalances(self):
""" Returns tradable balances """
return self.__call__('returnTradableBalances')
def returnActiveLoans(self):
""" Returns active loans """
return self.__call__('returnActiveLoans')
def returnOpenLoanOffers(self):
""" Returns open loan offers """
return self.__call__('returnOpenLoanOffers')
def returnFeeInfo(self):
""" Returns current trading fees and trailing 30-day volume in BTC """
return self.__call__('returnFeeInfo')
def returnLendingHistory(self, start=False, end=False, limit=False):
if not start:
start = time() - self.MONTH
if not end:
end = time()
args = {'start': str(start), 'end': str(end)}
if limit:
args['limit'] = str(limit)
return self.__call__('returnLendingHistory', args)
def returnOrderTrades(self, orderId):
""" Returns any trades made from <orderId> """
return self.__call__('returnOrderTrades',
{'orderNumber': str(orderId)})
def createLoanOffer(self, coin, amount, rate, autoRenew=0, duration=2):
""" Creates a loan offer for <coin> for <amount> at <rate> """
return self.__call__(
'createLoanOffer', {
'currency': str(coin).upper(),
'amount': str(amount),
'duration': str(duration),
'autoRenew': str(autoRenew),
'lendingRate': str(rate)
})
def cancelLoanOffer(self, orderId):
""" Cancels the loan offer with <orderId> """
return self.__call__('cancelLoanOffer', {'orderNumber': str(orderId)})
def toggleAutoRenew(self, orderId):
""" Toggles the 'autorenew' feature on loan <orderId> """
return self.__call__('toggleAutoRenew', {'orderNumber': str(orderId)})
def closeMarginPosition(self, pair):
""" Closes the margin position on <pair> """
return self.__call__('closeMarginPosition',
{'currencyPair': str(pair).upper()})
def marginBuy(self, pair, rate, amount, lendingRate=2):
""" Creates <pair> margin buy order at <rate> for <amount> """
return self.__call__(
'marginBuy', {
'currencyPair': str(pair).upper(),
'rate': str(rate),
'amount': str(amount),
'lendingRate': str(lendingRate)
})
def marginSell(self, pair, rate, amount, lendingRate=2):
""" Creates <pair> margin sell order at <rate> for <amount> """
return self.__call__(
'marginSell', {
'currencyPair': str(pair).upper(),
'rate': str(rate),
'amount': str(amount),
'lendingRate': str(lendingRate)
})
def buy(self, pair, rate, amount, orderType=False):
""" Creates buy order for <pair> at <rate> for
<amount> with optional orderType """
req = {
'currencyPair': str(pair).upper(),
'rate': str(rate),
'amount': str(amount),
}
# order type specified?
if orderType:
possTypes = ['fillOrKill', 'immediateOrCancel', 'postOnly']
# check type
if not orderType in possTypes:
raise ValueError('Invalid orderType')
req[orderType] = 1
return self.__call__('buy', req)
def sell(self, pair, rate, amount, orderType=False):
""" Creates sell order for <pair> at <rate> for
<amount> with optional orderType """
req = {
'currencyPair': str(pair).upper(),
'rate': str(rate),
'amount': str(amount),
}
# order type specified?
if orderType:
possTypes = ['fillOrKill', 'immediateOrCancel', 'postOnly']
# check type
if not orderType in possTypes:
raise ValueError('Invalid orderType')
req[orderType] = 1
return self.__call__('sell', req)
def cancelOrder(self, orderId):
""" Cancels order <orderId> """
return self.__call__('cancelOrder', {'orderNumber': str(orderId)})
def moveOrder(self, orderId, rate, amount, orderType=False):
""" Moves an order by <orderId> to <rate> for <amount> """
req = {
'orderNumber': str(orderId),
'rate': str(rate),
'amount': str(amount)
}
# order type specified?
if orderType:
possTypes = ['immediateOrCancel', 'postOnly']
# check type
if not orderType in possTypes:
raise ValueError('Invalid orderType')
req[orderType] = 1
return self.__call__('moveOrder', req)
def withdraw(self, coin, amount, address, paymentId=False):
""" Withdraws <coin> <amount> to <address> """
req = {
'currency': str(coin).upper(),
'amount': str(amount),
'address': str(address)
}
if paymentId:
req['paymentId'] = str(paymentId)
return self.__call__('withdraw', req)
def transferBalance(self, coin, amount, fromac, toac):
"""
Transfers coins between accounts (exchange, margin, lending)
- moves <coin> <amount> from <fromac> to <toac>
"""
return self.__call__(
'transferBalance', {
'currency': str(coin).upper(),
'amount': str(amount),
'fromAccount': str(fromac),
'toAccount': str(toac)
})
def setUp(self):
"""Sets up a BraceReader object for use in the tests."""
config = Mock()
config.debug = False
self.br = BraceReader(config)
def setUpApp(self, server_profile=None):
# Check the Nuxeo server test environment
self.nuxeo_url = os.environ.get('NXDRIVE_TEST_NUXEO_URL')
self.admin_user = os.environ.get('NXDRIVE_TEST_USER')
self.password = os.environ.get('NXDRIVE_TEST_PASSWORD')
self.build_workspace = os.environ.get('WORKSPACE')
self.result = None
self.tearedDown = False
# Take default parameter if none has been set
if self.nuxeo_url is None:
self.nuxeo_url = "http://localhost:8080/nuxeo"
if self.admin_user is None:
self.admin_user = "******"
if self.password is None:
self.password = "******"
self.tmpdir = None
if self.build_workspace is not None:
self.tmpdir = os.path.join(self.build_workspace, "tmp")
if not os.path.isdir(self.tmpdir):
os.makedirs(self.tmpdir)
self.upload_tmp_dir = tempfile.mkdtemp(u'-nxdrive-uploads',
dir=self.tmpdir)
if None in (self.nuxeo_url, self.admin_user, self.password):
raise unittest.SkipTest(
"No integration server configuration found in environment.")
# Check the local filesystem test environment
self.local_test_folder_1 = tempfile.mkdtemp(u'drive-1',
dir=self.tmpdir)
self.local_test_folder_2 = tempfile.mkdtemp(u'drive-2',
dir=self.tmpdir)
self.local_nxdrive_folder_1 = os.path.join(self.local_test_folder_1,
u'Nuxeo Drive')
os.mkdir(self.local_nxdrive_folder_1)
self.local_nxdrive_folder_2 = os.path.join(self.local_test_folder_2,
u'Nuxeo Drive')
os.mkdir(self.local_nxdrive_folder_2)
self.nxdrive_conf_folder_1 = os.path.join(self.local_test_folder_1,
u'nuxeo-drive-conf')
os.mkdir(self.nxdrive_conf_folder_1)
self.nxdrive_conf_folder_2 = os.path.join(self.local_test_folder_2,
u'nuxeo-drive-conf')
os.mkdir(self.nxdrive_conf_folder_2)
from mock import Mock
options = Mock()
options.debug = False
options.delay = TEST_DEFAULT_DELAY
options.force_locale = None
options.proxy_server = None
options.log_level_file = None
options.update_site_url = None
options.beta_update_site_url = None
options.autolock_interval = 30
options.nxdrive_home = self.nxdrive_conf_folder_1
self.manager_1 = Manager(options)
self.connected = False
import nxdrive
nxdrive_path = os.path.dirname(nxdrive.__file__)
i18n_path = os.path.join(nxdrive_path, 'tests', 'resources', "i18n.js")
Translator(self.manager_1, i18n_path)
options.nxdrive_home = self.nxdrive_conf_folder_2
Manager._singleton = None
self.manager_2 = Manager(options)
self.version = __version__
url = self.nuxeo_url
log.debug("Will use %s as url", url)
if '#' in url:
# Remove the engine type for the rest of the test
self.nuxeo_url = url.split('#')[0]
self.setUpServer(server_profile)
self.engine_1 = self.manager_1.bind_server(self.local_nxdrive_folder_1,
url,
self.user_1,
self.password_1,
start_engine=False)
self.engine_2 = self.manager_2.bind_server(self.local_nxdrive_folder_2,
url,
self.user_2,
self.password_2,
start_engine=False)
self.engine_1.syncCompleted.connect(self.app.sync_completed)
self.engine_1.get_remote_watcher().remoteScanFinished.connect(
self.app.remote_scan_completed)
self.engine_1.get_remote_watcher().changesFound.connect(
self.app.remote_changes_found)
self.engine_1.get_remote_watcher().noChangesFound.connect(
self.app.no_remote_changes_found)
self.engine_2.syncCompleted.connect(self.app.sync_completed)
self.engine_2.get_remote_watcher().remoteScanFinished.connect(
self.app.remote_scan_completed)
self.engine_2.get_remote_watcher().changesFound.connect(
self.app.remote_changes_found)
self.engine_2.get_remote_watcher().noChangesFound.connect(
self.app.no_remote_changes_found)
self.queue_manager_1 = self.engine_1.get_queue_manager()
self.queue_manager_2 = self.engine_2.get_queue_manager()
self.sync_root_folder_1 = os.path.join(self.local_nxdrive_folder_1,
self.workspace_title_1)
self.sync_root_folder_2 = os.path.join(self.local_nxdrive_folder_2,
self.workspace_title_2)
self.local_root_client_1 = self.engine_1.get_local_client()
self.local_root_client_2 = self.engine_2.get_local_client()
self.local_client_1 = self.get_local_client(
os.path.join(self.local_nxdrive_folder_1, self.workspace_title))
self.local_client_2 = self.get_local_client(
os.path.join(self.local_nxdrive_folder_2, self.workspace_title))
# Document client to be used to create remote test documents
# and folders
remote_document_client_1 = RemoteDocumentClient(
self.nuxeo_url,
self.user_1,
u'nxdrive-test-device-1',
self.version,
password=self.password_1,
base_folder=self.workspace_1,
upload_tmp_dir=self.upload_tmp_dir)
remote_document_client_2 = RemoteDocumentClient(
self.nuxeo_url,
self.user_2,
u'nxdrive-test-device-2',
self.version,
password=self.password_2,
base_folder=self.workspace_2,
upload_tmp_dir=self.upload_tmp_dir)
# File system client to be used to create remote test documents
# and folders
remote_file_system_client_1 = RemoteFileSystemClient(
self.nuxeo_url,
self.user_1,
u'nxdrive-test-device-1',
self.version,
password=self.password_1,
upload_tmp_dir=self.upload_tmp_dir)
remote_file_system_client_2 = RemoteFileSystemClient(
self.nuxeo_url,
self.user_2,
u'nxdrive-test-device-2',
self.version,
password=self.password_2,
upload_tmp_dir=self.upload_tmp_dir)
self.remote_restapi_client_1 = RestAPIClient(self.nuxeo_url,
self.user_1,
u'nxdrive-test-device-1',
self.version,
password=self.password_1)
self.remote_restapi_client_2 = RestAPIClient(self.nuxeo_url,
self.user_2,
u'nxdrive-test-device-2',
self.version,
password=self.password_2)
self.remote_restapi_client_admin = RestAPIClient(
self.nuxeo_url,
self.admin_user,
u'nxdrive-test-device-2',
self.version,
password=self.password)
# Register root
remote_document_client_1.register_as_root(self.workspace_1)
remote_document_client_2.register_as_root(self.workspace_2)
self.remote_document_client_1 = remote_document_client_1
self.remote_document_client_2 = remote_document_client_2
self.remote_file_system_client_1 = remote_file_system_client_1
self.remote_file_system_client_2 = remote_file_system_client_2
self._wait_sync = {
self.engine_1.get_uid(): True,
self.engine_2.get_uid(): True
}
self._wait_remote_scan = {
self.engine_1.get_uid(): True,
self.engine_2.get_uid(): True
}
self._remote_changes_count = {
self.engine_1.get_uid(): 0,
self.engine_2.get_uid(): 0
}
self._no_remote_changes = {
self.engine_1.get_uid(): False,
self.engine_2.get_uid(): False
}
def setUp(self):
"""Sets up a BraceReader object for use in the tests."""
config = Mock()
config.debug = False
self.br = BraceReader(config)
def setUpApp(self, server_profile=None):
# Check the Nuxeo server test environment
self.nuxeo_url = os.environ.get('NXDRIVE_TEST_NUXEO_URL')
self.admin_user = os.environ.get('NXDRIVE_TEST_USER')
self.password = os.environ.get('NXDRIVE_TEST_PASSWORD')
self.build_workspace = os.environ.get('WORKSPACE')
self.result = None
self.tearedDown = False
# Take default parameter if none has been set
if self.nuxeo_url is None:
self.nuxeo_url = "http://localhost:8080/nuxeo"
if self.admin_user is None:
self.admin_user = "******"
if self.password is None:
self.password = "******"
self.tmpdir = None
if self.build_workspace is not None:
self.tmpdir = os.path.join(self.build_workspace, "tmp")
if not os.path.isdir(self.tmpdir):
os.makedirs(self.tmpdir)
self.upload_tmp_dir = tempfile.mkdtemp(u'-nxdrive-uploads', dir=self.tmpdir)
if None in (self.nuxeo_url, self.admin_user, self.password):
raise unittest.SkipTest(
"No integration server configuration found in environment.")
# Check the local filesystem test environment
self.local_test_folder_1 = tempfile.mkdtemp(u'-nxdrive-tests-user-1', dir=self.tmpdir)
self.local_test_folder_2 = tempfile.mkdtemp(u'-nxdrive-tests-user-2', dir=self.tmpdir)
self.local_nxdrive_folder_1 = os.path.join(
self.local_test_folder_1, u'Nuxeo Drive')
os.mkdir(self.local_nxdrive_folder_1)
self.local_nxdrive_folder_2 = os.path.join(
self.local_test_folder_2, u'Nuxeo Drive')
os.mkdir(self.local_nxdrive_folder_2)
self.nxdrive_conf_folder_1 = os.path.join(
self.local_test_folder_1, u'nuxeo-drive-conf')
os.mkdir(self.nxdrive_conf_folder_1)
self.nxdrive_conf_folder_2 = os.path.join(
self.local_test_folder_2, u'nuxeo-drive-conf')
os.mkdir(self.nxdrive_conf_folder_2)
from mock import Mock
options = Mock()
options.debug = False
options.delay = TEST_DEFAULT_DELAY
options.force_locale = None
options.proxy_server = None
options.log_level_file = None
options.update_site_url = None
options.beta_update_site_url = None
options.autolock_interval = 30
options.nxdrive_home = self.nxdrive_conf_folder_1
self.manager_1 = Manager(options)
self.connected = False
import nxdrive
nxdrive_path = os.path.dirname(nxdrive.__file__)
i18n_path = os.path.join(nxdrive_path, 'tests', 'resources', "i18n.js")
Translator(self.manager_1, i18n_path)
options.nxdrive_home = self.nxdrive_conf_folder_2
Manager._singleton = None
self.manager_2 = Manager(options)
self.version = __version__
url = self.nuxeo_url
log.debug("Will use %s as url", url)
if '#' in url:
# Remove the engine type for the rest of the test
self.nuxeo_url = url.split('#')[0]
self.setUpServer(server_profile)
self.engine_1 = self.manager_1.bind_server(self.local_nxdrive_folder_1, url, self.user_1,
self.password_1, start_engine=False)
self.engine_2 = self.manager_2.bind_server(self.local_nxdrive_folder_2, url, self.user_2,
self.password_2, start_engine=False)
self.engine_1.syncCompleted.connect(self.app.sync_completed)
self.engine_1.get_remote_watcher().remoteScanFinished.connect(self.app.remote_scan_completed)
self.engine_1.get_remote_watcher().changesFound.connect(self.app.remote_changes_found)
self.engine_1.get_remote_watcher().noChangesFound.connect(self.app.no_remote_changes_found)
self.engine_2.syncCompleted.connect(self.app.sync_completed)
self.engine_2.get_remote_watcher().remoteScanFinished.connect(self.app.remote_scan_completed)
self.engine_2.get_remote_watcher().changesFound.connect(self.app.remote_changes_found)
self.engine_2.get_remote_watcher().noChangesFound.connect(self.app.no_remote_changes_found)
self.queue_manager_1 = self.engine_1.get_queue_manager()
self.queue_manager_2 = self.engine_2.get_queue_manager()
self.sync_root_folder_1 = os.path.join(self.local_nxdrive_folder_1, self.workspace_title_1)
self.sync_root_folder_2 = os.path.join(self.local_nxdrive_folder_2, self.workspace_title_2)
self.local_root_client_1 = self.engine_1.get_local_client()
self.local_root_client_2 = self.engine_2.get_local_client()
self.local_client_1 = LocalClient(os.path.join(self.local_nxdrive_folder_1, self.workspace_title_1))
self.local_client_2 = LocalClient(os.path.join(self.local_nxdrive_folder_2, self.workspace_title_2))
# Document client to be used to create remote test documents
# and folders
remote_document_client_1 = RemoteDocumentClient(
self.nuxeo_url, self.user_1, u'nxdrive-test-device-1',
self.version,
password=self.password_1, base_folder=self.workspace_1,
upload_tmp_dir=self.upload_tmp_dir)
remote_document_client_2 = RemoteDocumentClient(
self.nuxeo_url, self.user_2, u'nxdrive-test-device-2',
self.version,
password=self.password_2, base_folder=self.workspace_2,
upload_tmp_dir=self.upload_tmp_dir)
# File system client to be used to create remote test documents
# and folders
remote_file_system_client_1 = RemoteFileSystemClient(
self.nuxeo_url, self.user_1, u'nxdrive-test-device-1',
self.version,
password=self.password_1, upload_tmp_dir=self.upload_tmp_dir)
remote_file_system_client_2 = RemoteFileSystemClient(
self.nuxeo_url, self.user_2, u'nxdrive-test-device-2',
self.version,
password=self.password_2, upload_tmp_dir=self.upload_tmp_dir)
self.remote_restapi_client_1 = RestAPIClient(
self.nuxeo_url, self.user_1, u'nxdrive-test-device-1',
self.version,
password=self.password_1
)
self.remote_restapi_client_2 = RestAPIClient(
self.nuxeo_url, self.user_2, u'nxdrive-test-device-2',
self.version,
password=self.password_2
)
# Register root
remote_document_client_1.register_as_root(self.workspace_1)
remote_document_client_2.register_as_root(self.workspace_2)
self.remote_document_client_1 = remote_document_client_1
self.remote_document_client_2 = remote_document_client_2
self.remote_file_system_client_1 = remote_file_system_client_1
self.remote_file_system_client_2 = remote_file_system_client_2
self._wait_sync = {self.engine_1.get_uid(): True, self.engine_2.get_uid(): True}
self._wait_remote_scan = {self.engine_1.get_uid(): True, self.engine_2.get_uid(): True}
self._remote_changes_count = {self.engine_1.get_uid(): 0, self.engine_2.get_uid(): 0}
self._no_remote_changes = {self.engine_1.get_uid(): False, self.engine_2.get_uid(): False}
