fix: remove unused request dependency

Author: rbnayax

package-lock.json

@@ -68,7 +68,7 @@
         "isomorphic-ws": "^4.0.1",
         "js-yaml": "^4.1.0",
         "jsonpath-plus": "^0.19.0",
-        "node-fetch": "^2.6.0",
+        "node-fetch": "^2.6.9",
         "openid-client": "^4.1.1",
         "rfc4648": "^1.3.0",
         "shelljs": "^0.8.5",

package.json

@@ -159,6 +159,9 @@ export class KubeConfig implements SecurityAuthentication {
                 headers.set(key, val.toString());
             }
         }
+        if (opts.auth) {
+            headers.set('Authorization', 'Basic ' + Buffer.from(opts.auth).toString('base64'));
+        }
         return {
             agent: opts.agent,
             headers,
@@ -185,6 +188,23 @@ export class KubeConfig implements SecurityAuthentication {
         agentOptions.pfx = opts.pfx;
         agentOptions.passphrase = opts.passphrase;
         agentOptions.rejectUnauthorized = opts.rejectUnauthorized;
+        agentOptions.timeout = opts.timeout;
+        agentOptions.host = opts.host;
+        agentOptions.path = opts.path;
+        agentOptions.servername = opts.servername;
+        agentOptions.ciphers = opts.ciphers;
+        agentOptions.honorCipherOrder = opts.honorCipherOrder;
+        agentOptions.ecdhCurve = opts.ecdhCurve;
+        agentOptions.clientCertEngine = opts.clientCertEngine;
+        agentOptions.crl = opts.crl;
+        agentOptions.dhparam = opts.dhparam;
+        agentOptions.secureOptions = opts.secureOptions;
+        agentOptions.secureProtocol = opts.secureProtocol;
+        agentOptions.sessionIdContext = opts.sessionIdContext;
+        // setting undefined will cause tls error
+        if (opts.hasOwnProperty('port')) {
+            agentOptions.port = typeof opts.port === 'string' ? parseInt(opts.port, 10) : opts.port;
+        }
 
         opts.agent = new https.Agent(agentOptions);
     }

src/config.ts

@@ -1,7 +1,7 @@
 import { readFileSync } from 'fs';
 import * as https from 'https';
 import { join } from 'path';
-import { RequestOptions } from 'https';
+import { RequestOptions, Agent } from 'https';
 
 import { expect, use } from 'chai';
 import chaiAsPromised from 'chai-as-promised';
@@ -13,7 +13,8 @@ import { bufferFromFileOrString, findHomeDir, findObject, KubeConfig, makeAbsolu
 import { Cluster, newClusters, newContexts, newUsers, User, ActionOnInvalid } from './config_types';
 import { ExecAuth } from './exec_auth';
 import { HttpMethod } from '.';
-import { assertRequestOptionsEqual } from '../test/match-buffer';
+import { assertRequestOptionsEqual, assertRequestAgentsEqual } from '../test/match-buffer';
+import { Headers } from 'node-fetch';
 
 const kcFileName = 'testdata/kubeconfig.yaml';
 const kc2FileName = 'testdata/kubeconfig-2.yaml';
@@ -237,6 +238,47 @@ describe('KubeConfig', () => {
         });
     });
 
+    describe('applytoFetchOptions', () => {
+        it('should apply cert configs', async () => {
+            const kc = new KubeConfig();
+            kc.loadFromFile(kcFileName);
+            kc.setCurrentContext('passwd');
+
+            const opts: https.RequestOptions = {
+                method: 'POST',
+                timeout: 5,
+                headers: {
+                    number: 5,
+                    string: 'str',
+                    empty: undefined,
+                    list: ['a', 'b'],
+                },
+            };
+            const requestInit = await kc.applytoFetchOptions(opts);
+            const expectedCA = Buffer.from('CADATA2', 'utf-8');
+            const expectedAgent = new https.Agent({
+                ca: expectedCA,
+                rejectUnauthorized: false,
+            });
+
+            expect(requestInit.method).to.equal('POST');
+            expect(requestInit.timeout).to.equal(5);
+            expect((requestInit.headers as Headers).raw()).to.deep.equal({
+                "list": [
+                    "a",
+                    "b",
+                ],
+                "number": [
+                    "5",
+                ],
+                "string": [
+                    "str",
+                ],
+            });
+            assertRequestAgentsEqual(requestInit.agent as Agent, expectedAgent);
+        });
+    });
+
     describe('applyHTTPSOptions', () => {
         it('should apply cert configs', () => {
             const kc = new KubeConfig();

src/config_test.ts

@@ -86,7 +86,6 @@ export class Metrics {
 
         const requestInit = await this.config.applytoFetchOptions({
             method: 'GET',
-            servername: cluster.server + path,
         });
 
         return fetch(requestURL, requestInit)

src/metrics.ts

@@ -28,12 +28,7 @@ class StringBufferMatcher extends Matcher {
   }
 }
 
-export function assertRequestOptionsEqual(options1: RequestOptions, options2: RequestOptions): void {
-  //@ts-ignore agent has type Agent | Boolean which we expect to be populated with Agent here
-  const agent1: Agent = options1.agent
-  //@ts-ignore
-  const agent2: Agent = options2.agent
-
+export function assertRequestAgentsEqual(agent1: Agent, agent2: Agent): void {
   const BUFFER_EQUAL_TRUE = 0
   const ca1 = agent1.options.ca
   const ca2 = agent2.options.ca
@@ -55,10 +50,18 @@ export function assertRequestOptionsEqual(options1: RequestOptions, options2: Re
   if(key1 !== key2 && Buffer.compare(key1,key2) !== BUFFER_EQUAL_TRUE){
     throw("unequal agent key buffer")
   }
-  
+
   expect(agent1.options.passphrase).to.equal(agent2.options.passphrase);
   expect(agent1.options.pfx).to.equal(agent2.options.pfx);
   expect(agent1.options.rejectUnauthorized).to.equal(agent2.options.rejectUnauthorized);
+}
+
+export function assertRequestOptionsEqual(options1: RequestOptions, options2: RequestOptions): void {
+  //@ts-ignore agent has type Agent | Boolean which we expect to be populated with Agent here
+  const agent1: Agent = options1.agent
+  //@ts-ignore
+  const agent2: Agent = options2.agent
+  assertRequestAgentsEqual(agent1, agent2)
 
   expect(options1.auth).to.equal(options2.auth)
   expect(options1.headers).to.deep.equal(options2.headers)