fix: add getSpec tests and apply same fix to openapi-python

Co-authored-by: mrlubos <[e-mail]>

packages/openapi-python/src/createClient.ts

···
     // if in watch mode, subsequent errors won't throw to gracefully handle
     // cases where server might be reloading
     if (error && !_watches) {
-      throw new Error(`Request failed with status ${response.status}: ${response.statusText}`);
+      const text = await response.text().catch(() => '');
+      throw new Error(
+        `Request failed with status ${response.status}: ${text || response.statusText}`,
+      );
     }
 
     return { arrayBuffer, resolvedInput };

packages/shared/src/__tests__/getSpec.test.ts

···
+import * as refParser from '@hey-api/json-schema-ref-parser';
+
+import { getSpec } from '../getSpec';
+
+vi.mock('@hey-api/json-schema-ref-parser', () => ({
+  getResolvedInput: vi.fn(({ pathOrUrlOrSchema }: { pathOrUrlOrSchema: string }) => ({
+    path: pathOrUrlOrSchema,
+    schema: undefined,
+    type: 'url',
+  })),
+  sendRequest: vi.fn(),
+}));
+
+const mockSendRequest = vi.mocked(refParser.sendRequest);
+
+describe('getSpec', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('URL input', () => {
+    it('returns error with status 500 and error message when GET request throws an exception', async () => {
+      mockSendRequest.mockRejectedValueOnce(new Error('fetch failed'));
+
+      const result = await getSpec({
+        fetchOptions: undefined,
+        inputPath: 'http://example.com/openapi.json',
+        timeout: undefined,
+        watch: { headers: new Headers() },
+      });
+
+      expect(result.error).toBe('not-ok');
+      expect(result.response!.status).toBe(500);
+      expect(await result.response!.text()).toBe('fetch failed');
+    });
+
+    it('returns error with status 500 and string message when non-Error is thrown during GET request', async () => {
+      mockSendRequest.mockRejectedValueOnce('network unavailable');
+
+      const result = await getSpec({
+        fetchOptions: undefined,
+        inputPath: 'http://example.com/openapi.json',
+        timeout: undefined,
+        watch: { headers: new Headers() },
+      });
+
+      expect(result.error).toBe('not-ok');
+      expect(result.response!.status).toBe(500);
+      expect(await result.response!.text()).toBe('network unavailable');
+    });
+
+    it('returns error when GET response has status >= 300', async () => {
+      mockSendRequest.mockResolvedValueOnce({
+        response: new Response(null, { status: 404, statusText: 'Not Found' }),
+      });
+
+      const result = await getSpec({
+        fetchOptions: undefined,
+        inputPath: 'http://example.com/openapi.json',
+        timeout: undefined,
+        watch: { headers: new Headers() },
+      });
+
+      expect(result.error).toBe('not-ok');
+      expect(result.response!.status).toBe(404);
+    });
+
+    it('returns error with status 500 and error message when HEAD request throws an exception', async () => {
+      mockSendRequest.mockRejectedValueOnce(new Error('connection refused'));
+
+      const result = await getSpec({
+        fetchOptions: undefined,
+        inputPath: 'http://example.com/openapi.json',
+        timeout: undefined,
+        watch: { headers: new Headers(), isHeadMethodSupported: true, lastValue: 'previous' },
+      });
+
+      expect(result.error).toBe('not-ok');
+      expect(result.response!.status).toBe(500);
+      expect(await result.response!.text()).toBe('connection refused');
+    });
+
+    it('returns arrayBuffer on successful GET', async () => {
+      const content = '{"openapi":"3.0.0"}';
+      const encoder = new TextEncoder();
+      const buffer = encoder.encode(content).buffer as ArrayBuffer;
+
+      mockSendRequest.mockResolvedValueOnce({
+        response: new Response(buffer, { status: 200 }),
+      });
+
+      const result = await getSpec({
+        fetchOptions: undefined,
+        inputPath: 'http://example.com/openapi.json',
+        timeout: undefined,
+        watch: { headers: new Headers() },
+      });
+
+      expect(result.error).toBeUndefined();
+      expect(result.arrayBuffer).toBeDefined();
+    });
+  });
+});