Merge pull request #231 from sasjs/insecure-connection

feat: enable insecure connection for accessToken

.gitignore

@@ -1,4 +1,6 @@
 node_modules
 build
 
-.env
+.env
+
+/coverage

package.json

@@ -7,7 +7,7 @@
     "publish:lib": "npm run build && cd build && npm publish",
     "lint:fix": "npx prettier --write 'src/**/*.{ts,tsx,js,jsx,html,css,sass,less,json,yml,md,graphql}'",
     "lint": "npx prettier --check 'src/**/*.{ts,tsx,js,jsx,html,css,sass,less,json,yml,md,graphql}'",
-    "test": "jest",
+    "test": "jest --coverage",
     "prepublishOnly": "cp -r ./build/* . && rm -rf ./build",
     "postpublish": "git clean -fd",
     "semantic-release": "semantic-release",
@@ -37,30 +37,31 @@
   "license": "ISC",
   "devDependencies": {
     "@types/isomorphic-fetch": "0.0.35",
-    "@types/jest": "^26.0.15",
+    "@types/jest": "^26.0.20",
     "cp": "^0.2.0",
     "dotenv": "^8.2.0",
     "jest": "^25.5.4",
     "path": "^0.12.7",
     "rimraf": "^3.0.2",
-    "semantic-release": "^17.3.0",
+    "semantic-release": "^17.3.1",
     "terser-webpack-plugin": "^4.2.3",
     "ts-jest": "^25.5.1",
-    "ts-loader": "^8.0.11",
+    "ts-loader": "^8.0.14",
     "tslint": "^6.1.3",
     "tslint-config-prettier": "^1.18.0",
-    "typedoc": "^0.17.8",
+    "typedoc": "^0.19.2",
     "typedoc-neo-theme": "^1.0.10",
-    "typedoc-plugin-external-module-name": "^4.0.3",
+    "typedoc-plugin-external-module-name": "^4.0.6",
     "typescript": "^3.9.7",
-    "webpack": "^4.44.2",
-    "webpack-cli": "^4.2.0"
+    "webpack": "^5.13.0",
+    "webpack-cli": "^4.3.1"
   },
   "main": "index.js",
   "dependencies": {
-    "@sasjs/utils": "^1.5.0",
+    "@sasjs/utils": "^2.0.2",
     "es6-promise": "^4.2.8",
     "form-data": "^3.0.0",
+    "https": "^1.0.0",
     "isomorphic-fetch": "^2.2.1"
   }
 }

src/ContextManager.ts

