@quenty/nevermore-cli 4.46.0 → 4.47.1

package/src/utils/open-cloud/open-cloud-client.test.ts

@@ -372,6 +372,367 @@ describe('OpenCloudClient.resolveLatestPlaceVersionAsync', () => {
   });
 });
 
+describe('OpenCloudClient asset uploads', () => {
+  beforeEach(() => {
+    vi.mocked(fs.readFile).mockResolvedValue(
+      Buffer.from([1, 2, 3]) as unknown as string
+    );
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  interface CapturedRequest {
+    url: string;
+    method?: string;
+    headers: Record<string, string>;
+    form: FormData;
+  }
+
+  /** Answer every request with `operation`, recording what was sent. */
+  function makeUploadLimiter(
+    operation: unknown,
+    captured: CapturedRequest[] = []
+  ): RateLimiter {
+    return {
+      fetchAsync: vi.fn(async (url: string | URL, init?: RequestInit) => {
+        captured.push({
+          url: String(url),
+          method: init?.method,
+          headers: init?.headers as Record<string, string>,
+          form: init?.body as FormData,
+        });
+        return new Response(JSON.stringify(operation), { status: 200 });
+      }),
+    } as unknown as RateLimiter;
+  }
+
+  it('creates an asset as a multipart request naming its owner', async () => {
+    const captured: CapturedRequest[] = [];
+    const client = new OpenCloudClient({
+      apiKey: 'test-key',
+      rateLimiter: makeUploadLimiter({ path: 'operations/abc' }, captured),
+    });
+
+    const operation = await client.createAssetAsync({
+      filePath: '/art/icons_1.png',
+      contentType: 'image/png',
+      assetType: 'Image',
+      displayName: 'icons_1',
+      description: 'Interface art',
+      creator: { userId: 4397833 },
+    });
+
+    expect(operation.path).toBe('operations/abc');
+    expect(captured[0]?.url).toBe('https://apis.roblox.com/assets/v1/assets');
+    expect(captured[0]?.method).toBe('POST');
+    // The multipart boundary is fetch's to write; a hand-set Content-Type would
+    // send a body the API cannot split into its two parts.
+    expect(captured[0]?.headers).toEqual({ 'x-api-key': 'test-key' });
+
+    const form = captured[0]!.form;
+    expect(JSON.parse(form.get('request') as string)).toEqual({
+      assetType: 'Image',
+      displayName: 'icons_1',
+      description: 'Interface art',
+      creationContext: { creator: { userId: '4397833' } },
+    });
+    const file = form.get('fileContent') as File;
+    expect(file.name).toBe('icons_1.png');
+    expect(file.type).toBe('image/png');
+    expect([...new Uint8Array(await file.arrayBuffer())]).toEqual([1, 2, 3]);
+  });
+
+  it('names a group as the owner when given a group id', async () => {
+    const captured: CapturedRequest[] = [];
+    const client = new OpenCloudClient({
+      apiKey: 'test-key',
+      rateLimiter: makeUploadLimiter({ path: 'operations/abc' }, captured),
+    });
+
+    await client.createAssetAsync({
+      filePath: '/models/City.fbx',
+      contentType: 'model/fbx',
+      assetType: 'Model',
+      displayName: 'City',
+      description: 'City',
+      creator: { groupId: 77 },
+    });
+
+    const request = JSON.parse(captured[0]!.form.get('request') as string);
+    expect(request.creationContext).toEqual({ creator: { groupId: '77' } });
+  });
+
+  it('replaces an asset in place with a PATCH to its id', async () => {
+    const captured: CapturedRequest[] = [];
+    const client = new OpenCloudClient({
+      apiKey: 'test-key',
+      rateLimiter: makeUploadLimiter({ path: 'operations/abc' }, captured),
+    });
+
+    await client.updateAssetContentAsync(123, {
+      filePath: '/models/City.fbx',
+      contentType: 'model/fbx',
+    });
+
+    expect(captured[0]?.url).toBe(
+      'https://apis.roblox.com/assets/v1/assets/123'
+    );
+    expect(captured[0]?.method).toBe('PATCH');
+    expect(JSON.parse(captured[0]!.form.get('request') as string)).toEqual({
+      assetId: 123,
+    });
+    expect((captured[0]!.form.get('fileContent') as File).type).toBe(
+      'model/fbx'
+    );
+  });
+
+  it('names the scopes an upload needs when the key is refused', async () => {
+    const rateLimiter = {
+      fetchAsync: vi.fn(
+        async () =>
+          new Response(JSON.stringify({ code: 7, message: 'Forbidden' }), {
+            status: 403,
+            statusText: 'Forbidden',
+          })
+      ),
+    } as unknown as RateLimiter;
+    const client = new OpenCloudClient({ apiKey: 'test-key', rateLimiter });
+
+    await expect(
+      client.createAssetAsync({
+        filePath: '/art/icon.png',
+        contentType: 'image/png',
+        assetType: 'Image',
+        displayName: 'icon',
+        description: 'icon',
+        creator: { userId: 1 },
+      })
+    ).rejects.toThrowError(
+      /Create asset failed: Forbidden \(403\)[\s\S]*asset:read, asset:write/
+    );
+  });
+
+  describe('pollAssetOperationAsync', () => {
+    beforeEach(() => {
+      vi.spyOn(global, 'setTimeout').mockImplementation((fn: () => void) => {
+        fn();
+        return 0 as unknown as NodeJS.Timeout;
+      });
+    });
+
+    /** Answer successive polls with successive operation states. */
+    function makePollLimiter(
+      states: unknown[],
+      urls: string[] = []
+    ): RateLimiter {
+      return {
+        fetchAsync: vi.fn(async (url: string | URL) => {
+          urls.push(String(url));
+          const state = states[Math.min(urls.length, states.length) - 1];
+          return new Response(JSON.stringify(state), { status: 200 });
+        }),
+      } as unknown as RateLimiter;
+    }
+
+    it('polls the operation until it is done and returns the asset', async () => {
+      const urls: string[] = [];
+      const client = new OpenCloudClient({
+        apiKey: 'test-key',
+        rateLimiter: makePollLimiter(
+          [
+            { path: 'operations/abc' },
+            {
+              path: 'operations/abc',
+              done: true,
+              // As the live API answers: the id is a string despite the
+              // schema's integer, and the moderation state is a bare word.
+              response: {
+                assetId: '2205400862',
+                revisionId: '1',
+                moderationResult: { moderationState: 'Reviewing' },
+              },
+            },
+          ],
+          urls
+        ),
+      });
+
+      const asset = await client.pollAssetOperationAsync({
+        path: 'operations/abc',
+      });
+
+      expect(asset).toEqual({
+        assetId: 2205400862,
+        revisionId: '1',
+        moderationState: 'Reviewing',
+      });
+      expect(urls).toEqual([
+        'https://apis.roblox.com/assets/v1/operations/abc',
+        'https://apis.roblox.com/assets/v1/operations/abc',
+      ]);
+    });
+
+    it('does not poll an operation that is already done', async () => {
+      const urls: string[] = [];
+      const client = new OpenCloudClient({
+        apiKey: 'test-key',
+        rateLimiter: makePollLimiter([], urls),
+      });
+
+      const asset = await client.pollAssetOperationAsync({
+        path: 'operations/abc',
+        done: true,
+        response: { assetId: 9 },
+      });
+
+      expect(asset.assetId).toBe(9);
+      expect(urls).toHaveLength(0);
+    });
+
+    it('throws the reason when the upload is rejected', async () => {
+      const client = new OpenCloudClient({
+        apiKey: 'test-key',
+        rateLimiter: makePollLimiter([
+          {
+            path: 'operations/abc',
+            done: true,
+            error: { code: 3, message: 'File type is not supported' },
+          },
+        ]),
+      });
+
+      await expect(
+        client.pollAssetOperationAsync({ path: 'operations/abc' })
+      ).rejects.toThrowError(/Asset upload failed: File type is not supported/);
+    });
+
+    it('gives up after the timeout, without calling the upload failed', async () => {
+      // An operation that outlives the wait may still produce an asset, so the
+      // caller has to be told to look before uploading the same file again.
+      const urls: string[] = [];
+      const client = new OpenCloudClient({
+        apiKey: 'test-key',
+        rateLimiter: makePollLimiter([{ path: 'operations/abc' }], urls),
+      });
+
+      await expect(
+        client.pollAssetOperationAsync({ path: 'operations/abc' }, 6000)
+      ).rejects.toThrowError(
+        /did not finish within 6s\. Roblox may still create the asset/
+      );
+      expect(urls).toHaveLength(3);
+    });
+
+    it('refuses a finished operation that carries no asset id', async () => {
+      const client = new OpenCloudClient({
+        apiKey: 'test-key',
+        rateLimiter: makePollLimiter([
+          { path: 'operations/abc', done: true, response: {} },
+        ]),
+      });
+
+      await expect(
+        client.pollAssetOperationAsync({ path: 'operations/abc' })
+      ).rejects.toThrowError(/finished without an asset id/);
+    });
+  });
+});
+
+describe('OpenCloudClient asset owner lookups', () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  interface CapturedRequest {
+    url: string;
+    init?: RequestInit;
+  }
+
+  function makeLimiter(
+    body: unknown,
+    status = 200,
+    captured: CapturedRequest[] = []
+  ): RateLimiter {
+    return {
+      fetchAsync: vi.fn(async (url: string | URL, init?: RequestInit) => {
+        captured.push({ url: String(url), init });
+        return new Response(JSON.stringify(body), { status });
+      }),
+    } as unknown as RateLimiter;
+  }
+
+  it('reads a user-owned universe as that user', async () => {
+    const captured: CapturedRequest[] = [];
+    const client = new OpenCloudClient({
+      apiKey: 'test-key',
+      rateLimiter: makeLimiter(
+        { path: 'universes/10', user: 'users/4397833' },
+        200,
+        captured
+      ),
+    });
+
+    expect(await client.getUniverseOwnerAsync(10)).toEqual({ userId: 4397833 });
+    expect(captured[0]?.url).toBe(
+      'https://apis.roblox.com/cloud/v2/universes/10'
+    );
+  });
+
+  it('reads a group-owned universe as that group', async () => {
+    const client = new OpenCloudClient({
+      apiKey: 'test-key',
+      rateLimiter: makeLimiter({ path: 'universes/10', group: 'groups/77' }),
+    });
+
+    expect(await client.getUniverseOwnerAsync(10)).toEqual({ groupId: 77 });
+  });
+
+  it('throws when the universe cannot be read', async () => {
+    const client = new OpenCloudClient({
+      apiKey: 'test-key',
+      rateLimiter: makeLimiter({}, 403),
+    });
+
+    await expect(client.getUniverseOwnerAsync(10)).rejects.toThrowError(
+      /Read universe 10 failed: 403/
+    );
+  });
+
+  it('asks Roblox which user the API key belongs to', async () => {
+    const captured: CapturedRequest[] = [];
+    const client = new OpenCloudClient({
+      apiKey: 'test-key',
+      rateLimiter: makeLimiter(
+        { name: 'my-key', authorizedUserId: 4397833 },
+        200,
+        captured
+      ),
+    });
+
+    expect(await client.getApiKeyUserIdAsync()).toBe(4397833);
+    expect(captured[0]?.url).toBe(
+      'https://apis.roblox.com/api-keys/v1/introspect'
+    );
+    // Introspection takes the key in the body rather than the usual header.
+    expect(JSON.parse(captured[0]!.init!.body as string)).toEqual({
+      apiKey: 'test-key',
+    });
+  });
+
+  it('throws when the key does not name a user', async () => {
+    const client = new OpenCloudClient({
+      apiKey: 'test-key',
+      rateLimiter: makeLimiter({ name: 'my-key' }),
+    });
+
+    await expect(client.getApiKeyUserIdAsync()).rejects.toThrowError(
+      /did not report which user/
+    );
+  });
+});
+
 describe('getTaskReturnValues', () => {
   function makeTask(overrides: Partial<LuauTask>): LuauTask {
     return {