Skip to content
Merged
Show file tree
Hide file tree
Changes from 3 commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
40 changes: 40 additions & 0 deletions packages/frontend/src/components/ComputePanel.test.tsx
Original file line number Diff line number Diff line change
@@ -0,0 +1,40 @@
import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
import { render, screen, waitFor } from "@testing-library/react";
import userEvent from "@testing-library/user-event";
import { expect, test, vi } from "vitest";
import { ComputePanel } from "./ComputePanel";
import { describeEc2Instance, updateEc2InstanceTags } from "@/api/aws/ec2.api";

vi.mock("@/api/aws/ec2.api", async (importOriginal) => ({
...await importOriginal<typeof import("@/api/aws/ec2.api")>(),
describeEc2Instance: vi.fn(),
updateEc2InstanceTags: vi.fn(),
}));

test("the console protects system tags and refreshes after saving an ordinary tag", async () => {
vi.mocked(describeEc2Instance).mockResolvedValue({
instanceId: "i-test", name: "test", state: "running", instanceType: "t3.nano",
tags: [{ key: "aws:autoscaling:groupName", value: "group" }, { key: "Name", value: "before" }],
securityGroups: [],
});
vi.mocked(updateEc2InstanceTags).mockResolvedValue(undefined);
const client = new QueryClient({ defaultOptions: { queries: { retry: false } } });
const user = userEvent.setup();
render(<QueryClientProvider client={client}>
<ComputePanel cloud="aws" runtimeReachable resource={{
id: "i-test", name: "test", cloud: "aws", service: "compute", type: "instance",
region: "us-east-1", createdAt: null, metadata: {},
}} />
</QueryClientProvider>);
await user.click(await screen.findByRole("button", { name: "Tags" }));
expect(screen.getByDisplayValue("aws:autoscaling:groupName")).toHaveAttribute("readonly");
expect(screen.getByDisplayValue("group")).toHaveAttribute("readonly");
expect(screen.getAllByRole("button", { name: "Remove" })).toHaveLength(1);
await user.clear(screen.getByDisplayValue("before"));
await user.type(screen.getByPlaceholderText("Value"), "after");
await user.click(screen.getByRole("button", { name: "Save tags" }));
await waitFor(() => expect(updateEc2InstanceTags).toHaveBeenCalledWith(
"i-test", [{ key: "Name", value: "after" }], [],
));
await waitFor(() => expect(describeEc2Instance).toHaveBeenCalledTimes(2));
});
77 changes: 2 additions & 75 deletions packages/frontend/src/components/ComputePanel.tsx
Original file line number Diff line number Diff line change
Expand Up @@ -9,7 +9,6 @@ import {
Power,
RefreshCw,
RotateCcw,
Save,
Terminal,
Trash2,
X,
Expand All @@ -30,7 +29,6 @@ import {
startEc2Instance,
stopEc2Instance,
terminateEc2Instance,
updateEc2InstanceTags,
type Ec2Image,
type Ec2KeyPair,
type Ec2SecurityGroup,
Expand All @@ -42,6 +40,7 @@ import {
import { createCloudResource } from '@/api/cloudProxyClient'
import type { CloudProvider } from '@/types/cloud'
import type { CloudResource } from '@/types/resource'
import { TagEditor } from '@/features/ec2/TagEditor'

// ─── Props ────────────────────────────────────────────────────────────────────

Expand All @@ -65,78 +64,6 @@ function stateClass(state?: string): string {
}
}

// ─── Tag editor (inline) ──────────────────────────────────────────────────────

function InlineTagEditor({ instanceId, initialTags }: { instanceId: string; initialTags: Ec2Tag[] }) {
const qc = useQueryClient()
const [rows, setRows] = useState<Ec2Tag[]>(initialTags)
const [err, setErr] = useState('')

const mutation = useMutation({
mutationFn: ({ toAdd, toRemove }: { toAdd: Ec2Tag[]; toRemove: string[] }) =>
updateEc2InstanceTags(instanceId, toAdd, toRemove),
onSuccess: () => {
void qc.invalidateQueries({ queryKey: ['ec2', 'instance', instanceId] })
void qc.invalidateQueries({ queryKey: ['ec2', 'instances'] })
},
onError: (e) => setErr(e instanceof Error ? e.message : 'Save failed'),
})

function addRow() { setRows((prev) => [...prev, { key: '', value: '' }]) }
function removeRow(idx: number) { setRows((prev) => prev.filter((_, i) => i !== idx)) }
function setKey(idx: number, key: string) { setRows((prev) => prev.map((r, i) => i === idx ? { ...r, key } : r)) }
function setValue(idx: number, value: string) { setRows((prev) => prev.map((r, i) => i === idx ? { ...r, value } : r)) }

function handleSave() {
const newTags = rows.filter((r) => r.key.trim())
const newKeys = new Set(newTags.map((t) => t.key))
const oldKeys = new Set(initialTags.map((t) => t.key))
const toAdd = newTags.filter((t) => !oldKeys.has(t.key) || initialTags.find((ot) => ot.key === t.key)?.value !== t.value)
const toRemove = initialTags.map((t) => t.key).filter((k) => !newKeys.has(k))
setErr('')
mutation.mutate({ toAdd, toRemove })
}

return (
<div>
<div style={{ display: 'flex', flexDirection: 'column', gap: 4, marginBottom: 8 }}>
{rows.map((tag, idx) => (
<div key={idx} className="field-row" style={{ gap: 4 }}>
<input
className="input"
placeholder="Key"
value={tag.key}
onChange={(e) => setKey(idx, e.target.value)}
style={{ flex: 1 }}
/>
<input
className="input"
placeholder="Value"
value={tag.value}
onChange={(e) => setValue(idx, e.target.value)}
style={{ flex: 2 }}
/>
<button className="icon-btn danger" onClick={() => removeRow(idx)} title="Remove">
<Trash2 size={12} />
</button>
</div>
))}
</div>
{err && <p style={{ fontSize: 11, color: 'var(--status-error)', margin: '0 0 6px' }}>{err}</p>}
<div style={{ display: 'flex', gap: 6 }}>
<button className="button compact" onClick={addRow}>
<Plus size={12} />
Add tag
</button>
<button className="button compact primary" onClick={handleSave} disabled={mutation.isPending}>
{mutation.isPending ? <Loader2 size={12} /> : <Save size={12} />}
Save tags
</button>
</div>
</div>
)
}

// ─── Create AMI modal (inline) ────────────────────────────────────────────────

function CreateAmiModal({ instanceId, instanceName, onClose, onCreated }: {
Expand Down Expand Up @@ -576,7 +503,7 @@ function InstancePanel({ instanceId }: { instanceId: string }) {
)}

{tab === 'tags' && (
<InlineTagEditor instanceId={instanceId} initialTags={inst.tags} />
<TagEditor key={instanceId} instanceId={instanceId} initialTags={inst.tags} />
)}

{tab === 'console' && (
Expand Down
75 changes: 75 additions & 0 deletions packages/frontend/src/features/ec2/TagEditor.test.tsx
Original file line number Diff line number Diff line change
@@ -0,0 +1,75 @@
import { render, screen } from "@testing-library/react";
import userEvent from "@testing-library/user-event";
import { beforeEach, expect, test, vi } from "vitest";
import { TagEditor } from "./TagEditor";

const { mutate } = vi.hoisted(() => ({ mutate: vi.fn() }));
vi.mock("@/api/aws/ec2.mutations", () => ({
useUpdateEc2InstanceTagsMutation: () => ({ mutate, isPending: false }),
}));

beforeEach(() => mutate.mockClear());

test("shows AWS-owned tags read-only and saves only user tag changes", async () => {
render(<TagEditor instanceId="i-test" initialTags={[
{ key: "aws:autoscaling:groupName", value: "group" },
{ key: "AWS:other", value: "managed" },
{ key: "Name", value: "old" },
{ key: "remove-me", value: "old" },
]} />);
const user = userEvent.setup();
expect(screen.getByDisplayValue("aws:autoscaling:groupName")).toHaveAttribute("readonly");
expect(screen.getByDisplayValue("group")).toHaveAttribute("readonly");
expect(screen.getByDisplayValue("AWS:other")).toHaveAttribute("readonly");
expect(screen.getAllByRole("button", { name: "Remove" })).toHaveLength(2);
await user.clear(screen.getAllByPlaceholderText("Value")[0]);
await user.type(screen.getAllByPlaceholderText("Value")[0], "updated");
await user.click(screen.getAllByRole("button", { name: "Remove" })[1]);
await user.click(screen.getByRole("button", { name: "Save tags" }));
expect(mutate).toHaveBeenCalledWith({
instanceId: "i-test", toAdd: [{ key: "Name", value: "updated" }], toRemove: ["remove-me"],
}, expect.anything());
});

test.each(["aws:custom", "AWS:custom", "aWs:custom"])("rejects a new reserved key %s without locking its input", async (key) => {
render(<TagEditor instanceId="i-test" initialTags={[]} />);
const user = userEvent.setup();
await user.click(screen.getByRole("button", { name: "Add tag" }));
await user.type(screen.getByPlaceholderText("Key"), key);
await user.click(screen.getByRole("button", { name: "Save tags" }));
expect(screen.getByText("Tag keys starting with 'aws:' are reserved for AWS.")).toBeVisible();
expect(mutate).not.toHaveBeenCalled();
await user.clear(screen.getByPlaceholderText("Key"));
await user.type(screen.getByPlaceholderText("Key"), "Name");
await user.click(screen.getByRole("button", { name: "Save tags" }));
expect(mutate).toHaveBeenCalledWith({
instanceId: "i-test", toAdd: [{ key: "Name", value: "" }], toRemove: [],
}, expect.anything());
});
test("keeps unsaved edits on refresh and does not delete externally added tags", async () => {
const { rerender } = render(<TagEditor instanceId="i-test" initialTags={[
{ key: "aws:autoscaling:groupName", value: "group-a" },
{ key: "Name", value: "before" },
]} />);
const user = userEvent.setup();
await user.clear(screen.getByDisplayValue("before"));
await user.type(screen.getByPlaceholderText("Value"), "draft");
rerender(<TagEditor instanceId="i-test" initialTags={[
{ key: "aws:autoscaling:groupName", value: "group-b" },
{ key: "Name", value: "external" },
{ key: "External", value: "keep" },
]} />);
expect(screen.getByDisplayValue("draft")).toBeVisible();
expect(screen.getByDisplayValue("group-b")).toHaveAttribute("readonly");
await user.click(screen.getByRole("button", { name: "Save tags" }));
expect(mutate).toHaveBeenCalledWith({
instanceId: "i-test", toAdd: [{ key: "Name", value: "draft" }], toRemove: [],
}, expect.anything());
});

test("refreshes pristine rows without starting a draft", () => {
const { rerender } = render(<TagEditor instanceId="i-test" initialTags={[{ key: "Name", value: "before" }]} />);
rerender(<TagEditor instanceId="i-test" initialTags={[{ key: "Name", value: "after" }]} />);
expect(screen.getByDisplayValue("after")).toBeVisible();
expect(screen.queryByDisplayValue("before")).not.toBeInTheDocument();
});
42 changes: 33 additions & 9 deletions packages/frontend/src/features/ec2/TagEditor.tsx
Original file line number Diff line number Diff line change
@@ -1,4 +1,4 @@
import { useEffect, useState } from "react";
import { useState } from "react";
import { Loader2, Plus, Save, Trash2 } from "lucide-react";
import { useUpdateEc2InstanceTagsMutation } from "@/api/aws/ec2.mutations";
import type { Ec2Tag } from "@/api/aws/ec2.api";
Expand All @@ -8,14 +8,23 @@ interface Props {
initialTags: Ec2Tag[];
}

function isAwsTag(tag: Ec2Tag) {
return /^aws:/i.test(tag.key);
}

export function TagEditor({ instanceId, initialTags }: Props) {
const [rows, setRows] = useState<Ec2Tag[]>(initialTags);
const [draft, setDraft] = useState<{ base: Ec2Tag[]; rows: Ec2Tag[] } | null>(null);
const userTags = initialTags.filter((tag) => !isAwsTag(tag));
const rows = draft?.rows ?? userTags;
const [err, setErr] = useState("");
const mutation = useUpdateEc2InstanceTagsMutation();

useEffect(() => {
setRows(initialTags);
}, [initialTags]);
function setRows(update: (tags: Ec2Tag[]) => Ec2Tag[]) {
setDraft((previous) => ({
base: previous?.base ?? userTags,
rows: update(previous?.rows ?? userTags),
}));
}

function addRow() {
setRows((prev) => [...prev, { key: "", value: "" }]);
Expand All @@ -35,20 +44,35 @@ export function TagEditor({ instanceId, initialTags }: Props) {

function handleSave() {
const newTags = rows.filter((r) => r.key.trim());
if (newTags.some(isAwsTag)) {
setErr("Tag keys starting with 'aws:' are reserved for AWS.");
return;
}
const originalTags = draft?.base ?? userTags;
const newKeys = new Set(newTags.map((t) => t.key));
const oldKeys = new Set(initialTags.map((t) => t.key));
const toAdd = newTags.filter((t) => !oldKeys.has(t.key) || initialTags.find((ot) => ot.key === t.key)?.value !== t.value);
const toRemove = initialTags.map((t) => t.key).filter((k) => !newKeys.has(k));
const oldKeys = new Set(originalTags.map((t) => t.key));
const toAdd = newTags.filter((t) => !oldKeys.has(t.key) || originalTags.find((ot) => ot.key === t.key)?.value !== t.value);
const toRemove = originalTags.map((t) => t.key).filter((k) => !newKeys.has(k));
setErr("");
mutation.mutate(
{ instanceId, toAdd, toRemove },
{ onError: (e) => setErr(e instanceof Error ? e.message : "Save failed.") },
{
onSuccess: () => setDraft((current) => current === draft ? null : current),
Comment thread
AndreKurait marked this conversation as resolved.
Resolved
Comment thread
AndreKurait marked this conversation as resolved.
Resolved
onError: (e) => setErr(e instanceof Error ? e.message : "Save failed."),
},
);
}

return (
<div>
<div style={{ display: "flex", flexDirection: "column", gap: 4, marginBottom: 8 }}>
{initialTags.filter(isAwsTag).map((tag) => (
<div key={tag.key} className="field-row" style={{ gap: 4 }}>
<input className="input" aria-label="AWS-managed tag key" value={tag.key} readOnly style={{ flex: 1 }} />
<input className="input" aria-label="AWS-managed tag value" value={tag.value} readOnly style={{ flex: 2 }} />
<span title="AWS-managed tags cannot be edited or removed">AWS-managed</span>
Comment thread
greptile-apps[bot] marked this conversation as resolved.
Resolved
</div>
))}
{rows.map((tag, idx) => (
<div key={idx} className="field-row" style={{ gap: 4 }}>
<input
Expand Down