@readme/httpsnippet 3.1.3 → 4.0.0

package/src/targets/swift/nsurlsession/fixtures/multipart-data.swift

@@ -0,0 +1,56 @@
+import Foundation
+
+let headers = ["content-type": "multipart/form-data; boundary=---011000010111000001101001"]
+let parameters = [
+  [
+    "name": "foo",
+    "value": "Hello World",
+    "fileName": "src/fixtures/files/hello.txt",
+    "contentType": "text/plain"
+  ],
+  [
+    "name": "bar",
+    "value": "Bonjour le monde"
+  ]
+]
+
+let boundary = "---011000010111000001101001"
+
+var body = ""
+var error: NSError? = nil
+for param in parameters {
+  let paramName = param["name"]!
+  body += "--\(boundary)\r\n"
+  body += "Content-Disposition:form-data; name=\"\(paramName)\""
+  if let filename = param["fileName"] {
+    let contentType = param["content-type"]!
+    let fileContent = String(contentsOfFile: filename, encoding: String.Encoding.utf8)
+    if (error != nil) {
+      print(error as Any)
+    }
+    body += "; filename=\"\(filename)\"\r\n"
+    body += "Content-Type: \(contentType)\r\n\r\n"
+    body += fileContent
+  } else if let paramValue = param["value"] {
+    body += "\r\n\r\n\(paramValue)"
+  }
+}
+
+let request = NSMutableURLRequest(url: NSURL(string: "https://httpbin.org/anything")! as URL,
+                                        cachePolicy: .useProtocolCachePolicy,
+                                    timeoutInterval: 10.0)
+request.httpMethod = "POST"
+request.allHTTPHeaderFields = headers
+request.httpBody = postData as Data
+
+let session = URLSession.shared
+let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
+  if (error != nil) {
+    print(error as Any)
+  } else {
+    let httpResponse = response as? HTTPURLResponse
+    print(httpResponse)
+  }
+})
+
+dataTask.resume()

package/src/targets/swift/nsurlsession/fixtures/multipart-file.swift

@@ -0,0 +1,51 @@
+import Foundation
+
+let headers = ["content-type": "multipart/form-data; boundary=---011000010111000001101001"]
+let parameters = [
+  [
+    "name": "foo",
+    "fileName": "src/fixtures/files/hello.txt",
+    "contentType": "text/plain"
+  ]
+]
+
+let boundary = "---011000010111000001101001"
+
+var body = ""
+var error: NSError? = nil
+for param in parameters {
+  let paramName = param["name"]!
+  body += "--\(boundary)\r\n"
+  body += "Content-Disposition:form-data; name=\"\(paramName)\""
+  if let filename = param["fileName"] {
+    let contentType = param["content-type"]!
+    let fileContent = String(contentsOfFile: filename, encoding: String.Encoding.utf8)
+    if (error != nil) {
+      print(error as Any)
+    }
+    body += "; filename=\"\(filename)\"\r\n"
+    body += "Content-Type: \(contentType)\r\n\r\n"
+    body += fileContent
+  } else if let paramValue = param["value"] {
+    body += "\r\n\r\n\(paramValue)"
+  }
+}
+
+let request = NSMutableURLRequest(url: NSURL(string: "https://httpbin.org/anything")! as URL,
+                                        cachePolicy: .useProtocolCachePolicy,
+                                    timeoutInterval: 10.0)
+request.httpMethod = "POST"
+request.allHTTPHeaderFields = headers
+request.httpBody = postData as Data
+
+let session = URLSession.shared
+let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
+  if (error != nil) {
+    print(error as Any)
+  } else {
+    let httpResponse = response as? HTTPURLResponse
+    print(httpResponse)
+  }
+})
+
+dataTask.resume()

package/src/targets/swift/nsurlsession/fixtures/multipart-form-data-no-params.swift