@@ -0,0 +1,538 @@
+import {
+  Context,
+  CsrfToken,
+  EditContextInput,
+  ContextAllAttributes
+} from './types'
+import { makeRequest, isUrl } from './utils'
+import { SASViyaApiClient } from './SASViyaApiClient'
+import { prefixMessage } from '@sasjs/utils/error'
+
+export class ContextManager {
+  private defaultComputeContexts = [
+    'CAS Formats service compute context',
+    'Data Mining compute context',
+    'Import 9 service compute context',
+    'SAS Job Execution compute context',
+    'SAS Model Manager compute context',
+    'SAS Studio compute context',
+    'SAS Visual Forecasting compute context'
+  ]
+  private defaultLauncherContexts = [
+    'CAS Formats service launcher context',
+    'Data Mining launcher context',
+    'Import 9 service launcher context',
+    'Job Flow Execution launcher context',
+    'SAS Job Execution launcher context',
+    'SAS Model Manager launcher context',
+    'SAS Studio launcher context',
+    'SAS Visual Forecasting launcher context'
+  ]
+
+  private csrfToken: CsrfToken | null = null
+
+  get getDefaultComputeContexts() {
+    return this.defaultComputeContexts
+  }
+  get getDefaultLauncherContexts() {
+    return this.defaultLauncherContexts
+  }
+
+  constructor(
+    private serverUrl: string,
+    private setCsrfToken: (csrfToken: CsrfToken) => void
+  ) {
+    if (serverUrl) isUrl(serverUrl)
+  }
+
+  public async getComputeContexts(accessToken?: string) {
+    const headers: any = {
+      'Content-Type': 'application/json'
+    }
+
+    if (accessToken) {
+      headers.Authorization = `Bearer ${accessToken}`
+    }
+
+    const { result: contexts } = await this.request<{ items: Context[] }>(
+      `${this.serverUrl}/compute/contexts?limit=10000`,
+      { headers }
+    ).catch((err) => {
+      throw prefixMessage(err, 'Error while getting compute contexts. ')
+    })
+
+    const contextsList = contexts && contexts.items ? contexts.items : []
+
+    return contextsList.map((context: any) => ({
+      createdBy: context.createdBy,
+      id: context.id,
+      name: context.name,
+      version: context.version,
+      attributes: {}
+    }))
+  }
+
+  public async getLauncherContexts(accessToken?: string) {
+    const headers: any = {
+      'Content-Type': 'application/json'
+    }
+
+    if (accessToken) {
+      headers.Authorization = `Bearer ${accessToken}`
+    }
+
+    const { result: contexts } = await this.request<{ items: Context[] }>(
+      `${this.serverUrl}/launcher/contexts?limit=10000`,
+      { headers }
+    ).catch((err) => {
+      throw prefixMessage(err, 'Error while getting launcher contexts. ')
+    })
+
+    const contextsList = contexts && contexts.items ? contexts.items : []
+
+    return contextsList.map((context: any) => ({
+      createdBy: context.createdBy,
+      id: context.id,
+      name: context.name,
+      version: context.version,
+      attributes: {}
+    }))
+  }
+
+  public async createComputeContext(
+    contextName: string,
+    launchContextName: string,
+    sharedAccountId: string,
+    autoExecLines: string[],
+    accessToken?: string,
+    authorizedUsers?: string[]
+  ) {
+    this.validateContextName(contextName)
+
+    this.isDefaultContext(
+      contextName,
+      this.defaultComputeContexts,
+      `Compute context '${contextName}' already exists.`
+    )
+
+    const existingComputeContexts = await this.getComputeContexts(accessToken)
+
+    if (
+      existingComputeContexts.find((context) => context.name === contextName)
+    ) {
+      throw new Error(`Compute context '${contextName}' already exists.`)
+    }
+
+    if (launchContextName) {
+      if (!this.defaultLauncherContexts.includes(launchContextName)) {
+        const launcherContexts = await this.getLauncherContexts(accessToken)
+
+        if (
+          !launcherContexts.find(
+            (context) => context.name === launchContextName
+          )
+        ) {
+          const description = `The launcher context for ${launchContextName}`
+          const launchType = 'direct'
+
+          const newLauncherContext = await this.createLauncherContext(
+            launchContextName,
+            description,
+            launchType,
+            accessToken
+          ).catch((err) => {
+            throw new Error(`Error while creating launcher context. ${err}`)
+          })
+
+          if (newLauncherContext && newLauncherContext.name) {
+            launchContextName = newLauncherContext.name
+          } else {
+            throw new Error('Error while creating launcher context.')
+          }
+        }
+      }
+    }
+
+    const headers: any = {
+      'Content-Type': 'application/json'
+    }
+
+    if (accessToken) {
+      headers.Authorization = `Bearer ${accessToken}`
+    }
+
+    let attributes = { reuseServerProcesses: true } as object
+
+    if (sharedAccountId)
+      attributes = { ...attributes, runServerAs: sharedAccountId }
+
+    const requestBody: any = {
+      name: contextName,
+      launchContext: {
+        contextName: launchContextName || ''
+      },
+      attributes
+    }
+
+    if (authorizedUsers && authorizedUsers.length) {
+      requestBody['authorizedUsers'] = authorizedUsers
+    } else {
+      requestBody['authorizeAllAuthenticatedUsers'] = true
+    }
+
+    if (autoExecLines) {
+      requestBody.environment = { autoExecLines }
+    }
+
+    const createContextRequest: RequestInit = {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(requestBody)
+    }
+
+    const { result: context } = await this.request<Context>(
+      `${this.serverUrl}/compute/contexts`,
+      createContextRequest
+    ).catch((err) => {
+      throw prefixMessage(err, 'Error while creating compute context. ')
+    })
+
+    return context
+  }
+
+  public async createLauncherContext(
+    contextName: string,
+    description: string,
+    launchType = 'direct',
+    accessToken?: string
+  ) {
+    if (!contextName) {
+      throw new Error('Context name is required.')
+    }
+
+    this.isDefaultContext(
+      contextName,
+      this.defaultLauncherContexts,
+      `Launcher context '${contextName}' already exists.`
+    )
+
+    const existingLauncherContexts = await this.getLauncherContexts(accessToken)
+
+    if (
+      existingLauncherContexts.find((context) => context.name === contextName)
+    ) {
+      throw new Error(`Launcher context '${contextName}' already exists.`)
+    }
+
+    const headers: any = {
+      'Content-Type': 'application/json'
+    }
+
+    if (accessToken) {
+      headers.Authorization = `Bearer ${accessToken}`
+    }
+
+    const requestBody: any = {
+      name: contextName,
+      description: description,
+      launchType
+    }
+
+    const createContextRequest: RequestInit = {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(requestBody)
+    }
+
+    const { result: context } = await this.request<Context>(
+      `${this.serverUrl}/launcher/contexts`,
+      createContextRequest
+    ).catch((err) => {
+      throw prefixMessage(err, 'Error while creating launcher context. ')
+    })
+
+    return context
+  }
+
+  public async editComputeContext(
+    contextName: string,
+    editedContext: EditContextInput,
+    accessToken?: string
+  ) {
+    this.validateContextName(contextName)
+
+    this.isDefaultContext(
+      contextName,
+      this.defaultComputeContexts,
+      'Editing default SAS compute contexts is not allowed.',
+      true
+    )
+
+    const headers: any = {
+      'Content-Type': 'application/json'
+    }
+
+    if (accessToken) {
+      headers.Authorization = `Bearer ${accessToken}`
+    }
+
+    let originalContext
+
+    originalContext = await this.getComputeContextByName(
+      contextName,
+      accessToken
+    )
+
+    // Try to find context by id, when context name has been changed.
+    if (!originalContext) {
+      originalContext = await this.getComputeContextById(
+        editedContext.id!,
+        accessToken
+      )
+    }
+
+    const { result: context, etag } = await this.request<Context>(
+      `${this.serverUrl}/compute/contexts/${originalContext.id}`,
+      {
+        headers
+      }
+    ).catch((err) => {
+      if (err && err.status === 404) {
+        throw new Error(
+          `The context '${contextName}' was not found on this server.`
+        )
+      }
+
+      throw err
+    })
+
+    // An If-Match header with the value of the last ETag for the context
+    // is required to be able to update it
+    // https://developer.sas.com/apis/rest/Compute/#update-a-context-definition
+    headers['If-Match'] = etag
+
+    const updateContextRequest: RequestInit = {
+      method: 'PUT',
+      headers,
+      body: JSON.stringify({
+        ...context,
+        ...editedContext,
+        attributes: { ...context.attributes, ...editedContext.attributes }
+      })
+    }
+
+    return await this.request<Context>(
+      `${this.serverUrl}/compute/contexts/${context.id}`,
+      updateContextRequest
+    )
+  }
+
+  public async getComputeContextByName(
+    contextName: string,
+    accessToken?: string
+  ): Promise<Context> {
+    const headers: any = {
+      'Content-Type': 'application/json'
+    }
+
+    if (accessToken) {
+      headers.Authorization = `Bearer ${accessToken}`
+    }
+
+    const { result: contexts } = await this.request<{ items: Context[] }>(
+      `${this.serverUrl}/compute/contexts?filter=eq(name, "${contextName}")`,
+      { headers }
+    ).catch((err) => {
+      throw prefixMessage(err, 'Error while getting compute context by name. ')
+    })
+
+    if (!contexts || !(contexts.items && contexts.items.length)) {
+      throw new Error(
+        `The context '${contextName}' was not found at '${this.serverUrl}'.`
+      )
+    }
+
+    return contexts.items[0]
+  }
+
+  public async getComputeContextById(
+    contextId: string,
+    accessToken?: string
+  ): Promise<ContextAllAttributes> {
+    const headers: any = {
+      'Content-Type': 'application/json'
+    }
+
+    if (accessToken) {
+      headers.Authorization = `Bearer ${accessToken}`
+    }
+
+    const { result: context } = await this.request<ContextAllAttributes>(
+      `${this.serverUrl}/compute/contexts/${contextId}`,
+      { headers }
+    ).catch((err) => {
+      throw prefixMessage(err, 'Error while getting compute context by id. ')
+    })
+
+    return context
+  }
+
+  public async getExecutableContexts(
+    executeScript: Function,
+    accessToken?: string
+  ) {
+    const headers: any = {
+      'Content-Type': 'application/json'
+    }
+
+    if (accessToken) {
+      headers.Authorization = `Bearer ${accessToken}`
+    }
+
+    const { result: contexts } = await this.request<{ items: Context[] }>(
+      `${this.serverUrl}/compute/contexts?limit=10000`,
+      { headers }
+    ).catch((err) => {
+      throw prefixMessage(err, 'Error while fetching compute contexts.')
+    })
+
+    const contextsList = contexts.items || []
+    const executableContexts: any[] = []
+
+    const promises = contextsList.map((context: any) => {
+      const linesOfCode = ['%put &=sysuserid;']
+
+      return () =>
+        executeScript(
+          `test-${context.name}`,
+          linesOfCode,
+          context.name,
+          accessToken,
+          null,
+          false,
+          true,
+          true
+        ).catch((err: any) => err)
+    })
+
+    let results: any[] = []
+
+    for (const promise of promises) results.push(await promise())
+
+    results.forEach((result: any, index: number) => {
+      if (result && result.log) {
+        try {
+          const resultParsed = result.log
+          let sysUserId = ''
+
+          const sysUserIdLog = resultParsed
+            .split('\n')
+            .find((line: string) => line.startsWith('SYSUSERID='))
+
+          if (sysUserIdLog) {
+            sysUserId = sysUserIdLog.replace('SYSUSERID=', '')
+
+            executableContexts.push({
+              createdBy: contextsList[index].createdBy,
+              id: contextsList[index].id,
+              name: contextsList[index].name,
+              version: contextsList[index].version,
+              attributes: {
+                sysUserId
+              }
+            })
+          }
+        } catch (error) {
+          throw error
+        }
+      }
+    })
+
+    return executableContexts
+  }
+
+  public async deleteComputeContext(contextName: string, accessToken?: string) {
+    this.validateContextName(contextName)
+
+    this.isDefaultContext(
+      contextName,
+      this.defaultComputeContexts,
+      'Deleting default SAS compute contexts is not allowed.',
+      true
+    )
+
+    const headers: any = {
+      'Content-Type': 'application/json'
+    }
+
+    if (accessToken) {
+      headers.Authorization = `Bearer ${accessToken}`
+    }
+
+    const context = await this.getComputeContextByName(contextName, accessToken)
+
+    const deleteContextRequest: RequestInit = {
+      method: 'DELETE',
+      headers
+    }
+
+    return await this.request<Context>(
+      `${this.serverUrl}/compute/contexts/${context.id}`,
+      deleteContextRequest
+    )
+  }
+
+  // TODO: implement editLauncherContext method
+
+  // TODO: implement deleteLauncherContext method
+
+  private async request<T>(
+    url: string,
+    options: RequestInit,
+    contentType: 'text' | 'json' = 'json'
+  ) {
+    if (this.csrfToken) {
+      options.headers = {
+        ...options.headers,
+        [this.csrfToken.headerName]: this.csrfToken.value
+      }
+    }
+
+    return await makeRequest<T>(
+      url,
+      options,
+      (token) => {
+        this.csrfToken = token
+        this.setCsrfToken(token)
+      },
+      contentType
+    ).catch((err) => {
+      throw prefixMessage(
+        err,
+        'Error while making request in Context Manager. '
+      )
+    })
+  }
+
+  private validateContextName(name: string) {
+    if (!name) throw new Error('Context name is required.')
+  }
+
+  public isDefaultContext(
+    context: string,
+    defaultContexts: string[] = this.defaultComputeContexts,
+    errorMessage = '',
+    listDefaults = false
+  ) {
+    if (defaultContexts.includes(context)) {
+      throw new Error(
+        `${errorMessage}${
+          listDefaults
+            ? '\nDefault contexts:' +
+              defaultContexts.map((context, i) => `\n${i + 1}. ${context}`)
+            : ''
+        }`
+      )
+    }
+  }
+}

