gsadmin/headplane
1
0
Fork 0
mirror of https://github.com/tale/headplane.git synced 2026-08-30 08:49:30 +00:00
Code Issues Packages Projects Releases Wiki Activity

chore: fix some test issues

Browse Source
This commit is contained in:
Aarnav Tale
2026-02-08 11:11:44 -05:00
parent 0b8ae8fa2d
commit 0080cddb55
3 changed files with 121 additions and 145 deletions
Download Patch File Download Diff File Expand all files Collapse all files
app/server/headscale/api/endpoints/nodes.ts
+5
View File
@@ -156,6 +156,11 @@ export default defineApiEndpoints<NodeEndpoints>((client, apiKey) => ({
}, },
setNodeUser: async (nodeId, user) => { setNodeUser: async (nodeId, user) => {
// Headscale 0.28.0 got rid of node reassignment to users
if (client.isAtleast("0.28.0")) {
return;
}
await client.apiFetch<void>("POST", `v1/node/${nodeId}/user`, apiKey, { await client.apiFetch<void>("POST", `v1/node/${nodeId}/user`, apiKey, {
user, user,
}); });
tests/integration/nodes.test.ts
+62 -58
View File
@@ -1,72 +1,76 @@
import { describe, expect, test } from 'vitest'; import { describe, expect, test } from "vitest";
import { getNode, getRuntimeClient, getIsAtLeast, HS_VERSIONS } from './setup/env';
describe.sequential.for(HS_VERSIONS)('Headscale %s: Users', (version) => { import { getBootstrapClient, getNode, getRuntimeClient, HS_VERSIONS } from "./setup/env";
let workingNodeId: string;
test('nodes can register via their nodekey', async () => { describe.sequential.for(HS_VERSIONS)("Headscale %s: Users", (version) => {
const client = await getRuntimeClient(version); let workingNodeId: string;
const tailnetNode = await getNode(version);
const user = await client.createUser('node-reg@'); test("nodes can register via their nodekey", async () => {
const node = await client.registerNode(user.name, tailnetNode.authCode); const client = await getRuntimeClient(version);
expect(node).toBeDefined(); const tailnetNode = await getNode(version);
expect(node.registerMethod).toBe('REGISTER_METHOD_CLI');
expect(node.name).toBe(tailnetNode.nodeName);
});
test('nodes can be retrieved', async () => { const user = await client.createUser("node-reg@");
const client = await getRuntimeClient(version); const node = await client.registerNode(user.name, tailnetNode.authCode);
const { nodeName } = await getNode(version); expect(node).toBeDefined();
const nodes = await client.getNodes(); expect(node.registerMethod).toBe("REGISTER_METHOD_CLI");
const node = nodes.find((n) => n.name === nodeName); expect(node.name).toBe(tailnetNode.nodeName);
expect(node).toBeDefined(); });
expect(node?.name).toBe(nodeName);
const fetchedNode = await client.getNode(node!.id); test("nodes can be retrieved", async () => {
expect(fetchedNode).toBeDefined(); const client = await getRuntimeClient(version);
expect(fetchedNode.id).toBe(node!.id); const { nodeName } = await getNode(version);
workingNodeId = node!.id; const nodes = await client.getNodes();
}); const node = nodes.find((n) => n.name === nodeName);
expect(node).toBeDefined();
expect(node?.name).toBe(nodeName);
test('nodes can be renamed', async () => { const fetchedNode = await client.getNode(node!.id);
const client = await getRuntimeClient(version); expect(fetchedNode).toBeDefined();
const { nodeName } = await getNode(version); expect(fetchedNode.id).toBe(node!.id);
const newName = `${nodeName}-renamed`; workingNodeId = node!.id;
});
await client.renameNode(workingNodeId, newName); test("nodes can be renamed", async () => {
const renamedNode = await client.getNode(workingNodeId); const client = await getRuntimeClient(version);
expect(renamedNode).toBeDefined(); const { nodeName } = await getNode(version);
expect(renamedNode.givenName).toBe(newName); const newName = `${nodeName}-renamed`;
});
test('nodes can be reassigned to another user', async () => { await client.renameNode(workingNodeId, newName);
if (! getIsAtLeast("0.28.0")) { const renamedNode = await client.getNode(workingNodeId);
const client = await getRuntimeClient(version); expect(renamedNode).toBeDefined();
const user = await client.createUser('node-reassign@'); expect(renamedNode.givenName).toBe(newName);
});
await client.setNodeUser(workingNodeId, user.id); test("nodes can be reassigned to another user", async (context) => {
const reassignedNode = await client.getNode(workingNodeId); const bootstrap = await getBootstrapClient(version);
expect(reassignedNode).toBeDefined(); if (bootstrap.clientHelpers.isAtleast("0.28.0")) {
expect(reassignedNode.user.name).toBe(user.name); context.skip();
} }
});
test('nodes can be expired', async () => { const client = await getRuntimeClient(version);
const client = await getRuntimeClient(version); const user = await client.createUser("node-reassign@");
await client.expireNode(workingNodeId);
const expiredNode = await client.getNode(workingNodeId); await client.setNodeUser(workingNodeId, user.id);
expect(expiredNode).toBeDefined(); const reassignedNode = await client.getNode(workingNodeId);
expect(expiredNode.expiry).toBeDefined(); expect(reassignedNode).toBeDefined();
}); expect(reassignedNode.user.name).toBe(user.name);
});
test('nodes can be deleted', async () => { test("nodes can be expired", async () => {
const client = await getRuntimeClient(version); const client = await getRuntimeClient(version);
await client.deleteNode(workingNodeId); await client.expireNode(workingNodeId);
const nodes = await client.getNodes(); const expiredNode = await client.getNode(workingNodeId);
const node = nodes.find((n) => n.id === workingNodeId); expect(expiredNode).toBeDefined();
expect(node).toBeUndefined(); expect(expiredNode.expiry).toBeDefined();
}); });
test("nodes can be deleted", async () => {
const client = await getRuntimeClient(version);
await client.deleteNode(workingNodeId);
const nodes = await client.getNodes();
const node = nodes.find((n) => n.id === workingNodeId);
expect(node).toBeUndefined();
});
}); });
tests/integration/pre-auth-keys.test.ts
+54 -87
View File
@@ -1,99 +1,66 @@
import { describe, expect, test } from 'vitest'; import { describe, expect, test } from "vitest";
import { getRuntimeClient, HS_VERSIONS } from './setup/env';
describe.sequential.for(HS_VERSIONS)( import { getRuntimeClient, HS_VERSIONS } from "./setup/env";
'Headscale %s: Pre-auth Keys',
(version) => {
test('pre-auth keys can be created', async () => {
const client = await getRuntimeClient(version);
const preAuthKeyUser = await client.createUser('preauthkeyuser@');
expect(preAuthKeyUser).toBeDefined();
expect(preAuthKeyUser.name).toBe('preauthkeyuser@');
const expiry = new Date(Date.now() + 3600 * 1000); describe.sequential.for(HS_VERSIONS)("Headscale %s: Pre-auth Keys", (version) => {
const preAuthKey = await client.createPreAuthKey( test("pre-auth keys can be created", async () => {
preAuthKeyUser.id, const client = await getRuntimeClient(version);
false, const preAuthKeyUser = await client.createUser("preauthkeyuser@");
false, expect(preAuthKeyUser).toBeDefined();
expiry, expect(preAuthKeyUser.name).toBe("preauthkeyuser@");
null,
);
expect(preAuthKey).toBeDefined(); const expiry = new Date(Date.now() + 3600 * 1000);
expect(preAuthKey.user.id).toBe(preAuthKeyUser.id); const preAuthKey = await client.createPreAuthKey(preAuthKeyUser.id, false, false, expiry, null);
expect(preAuthKey.ephemeral).toBe(false);
expect(preAuthKey.reusable).toBe(false);
expect(preAuthKey.aclTags).toEqual([]);
expect(new Date(preAuthKey.expiration).getTime()).toBeCloseTo(
expiry.getTime(),
-2,
);
});
test('pre-auth keys can be created with ACL tags', async () => { expect(preAuthKey).toBeDefined();
const client = await getRuntimeClient(version); expect(preAuthKey.user.id).toBe(preAuthKeyUser.id);
const [preAuthKeyUser] = await client.getUsers( expect(preAuthKey.ephemeral).toBe(false);
undefined, expect(preAuthKey.reusable).toBe(false);
'preauthkeyuser@', expect(preAuthKey.aclTags).toEqual([]);
); expect(new Date(preAuthKey.expiration).getTime()).toBeCloseTo(expiry.getTime(), -2);
expect(preAuthKeyUser).toBeDefined(); });
expect(preAuthKeyUser.name).toBe('preauthkeyuser@');
const aclTags = ['tag:test1', 'tag:test2']; test("pre-auth keys can be created with ACL tags", async () => {
const preAuthKey = await client.createPreAuthKey( const client = await getRuntimeClient(version);
preAuthKeyUser.id, const [preAuthKeyUser] = await client.getUsers(undefined, "preauthkeyuser@");
true, expect(preAuthKeyUser).toBeDefined();
true, expect(preAuthKeyUser.name).toBe("preauthkeyuser@");
null,
aclTags,
);
expect(preAuthKey).toBeDefined(); const aclTags = ["tag:test1", "tag:test2"];
expect(preAuthKey.user.id).toBe(preAuthKeyUser.id); const preAuthKey = await client.createPreAuthKey(preAuthKeyUser.id, true, true, null, aclTags);
expect(preAuthKey.ephemeral).toBe(true);
expect(preAuthKey.reusable).toBe(true);
expect(preAuthKey.aclTags.sort()).toEqual(aclTags.sort());
});
test('pre-auth keys can be listed', async () => { expect(preAuthKey).toBeDefined();
const client = await getRuntimeClient(version); expect(preAuthKey.user.id).toBe(preAuthKeyUser.id);
const [preAuthKeyUser] = await client.getUsers( expect(preAuthKey.ephemeral).toBe(true);
undefined, expect(preAuthKey.reusable).toBe(true);
'preauthkeyuser@', expect(preAuthKey.aclTags.sort()).toEqual(aclTags.sort());
); });
expect(preAuthKeyUser).toBeDefined();
expect(preAuthKeyUser.name).toBe('preauthkeyuser@');
const preAuthKeys = await client.getPreAuthKeys(preAuthKeyUser.id); test("pre-auth keys can be listed", async () => {
expect(Array.isArray(preAuthKeys)).toBe(true); const client = await getRuntimeClient(version);
expect(preAuthKeys.length).toBeGreaterThanOrEqual(2); const [preAuthKeyUser] = await client.getUsers(undefined, "preauthkeyuser@");
}); expect(preAuthKeyUser).toBeDefined();
expect(preAuthKeyUser.name).toBe("preauthkeyuser@");
test('pre-auth keys can be expired', async () => { const preAuthKeys = await client.getPreAuthKeys(preAuthKeyUser.id);
const client = await getRuntimeClient(version); expect(Array.isArray(preAuthKeys)).toBe(true);
const [preAuthKeyUser] = await client.getUsers( expect(preAuthKeys.length).toBeGreaterThanOrEqual(2);
undefined, });
'preauthkeyuser@',
);
expect(preAuthKeyUser).toBeDefined();
expect(preAuthKeyUser.name).toBe('preauthkeyuser@');
const preAuthKeys = await client.getPreAuthKeys(preAuthKeyUser.id); test("pre-auth keys can be expired", async () => {
expect(preAuthKeys.length).toBeGreaterThanOrEqual(2); const client = await getRuntimeClient(version);
const preAuthKeyToExpire = preAuthKeys[0]; const [preAuthKeyUser] = await client.getUsers(undefined, "preauthkeyuser@");
expect(preAuthKeyUser).toBeDefined();
expect(preAuthKeyUser.name).toBe("preauthkeyuser@");
await client.expirePreAuthKey(preAuthKeyUser.id, preAuthKeyToExpire.key); const preAuthKeys = await client.getPreAuthKeys(preAuthKeyUser.id);
expect(preAuthKeys.length).toBeGreaterThanOrEqual(2);
const preAuthKeyToExpire = preAuthKeys[0];
const preAuthKeysAfterExpire = await client.getPreAuthKeys( await client.expirePreAuthKey(preAuthKeyUser.id, preAuthKeyToExpire.key);
preAuthKeyUser.id,
); const preAuthKeysAfterExpire = await client.getPreAuthKeys(preAuthKeyUser.id);
const expiredKey = preAuthKeysAfterExpire.find( const expiredKey = preAuthKeysAfterExpire.find((key) => key.key === preAuthKeyToExpire.key);
(key) => key.key === preAuthKeyToExpire.key, expect(expiredKey).toBeDefined();
); });
expect(expiredKey).toBeDefined(); });
expect(new Date(expiredKey!.expiration).getTime()).toBeLessThanOrEqual(
Date.now(),
);
});
},
);