@@ -0,0 +1,21 @@
+import Foundation
+
+let headers = ["Content-Type": "multipart/form-data"]
+
+let request = NSMutableURLRequest(url: NSURL(string: "https://httpbin.org/anything")! as URL,
+                                        cachePolicy: .useProtocolCachePolicy,
+                                    timeoutInterval: 10.0)
+request.httpMethod = "POST"
+request.allHTTPHeaderFields = headers
+
+let session = URLSession.shared
+let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
+  if (error != nil) {
+    print(error as Any)
+  } else {
+    let httpResponse = response as? HTTPURLResponse
+    print(httpResponse)
+  }
+})
+
+dataTask.resume()

package/src/targets/swift/nsurlsession/fixtures/multipart-form-data.swift

@@ -0,0 +1,50 @@
+import Foundation
+
+let headers = ["Content-Type": "multipart/form-data; boundary=---011000010111000001101001"]
+let parameters = [
+  [
+    "name": "foo",
+    "value": "bar"
+  ]
+]
+
+let boundary = "---011000010111000001101001"
+
+var body = ""
+var error: NSError? = nil
+for param in parameters {
+  let paramName = param["name"]!
+  body += "--\(boundary)\r\n"
+  body += "Content-Disposition:form-data; name=\"\(paramName)\""
+  if let filename = param["fileName"] {
+    let contentType = param["content-type"]!
+    let fileContent = String(contentsOfFile: filename, encoding: String.Encoding.utf8)
+    if (error != nil) {
+      print(error as Any)
+    }
+    body += "; filename=\"\(filename)\"\r\n"
+    body += "Content-Type: \(contentType)\r\n\r\n"
+    body += fileContent
+  } else if let paramValue = param["value"] {
+    body += "\r\n\r\n\(paramValue)"
+  }
+}
+
+let request = NSMutableURLRequest(url: NSURL(string: "https://httpbin.org/anything")! as URL,
+                                        cachePolicy: .useProtocolCachePolicy,
+                                    timeoutInterval: 10.0)
+request.httpMethod = "POST"
+request.allHTTPHeaderFields = headers
+request.httpBody = postData as Data
+
+let session = URLSession.shared
+let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
+  if (error != nil) {
+    print(error as Any)
+  } else {
+    let httpResponse = response as? HTTPURLResponse
+    print(httpResponse)
+  }
+})
+
+dataTask.resume()

package/src/targets/swift/nsurlsession/fixtures/nested.swift

@@ -0,0 +1,18 @@
+import Foundation
+
+let request = NSMutableURLRequest(url: NSURL(string: "https://httpbin.org/anything?foo%5Bbar%5D=baz%2Czap&fiz=buz&key=value")! as URL,
+                                        cachePolicy: .useProtocolCachePolicy,
+                                    timeoutInterval: 10.0)
+request.httpMethod = "GET"
+
+let session = URLSession.shared
+let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
+  if (error != nil) {
+    print(error as Any)
+  } else {
+    let httpResponse = response as? HTTPURLResponse
+    print(httpResponse)
+  }
+})
+
+dataTask.resume()

package/src/targets/swift/nsurlsession/fixtures/pretty-option.swift

@@ -0,0 +1,24 @@
+import Foundation
+
+let headers = ["cookie": "foo=bar; bar=baz", "accept": "application/json", "content-type": "application/x-www-form-urlencoded"]
+
+let postData = NSMutableData(data: "foo=bar".data(using: String.Encoding.utf8)!)
+
+let request = NSMutableURLRequest(url: NSURL(string: "https://httpbin.org/anything?foo=bar&foo=baz&baz=abc&key=value")! as URL,
+                                        cachePolicy: .useProtocolCachePolicy,
+                                    timeoutInterval: 10.0)
+request.httpMethod = "POST"
+request.allHTTPHeaderFields = headers
+request.httpBody = postData as Data
+
+let session = URLSession.shared
+let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
+  if (error != nil) {
+    print(error as Any)
+  } else {
+    let httpResponse = response as? HTTPURLResponse
+    print(httpResponse)
+  }
+})
+
+dataTask.resume()

package/src/targets/swift/nsurlsession/fixtures/query-encoded.swift

