nest-supabase-guard
Version:
Auth guard for NestJS using supabase
130 lines • 6.54 kB
JavaScript
;
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
Object.defineProperty(exports, "__esModule", { value: true });
const common_1 = require("@nestjs/common");
const supabase_js_1 = require("@supabase/supabase-js");
const supabase_auth_guard_1 = require("./supabase-auth.guard");
jest.mock("@supabase/supabase-js", () => {
return {
SupabaseClient: jest.fn().mockImplementation(() => ({
auth: {
getUser: jest.fn(),
},
})),
};
});
describe("SupabaseAuthGuard", () => {
let guard;
let mockSupabaseClient;
let mockExecutionContext;
let mockRequest;
beforeEach(() => {
mockSupabaseClient = new supabase_js_1.SupabaseClient("test", "test");
guard = new supabase_auth_guard_1.SupabaseAuthGuard(mockSupabaseClient);
mockRequest = {
headers: {},
};
mockExecutionContext = {
switchToHttp: jest.fn().mockReturnValue({
getRequest: jest.fn().mockReturnValue(mockRequest),
}),
};
});
describe("canActivate", () => {
it("should return true if authentication is successful", () => __awaiter(void 0, void 0, void 0, function* () {
mockRequest.headers.authorization = "Bearer valid-token";
guard.authenticateRequest = jest
.fn()
.mockResolvedValueOnce({ user: "test-user" });
const result = yield guard.canActivate(mockExecutionContext);
expect(result).toBeTruthy();
}));
it("should attach token user to request if authentication is successful", () => __awaiter(void 0, void 0, void 0, function* () {
mockRequest.headers.authorization = "Bearer valid-token";
const expectedUser = { user: "test-user" };
guard.authenticateRequest = jest.fn().mockResolvedValueOnce(expectedUser);
yield guard.canActivate(mockExecutionContext);
expect(mockRequest.authUser).toEqual(expectedUser);
}));
});
describe("authenticateRequest", () => {
it("should return a user for a valid token", () => __awaiter(void 0, void 0, void 0, function* () {
const validToken = "valid-token";
const expectedUser = { id: "test-id", email: "test-email" };
mockRequest.headers.authorization = `Bearer ${validToken}`;
mockSupabaseClient.auth.getUser.mockResolvedValueOnce({
data: { user: expectedUser },
error: null,
});
const user = yield guard.authenticateRequest(mockRequest);
expect(user).toEqual(expectedUser);
}));
it("should throw UnauthorizedException if no token provided", () => __awaiter(void 0, void 0, void 0, function* () {
mockRequest.headers.authorization = "";
yield expect(guard.authenticateRequest(mockRequest)).rejects.toThrow(common_1.UnauthorizedException);
}));
it("should throw UnauthorizedException for an invalid token", () => __awaiter(void 0, void 0, void 0, function* () {
const invalidToken = "invalid-token";
mockRequest.headers.authorization = `Bearer ${invalidToken}`;
mockSupabaseClient.auth.getUser.mockResolvedValueOnce({
data: { user: null },
error: { message: "Invalid token" },
});
yield expect(guard.authenticateRequest(mockRequest)).rejects.toThrow(common_1.UnauthorizedException);
}));
});
describe("extractTokenFromHeader", () => {
it("should extract token from bearer authorization header", () => {
const validToken = "valid-token";
mockRequest.headers.authorization = `Bearer ${validToken}`;
const token = guard.extractTokenFromHeader(mockRequest);
expect(token).toBe(validToken);
});
it("should return undefined if authorization type is not Bearer", () => {
const token = "some-token";
mockRequest.headers.authorization = `Basic ${token}`;
const extractedToken = guard.extractTokenFromHeader(mockRequest);
expect(extractedToken).toBeUndefined();
});
it("should return undefined if token is 'undefined'", () => {
mockRequest.headers.authorization = "Bearer undefined";
const extractedToken = guard.extractTokenFromHeader(mockRequest);
expect(extractedToken).toBeUndefined();
});
it("should return undefined if no authorization header is present", () => {
delete mockRequest.headers.authorization;
const extractedToken = guard.extractTokenFromHeader(mockRequest);
expect(extractedToken).toBeUndefined();
});
});
describe("getUserFromJWT", () => {
it("should return a user for a valid JWT", () => __awaiter(void 0, void 0, void 0, function* () {
const validToken = "valid-token";
const expectedUser = { id: "test-id", email: "test-email" };
mockSupabaseClient.auth.getUser.mockResolvedValueOnce({
data: { user: expectedUser },
error: null,
});
const userResult = yield guard.getUserFromJWT(validToken);
expect(userResult).toEqual(expectedUser);
}));
it("should throw error if no user found in JWT", () => __awaiter(void 0, void 0, void 0, function* () {
const invalidToken = "invalid-token";
mockSupabaseClient.auth.getUser.mockResolvedValueOnce({
data: { user: {} },
error: null,
});
const userResult = yield guard.getUserFromJWT(invalidToken);
yield expect(guard.getUserFromJWT(invalidToken)).rejects.toThrow();
}));
});
});
//# sourceMappingURL=supabase-auth.guard.spec.js.map