def setUp(self):
self.user1 = User("Max Mustermann")
self.user2 = User("12345")
self.service1 = LoginService("MusterService", ["fileStorage"])
self.service2 = LoginService("BetonService", ["fileStorage"])
self.token1 = Token(self.user1, self.service1, "ABC")
self.token2 = Token(self.user1, self.service2, "DEF")
self.oauthservice1 = OAuth2Service(
"MusterService",
["fileStorage"],
FileTransferMode.active,
FileTransferArchive.none,
"http://localhost/oauth/authorize",
"http://localhost/oauth/token",
"MNO",
"UVW",
)
self.oauthservice2 = OAuth2Service(
"BetonService",
["fileStorage"],
FileTransferMode.active,
FileTransferArchive.none,
"http://owncloud/oauth/authorize",
"http://owncloud/oauth/token",
"UVP",
"OMN",
)
self.oauthtoken1 = OAuth2Token(self.user1, self.oauthservice1, "ABC",
"XYZ")
self.oauthtoken2 = OAuth2Token(self.user1, self.oauthservice2, "DEF",
"UVW")
def setUp(self):
self.service1 = LoginService("MusterService", ["fileStorage"])
self.service2 = LoginService("BetonService", ["fileStorage"])
self.oauthservice1 = OAuth2Service.from_service(
self.service1,
"http://localhost:5000/oauth/authorize",
"http://localhost:5000/oauth/refresh",
"ABC",
"XYZ",
)
self.oauthservice2 = OAuth2Service.from_service(
self.service2,
"http://localhost:5000/oauth/authorize",
"http://localhost:5000/oauth/refresh",
"DEF",
"MNO",
)
self.user1 = User("Max Mustermann")
self.user2 = User("Mimi Mimikri")
self.token1 = Token(self.user1, self.service1, "ABC")
self.token2 = Token(self.user1, self.service2, "DEF")
self.oauthtoken1 = OAuth2Token(self.user1, self.oauthservice1, "ABC",
"XYZ")
self.oauthtoken2 = OAuth2Token(self.user1, self.oauthservice2, "DEF",
"UVW")
def test_compare_tokens(self):
t1 = Token(self.user1, self.service1, "ABC")
t2 = Token(self.user1, self.service1, "ABC")
t3 = Token(self.user1, self.service2, "ABC")
t4 = Token(self.user1, self.service1, "QWERT")
t5 = Token(self.user2, self.service2, "ABC")
ot1 = OAuth2Token(self.user1, self.oauthservice1, "ABC", "XYZ")
ot2 = OAuth2Token(self.user1, self.oauthservice1, "ABC", "XYZ")
ot3 = self.oauthtoken2 = OAuth2Token(self.user1, self.oauthservice2,
"DEF", "UVW")
ot4 = OAuth2Token(self.user1, self.oauthservice1, "QWE", "RTZ")
self.assertEqual(t1, t2)
self.assertNotEqual(t3, t2)
self.assertEqual(t1, t4)
self.assertNotEqual(t1, t5)
self.assertFalse(t1 is t2)
self.assertEqual(ot1, ot2)
self.assertNotEqual(ot3, ot2)
self.assertEqual(ot1, ot4)
self.assertEqual(t1, ot1)
def test_serviceprojects_add(self):
proj1 = {"projectId": 0, "metadata": {}}
proj2 = {"projectId": 1, "metadata": {}}
userId = "admin"
servicename = "port-zenodo"
expected_project = proj1
pact.given("one searched token was registered.").upon_receiving(
"a request to get a specific token for service from user."
).with_request(
"GET", f"/user/{userId}/token/{servicename}").will_respond_with(
200,
body=json.dumps(
Token(
User(userId),
BaseService(servicename=servicename,
implements=["metadata"]), "ABC")))
pact.given("service with project support").upon_receiving(
"try to create a project").with_request(
"POST",
f"/metadata/project").will_respond_with(200,
body=expected_project)
with pact:
code = self.client.post(
"/port-service/user/{}/service/{}/projects".format(
userId, servicename)).status_code
self.assertEqual(code, 200)
pact.given("one searched token was registered.").upon_receiving(
"a request to get a specific token for service from user."
).with_request(
"GET", f"/user/{userId}/token/{servicename}").will_respond_with(
200,
body=json.dumps(
Token(
User(userId),
BaseService(servicename=servicename,
implements=["metadata"]), "ABC")))
pact.given("Given token to access port").upon_receiving(
"invalid request").with_request(
"POST", "/metadata/project").will_respond_with(500, body="")
with pact:
code = self.client.post(
"/port-service/user/{}/service/{}/projects".format(
userId, servicename)).status_code
self.assertEqual(code, 500)
def test_serviceprojects_delete(self):
proj1 = {"projectId": 0, "metadata": {}}
userId = "admin"
servicename = "port-zenodo"
pact.given("one searched token was registered.").upon_receiving(
"a request to get a specific token for service from user."
).with_request(
"GET", f"/user/{userId}/token/{servicename}").will_respond_with(
200,
body=json.dumps(
Token(
User(userId),
BaseService(servicename=servicename,
implements=["metadata"]), "ABC")))
pact.given("Given token to access port").upon_receiving(
"try to delete {}".format(proj1["projectId"])).with_request(
"DELETE", "/metadata/project/{}".format(
proj1["projectId"])).will_respond_with(404, body="")
with pact:
code = self.client.delete(
"/port-service/user/{}/service/{}/projects/{}".format(
userId, servicename, proj1["projectId"])).status_code
self.assertGreaterEqual(code, 404)
pact.given("one searched token was registered.").upon_receiving(
"a request to get a specific token for service from user."
).with_request(
"GET", f"/user/{userId}/token/{servicename}").will_respond_with(
200,
body=json.dumps(
Token(
User(userId),
BaseService(servicename=servicename,
implements=["metadata"]), "ABC")))
pact.given("Given token to access port").upon_receiving(
"a call to delete {}".format(proj1["projectId"])).with_request(
"DELETE", "/metadata/project/{}".format(
proj1["projectId"])).will_respond_with(204, body="")
with pact:
code = self.client.delete(
"/port-service/user/{}/service/{}/projects/{}".format(
userId, servicename, proj1["projectId"])).status_code
self.assertEqual(code, 204)
def setUp(self):
Util.monkeypatch()
self.empty_storage = Storage(**get_opts())
self.user1 = User("Max Mustermann")
self.user2 = User("Mimi Mimikri")
self.service1 = LoginService(servicename="MusterService",
implements=["metadata"])
self.service2 = LoginService(servicename="FahrService",
implements=["metadata"])
self.oauthservice1 = OAuth2Service(
servicename="BetonService",
implements=["metadata"],
authorize_url="http://localhost/oauth/authorize",
refresh_url="http://localhost/oauth/token",
client_id="MNO",
client_secret="UVW",
)
self.oauthservice2 = OAuth2Service(
servicename="FlugService",
implements=["metadata"],
authorize_url="http://localhost21/oauth/authorize",
refresh_url="http://localhost21/oauth/token",
client_id="XCA",
client_secret="BCXY",
)
self.empty_storage.addService(self.service1)
self.empty_storage.addService(self.oauthservice1)
self.empty_storage.addService(self.oauthservice2)
self.token1 = Token(self.user1, self.service1, "ABC")
self.token_like_token1 = Token(self.user1, self.service1, "DEF")
self.token2 = Token(self.user1, self.oauthservice1, "XYZ")
self.token3 = Token(self.user2, self.service2, "XASD")
self.token4 = Token(self.user2, self.service1, "IOAJSD")
self.oauthtoken1 = OAuth2Token(self.user1, self.oauthservice1,
"ABC", "X_ABC")
self.oauthtoken_like_token1 = OAuth2Token(self.user1,
self.oauthservice1,
"ABC", "X_DEF")
self.oauthtoken2 = OAuth2Token(self.user1, self.oauthservice1,
"XYZ", "X_XYZ")
self.oauthtoken3 = OAuth2Token(self.user1, self.oauthservice2,
"XYZ", "X_XYZ")
def setUp(self):
self.tokenService = TokenService(testing="http://localhost:3000")
self.url1 = "https://10.14.29.60/owncloud/index.php/apps/oauth2/authorize?response_type=code&client_id={}&redirect_uri={}".format(
1, "http://localhost:8080")
self.url2 = "http://zenodo.org/oauth/authorize?response_type=code&client_id={}&redirect_uri={}".format(
2, "http://localhost:8080")
self.servicename1 = "owncloud-local"
self.servicename2 = "sandbox.zenodo.org"
self.user1 = User("user")
self.user2 = User("user_refresh")
self.service1 = OAuth2Service(
servicename=self.servicename1,
implements=["fileStorage"],
authorize_url=self.url1,
refresh_url=
"https://10.14.29.60/owncloud/index.php/apps/oauth2/api/v1/token",
client_id="ABC",
client_secret="XYZ",
)
self.service2 = OAuth2Service(
servicename=self.servicename2,
implements=["metadata"],
authorize_url=self.url2,
refresh_url="https://sandbox.zenodo.org/oauth/token",
client_id="DEF",
client_secret="UVW",
)
self.token1 = Token(self.user1, self.service1, "ABC")
self.token2 = OAuth2Token(self.user1, self.service2, "ABC", "XYZ")
def getTokenForServiceFromUser(self, service: BaseService,
user: User) -> Token:
"""
Returns the token from type Token (struct: servicename: str, access_token: str) for given service from given user.
Raise ServiceNotExistsError, if no token for service was found.
"""
response = requests.get(
f"{self.address}/user/{user.username}/token/{service.servicename}",
verify=(os.environ.get("VERIFY_SSL", "True") == "True"),
)
data = response.json()
while type(data) is not dict:
data = json.loads(data)
if response.status_code != 200:
if "error" in data:
if data["error"] == "TokenNotExistsError":
raise TokenNotFoundError(Token(user, service, "NOT_USED"))
if data["error"] == "UserNotExistsError":
raise UserNotFoundError(user)
if data["error"] == "ServiceNotExistsError":
raise ServiceNotFoundError(service)
raise Exception(data)
token = Util.getTokenObject(data)
if isinstance(token.service, OAuth2Service):
token.service._client_secret = ""
if isinstance(token, OAuth2Token):
token._refresh_token = ""
return token
def test_logintoken(self):
user1 = User("Max Mustermann")
user2 = User("12345")
service1 = LoginService("MusterService", ["fileStorage"])
service2 = LoginService("BetonService", ["fileStorage"], userId=False)
service3 = LoginService("FahrService", ["fileStorage"], password=False)
service4 = LoginService("TaxiService", ["fileStorage"],
userId=False,
password=False)
with self.assertRaises(ValueError):
LoginToken(None, service1, "")
with self.assertRaises(ValueError):
LoginToken(user1, service1, "")
with self.assertRaises(ValueError):
LoginToken(None, service1, "DEF")
with self.assertRaises(ValueError):
LoginToken(None, service2, "")
with self.assertRaises(ValueError):
LoginToken(user1, service2, "")
LoginToken(None, service2, "DEF")
with self.assertRaises(ValueError):
LoginToken(None, service3, "")
LoginToken(user1, service3, "")
LoginToken(user1, service3, None)
LoginToken(user1, service3, "DEF")
with self.assertRaises(ValueError):
LoginToken(None, service3, "DEF")
LoginToken(None, service4, None)
LoginToken(None, service4, "")
LoginToken(user1, service4, "")
LoginToken(None, service4, "DEF")
Token(user1, service1, "DEF")
Token(user1, service3, "DEF")
def test_token_service_init(self):
user1 = User("Max Mustermann")
service1 = BaseService("MusterService", ["fileStorage"])
service2 = LoginService("BetonService", ["fileStorage"],
userId=True,
password=False)
LoginToken(user1, service2, "")
with self.assertRaises(ValueError):
Token(user1, service1, "")
def test_parseToken(self):
user1 = User("MaxMustermann")
service1 = LoginService("MusterService", ["fileStorage"])
token1 = Token(user1, service1, "ABC")
serviceport = "{}".format(token1.service.servicename)
data = {
"userId":
"port-{}://{}:{}".format("musterservice", "MaxMustermann", "ABC")
}
self.assertEqual(Util.parseToken(token1), data)
def test_token_empty_string(self):
with self.assertRaises(ValueError):
Token(None, None, "")
with self.assertRaises(ValueError):
Token(self.user1, None, "")
with self.assertRaises(ValueError):
Token(self.user1, None, "ABC")
with self.assertRaises(ValueError):
OAuth2Token(self.user1, None, "", "")
# refresh_token is the only parameter, which can be empty
self.assertIsInstance(
OAuth2Token(self.user1, self.oauthservice1, "ABC"), OAuth2Token)
self.assertIsInstance(
OAuth2Token(self.user1, self.oauthservice2, "ABC"), Token)
with self.assertRaises(ValueError):
OAuth2Token(self.user1, self.oauthservice1, "")
with self.assertRaises(ValueError):
OAuth2Token(self.user1, self.oauthservice1, "", "")
with self.assertRaises(ValueError):
OAuth2Token(self.user1, None, "ABC", "")
with self.assertRaises(ValueError):
OAuth2Token(self.user1, None, "", "X_ABC")
with self.assertRaises(ValueError):
OAuth2Token(self.user1, self.oauthservice1, "", "X_ABC")
with self.assertRaises(ValueError):
OAuth2Token(self.user1, None, "ABC", "X_ABC")
def test_service_check_raises(self):
svc1 = OAuth2Service(
"MusterService",
["fileStorage"],
FileTransferMode.active,
FileTransferArchive.none,
"http://localhost:5001",
"http://localhost:5001/oauth/refresh",
"ABC",
"XYZ",
)
from RDS import User, Token, OAuth2Token
with self.assertRaises(ValueError):
svc1.refresh(Token(User("Max Mustermann"), svc1, "ABC"))
svc1.refresh("asd")
svc1.refresh(123)
def test_tokenstorage_service_implementstype(self):
empty_storage = Storage(**get_opts())
service = LoginService(servicename="longname",
implements=["fileStorage", "metadata"])
empty_storage.addUser(self.user1)
token1 = Token(self.user1, service, "ISADF")
# test the exception raise
with self.assertRaises(ServiceNotExistsError):
empty_storage.addTokenToUser(token1, self.user1)
# now should work
self.assertTrue(empty_storage.addService(service))
self.assertTrue(empty_storage.addTokenToUser(token1, self.user1))
self.assertEqual(empty_storage.getTokens(self.user1), [token1])
with self.assertRaises(ServiceExistsAlreadyError):
empty_storage.addService(service)
def internal_removeTokenForStringFromUser(self, service: BaseService,
user: User) -> bool:
response = requests.delete(
f"{self.address}/user/{user.username}/token/{service.servicename}",
verify=(os.environ.get("VERIFY_SSL", "True") == "True"),
)
data = response.json()
if response.status_code != 200:
if "error" in data:
if data["error"] == "TokenNotExistsError":
raise TokenNotFoundError(Token(user, service, "NOT_USED"))
if data["error"] == "UserNotExistsError":
raise UserNotFoundError(user)
if data["error"] == "ServiceNotExistsError":
raise ServiceNotFoundError(service)
raise Exception(data)
return data["success"]
def test_tokenstorage_tokens_under_user(self):
oauthtoken1 = OAuth2Token(self.user1, self.oauthservice1, "ABC",
"X_ABC")
self.empty_storage.addTokenToUser(oauthtoken1,
self.user1,
Force=True)
oauthtoken2 = OAuth2Token(self.user1, self.oauthservice2, "XYZ",
"X_XYZ")
self.empty_storage.addTokenToUser(oauthtoken2,
self.user1,
Force=True)
token1 = Token(self.user1, self.service2, "ISADF")
with self.assertRaises(ServiceNotExistsError):
self.empty_storage.addTokenToUser(token1,
self.user1,
Force=True)
self.empty_storage.addTokenToUser(self.token1,
self.user1,
Force=True)
def test_owncloud(self):
# prepare service
storage = Storage()
redirect = "https://10.14.29.60/owncloud/index.php/apps/rds/oauth"
owncloud = OAuth2Service(
servicename="owncloud-local",
implements=["metadata"],
authorize_url=
"https://10.14.29.60/owncloud/index.php/apps/oauth2/authorize?response_type=code&client_id={}&redirect_uri={}"
.format(os.getenv("OWNCLOUD_OAUTH_CLIENT_ID"), redirect),
refresh_url=
"https://10.14.29.60/owncloud/index.php/apps/oauth2/api/v1/token",
client_id=os.getenv("OWNCLOUD_OAUTH_CLIENT_ID"),
client_secret=os.getenv("OWNCLOUD_OAUTH_CLIENT_SECRET"),
)
storage.addService(owncloud)
# prepare user, which wants to make the whole oauth workflow
user1 = User("user")
token1 = Token(user1, owncloud, "user")
storage.addUser(user1)
storage.addTokenToUser(token1, user1)
def get_access_token(user, token):
nonlocal owncloud, storage
self.driver.get(owncloud.authorize_url)
if self.driver.current_url.startswith(
"https://10.14.29.60/owncloud/index.php/login"):
# it redirects to login form
field_username = self.driver.find_element_by_xpath(
'//*[@id="user"]')
field_password = self.driver.find_element_by_xpath(
'//*[@id="password"]')
field_username.clear()
field_username.send_keys(user.username)
field_password.clear()
field_password.send_keys(token.access_token)
old_url = self.driver.current_url
url = self.driver.current_url
field_password.send_keys(Keys.RETURN)
retry = 0
while old_url == url and retry < 5:
sleep(1)
retry += 1
url = self.driver.current_url
logger.info("url: {}".format(url))
if retry >= 5:
raise Exception("url not redirect!")
btn = self.driver.find_element_by_xpath(
"/html/body/div[1]/div/span/form/button")
old_url = self.driver.current_url
url = self.driver.current_url
btn.click()
retry = 0
while old_url == url and retry < 5:
sleep(1)
retry += 1
url = self.driver.current_url
logger.info("url: {}".format(url))
if retry >= 5:
raise Exception("url not redirect!")
self.driver.delete_all_cookies() # remove all cookies
from urllib.parse import urlparse, parse_qs
query = urlparse(url).query
logger.info("query: {}".format(query))
parse = parse_qs(query)
logger.info("parse: {}".format(parse))
code = parse["code"]
data = {
"grant_type": "authorization_code",
"code": code,
"redirect_uri": redirect,
}
req = requests.post(
owncloud.refresh_url,
data=data,
auth=(owncloud.client_id, owncloud.client_secret),
verify=False,
).json()
oauthtoken = OAuth2Token(
user,
token.service,
req["access_token"],
req["refresh_token"],
datetime.now() + timedelta(seconds=req["expires_in"]),
)
return oauthtoken
oauthtoken1 = get_access_token(user1, token1)
storage.addTokenToUser(oauthtoken1, user1, Force=True)
######## test a refresh token #######
# prepare user, which wants to get a refresh token
oauthuser2 = User("user_refresh")
# check if there is already a file, which has an oauth2token to reuse it.
oauthtoken2 = None
filepath = "https://zivgitlab.uni-muenster.de/{}/{}/-/jobs/artifacts/{}/raw/{}/user_refresh.token?job_token={}&job={}".format(
os.getenv("CI_PROJECT_NAMESPACE"),
os.getenv("CI_PROJECT_NAME"),
os.getenv("CI_COMMIT_REF_NAME"),
os.getenv("FOLDER"),
os.getenv("CI_JOB_TOKEN"),
os.getenv("CI_JOB_NAME"),
)
try:
headers = {"JOB-TOKEN": os.getenv("CI_JOB_TOKEN")}
req = requests.get(filepath, headers=headers)
if req.status_code != 200:
raise Exception(
"Artifact not found, filepath: {filepath}, headers: {headers}"
)
try:
oauthtoken2 = initialize_object_from_json(req.text)
except Exception as e:
raise Exception(f"{str(e)} + \n req: {req.text}")
except Exception as e:
logger.error(e)
logger.warning(
"No refresh token from previous test run was found, so we collect a new one. \nFilepath: {}"
.format(filepath))
# initialize like user1 with password
token2 = Token(oauthuser2, owncloud, "user_refresh")
# generate an oauthtoken like before and overwrite oauthtoken1
oauthtoken2 = get_access_token(oauthuser2, token2)
storage.addUser(oauthuser2)
storage.addTokenToUser(oauthtoken2, oauthuser2)
# try to refresh it now
storage.refresh_service(owncloud)
tokens = storage.getTokens(oauthuser2)
checkToken = tokens[0]
self.assertEqual(checkToken, oauthtoken2)
# safe the current oauthtoken for reuse to test refresh token after a bigger period.
with open("user_refresh.token", "w") as f:
f.write(json.dumps(checkToken))
def test_zenodo(self):
# prepare service
storage = Storage()
zenodo = OAuth2Service(
servicename="sandbox.zenodo.org",
authorize_url=
"https://sandbox.zenodo.org/oauth/authorize?scope=deposit%3Awrite+deposit%3Aactions&state=CHANGEME&redirect_uri=http%3A%2F%2Flocalhost%3A8080&response_type=code&client_id={}"
.format(os.getenv("ZENODO_OAUTH_CLIENT_ID")),
refresh_url="https://sandbox.zenodo.org/oauth/token",
client_id=os.getenv("ZENODO_OAUTH_CLIENT_ID"),
client_secret=os.getenv("ZENODO_OAUTH_CLIENT_SECRET"),
)
# TODO: needs valid user in env var in gitlab
zenodouser1 = User("USERNAME")
zenodotoken1 = Token(zenodo.servicename, "PASSWORT")
def get_access_token(user, token):
nonlocal zenodo, storage
self.driver.get(zenodo.authorize_url)
if self.driver.current_url.startswith(
"https://sandbox.zenodo.org/login"):
# it redirects to login form
field_username = self.driver.find_element_by_xpath(
'//*[@id="email"]')
field_password = self.driver.find_element_by_xpath(
'//*[@id="password"]')
field_username.clear()
field_username.send_keys(user.username)
field_password.clear()
field_password.send_keys(token.access_token)
field_password.send_keys(Keys.RETURN)
self.driver.get(zenodo.authorize_url)
btn = self.driver.find_element_by_xpath(
"/html/body/div[2]/div[2]/div/div/div/div/div[2]/div[2]/form/button[1]"
)
old_url = self.driver.current_url
url = self.driver.current_url
btn.click()
retry = 0
while old_url == url and retry < 5:
sleep(1)
retry += 1
url = self.driver.current_url
logger.info("url: {}".format(url))
if retry >= 5:
raise Exception("url not redirect!")
self.driver.delete_all_cookies() # remove all cookies
from urllib.parse import urlparse, parse_qs
query = urlparse(url).query
logger.info("query: {}".format(query))
parse = parse_qs(query)
logger.info("parse: {}".format(parse))
code = parse["code"]
data = {
"grant_type": "authorization_code",
"code": code,
"redirect_uri": redirect,
}
req = requests.post(
zenodo.refresh_url,
data=data,
auth=(zenodo.client_id, zenodo.client_secret),
).json()
oauthtoken = OAuth2Token(
zenodo.servicename,
req["access_token"],
req["refresh_token"],
datetime.now() + timedelta(seconds=req["expires_in"]),
)
return oauthtoken
oauthtoken1 = get_access_token(zenodouser1, zenodotoken1)
storage.addTokenToUser(oauthtoken1, zenodouser1, Force=True)
def setUp(self):
self.app = create_app()
self.client = self.app.test_client()
self.empty_storage = Storage()
self.success = {"success": True}
self.user1 = User("Max Mustermann")
self.user2 = User("Mimi Mimikri")
self.user3 = User("Karla Kolumda")
self.service1 = LoginService(servicename="MusterService",
implements=["metadata"])
self.service2 = LoginService(servicename="BetonService",
implements=["metadata"])
self.service3 = LoginService(servicename="FahrService",
implements=["metadata"])
self.oauthservice1 = OAuth2Service.from_service(
self.service1,
f"{pact_host_fqdn}/owncloud/index.php/apps/oauth2/authorize",
f"{pact_host_fqdn}/owncloud/index.php/apps/oauth2/api/v1/token",
"ABC",
"XYZ",
)
self.oauthservice2 = OAuth2Service.from_service(
self.service2,
f"{pact_host_fqdn}/oauth/authorize",
f"{pact_host_fqdn}/oauth/token",
"DEF",
"UVW",
)
self.oauthservice3 = OAuth2Service.from_service(
self.service3,
f"{pact_host_fqdn}/api/authorize",
f"{pact_host_fqdn}/api/token",
"GHI",
"MNO",
)
self.token1 = Token(self.user1, self.service1, "ABC")
self.token_like_token1 = Token(self.user1, self.service1, "DEF")
self.token2 = Token(self.user2, self.service2, "XYZ")
self.token3 = Token(self.user1, self.service3, "GHI")
self.oauthtoken1 = OAuth2Token(self.user1, self.oauthservice1, "ABC",
"X_ABC")
self.oauthtoken_like_token1 = OAuth2Token(self.user1,
self.oauthservice1, "X_DEF")
self.oauthtoken2 = OAuth2Token(self.user2, self.oauthservice2, "XYZ",
"X_XYZ")
self.oauthtoken3 = OAuth2Token(self.user1, self.oauthservice3, "GHI",
"X_GHI")
self.services = [
self.service1,
self.service2,
self.service3,
self.oauthservice1,
self.oauthservice2,
self.oauthservice3,
]
self.filled_storage_without_tokens = Storage()
self.filled_storage_without_tokens.addUser(self.user1)
self.filled_storage_without_tokens.addUser(self.user2)
self.filled_storage_without_tokens.addUser(self.user3)
self.filled_storage = Storage()
self.filled_storage.addService(self.oauthservice1)
self.filled_storage.addService(self.oauthservice2)
self.filled_storage.addService(self.oauthservice3)
# user1 is filled with mixed token and oauth2token
self.filled_storage.addUser(self.user1)
self.filled_storage.addTokenToUser(self.token1, self.user1)
self.filled_storage.addTokenToUser(self.token3, self.user1)
self.filled_storage.addTokenToUser(self.oauthtoken1,
self.user1,
Force=True)
# user2 is only filled with token
self.filled_storage.addUser(self.user2)
self.filled_storage.addTokenToUser(self.token2, self.user2)
def test_get_token_for_service_from_user(self):
# test get token, if no token is there
pact.given("no token was registered.").upon_receiving(
"a request to get a specific token for service from user."
).with_request(
"GET",
f"/user/{self.user1.username}/token/{self.service1.servicename}"
).will_respond_with(
404,
body={
"error": "ServiceNotExistsError",
"description": "Service not found.",
},
)
with self.assertRaises(ServiceNotFoundError):
self.tokenService.getTokenForServiceFromUser(
self.service1, self.user1)
# test get token, if one token, but not same is there
pact.given("one token was registered.").upon_receiving(
"a request to get a specific token for service from user."
).with_request(
"GET",
f"/user/{self.user1.username}/token/{self.service1.servicename}"
).will_respond_with(
404,
body={
"error": "ServiceNotExistsError",
"description": "Service not found.",
},
)
with self.assertRaises(ServiceNotFoundError):
self.tokenService.getTokenForServiceFromUser(
self.service1, self.user1)
# test, get token successful
pact.given("one searched token was registered.").upon_receiving(
"a request to get a specific token for service from user."
).with_request(
"GET",
f"/user/{self.user1.username}/token/{self.service1.servicename}"
).will_respond_with(200, body=json.dumps(self.token1))
testToken1 = self.tokenService.getTokenForServiceFromUser(
self.service1, self.user1)
self.assertEqual(
testToken1,
self.token1,
)
self.assertEqual(testToken1.service.client_secret, "")
# test, get oauthtoken successful, but it have to be reduced to token
pact.given("one searched oauthtoken was registered.").upon_receiving(
"a request to get a specific oauthtoken for service from user."
).with_request(
"GET",
f"/user/{self.user1.username}/token/{self.service1.servicename}"
).will_respond_with(200, body=json.dumps(self.token2))
reduced_token = Token(self.user1, self.token2.service,
self.token2.access_token)
testtoken2 = self.tokenService.getTokenForServiceFromUser(
self.service1, self.user1)
self.assertEqual(
testtoken2,
reduced_token,
)
self.assertEqual(testtoken2.refresh_token, "")