@@ -0,0 +1,18 @@
+import Foundation
+
+let request = NSMutableURLRequest(url: NSURL(string: "https://httpbin.org/anything?startTime=2019-06-13T19%3A08%3A25.455Z&endTime=2015-09-15T14%3A00%3A12-04%3A00")! as URL,
+                                        cachePolicy: .useProtocolCachePolicy,
+                                    timeoutInterval: 10.0)
+request.httpMethod = "GET"
+
+let session = URLSession.shared
+let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
+  if (error != nil) {
+    print(error as Any)
+  } else {
+    let httpResponse = response as? HTTPURLResponse
+    print(httpResponse)
+  }
+})
+
+dataTask.resume()

package/src/targets/swift/nsurlsession/fixtures/query.swift

@@ -0,0 +1,18 @@
+import Foundation
+
+let request = NSMutableURLRequest(url: NSURL(string: "https://httpbin.org/anything?foo=bar&foo=baz&baz=abc&key=value")! as URL,
+                                        cachePolicy: .useProtocolCachePolicy,
+                                    timeoutInterval: 10.0)
+request.httpMethod = "GET"
+
+let session = URLSession.shared
+let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
+  if (error != nil) {
+    print(error as Any)
+  } else {
+    let httpResponse = response as? HTTPURLResponse
+    print(httpResponse)
+  }
+})
+
+dataTask.resume()

package/src/targets/swift/nsurlsession/fixtures/short.swift

@@ -0,0 +1,18 @@
+import Foundation
+
+let request = NSMutableURLRequest(url: NSURL(string: "https://httpbin.org/anything")! as URL,
+                                        cachePolicy: .useProtocolCachePolicy,
+                                    timeoutInterval: 10.0)
+request.httpMethod = "GET"
+
+let session = URLSession.shared
+let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
+  if (error != nil) {
+    print(error as Any)
+  } else {
+    let httpResponse = response as? HTTPURLResponse
+    print(httpResponse)
+  }
+})
+
+dataTask.resume()

package/src/targets/swift/nsurlsession/fixtures/text-plain.swift

@@ -0,0 +1,24 @@
+import Foundation
+
+let headers = ["content-type": "text/plain"]
+
+let postData = NSData(data: "Hello World".data(using: String.Encoding.utf8)!)
+
+let request = NSMutableURLRequest(url: NSURL(string: "https://httpbin.org/anything")! as URL,
+                                        cachePolicy: .useProtocolCachePolicy,
+                                    timeoutInterval: 10.0)
+request.httpMethod = "POST"
+request.allHTTPHeaderFields = headers
+request.httpBody = postData as Data
+
+let session = URLSession.shared
+let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
+  if (error != nil) {
+    print(error as Any)
+  } else {
+    let httpResponse = response as? HTTPURLResponse
+    print(httpResponse)
+  }
+})
+
+dataTask.resume()

package/src/targets/swift/nsurlsession/fixtures/timeout-option.swift

@@ -0,0 +1,18 @@
+import Foundation
+
+let request = NSMutableURLRequest(url: NSURL(string: "https://httpbin.org/anything")! as URL,
+                                        cachePolicy: .useProtocolCachePolicy,
+                                    timeoutInterval: 5.0)
+request.httpMethod = "GET"
+
+let session = URLSession.shared
+let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
+  if (error != nil) {
+    print(error as Any)
+  } else {
+    let httpResponse = response as? HTTPURLResponse
+    print(httpResponse)
+  }
+})
+
+dataTask.resume()

package/src/targets/swift/target.ts

@@ -0,0 +1,14 @@
+import type { Target } from '../targets';
+import { nsurlsession } from './nsurlsession/client';
+
+export const swift: Target = {
+  info: {
+    key: 'swift',
+    title: 'Swift',
+    extname: '.swift',
+    default: 'nsurlsession',
+  },
+  clientsById: {
+    nsurlsession,
+  },
+};

package/src/targets/targets.test.ts

