def test_user_install_stores_token_if_success(mocker):
expected_user = User(team_id="foo-team", user_id="foo-user")
mocker.patch(
"slack_profile_update.gateway.slack.authorisation_grant",
return_value=AuthorisationGrantResponse(
success=True,
team=expected_user.team_id,
user=expected_user.user_id,
token="foo-token",
scope=EXPECTED_SCOPE,
),
)
client_id = "test client id"
client_secret = "test client secret"
stub_user_token_store = StubUserTokenStore()
user_install = UserInstall(
client_id=client_id,
client_secret=client_secret,
redirect_uri="example.com",
user_token_store=stub_user_token_store,
)
response = user_install.execute("foobar", "test-state")
assert response.present()["statusCode"] == 200
assert stub_user_token_store.fetch(expected_user).token == "foo-token"
def test_user_uninstall_logs_message(caplog, test_file):
event = json.loads(test_file("user_token_revoked.json"))
user_to_be_removed = User("U019LN451HT", "T019PQN3UAE", "token1")
token_store = StubUserTokenStore()
token_store.store(user_to_be_removed)
with caplog.at_level(logging.INFO):
UserUninstall(user_link_store=StubUserLinkStore(),
user_token_store=token_store).execute(event)
assert "uninstalled user" in caplog.text, "missing log entry"
def test_remove_non_existent_is_silent():
team_id = "team"
user_id = "user"
expected_token = "foobar"
gateway = StubUserTokenStore()
expected_user = User(user_id=user_id,
team_id=team_id,
token=expected_token)
unstored_user = User(user_id="foo", team_id="bar", token=None)
gateway.store(expected_user)
assert gateway.remove(unstored_user) is False
def test_can_get_a_user_token():
team_id = "team"
user_id = "user"
expected_token = "foobar"
gateway = StubUserTokenStore()
expected_user = User(user_id=user_id,
team_id=team_id,
token=expected_token)
gateway.store(expected_user)
user = gateway.fetch(expected_user)
assert expected_user == user
assert expected_token == user.token
def execute(self, environment, event):
path = event["input"]["path"]
http_method = event["input"]["requestContext"]["httpMethod"]
response = ApiGatewayResponse()
if http_method == "GET":
if path == "/oauth/authorization_grant":
query_strings = event["input"][
"multiValueQueryStringParameters"]
code = query_strings.get("code", None)
state = query_strings.get("state", None)
if (code is not None and state is not None and len(code) == 1
and len(state) == 1):
response = UserInstall(
client_id=environment["CLIENT_ID"],
client_secret=environment["CLIENT_SECRET"],
redirect_uri=environment["REDIRECT_URI"],
user_token_store=StubUserTokenStore(),
).execute(code[0], state[0])
else:
logging.debug("missing code or state")
response.not_found()
else:
response.not_found()
else:
request = ApiGatewayRequest(event)
response = HandleEvent(
environment=environment,
headers=request.headers(),
raw_body=request.raw_body(),
).execute()
return response.present()
def test_user_uninstall_with_no_exsisting_user(caplog, test_file):
event = json.loads(test_file("user_token_revoked.json"))
with caplog.at_level(logging.WARNING):
UserUninstall(user_link_store=StubUserLinkStore(),
user_token_store=StubUserTokenStore()).execute(event)
assert "tried to uninstall user that did not exist" in caplog.text
def test_remove_a_user_token():
team_id = "team"
user_id = "user"
expected_token = "foobar"
gateway = StubUserTokenStore()
expected_user = User(user_id=user_id,
team_id=team_id,
token=expected_token)
gateway.store(expected_user)
gateway.fetch(expected_user)
assert gateway.remove(expected_user) is True
with pytest.raises(KeyError):
gateway.fetch(expected_user)
def test_user_uninstall_removed_users_from_gateways(test_file):
event = test_file("user_token_revoked.json")
secret = "secret"
user_to_be_removed = User("U019LN451HT", "T019PQN3UAE", "token1")
linked_user_1 = User("user1", "team1", "token2")
linked_user_2 = User("user2", "team1", "token3")
link_store = StubUserLinkStore()
link_store.link(user_to_be_removed, linked_user_1)
link_store.link(user_to_be_removed, linked_user_2)
token_store = StubUserTokenStore()
token_store.store(user_to_be_removed)
token_store.store(linked_user_1)
token_store.store(linked_user_2)
response = HandleEvent(
environment={
"SLACK_SIGNING_SECRET": secret
},
headers=event_signature_headers(secret, event),
raw_body=event,
user_link_store=link_store,
user_token_store=token_store,
).execute()
assert response.present() == {
"statusCode": 204,
"headers": {},
"body": None,
}
with pytest.raises(KeyError):
token_store.fetch(user_to_be_removed)
with pytest.raises(KeyError):
link_store.fetch(user_to_be_removed)
# does not remove linked users
token_store.fetch(linked_user_1)
token_store.fetch(linked_user_2)
link_store.fetch(linked_user_2)
link_store.fetch(linked_user_2)
def __init__(
self,
environment,
headers,
raw_body,
user_token_store=StubUserTokenStore(),
user_link_store=StubUserLinkStore(),
):
self.raw_body = raw_body
self.headers = headers
self.signing_secret = environment["SLACK_SIGNING_SECRET"]
self.user_link_store = user_link_store
self.user_token_store = user_token_store
def test_updates_status_of_linked_users(caplog, test_file, mocker):
mocker.patch(
"slack_profile_update.gateway.slack.update_status",
return_value=True,
)
event = json.loads(test_file("example_user_updated_event.json"))
source_user = User("U019LN451HT", "T019PQN3UAE", "token1")
dest_user_1 = User("user1", "team1", "token2")
dest_user_2 = User("user3", "team3", "token3")
link_store = StubUserLinkStore()
link_store.link(source_user, dest_user_1)
link_store.link(source_user, dest_user_2)
token_store = StubUserTokenStore()
token_store.store(dest_user_1)
token_store.store(dest_user_2)
UpdateAllProfiles(user_link_store=link_store,
user_token_store=token_store).execute(event)
slack.update_status.assert_has_calls(
[
call(
status_emoji=":smile:",
status_expiration=0,
status_text="This is a test!",
token=dest_user_1.token,
),
call(
status_emoji=":smile:",
status_expiration=0,
status_text="This is a test!",
token=dest_user_2.token,
),
],
any_order=True,
)
def test_can_store_a_user_token():
StubUserTokenStore().store(User("team", "user", "test-token"))