mirror of
https://github.com/inventree/inventree-app.git
synced 2026-11-17 03:14:49 +00:00
* use session auth rather than token auth * Add unit tests for login * Ensure user cannot reuse login after logout * handle logout mid session * Additional unit tests * ensure sensitive data is redacted from sentry * Handle session disconnect * Additional tweaks * Update pubspec.lock * Update release_notes.md * Bump version number * Adjust login button * Clear stored session when host changes * Improved redacting of sensitive info * Improved handling of local session storage * prevent failed migration from logging as complete * Fix for error raised in overlapping requests * replace userInfo on successful response * handle empty response * Improved session comparison * Add UI testing
845 lines
26 KiB
Dart
845 lines
26 KiB
Dart
/*
|
|
* Unit tests for session authentication (no server required)
|
|
*/
|
|
|
|
import "dart:io";
|
|
|
|
import "package:flutter_secure_storage/flutter_secure_storage.dart";
|
|
import "package:flutter_test/flutter_test.dart";
|
|
import "package:sembast/sembast.dart";
|
|
|
|
import "package:inventree/api.dart";
|
|
import "package:inventree/auth/auth_manager.dart";
|
|
import "package:inventree/auth/auth_result.dart";
|
|
import "package:inventree/auth/session_store.dart";
|
|
import "package:inventree/inventree/redact.dart";
|
|
import "package:inventree/preferences.dart";
|
|
import "package:inventree/user_profile.dart";
|
|
|
|
import "setup.dart";
|
|
|
|
const String server = "https://inventree.example.com";
|
|
|
|
Cookie _cookie(
|
|
String name,
|
|
String value, {
|
|
String? domain,
|
|
String? path,
|
|
int? maxAge,
|
|
DateTime? expires,
|
|
bool secure = false,
|
|
}) {
|
|
final cookie = Cookie(name, value);
|
|
cookie.domain = domain;
|
|
cookie.path = path;
|
|
cookie.maxAge = maxAge;
|
|
cookie.expires = expires;
|
|
cookie.secure = secure;
|
|
return cookie;
|
|
}
|
|
|
|
void main() {
|
|
setupTestEnv();
|
|
|
|
final Uri serverUri = Uri.parse("${server}/api/part/");
|
|
|
|
group("SessionStore:", () {
|
|
test("Capture and send cookies", () {
|
|
final store = SessionStore(server: server);
|
|
|
|
store.capture(serverUri, [
|
|
_cookie(SESSION_COOKIE_NAME, "abc", path: "/"),
|
|
_cookie(CSRF_COOKIE_NAME, "xyz", path: "/"),
|
|
]);
|
|
|
|
expect(store.hasSession, equals(true));
|
|
expect(store.csrfToken, equals("xyz"));
|
|
|
|
final String header = store.cookieHeader(serverUri);
|
|
expect(header, contains("sessionid=abc"));
|
|
expect(header, contains("csrftoken=xyz"));
|
|
});
|
|
|
|
test("Cookies are never accepted from or sent to another host", () {
|
|
final store = SessionStore(server: server);
|
|
|
|
// Cookie received from a different host
|
|
store.capture(Uri.parse("https://evil.example.org/"), [
|
|
_cookie(SESSION_COOKIE_NAME, "abc"),
|
|
]);
|
|
|
|
expect(store.hasSession, equals(false));
|
|
|
|
// Cookie for a domain the server does not belong to
|
|
store.capture(serverUri, [
|
|
_cookie(SESSION_COOKIE_NAME, "abc", domain: "other.com"),
|
|
]);
|
|
|
|
expect(store.hasSession, equals(false));
|
|
|
|
store.capture(serverUri, [_cookie(SESSION_COOKIE_NAME, "abc")]);
|
|
expect(store.hasSession, equals(true));
|
|
|
|
expect(store.cookieHeader(Uri.parse("https://evil.example.org/")), "");
|
|
|
|
// Same host, different scheme / port
|
|
expect(
|
|
store.cookieHeader(Uri.parse("http://inventree.example.com/")),
|
|
"",
|
|
);
|
|
expect(
|
|
store.cookieHeader(Uri.parse("https://inventree.example.com:8443/")),
|
|
"",
|
|
);
|
|
});
|
|
|
|
test("Expiry and deletion", () {
|
|
final store = SessionStore(server: server);
|
|
|
|
store.capture(serverUri, [_cookie(SESSION_COOKIE_NAME, "abc")]);
|
|
expect(store.hasSession, equals(true));
|
|
|
|
// Max-Age=0 deletes the cookie
|
|
store.capture(serverUri, [_cookie(SESSION_COOKIE_NAME, "", maxAge: 0)]);
|
|
expect(store.hasSession, equals(false));
|
|
|
|
// Expires in the past deletes the cookie
|
|
store.capture(serverUri, [_cookie(SESSION_COOKIE_NAME, "abc")]);
|
|
store.capture(serverUri, [
|
|
_cookie(SESSION_COOKIE_NAME, "abc", expires: DateTime(1970)),
|
|
]);
|
|
expect(store.hasSession, equals(false));
|
|
});
|
|
|
|
test("Secure cookies are not sent over HTTP", () {
|
|
final store = SessionStore(server: "http://inventree.local");
|
|
final uri = Uri.parse("http://inventree.local/api/");
|
|
|
|
store.capture(uri, [
|
|
_cookie(SESSION_COOKIE_NAME, "abc", secure: true),
|
|
_cookie(CSRF_COOKIE_NAME, "xyz"),
|
|
]);
|
|
|
|
expect(store.cookieHeader(uri), equals("csrftoken=xyz"));
|
|
});
|
|
|
|
test("Path matching", () {
|
|
final store = SessionStore(server: server);
|
|
|
|
store.capture(serverUri, [_cookie("scoped", "1", path: "/api")]);
|
|
|
|
expect(store.cookieHeader(Uri.parse("${server}/api/part/")), "scoped=1");
|
|
expect(store.cookieHeader(Uri.parse("${server}/api")), "scoped=1");
|
|
expect(store.cookieHeader(Uri.parse("${server}/apix/")), "");
|
|
expect(store.cookieHeader(Uri.parse("${server}/web/")), "");
|
|
});
|
|
|
|
// A store which counts change notifications, and simulates each one being
|
|
// persisted successfully (as saveSession() does)
|
|
(SessionStore, int Function()) persistingStore() {
|
|
final store = SessionStore(server: server);
|
|
|
|
int changes = 0;
|
|
|
|
store.onChanged = () {
|
|
changes++;
|
|
store.markPersisted(store.snapshot());
|
|
};
|
|
|
|
return (store, () => changes);
|
|
}
|
|
|
|
test("Change notification", () {
|
|
final (store, changes) = persistingStore();
|
|
|
|
store.capture(serverUri, [_cookie(CSRF_COOKIE_NAME, "xyz", maxAge: 60)]);
|
|
expect(changes(), equals(1));
|
|
|
|
// Same value (and similar expiry) - no change reported
|
|
store.capture(serverUri, [_cookie(CSRF_COOKIE_NAME, "xyz", maxAge: 61)]);
|
|
expect(changes(), equals(1));
|
|
|
|
// New value
|
|
store.capture(serverUri, [_cookie(CSRF_COOKIE_NAME, "abc", maxAge: 60)]);
|
|
expect(changes(), equals(2));
|
|
|
|
// Deleted
|
|
store.capture(serverUri, [_cookie(CSRF_COOKIE_NAME, "", maxAge: 0)]);
|
|
expect(changes(), equals(3));
|
|
});
|
|
|
|
test("Sliding expiry is persisted once it has moved by an hour", () {
|
|
final (store, changes) = persistingStore();
|
|
final DateTime base = DateTime.now().add(Duration(days: 14));
|
|
|
|
store.capture(serverUri, [
|
|
_cookie(SESSION_COOKIE_NAME, "abc", expires: base),
|
|
]);
|
|
expect(changes(), equals(1));
|
|
|
|
// Each renewal is less than an hour after the previous one...
|
|
store.capture(serverUri, [
|
|
_cookie(
|
|
SESSION_COOKIE_NAME,
|
|
"abc",
|
|
expires: base.add(Duration(minutes: 40)),
|
|
),
|
|
]);
|
|
expect(changes(), equals(1));
|
|
|
|
// ... but more than an hour after the persisted expiry
|
|
store.capture(serverUri, [
|
|
_cookie(
|
|
SESSION_COOKIE_NAME,
|
|
"abc",
|
|
expires: base.add(Duration(minutes: 80)),
|
|
),
|
|
]);
|
|
expect(changes(), equals(2));
|
|
|
|
// Now compared against the new persisted expiry
|
|
store.capture(serverUri, [
|
|
_cookie(
|
|
SESSION_COOKIE_NAME,
|
|
"abc",
|
|
expires: base.add(Duration(minutes: 120)),
|
|
),
|
|
]);
|
|
expect(changes(), equals(2));
|
|
});
|
|
|
|
test("Cookie attribute changes are persisted", () {
|
|
for (final changed in [
|
|
_cookie(CSRF_COOKIE_NAME, "xyz", path: "/api/"),
|
|
_cookie(CSRF_COOKIE_NAME, "xyz", secure: true),
|
|
_cookie(CSRF_COOKIE_NAME, "xyz", domain: "example.com"),
|
|
]) {
|
|
final (store, changes) = persistingStore();
|
|
|
|
store.capture(serverUri, [_cookie(CSRF_COOKIE_NAME, "xyz")]);
|
|
expect(changes(), equals(1));
|
|
|
|
// Same value - but different path / secure / domain
|
|
store.capture(serverUri, [changed]);
|
|
expect(changes(), equals(2), reason: changed.toString());
|
|
}
|
|
});
|
|
|
|
test("Changes are reported again after a failed write", () {
|
|
final store = SessionStore(server: server);
|
|
|
|
int changes = 0;
|
|
bool writeSucceeds = false;
|
|
|
|
store.onChanged = () {
|
|
changes++;
|
|
|
|
if (writeSucceeds) {
|
|
store.markPersisted(store.snapshot());
|
|
}
|
|
};
|
|
|
|
store.capture(serverUri, [_cookie(CSRF_COOKIE_NAME, "xyz")]);
|
|
expect(changes, equals(1));
|
|
|
|
// Not persisted - so the same cookie is reported again (write retried)
|
|
writeSucceeds = true;
|
|
store.capture(serverUri, [_cookie(CSRF_COOKIE_NAME, "xyz")]);
|
|
expect(changes, equals(2));
|
|
|
|
// Persisted - no further change
|
|
store.capture(serverUri, [_cookie(CSRF_COOKIE_NAME, "xyz")]);
|
|
expect(changes, equals(2));
|
|
});
|
|
|
|
test("Restored cookies are treated as persisted", () {
|
|
final (original, _) = persistingStore();
|
|
original.capture(serverUri, [
|
|
_cookie(SESSION_COOKIE_NAME, "abc", maxAge: 3600),
|
|
]);
|
|
|
|
final restored = SessionStore.fromJson(server, original.toJson());
|
|
|
|
int changes = 0;
|
|
restored.onChanged = () => changes++;
|
|
|
|
// Same cookie as stored - no write required
|
|
restored.capture(serverUri, [
|
|
_cookie(SESSION_COOKIE_NAME, "abc", maxAge: 3600),
|
|
]);
|
|
expect(changes, equals(0));
|
|
});
|
|
|
|
test("saveSession records the persisted cookies", () async {
|
|
final manager = UserProfileDBManager();
|
|
|
|
final profile = UserProfile(name: "Persist Test", server: server);
|
|
await manager.addProfile(profile);
|
|
final loaded = (await manager.getProfileByName("Persist Test"))!;
|
|
|
|
final session = SessionStore(server: server);
|
|
int changes = 0;
|
|
session.onChanged = () => changes++;
|
|
|
|
session.capture(serverUri, [_cookie(SESSION_COOKIE_NAME, "abc")]);
|
|
expect(changes, equals(1));
|
|
|
|
// Failed write - still reported as changed
|
|
secureStorageFailures.add("write");
|
|
expect(await manager.saveSession(loaded, session), equals(false));
|
|
secureStorageFailures.clear();
|
|
|
|
session.capture(serverUri, [_cookie(SESSION_COOKIE_NAME, "abc")]);
|
|
expect(changes, equals(2));
|
|
|
|
// Successful write - no longer reported
|
|
expect(await manager.saveSession(loaded, session), equals(true));
|
|
|
|
session.capture(serverUri, [_cookie(SESSION_COOKIE_NAME, "abc")]);
|
|
expect(changes, equals(2));
|
|
|
|
await manager.deleteProfile(loaded);
|
|
});
|
|
|
|
test("Clear auth cookies retains other cookies", () {
|
|
final store = SessionStore(server: server);
|
|
|
|
store.capture(serverUri, [
|
|
_cookie(SESSION_COOKIE_NAME, "abc"),
|
|
_cookie(CSRF_COOKIE_NAME, "xyz"),
|
|
_cookie("mfa_trusted", "trusted"),
|
|
]);
|
|
|
|
store.clearAuthCookies();
|
|
|
|
expect(store.hasSession, equals(false));
|
|
expect(store.hasCsrfToken, equals(false));
|
|
expect(store.cookieHeader(serverUri), equals("mfa_trusted=trusted"));
|
|
|
|
store.clear();
|
|
expect(store.isEmpty, equals(true));
|
|
});
|
|
|
|
test("Serialization", () {
|
|
final store = SessionStore(server: server);
|
|
|
|
store.capture(serverUri, [
|
|
_cookie(SESSION_COOKIE_NAME, "abc", maxAge: 3600),
|
|
_cookie(CSRF_COOKIE_NAME, "xyz", secure: true),
|
|
_cookie("expired", "old", expires: DateTime(1970)),
|
|
]);
|
|
|
|
final restored = SessionStore.fromJson(server, store.toJson());
|
|
|
|
expect(restored.hasSession, equals(true));
|
|
expect(restored.csrfToken, equals("xyz"));
|
|
expect(restored.cookieNames.length, equals(2));
|
|
|
|
// Corrupt data results in an empty store
|
|
expect(SessionStore.fromJson(server, "not-json").isEmpty, equals(true));
|
|
expect(SessionStore.fromJson(server, null).isEmpty, equals(true));
|
|
});
|
|
|
|
test("Server origin", () {
|
|
expect(
|
|
serverOrigin("https://inventree.example.com"),
|
|
equals("https://inventree.example.com:443"),
|
|
);
|
|
expect(
|
|
serverOrigin("HTTPS://InvenTree.Example.com:443/inventree/"),
|
|
equals("https://inventree.example.com:443"),
|
|
);
|
|
expect(
|
|
serverOrigin("http://127.0.0.1:8000/"),
|
|
equals("http://127.0.0.1:8000"),
|
|
);
|
|
expect(serverOrigin("not a url"), isEmpty);
|
|
expect(serverOrigin(""), isEmpty);
|
|
});
|
|
|
|
test("Stored cookies are only restored for the issuing origin", () {
|
|
final store = SessionStore(server: server);
|
|
store.capture(serverUri, [
|
|
_cookie(SESSION_COOKIE_NAME, "abc"),
|
|
_cookie(CSRF_COOKIE_NAME, "xyz"),
|
|
_cookie("mfa_trusted", "trusted"),
|
|
]);
|
|
|
|
final String data = store.toJson();
|
|
|
|
// Same origin - including an explicit default port, a different path or case
|
|
for (final address in [
|
|
server,
|
|
"https://inventree.example.com:443",
|
|
"https://inventree.example.com/inventree/",
|
|
"https://INVENTREE.example.com/",
|
|
]) {
|
|
final restored = SessionStore.fromJson(address, data);
|
|
expect(restored.rejected, equals(false), reason: address);
|
|
expect(restored.hasSession, equals(true), reason: address);
|
|
}
|
|
|
|
// Different origin - no cookies at all are restored (including MFA trust)
|
|
for (final address in [
|
|
"http://inventree.example.com",
|
|
"https://inventree.example.com:8443",
|
|
"http://inventree.example.com:443",
|
|
"https://other.example.com",
|
|
"https://example.com",
|
|
"",
|
|
]) {
|
|
final restored = SessionStore.fromJson(address, data);
|
|
expect(restored.rejected, equals(true), reason: address);
|
|
expect(restored.isEmpty, equals(true), reason: address);
|
|
expect(
|
|
restored.cookieHeader(Uri.parse("${address}/api/")),
|
|
isEmpty,
|
|
reason: address,
|
|
);
|
|
}
|
|
});
|
|
|
|
test("Stored cookies without an origin are not restored", () {
|
|
// Format used before the origin was recorded
|
|
const String legacy =
|
|
'[{"name": "sessionid", "value": "abc", "domain": "inventree.example.com"}]';
|
|
|
|
final restored = SessionStore.fromJson(server, legacy);
|
|
|
|
expect(restored.rejected, equals(true));
|
|
expect(restored.isEmpty, equals(true));
|
|
|
|
expect(
|
|
SessionStore.fromJson(server, '{"cookies": []}').rejected,
|
|
equals(true),
|
|
);
|
|
});
|
|
|
|
test("Set-Cookie header parsing", () {
|
|
// package:http folds multiple headers into one, separated by a comma
|
|
final values = splitSetCookieHeader(
|
|
[
|
|
"sessionid=abc; expires=Thu, 01 Jan 2099 00:00:00 GMT; HttpOnly; Path=/",
|
|
"csrftoken=xyz; expires=Fri, 02 Jan 2099 00:00:00 GMT; Path=/",
|
|
].join(","),
|
|
);
|
|
|
|
expect(values.length, equals(2));
|
|
expect(values[0], startsWith("sessionid=abc"));
|
|
expect(values[1], startsWith("csrftoken=xyz"));
|
|
|
|
final store = SessionStore(server: server);
|
|
|
|
// A malformed cookie does not prevent the others from being stored
|
|
store.captureHeaders(serverUri, [...values, "=bad=;;"]);
|
|
|
|
expect(store.hasSession, equals(true));
|
|
expect(store.csrfToken, equals("xyz"));
|
|
});
|
|
});
|
|
|
|
group("Request headers:", () {
|
|
final api = InvenTreeAPI();
|
|
|
|
setUp(() {
|
|
api.profile = UserProfile(name: "Test", server: server);
|
|
|
|
api.session = SessionStore(server: server);
|
|
api.session.capture(serverUri, [
|
|
_cookie(SESSION_COOKIE_NAME, "abc"),
|
|
_cookie(CSRF_COOKIE_NAME, "xyz"),
|
|
]);
|
|
});
|
|
|
|
tearDown(() {
|
|
api.disconnectFromServer();
|
|
});
|
|
|
|
test("Safe requests include cookies but not CSRF headers", () {
|
|
final headers = api.defaultHeaders(url: "part/");
|
|
|
|
expect(headers[HttpHeaders.cookieHeader], contains("sessionid=abc"));
|
|
expect(headers.containsKey("X-CSRFToken"), equals(false));
|
|
expect(headers.containsKey(HttpHeaders.authorizationHeader), false);
|
|
});
|
|
|
|
test("Unsafe requests include CSRF headers", () {
|
|
for (final method in ["POST", "PUT", "PATCH", "DELETE"]) {
|
|
final headers = api.defaultHeaders(method: method, url: "part/");
|
|
|
|
expect(headers["X-CSRFToken"], equals("xyz"));
|
|
expect(headers["Origin"], equals(server));
|
|
expect(headers[HttpHeaders.refererHeader], equals("${server}/"));
|
|
}
|
|
});
|
|
|
|
test("No credentials for other hosts", () {
|
|
final headers = api.defaultHeaders(
|
|
method: "POST",
|
|
url: "https://images.example.org/image.png",
|
|
);
|
|
|
|
expect(headers.containsKey(HttpHeaders.cookieHeader), equals(false));
|
|
expect(headers.containsKey("X-CSRFToken"), equals(false));
|
|
expect(headers.containsKey("Origin"), equals(false));
|
|
});
|
|
});
|
|
|
|
group("Error reporting:", () {
|
|
test("Credentials are redacted", () {
|
|
final String result = redactHeaders({
|
|
"Cookie": "sessionid=abc",
|
|
"set-cookie": "sessionid=abc",
|
|
"X-CSRFToken": "xyz",
|
|
"Authorization": "Token 123",
|
|
"Accept": "application/json",
|
|
});
|
|
|
|
expect(result, isNot(contains("abc")));
|
|
expect(result, isNot(contains("xyz")));
|
|
expect(result, isNot(contains("123")));
|
|
expect(result, contains("application/json"));
|
|
});
|
|
});
|
|
|
|
group("AuthResult:", () {
|
|
APIResponse response(int status, Map<String, dynamic> data) =>
|
|
APIResponse(statusCode: status, data: data);
|
|
|
|
test("Authenticated", () {
|
|
final result = AuthResult.fromResponse(
|
|
response(200, {
|
|
"status": 200,
|
|
"data": {
|
|
"user": {"id": 1, "username": "admin"},
|
|
},
|
|
"meta": {"is_authenticated": true},
|
|
}),
|
|
);
|
|
|
|
expect(result.status, equals(AuthStatus.authenticated));
|
|
expect(result.user["username"], equals("admin"));
|
|
});
|
|
|
|
test("MFA required", () {
|
|
final result = AuthResult.fromResponse(
|
|
response(401, {
|
|
"status": 401,
|
|
"data": {
|
|
"flows": [
|
|
{"id": "login"},
|
|
{
|
|
"id": "mfa_authenticate",
|
|
"is_pending": true,
|
|
"types": ["totp", "recovery_codes"],
|
|
},
|
|
],
|
|
},
|
|
"meta": {"is_authenticated": false},
|
|
}),
|
|
);
|
|
|
|
expect(result.status, equals(AuthStatus.flowPending));
|
|
expect(result.pendingFlow!.id, equals(FLOW_MFA_AUTHENTICATE));
|
|
expect(result.pendingFlow!.isSupportedMfa, equals(true));
|
|
expect(result.pendingFlow!.supportsRecoveryCodes, equals(true));
|
|
});
|
|
|
|
test("Unsupported MFA types", () {
|
|
final flow = AuthFlow.fromJson({
|
|
"id": "mfa_authenticate",
|
|
"is_pending": true,
|
|
"types": ["webauthn"],
|
|
});
|
|
|
|
expect(flow.isSupportedMfa, equals(false));
|
|
});
|
|
|
|
test("Invalid credentials", () {
|
|
final result = AuthResult.fromResponse(
|
|
response(400, {
|
|
"status": 400,
|
|
"errors": [
|
|
{
|
|
"message":
|
|
"The username and/or password you specified are not correct.",
|
|
"code": "username_password_mismatch",
|
|
},
|
|
],
|
|
}),
|
|
);
|
|
|
|
expect(result.status, equals(AuthStatus.failed));
|
|
expect(result.errorMessage, contains("not correct"));
|
|
});
|
|
|
|
test("Not authenticated, no pending flow", () {
|
|
final result = AuthResult.fromResponse(
|
|
response(401, {
|
|
"status": 401,
|
|
"data": {
|
|
"flows": [
|
|
{"id": "login"},
|
|
],
|
|
},
|
|
"meta": {"is_authenticated": false},
|
|
}),
|
|
);
|
|
|
|
expect(result.status, equals(AuthStatus.failed));
|
|
});
|
|
|
|
test("No response", () {
|
|
final result = AuthResult.fromResponse(APIResponse());
|
|
|
|
expect(result.status, equals(AuthStatus.failed));
|
|
expect(result.statusCode, equals(-1));
|
|
});
|
|
|
|
test("Config", () {
|
|
final config = AuthConfig.fromResponse(
|
|
response(200, {
|
|
"status": 200,
|
|
"data": {
|
|
"account": {
|
|
"login_methods": ["email"],
|
|
},
|
|
"mfa": {
|
|
"supported_types": ["totp", "recovery_codes", "webauthn"],
|
|
},
|
|
"socialaccount": {
|
|
"providers": [
|
|
{
|
|
"id": "google",
|
|
"name": "Google",
|
|
"flows": ["provider_redirect", "provider_token"],
|
|
"client_id": "123.apps.googleusercontent.com",
|
|
},
|
|
],
|
|
},
|
|
},
|
|
}),
|
|
);
|
|
|
|
expect(config.loginField, equals("email"));
|
|
expect(config.mfaTypes.length, equals(3));
|
|
expect(config.providers.first.supportsTokenLogin, equals(true));
|
|
|
|
// Fallback to username for an invalid response
|
|
expect(AuthConfig.fromResponse(APIResponse()).loginField, "username");
|
|
});
|
|
});
|
|
|
|
group("UserProfile session storage:", () {
|
|
test("Save, load and clear", () async {
|
|
final manager = UserProfileDBManager();
|
|
|
|
final profile = UserProfile(name: "Session Test", server: server);
|
|
await manager.addProfile(profile);
|
|
|
|
final session = SessionStore(server: server);
|
|
session.capture(serverUri, [_cookie(SESSION_COOKIE_NAME, "abc")]);
|
|
|
|
await manager.saveSession(profile, session);
|
|
|
|
final loaded = await manager.getProfileByName("Session Test");
|
|
expect(loaded!.hasSession, equals(true));
|
|
expect((await manager.loadSession(loaded)).hasSession, equals(true));
|
|
|
|
// The session must never be stored in the plain profile record
|
|
expect(loaded.toJson().toString(), isNot(contains("abc")));
|
|
|
|
await manager.clearSession(loaded);
|
|
expect((await manager.loadSession(loaded)).hasSession, equals(false));
|
|
|
|
await manager.deleteProfile(loaded);
|
|
});
|
|
|
|
test("Legacy API tokens are removed", () async {
|
|
final manager = UserProfileDBManager();
|
|
final db = await InvenTreePreferencesDB.instance.database;
|
|
const storage = FlutterSecureStorage();
|
|
|
|
// Profile as stored by an older version of the app
|
|
final int key =
|
|
(await manager.store.add(db, {
|
|
"name": "Legacy Profile",
|
|
"server": server,
|
|
"token": "legacy-plaintext-token",
|
|
}))!
|
|
as int;
|
|
|
|
await storage.write(key: "profile_token_${key}", value: "legacy-token");
|
|
|
|
await InvenTreeSettingsManager().setValue("legacy_tokens_removed", false);
|
|
await manager.migrateLegacyTokens();
|
|
|
|
expect(await storage.read(key: "profile_token_${key}"), isNull);
|
|
|
|
final record = (await manager.store.record(key).get(db))! as Map;
|
|
expect(record.containsKey("token"), equals(false));
|
|
expect(record["name"], equals("Legacy Profile"));
|
|
|
|
await manager.store.record(key).delete(db);
|
|
});
|
|
|
|
test("Legacy token migration retries after a storage failure", () async {
|
|
final manager = UserProfileDBManager();
|
|
final db = await InvenTreePreferencesDB.instance.database;
|
|
const storage = FlutterSecureStorage();
|
|
|
|
final List<int> keys = [];
|
|
|
|
for (final name in ["Legacy Retry A", "Legacy Retry B"]) {
|
|
keys.add(
|
|
(await manager.store.add(db, {
|
|
"name": name,
|
|
"server": server,
|
|
"token": "legacy-plaintext-token",
|
|
}))!
|
|
as int,
|
|
);
|
|
}
|
|
|
|
for (final key in keys) {
|
|
await storage.write(key: "profile_token_${key}", value: "legacy-token");
|
|
}
|
|
|
|
await InvenTreeSettingsManager().setValue("legacy_tokens_removed", false);
|
|
|
|
// Secure storage deletion fails
|
|
secureStorageFailures.add("delete");
|
|
|
|
try {
|
|
await manager.migrateLegacyTokens();
|
|
} finally {
|
|
secureStorageFailures.clear();
|
|
}
|
|
|
|
// Migration is not marked complete, so runs again on next startup
|
|
expect(
|
|
await InvenTreeSettingsManager().getBool(
|
|
"legacy_tokens_removed",
|
|
false,
|
|
),
|
|
equals(false),
|
|
);
|
|
|
|
// Plaintext tokens are still stripped from *all* profiles in the meantime
|
|
for (final key in keys) {
|
|
final record = (await manager.store.record(key).get(db))! as Map;
|
|
expect(record.containsKey("token"), equals(false));
|
|
expect(await storage.read(key: "profile_token_${key}"), isNotNull);
|
|
}
|
|
|
|
// Next startup - storage is available again
|
|
await manager.migrateLegacyTokens();
|
|
|
|
for (final key in keys) {
|
|
expect(await storage.read(key: "profile_token_${key}"), isNull);
|
|
}
|
|
|
|
expect(
|
|
await InvenTreeSettingsManager().getBool(
|
|
"legacy_tokens_removed",
|
|
false,
|
|
),
|
|
equals(true),
|
|
);
|
|
|
|
for (final key in keys) {
|
|
await manager.store.record(key).delete(db);
|
|
}
|
|
});
|
|
|
|
test("Startup cleanup removes legacy tokens for existing profiles", () async {
|
|
final manager = UserProfileDBManager();
|
|
const storage = FlutterSecureStorage();
|
|
|
|
final profile = UserProfile(name: "Legacy Cleanup", server: server);
|
|
await manager.addProfile(profile);
|
|
|
|
final loaded = (await manager.getProfileByName("Legacy Cleanup"))!;
|
|
|
|
// Token left behind for an existing profile (e.g. migration could not remove it)
|
|
await storage.write(
|
|
key: "profile_token_${loaded.key}",
|
|
value: "legacy-token",
|
|
);
|
|
|
|
// ... alongside the profile's (valid) session
|
|
final session = SessionStore(server: server);
|
|
session.capture(serverUri, [_cookie(SESSION_COOKIE_NAME, "abc")]);
|
|
await manager.saveSession(loaded, session);
|
|
|
|
// Token for a profile which no longer exists
|
|
await storage.write(key: "profile_token_99998", value: "legacy-token");
|
|
|
|
await manager.removeOrphanedSessions();
|
|
|
|
expect(await storage.read(key: "profile_token_${loaded.key}"), isNull);
|
|
expect(await storage.read(key: "profile_token_99998"), isNull);
|
|
|
|
// The session for the existing profile is retained
|
|
expect((await manager.loadSession(loaded)).hasSession, equals(true));
|
|
|
|
await manager.deleteProfile(loaded);
|
|
});
|
|
|
|
test("Logout keeps the username", () async {
|
|
final manager = UserProfileDBManager();
|
|
|
|
final profile = UserProfile(
|
|
name: "Username Test",
|
|
server: server,
|
|
username: "alice",
|
|
);
|
|
await manager.addProfile(profile);
|
|
|
|
final session = SessionStore(server: server);
|
|
session.capture(serverUri, [_cookie(SESSION_COOKIE_NAME, "abc")]);
|
|
await manager.saveSession(profile, session);
|
|
|
|
await InvenTreeAuth().logout(profile);
|
|
|
|
final loaded = await manager.getProfileByName("Username Test");
|
|
expect(loaded!.username, equals("alice"));
|
|
expect(loaded.hasSession, equals(false));
|
|
|
|
// The password is never part of the profile
|
|
expect(loaded.toJson().keys, isNot(contains("password")));
|
|
|
|
await manager.deleteProfile(loaded);
|
|
});
|
|
|
|
test("Orphaned sessions are removed", () async {
|
|
final manager = UserProfileDBManager();
|
|
const storage = FlutterSecureStorage();
|
|
|
|
final profile = UserProfile(name: "Orphan Test", server: server);
|
|
await manager.addProfile(profile);
|
|
|
|
final session = SessionStore(server: server);
|
|
session.capture(serverUri, [_cookie(SESSION_COOKIE_NAME, "abc")]);
|
|
await manager.saveSession(profile, session);
|
|
|
|
// Left behind by a profile which no longer exists (e.g. before a reinstall)
|
|
await storage.write(key: "profile_session_99999", value: "[]");
|
|
await storage.write(key: "profile_token_99999", value: "legacy-token");
|
|
|
|
// Unrelated entries are not touched
|
|
await storage.write(key: "other_value", value: "keep");
|
|
|
|
await manager.removeOrphanedSessions();
|
|
|
|
expect(await storage.read(key: "profile_session_99999"), isNull);
|
|
expect(await storage.read(key: "profile_token_99999"), isNull);
|
|
expect(await storage.read(key: "other_value"), equals("keep"));
|
|
expect((await manager.loadSession(profile)).hasSession, equals(true));
|
|
|
|
await storage.delete(key: "other_value");
|
|
await manager.deleteProfile(profile);
|
|
});
|
|
});
|
|
}
|