@@ -0,0 +1,297 @@
+import type { HTTPSnippetOptions, Request } from '..';
+import type { Client, ClientId, Target, TargetId } from './targets';
+import { readdirSync, readFileSync, writeFileSync } from 'fs';
+import path from 'path';
+
+import { availableTargets, extname } from '../helpers/utils';
+import { HTTPSnippet } from '..';
+import { isClient, isTarget, addTarget, addTargetClient, targets } from './targets';
+
+import short from '../fixtures/requests/short';
+
+const expectedBasePath = ['src', 'fixtures', 'requests'];
+
+const inputFileNames = readdirSync(path.join(...expectedBasePath), 'utf-8');
+
+const fixtures: [string, Request][] = inputFileNames.map(inputFileName => [
+  inputFileName.replace(path.extname(inputFileName), ''),
+  // eslint-disable-next-line import/no-dynamic-require, global-require
+  require(path.resolve(...expectedBasePath, inputFileName)),
+]);
+
+/** useful for debuggin, only run a particular set of targets */
+const targetFilter: TargetId[] = [
+  // put your targetId:
+  // 'node',
+];
+
+/** useful for debuggin, only run a particular set of targets */
+const clientFilter: ClientId[] = [
+  // put your clientId here:
+  // 'unirest',
+];
+
+/** useful for debuggin, only run a particular set of fixtures */
+const fixtureFilter: string[] = [
+  // put the name of the fixture file you want to isolate (excluding `.json`):
+  // 'multipart-file',
+];
+
+/**
+ * This is useful when you want to make a change and overwrite it for every fixture.
+ * Basically a snapshot reset.
+ *
+ * Switch to `true` in debug mode to put into effect.
+ */
+const OVERWRITE_EVERYTHING = Boolean(process.env.OVERWRITE_EVERYTHING) || false;
+
+const testFilter =
+  <T>(property: keyof T, list: T[keyof T][]) =>
+  (item: T) =>
+    list.length > 0 ? list.includes(item[property]) : true;
+
+availableTargets()
+  .filter(testFilter('key', targetFilter))
+  .forEach(({ key: targetId, title, extname: fixtureExtension, clients }) => {
+    describe(`${title} Request Validation`, () => {
+      clients.filter(testFilter('key', clientFilter)).forEach(({ key: clientId }) => {
+        fixtures.filter(testFilter(0, fixtureFilter)).forEach(([fixture, request]) => {
+          const expectedPath = path.join(
+            'src',
+            'targets',
+            targetId,
+            clientId,
+            'fixtures',
+            `${fixture}${extname(targetId)}`
+          );
+          try {
+            const options: HTTPSnippetOptions = {};
+
+            if (fixture === 'query-encoded') {
+              // Query strings in this HAR are already escaped.
+              options.harIsAlreadyEncoded = true;
+            }
+
+            const expected = readFileSync(expectedPath).toString();
+            const { convert } = new HTTPSnippet(request, options);
+            const result = convert(targetId, clientId); //?
+
+            if (OVERWRITE_EVERYTHING && result) {
+              writeFileSync(expectedPath, String(result));
+              return;
+            }
+
+            it(`${clientId} request should match fixture for "${fixture}.js"`, () => {
+              expect(result).toStrictEqual(expected);
+            });
+          } catch (error) {
+            throw new Error(
+              `Missing a test file for ${targetId}:${clientId} for the ${fixture} fixture.\nExpected to find the output fixture: \`/src/targets/${targetId}/${clientId}/fixtures/${fixture}${fixtureExtension}\``
+            );
+          }
+        });
+      });
+    });
+  });
+
+describe('isTarget', () => {
+  it("should throw if you don't provide an object", () => {
+    // @ts-expect-error intentionally incorrect
+    expect(() => isTarget(null)).toThrow('you tried to add a target which is not an object, got type: "null"');
+    // @ts-expect-error intentionally incorrect
+    expect(() => isTarget(undefined)).toThrow(
+      'you tried to add a target which is not an object, got type: "undefined"'
+    );
+    // @ts-expect-error intentionally incorrect
+    expect(() => isTarget([])).toThrow('you tried to add a target which is not an object, got type: "array"');
+  });
+
+  it('validates required fields', () => {
+    // @ts-expect-error intentionally incorrect
+    expect(() => isTarget({})).toThrow('targets must contain an `info` object');
+    // @ts-expect-error intentionally incorrect
+    expect(() => isTarget({ info: {} })).toThrow('targets must have an `info` object with the property `key`');
+    // @ts-expect-error intentionally incorrect
+    expect(() => isTarget({ info: { key: '' } })).toThrow('target key must be a unique string');
+    // @ts-expect-error intentionally incorrect
+    expect(() => isTarget({ info: { key: null } })).toThrow('target key must be a unique string');
+    // @ts-expect-error intentionally incorrect
+    expect(() => isTarget({ info: { key: undefined } })).toThrow('target key must be a unique string');
+    // @ts-expect-error intentionally incorrect
+    expect(() => isTarget({ info: { key: 'c' } })).toThrow('a target already exists with this key, `c`');
+    // @ts-expect-error intentionally incorrect
+    expect(() => isTarget({ info: { key: 'z' } })).toThrow(
+      'targets must have an `info` object with the property `title`'
+    );
+    // @ts-expect-error intentionally incorrect
+    expect(() => isTarget({ info: { key: 'z', title: '' } })).toThrow('target title must be a non-zero-length string');
+    // @ts-expect-error intentionally incorrect
+    expect(() => isTarget({ info: { key: 'z', title: null } })).toThrow(
+      'target title must be a non-zero-length string'
+    );
+    // @ts-expect-error intentionally incorrect
+    expect(() => isTarget({ info: { key: 'z', title: undefined } })).toThrow(
+      'target title must be a non-zero-length string'
+    );
+    // @ts-expect-error intentionally incorrect
+    expect(() => isTarget({ info: { key: 'z', title: 't' } })).toThrow(
+      'targets must have an `info` object with the property `extname`'
+    );
+    // @ts-expect-error intentionally incorrect
+    expect(() => isTarget({ info: { key: 'z', title: 't', extname: '' } })).toThrow(
+      'No clients provided in target z.  You must provide the property `clientsById` containg your clients.'
+    );
+    expect(() =>
+      // @ts-expect-error intentionally incorrect
+      isTarget({ info: { key: 'z', title: 't', extname: '' }, clientsById: {} })
+    ).toThrow('No clients provided in target z.  You must provide the property `clientsById` containg your clients.');
+    expect(() =>
+      // @ts-expect-error intentionally incorrect
+      isTarget({ info: { key: 'z', title: 't', extname: '' }, clientsById: null })
+    ).toThrow('No clients provided in target z.  You must provide the property `clientsById` containg your clients.');
+    expect(() =>
+      // @ts-expect-error intentionally incorrect
+      isTarget({ info: { key: 'z', title: 't', extname: '' }, clientsById: undefined })
+    ).toThrow('No clients provided in target z.  You must provide the property `clientsById` containg your clients.');
+    expect(() =>
+      // @ts-expect-error intentionally incorrect
+      isTarget({ info: { key: 'z', title: 't', extname: '' }, clientsById: { a: {} } })
+    ).toThrow('targets must have an `info` object with the property `default`');
+    expect(() =>
+      isTarget({
+        // @ts-expect-error intentionally incorrect
+        info: { key: 'z', title: 't', extname: '', default: 'b' },
+        // @ts-expect-error intentionally incorrect
+        clientsById: { a: {} },
+      })
+    ).toThrow(
+      'target z is configured with a default client b, but no such client was found in the property `clientsById` (found ["a"])'
+    );
+
+    expect(
+      isTarget({
+        info: { key: 'z' as TargetId, title: 't', extname: null, default: 'a' },
+        clientsById: {
+          a: {
+            info: {
+              key: 'a',
+              title: 'a',
+              description: '',
+              link: '',
+            },
+            convert: () => '',
+          },
+        },
+      })
+    ).toBeTruthy();
+  });
+});
+
+describe('isClient', () => {
+  it('validates the client', () => {
+    // @ts-expect-error intentionally incorrect
+    expect(() => isClient(null)).toThrow('clients must be objects');
+    // @ts-expect-error intentionally incorrect
+    expect(() => isClient(undefined)).toThrow('clients must be objects');
+    // @ts-expect-error intentionally incorrect
+    expect(() => isClient({})).toThrow('targets client must contain an `info` object');
+    // @ts-expect-error intentionally incorrect
+    expect(() => isClient({ info: '' })).toThrow('targets client must have an `info` object with property `key`');
+    // @ts-expect-error intentionally incorrect
+    expect(() => isClient({ info: { key: undefined } })).toThrow(
+      'client.info.key must contain an identifier unique to this target'
+    );
+    // @ts-expect-error intentionally incorrect
+    expect(() => isClient({ info: { key: null } })).toThrow(
+      'client.info.key must contain an identifier unique to this target'
+    );
+    // @ts-expect-error intentionally incorrect
+    expect(() => isClient({ info: { key: '' } })).toThrow(
+      'client.info.key must contain an identifier unique to this target'
+    );
+    // @ts-expect-error intentionally incorrect
+    expect(() => isClient({ info: { key: 'a' } })).toThrow(
+      'targets client must have an `info` object with property `title`'
+    );
+    // @ts-expect-error intentionally incorrect
+    expect(() => isClient({ info: { key: 'a', title: '' } })).toThrow(
+      'targets client must have an `info` object with property `description`'
+    );
+    // @ts-expect-error intentionally incorrect
+    expect(() => isClient({ info: { key: 'a', description: '', title: '' } })).toThrow(
+      'targets client must have an `info` object with property `link`'
+    );
+    // @ts-expect-error intentionally incorrect
+    expect(() => isClient({ info: { key: 'a', title: '', link: '', description: '' } })).toThrow(
+      'targets client must have a `convert` property containing a conversion function'
+    );
+    expect(() =>
+      // @ts-expect-error intentionally incorrect
+      isClient({ info: { key: 'a', title: '', link: '', description: '' }, convert: '' })
+    ).toThrow('targets client must have a `convert` property containing a conversion function');
+    expect(
+      isClient({
+        info: { key: 'a', title: '', link: '', description: '' },
+        convert: () => '',
+      })
+    ).toBeTruthy();
+  });
+});
+
+describe('addTarget', () => {
+  afterEach(() => {
+    // @ts-expect-error intentionally incorrect
+    delete targets.deno;
+  });
+
+  it('should add a new custom target', async () => {
+    const { fetch: fetchClient } = await import('./node/fetch/client');
+
+    const deno: Target = {
+      info: {
+        // @ts-expect-error intentionally incorrect
+        key: 'deno',
+        title: 'Deno',
+        extname: '.js',
+        default: 'fetch',
+      },
+      clientsById: {
+        fetch: fetchClient,
+      },
+    };
+
+    addTarget(deno);
+
+    // @ts-expect-error intentionally incorrect
+    expect(targets.deno).toBeDefined();
+    // @ts-expect-error intentionally incorrect
+    expect(targets.deno).toStrictEqual(deno);
+  });
+});
+
+describe('addTargetClient', () => {
+  afterEach(() => {
+    delete targets.node.clientsById.custom;
+  });
+
+  it('should add a new custom target', () => {
+    const customClient: Client = {
+      info: {
+        key: 'custom',
+        title: 'Custom HTTP library',
+        link: 'https://example.com',
+        description: 'A custom HTTP library',
+      },
+      convert: () => {
+        return 'This was generated from a custom client.';
+      },
+    };
+
+    addTargetClient('node', customClient);
+
+    const { convert } = new HTTPSnippet(short.log.entries[0].request as Request, {});
+    const result = convert('node', 'custom');
+
+    expect(result).toBe('This was generated from a custom client.');
+  });
+});