src/SASViyaApiClient.ts

@@ -21,6 +21,7 @@ import {
 } from './types'
 import { formatDataForRequest } from './utils/formatDataForRequest'
 import { SessionManager } from './SessionManager'
+import { ContextManager } from './ContextManager'
 import { timestampToYYYYMMDDHHMMSS } from '@sasjs/utils/time'
 import { Logger, LogLevel } from '@sasjs/utils/logger'
 
@@ -46,6 +47,7 @@ export class SASViyaApiClient {
     this.contextName,
     this.setCsrfToken
   )
+  private contextManager = new ContextManager(this.serverUrl, this.setCsrfToken)
   private folderMap = new Map<string, Job[]>()
 
   public get debug() {
@@ -98,29 +100,23 @@ export class SASViyaApiClient {
    * Returns all available compute contexts on this server.
    * @param accessToken - an access token for an authorized user.
    */
-  public async getAllContexts(accessToken?: string) {
-    const headers: any = {
-      'Content-Type': 'application/json'
-    }
+  public async getComputeContexts(accessToken?: string) {
+    return await this.contextManager.getComputeContexts(accessToken)
+  }
 
-    if (accessToken) {
-      headers.Authorization = `Bearer ${accessToken}`
-    }
+  /**
+   * Returns default(system) compute contexts.
+   */
+  public getDefaultComputeContexts() {
+    return this.contextManager.getDefaultComputeContexts
+  }
 
-    const { result: contexts } = await this.request<{ items: Context[] }>(
-      `${this.serverUrl}/compute/contexts?limit=10000`,
-      { headers }
-    )
-
-    const contextsList = contexts && contexts.items ? contexts.items : []
-
-    return contextsList.map((context: any) => ({
-      createdBy: context.createdBy,
-      id: context.id,
-      name: context.name,
-      version: context.version,
-      attributes: {}
-    }))
+  /**
+   * Returns all available launcher contexts on this server.
+   * @param accessToken - an access token for an authorized user.
+   */
+  public async getLauncherContexts(accessToken?: string) {
+    return await this.contextManager.getLauncherContexts(accessToken)
   }
 
   /**
@@ -128,74 +124,12 @@ export class SASViyaApiClient {
    * @param accessToken - an access token for an authorized user.
    */
   public async getExecutableContexts(accessToken?: string) {
-    const headers: any = {
-      'Content-Type': 'application/json'
-    }
+    const bindedExecuteScript = this.executeScript.bind(this)
 
-    if (accessToken) {
-      headers.Authorization = `Bearer ${accessToken}`
-    }
-
-    const { result: contexts } = await this.request<{ items: Context[] }>(
-      `${this.serverUrl}/compute/contexts?limit=10000`,
-      { headers }
-    ).catch((err) => {
-      throw err
-    })
-
-    const contextsList = contexts.items || []
-    const executableContexts: any[] = []
-
-    const promises = contextsList.map((context: any) => {
-      const linesOfCode = ['%put &=sysuserid;']
-
-      return () =>
-        this.executeScript(
-          `test-${context.name}`,
-          linesOfCode,
-          context.name,
-          accessToken,
-          null,
-          false,
-          true,
-          true
-        ).catch((err) => err)
-    })
-
-    let results: any[] = []
-
-    for (const promise of promises) results.push(await promise())
-
-    results.forEach((result: any, index: number) => {
-      if (result && result.log) {
-        try {
-          const resultParsed = result.log
-          let sysUserId = ''
-
-          const sysUserIdLog = resultParsed
-            .split('\n')
-            .find((line: string) => line.startsWith('SYSUSERID='))
-
-          if (sysUserIdLog) {
-            sysUserId = sysUserIdLog.replace('SYSUSERID=', '')
-
-            executableContexts.push({
-              createdBy: contextsList[index].createdBy,
-              id: contextsList[index].id,
-              name: contextsList[index].name,
-              version: contextsList[index].version,
-              attributes: {
-                sysUserId
-              }
-            })
-          }
-        } catch (error) {
-          throw error
-        }
-      }
-    })
-
-    return executableContexts
+    return await this.contextManager.getExecutableContexts(
+      bindedExecuteScript,
+      accessToken
+    )
   }
 
   /**
@@ -248,7 +182,7 @@ export class SASViyaApiClient {
    * @param accessToken - an access token for an authorized user.
    * @param authorizedUsers - an optional list of authorized user IDs.
    */
-  public async createContext(
+  public async createComputeContext(
     contextName: string,
     launchContextName: string,
     sharedAccountId: string,
@@ -256,59 +190,35 @@ export class SASViyaApiClient {
     accessToken?: string,
     authorizedUsers?: string[]
   ) {
-    if (!contextName) {
-      throw new Error('Context name is required.')
-    }
-
-    if (!launchContextName) {
-      throw new Error('Launch context name is required.')
-    }
-
-    if (!sharedAccountId) {
-      throw new Error('Shared account ID is required.')
-    }
-
-    const headers: any = {
-      'Content-Type': 'application/json'
-    }
-
-    if (accessToken) {
-      headers.Authorization = `Bearer ${accessToken}`
-    }
-
-    const requestBody: any = {
-      name: contextName,
-      launchContext: {
-        contextName: launchContextName
-      },
-      attributes: {
-        reuseServerProcesses: true,
-        runServerAs: sharedAccountId
-      }
-    }
-
-    if (authorizedUsers && authorizedUsers.length) {
-      requestBody['authorizedUsers'] = authorizedUsers
-    } else {
-      requestBody['authorizeAllAuthenticatedUsers'] = true
-    }
-
-    if (autoExecLines) {
-      requestBody.environment = { autoExecLines }
-    }
-
-    const createContextRequest: RequestInit = {
-      method: 'POST',
-      headers,
-      body: JSON.stringify(requestBody)
-    }
-
-    const { result: context } = await this.request<Context>(
-      `${this.serverUrl}/compute/contexts`,
-      createContextRequest
+    return await this.contextManager.createComputeContext(
+      contextName,
+      launchContextName,
+      sharedAccountId,
+      autoExecLines,
+      accessToken,
+      authorizedUsers
     )
+  }
 
-    return context
+  /**
+   * Creates a launcher context on the given server.
+   * @param contextName - the name of the context to be created.
+   * @param description - the description of the context to be created.
+   * @param launchType - launch type of the context to be created.
+   * @param accessToken - an access token for an authorized user.
+   */
+  public async createLauncherContext(
+    contextName: string,
+    description: string,
+    launchType = 'direct',
+    accessToken?: string
+  ) {
+    return await this.contextManager.createLauncherContext(
+      contextName,
+      description,
+      launchType,
+      accessToken
+    )
   }
 
   /**
@@ -317,75 +227,15 @@ export class SASViyaApiClient {
    * @param editedContext - an object with the properties to be updated.
    * @param accessToken - an access token for an authorized user.
    */
-  public async editContext(
+  public async editComputeContext(
     contextName: string,
     editedContext: EditContextInput,
     accessToken?: string
   ) {
-    if (!contextName) {
-      throw new Error('Invalid context name.')
-    }
-
-    const headers: any = {
-      'Content-Type': 'application/json'
-    }
-
-    if (accessToken) {
-      headers.Authorization = `Bearer ${accessToken}`
-    }
-
-    let originalContext
-
-    originalContext = await this.getComputeContextByName(
+    return await this.contextManager.editComputeContext(
       contextName,
+      editedContext,
       accessToken
-    ).catch((err) => {
-      throw err
-    })
-
-    // Try to find context by id, when context name has been changed.
-    if (!originalContext) {
-      originalContext = await this.getComputeContextById(
-        editedContext.id!,
-        accessToken
-      ).catch((err) => {
-        throw err
-      })
-    }
-
-    const { result: context, etag } = await this.request<Context>(
-      `${this.serverUrl}/compute/contexts/${originalContext.id}`,
-      {
-        headers
-      }
-    ).catch((err) => {
-      if (err && err.status === 404) {
-        throw new Error(
-          `The context '${contextName}' was not found on this server.`
-        )
-      }
-
-      throw err
-    })
-
-    // An If-Match header with the value of the last ETag for the context
-    // is required to be able to update it
-    // https://developer.sas.com/apis/rest/Compute/#update-a-context-definition
-    headers['If-Match'] = etag
-
-    const updateContextRequest: RequestInit = {
-      method: 'PUT',
-      headers,
-      body: JSON.stringify({
-        ...context,
-        ...editedContext,
-        attributes: { ...context.attributes, ...editedContext.attributes }
-      })
-    }
-
-    return await this.request<Context>(
-      `${this.serverUrl}/compute/contexts/${context.id}`,
-      updateContextRequest
     )
   }
 
@@ -394,29 +244,10 @@ export class SASViyaApiClient {
    * @param contextName - the name of the context to be deleted.
    * @param accessToken - an access token for an authorized user.
    */
-  public async deleteContext(contextName: string, accessToken?: string) {
-    if (!contextName) {
-      throw new Error('Invalid context name.')
-    }
-
-    const headers: any = {
-      'Content-Type': 'application/json'
-    }
-
-    if (accessToken) {
-      headers.Authorization = `Bearer ${accessToken}`
-    }
-
-    const context = await this.getComputeContextByName(contextName, accessToken)
-
-    const deleteContextRequest: RequestInit = {
-      method: 'DELETE',
-      headers
-    }
-
-    return await this.request<Context>(
-      `${this.serverUrl}/compute/contexts/${context.id}`,
-      deleteContextRequest
+  public async deleteComputeContext(contextName: string, accessToken?: string) {
+    return await this.contextManager.deleteComputeContext(
+      contextName,
+      accessToken
     )
   }
 
@@ -870,11 +701,13 @@ export class SASViyaApiClient {
    * @param clientId - the client ID to authenticate with.
    * @param clientSecret - the client secret to authenticate with.
    * @param authCode - the auth code received from the server.
+   * @param insecure - this boolean tells adapter to ignore SSL errors. [Not Recommended]
    */
   public async getAccessToken(
     clientId: string,
     clientSecret: string,
-    authCode: string
+    authCode: string,
+    insecure: boolean = false
   ) {
     const url = this.serverUrl + '/SASLogon/oauth/token'
     let token
@@ -898,12 +731,23 @@ export class SASViyaApiClient {
       formData.append('code', authCode)
     }
 
+    let moreOptions = {}
+    if (insecure) {
+      const https = require('https')
+      moreOptions = {
+        agent: new https.Agent({
+          rejectUnauthorized: false
+        })
+      }
+    }
+
     const authResponse = await fetch(url, {
       method: 'POST',
       credentials: 'include',
       headers,
       body: formData as any,
-      referrerPolicy: 'same-origin'
+      referrerPolicy: 'same-origin',
+      ...moreOptions
     }).then((res) => res.json())
 
     return authResponse
@@ -1002,23 +846,20 @@ export class SASViyaApiClient {
       )
     }
 
-    if (isRelativePath(sasJob)) {
-      const folderName = sasJob.split('/')[0]
-      await this.populateFolderMap(
-        `${this.rootFolderName}/${folderName}`,
-        accessToken
-      )
+    const folderPathParts = sasJob.split('/')
+    const jobName = folderPathParts.pop()
+    const folderPath = folderPathParts.join('/')
+    const fullFolderPath = isRelativePath(sasJob)
+      ? `${this.rootFolderName}/${folderPath}`
+      : folderPath
 
-      if (!this.folderMap.get(`${this.rootFolderName}/${folderName}`)) {
-        throw new Error(
-          `The folder '${folderName}' was not found at '${this.serverUrl}/${this.rootFolderName}'`
-        )
-      }
-    } else {
-      const folderPathParts = sasJob.split('/')
-      folderPathParts.pop()
-      const folderPath = folderPathParts.join('/')
-      await this.populateFolderMap(folderPath, accessToken)
+    await this.populateFolderMap(fullFolderPath, accessToken)
+
+    const jobFolder = this.folderMap.get(fullFolderPath)
+    if (!jobFolder) {
+      throw new Error(
+        `The folder '${fullFolderPath}' was not found on '${this.serverUrl}'`
+      )
     }
 
     const headers: any = { 'Content-Type': 'application/json' }
@@ -1026,21 +867,7 @@ export class SASViyaApiClient {
       headers.Authorization = `Bearer ${accessToken}`
     }
 
-    let jobToExecute
-    if (isRelativePath(sasJob)) {
-      const folderName = sasJob.split('/')[0]
-      const jobName = sasJob.split('/')[1]
-      const jobFolder = this.folderMap.get(
-        `${this.rootFolderName}/${folderName}`
-      )
-      jobToExecute = jobFolder?.find((item) => item.name === jobName)
-    } else {
-      const folderPathParts = sasJob.split('/')
-      const jobName = folderPathParts.pop()
-      const folderPath = folderPathParts.join('/')
-      const jobFolder = this.folderMap.get(folderPath)
-      jobToExecute = jobFolder?.find((item) => item.name === jobName)
-    }
+    const jobToExecute = jobFolder?.find((item) => item.name === jobName)
 
     if (!jobToExecute) {
       throw new Error(`Job was not found.`)
@@ -1106,52 +933,28 @@ export class SASViyaApiClient {
       )
     }
 
-    if (isRelativePath(sasJob)) {
-      const folderName = sasJob.split('/')[0]
-      await this.populateFolderMap(
-        `${this.rootFolderName}/${folderName}`,
-        accessToken
-      )
+    const folderPathParts = sasJob.split('/')
+    const jobName = folderPathParts.pop()
+    const folderPath = folderPathParts.join('/')
+    const fullFolderPath = isRelativePath(sasJob)
+      ? `${this.rootFolderName}/${folderPath}`
+      : folderPath
+    await this.populateFolderMap(fullFolderPath, accessToken)
 
-      if (!this.folderMap.get(`${this.rootFolderName}/${folderName}`)) {
-        throw new Error(
-          `The folder '${folderName}' was not found at '${this.serverUrl}/${this.rootFolderName}'.`
-        )
-      }
-    } else {
-      const folderPathParts = sasJob.split('/')
-      folderPathParts.pop()
-      const folderPath = folderPathParts.join('/')
-      await this.populateFolderMap(folderPath, accessToken)
-      if (!this.folderMap.get(folderPath)) {
-        throw new Error(
-          `The folder '${folderPath}' was not found at '${this.serverUrl}'.`
-        )
-      }
+    const jobFolder = this.folderMap.get(fullFolderPath)
+    if (!jobFolder) {
+      throw new Error(
+        `The folder '${fullFolderPath}' was not found on '${this.serverUrl}'.`
+      )
     }
 
+    const jobToExecute = jobFolder?.find((item) => item.name === jobName)
+
     let files: any[] = []
     if (data && Object.keys(data).length) {
       files = await this.uploadTables(data, accessToken)
     }
 
-    let jobToExecute: Job | undefined
-    let jobName: string | undefined
-    let jobPath: string | undefined
-    if (isRelativePath(sasJob)) {
-      const folderName = sasJob.split('/')[0]
-      jobName = sasJob.split('/')[1]
-      jobPath = `${this.rootFolderName}/${folderName}`
-      const jobFolder = this.folderMap.get(jobPath)
-      jobToExecute = jobFolder?.find((item) => item.name === jobName)
-    } else {
-      const folderPathParts = sasJob.split('/')
-      jobName = folderPathParts.pop()
-      jobPath = folderPathParts.join('/')
-      const jobFolder = this.folderMap.get(jobPath)
-      jobToExecute = jobFolder?.find((item) => item.name === jobName)
-    }
-
     if (!jobToExecute) {
       throw new Error(`Job was not found.`)
     }
@@ -1176,7 +979,7 @@ export class SASViyaApiClient {
 
     const jobArguments: { [key: string]: any } = {
       _contextName: contextName,
-      _program: `${jobPath}/${jobName}`,
+      _program: `${fullFolderPath}/${jobName}`,
       _webin_file_count: files.length,
       _OMITJSONLISTING: true,
       _OMITJSONLOG: true,
@@ -1317,6 +1120,8 @@ export class SASViyaApiClient {
     }
 
     return new Promise(async (resolve, _) => {
+      let printedState = ''
+
       const interval = setInterval(async () => {
         if (
           postedJobState === 'running' ||
@@ -1324,9 +1129,6 @@ export class SASViyaApiClient {
           postedJobState === 'pending'
         ) {
           if (stateLink) {
-            if (this.debug) {
-              console.log('Polling job status... \n')
-            }
             const { result: jobState } = await this.request<string>(
               `${this.serverUrl}${stateLink.href}?_action=wait&wait=30`,
               {
@@ -1336,10 +1138,16 @@ export class SASViyaApiClient {
             )
 
             postedJobState = jobState.trim()
-            if (this.debug) {
-              console.log(`Current state: ${postedJobState}\n`)
+
+            if (this.debug && printedState !== postedJobState) {
+              console.log('Polling job status...')
+              console.log(`Current job state: ${postedJobState}`)
+
+              printedState = postedJobState
             }
+
             pollCount++
+
             if (pollCount >= MAX_POLL_COUNT) {
               resolve(postedJobState)
             }
@@ -1438,26 +1246,10 @@ export class SASViyaApiClient {
     contextName: string,
     accessToken?: string
   ): Promise<Context> {
-    const headers: any = {
-      'Content-Type': 'application/json'
-    }
-
-    if (accessToken) {
-      headers.Authorization = `Bearer ${accessToken}`
-    }
-
-    const { result: contexts } = await this.request<{ items: Context[] }>(
-      `${this.serverUrl}/compute/contexts?filter=eq(name, "${contextName}")`,
-      { headers }
+    return await this.contextManager.getComputeContextByName(
+      contextName,
+      accessToken
     )
-
-    if (!contexts || !(contexts.items && contexts.items.length)) {
-      throw new Error(
-        `The context '${contextName}' was not found at '${this.serverUrl}'.`
-      )
-    }
-
-    return contexts.items[0]
   }
 
   /**
@@ -1469,22 +1261,10 @@ export class SASViyaApiClient {
     contextId: string,
     accessToken?: string
   ): Promise<ContextAllAttributes> {
-    const headers: any = {
-      'Content-Type': 'application/json'
-    }
-
-    if (accessToken) {
-      headers.Authorization = `Bearer ${accessToken}`
-    }
-
-    const { result: context } = await this.request<ContextAllAttributes>(
-      `${this.serverUrl}/compute/contexts/${contextId}`,
-      { headers }
-    ).catch((err) => {
-      throw err
-    })
-
-    return context
+    return await this.contextManager.getComputeContextById(
+      contextId,
+      accessToken
+    )
   }
 
   /**

src/SASjs.ts

@@ -96,12 +96,39 @@ export default class SASjs {
     )
   }
 
-  public async getAllContexts(accessToken: string) {
-    this.isMethodSupported('getAllContexts', ServerType.SASViya)
+  /**
+   * Gets compute contexts.
+   * @param accessToken - an access token for an authorized user.
+   */
+  public async getComputeContexts(accessToken: string) {
+    this.isMethodSupported('getComputeContexts', ServerType.SASViya)
 
-    return await this.sasViyaApiClient!.getAllContexts(accessToken)
+    return await this.sasViyaApiClient!.getComputeContexts(accessToken)
   }
 
+  /**
+   * Gets launcher contexts.
+   * @param accessToken - an access token for an authorized user.
+   */
+  public async getLauncherContexts(accessToken: string) {
+    this.isMethodSupported('getLauncherContexts', ServerType.SASViya)
+
+    return await this.sasViyaApiClient!.getLauncherContexts(accessToken)
+  }
+
+  /**
+   * Gets default(system) launcher contexts.
+   */
+  public getDefaultComputeContexts() {
+    this.isMethodSupported('getDefaultComputeContexts', ServerType.SASViya)
+
+    return this.sasViyaApiClient!.getDefaultComputeContexts()
+  }
+
+  /**
+   * Gets executable compute contexts.
+   * @param accessToken - an access token for an authorized user.
+   */
   public async getExecutableContexts(accessToken: string) {
     this.isMethodSupported('getExecutableContexts', ServerType.SASViya)
 
@@ -117,7 +144,7 @@ export default class SASjs {
    * @param accessToken - an access token for an authorized user.
    * @param authorizedUsers - an optional list of authorized user IDs.
    */
-  public async createContext(
+  public async createComputeContext(
     contextName: string,
     launchContextName: string,
     sharedAccountId: string,
@@ -125,9 +152,9 @@ export default class SASjs {
     accessToken: string,
     authorizedUsers?: string[]
   ) {
-    this.isMethodSupported('createContext', ServerType.SASViya)
+    this.isMethodSupported('createComputeContext', ServerType.SASViya)
 
-    return await this.sasViyaApiClient!.createContext(
+    return await this.sasViyaApiClient!.createComputeContext(
       contextName,
       launchContextName,
       sharedAccountId,
@@ -137,20 +164,43 @@ export default class SASjs {
     )
   }
 
+  /**
+   * Creates a launcher context on the given server.
+   * @param contextName - the name of the context to be created.
+   * @param description - the description of the context to be created.
+   * @param launchType - launch type of the context to be created.
+   * @param accessToken - an access token for an authorized user.
+   */
+  public async createLauncherContext(
+    contextName: string,
+    description: string,
+    launchType: string,
+    accessToken: string
+  ) {
+    this.isMethodSupported('createLauncherContext', ServerType.SASViya)
+
+    return await this.sasViyaApiClient!.createLauncherContext(
+      contextName,
+      description,
+      launchType,
+      accessToken
+    )
+  }
+
   /**
    * Updates a compute context on the given server.
    * @param contextName - the original name of the context to be deleted.
    * @param editedContext - an object with the properties to be updated.
    * @param accessToken - an access token for an authorized user.
    */
-  public async editContext(
+  public async editComputeContext(
     contextName: string,
     editedContext: EditContextInput,
     accessToken?: string
   ) {
-    this.isMethodSupported('editContext', ServerType.SASViya)
+    this.isMethodSupported('editComputeContext', ServerType.SASViya)
 
-    return await this.sasViyaApiClient!.editContext(
+    return await this.sasViyaApiClient!.editComputeContext(
       contextName,
       editedContext,
       accessToken
@@ -162,10 +212,13 @@ export default class SASjs {
    * @param contextName - the name of the context to be deleted.
    * @param accessToken - an access token for an authorized user.
    */
-  public async deleteContext(contextName: string, accessToken?: string) {
-    this.isMethodSupported('deleteContext', ServerType.SASViya)
+  public async deleteComputeContext(contextName: string, accessToken?: string) {
+    this.isMethodSupported('deleteComputeContext', ServerType.SASViya)
 
-    return await this.sasViyaApiClient!.deleteContext(contextName, accessToken)
+    return await this.sasViyaApiClient!.deleteComputeContext(
+      contextName,
+      accessToken
+    )
   }
 
   /**
@@ -333,17 +386,26 @@ export default class SASjs {
     return await this.sasViyaApiClient!.getAuthCode(clientId)
   }
 
+  /**
+   * Exchanges the auth code for an access token for the given client.
+   * @param clientId - the client ID to authenticate with.
+   * @param clientSecret - the client secret to authenticate with.
+   * @param authCode - the auth code received from the server.
+   * @param insecure - this boolean tells adapter to ignore SSL errors. [Not Recommended]
+   */
   public async getAccessToken(
     clientId: string,
     clientSecret: string,
-    authCode: string
+    authCode: string,
+    insecure: boolean = false
   ) {
     this.isMethodSupported('getAccessToken', ServerType.SASViya)
 
     return await this.sasViyaApiClient!.getAccessToken(
       clientId,
       clientSecret,
-      authCode
+      authCode,
+      insecure
     )
   }
 
@@ -694,10 +756,7 @@ export default class SASjs {
       )
     }
 
-    const members =
-      serviceJson.members[0].name === 'services'
-        ? serviceJson.members[0].members
-        : serviceJson.members
+    const members = serviceJson.members
 
     await this.createFoldersAndServices(
       appLoc,

src/SessionManager.ts

@@ -23,6 +23,10 @@ export class SessionManager {
   private currentContext: Context | null = null
   private csrfToken: CsrfToken | null = null
   private _debug: boolean = false
+  private printedSessionState = {
+    printed: false,
+    state: ''
+  }
 
   public get debug() {
     return this._debug
@@ -175,8 +179,10 @@ export class SessionManager {
         sessionState === ''
       ) {
         if (stateLink) {
-          if (this.debug) {
-            console.log('Polling session status... \n') // ?
+          if (this.debug && !this.printedSessionState.printed) {
+            console.log('Polling session status...')
+
+            this.printedSessionState.printed = true
           }
 
           const { result: state } = await this.requestSessionStatus<string>(
@@ -191,8 +197,11 @@ export class SessionManager {
 
           sessionState = state.trim()
 
-          if (this.debug) {
-            console.log(`Current state is '${sessionState}'\n`)
+          if (this.debug && this.printedSessionState.state !== sessionState) {
+            console.log(`Current session state is '${sessionState}'`)
+
+            this.printedSessionState.state = sessionState
+            this.printedSessionState.printed = false
           }
 
           // There is an internal error present in SAS Viya 3.5

src/test/ContextManager.spec.ts

@@ -0,0 +1,585 @@
+import { ContextManager } from '../ContextManager'
+
+describe('ContextManager', () => {
+  let originalFetch: any
+  let fetchCallNumber = 0
+
+  const fakeGlobalFetch = (fakeResponses: object[]) => {
+    ;(global as any).fetch = jest.fn().mockImplementation(() => {
+      const fakeResponse = fakeResponses[fetchCallNumber]
+
+      if (
+        fetchCallNumber !== fakeResponses.length &&
+        fakeResponses.length > 1
+      ) {
+        if (fetchCallNumber + 1 === fakeResponses.length) fetchCallNumber = 0
+        else fetchCallNumber += 1
+      } else {
+        fetchCallNumber = 0
+      }
+
+      return Promise.resolve({
+        ok: true,
+        headers: { get: () => '' },
+        json: () => Promise.resolve(fakeResponse)
+      })
+    })
+  }
+
+  const contextManager = new ContextManager(
+    process.env.SERVER_URL as string,
+    () => {}
+  )
+
+  const defaultComputeContexts = contextManager.getDefaultComputeContexts
+  const defaultLauncherContexts = contextManager.getDefaultLauncherContexts
+
+  const getRandomDefaultComputeContext = () =>
+    defaultComputeContexts[
+      Math.floor(Math.random() * defaultComputeContexts.length)
+    ]
+  const getRandomDefaultLauncherContext = () =>
+    defaultLauncherContexts[
+      Math.floor(Math.random() * defaultLauncherContexts.length)
+    ]
+
+  beforeAll(() => {
+    originalFetch = (global as any).fetch
+  })
+
+  afterEach(() => {
+    ;(global as any).fetch = originalFetch
+  })
+
+  describe('getComputeContexts', () => {
+    it('should fetch compute contexts', async () => {
+      const sampleComputeContext = {
+        createdBy: 'fake creator',
+        id: 'fakeId',
+        version: 2,
+        name: 'Fake Compute Context',
+        attributes: {}
+      }
+
+      const sampleResponse = {
+        items: [sampleComputeContext]
+      }
+
+      fakeGlobalFetch([sampleResponse])
+
+      await expect(contextManager.getComputeContexts()).resolves.toEqual([
+        sampleComputeContext
+      ])
+    })
+  })
+
+  describe('getLauncherContexts', () => {
+    it('should fetch launcher contexts', async () => {
+      const sampleComputeContext = {
+        createdBy: 'fake creator',
+        id: 'fakeId',
+        version: 2,
+        name: 'Fake Launcher Context',
+        attributes: {}
+      }
+
+      const sampleResponse = {
+        items: [sampleComputeContext]
+      }
+
+      fakeGlobalFetch([sampleResponse])
+
+      await expect(contextManager.getLauncherContexts()).resolves.toEqual([
+        sampleComputeContext
+      ])
+    })
+  })
+
+  describe('createComputeContext', () => {
+    it('should throw an error if context name was not provided', async () => {
+      await expect(
+        contextManager.createComputeContext(
+          '',
+          'Test Launcher Context',
+          'fakeAccountId',
+          []
+        )
+      ).rejects.toEqual(new Error('Context name is required.'))
+    })
+
+    it('should throw an error when attempt to create context with reserved name', async () => {
+      const contextName = getRandomDefaultComputeContext()
+
+      await expect(
+        contextManager.createComputeContext(
+          contextName,
+          'Test Launcher Context',
+          'fakeAccountId',
+          []
+        )
+      ).rejects.toEqual(
+        new Error(`Compute context '${contextName}' already exists.`)
+      )
+    })
+
+    it('should throw an error if context already exists', async () => {
+      const contextName = 'Existing Compute Context'
+
+      const sampleComputeContext = {
+        createdBy: 'fake creator',
+        id: 'fakeId',
+        version: 2,
+        name: contextName,
+        attributes: {}
+      }
+
+      const sampleResponse = {
+        items: [sampleComputeContext]
+      }
+
+      fakeGlobalFetch([sampleResponse])
+
+      await expect(
+        contextManager.createComputeContext(
+          contextName,
+          'Test Launcher Context',
+          'fakeAccountId',
+          []
+        )
+      ).rejects.toEqual(
+        new Error(`Compute context '${contextName}' already exists.`)
+      )
+    })
+
+    it('should create compute context without launcher context', async () => {
+      const contextName = 'New Compute Context'
+
+      const sampleExistingComputeContext = {
+        createdBy: 'fake creator',
+        id: 'fakeId',
+        version: 2,
+        name: 'Existing Compute Context',
+        attributes: {}
+      }
+      const sampleNewComputeContext = {
+        createdBy: 'fake creator',
+        id: 'fakeId',
+        version: 2,
+        name: contextName,
+        attributes: {}
+      }
+
+      const sampleResponseExistingComputeContexts = {
+        items: [sampleExistingComputeContext]
+      }
+      const sampleResponseCreatedComputeContext = {
+        items: [sampleNewComputeContext]
+      }
+
+      fakeGlobalFetch([
+        sampleResponseExistingComputeContexts,
+        sampleResponseCreatedComputeContext
+      ])
+
+      await expect(
+        contextManager.createComputeContext(
+          contextName,
+          '',
+          'fakeAccountId',
+          []
+        )
+      ).resolves.toEqual({
+        items: [
+          {
+            attributes: {},
+            createdBy: 'fake creator',
+            id: 'fakeId',
+            name: contextName,
+            version: 2
+          }
+        ]
+      })
+    })
+
+    it('should create compute context with default launcher context', async () => {
+      const contextName = 'New Compute Context'
+
+      const sampleExistingComputeContext = {
+        createdBy: 'fake creator',
+        id: 'fakeId',
+        version: 2,
+        name: 'Existing Compute Context',
+        attributes: {}
+      }
+      const sampleNewComputeContext = {
+        createdBy: 'fake creator',
+        id: 'fakeId',
+        version: 2,
+        name: contextName,
+        attributes: {}
+      }
+
+      const sampleResponseExistingComputeContexts = {
+        items: [sampleExistingComputeContext]
+      }
+      const sampleResponseCreatedComputeContext = {
+        items: [sampleNewComputeContext]
+      }
+
+      fakeGlobalFetch([
+        sampleResponseExistingComputeContexts,
+        sampleResponseCreatedComputeContext
+      ])
+
+      await expect(
+        contextManager.createComputeContext(
+          contextName,
+          getRandomDefaultLauncherContext(),
+          'fakeAccountId',
+          []
+        )
+      ).resolves.toEqual({
+        items: [
+          {
+            attributes: {},
+            createdBy: 'fake creator',
+            id: 'fakeId',
+            name: contextName,
+            version: 2
+          }
+        ]
+      })
+    })
+
+    it('should create compute context with not existing launcher context', async () => {
+      const computeContextName = 'New Compute Context'
+      const launcherContextName = 'New Launcher Context'
+
+      const sampleExistingComputeContext = {
+        createdBy: 'fake creator',
+        id: 'fakeId',
+        version: 2,
+        name: 'Existing Compute Context',
+        attributes: {}
+      }
+      const sampleNewComputeContext = {
+        createdBy: 'fake creator',
+        id: 'fakeId',
+        version: 2,
+        name: computeContextName,
+        attributes: {}
+      }
+      const sampleNewLauncherContext = {
+        createdBy: 'fake creator',
+        id: 'fakeId',
+        version: 2,
+        name: launcherContextName,
+        attributes: {}
+      }
+
+      const sampleResponseExistingComputeContexts = {
+        items: [sampleExistingComputeContext]
+      }
+      const sampleResponseCreatedLauncherContext = {
+        items: [sampleNewLauncherContext]
+      }
+      const sampleResponseCreatedComputeContext = {
+        items: [sampleNewComputeContext]
+      }
+
+      fakeGlobalFetch([
+        sampleResponseExistingComputeContexts,
+        sampleResponseCreatedLauncherContext,
+        sampleResponseCreatedComputeContext
+      ])
+
+      await expect(
+        contextManager.createComputeContext(
+          computeContextName,
+          launcherContextName,
+          'fakeAccountId',
+          []
+        )
+      ).resolves.toEqual({
+        items: [
+          {
+            attributes: {},
+            createdBy: 'fake creator',
+            id: 'fakeId',
+            name: computeContextName,
+            version: 2
+          }
+        ]
+      })
+    })
+  })
+
+  describe('createLauncherContext', () => {
+    it('should throw an error if context name was not provided', async () => {
+      await expect(
+        contextManager.createLauncherContext('', 'Test Description')
+      ).rejects.toEqual(new Error('Context name is required.'))
+    })
+
+    it('should throw an error when attempt to create context with reserved name', async () => {
+      const contextName = getRandomDefaultLauncherContext()
+
+      await expect(
+        contextManager.createLauncherContext(contextName, 'Test Description')
+      ).rejects.toEqual(
+        new Error(`Launcher context '${contextName}' already exists.`)
+      )
+    })
+
+    it('should throw an error if context already exists', async () => {
+      const contextName = 'Existing Launcher Context'
+
+      const sampleLauncherContext = {
+        createdBy: 'fake creator',
+        id: 'fakeId',
+        version: 2,
+        name: contextName,
+        attributes: {}
+      }
+
+      const sampleResponse = {
+        items: [sampleLauncherContext]
+      }
+
+      fakeGlobalFetch([sampleResponse])
+
+      await expect(
+        contextManager.createLauncherContext(contextName, 'Test Description')
+      ).rejects.toEqual(
+        new Error(`Launcher context '${contextName}' already exists.`)
+      )
+    })
+
+    it('should create launcher context', async () => {
+      const contextName = 'New Launcher Context'
+
+      const sampleExistingLauncherContext = {
+        createdBy: 'fake creator',
+        id: 'fakeId',
+        version: 2,
+        name: 'Existing Launcher Context',
+        attributes: {}
+      }
+      const sampleNewLauncherContext = {
+        createdBy: 'fake creator',
+        id: 'fakeId',
+        version: 2,
+        name: contextName,
+        attributes: {}
+      }
+
+      const sampleResponseExistingLauncherContext = {
+        items: [sampleExistingLauncherContext]
+      }
+      const sampleResponseCreatedLauncherContext = {
+        items: [sampleNewLauncherContext]
+      }
+
+      fakeGlobalFetch([
+        sampleResponseExistingLauncherContext,
+        sampleResponseCreatedLauncherContext
+      ])
+
+      await expect(
+        contextManager.createLauncherContext(contextName, 'Test Description')
+      ).resolves.toEqual({
+        items: [
+          {
+            attributes: {},
+            createdBy: 'fake creator',
+            id: 'fakeId',
+            name: contextName,
+            version: 2
+          }
+        ]
+      })
+    })
+  })
+
+  describe('editComputeContext', () => {
+    const editedContext = {
+      name: 'updated name',
+      description: 'updated description',
+      id: 'someId'
+    }
+
+    it('should throw an error if context name was not provided', async () => {
+      await expect(
+        contextManager.editComputeContext('', editedContext)
+      ).rejects.toEqual(new Error('Context name is required.'))
+    })
+
+    it('should throw an error when attempt to edit context with reserved name', async () => {
+      const contextName = getRandomDefaultComputeContext()
+
+      let editError: Error = { name: '', message: '' }
+
+      try {
+        contextManager.isDefaultContext(
+          contextName,
+          defaultComputeContexts,
+          'Editing default SAS compute contexts is not allowed.',
+          true
+        )
+      } catch (error) {
+        editError = error
+      }
+
+      await expect(
+        contextManager.editComputeContext(contextName, editedContext)
+      ).rejects.toEqual(editError)
+    })
+
+    it('should edit context if founded by name', async () => {
+      const sampleComputeContext = {
+        createdBy: 'fake creator',
+        id: 'fakeId',
+        version: 2,
+        name: editedContext.name,
+        attributes: {}
+      }
+
+      const sampleResponseGetComputeContextByName = {
+        items: [sampleComputeContext]
+      }
+
+      fakeGlobalFetch([sampleResponseGetComputeContextByName])
+
+      const expectedResponse = {
+        etag: '',
+        result: sampleResponseGetComputeContextByName
+      }
+
+      await expect(
+        contextManager.editComputeContext(editedContext.name, editedContext)
+      ).resolves.toEqual(expectedResponse)
+    })
+  })
+
+  describe('getExecutableContexts', () => {
+    it('should return executable contexts', async () => {
+      const sampleComputeContext = {
+        createdBy: 'fake creator',
+        id: 'fakeId',
+        version: 2,
+        name: 'Executable Compute Context',
+        attributes: {}
+      }
+
+      const sampleResponse = {
+        items: [sampleComputeContext]
+      }
+
+      fakeGlobalFetch([sampleResponse])
+
+      const user = 'testUser'
+
+      const fakedExecuteScript = async () => {
+        return Promise.resolve({ log: `SYSUSERID=${user}` })
+      }
+
+      const expectedResponse = [
+        {
+          ...sampleComputeContext,
+          attributes: { sysUserId: user }
+        }
+      ]
+
+      await expect(
+        contextManager.getExecutableContexts(fakedExecuteScript)
+      ).resolves.toEqual(expectedResponse)
+    })
+
+    it('should not return executable contexts', async () => {
+      const sampleComputeContext = {
+        createdBy: 'fake creator',
+        id: 'fakeId',
+        version: 2,
+        name: 'Not Executable Compute Context',
+        attributes: {}
+      }
+
+      const sampleResponse = {
+        items: [sampleComputeContext]
+      }
+
+      fakeGlobalFetch([sampleResponse])
+
+      const fakedExecuteScript = async () => {
+        return Promise.resolve({ log: '' })
+      }
+
+      await expect(
+        contextManager.getExecutableContexts(fakedExecuteScript)
+      ).resolves.toEqual([])
+    })
+  })
+
+  describe('deleteComputeContext', () => {
+    it('should throw an error if context name was not provided', async () => {
+      await expect(contextManager.deleteComputeContext('')).rejects.toEqual(
+        new Error('Context name is required.')
+      )
+    })
+
+    it('should throw an error when attempt to delete context with reserved name', async () => {
+      const contextName = getRandomDefaultComputeContext()
+
+      let deleteError: Error = { name: '', message: '' }
+
+      try {
+        contextManager.isDefaultContext(
+          contextName,
+          defaultComputeContexts,
+          'Deleting default SAS compute contexts is not allowed.',
+          true
+        )
+      } catch (error) {
+        deleteError = error
+      }
+
+      await expect(
+        contextManager.deleteComputeContext(contextName)
+      ).rejects.toEqual(deleteError)
+    })
+
+    it('should delete context', async () => {
+      const contextName = 'Compute Context To Delete'
+
+      const sampleComputeContext = {
+        createdBy: 'fake creator',
+        id: 'fakeId',
+        version: 2,
+        name: contextName,
+        attributes: {}
+      }
+
+      const sampleResponseGetComputeContextByName = {
+        items: [sampleComputeContext]
+      }
+
+      const sampleResponseDeletedContext = {
+        items: [sampleComputeContext]
+      }
+
+      fakeGlobalFetch([
+        sampleResponseGetComputeContextByName,
+        sampleResponseDeletedContext
+      ])
+
+      const expectedResponse = {
+        etag: '',
+        result: sampleResponseDeletedContext
+      }
+
+      await expect(
+        contextManager.deleteComputeContext(contextName)
+      ).resolves.toEqual(expectedResponse)
+    })
+  })
+})

webpack.config.js

@@ -26,7 +26,8 @@ const browserConfig = {
     ]
   },
   resolve: {
-    extensions: ['.ts', '.js']
+    extensions: ['.ts', '.js'],
+    fallback: { https: false }
   },
   output: {
     filename: 'index.js',