class ConfigTests(N26TestBase):
"""Config tests"""
EXPECTED_FILE_CONF = config.Config(username='******',
password='******',
login_data_store_path=None)
EXPECTED_ENV_CONF = config.Config(username='******',
password='******',
login_data_store_path=None)
def test_preconditions(self):
assert os.path.exists(self.CONFIG_FILE)
@mock.patch.dict(
os.environ, {
ENV_PARAM_USER: EXPECTED_ENV_CONF.username,
ENV_PARAM_PASSWORD: EXPECTED_ENV_CONF.password
})
def test_environment_variable(self):
result = config.get_config()
self.assertEqual(result, self.EXPECTED_ENV_CONF)
# ensure environment is empty
@mock.patch.dict(os.environ, {ENV_PARAM_USER: "", ENV_PARAM_PASSWORD: ""})
def test_file(self):
# use test file path instead of real one
config.CONFIG_FILE_PATH = self.CONFIG_FILE
result = config.get_config()
self.assertEqual(result, self.EXPECTED_FILE_CONF)
def wrapper(*args, **kwargs):
with mock.patch('n26.config.get_config') as mock_config:
from n26 import config
mock_config.return_value = config.Config(
username=username, password=password,
login_data_store_path=None)
return function(*args, **kwargs)
def test_init_with_config(self):
conf = config.Config(username='******',
password='******',
login_data_store_path=None)
api_client = api.Api(conf)
self.assertIsNotNone(api_client.config)
self.assertEqual(api_client.config, conf)
def setup(hass, config):
"""Set up N26 Component."""
acc_list = config[DOMAIN]
api_data_list = []
for acc in acc_list:
user = acc[CONF_USERNAME]
password = acc[CONF_PASSWORD]
api = n26_api.Api(n26_config.Config(user, password))
try:
api.get_token()
except HTTPError as err:
_LOGGER.error(str(err))
return False
api_data = N26Data(api)
api_data.update()
api_data_list.append(api_data)
hass.data[DOMAIN] = {}
hass.data[DOMAIN][DATA] = api_data_list
# Load components for supported devices
for component in N26_COMPONENTS:
load_platform(hass, component, DOMAIN, {}, config)
return True
def setup(hass, config):
"""Set up N26 Component."""
user = config[DOMAIN][CONF_USERNAME]
password = config[DOMAIN][CONF_PASSWORD]
from n26 import api, config as api_config
api = api.Api(api_config.Config(user, password))
from requests import HTTPError
try:
api.get_token()
except HTTPError as err:
_LOGGER.error(str(err))
return False
api_data = N26Data(api)
api_data.update()
hass.data[DOMAIN] = {}
hass.data[DOMAIN][DATA] = api_data
# Load components for supported devices
for component in N26_COMPONENTS:
load_platform(hass, component, DOMAIN, {}, config)
return True
def test_init_with_config(self):
from container_app_conf.source.yaml_source import YamlSource
conf = config.Config(
singleton=False,
data_sources=[YamlSource("test_creds", "./tests/")])
api_client = api.Api(conf)
self.assertIsNotNone(api_client.config)
self.assertEqual(api_client.config, conf)
def test_file(monkeypatch):
# patch path to local test file
def mockreturn(path):
return test_creds
monkeypatch.setattr(os.path, "expanduser", mockreturn)
assert config.get_config() == config.Config(
username='******',
password='******',
card_id="123456789")
import functools
import mock
from n26 import api, config
import pytest
conf = config.Config(username='******',
password='******',
card_id="123456789")
# decorator for patching get_token
def patch_token(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
with mock.patch('n26.api.Api.get_token') as mock_token:
mock_token.return_value = 'some token'
return func(*args, **kwargs)
return wrapper
@pytest.fixture
def api_object():
new_api = api.Api(conf)
return new_api
# test __init__
@mock.patch('n26.api.config.get_config')
def test_init_implicit(patched_config):
patched_config.return_value = conf
def test_environment_variable():
assert config.get_config() == config.Config(
username='******',
password='******',
card_id="123456789")
def main(cat_mappings):
conf = config.Config(os.getenv("N26_USER"), os.getenv("N26_PASSWORD"),
'store/n26_creds')
client = api.Api(conf)
#s to ms - CET Local
now = int(time.time() * 1E3)
# -5min
minus5 = int(now - 3E5)
print(minus5, now)
response = client.get_transactions(limit=200,
from_time=minus5,
to_time=now)
print(datetime.fromtimestamp(math.floor(minus5 / 1E3)), '-',
datetime.fromtimestamp(math.floor(now / 1E3)))
transactions_payload = list()
print("Transactions to process: " + str(len(response)))
for transaction in response:
category_name = mappings[next(
(index for (index, d) in enumerate(mappings)
if d["id"] == transaction["category"]), None)]["name"]
is_sepa = 'partnerName' in transaction
if not 'confirmed' in transaction or 'paymentScheme' in transaction:
continue
try:
transaction_time = time.strftime(
"%Y-%m-%d", time.localtime(transaction["confirmed"] / 1E3))
is_debit = transaction["amount"] < 0
payload = {
'type': "withdrawal" if is_debit else "deposit",
'external_id': transaction["linkId"],
'date': transaction_time,
'amount': abs(transaction["amount"]),
'currency_code': transaction["currencyCode"],
'category_name': category_name,
'tags': ['N26 importer']
}
if is_sepa:
payload["destination_name"] = transaction["partnerName"]
if 'partnerIban' in transaction:
payload["destination_iban"] = transaction["partnerIban"]
if 'referenceText' in transaction:
payload["description"] = transaction["referenceText"]
payload["source_name"] = "N26" if is_debit else transaction[
"partnerName"]
payload["destination_name"] = transaction[
"partnerName"] if is_debit else "N26"
else:
payload["source_name"] = "N26" if is_debit else transaction[
"merchantName"]
payload["destination_name"] = transaction[
"merchantName"] if is_debit else "N26"
payload["description"] = "(empty description)"
transactions_payload.append(payload)
except Exception as e:
writeLog(transaction, e)
if len(transactions_payload) == 0:
print("Nothing to do")
return
data = {'transactions': transactions_payload}
headers = {
'Authorization': 'Bearer ' + os.getenv("FFIII_AUTH_TOKEN"),
'Content-Type': 'application/json',
'Accept': 'application/json'
}
try:
r = requests.post(url=os.getenv("FFIII_API_ENDPOINT"),
json=data,
headers=headers)
r.raise_for_status()
print(r.text)
except Exception as e:
printLog(r.text, e)
printLog(data)
print("Job done")
