1622 lines
49 KiB
Python
1622 lines
49 KiB
Python
from __future__ import absolute_import
|
|
from __future__ import division
|
|
from __future__ import print_function
|
|
from __future__ import unicode_literals
|
|
|
|
import pytest
|
|
|
|
pytestmark = pytest.mark.django_db
|
|
from rowers.opaque import encoder
|
|
encoded1 = str(encoder.encode_hex(1))
|
|
encoded2 = str(encoder.encode_hex(2))
|
|
encoded13 = str(encoder.encode_hex(13))
|
|
|
|
from bs4 import BeautifulSoup
|
|
import re
|
|
from parameterized import parameterized
|
|
from django.test import TestCase, Client,override_settings
|
|
from django.core.management import call_command
|
|
|
|
from django.test.client import RequestFactory
|
|
from rowers.models import Workout, User, Rower, WorkoutForm,RowerForm,GraphImage
|
|
from rowers.forms import DocumentsForm,CNsummaryForm,RegistrationFormUniqueEmail
|
|
import rowers.plots as plots
|
|
import rowers.interactiveplots as iplots
|
|
import datetime
|
|
from rowingdata import rowingdata as rdata
|
|
from rowingdata import rower as rrower
|
|
from django.utils import timezone
|
|
from rowers.rows import handle_uploaded_file
|
|
from django.core.files.uploadedfile import SimpleUploadedFile
|
|
from time import strftime,strptime,mktime,time,daylight
|
|
import os
|
|
from rowers.tasks import handle_makeplot
|
|
from rowers.utils import serialize_list,deserialize_list
|
|
from rowers.utils import NoTokenError
|
|
from shutil import copyfile
|
|
from nose.tools import assert_true
|
|
from mock import Mock, patch
|
|
#from minimocktest import MockTestCase
|
|
import pandas as pd
|
|
import polars as pl
|
|
|
|
import arrow
|
|
from django.http import HttpResponseRedirect
|
|
|
|
import json
|
|
import numpy as np
|
|
from rowingdata import rowingdata, figure
|
|
|
|
from rowers import urls
|
|
from rowers.views import (
|
|
error500_view,error404_view,error400_view,error403_view
|
|
)
|
|
|
|
from rowers.dataprep import delete_strokedata
|
|
|
|
from redis import StrictRedis
|
|
redis_connection = StrictRedis()
|
|
|
|
def mocked_idoklad_token(*args, **kwargs): # pragma: no cover
|
|
class MockToken:
|
|
def __init__(self, *args,**kwargs):
|
|
self.access_token = "aap"
|
|
|
|
return MockToken()
|
|
|
|
|
|
|
|
def mocked_grpc(*args, **kwargs): # pragma: no cover
|
|
class insecure_channel:
|
|
def __init__(*args,**kwargs):
|
|
pass
|
|
|
|
class channel_ready_future:
|
|
def __init__(*args,**kwargs):
|
|
pass
|
|
|
|
def result(self,*args,**kwargs):
|
|
pass
|
|
|
|
class Result:
|
|
def __init__(*args,**kwargs):
|
|
self.result = 1
|
|
|
|
class calculator_pb2_grpc:
|
|
def PowerStub(*args,**kwargs):
|
|
def __init__(*args,**kwargs):
|
|
pass
|
|
|
|
def CalcPower(*args,**kwargs):
|
|
return Result()
|
|
|
|
def mocked_send_template_email(*args,**kwargs):
|
|
return 1
|
|
|
|
def mocked_myqueue(*args, **kwargs): # pragma: no cover
|
|
class Job:
|
|
def __init__(self,*args, **kwargs):
|
|
self.result = 1
|
|
self.id = 1
|
|
|
|
def revoke(self):
|
|
return 1
|
|
|
|
return Job()
|
|
|
|
def mock_c2open(*args, **kwargs): # pragma: no cover
|
|
return('aap')
|
|
|
|
def mock_osm(*args, **kwargs):
|
|
return {
|
|
'ok': True,
|
|
json: {
|
|
'country': 'Atlantis',
|
|
}
|
|
}
|
|
|
|
def mocked_session(*args, **kwargs):
|
|
|
|
class MockEngine:
|
|
def __init__(self, *args, **kwargs):
|
|
self.headers = MockHeaders()
|
|
|
|
def post(self, *args, **kwargs):
|
|
return MockResponse({'id':1},200)
|
|
|
|
class MockHeaders:
|
|
def update(*args, **kwargs):
|
|
return None
|
|
|
|
class MockResponse:
|
|
def __init__(self, json_data, status_code):
|
|
self.json_data = json_data
|
|
self.status_code = status_code
|
|
self.reason = 'mock reason'
|
|
self.headers = {
|
|
'Location':'MockLocation',
|
|
}
|
|
self.ok = True
|
|
self.text = 'Mocked response text'
|
|
|
|
def json(self):
|
|
return self.json_data
|
|
|
|
class MockContentResponse: # pragma: no cover
|
|
def __init__(self,filename,status_code):
|
|
with open(filename,'rb') as f:
|
|
s = f.read()
|
|
self.content = s
|
|
self.status_code = status_code
|
|
self.ok = True
|
|
|
|
|
|
return MockEngine()
|
|
|
|
def mocked_sqlalchemy(*args, **kwargs): # pragma: no cover
|
|
# return object with method
|
|
|
|
class MockEngine:
|
|
def connect(self):
|
|
return MockConnection()
|
|
|
|
def dispose(self):
|
|
return True
|
|
|
|
def raw_connection(self):
|
|
return True
|
|
|
|
class QueryResult:
|
|
def fetchall(self):
|
|
return []
|
|
|
|
class MockConnection:
|
|
def begin(self):
|
|
return True
|
|
|
|
def execute(self,query):
|
|
if 'polygon' in query:
|
|
return QueryResult()
|
|
return True
|
|
|
|
def execute(self):
|
|
return True
|
|
|
|
def close(self):
|
|
return True
|
|
|
|
def __exit__(self, *args, **kwargs):
|
|
return True
|
|
|
|
def __enter__(self, *args, **kwargs):
|
|
return True
|
|
|
|
return MockEngine()
|
|
|
|
from rowers import courses
|
|
|
|
def mocked_sqlalchemy_courses(*args, **kwargs): # pragma: no cover
|
|
# return object with method
|
|
cs = courses.kmltocourse('rowers/tests/testdata/thyro.kml')
|
|
course = cs[0]
|
|
cname = course['name']
|
|
cnotes = course['description']
|
|
polygons = course['polygons']
|
|
|
|
lijst = []
|
|
i=0
|
|
for polygon in polygons:
|
|
lijst.append((i,polygon['name']))
|
|
i = i+1
|
|
|
|
puntenlijst = []
|
|
i = 0
|
|
for p in polygons[0]['points']:
|
|
puntenlijst.append((i,p['latitude'],p['longitude']))
|
|
i = i+1
|
|
|
|
|
|
class MockEngine:
|
|
def connect(self):
|
|
return MockConnection()
|
|
|
|
def dispose(self):
|
|
return True
|
|
|
|
def raw_connection(self):
|
|
return True
|
|
|
|
class QueryResultPolygons:
|
|
def fetchall(self):
|
|
return lijst
|
|
|
|
class QueryResultPoints:
|
|
def fetchall(self):
|
|
return puntenlijst
|
|
|
|
class MockConnection:
|
|
def begin(self):
|
|
return True
|
|
|
|
def execute(self,query):
|
|
if 'latitude' in query:
|
|
return QueryResultPoints()
|
|
if 'polygon' in query:
|
|
return QueryResultPolygons()
|
|
return True
|
|
|
|
def close(self):
|
|
return True
|
|
|
|
def __exit__(self, *args, **kwargs):
|
|
return True
|
|
|
|
def __enter__(self, *args, **kwargs):
|
|
return True
|
|
|
|
return MockEngine()
|
|
|
|
|
|
#@pytest.mark.django_db
|
|
class DjangoTestCase(TestCase): #, MockTestCase):
|
|
def _pre_setup(self):
|
|
# MockTestCase.setUp(self)
|
|
TestCase._pre_setup(self)
|
|
self.client = Client()
|
|
|
|
def _post_teardown(self):
|
|
TestCase._post_teardown(self)
|
|
#MockTestCase.tearDown(self)
|
|
# delete_strokedata(1)
|
|
|
|
def mocked_tcx_parser(*args, **kwargs): # pragma: no cover
|
|
df = pd.read_csv('rowers/tests/testdata/fake_strokedata.csv')
|
|
|
|
return rowingdata(df=df)
|
|
|
|
def mocked_polar_notifications(*args, **kwargs):
|
|
return []
|
|
|
|
|
|
class mocked_canvas():
|
|
def print_figure(*args, **kwargs):
|
|
return True
|
|
|
|
# Mocked Dataprep
|
|
|
|
def mocked_fetchcperg(*args, **kwargs):
|
|
df = pd.read_csv('rowers/tests/testdata/cpdataerg.csv')
|
|
|
|
return df
|
|
|
|
|
|
def mocked_read_df_sql(id): # pragma: no cover
|
|
df = pd.read_csv('rowers/tests/testdata/fake_strokedata.csv')
|
|
|
|
return df
|
|
|
|
def mocked_sendmail(*args,**kwargs): # pragma: no cover
|
|
return HttpResponseRedirect('/rowers/email/')
|
|
|
|
def mocked_get_video_data(*args, **kwargs):
|
|
with open('rowers/tests/testdata/videodata.json','r') as infile:
|
|
data = json.load(infile)
|
|
|
|
maxtime = 4135.
|
|
with open('rowers/tests/testdata/videometrics.json','r') as infile:
|
|
metrics = json.load(infile)
|
|
|
|
return data,metrics,maxtime
|
|
|
|
def mocked_getrowdata_db(*args, **kwargs):
|
|
df = pd.read_csv('rowers/tests/testdata/getrowdata_mock.csv')
|
|
|
|
id = kwargs['id']
|
|
|
|
row = Workout.objects.get(id=id)
|
|
|
|
return df,row
|
|
|
|
def mocked_getrowdata_uh(*args, **kwargs): # pragma: no cover
|
|
df = pl.read_csv('rowers/tests/testdata/uhfull.csv')
|
|
|
|
id = kwargs['id']
|
|
|
|
row = Workout.objects.get(id=id)
|
|
|
|
return df, row
|
|
|
|
|
|
def mocked_getsmallrowdata_uh(*args, **kwargs): # pragma: no cover
|
|
df = pl.read_csv('rowers/tests/testdata/uhfull.csv')
|
|
|
|
return df
|
|
|
|
def mocked_getsmallrowdata_uh_pd(*args, **kwargs): # pragma: no cover
|
|
df = pd.read_csv('rowers/tests/testdata/uhfull.csv')
|
|
|
|
return df
|
|
|
|
def mocked_getsmallrowdata_forfusion(*args, **kwargs):
|
|
df = pl.read_csv('rowers/tests/testdata/getrowdata_mock.csv')
|
|
|
|
return df
|
|
|
|
from collections import OrderedDict
|
|
|
|
def mocked_videodata(*args, **kwargs):
|
|
df = pd.read_csv('rowers/tests/testdata/testvideodata.csv')
|
|
data = df .to_dict()
|
|
df = pd.read_csv('rowers/tests/testdata/testvideodata_metrics.csv')
|
|
metrics = OrderedDict(df.to_dict())
|
|
|
|
maxtime = 3282.4
|
|
|
|
return data, metrics, maxtime
|
|
|
|
def mocked_getsmallrowdata_db(*args, **kwargs):
|
|
df = pd.read_csv('rowers/tests/testdata/colsfromdb.csv')
|
|
|
|
return df
|
|
|
|
def mocked_read_data(*args, **kwargs):
|
|
df = pl.read_csv('rowers/tests/testdata/colsfromdb.csv')
|
|
|
|
return df
|
|
|
|
def mocked_getsmallrowdata_db_updatecp(*args, **kwargs): # pragma: no cover
|
|
df = pd.read_csv('rowers/tests/testdata/colsfromdb.csv')
|
|
|
|
return df
|
|
|
|
def mocked_getsmallrowdata_db_setcp(*args, **kwargs): # pragma: no cover
|
|
df = pd.read_csv('rowers/tests/testdata/colsfromdb2.csv')
|
|
|
|
return df
|
|
|
|
|
|
def mocked_getsmallrowdata_db_water(*args, **kwargs): # pragma: no cover
|
|
df = pd.read_csv('rowers/tests/testdata/colsfromdb3.csv')
|
|
|
|
return df
|
|
|
|
def mocked_read_data_wps(*args, **kwargs): # pragma: no cover
|
|
df = pl.read_csv('rowers/tests/testdata/driveenergies.csv')
|
|
|
|
return df
|
|
|
|
def mocked_getpowerdata_db(*args, **kwargs): # pragma: no cover
|
|
df = pd.read_csv('rowers/tests/testdata/fake_powerdata.csv')
|
|
|
|
return df
|
|
|
|
def mock_for_interactive_chart(*args, **kwargs): # pragma: no cover
|
|
df = pd.read_csv('rowers/tests/testdata/interactivechart.csv')
|
|
|
|
return df
|
|
|
|
def mocked_getempowerdata_db(*args, **kwargs):
|
|
df = pd.read_csv('rowers/tests/testdata/fake_empowerdata.csv')
|
|
|
|
return df
|
|
|
|
def mocked_read_df_cols_sql_multistats(ids,columns,convertnewtons=True): # pragma: no cover
|
|
df = pd.read_csv('rowers/tests/testdata/cumstats.csv')
|
|
extracols = []
|
|
|
|
return df, extracols
|
|
|
|
def mocked_read_cols_df_sql(*args, **kwargs):
|
|
df = pd.read_csv('rowers/tests/testdata/readcols.csv')
|
|
|
|
return df,[]
|
|
|
|
|
|
def mock_workout_summaries(*args, **kwargs):
|
|
df = pl.read_csv('rowers/tests/testdata/workout_summaries.csv')
|
|
return df
|
|
|
|
def mocked_read_df_cols_sql_multi(ids, columns, convertnewtons=True): # pragma: no cover
|
|
df = pd.read_csv('rowers/tests/testdata/fake_strokedata2.csv')
|
|
extracols = []
|
|
|
|
return df, extracols
|
|
|
|
def mocked_read_df_cols_sql_multiflex(ids, columns, convertnewtons=True): # pragma: no cover
|
|
df = pd.read_csv('rowers/tests/testdata/multiflexdata.csv')
|
|
extracols = []
|
|
|
|
return df, extracols
|
|
|
|
# Mocked Strava
|
|
|
|
def mocked_stravaexport(f2,workoutname,stravatoken,description='',
|
|
activity_type='Rowing'): # pragma: no cover
|
|
print("this is mocked strava export")
|
|
return 1,'success'
|
|
|
|
def mocked_fetchcp(*args, **kwargs): # pragma: no cover
|
|
df = pd.read_csv('rowers/tests/testdata/otwcpresult.csv')
|
|
delta = df['delta']
|
|
cpvalue = df['cpvalue']
|
|
|
|
try:
|
|
theworkouts = args[1]
|
|
except:
|
|
theworkouts = []
|
|
|
|
theids = [int(w.id) for w in theworkouts]
|
|
|
|
avgpower = {}
|
|
thepowers = [203,153,143,152,196,211,223]
|
|
|
|
for i in range(len(theids)):
|
|
avgpower[id[i]] = thepowers[i]
|
|
|
|
return delta, cpvalue, avgpower
|
|
|
|
def mocked_getcpdata_sql(*args, **kwargs): # pragma: no cover
|
|
df = pd.read_csv('rowers/tests/testdata/otwcpresult.csv')
|
|
|
|
df['cp'] = df['cpvalue']
|
|
|
|
return df
|
|
|
|
def mocked_cpraw(*args, **kwargs): # pragma: no cover
|
|
df = pd.read_csv('rowers/tests/testdata/otwcp_df.csv')
|
|
|
|
return df
|
|
|
|
class StravalibResponse():
|
|
def __init__(self,*args, **kwargs):
|
|
self.id = 1
|
|
|
|
class StravaActivity():
|
|
def wait(*args, **kwargs):
|
|
return StravalibResponse()
|
|
|
|
def __init__(*args, **kwargs):
|
|
pass
|
|
|
|
|
|
|
|
class MockStravalibClient():
|
|
def upload_activity(*args, **kwargs):
|
|
return StravaActivity()
|
|
|
|
def update_activity(*args, **kwargs):
|
|
return StravaActivity()
|
|
|
|
def __init__(*args,**kwargs):
|
|
pass
|
|
|
|
# Mocked Braintree
|
|
|
|
## Higher level - unfortunately didn't succeed in mocking the gateway
|
|
|
|
def get_client_token(*args, **kwargs): # pragma: no cover
|
|
return "aap"
|
|
|
|
def mock_create_customer(*args, **kwargs):
|
|
return 121
|
|
|
|
def mock_make_payment(*args, **kwargs): # pragma: no cover
|
|
return 15,''
|
|
|
|
def mock_update_subscription(*args, **kwargs):
|
|
try: # pragma: no cover
|
|
rower = args[0]
|
|
data = args[1]
|
|
planid = data['plan']
|
|
plan = PaidPlan.objects.get(id=planid)
|
|
amount = data['amount']
|
|
|
|
rower.paidplan = plan
|
|
rower.planexpires = (datetime.datetime.now()+datetime.timedelta(days=365)).date()
|
|
rower.clubsize = plan.clubsize
|
|
rower.paymenttype = plan.paymenttype
|
|
rower.rowerplan = plan.shortname
|
|
rower.subscription_id = 12
|
|
rower.save()
|
|
except:
|
|
amount = 20
|
|
|
|
return True,amount
|
|
|
|
def mock_create_subscription(*args, **kwargs):
|
|
return mock_update_subscription(*args, **kwargs)
|
|
|
|
def mock_cancel_subscription(*args, **kwargs): # pragma: no cover
|
|
themessages = []
|
|
errormessages = []
|
|
try:
|
|
basicplans = PaidPlan.objects.filter(price=0,paymentprocessor='braintree')
|
|
rower.paidplan = basicplans[0]
|
|
rower.teamplanexpires = timezone.now()
|
|
rower.planexpires = timezone.now()
|
|
rower.clubsize = 0
|
|
rower.rowerplan = 'basic'
|
|
rower.subscription_id = None
|
|
rower.save()
|
|
themessages.append("Your plan was reset to basic")
|
|
except:
|
|
pass
|
|
|
|
return True, themessages,errormessages
|
|
|
|
def mock_mocktest(*args, **kwargs):
|
|
return '121'
|
|
|
|
|
|
## Gateway stuff (not working)
|
|
|
|
class gatewayresult(): # pragma: no cover
|
|
def __init__(self,*args,**kwargs):
|
|
self.is_success = kwargs.pop('is_success',True)
|
|
self.customer_id = 1
|
|
self.transaction = vtransaction()
|
|
self.payment_method = vpayment_method()
|
|
self.subscription = vsubscription()
|
|
self.paid_through_date = datetime.datetime.now()+datetime.timedelta(days=365)
|
|
self.customer = kwargs.pop('customer',customer())
|
|
|
|
def __unicode__():
|
|
return "mockedgatewayresult"
|
|
|
|
class credit_card(): # pragma: no cover
|
|
def __init__(self, *args, **kwargs):
|
|
self.subscriptions = [vsubscription()]
|
|
self.country_of_issuance = 'US'
|
|
|
|
class paypal_account(): # pragma: no cover
|
|
def __init__(self, *args, **kwargs):
|
|
self.subscriptions = [vsubscription(),vsubscription()]
|
|
|
|
class customercreateresult: # pragma: no cover
|
|
def __init__(self, *args, **kwargs):
|
|
self.customer = kwargs.pop('customer',customer())
|
|
self.is_success = kwargs.pop('is_success',True)
|
|
self.customer_id = 1
|
|
|
|
class customer(): # pragma: no cover
|
|
def find(*arg, **kwargs):
|
|
return self
|
|
|
|
def create(*args, **kwargs):
|
|
return customercreateresult(is_success=True)
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
self.credit_cards = [credit_card(),credit_card()]
|
|
self.paypal_accounts = [paypal_account()]
|
|
self.id = 1
|
|
|
|
class client_token(): # pragma: no cover
|
|
def generate(*args, **kwargs):
|
|
return 'aapnooit'
|
|
|
|
class plan(): # pragma: no cover
|
|
def all(*args, **kwargs):
|
|
return []
|
|
|
|
|
|
|
|
class transaction(): # pragma: no cover
|
|
def sale(*args, **kwargs):
|
|
return gatewayresult(is_success=True)
|
|
|
|
def search(*args, **kwargs):
|
|
return [gatewayresult(is_success=True),gatewayresult(is_success=True)]
|
|
|
|
def __init__(self,*args, **kwargs):
|
|
self.amount = 15
|
|
self.credit_card_details = credit_card()
|
|
self.customer = {
|
|
'first_name': 'John',
|
|
'last_name': 'Doe',
|
|
'id': 12
|
|
}
|
|
self.created_at = datetime.datetime.now()
|
|
self.paid_through_date = datetime.datetime.now()+datetime.timedelta(days=365)
|
|
self.currency_iso_code = 'EUR'
|
|
|
|
class vtransaction(): # pragma: no cover
|
|
def __init__(self,*args, **kwargs):
|
|
self.amount = 15
|
|
self.credit_card_details = credit_card()
|
|
self.customer = {
|
|
'first_name': 'John',
|
|
'last_name': 'Doe',
|
|
'id': 12
|
|
}
|
|
self.created_at = datetime.datetime.now()
|
|
self.paid_through_date = datetime.datetime.now()+datetime.timedelta(days=365)
|
|
self.currency_iso_code = 'EUR'
|
|
|
|
class vsubscription(): # pragma: no cover
|
|
def update(*args, **kwargs):
|
|
return gatewayresult(is_success=True)
|
|
|
|
def cancel(*args, **kwargs):
|
|
return gatewayresult(is_success=True)
|
|
|
|
def find(*args, **kwargs):
|
|
return subscription()
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
self.id = '121'
|
|
self.billing_period_end_date = (datetime.datetime.now()+datetime.timedelta(days=365)).date()
|
|
self.paid_through_date = (datetime.datetime.now()+datetime.timedelta(days=365)).date()
|
|
self.status = 'Active'
|
|
self.plan_id = 12
|
|
self.price = 15
|
|
self.never_expires = True
|
|
|
|
class subscription(): # pragma: no cover
|
|
def create(*args, **kwargs):
|
|
return gatewayresult(is_success=True)
|
|
|
|
def update(*args, **kwargs):
|
|
return gatewayresult(is_success=True)
|
|
|
|
def cancel(*args, **kwargs):
|
|
return gatewayresult(is_success=True)
|
|
|
|
def find(*args, **kwargs):
|
|
return subscription()
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
self.id = '121'
|
|
self.billing_period_end_date = (datetime.datetime.now()+datetime.timedelta(days=365)).date()
|
|
self.paid_through_date = (datetime.datetime.now()+datetime.timedelta(days=365)).date()
|
|
self.transactions = [vtransaction()]
|
|
self.status = 'Active'
|
|
self.plan_id = 12
|
|
self.price = 15
|
|
self.never_expires = True
|
|
|
|
class vpayment_method(): # pragma: no cover
|
|
def create(*args, **kwargs):
|
|
return gatewayresult()
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
self.token = 'liesjeleerdelotje'
|
|
|
|
|
|
class payment_method(): # pragma: no cover
|
|
def create(*args, **kwargs):
|
|
return gatewayresult()
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
self.token = 'liesjeleerdelotje'
|
|
|
|
class notification(): # pragma: no cover
|
|
def __init__(self, *args, **kwargs):
|
|
print('notifucation')
|
|
self.kind = 'subscription_canceled'
|
|
|
|
class webhook_notification(): # pragma: no cover
|
|
def parse(*args, **kwargs):
|
|
print(args,kwargs,'parse')
|
|
return notification()
|
|
|
|
# mock braintree gateway
|
|
class MockBraintreeGateway: # pragma: no cover
|
|
def __init__(self,*args, **kwargs):
|
|
self.customer = customer()
|
|
self.client_token = client_token()
|
|
self.plan = plan()
|
|
self.transaction = transaction()
|
|
self.subscription = subscription()
|
|
self.payment_method = payment_method()
|
|
self.webhook_notification = webhook_notification()
|
|
|
|
|
|
def mocked_gateway(*args, **kwargs): # pragma: no cover
|
|
return MockBraintreeGateway()
|
|
|
|
|
|
# Mocked Rowingdata
|
|
|
|
class mocked_rowingdata(rowingdata): # pragma: no cover
|
|
def __init__(self, *args, **kwargs):
|
|
super(mocked_rowingdata).__init__(*args, **kwargs)
|
|
|
|
def get_metersplot_erg(self, title):
|
|
fig1 = figure.Figure(figsize(12,10))
|
|
return fig1
|
|
|
|
def get_timeplot_erg(self, title):
|
|
fig1 = figure.Figure(figsize(12,10))
|
|
return fig1
|
|
|
|
def get_piechart(self, title):
|
|
fig1 = figure.Figure(figsize(12,10))
|
|
return fig1
|
|
|
|
def get_timeplot_otwempower(self, title):
|
|
fig1 = figure.Figure(figsize(12,10))
|
|
return fig1
|
|
|
|
def get_timeplot_otw(self, title):
|
|
fig1 = figure.Figure(figsize(12,10))
|
|
return fig1
|
|
|
|
def get_metersplot_otwempower(self, title):
|
|
fig1 = figure.Figure(figsize(12,10))
|
|
return fig1
|
|
|
|
def get_metersplot_erg2(self, title):
|
|
fig1 = figure.Figure(figsize(12,10))
|
|
return fig1
|
|
|
|
def get_timeplot_erg2(self, title):
|
|
fig1 = figure.Figure(figsize(12,10))
|
|
return fig1
|
|
|
|
def get_time_otwpower(self, title):
|
|
fig1 = figure.Figure(figsize(12,10))
|
|
return fig1
|
|
|
|
def get_power_piechart(self, title):
|
|
fig1 = figure.Figure(figsize(12,10))
|
|
return fig1
|
|
|
|
|
|
# Mocked Requests
|
|
|
|
# to be done add polar mocks (for email processing)
|
|
def mocked_requests(*args, **kwargs):
|
|
with open('rowers/tests/testdata/c2jsonworkoutdata.txt','r') as infile:
|
|
c2workoutdata = json.load(infile)
|
|
|
|
with open('rowers/tests/testdata/c2_timezone.json','r') as infile:
|
|
c2timezoneworkoutdata = json.load(infile)
|
|
|
|
with open('rowers/tests/testdata/rojabolist.json','r') as infile:
|
|
rojabodata = json.load(infile)
|
|
|
|
with open('rowers/tests/testdata/c2_timezone2.json','r') as infile:
|
|
c2timezoneworkoutdata2 = json.load(infile)
|
|
|
|
with open('rowers/tests/testdata/c2_timezonebad.json','r') as infile:
|
|
c2timezoneworkoutdatabad = json.load(infile)
|
|
|
|
with open('rowers/tests/testdata/c2jsonstrokedata.txt','r') as infile:
|
|
c2strokedata = json.load(infile)
|
|
|
|
with open('rowers/tests/testdata/nk_strokes.json','r') as infile:
|
|
nkstrokedata = json.load(infile)
|
|
|
|
with open('rowers/tests/testdata/nk_list.json','r') as infile:
|
|
nkworkoutlist = json.load(infile)
|
|
|
|
with open('rowers/tests/testdata/rp3_list.json','r') as infile:
|
|
rp3workoutlist = json.load(infile)
|
|
|
|
with open('rowers/tests/testdata/idoklad_default.json','r') as infile:
|
|
idokladdefault = json.load(infile)
|
|
|
|
rp3linkready = {'data': {'download': {'id': 591621, 'status': 'ready', 'link': 'https://rp3rowing-app.com/api/workouts/591621/download?type=csv'}}}
|
|
|
|
with open('rowers/tests/testdata/example-session-strokes-with-impeller-data.json','r') as infile:
|
|
nkimpellerstrokedata = json.load(infile)
|
|
|
|
with open('rowers/tests/testdata/example-session-with-impeller-data.json','r') as infile:
|
|
nkimpellerworkoutlist = json.load(infile)
|
|
|
|
polar_json = {
|
|
"transaction-id":240522162,
|
|
"resource-uri":"https://polaraccesslink.com/v3/users/40273947/exercise-transactions/240522162"
|
|
}
|
|
|
|
polar_exercise_list = {
|
|
"exercises": [
|
|
"https://www.polaraccesslink.com/v3/users/12/exercise-transactions/34/exercises/56",
|
|
"https://www.polaraccesslink.com/v3/users/12/exercise-transactions/34/exercises/120"
|
|
]
|
|
}
|
|
|
|
polar_user_data = {
|
|
"polar-user-id": 475,
|
|
"member-id": "i09u9ujj",
|
|
"registration-date": "2011-10-14T12:50:37.000Z",
|
|
"first-name": "Eka",
|
|
"last-name": "Toka",
|
|
"birthdate": "1985-09-06",
|
|
"gender": "MALE",
|
|
"weight": 66,
|
|
"height": 170,
|
|
"field": [
|
|
{
|
|
"value": "2",
|
|
"index": 0,
|
|
"name": "number-of-children"
|
|
}
|
|
]
|
|
}
|
|
|
|
polar_exercise_dict = {
|
|
"id": 1937529874,
|
|
"upload-time": "2008-10-13T10:40:02Z",
|
|
"polar-user": "https://www.polaraccesslink/v3/users/1",
|
|
"transaction-id": 179879,
|
|
"device": "Polar M400",
|
|
"device-id": "1111AAAA",
|
|
"start-time": "2008-10-13T10:40:02Z",
|
|
"start-time-utc-offset": 180,
|
|
"duration": "PT2H44M",
|
|
"calories": 530,
|
|
"distance": 1600,
|
|
"heart-rate": {
|
|
"average": 129,
|
|
"maximum": 147
|
|
},
|
|
"training-load": 143.22,
|
|
"sport": "OTHER",
|
|
"has-route": True,
|
|
"club-id": 999,
|
|
"club-name": "Polar Club",
|
|
"detailed-sport-info": "WALKING",
|
|
"fat-percentage": 60,
|
|
"carbohydrate-percentage": 38,
|
|
"protein-percentage": 2
|
|
}
|
|
|
|
with open('rowers/tests/testdata/c2workoutlist.txt') as f:
|
|
c2workoutlist = json.load(f)
|
|
|
|
c2uploadjson = {
|
|
"data": {
|
|
"id": 339,
|
|
"user_id": 1,
|
|
"date": "2015-08-05 13:15:41",
|
|
"timezone": "Europe/London",
|
|
"date_utc": "2015-08-05 12:15:41",
|
|
"distance": 5649,
|
|
"type": "rower",
|
|
"time": 8649,
|
|
"time_formatted": "14:24.9",
|
|
"workout_type": "JustRow",
|
|
"source": "ErgData",
|
|
"weight_class": "H",
|
|
"verified": True,
|
|
"ranked": False
|
|
}
|
|
}
|
|
|
|
osm_json = [
|
|
{
|
|
"place_id": 165922574,
|
|
"licence": "Data © OpenStreetMap contributors, ODbL 1.0. http://osm.org/copyright",
|
|
"osm_type": "node",
|
|
"osm_id": 2756013867,
|
|
"lat": "52.2229364",
|
|
"lon": "6.846701",
|
|
"category": "place",
|
|
"type": "house",
|
|
"place_rank": 30,
|
|
"importance": 0.000009999999999954,
|
|
"addresstype": "place",
|
|
"name": "",
|
|
"display_name": "254, Ir. Schiffstraat, Havengebied, Enschede, Overijssel, Netherlands, 7547 RD, Netherlands",
|
|
"address": {
|
|
"house_number": "254",
|
|
"road": "Ir. Schiffstraat",
|
|
"industrial": "Havengebied",
|
|
"city": "Enschede",
|
|
"state": "Overijssel",
|
|
"ISO3166-2-lvl4": "NL-OV",
|
|
"country": "Netherlands",
|
|
"postcode": "7547 RD",
|
|
"country_code": "nl"
|
|
},
|
|
"boundingbox": [
|
|
"52.2228864",
|
|
"52.2229864",
|
|
"6.8466510",
|
|
"6.8467510"
|
|
]
|
|
}
|
|
]
|
|
|
|
with open('rowers/tests/testdata/stravaworkoutlist.txt') as f:
|
|
stravaworkoutlist = json.load(f)
|
|
|
|
with open('rowers/tests/testdata/sporttracksworkouts.txt') as f:
|
|
sporttracksworkoutlist = json.load(f)
|
|
|
|
#nkworkoutlist = json.load(open('rowers/tests/testdata/nkworkouts.txt'))
|
|
|
|
|
|
with open('rowers/tests/testdata/rkworkoutslist.txt','r') as f:
|
|
rkworkoutlistjson = json.load(f)
|
|
|
|
with open('rowers/tests/testdata/uaworkoutlist.txt','r') as f:
|
|
uaworkoutlistjson = json.load(f)
|
|
|
|
with open('rowers/tests/testdata/stravaworkoutsummary.txt','r') as f:
|
|
stravasummaryjson = json.load(f)
|
|
|
|
with open('rowers/tests/testdata/stravatimetestdata.txt','r') as f:
|
|
stravatimejson = json.load(f)
|
|
|
|
with open('rowers/tests/testdata/stravavelotestdata.txt','r') as f:
|
|
stravavelojson = json.load(f)
|
|
|
|
with open('rowers/tests/testdata/stravapowertestdata.txt','r') as f:
|
|
stravapowerjson = json.load(f)
|
|
|
|
with open('rowers/tests/testdata/stravadistancetestdata.txt','r') as f:
|
|
stravadistancejson = json.load(f)
|
|
|
|
with open('rowers/tests/testdata/stravalatlongtestdata.txt','r') as f:
|
|
stravalatlongjson = json.load(f)
|
|
|
|
with open('rowers/tests/testdata/stravahrtestdata.txt','r') as f:
|
|
stravahrjson = json.load(f)
|
|
|
|
with open('rowers/tests/testdata/stravaspmtestdata.txt','r') as f:
|
|
stravaspmjson = json.load(f)
|
|
|
|
|
|
with open('rowers/tests/testdata/uapostworkoutresponse.txt','r') as f:
|
|
uapostworkoutjson = json.load(f)
|
|
|
|
|
|
with open('rowers/tests/testdata/tpuploadresponse.txt','r') as f:
|
|
tpuploadresponse = json.load(f)
|
|
|
|
with open('rowers/tests/testdata/intervals.json','r') as f:
|
|
intervalsjson = json.load(f)
|
|
|
|
stravastreamjson = {
|
|
'time':stravatimejson,
|
|
'velocity_smooth':stravavelojson,
|
|
'distance':stravadistancejson,
|
|
'latlng':stravalatlongjson,
|
|
'heartrate':stravahrjson,
|
|
'cadence':stravaspmjson,
|
|
'watts':stravapowerjson,
|
|
}
|
|
|
|
with open('rowers/tests/testdata/sporttracksstrokedata.txt','r') as f:
|
|
ststrokesjson = json.load(f)
|
|
|
|
with open('rowers/tests/testdata/sporttracksstrokedatanolocation.txt','r') as f:
|
|
ststrokesjson_nogps = json.load(f)
|
|
|
|
with open('rowers/tests/testdata/rkstrokes.txt','r') as f:
|
|
rkstrokesjson = json.load(f)
|
|
|
|
with open('rowers/tests/testdata/uastrokes.txt','r') as f:
|
|
uastrokesjson = json.load(f)
|
|
|
|
with open('rowers/tests/testdata/uauser.txt','r') as f:
|
|
uauserjson = json.load(f)
|
|
|
|
with open('rowers/tests/testdata/strava_athlete.txt') as f:
|
|
stravaathletejson = json.load(f)
|
|
|
|
class MockResponse:
|
|
def __init__(self, json_data, status_code):
|
|
self.json_data = json_data
|
|
self.status_code = status_code
|
|
self.reason = 'mock reason'
|
|
self.ok = True
|
|
self.headers = {
|
|
'Location':'MockLocation',
|
|
}
|
|
self.text = 'Mocked response text'
|
|
|
|
def json(self):
|
|
return self.json_data
|
|
|
|
class MockContentResponse:
|
|
def __init__(self,filename,status_code):
|
|
with open(filename,'rb') as f:
|
|
s = f.read()
|
|
self.content = s
|
|
self.status_code = status_code
|
|
self.ok = True
|
|
|
|
|
|
|
|
class MockHeaderResponse: # pragma: no cover
|
|
def __init__(self, header_data, status_code):
|
|
self.headers = header_data
|
|
self.status_code = status_code
|
|
|
|
class MockStreamResponse: # pragma: no cover
|
|
def __init__(self, file_name, status_code):
|
|
self.raw = open(file_name,'rb')
|
|
self.status_code = status_code
|
|
self.ok = True
|
|
self.file_name = file_name
|
|
|
|
def __enter__(self): # pragma: no cover
|
|
return self
|
|
|
|
def __exit__(self, exc_type, exc_value, traceback):
|
|
self.raw.close()
|
|
|
|
|
|
def __delete__(self):
|
|
self.raw.close()
|
|
|
|
|
|
def __del__(self):
|
|
try:
|
|
self.raw.close()
|
|
except TypeError:
|
|
pass
|
|
|
|
class MockOAuth1Session:
|
|
def __init__(self,*args, **kwargs):
|
|
pass
|
|
|
|
def get(*args,**kwargs):
|
|
return MockStreamResponse('rowers/tests/testdata/3x250m.fit',200)
|
|
|
|
|
|
class MockSession:
|
|
def __init__(self):
|
|
self.status_code = 200
|
|
self.text = "- 20m 200W"
|
|
|
|
class headers:
|
|
def __init__(self,*args,**kwargs): # pragma: no cover
|
|
pass
|
|
|
|
def update(self,*args,**kwargs):
|
|
pass
|
|
|
|
def post(self, *args, **kwargs):
|
|
json_data = {'id':1}
|
|
return MockResponse(json_data,200)
|
|
|
|
def send(self,prepped):
|
|
# prepped.url
|
|
# prepped.body (post data)
|
|
# prepped.headers
|
|
# prepped.method
|
|
|
|
json_data = {
|
|
'access_token': 'TA3n1vrNjuQJWw0TdCDHnjSmrjIPULhTlejMIWqq',
|
|
'expires_in': 604800,
|
|
'refresh_token': 'jHJhFzCfOOKB8oyiayubhLAlxaMkG3ruC1E8YxaR',
|
|
}
|
|
|
|
return MockResponse(json_data,200)
|
|
|
|
if len(args)==1 and 'userPermissions' in args[0]:
|
|
json_data = ['WORKOUT_IMPORT','ACTIVITY_EXPORT']
|
|
return MockResponse(json_data,200)
|
|
|
|
if 'garmin' in args:
|
|
return MockOAuth1Session()
|
|
|
|
if 'url' in kwargs:
|
|
if 'rp3' in kwargs['url']:
|
|
args = [kwargs['url']]
|
|
if "tofit" in kwargs['url']:
|
|
args = [kwargs['url']]
|
|
if "tojson" in kwargs['url']: # pragma: no cover
|
|
args = [kwargs['url']]
|
|
|
|
if not args:
|
|
return MockSession()
|
|
|
|
|
|
if "tofit" in args[0]:
|
|
jsonresponse = {
|
|
'name': '',
|
|
'sport': 'rowing',
|
|
'filename': '/home/sander/python/rowsandall/media/630a9e78-6d34-4eb3-8d53-4c02b2e95fff.fit',
|
|
'steps': [
|
|
{
|
|
'wkt_step_name': '0',
|
|
'stepId': 0,
|
|
'durationType': 'Distance',
|
|
'durationValue': 100000,
|
|
'intensity': 'Active'
|
|
},
|
|
{
|
|
'wkt_step_name': '1',
|
|
'stepId': 1,
|
|
'durationType': 'RepeatUntilStepsCmplt',
|
|
'targetValue': 4,
|
|
'durationValue': 0
|
|
}
|
|
]
|
|
}
|
|
|
|
|
|
return MockResponse(jsonresponse,200)
|
|
|
|
if 'rojabo' in args[0]:
|
|
return MockResponse(rojabodata, 200)
|
|
|
|
osmtester = re.compile(r'.*?nominatim.openstreetmap.org')
|
|
polartester = re.compile(r'.*?polaraccesslink\.com')
|
|
polarremotetester = re.compile(r'.*?polarremote\.com')
|
|
c2tester = re.compile(r'.*?log\.concept2\.com')
|
|
stravatester = re.compile(r'.*?strava\.com')
|
|
sttester = re.compile(r'.*?sporttracks\.mobi')
|
|
rktester = re.compile(r'.*?runkeeper\.com')
|
|
uatester = re.compile(r'.*?mapmyfitness\.com')
|
|
tptester = re.compile(r'.*?trainingpeaks\.com')
|
|
nktester = re.compile(r'.*?nkrowlink\.com')
|
|
rp3tester = re.compile(r'.*?rp3rowing-app\.com')
|
|
garmintester = re.compile(r'.*?garmin\.com')
|
|
fakturoidtester = re.compile(r'.*?fakturoid\.cz')
|
|
idokladtester = re.compile(r'.*?idoklad\.cz')
|
|
intervalstester = re.compile(r'.*?intervals\.icu')
|
|
|
|
polarlistregex = r'.*?polaraccesslink\.com\/.*\/(\d+)$'
|
|
polarlisttester = re.compile(polarlistregex)
|
|
|
|
polarexerciseregex = r'.*?polaraccesslink\.com\/.*\/(\d+)\/exercises\/(\d+)$'
|
|
polarexercisetester = re.compile(polarexerciseregex)
|
|
|
|
polartcxregex = r'.*?polaraccesslink\.com\/.*\/(\d+)\/tcx'
|
|
polartcxtester = re.compile(polartcxregex)
|
|
|
|
polaruserregex = r'.*?polaraccesslink\.com\/.*\/users$'
|
|
polarusertester = re.compile(polaruserregex)
|
|
|
|
polarnotificationregex = r'.*polaraccesslink\.com\/.*\/notifications'
|
|
polarnotificationtester = re.compile(polarnotificationregex)
|
|
|
|
c2importregex = r'.*?concept2.com\/api\/users\/me\/results\/\d+'
|
|
c2importtester = re.compile(c2importregex)
|
|
|
|
c2uploadregex = r'.*?concept2.com\/api\/users\/\d+\/results$'
|
|
c2uploadtester = re.compile(c2uploadregex)
|
|
|
|
c2strokesregex = r'.*?concept2.com\/api\/users\/me\/results\/\d+\/strokes'
|
|
c2strokestester = re.compile(c2strokesregex)
|
|
|
|
c2workoutlistregex = r'.*?concept2\.com\/api\/users\/me\/results\?page=\d'
|
|
c2workoutlisttester = re.compile(c2workoutlistregex)
|
|
|
|
nkworkoutlistregex = r'.*?nkrowlink\.com\/api\/v1\/sessions'
|
|
nkworkoutlisttester = re.compile(nkworkoutlistregex)
|
|
|
|
nkstrokesregex = r'.*?nkrowlink\.com\/api\/v1\/sessions\/strokes'
|
|
nkstrokestester = re.compile(nkstrokesregex)
|
|
|
|
rp3graphregex = r'.*?rp3rowing-app\.com\/graphql'
|
|
rp3graphtester = re.compile(rp3graphregex)
|
|
|
|
stravaathleteregex = r'.*?strava\.com\/api\/v3\/athlete$'
|
|
stravaathletetester = re.compile(stravaathleteregex)
|
|
|
|
|
|
stravaworkoutlistregex = r'.*?strava\.com\/api\/v3\/athlete\/activities'
|
|
stravaworkoutlisttester = re.compile(stravaworkoutlistregex)
|
|
|
|
stravastreamregex = r'.*?strava\.com\/api\/v3\/activities\/\d+\/streams\/(\w.*?)\?'
|
|
stravastreamtester = re.compile(stravastreamregex)
|
|
|
|
stravasummaryregex = r'.*?strava\.com\/api\/v3\/activities\/\d+$'
|
|
stravasummarytester = re.compile(stravasummaryregex)
|
|
|
|
stuploadregex = r'.*?sporttracks\.mobi\/api\/v2\/fitnessActivities.json$'
|
|
stuploadtester = re.compile(stuploadregex)
|
|
|
|
stworkoutlistregex = r'.*?sporttracks\.mobi\/api\/v2\/fitnessActivities$'
|
|
stworkoutlisttester = re.compile(stworkoutlistregex)
|
|
|
|
ststrokesregex = r'.*?sporttracks\.mobi\/api\/v2\/fitnessActivities/(\d+)$'
|
|
ststrokestester = re.compile(ststrokesregex)
|
|
|
|
rkuploadregex = r'.*?api\.runkeeper\.com\/fitnessActivities$'
|
|
rkuploadtester = re.compile(rkuploadregex)
|
|
rkuserregex = r'.*?api\.runkeeper\.com\/user$'
|
|
rkusertester = re.compile(rkuserregex)
|
|
rkstrokesregex = r'.*?api\.runkeeper\.com\/fitnessActivities/\d+$'
|
|
rkstrokestester = re.compile(rkstrokesregex)
|
|
|
|
uaapiregex = r'.*?api\.ua\.com'
|
|
uaapitester = re.compile(uaapiregex)
|
|
|
|
uauploadregex = r'.*?api\.ua\.com\/v7.1\/workout\/$'
|
|
uauploadtester = re.compile(uauploadregex)
|
|
|
|
uastrokesregex = r'.*?api\.ua\.com\/v7.1\/workout\/\d+'
|
|
uastrokestester = re.compile(uastrokesregex)
|
|
|
|
ualistregex = r'.*?api\.ua\.com\/v7.1\/workout\/\?user'
|
|
ualisttester = re.compile(ualistregex)
|
|
|
|
uauserregex = r'.*?api\.ua\.com\/v7.1\/user\/self\/'
|
|
uausertester = re.compile(uauserregex)
|
|
|
|
tpuploadregex = r'.*?trainingpeaks\.com\/v3\/file'
|
|
tpuploadtester = re.compile(tpuploadregex)
|
|
|
|
garmindownloadregex = r'.*?garmin\.com\/mockfile?id=1'
|
|
garmindownloadtester = re.compile(garmindownloadregex)
|
|
|
|
garmintrainingregex = r'.*?garmin\.com\/training-api\/workout'
|
|
garmintrainingtester = re.compile(garmintrainingregex)
|
|
|
|
garmintrainingscheduleregex = r'.*?garmin\.com\/training-api\/schedule'
|
|
garmintrainingscheduletester = re.compile(garmintrainingscheduleregex)
|
|
|
|
if osmtester.match(args[0]):
|
|
return MockResponse(osm_json, 200)
|
|
|
|
if args[0] == '1.1.1.1':
|
|
return MockResponse(osm_json, 200)
|
|
|
|
if garmintester.match(args[0]):
|
|
if garmindownloadtester.match(args[0]): # pragma: no cover
|
|
return MockStreamResponse('rowers/tests/testdata/3x250m.fit',200)
|
|
if garmintrainingtester.match(args[0]):
|
|
json_data = {
|
|
'workoutId':1212,
|
|
}
|
|
return MockResponse(json_data,200)
|
|
if garmintrainingscheduletester.match(args[0]):
|
|
json_data = 1234
|
|
return MockResponse(json_data,200)
|
|
|
|
if stravaathletetester.match(args[0]):
|
|
json_data = stravaathletejson
|
|
return MockResponse(json_data,200)
|
|
|
|
if polarremotetester.match(args[0]):
|
|
json_data = {
|
|
'access_token':'aap',
|
|
'expires_in':31535999,
|
|
'x_user_id':475,
|
|
}
|
|
return MockResponse(json_data,200)
|
|
|
|
if polartester.match(args[0]):
|
|
if polarnotificationtester.match(args[0]):
|
|
json_data = {
|
|
"available-user-data": [
|
|
{
|
|
"user-id": 475,
|
|
"data-type": "ACTIVITY_SUMMARY",
|
|
"url": "https://www.polaraccesslink.com/v3/users/475/activity-transactions"
|
|
},
|
|
{
|
|
'user-id': 475,
|
|
'data-type': 'EXERCISE',
|
|
'url': 'https://polaraccesslink.com/v3/users/40273947/exercise-transactions'
|
|
}
|
|
]
|
|
}
|
|
return MockResponse(json_data,200)
|
|
elif polarusertester.match(args[0]):
|
|
json_data = polar_user_data
|
|
return MockResponse(json_data,200)
|
|
elif polartcxtester.match(args[0]):
|
|
filename = 'rowers/tests/testdata/polar_response.tcx'
|
|
return MockContentResponse(filename,200)
|
|
elif polarexercisetester.match(args[0]):
|
|
json_data = polar_exercise_dict
|
|
return MockResponse(json_data,200)
|
|
elif polarlisttester.match(args[0]):
|
|
json_data = polar_exercise_list
|
|
return MockResponse(json_data,200)
|
|
|
|
# getting user data
|
|
json_data = polar_json
|
|
|
|
return MockResponse(json_data,201)
|
|
|
|
if tptester.match(args[0]):
|
|
if 'token' in args[0]:
|
|
json_data = {
|
|
'access_token': 'TA3n1vrNjuQJWw0TdCDHnjSmrjIPULhTlejMIWqq',
|
|
'expires_in': 604800,
|
|
'refresh_token': 'jHJhFzCfOOKB8oyiayubhLAlxaMkG3ruC1E8YxaR'
|
|
}
|
|
return MockResponse(json_data,200)
|
|
elif tpuploadtester.match(args[0]): # pragma: no cover
|
|
return MockResponse(tpuploadresponse,200)
|
|
|
|
if uaapitester.match(args[0]): # pragma: no cover
|
|
if 'access_token' in args[0]:
|
|
json_data = {
|
|
'access_token': 'TA3n1vrNjuQJWw0TdCDHnjSmrjIPULhTlejMIWqq',
|
|
'expires_in': 604800,
|
|
'refresh_token': 'jHJhFzCfOOKB8oyiayubhLAlxaMkG3ruC1E8YxaR'
|
|
}
|
|
return MockResponse(json_data,200)
|
|
elif uauploadtester.match(args[0]):
|
|
if 'data' in kwargs:
|
|
return MockResponse(uapostworkoutjson,200)
|
|
elif uastrokestester.match(args[0]):
|
|
return MockResponse(uastrokesjson,200)
|
|
elif ualisttester.match(args[0]):
|
|
return MockResponse(uaworkoutlistjson,200)
|
|
elif uausertester.match(args[0]):
|
|
return MockResponse(uauserjson,200)
|
|
|
|
|
|
if uatester.match(args[0]): # pragma: no cover
|
|
if 'access_token' in args[0]:
|
|
json_data = {
|
|
'access_token': 'TA3n1vrNjuQJWw0TdCDHnjSmrjIPULhTlejMIWqq',
|
|
'expires_in': 604800,
|
|
'refresh_token': 'jHJhFzCfOOKB8oyiayubhLAlxaMkG3ruC1E8YxaR'
|
|
}
|
|
return MockResponse(json_data,200)
|
|
|
|
|
|
if rktester.match(args[0]): # pragma: no cover
|
|
if 'token' in args[0]:
|
|
json_data = {
|
|
'access_token': 'TA3n1vrNjuQJWw0TdCDHnjSmrjIPULhTlejMIWqq',
|
|
'expires_in': 604800,
|
|
'refresh_token': 'jHJhFzCfOOKB8oyiayubhLAlxaMkG3ruC1E8YxaR'
|
|
}
|
|
return MockResponse(json_data,200)
|
|
elif rkuploadtester.match(args[0]):
|
|
if 'data' in kwargs:
|
|
# post
|
|
header_data = {
|
|
'Location': '/fitnessActivities/12'
|
|
}
|
|
return MockHeaderResponse(header_data,200)
|
|
else:
|
|
json_data = rkworkoutlistjson
|
|
return MockResponse(json_data,200)
|
|
elif rkusertester.match(args[0]): # pragma: no cover
|
|
json_data = {
|
|
"userID": 1234567890,
|
|
"profile": "/profile",
|
|
"settings": "/settings",
|
|
"fitness_activities": "/fitnessActivities",
|
|
"strength_training_activities": "/strengthTrainingActivities",
|
|
"background_activities": "/backgroundActivities",
|
|
"sleep": "/sleep",
|
|
"nutrition": "/nutrition",
|
|
"weight": "/weight",
|
|
"general_measurements": "/generalMeasurements",
|
|
"diabetes": "/diabetes",
|
|
"records": "/records",
|
|
"team": "/team"
|
|
}
|
|
return MockResponse(json_data, 200)
|
|
elif rkstrokestester.match(args[0]): # pragma: no cover
|
|
return MockResponse(rkstrokesjson,200)
|
|
|
|
if sttester.match(args[0]): # pragma: no cover
|
|
if 'oauth2/token' in args[0]:
|
|
json_data = {
|
|
'access_token': 'TA3n1vrNjuQJWw0TdCDHnjSmrjIPULhTlejMIWqq',
|
|
'expires_in': 604800,
|
|
'refresh_token': 'jHJhFzCfOOKB8oyiayubhLAlxaMkG3ruC1E8YxaR'
|
|
}
|
|
return MockResponse(json_data,200)
|
|
if ststrokestester.match(args[0]):
|
|
if ststrokestester.match(args[0]).group(1) == '13':
|
|
return MockResponse(ststrokesjson_nogps,200)
|
|
else:
|
|
return MockResponse(ststrokesjson,200)
|
|
if stuploadtester.match(args[0]):
|
|
json_data = {
|
|
"uris": [
|
|
"https://api.sporttracks.mobi/api/v2/fitnessActivities/123456.json"
|
|
]
|
|
}
|
|
return MockResponse(json_data, 200)
|
|
if stworkoutlisttester.match(args[0]):
|
|
return MockResponse(sporttracksworkoutlist,200)
|
|
|
|
|
|
if nktester.match(args[0]):
|
|
if 'token' in args[0]:
|
|
json_data = {
|
|
'access_token': 'TA3n1vrNjuQJWw0TdCDHnjSmrjIPULhTlejMIWqq',
|
|
'expires_in': 604800,
|
|
'refresh_token': 'jHJhFzCfOOKB8oyiayubhLAlxaMkG3ruC1E8YxaR'
|
|
}
|
|
return MockResponse(json_data,200)
|
|
if nkstrokestester.match(args[0]):
|
|
params = kwargs.pop('params',{})
|
|
|
|
if 'sessionIds' in params and params['sessionIds'] == '404': # pragma: no cover
|
|
return MockResponse(nkimpellerstrokedata, 200)
|
|
return MockResponse(nkstrokedata,200)
|
|
if nkworkoutlisttester.match(args[0]):
|
|
params = kwargs.pop('params',{})
|
|
|
|
if 'after' in params and params['after'] == '1267049972000': # pragma: no cover
|
|
return MockResponse(nkimpellerworkoutlist,200)
|
|
return MockResponse(nkworkoutlist,200)
|
|
|
|
if rp3tester.match(args[0]):
|
|
if 'token' in args[0]:
|
|
json_data = {
|
|
'access_token': 'TA3n1vrNjuQJWw0TdCDHnjSmrjIPULhTlejMIWqq',
|
|
'expires_in': 604800,
|
|
'refresh_token': 'jHJhFzCfOOKB8oyiayubhLAlxaMkG3ruC1E8YxaR'
|
|
}
|
|
return MockResponse(json_data,200)
|
|
|
|
if 'api' in args[0]:
|
|
if '591621' in args[0]:
|
|
return MockContentResponse('rowers/tests/testdata/rp3content.csv',200)
|
|
|
|
|
|
if rp3graphtester.match(args[0]):
|
|
if 'json' in kwargs:
|
|
try:
|
|
query = kwargs['json']['query']
|
|
if 'download' in query:
|
|
return MockResponse(rp3linkready,200)
|
|
except KeyError: # pragma: no cover
|
|
pass
|
|
json_data = rp3workoutlist
|
|
return MockResponse(json_data,200)
|
|
|
|
if stravatester.match(args[0]):
|
|
if stravaworkoutlisttester.match(args[0]):
|
|
return MockResponse(stravaworkoutlist,200)
|
|
if stravastreamtester.match(args[0]):
|
|
metric = stravastreamtester.match(args[0]).group(1)
|
|
json_data = stravastreamjson[metric]
|
|
return MockResponse(json_data,200)
|
|
elif stravasummarytester.match(args[0]):
|
|
return MockResponse(stravasummaryjson,200)
|
|
elif 'token' in args[0]:
|
|
json_data = {
|
|
"token_type": "Bearer",
|
|
"access_token": "987654321234567898765432123456789",
|
|
"refresh_token": "1234567898765432112345678987654321",
|
|
"expires_at": arrow.now().timestamp()+7200
|
|
}
|
|
|
|
return MockResponse(json_data,200)
|
|
|
|
|
|
if c2tester.match(args[0]):
|
|
if c2uploadtester.match(args[0]):
|
|
return MockResponse(c2uploadjson,201)
|
|
if c2strokestester.match(args[0]):
|
|
return MockResponse(c2strokedata,200)
|
|
elif c2importtester.match(args[0]):
|
|
if '12' in args[0]: # pragma: no cover
|
|
return MockResponse(c2workoutdata,200)
|
|
elif '31' in args[0]:
|
|
return MockResponse(c2timezoneworkoutdata2,200)
|
|
elif '32' in args[0]: # pragma: no cover
|
|
return MockResponse(c2timezoneworkoutdatabad,200)
|
|
else: # pragma: no cover
|
|
return MockResponse(c2timezoneworkoutdata,200)
|
|
elif c2workoutlisttester.match(args[0]):
|
|
return MockResponse(c2workoutlist,200)
|
|
elif 'access_token' in args[0]:
|
|
json_data = {
|
|
'access_token': 'TA3n1vrNjuQJWw0TdCDHnjSmrjIPULhTlejMIWqq',
|
|
'expires_in': 604800,
|
|
'refresh_token': 'jHJhFzCfOOKB8oyiayubhLAlxaMkG3ruC1E8YxaR'
|
|
}
|
|
return MockResponse(json_data,200)
|
|
elif 'users/me' in args[0]:
|
|
json_data = {
|
|
'data': {
|
|
'username': 'john',
|
|
'id': 1234,
|
|
}
|
|
}
|
|
return MockResponse(json_data,200)
|
|
elif 'results' in args[0]: # pragma: no cover
|
|
json_data = {
|
|
'data': {
|
|
'id': 1223,
|
|
}
|
|
}
|
|
else: # pragma: no cover
|
|
return MockResponse(c2workoutdata,200)
|
|
|
|
|
|
if idokladtester.match(args[0]):
|
|
if 'Invoices' in args[0]:
|
|
if 'Default' in args[0]:
|
|
response_data = idokladdefault
|
|
|
|
return MockResponse(response_data,200)
|
|
|
|
response = {
|
|
'Data': {
|
|
'Id': 1,
|
|
}
|
|
}
|
|
return MockResponse(response,200)
|
|
|
|
if 'Contacts' in args[0]:
|
|
response = {
|
|
'Data': {
|
|
'Items': [
|
|
{
|
|
'Id': 1,
|
|
'url':'aap',
|
|
}
|
|
]
|
|
}
|
|
}
|
|
|
|
return MockResponse(response,200)
|
|
|
|
response = [
|
|
{
|
|
'Id':1,
|
|
'url':'aap',
|
|
}
|
|
]
|
|
return MockResponse(response, 200)
|
|
|
|
if fakturoidtester.match(args[0]):
|
|
if 'invoices' in args[0]:
|
|
response = {
|
|
'url':'aap',
|
|
'id':1,
|
|
}
|
|
return MockResponse(response,200)
|
|
|
|
response = [
|
|
{
|
|
'id':1,
|
|
'url':'aap',
|
|
}
|
|
]
|
|
return MockResponse(response,200)
|
|
|
|
if intervalstester.match(args[0]):
|
|
return MockResponse(intervalsjson,200)
|
|
|
|
|
|
return MockResponse(None,404)
|
|
|
|
class MockEmailMessage:
|
|
def __init__(*args,**kwargs):
|
|
pass
|
|
|
|
def send(self):
|
|
return 1
|
|
|
|
class MockResponse: # pragma: no cover
|
|
def __init__(self, json_data, status_code):
|
|
self.json_data = json_data
|
|
self.status_code = status_code
|
|
self.ok = True
|
|
self.headers = {
|
|
'Location':'MockLocation',
|
|
}
|
|
self.text = 'Mocked response text'
|
|
|
|
def json(self):
|
|
return self.json_data
|
|
|
|
|
|
|
|
class MockOAuth1Session: # pragma: no cover
|
|
def __init__(self,*args, **kwargs):
|
|
pass
|
|
|
|
def get(*args,**kwargs):
|
|
return MockStreamResponse('rowers/tests/testdata/3x250m.fit',200)
|
|
|
|
def post(*args, **kwargs):
|
|
return MockResponse({},200)
|
|
|
|
def fetch_request_token(*args, **kwargs):
|
|
return {
|
|
'oauth_token':'aap',
|
|
'oauth_token_secret':'noot',
|
|
}
|
|
|
|
def authorization_url(*args, **kwargs):
|
|
return 'url'
|
|
|
|
def mocked_invoiceid(*args,**kwargs):
|
|
return 1
|