chore(auth manager): tests fix

.github/PULL_REQUEST_TEMPLATE.md

@@ -14,7 +14,7 @@ What code changes have been made to achieve the intent.
 
 No PR (that involves a non-trivial code change) should be merged, unless all items below are confirmed!  If an urgent fix is needed - use a tar file.
 
-- [ ] Unit tests coverage has been increased and a new threshold is set.
+
 - [ ] All `sasjs-cli` unit tests are passing (`npm test`).
 - (CI Runs this) All `sasjs-tests` are passing. If you want to run it manually (instructions available [here](https://github.com/sasjs/adapter/blob/master/sasjs-tests/README.md)).
 - [ ] [Data Controller](https://datacontroller.io) builds and is functional on both SAS 9 and Viya

.github/vpn/config.ovpn

@@ -3,12 +3,10 @@ client
 tls-client
 dev tun
 # this will connect with whatever proto DNS tells us (https://community.openvpn.net/openvpn/ticket/934)
-proto udp
-remote vpn.4gl.io 7194
+proto tcp
+remote vpn.4gl.io 7494
 resolv-retry infinite
-# this will fallback from udp6 to udp4 as well
-connect-timeout 5
-data-ciphers AES-256-CBC:AES-256-GCM
+cipher AES-256-CBC
 auth SHA256
 script-security 2
 keepalive 10 120

.github/workflows/assign-reviewer.yml

@@ -10,4 +10,4 @@ jobs:
       - uses: actions/checkout@v2
       - uses: uesteibar/reviewer-lottery@v1
         with:
-          repo-token: ${{ secrets.GITHUB_TOKEN }}
+          repo-token: ${{ secrets.GH_TOKEN }}

.github/workflows/build-unit-tests.yml

@@ -1,58 +0,0 @@
-# This workflow will do a clean install of node dependencies, build the source code and run tests across different versions of node
-# For more information see: https://help.github.com/actions/language-and-framework-guides/using-nodejs-with-github-actions
-
-name: SASjs Build and Unit Test
-
-on:
-  pull_request:
-
-jobs:
-  build:
-    runs-on: ubuntu-22.04
-
-    strategy:
-      matrix:
-        node-version: [lts/hydrogen]
-
-    steps:
-      - uses: actions/checkout@v2
-      - name: Use Node.js ${{ matrix.node-version }}
-        uses: actions/setup-node@v2
-        with:
-          node-version: ${{ matrix.node-version }}
-
-       # 2. Restore npm cache manually
-      - name: Restore npm cache
-        uses: actions/cache@v3
-        id: npm-cache
-        with:
-          path: ~/.npm
-          key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
-          restore-keys: |
-            ${{ runner.os }}-node-
-
-      - name: Check npm audit
-        run: npm audit --production --audit-level=low
-
-      - name: Install Dependencies
-        run: npm ci
-
-      - name: Install Rimraf
-        run: npm i rimraf
-
-      - name: Check code style
-        run: npm run lint
-
-      - name: Run unit tests
-        run: npm test
-
-      - name: Build Package
-        run: npm run package:lib
-        env:
-          CI: true
-
-      # For some reason if coverage report action is run before other commands, those commands can't access the directories and files on which they depend on
-      - name: Generate coverage report
-        uses: artiomtr/jest-coverage-report-action@v2.0-rc.2
-        with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/build.yml

@@ -1,108 +1,94 @@
-# This workflow will do a clean install of node dependencies, build the source code and run tests across different versions of node
-# For more information see: https://help.github.com/actions/language-and-framework-guides/using-nodejs-with-github-actions
-
-name: SASjs Build and Server Tests
-
-on:
-  pull_request:
-
-jobs:
-  test:
-    runs-on: ubuntu-22.04
-
-    strategy:
-      matrix:
-        node-version: [lts/hydrogen]
-
-    steps:
-      - uses: actions/checkout@v2
-      - name: Use Node.js ${{ matrix.node-version }}
-        uses: actions/setup-node@v2
-        with:
-          node-version: ${{ matrix.node-version }}
-
-      # 2. Restore npm cache manually
-      - name: Restore npm cache
-        uses: actions/cache@v3
-        id: npm-cache
-        with:
-          path: ~/.npm
-          key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
-          restore-keys: |
-            ${{ runner.os }}-node-
-
-      - name: Install Dependencies
-        run: npm ci
-
-      - name: Install Rimraf
-        run: npm i rimraf
-
-      - name: Build Package
-        run: npm run package:lib
-        env:
-          CI: true
-
-      - name: Write VPN Files
-        run: |
-          echo "$CA_CRT" > .github/vpn/ca.crt
-          echo "$USER_CRT" > .github/vpn/user.crt
-          echo "$USER_KEY" > .github/vpn/user.key
-          echo "$TLS_KEY" > .github/vpn/tls.key
-        shell: bash
-        env:
-          CA_CRT: ${{ secrets.CA_CRT}}
-          USER_CRT: ${{ secrets.USER_CRT }}
-          USER_KEY: ${{ secrets.USER_KEY }}
-          TLS_KEY: ${{ secrets.TLS_KEY }}
-
-      - name: Chmod VPN files
-        run: |
-          chmod 600 .github/vpn/ca.crt .github/vpn/user.crt .github/vpn/user.key .github/vpn/tls.key
-
-      - name: Install Open VPN
-        run: |
-          sudo apt install apt-transport-https
-          sudo wget https://swupdate.openvpn.net/repos/openvpn-repo-pkg-key.pub
-          sudo apt-key add openvpn-repo-pkg-key.pub
-          sudo wget -O /etc/apt/sources.list.d/openvpn3.list https://swupdate.openvpn.net/community/openvpn3/repos/openvpn3-jammy.list
-          sudo apt update
-          sudo apt install openvpn3=17~betaUb22042+jammy
-
-      - name: Start Open VPN 3
-        run: openvpn3 session-start --config .github/vpn/config.ovpn
-
-      - name: install pm2
-        run: npm i -g pm2
-
-      - name: Fetch SASJS server
-        run: curl ${{ secrets.SASJS_SERVER_URL }}/SASjsApi/info
-
-      - name: Deploy sasjs-tests
-        run: |
-          sudo apt install jq
-          cd sasjs-tests
-          jq '.dependencies."@sasjs/adapter" |= "latest"' ./package.json > ./package.temp && mv ./package.temp ./package.json
-          npm i
-          jq '.sasJsConfig.serverUrl |= "${{ secrets.SASJS_SERVER_URL }}"' ./public/config.json > ./public/config.temp && mv ./public/config.temp ./public/config.json
-          jq '.sasJsConfig.serverType |= "SASJS"' ./public/config.json > ./public/config.temp && mv ./public/config.temp ./public/config.json
-          jq '.userName |= "${{ secrets.SASJS_USERNAME }}"' ./public/config.json > ./public/config.temp && mv ./public/config.temp ./public/config.json
-          jq '.password |= "${{ secrets.SASJS_PASSWORD }}"' ./public/config.json > ./public/config.temp && mv ./public/config.temp ./public/config.json
-
-          cat ./public/config.json
-
-          npm run update:adapter
-          pm2 start --name sasjs-test npm -- start
-
-      - name: Sleep for 10 seconds
-        run: sleep 10s
-        shell: bash
-
-      - name: Run cypress on sasjs
-        run: |
-          jq '.env.sasjsTestsUrl |= "http://localhost:3000"' ./cypress.json > ./cypress.temp && mv ./cypress.temp ./cypress.json
-          jq '.env.username |= "${{ secrets.SASJS_USERNAME }}"' ./cypress.json > ./cypress.temp && mv ./cypress.temp ./cypress.json
-          jq '.env.password |= "${{ secrets.SASJS_PASSWORD }}"' ./cypress.json > ./cypress.temp && mv ./cypress.temp ./cypress.json
-          cat ./cypress.json
-          echo "SASJS_USERNAME=${{ secrets.SASJS_USERNAME }}"
-
-          sh ./sasjs-tests/sasjs-cypress-run.sh ${{ secrets.MATRIX_TOKEN }} https://github.com/${{github.repository}}/actions/runs/${{github.run_id}}
+# This workflow will do a clean install of node dependencies, build the source code and run tests across different versions of node
+# For more information see: https://help.github.com/actions/language-and-framework-guides/using-nodejs-with-github-actions
+
+name: SASjs Build
+
+on:
+  pull_request:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    strategy:
+      matrix:
+        node-version: [lts/hydrogen]
+
+    steps:
+      - uses: actions/checkout@v2
+      - name: Use Node.js ${{ matrix.node-version }}
+        uses: actions/setup-node@v2
+        with:
+          node-version: ${{ matrix.node-version }}
+          cache: npm
+
+      - name: Check npm audit
+        run: npm audit --production --audit-level=low
+
+      - name: Install Dependencies
+        run: npm ci
+
+      - name: Check code style
+        run: npm run lint
+
+      - name: Run unit tests
+        run: npm test
+
+      - name: Build Package
+        run: npm run package:lib
+        env:
+          CI: true
+
+      - name: Write VPN Files
+        run: |
+          echo "$CA_CRT" > .github/vpn/ca.crt
+          echo "$USER_CRT" > .github/vpn/user.crt
+          echo "$USER_KEY" > .github/vpn/user.key
+          echo "$TLS_KEY" > .github/vpn/tls.key
+        shell: bash
+        env:
+          CA_CRT: ${{ secrets.CA_CRT}}
+          USER_CRT: ${{ secrets.USER_CRT }}
+          USER_KEY: ${{ secrets.USER_KEY }}
+          TLS_KEY: ${{ secrets.TLS_KEY }}
+
+      - name: Install Open VPN
+        run: |
+          sudo apt install apt-transport-https
+          sudo wget https://swupdate.openvpn.net/repos/openvpn-repo-pkg-key.pub
+          sudo apt-key add openvpn-repo-pkg-key.pub
+          sudo wget -O /etc/apt/sources.list.d/openvpn3.list https://swupdate.openvpn.net/community/openvpn3/repos/openvpn3-jammy.list
+          sudo apt update
+          sudo apt install openvpn3=17~betaUb22042+jammy
+
+      - name: Start Open VPN 3
+        run: openvpn3 session-start --config .github/vpn/config.ovpn
+
+      - name: install pm2
+        run: npm i -g pm2
+
+      - name: Deploy sasjs-tests
+        run: |
+          npm install -g replace-in-files-cli
+          cd sasjs-tests
+          replace-in-files --regex='"@sasjs/adapter".*' --replacement='"@sasjs/adapter":"latest",' ./package.json
+          npm i
+          replace-in-files --regex='"serverUrl".*' --replacement='"serverUrl":"${{ secrets.SASJS_SERVER_URL }}",' ./public/config.json
+          replace-in-files --regex='"userName".*' --replacement='"userName":"${{ secrets.SASJS_USERNAME }}",' ./public/config.json
+          replace-in-files --regex='"password".*' --replacement='"password":"${{ secrets.SASJS_PASSWORD }}",' ./public/config.json
+          replace-in-files --regex='"serverType".*' --replacement='"serverType":"SASJS",' ./public/config.json
+          npm run update:adapter
+          pm2 start --name sasjs-test npm -- start
+
+      - name: Run cypress on sasjs
+        run: |
+          replace-in-files --regex='"sasjsTestsUrl".*' --replacement='"sasjsTestsUrl":"http://localhost:3000",' ./cypress.json
+          replace-in-files --regex='"username".*' --replacement='"username":"${{ secrets.SASJS_USERNAME }}",' ./cypress.json
+          replace-in-files --regex='"password".*' --replacement='"password":"${{ secrets.SASJS_PASSWORD }}",' ./cypress.json
+          sh ./sasjs-tests/sasjs-cypress-run.sh ${{ secrets.MATRIX_TOKEN }} https://github.com/${{github.repository}}/actions/runs/${{github.run_id}}
+
+      # For some reason if coverage report action is run before other commands, those commands can't access the directories and files on which they depend on
+      - name: Generate coverage report
+        uses: artiomtr/jest-coverage-report-action@v2.0-rc.2
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/generateDocs.yml

@@ -21,16 +21,7 @@ jobs:
         uses: actions/setup-node@v2
         with:
           node-version: ${{ matrix.node-version }}
-
-                 # 2. Restore npm cache manually
-      - name: Restore npm cache
-        uses: actions/cache@v3
-        id: npm-cache
-        with:
-          path: ~/.npm
-          key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
-          restore-keys: |
-            ${{ runner.os }}-node-
+          cache: npm
 
       - name: Install Dependencies
         run: npm ci
@@ -46,8 +37,8 @@ jobs:
       - name: Push generated docs
         uses: peaceiris/actions-gh-pages@v3
         with:
-          github_token: ${{ secrets.GITHUB_TOKEN }}
+          github_token: ${{ secrets.GH_TOKEN }}
           publish_branch: gh-pages
-          publish_dir: ./docs
+          publish_dir: ./docs 
           cname: adapter.sasjs.io
 

.github/workflows/npmpublish.yml

@@ -22,16 +22,7 @@ jobs:
         uses: actions/setup-node@v2
         with:
           node-version: ${{ matrix.node-version }}
-
-       # 2. Restore npm cache manually
-      - name: Restore npm cache
-        uses: actions/cache@v3
-        id: npm-cache
-        with:
-          path: ~/.npm
-          key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
-          restore-keys: |
-            ${{ runner.os }}-node-
+          cache: npm
 
       - name: Install Dependencies
         run: npm ci
@@ -45,7 +36,7 @@ jobs:
       - name: Semantic Release
         uses: cycjimmy/semantic-release-action@v3
         env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          GITHUB_TOKEN: ${{ secrets.GH_TOKEN }}
           NPM_TOKEN: ${{ secrets.NPM_TOKEN }}
 
       - name: Send Matrix message

.vscode/settings.json

@@ -1,3 +0,0 @@
-{
-  "cSpell.words": ["SASVIYA"]
-}

README.md

@@ -3,16 +3,18 @@
 [![npm package][npm-image]][npm-url]
 [![Github Workflow][githubworkflow-image]][githubworkflow-url]
 [![npm](https://img.shields.io/npm/dt/@sasjs/adapter)]()
-![GitHub License](https://img.shields.io/github/license/sasjs/adapter)
+![Snyk Vulnerabilities for npm package](https://img.shields.io/snyk/vulnerabilities/npm/@sasjs/adapter)
+[![License](https://img.shields.io/apm/l/atomic-design-ui.svg)](/LICENSE)
 ![GitHub top language](https://img.shields.io/github/languages/top/sasjs/adapter)
 ![GitHub issues](https://img.shields.io/github/issues/sasjs/adapter)
 [![Gitpod ready-to-code](https://img.shields.io/badge/Gitpod-ready--to--code-908a85?logo=gitpod)](https://gitpod.io/#https://github.com/sasjs/adapter)
 
-[npm-image]: https://img.shields.io/npm/v/@sasjs/adapter.svg
-[npm-url]: http://npmjs.org/package/@sasjs/adapter
-[githubworkflow-image]: https://github.com/sasjs/adapter/actions/workflows/build-unit-tests.yml/badge.svg
-[githubworkflow-url]: https://github.com/sasjs/adapter/blob/main/.github/workflows/build.yml
-[dependency-image]: https://david-dm.org/sasjs/adapter.svg
+
+[npm-image]:https://img.shields.io/npm/v/@sasjs/adapter.svg
+[npm-url]:http://npmjs.org/package/@sasjs/adapter
+[githubworkflow-image]:https://github.com/sasjs/adapter/actions/workflows/build.yml/badge.svg
+[githubworkflow-url]:https://github.com/sasjs/adapter/blob/main/.github/workflows/build.yml
+[dependency-image]:https://david-dm.org/sasjs/adapter.svg
 
 SASjs is a open-source framework for building Web Apps on SAS® platforms. You can use as much or as little of it as you like. This repository contains the JS adapter, the part that handles the to/from SAS communication on the client side. There are 3 ways to install it:
 
@@ -67,27 +69,24 @@ There are three parts to consider:
 
 To install the library you can simply run `npm i @sasjs/adapter` or include a `<script>` tag with a reference to our [CDN](https://www.jsdelivr.com/package/npm/@sasjs/adapter).
 
-Full technical documentation is available [here](https://adapter.sasjs.io). The main parts are:
+Full technical documentation is available [here](https://adapter.sasjs.io).  The main parts are:
 
 ### Instantiation
-
 The following code will instantiate an instance of the adapter:
 
 ```javascript
-let sasJs = new SASjs.default({
-  appLoc: '/Your/SAS/Folder',
-  serverType: 'SAS9'
-})
+let sasJs = new SASjs.default(
+  {
+    appLoc: "/Your/SAS/Folder",
+    serverType:"SAS9"
+  }
+);
 ```
-
 If you've installed it via NPM, you can import it as a default import like so:
-
 ```js
-import SASjs from '@sasjs/adapter'
+  import SASjs from '@sasjs/adapter';
 ```
-
 You can then instantiate it with:
-
 ```js
 const sasJs = new SASjs({your config})
 ```
@@ -95,11 +94,10 @@ const sasJs = new SASjs({your config})
 More on the config later.
 
 ### SAS Logon
+All authentication from the adapter is done against SASLogon.  There are two approaches that can be taken, which are configured using the `loginMechanism` attribute of the sasJs config object (above):
 
-All authentication from the adapter is done against SASLogon. There are two approaches that can be taken, which are configured using the `loginMechanism` attribute of the sasJs config object (above):
-
-- `loginMechanism:'Redirected'` - this approach enables authentication through a SASLogon window, supporting complex authentication flows (such as 2FA) and avoids the need to handle passwords in the application itself. The styling of the window can be modified using CSS.
-- `loginMechanism:'Default'` - this approach requires that the username and password are captured, and used within the `.login()` method. This can be helpful for development, or automated testing.
+* `loginMechanism:'Redirected'` - this approach enables authentication through a SASLogon window, supporting complex authentication flows (such as 2FA) and avoids the need to handle passwords in the application itself.  The styling of the window can be modified using CSS.
+* `loginMechanism:'Default'` - this approach requires that the username and password are captured, and used within the `.login()` method.  This can be helpful for development, or automated testing.
 
 Sample code for logging in with the `Default` approach:
 
@@ -116,53 +114,44 @@ sasJs.logIn('USERNAME','PASSWORD'
 
 More examples of using authentication, and more, can be found in the [SASjs Seed Apps](https://github.com/search?q=topic%3Asasjs-app+org%3Asasjs+fork%3Atrue) on github.
 
-### Request / Response
-
+###  Request / Response
 A simple request can be sent to SAS in the following fashion:
 
 ```javascript
-sasJs.request('/path/to/my/service', dataObject).then((response) => {
-  // all tables are in the response object, eg:
-  console.log(response.tablewith2cols1row[0].COL1.value)
-})
+sasJs.request("/path/to/my/service", dataObject)
+  .then((response) => {
+    // all tables are in the response object, eg:
+    console.log(response.tablewith2cols1row[0].COL1.value)
+  })
 ```
 
 We supply the path to the SAS service, and a data object.
 
-If the path starts with a `/` then it should be a full path to the service. If there is no leading `/` then it is relative to the `appLoc`.
+If the path starts with a `/` then it should be a full path to the service.  If there is no leading `/` then it is relative to the `appLoc`.
 
 The data object can be null (for services with no input), or can contain one or more "tables" in the following format:
 
 ```javascript
-let dataObject = {
-  tablewith2cols1row: [
-    {
-      col1: 'val1',
-      col2: 42
-    }
-  ],
-  tablewith1col2rows: [
-    {
-      col: 'row1'
-    },
-    {
-      col: 'row2'
-    }
-  ]
-}
+let dataObject={
+	"tablewith2cols1row": [{
+		"col1": "val1",
+		"col2": 42
+	}],
+	"tablewith1col2rows": [{
+		"col": "row1"
+	}, {
+		"col": "row2"
+	}]
+};
 ```
 
 These tables (`tablewith2cols1row` and `tablewith1col2rows`) will be created in SAS WORK after running `%webout(FETCH)` in your SAS service.
 
 The `request()` method also has optional parameters such as a config object and a callback login function.
 
-The response object will contain returned tables and columns. Table names are always lowercase, and column names uppercase.
+The response object will contain returned tables and columns.  Table names are always lowercase, and column names uppercase.
 
-The adapter will also cache the logs (if debug enabled) and even the work tables. For performance, it is best to keep debug mode off.
-
-### Verbose Mode
-
-Set `verbose` to `true` to enable verbose mode that logs a summary of every HTTP response. Verbose mode can be disabled by calling `disableVerboseMode` method or enabled by `enableVerboseMode` method. Verbose mode also supports `bleached` mode that disables extra colors in req/res summary. To enable `bleached` verbose mode, pass `verbose` equal to `bleached` while instantiating an instance of `RequestClient` or to `setVerboseMode` method. Verbose mode can also be enabled/disabled by `startComputeJob` method.
+The adapter will also cache the logs (if debug enabled) and even the work tables.  For performance, it is best to keep debug mode off.
 
 ### Session Manager
 
@@ -176,46 +165,45 @@ To execute a script on Viya a session has to be created first which is time-cons
 
 The SAS type (char/numeric) of the values is determined according to a set of rules:
 
-- If the values are numeric, the SAS type is numeric
-- If the values are all string, the SAS type is character
-- If the values contain a single character (a-Z + underscore + .) AND a numeric, then the SAS type is numeric (with special missing values).
-- `null` is set to either '.' or '' depending on the assigned or derived type per the above rules. If entire column is `null` then the type will be numeric.
+* If the values are numeric, the SAS type is numeric
+* If the values are all string, the SAS type is character
+* If the values contain a single character (a-Z + underscore + .) AND a numeric, then the SAS type is numeric (with special missing values).
+* `null` is set to either '.' or '' depending on the assigned or derived type per the above rules.  If entire column is `null` then the type will be numeric.
 
 The following table illustrates the formats applied to columns under various scenarios:
 
-| JS Values        | SAS Format |
-| ---------------- | ---------- |
-| 'a', 'a'         | $char1.    |
-| 0, '\_'          | best.      |
-| 'Z', 0           | best.      |
-| 'a', 'aaa'       | $char3.    |
-| null, 'a', 'aaa' | $char3.    |
-| null, 'a', 0     | best.      |
-| null, null       | best.      |
-| null, ''         | $char1.    |
-| null, 'a'        | $char1.    |
-| 'a'              | $char1.    |
-| 'a', null        | $char1.    |
-| 'a', null, 0     | best.      |
+|JS Values |SAS Format|
+|---|---|
+|'a', 'a' |$char1.|
+|0, '_' |best.|
+|'Z', 0 |best.|
+|'a', 'aaa' |$char3.|
+|null, 'a', 'aaa' | $char3.|
+|null, 'a', 0 | best.|
+|null, null | best.|
+|null, '' | $char1.|
+|null, 'a' | $char1.|
+|'a' | $char1.|
+|'a', null | $char1.|
+|'a', null, 0 | best.|
 
-Validation is also performed on the values. The following combinations will throw errors:
+Validation is also performed on the values.  The following combinations will throw errors:
 
-| JS Values       | SAS Format                                                 |
-| --------------- | ---------------------------------------------------------- |
-| null, 'aaaa', 0 | Error: mixed types. 'aaaa' is not a special missing value. |
-| 0, 'a', '!'     | Error: mixed types. '!' is not a special missing value     |
-| 1.1, '.', 0     | Error: mixed types. For regular nulls, use `null`          |
+|JS Values |SAS Format|
+|---|---|
+|null, 'aaaa', 0 | Error: mixed types. 'aaaa' is not a special missing value.|
+|0, 'a', '!' | Error: mixed types. '!' is not a special missing value|
+|1.1, '.', 0| Error: mixed types.  For regular nulls, use `null`|
 
 ### Variable Format Override
-
 The auto-detect functionality above is thwarted in the following scenarios:
 
-- A character column containing only `null` values (is considered numeric)
-- A numeric column containing only special missing values (is considered character)
+* A character column containing only `null` values (is considered numeric)
+* A numeric column containing only special missing values (is considered character)
 
 To cater for these scenarios, an optional array of formats can be passed along with the data to ensure that SAS will read them in correctly.
 
-To understand these formats, it should be noted that the JSON data is NOT passed directly (as JSON) to SAS. It is first converted into CSV, and the header row is actually an `infile` statement in disguise. It looks a bit like this:
+To understand these formats, it should be noted that the JSON data is NOT passed directly (as JSON) to SAS. It is first converted into CSV, and the header row is actually an `infile` statement in disguise.  It looks a bit like this:
 
 ```csv
 CHARVAR1:$char4. CHARVAR2:$char1. NUMVAR:best.
@@ -226,13 +214,14 @@ ABCD,X,.
 To provide overrides to this header row, the tables object can be constructed as follows (with a leading '$' in the table name):
 
 ```javascript
-let specialData = {
-  tablewith2cols2rows: [
-    { col1: 'val1', specialMissingsCol: 'A' },
-    { col1: 'val2', specialMissingsCol: '_' }
+let specialData={
+  "tablewith2cols2rows": [
+    {"col1": "val1","specialMissingsCol": "A"},
+    {"col1": "val2","specialMissingsCol": "_"}
   ],
-  $tablewith2cols2rows: { formats: { specialMissingsCol: 'best.' } }
-}
+  "$tablewith2cols2rows":{"formats":{"specialMissingsCol":"best."}
+  }
+};
 ```
 
 It is not necessary to provide formats for ALL the columns, only the ones that need to be overridden.
@@ -261,15 +250,14 @@ run;
 %webout(CLOSE) /* Close the JSON and add default variables */
 ```
 
-By default, special SAS numeric missings (\_a-Z) are converted to `null` in the JSON. If you'd like to preserve these, use the `missing=STRING` option as follows:
+By default, special SAS numeric missings (_a-Z) are converted to `null` in the JSON.  If you'd like to preserve these, use the `missing=STRING` option as follows:
 
 ```sas
 %webout(OBJ,a,missing=STRING)
 ```
-
 In this case, special missings (such as `.a`, `.b`) are converted to javascript string values (`'A', 'B'`).
 
-Where an entire column is made up of special missing numerics, there would be no way to distinguish it from a single-character column by looking at the values. To cater for this scenario, it is possible to export the variable types (and other attributes such as label and format) by adding a `showmeta` param to the `webout()` macro as follows:
+Where an entire column is made up of special missing numerics, there would be no way to distinguish it from a single-character column by looking at the values.  To cater for this scenario, it is possible to export the variable types (and other attributes such as label and format) by adding a `showmeta` param to the `webout()` macro as follows:
 
 ```sas
 %webout(OBJ,a,missing=STRING,showmeta=YES)
@@ -279,23 +267,22 @@ The `%webout()` macro itself is just a wrapper for the [mp_jsonout](https://core
 
 ## Configuration
 
-Configuration on the client side involves passing an object on startup, which can also be passed with each request. Technical documentation on the SASjsConfig class is available [here](https://github.com/sasjs/adapter/blob/master/src/types/SASjsConfig.ts). The main config items are:
+Configuration on the client side involves passing an object on startup, which can also be passed with each request.  Technical documentation on the SASjsConfig class is available [here](https://adapter.sasjs.io/classes/types.sasjsconfig.html).  The main config items are:
 
-- `appLoc` - this is the folder (eg in metadata or SAS Drive) under which the SAS services are created.
-- `serverType` - either `SAS9`, `SASVIYA` or `SASJS`. The `SASJS` server type is for use with [sasjs/server](https://github.com/sasjs/server).
-- `serverUrl` - the location (including http protocol and port) of the SAS Server. Can be omitted, eg if serving directly from the SAS Web Server, or in streaming mode.
-- `debug` - if `true` then SAS Logs and extra debug information is returned.
-- `verbose` - optional, if `true` then a summary of every HTTP response is logged.
-- `loginMechanism` - either `Default` or `Redirected`. See [SAS Logon](#sas-logon) section.
-- `useComputeApi` - Only relevant when the serverType is `SASVIYA`. If `true` the [Compute API](#using-the-compute-api) is used. If `false` the [JES API](#using-the-jes-api) is used. If `null` or `undefined` the [Web](#using-jes-web-app) approach is used.
-- `contextName` - Compute context on which the requests will be called. If missing or not provided, defaults to `Job Execution Compute context`.
-- `requestHistoryLimit` - Request history limit. Increasing this limit may affect browser performance, especially with debug (logs) enabled. Default is 10.
+* `appLoc` - this is the folder (eg in metadata or SAS Drive) under which the SAS services are created.
+* `serverType` - either `SAS9`, `SASVIYA` or `SASJS`.  The `SASJS` server type is for use with [sasjs/server](https://github.com/sasjs/server).
+* `serverUrl` - the location (including http protocol and port) of the SAS Server. Can be omitted, eg if serving directly from the SAS Web Server, or in streaming mode.
+* `debug` - if `true` then SAS Logs and extra debug information is returned.
+* `loginMechanism` - either `Default` or `Redirected`.  See [SAS Logon](#sas-logon) section.
+* `useComputeApi` - Only relevant when the serverType is `SASVIYA`. If `true` the [Compute API](#using-the-compute-api) is used.  If `false` the [JES API](#using-the-jes-api) is used.  If `null` or `undefined` the [Web](#using-jes-web-app) approach is used.
+* `contextName` - Compute context on which the requests will be called.  If missing or not provided, defaults to `Job Execution Compute context`.
+* `requestHistoryLimit` - Request history limit. Increasing this limit may affect browser performance, especially with debug (logs) enabled.  Default is 10.
 
-The adapter supports a number of approaches for interfacing with Viya (`serverType` is `SASVIYA`). For maximum performance, be sure to [configure your compute context](https://sasjs.io/guide-viya/#shared-account-and-server-re-use) with `reuseServerProcesses` as `true` and a system account in `runServerAs`. This functionality is available since Viya 3.5. This configuration is supported when [creating contexts using the CLI](https://sasjs.io/sasjs-cli-context/#sasjs-context-create).
+The adapter supports a number of approaches for interfacing with Viya (`serverType` is `SASVIYA`).  For maximum performance, be sure to [configure your compute context](https://sasjs.io/guide-viya/#shared-account-and-server-re-use) with `reuseServerProcesses` as `true` and a system account in `runServerAs`.  This functionality is available since Viya 3.5.  This configuration is supported when [creating contexts using the CLI](https://sasjs.io/sasjs-cli-context/#sasjs-context-create).
 
 ### Using JES Web App
 
-In this setup, all requests are routed through the JES web app, at `YOURSERVER/SASJobExecution?_program=/your/program`. This is the most reliable method, and also the slowest. One request is made to the JES app, and remaining requests (getting job uri, session spawning, passing parameters, running the program, fetching the log) are handled by the SAS server inside the JES app.
+In this setup, all requests are routed through the JES web app, at `YOURSERVER/SASJobExecution?_program=/your/program`.  This is the most reliable method, and also the slowest.  One request is made to the JES app, and remaining requests (getting job uri, session spawning, passing parameters, running the program, fetching the log) are handled by the SAS server inside the JES app.
 
 ```
 {
@@ -308,35 +295,34 @@ In this setup, all requests are routed through the JES web app, at `YOURSERVER/S
 Note - to use the web approach, the `useComputeApi` property must be `undefined` or `null`.
 
 ### Using the JES API
-
-Here we are running Jobs using the Job Execution Service except this time we are making the requests directly using the REST API instead of through the JES Web App. This is helpful when we need to call web services outside of a browser (eg with the SASjs CLI or other commandline tools). To save one network request, the adapter prefetches the JOB URIs and passes them in the `__job` parameter. Depending on your network bandwidth, it may or may not be faster than the JES Web approach.
+Here we are running Jobs using the Job Execution Service except this time we are making the requests directly using the REST API instead of through the JES Web App.  This is helpful when we need to call web services outside of a browser (eg with the SASjs CLI or other commandline tools).  To save one network request, the adapter prefetches the JOB URIs and passes them in the `__job` parameter.  Depending on your network bandwidth, it may or may not be faster than the JES Web approach.
 
 This approach (`useComputeApi: false`) also ensures that jobs are displayed in Environment Manager.
 
 ```json
 {
-  "appLoc": "/Your/Path",
-  "serverType": "SASVIYA",
-  "useComputeApi": false,
-  "contextName": "yourComputeContext"
+  appLoc:"/Your/Path",
+  serverType:"SASVIYA",
+  useComputeApi: false,
+  contextName: 'yourComputeContext'
 }
 ```
 
 ### Using the Compute API
-
-This approach is by far the fastest, as a result of the optimisations we have built into the adapter. With this configuration, in the first sasjs request, we take a URI map of the services in the target folder, and create a session manager. This manager will spawn a additional session every time a request is made. Subsequent requests will use the existing 'hot' session, if it exists. Sessions are always deleted after every use, which actually makes this _less_ resource intensive than a typical JES web app, in which all sessions are kept alive by default for 15 minutes.
+This approach is by far the fastest, as a result of the optimisations we have built into the adapter.  With this configuration, in the first sasjs request, we take a URI map of the services in the target folder, and create a session manager.  This manager will spawn a additional session every time a request is made. Subsequent requests will use the existing 'hot' session, if it exists.  Sessions are always deleted after every use, which actually makes this _less_ resource intensive than a typical JES web app, in which all sessions are kept alive by default for 15 minutes.
 
 With this approach (`useComputeApi: true`), the requests/logs will _not_ appear in the list in Environment manager.
 
 ```json
 {
-  "appLoc": "/Your/Path",
-  "serverType": "SASVIYA",
-  "useComputeApi": true,
-  "contextName": "yourComputeContext"
+  appLoc:"/Your/Path",
+  serverType:"SASVIYA",
+  useComputeApi: true,
+  contextName: "yourComputeContext"
 }
 ```
 
+
 # More resources
 
 For more information and examples specific to this adapter you can check out the [user guide](https://sasjs.io/sasjs-adapter/) or the [technical](http://adapter.sasjs.io/) documentation.
@@ -345,6 +331,7 @@ For more information on building web apps in general, check out these [resources
 
 As a SAS customer you can also request a copy of [Data Controller](https://datacontroller.io) - free for up to 5 users, this tool makes use of all parts of the SASjs framework.
 
+
 ## Star Gazing
 
 If you find this library useful, help us grow our star graph!
@@ -352,11 +339,8 @@ If you find this library useful, help us grow our star graph!
 ![](https://starchart.cc/sasjs/adapter.svg)
 
 ## Contributors ✨
-
 <!-- ALL-CONTRIBUTORS-BADGE:START - Do not remove or modify this section -->
-
 [![All Contributors](https://img.shields.io/badge/all_contributors-9-orange.svg?style=flat-square)](#contributors-)
-
 <!-- ALL-CONTRIBUTORS-BADGE:END -->
 
 Thanks goes to these wonderful people ([emoji key](https://allcontributors.org/docs/en/emoji-key)):

cypress/integration/sasjs.tests.ts

@@ -4,70 +4,93 @@ const password = Cypress.env('password')
 const testingFinishTimeout = Cypress.env('testingFinishTimeout')
 
 context('sasjs-tests', function () {
-  before(() => {
+  this.beforeAll(() => {
     cy.visit(sasjsTestsUrl)
   })
 
-  beforeEach(() => {
+  this.beforeEach(() => {
     cy.reload()
   })
 
-  function loginIfNeeded() {
+  it('Should have all tests successfull', (done) => {
     cy.get('body').then(($body) => {
-      if ($body.find('login-form').length > 0) {
-        cy.get('login-form')
-          .shadow()
-          .find('#username')
-          .should('be.visible')
-          .type(username)
-        cy.get('login-form')
-          .shadow()
-          .find('#password')
-          .should('be.visible')
-          .type(password)
-        cy.get('login-form')
-          .shadow()
-          .find('#submit-btn')
-          .should('be.visible')
-          .click()
-        cy.get('login-form').should('not.exist') // Wait for login to finish
-      }
-    })
-  }
+      cy.wait(1000).then(() => {
+        const startButton = $body.find(
+          '.ui.massive.icon.primary.left.labeled.button'
+        )[0]
 
-  it('Should have all tests successful', () => {
-    loginIfNeeded()
+        if (
+          !startButton ||
+          (startButton && !Cypress.dom.isVisible(startButton))
+        ) {
+          cy.get('input[placeholder="User Name"]').type(username)
+          cy.get('input[placeholder="Password"]').type(password)
+          cy.get('.submit-button').click()
+        }
 
-    cy.get('tests-view').shadow().find('#run-btn').should('be.visible').click()
-
-    cy.get('tests-view')
-      .shadow()
-      .find('#run-btn:disabled', {
-        timeout: testingFinishTimeout
+        cy.get('input[placeholder="User Name"]', { timeout: 40000 })
+          .should('not.exist')
+          .then(() => {
+            cy.get('.ui.massive.icon.primary.left.labeled.button')
+              .click()
+              .then(() => {
+                cy.get('.ui.massive.loading.primary.button', {
+                  timeout: testingFinishTimeout
+                })
+                  .should('not.exist')
+                  .then(() => {
+                    cy.get('span.icon.failed')
+                      .should('not.exist')
+                      .then(() => {
+                        done()
+                      })
+                  })
+              })
+          })
       })
-      .should('not.exist')
-
-    cy.get('test-card').shadow().find('.status-icon.failed').should('not.exist')
+    })
   })
 
-  it('Should have all tests successful with debug on', () => {
-    loginIfNeeded()
+  it('Should have all tests successfull with debug on', (done) => {
+    cy.get('body').then(($body) => {
+      cy.wait(1000).then(() => {
+        const startButton = $body.find(
+          '.ui.massive.icon.primary.left.labeled.button'
+        )[0]
 
-    cy.get('tests-view')
-      .shadow()
-      .find('#debug-toggle')
-      .should('be.visible')
-      .click()
+        if (
+          !startButton ||
+          (startButton && !Cypress.dom.isVisible(startButton))
+        ) {
+          cy.get('input[placeholder="User Name"]').type(username)
+          cy.get('input[placeholder="Password"]').type(password)
+          cy.get('.submit-button').click()
+        }
 
-    cy.get('tests-view').shadow().find('#run-btn').should('be.visible').click()
-
-    cy.get('tests-view')
-      .shadow()
-      .find('#run-btn:disabled', {
-        timeout: testingFinishTimeout
+        cy.get('.ui.fitted.toggle.checkbox label')
+          .click()
+          .then(() => {
+            cy.get('input[placeholder="User Name"]', { timeout: 40000 })
+              .should('not.exist')
+              .then(() => {
+                cy.get('.ui.massive.icon.primary.left.labeled.button')
+                  .click()
+                  .then(() => {
+                    cy.get('.ui.massive.loading.primary.button', {
+                      timeout: testingFinishTimeout
+                    })
+                      .should('not.exist')
+                      .then(() => {
+                        cy.get('span.icon.failed')
+                          .should('not.exist')
+                          .then(() => {
+                            done()
+                          })
+                      })
+                  })
+              })
+          })
       })
-      .should('not.exist')
-
-    cy.get('test-card').shadow().find('.status-icon.failed').should('not.exist')
+    })
   })
 })

jest.config.js

@@ -41,14 +41,7 @@ module.exports = {
   // ],
 
   // An object that configures minimum threshold enforcement for coverage results
-  coverageThreshold: {
-    global: {
-      statements: 64.03,
-      branches: 45.11,
-      functions: 54.18,
-      lines: 64.53
-    }
-  },
+  // coverageThreshold: undefined,
 
   // A path to a custom dependency extractor
   // dependencyExtractor: undefined,
@@ -142,8 +135,6 @@ module.exports = {
   // Options that will be passed to the testEnvironment
   // testEnvironmentOptions: {},
 
-  testEnvironment: 'node',
-
   // Adds a location field to test results
   // testLocationInResults: false,
 

package.json

@@ -6,7 +6,7 @@
     "nodeVersionMessage": "echo \u001b[33m make sure you are running node lts version \u001b[0m",
     "preinstall": "npm run nodeVersionMessage",
     "prebuild": "npm run nodeVersionMessage",
-    "build": "npx rimraf build && npx rimraf node && mkdir node && copyfiles -u 1 \"./src/**/*\" ./node && webpack && npx rimraf build/src && npx rimraf node",
+    "build": "rimraf build && rimraf node && mkdir node && copyfiles -u 1 \"./src/**/*\" ./node && webpack && rimraf build/src && rimraf node",
     "package:lib": "npm run build && copyfiles ./package.json build && cd build && npm version \"5.0.0\" && npm pack",
     "publish:lib": "npm run build && cd build && npm publish",
     "lint:fix": "npx prettier --loglevel silent --write \"src/**/*.{ts,tsx,js,jsx,html,css,sass,less,json,yml,md,graphql}\" && npx prettier --loglevel silent --write \"sasjs-tests/src/**/*.{ts,tsx,js,jsx,html,css,sass,less,json,yml,md,graphql}\" && npx prettier --loglevel silent --write \"cypress/**/*.{ts,tsx,js,jsx,html,css,sass,less,json,yml,md,graphql}\"",
@@ -45,44 +45,42 @@
   "license": "ISC",
   "devDependencies": {
     "@cypress/webpack-preprocessor": "5.9.1",
-    "@types/cors": "^2.8.17",
     "@types/express": "4.17.13",
-    "@types/jest": "29.5.14",
+    "@types/jest": "27.4.0",
     "@types/mime": "2.0.3",
     "@types/pem": "1.9.6",
     "@types/tough-cookie": "4.0.2",
     "copyfiles": "2.4.1",
-    "cors": "^2.8.5",
     "cp": "0.2.0",
     "cypress": "7.7.0",
     "dotenv": "16.0.0",
     "express": "4.17.3",
-    "jest": "29.7.0",
-    "jest-environment-jsdom": "^29.7.0",
-    "jest-extended": "4.0.2",
+    "jest": "27.4.7",
+    "jest-extended": "2.0.0",
     "node-polyfill-webpack-plugin": "1.1.4",
     "path": "0.12.7",
     "pem": "1.14.5",
     "prettier": "2.8.7",
     "process": "0.11.10",
+    "rimraf": "3.0.2",
     "semantic-release": "19.0.3",
     "terser-webpack-plugin": "5.3.6",
-    "ts-jest": "29.2.6",
+    "ts-jest": "27.1.3",
     "ts-loader": "9.4.0",
     "tslint": "6.1.3",
     "tslint-config-prettier": "1.18.0",
     "typedoc": "0.23.24",
     "typedoc-plugin-rename-defaults": "0.6.4",
-    "typescript": "4.9.5",
+    "typescript": "4.8.3",
     "webpack": "5.76.2",
     "webpack-cli": "4.9.2"
   },
   "main": "index.js",
   "dependencies": {
-    "@sasjs/utils": "3.5.2",
-    "axios": "1.12.2",
-    "axios-cookiejar-support": "5.0.5",
-    "form-data": "4.0.4",
+    "@sasjs/utils": "2.52.0",
+    "axios": "0.27.2",
+    "axios-cookiejar-support": "1.0.1",
+    "form-data": "4.0.0",
     "https": "1.0.0",
     "tough-cookie": "4.1.3"
   }

sasjs-tests/.env

@@ -0,0 +1 @@
+SKIP_PREFLIGHT_CHECK=true

sasjs-tests/.gitignore

@@ -1,29 +1,23 @@
-# Logs
-logs
-*.log
+# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
+
+# dependencies
+/node_modules
+/.pnp
+.pnp.js
+
+# testing
+/coverage
+
+# production
+/build
+
+# misc
+.DS_Store
+.env.*
+
 npm-debug.log*
 yarn-debug.log*
 yarn-error.log*
-pnpm-debug.log*
-lerna-debug.log*
 
-node_modules
-dist
-dist-ssr
-*.local
-
-# Editor directories and files
-.vscode/*
-!.vscode/extensions.json
-.idea
-.DS_Store
-*.suo
-*.ntvs*
-*.njsproj
-*.sln
-*.sw?
-
-
-# sasjs
 sasjsbuild
 sasjsresults

sasjs-tests/.prettierrc

@@ -0,0 +1,6 @@
+{
+  "trailingComma": "none",
+  "tabWidth": 2,
+  "semi": false,
+  "singleQuote": true
+}

sasjs-tests/README.md

@@ -1,8 +1,6 @@
-# SASjs Tests
-
 `sasjs-tests` is a test suite for the SASjs adapter.
 
-Browser-based integration testing for [@sasjs/adapter](https://github.com/sasjs/adapter) using TypeScript, Custom Elements, and zero dependencies.
+It is a React app bootstrapped using [Create React App](https://github.com/facebook/create-react-app) and [@sasjs/test-framework](https://github.com/sasjs/test-framework).
 
 When developing on `@sasjs/adapter`, it's good practice to run the test suite against your changed version of the adapter to ensure that existing functionality has not been impacted.
 
@@ -22,70 +20,11 @@ There are three prerequisites to be able to run the tests:
 2. `sasjs-tests` deployed to your SAS server.
 3. The required SAS services created on the same server.
 
-### Configuring the SASjs adapter
+### 1. Configuring the SASjs adapter
 
 There is a `config.json` file in the `/public` folder which specifies the configuration for the SASjs adapter. You can set the values within the `sasjsConfig` property in this file to match your SAS server configuration.
 
-## Test Suites
-
-Tests are defined in `src/testSuites/`:
-
-- **Basic.ts** - Login, config, session management, debug mode
-- **RequestData.ts** - Data serialization (sendArr, sendObj) with various types
-- **FileUpload.ts** - File upload functionality (VIYA only)
-- **Compute.ts** - Compute API, JES API, executeScript (VIYA only)
-- **SasjsRequests.ts** - WORK tables, log capture
-- **SpecialCases.ts** - Edge cases (currently disabled)
-
-Each test suite follows this pattern:
-
-```typescript
-export const myTests = (adapter: SASjs): TestSuite => ({
-  name: 'My Test Suite',
-  tests: [
-    {
-      title: 'Should do something',
-      description: 'Description of what this tests',
-      test: async () => {
-        // Test logic - return a value
-        return adapter.request('service', data)
-      },
-      assertion: (response) => {
-        // Assertion - return true/false
-        return response.success === true
-      }
-    }
-  ],
-  beforeAll: async () => {
-    // Optional: runs once before all tests
-  },
-  afterAll: async () => {
-    // Optional: runs once after all tests
-  }
-})
-```
-
-### Shadow DOM Access
-
-Cypress accesses Shadow DOM using a custom command:
-
-```javascript
-cy.get('login-form').shadow().find('input#username').type('user')
-```
-
-The `shadow()` command is defined in `cypress/support/commands.js`.
-
-## Deployment
-
-### Build for Production
-
-```bash
-npm run build
-```
-
-This creates a `dist/` folder ready for deployment.
-
-### Deploy to SAS Server
+### 2. Deploying to your SAS server
 
 There is a `deploy` NPM script provided in the `sasjs-tests` project's `package.json`.
 
@@ -103,26 +42,21 @@ SSH_ACCOUNT=me@my-sas-server.com DEPLOY_PATH=/var/www/html/my-folder/sasjs-tests
 ```
 
 If you are on `WINDOWS`, you will first need to install one dependency:
-
 ```bash
 npm i -g copyfiles
 ```
-
 and then run to build:
-
 ```bash
 npm run update:adapter && npm run build
 ```
-
 when it finishes run to deploy:
-
 ```bash
 scp -rp ./build/* me@my-sas-server.com:/var/www/html/my-folder/sasjs-tests
 ```
 
 If you'd like to deploy just `sasjs-tests` without changing the adapter version, you can use the `deploy:tests` script, while also setting the same environment variables as above.
 
-#### Creating the required SAS services
+## 3. Creating the required SAS services
 
 The below services need to be created on your SAS server, at the location specified as the `appLoc` in the SASjs configuration.
 
@@ -141,8 +75,8 @@ parmcards4;
     %let table=%scan(&sasjs_tables,&i);
     %webout(OBJ,&table,missing=STRING,showmeta=YES)
   %end;
-  %else %do i=1 %to &_webin_file_count;
-    %webout(OBJ,&&_webin_name&i,missing=STRING,showmeta=YES)
+  %else %do i=1 %to &_webin_file_count; 
+    %webout(OBJ,&&_webin_name&i,missing=STRING,showmeta=YES) 
   %end;
   %mend; %x()
   %webout(CLOSE)
@@ -156,8 +90,8 @@ parmcards4;
     %let table=%scan(&sasjs_tables,&i);
     %webout(ARR,&table,missing=STRING,showmeta=YES)
   %end;
-  %else %do i=1 %to &_webin_file_count;
-    %webout(ARR,&&_webin_name&i,missing=STRING,showmeta=YES)
+  %else %do i=1 %to &_webin_file_count; 
+    %webout(ARR,&&_webin_name&i,missing=STRING,showmeta=YES) 
   %end;
   %mend; %x()
   %webout(CLOSE)
@@ -168,7 +102,7 @@ parmcards4;
     set sashelp.vmacro;
   run;
   %webout(OPEN)
-  %webout(OBJ,macvars)
+  %webout(OBJ,macvars) 
   %webout(CLOSE)
 ;;;;
 %mx_createwebservice(path=&apploc/services/common,name=sendMacVars)
@@ -192,64 +126,23 @@ data _null_;
 
 You should now be able to access the tests in your browser at the deployed path on your server.
 
-#### Using SASjs CLI
+## Creating new tests
 
-```bash
-sasjs deploy -t <target>
+The `src/testSuites` folder contains all the test suites currently available.
+Each suite contains a set of specs, each of which looks like this:
+
+```javascript
+    {
+        title: "Your test title",
+        description: "A slightly more detailed description",
+        test: async () => {
+        // typically makes a request using the adapter and returns a promise
+        },
+        assertion: (response: any) =>
+        // receives the response when the test promise resolves, runs an assertion and returns a boolean
+    }
 ```
 
-### Matrix Notifications
+A test suite is an array of such objects, along with a `name` property.
 
-The `sasjs-cypress-run.sh` script sends Matrix chat notifications on test failure:
-
-```bash
-./sasjs-cypress-run.sh $MATRIX_ACCESS_TOKEN $PR_NUMBER
-```
-
-Notification format:
-
-```
-Automated sasjs-tests failed on the @sasjs/adapter PR: <PR_NUMBER>
-```
-
-## SAS Service Setup
-
-The tests require SAS services to be deployed at the `appLoc` specified in `config.json`.
-
-Services expected:
-
-- `common/sendArr` - Echo back array data
-- `common/sendObj` - Echo back object data
-- (Additional services per test suite)
-
-Deploy these services using [SASjs CLI](https://cli.sasjs.io) or manually.
-
-## UI Components (Custom Elements)
-
-- `<login-form>` - SAS authentication
-- `<tests-view>` - Test orchestrator with run controls
-- `<test-suite>` - Test suite display with stats
-- `<test-card>` - Individual test with status (pending/running/passed/failed)
-
-All components use Shadow DOM for style encapsulation and expose custom events for interactivity.
-
-### Adding New Test Suites
-
-1. Create file in `src/testSuites/MyNewTests.ts`
-2. Export function returning TestSuite
-3. Import in `src/index.ts`
-4. Add to `testSuites` array in `showTests()` function
-
-### Modifying UI Components
-
-Components are in `src/components/`:
-
-- Edit `.ts` file
-- Styles are in corresponding `.css` file
-- Rebuild with `npm run build`
-
-## Links
-
-- [@sasjs/adapter](https://adapter.sasjs.io)
-- [SASjs Documentation](https://sasjs.io)
-- [SASjs CLI](https://cli.sasjs.io)
+You can add your test to one of the existing suites if suitable, or create a new file that specifies a new test suite.

sasjs-tests/index.css

@@ -1,39 +0,0 @@
-* {
-  box-sizing: border-box;
-  margin: 0;
-  padding: 0;
-}
-
-body {
-  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen,
-    Ubuntu, Cantarell, sans-serif;
-  line-height: 1.6;
-  color: #333;
-  background: #f5f5f5;
-}
-
-.app__error {
-  max-width: 800px;
-  margin: 50px auto;
-  padding: 30px;
-  background: white;
-  border-radius: 8px;
-  box-shadow: 0 2px 10px rgba(0, 0, 0, 0.1);
-
-  h1 {
-    color: #e74c3c;
-    margin-bottom: 15px;
-  }
-
-  p {
-    margin-bottom: 15px;
-  }
-
-  pre {
-    background: #2c3e50;
-    color: #ecf0f1;
-    padding: 15px;
-    border-radius: 4px;
-    overflow-x: auto;
-  }
-}

sasjs-tests/index.html

@@ -1,14 +0,0 @@
-<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <link rel="icon" type="image/png" href="./src/images/favicon.png" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>SASjs tests</title>
-    <link rel="stylesheet" href="./index.css">
-  </head>
-  <body>
-    <div id="app"></div>
-    <script type="module" src="./src/main.ts"></script>
-  </body>
-</html>

sasjs-tests/package.json

@@ -1,25 +1,47 @@
 {
-  "name": "sasjs-tests-new",
+  "name": "@sasjs/tests",
+  "version": "1.0.0",
+  "homepage": ".",
   "private": true,
-  "version": "0.0.0",
-  "type": "module",
+  "dependencies": {
+    "@sasjs/test-framework": "1.5.7",
+    "@types/jest": "^26.0.20",
+    "@types/node": "^14.14.41",
+    "@types/react": "^16.0.1",
+    "@types/react-dom": "^16.0.0",
+    "@types/react-router-dom": "^5.1.7",
+    "react": "^16.0.1",
+    "react-dom": "^16.0.1",
+    "react-router-dom": "^5.2.0",
+    "react-scripts": "^5.0.1",
+    "typescript": "^4.1.3"
+  },
   "scripts": {
-    "start": "vite",
-    "build": "tsc && vite build",
-    "preview": "vite preview",
+    "start": "react-scripts start",
+    "build": "react-scripts build",
+    "test": "react-scripts test",
+    "eject": "react-scripts eject",
     "update:adapter": "cd .. && npm run package:lib && cd sasjs-tests && npm i ../build/sasjs-adapter-5.0.0.tgz",
-    "deploy:tests": "rsync -avhe ssh ./dist/* --delete $SSH_ACCOUNT:$DEPLOY_PATH || npm run deploy:tests-win",
-    "deploy:tests-win": "scp %DEPLOY_PATH% ./dist/*",
+    "deploy:tests": "rsync -avhe ssh ./build/* --delete $SSH_ACCOUNT:$DEPLOY_PATH || npm run deploy:tests-win",
+    "deploy:tests-win": "scp %DEPLOY_PATH% ./build/*",
     "deploy": "npm run update:adapter && npm run build && npm run deploy:tests"
   },
+  "eslintConfig": {
+    "extends": "react-app"
+  },
+  "browserslist": {
+    "production": [
+      ">0.2%",
+      "not dead",
+      "not op_mini all"
+    ],
+    "development": [
+      "last 1 chrome version",
+      "last 1 firefox version",
+      "last 1 safari version"
+    ]
+  },
   "devDependencies": {
-    "typescript": "~5.9.3",
-    "vite": "npm:rolldown-vite@7.2.2"
-  },
-  "overrides": {
-    "vite": "npm:rolldown-vite@7.2.2"
-  },
-  "dependencies": {
-    "@sasjs/adapter": "^4.14.0"
+    "node-sass": "9.0.0"
   }
 }

sasjs-tests/public/config.json

@@ -2,12 +2,11 @@
   "userName": "",
   "password": "",
   "sasJsConfig": {
-    "loginMechanism": "Redirected",
     "serverUrl": "",
     "appLoc": "/Public/app/adapter-tests/services",
-    "serverType": "SASVIYA",
+    "serverType": "SASJS",
     "debug": false,
-    "contextName": "SAS Job Execution compute context",
+    "contextName": "sasjs adapter compute context",
     "useComputeApi": true
   }
 }

sasjs-tests/public/index.html

@@ -0,0 +1,40 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <link rel="icon" href="%PUBLIC_URL%/favicon.png" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <meta name="theme-color" content="#000000" />
+    <meta name="description" content="Tests for SASjs" />
+    <link rel="apple-touch-icon" href="%PUBLIC_URL%/logo192.png" />
+    <!--
+      manifest.json provides metadata used when your web app is installed on a
+      user's mobile device or desktop. See https://developers.google.com/web/fundamentals/web-app-manifest/
+    -->
+    <link rel="manifest" href="%PUBLIC_URL%/manifest.json" />
+    <!--
+      Notice the use of %PUBLIC_URL% in the tags above.
+      It will be replaced with the URL of the `public` folder during the build.
+      Only files inside the `public` folder can be referenced from the HTML.
+
+      Unlike "/favicon.ico" or "favicon.ico", "%PUBLIC_URL%/favicon.ico" will
+      work correctly both with client-side routing and a non-root public URL.
+      Learn how to configure a non-root public URL by running `npm run build`.
+    -->
+    <title>SASjs Tests</title>
+  </head>
+  <body>
+    <noscript>You need to enable JavaScript to run this app.</noscript>
+    <div id="root"></div>
+    <!--
+      This HTML file is a template.
+      If you open it directly in the browser, you will see an empty page.
+
+      You can add webfonts, meta tags, or analytics to this file.
+      The build step will place the bundled scripts into the <body> tag.
+
+      To begin the development, run `npm start` or `yarn start`.
+      To create a production bundle, use `npm run build` or `yarn build`.
+    -->
+  </body>
+</html>

sasjs-tests/public/manifest.json

@@ -0,0 +1,25 @@
+{
+  "short_name": "React App",
+  "name": "Create React App Sample",
+  "icons": [
+    {
+      "src": "favicon.ico",
+      "sizes": "64x64 32x32 24x24 16x16",
+      "type": "image/x-icon"
+    },
+    {
+      "src": "logo192.png",
+      "type": "image/png",
+      "sizes": "192x192"
+    },
+    {
+      "src": "logo512.png",
+      "type": "image/png",
+      "sizes": "512x512"
+    }
+  ],
+  "start_url": ".",
+  "display": "standalone",
+  "theme_color": "#000000",
+  "background_color": "#ffffff"
+}

sasjs-tests/sasjs-cypress-run.sh

@@ -4,7 +4,7 @@ if npm run cy:run -- --spec "cypress/integration/sasjs.tests.ts" ; then
     echo "Cypress sasjs testing passed!"
 else
     echo '{"msgtype":"m.text", "body":"Automated sasjs-tests failed on the @sasjs/adapter PR: '$2'"}'
-    curl -XPOST -d '{"msgtype":"m.text", "body":"Automated sasjs-tests failed on the @sasjs/adapter PR: '$2'"}' https://matrix.4gl.io/_matrix/client/r0/rooms/%21jRebyiGmHZlpfDwYXN:4gl.io/send/m.room.message?access_token=$1
+    curl -XPOST -d '{"msgtype":"m.text", "body":"Automated sasjs-tests failed on the @sasjs/adapter PR: '$2'"}' https://matrix.4gl.io/_matrix/client/r0/rooms/%21jRebyiGmHZlpfDwYXN:4gl.io:4gl.io/send/m.room.message?access_token=$1
     echo "Cypress sasjs testing failed!"
     exit 1
 fi

sasjs-tests/sasjs/sasjsconfig.json

@@ -20,27 +20,7 @@
       "streamConfig": {
         "streamWeb": true,
         "streamWebFolder": "webv",
-        "webSourcePath": "dist",
-        "streamServiceName": "adapter-tests",
-        "assetPaths": []
-      }
-    },
-    {
-      "name": "viya",
-      "serverUrl": "",
-      "serverType": "SASVIYA",
-      "httpsAgentOptions": {
-        "allowInsecureRequests": false
-      },
-      "appLoc": "/Public/app/adapter-tests",
-      "deployConfig": {
-        "deployServicePack": true,
-        "deployScripts": []
-      },
-      "streamConfig": {
-        "streamWeb": true,
-        "streamWebFolder": "webv",
-        "webSourcePath": "dist",
+        "webSourcePath": "build",
         "streamServiceName": "adapter-tests",
         "assetPaths": []
       }

sasjs-tests/src/App.tsx

@@ -0,0 +1,42 @@
+import React, { ReactElement, useState, useContext, useEffect } from 'react'
+import { TestSuiteRunner, TestSuite, AppContext } from '@sasjs/test-framework'
+import { basicTests } from './testSuites/Basic'
+import { sendArrTests, sendObjTests } from './testSuites/RequestData'
+import { specialCaseTests } from './testSuites/SpecialCases'
+import { sasjsRequestTests } from './testSuites/SasjsRequests'
+import '@sasjs/test-framework/dist/index.css'
+import { computeTests } from './testSuites/Compute'
+import { fileUploadTests } from './testSuites/FileUpload'
+
+const App = (): ReactElement<{}> => {
+  const { adapter, config } = useContext(AppContext)
+  const [testSuites, setTestSuites] = useState<TestSuite[]>([])
+  const appLoc = config.sasJsConfig.appLoc
+
+  useEffect(() => {
+    if (adapter) {
+      const testSuites = [
+        basicTests(adapter, config.userName, config.password),
+        sendArrTests(adapter, appLoc),
+        sendObjTests(adapter),
+        specialCaseTests(adapter),
+        sasjsRequestTests(adapter),
+        fileUploadTests(adapter)
+      ]
+
+      if (adapter.getSasjsConfig().serverType === 'SASVIYA') {
+        testSuites.push(computeTests(adapter, appLoc))
+      }
+
+      setTestSuites(testSuites)
+    }
+  }, [adapter, config, appLoc])
+
+  return (
+    <div className="app">
+      {adapter && testSuites && <TestSuiteRunner testSuites={testSuites} />}
+    </div>
+  )
+}
+
+export default App

sasjs-tests/src/Login.scss

@@ -0,0 +1,34 @@
+.login-container {
+  display: flex;
+  flex-direction: column;
+  height: 100vh;
+  justify-content: center;
+  align-items: center;
+
+  img {
+    max-width: 30%;
+  }
+
+  form {
+    width: 33%;
+    margin-top: 3%;
+    display: flex;
+    flex-direction: column;
+
+    .row {
+      input {
+        font-size: 0.9em;
+      }
+
+      label {
+        font-weight: bold;
+        font-size: 0.9em;
+        margin-bottom: 4px;
+      }
+    }
+
+    .submit-button {
+      margin-top: 16px;
+    }
+  }
+}

sasjs-tests/src/Login.tsx

@@ -0,0 +1,54 @@
+import React, { ReactElement, useState, useCallback, useContext } from 'react'
+import './Login.scss'
+import { AppContext } from '@sasjs/test-framework'
+import { Redirect } from 'react-router-dom'
+
+const Login = (): ReactElement<{}> => {
+  const [username, setUsername] = useState('')
+  const [password, setPassword] = useState('')
+  const appContext = useContext(AppContext)
+
+  const handleSubmit = useCallback(
+    (e: any) => {
+      e.preventDefault()
+      appContext.adapter.logIn(username, password).then((res) => {
+        appContext.setIsLoggedIn(res.isLoggedIn)
+      })
+    },
+    [username, password, appContext]
+  )
+
+  return !appContext.isLoggedIn ? (
+    <div className="login-container">
+      <img src="sasjs-logo.png" alt="SASjs Logo" />
+      <form onSubmit={handleSubmit}>
+        <div className="row">
+          <label>User Name</label>
+          <input
+            placeholder="User Name"
+            value={username}
+            required
+            onChange={(e: any) => setUsername(e.target.value)}
+          />
+        </div>
+        <div className="row">
+          <label>Password</label>
+          <input
+            placeholder="Password"
+            type="password"
+            value={password}
+            required
+            onChange={(e: any) => setPassword(e.target.value)}
+          />
+        </div>
+        <button type="submit" className="submit-button">
+          Log In
+        </button>
+      </form>
+    </div>
+  ) : (
+    <Redirect to="/" />
+  )
+}
+
+export default Login

sasjs-tests/src/PrivateRoute.tsx

@@ -0,0 +1,23 @@
+import React, { ReactElement, useContext, FunctionComponent } from 'react'
+import { Redirect, Route } from 'react-router-dom'
+import { AppContext } from '@sasjs/test-framework'
+
+interface PrivateRouteProps {
+  component: FunctionComponent
+  exact?: boolean
+  path: string
+}
+
+const PrivateRoute = (
+  props: PrivateRouteProps
+): ReactElement<PrivateRouteProps> => {
+  const { component, path, exact } = props
+  const appContext = useContext(AppContext)
+  return appContext.isLoggedIn ? (
+    <Route component={component} path={path} exact={exact} />
+  ) : (
+    <Redirect to="/login" />
+  )
+}
+
+export default PrivateRoute

sasjs-tests/src/components/LoginForm.css

@@ -1,65 +0,0 @@
-:host {
-  display: block;
-  max-width: 400px;
-  margin: 100px auto;
-  padding: 40px;
-  background: white;
-  border-radius: 8px;
-  box-shadow: 0 2px 10px rgba(0, 0, 0, 0.1);
-}
-
-h1 {
-  text-align: center;
-  margin-bottom: 30px;
-  color: #2c3e50;
-}
-
-form {
-  display: flex;
-  flex-direction: column;
-  gap: 15px;
-}
-
-label {
-  font-weight: 600;
-  margin-bottom: 5px;
-}
-
-input {
-  padding: 10px;
-  border: 1px solid #ddd;
-  border-radius: 4px;
-  font-size: 14px;
-
-  &:focus {
-    outline: none;
-    border-color: #3498db;
-  }
-}
-
-button {
-  padding: 12px;
-  background: #3498db;
-  color: white;
-  border: none;
-  border-radius: 4px;
-  font-size: 16px;
-  font-weight: 600;
-  cursor: pointer;
-  transition: background 0.2s;
-
-  &:hover:not(:disabled) {
-    background: #2980b9;
-  }
-
-  &:disabled {
-    opacity: 0.6;
-    cursor: not-allowed;
-  }
-}
-
-.error {
-  color: #e74c3c;
-  font-size: 14px;
-  min-height: 20px;
-}

sasjs-tests/src/components/LoginForm.ts

@@ -1,93 +0,0 @@
-import { appContext } from '../core/AppContext'
-import styles from './LoginForm.css?inline'
-
-export class LoginForm extends HTMLElement {
-  private static styleSheet = new CSSStyleSheet()
-  private shadow: ShadowRoot
-
-  static {
-    this.styleSheet.replaceSync(styles)
-  }
-
-  constructor() {
-    super()
-    this.shadow = this.attachShadow({ mode: 'open' })
-    this.shadow.adoptedStyleSheets = [LoginForm.styleSheet]
-  }
-
-  connectedCallback() {
-    this.render()
-    this.attachEventListeners()
-  }
-
-  render() {
-    this.shadow.innerHTML = `
-      <h1>SASjs Tests</h1>
-      <form id="login-form">
-        <label for="username">Username</label>
-        <input type="text" id="username" name="username" placeholder="Enter username" required />
-
-        <label for="password">Password</label>
-        <input type="password" id="password" name="password" placeholder="Enter password" required />
-
-        <button type="submit" id="submit-btn">Log In</button>
-        <div class="error" id="error"></div>
-      </form>
-    `
-  }
-
-  attachEventListeners() {
-    const form = this.shadow.getElementById('login-form') as HTMLFormElement
-    form.addEventListener('submit', async (e) => {
-      e.preventDefault()
-      await this.handleLogin()
-    })
-  }
-
-  async handleLogin() {
-    const username = (
-      this.shadow.getElementById('username') as HTMLInputElement
-    ).value
-    const password = (
-      this.shadow.getElementById('password') as HTMLInputElement
-    ).value
-    const submitBtn = this.shadow.getElementById(
-      'submit-btn'
-    ) as HTMLButtonElement
-    const errorDiv = this.shadow.getElementById('error') as HTMLDivElement
-
-    errorDiv.textContent = ''
-    submitBtn.textContent = 'Logging in...'
-    submitBtn.disabled = true
-
-    try {
-      const adapter = appContext.getAdapter()
-      if (!adapter) {
-        throw new Error('Adapter not initialized')
-      }
-
-      const response = await adapter.logIn(username, password)
-
-      if (response && response.isLoggedIn) {
-        appContext.setIsLoggedIn(true)
-        this.dispatchEvent(
-          new CustomEvent('login-success', {
-            bubbles: true,
-            composed: true
-          })
-        )
-      } else {
-        throw new Error('Login failed')
-      }
-    } catch (error: unknown) {
-      errorDiv.textContent =
-        error instanceof Error
-          ? error.message
-          : 'Login failed. Please try again.'
-      submitBtn.textContent = 'Log In'
-      submitBtn.disabled = false
-    }
-  }
-}
-
-customElements.define('login-form', LoginForm)

sasjs-tests/src/components/RequestsModal.css

@@ -1,193 +0,0 @@
-:host {
-  display: contents;
-}
-
-button {
-  padding: 8px 16px;
-  background: #3498db;
-  color: white;
-  border: none;
-  border-radius: 4px;
-  cursor: pointer;
-  font-size: 14px;
-  margin-left: 10px;
-
-  &:hover {
-    background: #2980b9;
-  }
-}
-
-dialog {
-  max-width: 95vw;
-  max-height: 95vh;
-  width: 1400px;
-  padding: 0;
-  border: none;
-  border-radius: 8px;
-  box-shadow: 0 4px 20px rgba(0, 0, 0, 0.3);
-  background: #2c3e50;
-  color: #ecf0f1;
-
-  &::backdrop {
-    background: rgba(0, 0, 0, 0.5);
-  }
-}
-
-.modal-header {
-  display: flex;
-  justify-content: space-between;
-  align-items: center;
-  padding: 20px;
-  border-bottom: 1px solid #34495e;
-
-  h2 {
-    margin: 0;
-    color: #ecf0f1;
-    font-size: 20px;
-  }
-}
-
-.close-btn {
-  background: transparent;
-  color: #ecf0f1;
-  font-size: 24px;
-  padding: 0;
-  width: 32px;
-  height: 32px;
-  cursor: pointer;
-  border-radius: 4px;
-  margin: 0;
-
-  &:hover {
-    background: #34495e;
-  }
-}
-
-.modal-content {
-  padding: 20px;
-  overflow-y: auto;
-  max-height: calc(95vh - 80px);
-}
-
-.debug-message {
-  text-align: center;
-  padding: 60px 20px;
-
-  .icon {
-    font-size: 64px;
-    margin-bottom: 20px;
-  }
-
-  h3 {
-    margin: 10px 0;
-    color: #ecf0f1;
-  }
-
-  span {
-    color: #95a5a6;
-  }
-}
-
-.requests-list {
-  display: flex;
-  flex-direction: column;
-  gap: 10px;
-}
-
-details {
-  border: 1px solid #34495e;
-  border-radius: 4px;
-  background: #34495e;
-
-  &[open] summary::before {
-    transform: rotate(90deg);
-  }
-}
-
-summary {
-  padding: 15px;
-  cursor: pointer;
-  user-select: none;
-  list-style: none;
-  display: flex;
-  justify-content: space-between;
-  align-items: center;
-  transition: background 0.2s;
-
-  &::-webkit-details-marker {
-    display: none;
-  }
-
-  &::before {
-    content: '▶';
-    display: inline-block;
-    margin-right: 10px;
-    transition: transform 0.2s;
-  }
-
-  &:hover {
-    background: #3d5266;
-  }
-}
-
-.request-timestamp {
-  color: #95a5a6;
-  font-size: 13px;
-}
-
-.request-content {
-  padding: 0 15px 15px 15px;
-}
-
-.tabs {
-  display: flex;
-  gap: 10px;
-  padding-bottom: 10px;
-  border-bottom: 1px solid #2c3e50;
-  margin-bottom: 10px;
-}
-
-.tab-btn {
-  padding: 8px 16px;
-  background: transparent;
-  color: #95a5a6;
-  border: none;
-  border-bottom: 2px solid transparent;
-  cursor: pointer;
-  font-size: 14px;
-  margin: 0;
-  border-radius: 0;
-
-  &:hover {
-    color: #ecf0f1;
-    background: transparent;
-  }
-
-  &.active {
-    color: #3498db;
-    border-bottom-color: #3498db;
-    background: transparent;
-  }
-}
-
-.tab-pane {
-  display: none;
-
-  &.active {
-    display: block;
-  }
-}
-
-pre {
-  background: #1e2832;
-  padding: 15px;
-  border-radius: 4px;
-  overflow-x: auto;
-  margin: 0;
-  color: #ecf0f1;
-  font-family: 'Courier New', monospace;
-  font-size: 13px;
-  line-height: 1.5;
-  white-space: pre-wrap;
-  word-wrap: break-word;
-}

sasjs-tests/src/components/RequestsModal.ts

@@ -1,180 +0,0 @@
-import type { SASjsRequest } from '@sasjs/adapter'
-import { appContext } from '../core/AppContext'
-import styles from './RequestsModal.css?inline'
-
-export class RequestsModal extends HTMLElement {
-  private static styleSheet = new CSSStyleSheet()
-  private shadow: ShadowRoot
-  private dialog: HTMLDialogElement | null = null
-
-  static {
-    this.styleSheet.replaceSync(styles)
-  }
-
-  constructor() {
-    super()
-    this.shadow = this.attachShadow({ mode: 'open' })
-    this.shadow.adoptedStyleSheets = [RequestsModal.styleSheet]
-  }
-
-  connectedCallback() {
-    this.render()
-    this.attachEventListeners()
-  }
-
-  render() {
-    this.shadow.innerHTML = `
-      <dialog id="requests-dialog">
-        <div class="modal-header">
-          <h2 id="modal-title"></h2>
-          <button class="close-btn" id="close-btn">×</button>
-        </div>
-        <div class="modal-content" id="modal-content"></div>
-      </dialog>
-    `
-  }
-
-  attachEventListeners() {
-    const dialog = this.shadow.getElementById(
-      'requests-dialog'
-    ) as HTMLDialogElement
-    const closeBtn = this.shadow.getElementById('close-btn')
-
-    this.dialog = dialog
-
-    closeBtn?.addEventListener('click', () => this.closeModal())
-    dialog?.addEventListener('click', (e) => {
-      if (e.target === dialog) {
-        this.closeModal()
-      }
-    })
-  }
-
-  openModal() {
-    if (!this.dialog) return
-
-    const adapter = appContext.getAdapter()
-    if (!adapter) return
-
-    const requests = adapter.getSasRequests()
-
-    const title = this.shadow.getElementById('modal-title')
-    const content = this.shadow.getElementById('modal-content')
-
-    if (!title || !content) return
-
-    title.textContent = 'Last 20 requests'
-
-    if (!requests || requests.length === 0) {
-      content.innerHTML = `
-        <div class="debug-message">
-          <div class="icon">🐛</div>
-          <h3>There are no requests available.</h3>
-          <span>Please run a test and check again.</span>
-        </div>
-      `
-    } else {
-      content.innerHTML = `
-        <div class="requests-list">
-          ${requests
-            .map((request, index) => this.renderRequest(request, index))
-            .join('')}
-        </div>
-      `
-
-      this.attachTabListeners()
-    }
-
-    this.dialog.showModal()
-  }
-
-  closeModal() {
-    this.dialog?.close()
-  }
-
-  renderRequest(request: SASjsRequest, index: number): string {
-    const timestamp = new Date(request.timestamp)
-    const formattedDate = timestamp.toLocaleString('en-US', {
-      weekday: 'long',
-      year: 'numeric',
-      month: 'long',
-      day: 'numeric',
-      hour: 'numeric',
-      minute: 'numeric',
-      second: 'numeric'
-    })
-    const timeAgo = this.getTimeAgo(timestamp)
-
-    return `
-      <details data-index="${index}">
-        <summary>
-          <span>${request.serviceLink}</span>
-          <span class="request-timestamp">${formattedDate} (${timeAgo})</span>
-        </summary>
-        <div class="request-content">
-          <div class="tabs">
-            <button class="tab-btn active" data-tab="log-${index}">Log</button>
-            <button class="tab-btn" data-tab="source-${index}">Source Code</button>
-            <button class="tab-btn" data-tab="generated-${index}">Generated Code</button>
-          </div>
-          <div class="tab-panes">
-            <div class="tab-pane active" id="log-${index}">
-              <pre>${this.decodeHtml(request.logFile)}</pre>
-            </div>
-            <div class="tab-pane" id="source-${index}">
-              <pre>${this.decodeHtml(request.sourceCode)}</pre>
-            </div>
-            <div class="tab-pane" id="generated-${index}">
-              <pre>${this.decodeHtml(request.generatedCode)}</pre>
-            </div>
-          </div>
-        </div>
-      </details>
-    `
-  }
-
-  attachTabListeners() {
-    const tabBtns = this.shadow.querySelectorAll('.tab-btn')
-    tabBtns.forEach((btn) => {
-      btn.addEventListener('click', (e) => {
-        const target = e.currentTarget as HTMLElement
-        const tabId = target.getAttribute('data-tab')
-        if (!tabId) return
-
-        const container = target.closest('.request-content')
-        if (!container) return
-
-        container
-          .querySelectorAll('.tab-btn')
-          .forEach((b) => b.classList.remove('active'))
-        container
-          .querySelectorAll('.tab-pane')
-          .forEach((p) => p.classList.remove('active'))
-
-        target.classList.add('active')
-        const pane = container.querySelector(`#${tabId}`)
-        pane?.classList.add('active')
-      })
-    })
-  }
-
-  decodeHtml(encodedString: string): string {
-    const tempElement = document.createElement('textarea')
-    tempElement.innerHTML = encodedString
-    return tempElement.value
-  }
-
-  getTimeAgo(date: Date): string {
-    const seconds = Math.floor((new Date().getTime() - date.getTime()) / 1000)
-
-    if (seconds < 60) return `${seconds} seconds ago`
-    const minutes = Math.floor(seconds / 60)
-    if (minutes < 60) return `${minutes} minute${minutes !== 1 ? 's' : ''} ago`
-    const hours = Math.floor(minutes / 60)
-    if (hours < 24) return `${hours} hour${hours !== 1 ? 's' : ''} ago`
-    const days = Math.floor(hours / 24)
-    return `${days} day${days !== 1 ? 's' : ''} ago`
-  }
-}
-
-customElements.define('requests-modal', RequestsModal)

sasjs-tests/src/components/TestCard.css

@@ -1,126 +0,0 @@
-:host {
-  display: block;
-  border: 2px solid #ecf0f1;
-  border-radius: 6px;
-  padding: 15px;
-  background: #fafafa;
-  transition: border-color 0.2s;
-
-  &[status='passed'] {
-    border-color: #27ae60;
-    background: #f0fff4;
-  }
-
-  &[status='failed'] {
-    border-color: #e74c3c;
-    background: #fff5f5;
-  }
-
-  &[status='running'] {
-    border-color: #f39c12;
-    background: #fffbf0;
-  }
-
-  &[status='pending'] {
-    border-color: #95a5a6;
-    background: #f8f9fa;
-  }
-}
-
-.header {
-  display: flex;
-  align-items: center;
-  gap: 10px;
-  margin-bottom: 10px;
-}
-
-.status-icon {
-  font-size: 20px;
-  font-weight: bold;
-
-  &.passed {
-    color: #27ae60;
-  }
-  &.failed {
-    color: #e74c3c;
-  }
-  &.running {
-    color: #f39c12;
-    animation: spin 1s linear infinite;
-  }
-  &.pending {
-    color: #95a5a6;
-  }
-}
-
-@keyframes spin {
-  from {
-    transform: rotate(0deg);
-  }
-  to {
-    transform: rotate(360deg);
-  }
-}
-
-h3 {
-  font-size: 16px;
-  color: #2c3e50;
-  margin: 0;
-}
-
-.description {
-  color: #7f8c8d;
-  font-size: 14px;
-  margin-bottom: 10px;
-}
-
-.details {
-  margin-top: 10px;
-  font-size: 14px;
-}
-
-.time {
-  color: #7f8c8d;
-  margin-bottom: 5px;
-}
-
-.error {
-  margin-top: 10px;
-
-  strong {
-    color: #e74c3c;
-    display: block;
-    margin-bottom: 5px;
-  }
-
-  pre {
-    background: #2c3e50;
-    color: #ecf0f1;
-    padding: 10px;
-    border-radius: 4px;
-    overflow-x: auto;
-    font-size: 12px;
-    line-height: 1.4;
-    margin: 0;
-  }
-}
-
-button {
-  margin-top: 10px;
-  padding: 6px 12px;
-  background: #3498db;
-  color: white;
-  border: none;
-  border-radius: 4px;
-  cursor: pointer;
-  font-size: 13px;
-
-  &:hover:not(:disabled) {
-    background: #2980b9;
-  }
-
-  &:disabled {
-    opacity: 0.6;
-    cursor: not-allowed;
-  }
-}

sasjs-tests/src/components/TestCard.ts

@@ -1,113 +0,0 @@
-import type { CompletedTest } from '../core/TestRunner'
-import type { TestStatus } from '../types'
-import styles from './TestCard.css?inline'
-
-export class TestCard extends HTMLElement {
-  private static styleSheet = new CSSStyleSheet()
-  private shadow: ShadowRoot
-  private _testData: CompletedTest | null = null
-
-  static {
-    this.styleSheet.replaceSync(styles)
-  }
-
-  static get observedAttributes() {
-    return ['status', 'execution-time']
-  }
-
-  constructor() {
-    super()
-    this.shadow = this.attachShadow({ mode: 'open' })
-    this.shadow.adoptedStyleSheets = [TestCard.styleSheet]
-  }
-
-  connectedCallback() {
-    this.render()
-  }
-
-  attributeChangedCallback(_name: string, oldValue: string, newValue: string) {
-    if (oldValue !== newValue) {
-      this.render()
-    }
-  }
-
-  set testData(data: CompletedTest) {
-    this._testData = data
-    this.setAttribute('status', data.status)
-    if (data.executionTime) {
-      this.setAttribute('execution-time', data.executionTime.toString())
-    }
-    this.render()
-  }
-
-  get testData(): CompletedTest | null {
-    return this._testData
-  }
-
-  render() {
-    if (!this._testData) return
-
-    const { test, status, executionTime, error } = this._testData
-    const statusIcon = this.getStatusIcon(status)
-
-    this.shadow.innerHTML = `
-      <div class="header">
-        <span class="status-icon ${status}">${statusIcon}</span>
-        <h3>${test.title}</h3>
-      </div>
-      <p class="description">${test.description}</p>
-
-      ${
-        executionTime
-          ? `
-        <div class="details">
-          <div class="time">Time: ${executionTime.toFixed(3)}s</div>
-        </div>
-      `
-          : ''
-      }
-
-      ${
-        error
-          ? `
-        <div class="error">
-          <strong>Error:</strong>
-          <pre>${(error as Error).message || String(error)}</pre>
-        </div>
-      `
-          : ''
-      }
-
-      <button id="rerun-btn">Rerun</button>
-    `
-
-    const rerunBtn = this.shadow.getElementById('rerun-btn')
-    if (rerunBtn) {
-      rerunBtn.addEventListener('click', () => {
-        this.dispatchEvent(
-          new CustomEvent('rerun', {
-            bubbles: true,
-            composed: true
-          })
-        )
-      })
-    }
-  }
-
-  getStatusIcon(status: TestStatus): string {
-    switch (status) {
-      case 'passed':
-        return '✓'
-      case 'failed':
-        return '✗'
-      case 'running':
-        return '⟳'
-      case 'pending':
-        return '○'
-      default:
-        return '?'
-    }
-  }
-}
-
-customElements.define('test-card', TestCard)

sasjs-tests/src/components/TestSuite.css

@@ -1,34 +0,0 @@
-:host {
-  display: block;
-  background: white;
-  border-radius: 8px;
-  padding: 20px;
-  margin-bottom: 20px;
-  box-shadow: 0 2px 5px rgba(0, 0, 0, 0.1);
-}
-
-.header {
-  display: flex;
-  justify-content: space-between;
-  align-items: center;
-  margin-bottom: 15px;
-  padding-bottom: 10px;
-  border-bottom: 1px solid #ecf0f1;
-}
-
-h2 {
-  color: #2c3e50;
-  font-size: 20px;
-  margin: 0;
-}
-
-.stats {
-  font-size: 14px;
-  color: #7f8c8d;
-}
-
-.tests {
-  display: grid;
-  grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
-  gap: 15px;
-}

sasjs-tests/src/components/TestSuite.ts

@@ -1,117 +0,0 @@
-import type { CompletedTestSuite } from '../core/TestRunner'
-import { TestCard } from './TestCard'
-import styles from './TestSuite.css?inline'
-
-export class TestSuiteElement extends HTMLElement {
-  private static styleSheet = new CSSStyleSheet()
-  private shadow: ShadowRoot
-  private _suiteData: CompletedTestSuite | null = null
-  private _suiteIndex: number = 0
-
-  static {
-    this.styleSheet.replaceSync(styles)
-  }
-
-  constructor() {
-    super()
-    this.shadow = this.attachShadow({ mode: 'open' })
-    this.shadow.adoptedStyleSheets = [TestSuiteElement.styleSheet]
-  }
-
-  connectedCallback() {
-    this.render()
-  }
-
-  set suiteData(data: CompletedTestSuite) {
-    this._suiteData = data
-    this.render()
-  }
-
-  get suiteData(): CompletedTestSuite | null {
-    return this._suiteData
-  }
-
-  set suiteIndex(index: number) {
-    this._suiteIndex = index
-  }
-
-  get suiteIndex(): number {
-    return this._suiteIndex
-  }
-
-  updateTest(testIndex: number, testData: any) {
-    if (!this._suiteData) return
-
-    // Update the data
-    this._suiteData.completedTests[testIndex] = testData
-
-    // Update stats
-    this.updateStats()
-
-    // Update the specific test card
-    const testsContainer = this.shadow.getElementById('tests-container')
-    if (testsContainer) {
-      const cards = testsContainer.querySelectorAll('test-card')
-      const card = cards[testIndex] as TestCard
-      if (card) {
-        card.testData = testData
-      }
-    }
-  }
-
-  updateStats() {
-    if (!this._suiteData) return
-
-    const { completedTests } = this._suiteData
-    const passed = completedTests.filter((t) => t.status === 'passed').length
-    const failed = completedTests.filter((t) => t.status === 'failed').length
-    const running = completedTests.filter((t) => t.status === 'running').length
-
-    const statsEl = this.shadow.querySelector('.stats')
-    if (statsEl) {
-      statsEl.textContent = `Passed: ${passed} | Failed: ${failed} | Running: ${running}`
-    }
-  }
-
-  render() {
-    if (!this._suiteData) return
-
-    const { name, completedTests } = this._suiteData
-    const passed = completedTests.filter((t) => t.status === 'passed').length
-    const failed = completedTests.filter((t) => t.status === 'failed').length
-    const running = completedTests.filter((t) => t.status === 'running').length
-
-    this.shadow.innerHTML = `
-      <div class="header">
-        <h2>${name}</h2>
-        <div class="stats">Passed: ${passed} | Failed: ${failed} | Running: ${running}</div>
-      </div>
-      <div class="tests" id="tests-container"></div>
-    `
-
-    const testsContainer = this.shadow.getElementById('tests-container')
-    if (testsContainer) {
-      completedTests.forEach((completedTest, testIndex) => {
-        const card = document.createElement('test-card') as TestCard
-        card.testData = completedTest
-
-        card.addEventListener('rerun', () => {
-          this.dispatchEvent(
-            new CustomEvent('rerun-test', {
-              bubbles: true,
-              composed: true,
-              detail: {
-                suiteIndex: this._suiteIndex,
-                testIndex
-              }
-            })
-          )
-        })
-
-        testsContainer.appendChild(card)
-      })
-    }
-  }
-}
-
-customElements.define('test-suite', TestSuiteElement)

sasjs-tests/src/components/TestsView.css

@@ -1,104 +0,0 @@
-:host {
-  display: block;
-  width: 100%;
-  padding: 80px 20px 20px 20px;
-}
-
-.header {
-  position: fixed;
-  top: 0;
-  left: 0;
-  right: 0;
-  display: flex;
-  justify-content: space-between;
-  align-items: center;
-  padding: 15px 20px;
-  background: white;
-  border-bottom: 2px solid #3498db;
-  box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
-  z-index: 100;
-  height: 32px;
-}
-
-h1 {
-  color: #2c3e50;
-  margin: 0;
-  font-size: 20px;
-}
-
-.header-controls {
-  display: flex;
-  align-items: center;
-  gap: 15px;
-}
-
-.logout-btn {
-  padding: 8px 16px;
-  background: #e74c3c;
-  color: white;
-  border: none;
-  border-radius: 4px;
-  cursor: pointer;
-  font-size: 14px;
-
-  &:hover {
-    background: #c0392b;
-  }
-}
-
-.requests-btn {
-  padding: 8px 16px;
-  background: #3498db;
-  color: white;
-  border: none;
-  border-radius: 4px;
-  cursor: pointer;
-  font-size: 14px;
-
-  &:hover {
-    background: #2980b9;
-  }
-}
-
-.debug-toggle {
-  display: flex;
-  align-items: center;
-  gap: 8px;
-
-  label {
-    font-size: 14px;
-    color: #2c3e50;
-    cursor: pointer;
-  }
-}
-
-input[type='checkbox'] {
-  width: 18px;
-  height: 18px;
-  cursor: pointer;
-}
-
-.run-btn {
-  padding: 8px 16px;
-  background: #27ae60;
-  color: white;
-  border: none;
-  border-radius: 4px;
-  font-size: 14px;
-  font-weight: 600;
-  cursor: pointer;
-
-  &:hover:not(:disabled) {
-    background: #229954;
-  }
-
-  &:disabled {
-    opacity: 0.6;
-    cursor: not-allowed;
-  }
-}
-
-.results {
-  margin-top: 64px;
-  width: 100%;
-}

sasjs-tests/src/components/TestsView.ts

@@ -1,163 +0,0 @@
-import { appContext } from '../core/AppContext'
-import { TestRunner, type CompletedTestSuite } from '../core/TestRunner'
-import type { TestSuite } from '../types'
-import { TestSuiteElement } from './TestSuite'
-import styles from './TestsView.css?inline'
-
-export class TestsView extends HTMLElement {
-  private static styleSheet = new CSSStyleSheet()
-  private shadow: ShadowRoot
-  private testRunner: TestRunner | null = null
-  private _testSuites: TestSuite[] = []
-  private debugMode: boolean = false
-
-  static {
-    this.styleSheet.replaceSync(styles)
-  }
-
-  constructor() {
-    super()
-    this.shadow = this.attachShadow({ mode: 'open' })
-    this.shadow.adoptedStyleSheets = [TestsView.styleSheet]
-  }
-
-  connectedCallback() {
-    this.render()
-  }
-
-  get testSuites(): TestSuite[] {
-    return this._testSuites
-  }
-
-  set testSuites(suites: TestSuite[]) {
-    this._testSuites = suites
-    this.testRunner = new TestRunner(suites)
-    this.render()
-  }
-
-  render() {
-    this.shadow.innerHTML = `
-      <div class="header">
-        <h1>SASjs Adapter Tests</h1>
-        <div class="header-controls">
-          <div class="debug-toggle">
-            <input type="checkbox" id="debug-toggle" ${
-              this.debugMode ? 'checked' : ''
-            } />
-            <label for="debug-toggle">Debug Mode</label>
-          </div>
-          <button class="run-btn" id="run-btn">Run All Tests</button>
-          <button class="logout-btn" id="logout-btn">Logout</button>
-          <button class="requests-btn" id="requests-btn">View Requests</button>
-        </div>
-      </div>
-
-      <div class="results" id="results"></div>
-    `
-
-    const logoutBtn = this.shadow.getElementById('logout-btn')
-    logoutBtn?.addEventListener('click', () => this.handleLogout())
-
-    const debugToggle = this.shadow.getElementById(
-      'debug-toggle'
-    ) as HTMLInputElement
-    debugToggle?.addEventListener('change', (e) => this.handleDebugToggle(e))
-
-    const runBtn = this.shadow.getElementById('run-btn') as HTMLButtonElement
-    runBtn?.addEventListener('click', () => this.handleRunTests(runBtn))
-
-    const requestsBtn = this.shadow.getElementById('requests-btn')
-    requestsBtn?.addEventListener('click', () => this.handleViewRequests())
-  }
-
-  handleViewRequests() {
-    const requestsModal = document.querySelector('requests-modal') as any
-    if (requestsModal && requestsModal.openModal) {
-      requestsModal.openModal()
-    }
-  }
-
-  handleDebugToggle(e: Event) {
-    const checkbox = e.target as HTMLInputElement
-    this.debugMode = checkbox.checked
-
-    const adapter = appContext.getAdapter()
-    if (adapter) {
-      adapter.setDebugState(this.debugMode)
-    }
-  }
-
-  async handleLogout() {
-    const adapter = appContext.getAdapter()
-    if (adapter) {
-      await adapter.logOut()
-      appContext.setIsLoggedIn(false)
-      this.dispatchEvent(
-        new CustomEvent('logout', {
-          bubbles: true,
-          composed: true
-        })
-      )
-    }
-  }
-
-  async handleRunTests(runBtn: HTMLButtonElement) {
-    if (!this.testRunner) return
-
-    runBtn.disabled = true
-    runBtn.textContent = 'Running...'
-
-    const resultsContainer = this.shadow.getElementById('results')
-    if (resultsContainer) {
-      resultsContainer.innerHTML = ''
-    }
-
-    await this.testRunner.runAllTests((completedSuites) => {
-      this.renderResults(resultsContainer!, completedSuites)
-    })
-
-    runBtn.disabled = false
-    runBtn.textContent = 'Run All Tests'
-  }
-
-  renderResults(container: HTMLElement, completedSuites: CompletedTestSuite[]) {
-    container.innerHTML = ''
-
-    completedSuites.forEach((suite, suiteIndex) => {
-      const suiteElement = document.createElement(
-        'test-suite'
-      ) as TestSuiteElement
-      suiteElement.suiteData = suite
-      suiteElement.suiteIndex = suiteIndex
-
-      suiteElement.addEventListener('rerun-test', ((e: CustomEvent) => {
-        const { suiteIndex, testIndex } = e.detail
-        this.handleRerunTest(suiteIndex, testIndex, container)
-      }) as EventListener)
-
-      container.appendChild(suiteElement)
-    })
-  }
-
-  async handleRerunTest(
-    suiteIndex: number,
-    testIndex: number,
-    container: HTMLElement
-  ) {
-    if (!this.testRunner) return
-
-    await this.testRunner.rerunTest(
-      suiteIndex,
-      testIndex,
-      (suiteIdx, testIdx, testData) => {
-        const suites = container.querySelectorAll('test-suite')
-        const suiteElement = suites[suiteIdx] as TestSuiteElement
-        if (suiteElement && suiteElement.updateTest) {
-          suiteElement.updateTest(testIdx, testData)
-        }
-      }
-    )
-  }
-}
-
-customElements.define('tests-view', TestsView)

sasjs-tests/src/components/index.ts

@@ -1,5 +0,0 @@
-export { LoginForm } from './LoginForm'
-export { TestCard } from './TestCard'
-export { TestSuiteElement } from './TestSuite'
-export { TestsView } from './TestsView'
-export { RequestsModal } from './RequestsModal'

sasjs-tests/src/config/loader.ts

@@ -1,14 +0,0 @@
-import type { AppConfig } from '../types'
-
-export interface ConfigWithCredentials extends AppConfig {
-  userName?: string
-  password?: string
-}
-
-export async function loadConfig(): Promise<ConfigWithCredentials> {
-  const response = await fetch('config.json')
-  if (!response.ok) {
-    throw new Error('Failed to load config.json')
-  }
-  return response.json()
-}

sasjs-tests/src/core/AppContext.ts

@@ -1,60 +0,0 @@
-import type SASjs from '@sasjs/adapter'
-import type { AppConfig, AppState } from '../types'
-
-export class AppContext {
-  private state: AppState = {
-    config: null,
-    adapter: null,
-    isLoggedIn: false
-  }
-
-  private listeners: Array<(state: AppState) => void> = []
-
-  getState(): AppState {
-    return { ...this.state }
-  }
-
-  setState(newState: Partial<AppState>): void {
-    this.state = { ...this.state, ...newState }
-    this.notifyListeners()
-  }
-
-  subscribe(listener: (state: AppState) => void): () => void {
-    this.listeners.push(listener)
-    // Return unsubscribe function
-    return () => {
-      this.listeners = this.listeners.filter((l) => l !== listener)
-    }
-  }
-
-  private notifyListeners(): void {
-    this.listeners.forEach((listener) => listener(this.getState()))
-  }
-
-  setConfig(config: AppConfig): void {
-    this.setState({ config })
-  }
-
-  setAdapter(adapter: SASjs): void {
-    this.setState({ adapter })
-  }
-
-  setIsLoggedIn(isLoggedIn: boolean): void {
-    this.setState({ isLoggedIn })
-  }
-
-  getAdapter(): SASjs | null {
-    return this.state.adapter
-  }
-
-  getConfig(): AppConfig | null {
-    return this.state.config
-  }
-
-  isUserLoggedIn(): boolean {
-    return this.state.isLoggedIn
-  }
-}
-
-// Global singleton instance
-export const appContext = new AppContext()

sasjs-tests/src/core/TestRunner.ts

@@ -1,173 +0,0 @@
-import type { Test, TestSuite, TestStatus } from '../types'
-import { runTest } from './runTest'
-
-export interface CompletedTest {
-  test: Test
-  result: boolean
-  error: unknown
-  executionTime: number
-  status: TestStatus
-}
-
-export interface CompletedTestSuite {
-  name: string
-  completedTests: CompletedTest[]
-}
-
-export class TestRunner {
-  private testSuites: TestSuite[]
-  private completedTestSuites: CompletedTestSuite[] = []
-  private isRunning = false
-
-  constructor(testSuites: TestSuite[]) {
-    this.testSuites = testSuites
-  }
-
-  async runAllTests(
-    onUpdate?: (
-      completedSuites: CompletedTestSuite[],
-      currentIndex: number
-    ) => void
-  ): Promise<CompletedTestSuite[]> {
-    this.isRunning = true
-    this.completedTestSuites = []
-
-    for (let i = 0; i < this.testSuites.length; i++) {
-      const suite = this.testSuites[i]
-      await this.runTestSuite(suite, i, onUpdate)
-    }
-
-    this.isRunning = false
-    return this.completedTestSuites
-  }
-
-  async runTestSuite(
-    suite: TestSuite,
-    suiteIndex: number,
-    onUpdate?: (
-      completedSuites: CompletedTestSuite[],
-      currentIndex: number
-    ) => void
-  ): Promise<CompletedTestSuite> {
-    const completedTests: CompletedTest[] = []
-    let context: unknown
-
-    // Run beforeAll if exists
-    if (suite.beforeAll) {
-      context = await suite.beforeAll()
-    }
-
-    // Run each test sequentially
-    for (let i = 0; i < suite.tests.length; i++) {
-      const test = suite.tests[i]
-      const currentIndex = suiteIndex * 1000 + i
-
-      // Set status to running
-      const runningTest: CompletedTest = {
-        test,
-        result: false,
-        error: null,
-        executionTime: 0,
-        status: 'running'
-      }
-      completedTests.push(runningTest)
-
-      // Notify update
-      if (onUpdate) {
-        this.completedTestSuites[suiteIndex] = {
-          name: suite.name,
-          completedTests: [...completedTests]
-        }
-        onUpdate([...this.completedTestSuites], currentIndex)
-      }
-
-      // Execute test
-      const result = await runTest(test, { data: context })
-
-      // Update with result
-      completedTests[i] = {
-        test,
-        result: result.result,
-        error: result.error,
-        executionTime: result.executionTime,
-        status: result.result ? 'passed' : 'failed'
-      }
-
-      // Notify update
-      if (onUpdate) {
-        this.completedTestSuites[suiteIndex] = {
-          name: suite.name,
-          completedTests: [...completedTests]
-        }
-        onUpdate([...this.completedTestSuites], currentIndex)
-      }
-    }
-
-    // Run afterAll if exists
-    if (suite.afterAll) {
-      await suite.afterAll()
-    }
-
-    return {
-      name: suite.name,
-      completedTests
-    }
-  }
-
-  async rerunTest(
-    suiteIndex: number,
-    testIndex: number,
-    onUpdate?: (
-      suiteIndex: number,
-      testIndex: number,
-      testData: CompletedTest
-    ) => void
-  ): Promise<void> {
-    const suite = this.testSuites[suiteIndex]
-    const test = suite.tests[testIndex]
-
-    let context: unknown
-    if (suite.beforeAll) {
-      context = await suite.beforeAll()
-    }
-
-    // Set status to running
-    this.completedTestSuites[suiteIndex].completedTests[testIndex].status =
-      'running'
-    if (onUpdate) {
-      onUpdate(
-        suiteIndex,
-        testIndex,
-        this.completedTestSuites[suiteIndex].completedTests[testIndex]
-      )
-    }
-
-    // Execute test
-    const result = await runTest(test, { data: context })
-
-    // Update with result
-    this.completedTestSuites[suiteIndex].completedTests[testIndex] = {
-      test,
-      result: result.result,
-      error: result.error,
-      executionTime: result.executionTime,
-      status: result.result ? 'passed' : 'failed'
-    }
-
-    if (onUpdate) {
-      onUpdate(
-        suiteIndex,
-        testIndex,
-        this.completedTestSuites[suiteIndex].completedTests[testIndex]
-      )
-    }
-  }
-
-  getCompletedTestSuites(): CompletedTestSuite[] {
-    return this.completedTestSuites
-  }
-
-  isTestRunning(): boolean {
-    return this.isRunning
-  }
-}

sasjs-tests/src/core/index.ts

@@ -1,3 +0,0 @@
-export * from './runTest'
-export * from './TestRunner'
-export * from './AppContext'

sasjs-tests/src/core/runTest.ts

@@ -1,30 +0,0 @@
-import type { Test, TestResult } from '../types'
-
-export async function runTest(
-  testToRun: Test,
-  context: unknown
-): Promise<TestResult> {
-  const { test, assertion, beforeTest, afterTest } = testToRun
-  const beforeTestFunction = beforeTest ? beforeTest : () => Promise.resolve()
-  const afterTestFunction = afterTest ? afterTest : () => Promise.resolve()
-
-  const startTime = new Date().valueOf()
-
-  return beforeTestFunction()
-    .then(() => test(context))
-    .then((res) => {
-      return Promise.resolve(assertion(res, context))
-    })
-    .then((testResult) => {
-      afterTestFunction()
-      const endTime = new Date().valueOf()
-      const executionTime = (endTime - startTime) / 1000
-      return { result: testResult, error: null, executionTime }
-    })
-    .catch((e) => {
-      console.error(e)
-      const endTime = new Date().valueOf()
-      const executionTime = (endTime - startTime) / 1000
-      return { result: false, error: e, executionTime }
-    })
-}

sasjs-tests/src/index.scss

@@ -0,0 +1,61 @@
+body {
+  margin: 0;
+  font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", "Roboto", "Oxygen", "Ubuntu", "Cantarell", "Fira Sans",
+    "Droid Sans", "Helvetica Neue", sans-serif;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+  background-color: #1f2027;
+  color: #eee;
+}
+
+* {
+  font-family: source-code-pro, Menlo, Monaco, Consolas, "Courier New", monospace;
+}
+
+input {
+  padding: 8px;
+  border-radius: 3px;
+  border: none;
+  font-size: 1.125em;
+}
+
+.submit-button {
+  border: none;
+  border-radius: 3px;
+  padding: 8px;
+  background-color: #f9e804;
+  color: black;
+  font-size: 0.8em;
+
+  &.disabled {
+    pointer-events: none;
+  }
+}
+
+.row {
+  display: flex;
+  flex-direction: column;
+  margin-top: 16px;
+}
+
+.loading-spinner {
+  display: inline-block;
+  width: 50px;
+  height: 50px;
+  border: 3px solid rgba(255, 255, 255, 0.3);
+  border-radius: 50%;
+  border-top-color: #fff;
+  animation: spin 1s ease-in-out infinite;
+  -webkit-animation: spin 1s ease-in-out infinite;
+}
+
+@keyframes spin {
+  to {
+    -webkit-transform: rotate(360deg);
+  }
+}
+@-webkit-keyframes spin {
+  to {
+    -webkit-transform: rotate(360deg);
+  }
+}

sasjs-tests/src/index.tsx

@@ -0,0 +1,26 @@
+import React from 'react'
+import ReactDOM from 'react-dom'
+import { Route, HashRouter, Switch } from 'react-router-dom'
+import './index.scss'
+import * as serviceWorker from './serviceWorker'
+import { AppProvider } from '@sasjs/test-framework'
+import PrivateRoute from './PrivateRoute'
+import Login from './Login'
+import App from './App'
+
+ReactDOM.render(
+  <AppProvider>
+    <HashRouter>
+      <Switch>
+        <PrivateRoute exact path="/" component={App} />
+        <Route exact path="/login" component={Login} />
+      </Switch>
+    </HashRouter>
+  </AppProvider>,
+  document.getElementById('root')
+)
+
+// If you want your app to work offline and load faster, you can change
+// unregister() to register() below. Note this comes with some pitfalls.
+// Learn more about service workers: https://bit.ly/CRA-PWA
+serviceWorker.unregister()

sasjs-tests/src/main.ts

@@ -1,140 +0,0 @@
-import * as SASjsModule from '@sasjs/adapter'
-const SASjsImport = (SASjsModule as any).default || SASjsModule
-const SASjs = SASjsImport.default
-
-import { appContext } from './core/AppContext'
-import { type ConfigWithCredentials, loadConfig } from './config/loader'
-import type { TestSuite } from './types'
-
-// Import custom elements (this registers them)
-import './components/LoginForm'
-import './components/TestCard'
-import './components/TestSuite'
-import './components/TestsView'
-import './components/RequestsModal'
-import type { LoginForm } from './components/LoginForm'
-import type { TestsView } from './components/TestsView'
-import type { RequestsModal } from './components/RequestsModal'
-
-// Import test suites
-// import { basicTests } from './testSuites/Basic'
-import { sendArrTests, sendObjTests } from './testSuites/RequestData'
-import { fileUploadTests } from './testSuites/FileUpload'
-import { computeTests } from './testSuites/Compute'
-import { sasjsRequestTests } from './testSuites/SasjsRequests'
-
-async function init() {
-  const appContainer = document.getElementById('app')
-  if (!appContainer) {
-    console.error('App container not found')
-    return
-  }
-
-  try {
-    // Load config
-    const config = await loadConfig()
-
-    // Initialize adapter
-    const adapter = new SASjs(config.sasJsConfig)
-    appContext.setAdapter(adapter)
-    appContext.setConfig(config)
-
-    // Check session
-    try {
-      const sessionResponse = await adapter.checkSession()
-      if (sessionResponse && sessionResponse.isLoggedIn) {
-        appContext.setIsLoggedIn(true)
-        showTests(appContainer, adapter, config)
-        return
-      }
-    } catch {
-      console.log('No active session, showing login')
-    }
-
-    // Show login
-    showLogin(appContainer)
-  } catch (error) {
-    console.error('Failed to initialize app:', error)
-    appContainer.innerHTML = `
-      <div class="app__error">
-        <h1>Initialization Error</h1>
-        <p>Failed to load configuration. Please check config.json file.</p>
-        <pre>${error}</pre>
-      </div>
-    `
-  }
-}
-
-function showLogin(container: HTMLElement) {
-  container.innerHTML = ''
-  const loginForm = document.createElement('login-form') as LoginForm
-
-  loginForm.addEventListener('login-success', () => {
-    const adapter = appContext.getAdapter()
-    const config = appContext.getConfig()
-    if (adapter && config) {
-      showTests(container, adapter, config)
-    }
-  })
-
-  container.appendChild(loginForm)
-}
-
-function showTests(
-  container: HTMLElement,
-  adapter: typeof SASjs,
-  config: ConfigWithCredentials
-) {
-  const configTyped = config as {
-    sasJsConfig: { appLoc: string }
-    userName?: string
-    password?: string
-  }
-  const appLoc = configTyped.sasJsConfig.appLoc
-
-  // Build test suites with adapter and credentials
-  const testSuites: TestSuite[] = [
-    // FIXME: disabled basicTests due to login/logout operations
-    // basicTests(adapter, configTyped.userName || '', configTyped.password || ''),
-    sendArrTests(adapter, appLoc),
-    sendObjTests(adapter),
-    // specialCaseTests(adapter),
-    sasjsRequestTests(adapter),
-    fileUploadTests(adapter)
-  ]
-
-  // Add compute tests for SASVIYA only
-  if (adapter.getSasjsConfig().serverType === 'SASVIYA') {
-    testSuites.push(computeTests(adapter, appLoc))
-  }
-
-  container.innerHTML = ''
-  const testsView = document.createElement('tests-view') as TestsView
-  testsView.testSuites = testSuites
-
-  const requestsModal = document.createElement(
-    'requests-modal'
-  ) as RequestsModal
-
-  testsView.addEventListener('logout', () => {
-    showLogin(container)
-  })
-
-  container.appendChild(requestsModal)
-  container.appendChild(testsView)
-}
-
-// Subscribe to auth changes
-appContext.subscribe((state) => {
-  const appContainer = document.getElementById('app')
-  if (!appContainer) return
-
-  if (!state.isLoggedIn) {
-    showLogin(appContainer)
-  } else if (state.adapter && state.config) {
-    showTests(appContainer, state.adapter, state.config)
-  }
-})
-
-// Initialize app
-init()

sasjs-tests/src/react-app-env.d.ts

@@ -0,0 +1 @@
+/// <reference types="react-scripts" />

sasjs-tests/src/serviceWorker.js

@@ -0,0 +1,141 @@
+// This optional code is used to register a service worker.
+// register() is not called by default.
+
+// This lets the app load faster on subsequent visits in production, and gives
+// it offline capabilities. However, it also means that developers (and users)
+// will only see deployed updates on subsequent visits to a page, after all the
+// existing tabs open on the page have been closed, since previously cached
+// resources are updated in the background.
+
+// To learn more about the benefits of this model and instructions on how to
+// opt-in, read https://bit.ly/CRA-PWA
+
+const isLocalhost = Boolean(
+  window.location.hostname === 'localhost' ||
+    // [::1] is the IPv6 localhost address.
+    window.location.hostname === '[::1]' ||
+    // 127.0.0.0/8 are considered localhost for IPv4.
+    window.location.hostname.match(
+      /^127(?:\.(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)){3}$/
+    )
+)
+
+export function register(config) {
+  if (process.env.NODE_ENV === 'production' && 'serviceWorker' in navigator) {
+    // The URL constructor is available in all browsers that support SW.
+    const publicUrl = new URL(process.env.PUBLIC_URL, window.location.href)
+    if (publicUrl.origin !== window.location.origin) {
+      // Our service worker won't work if PUBLIC_URL is on a different origin
+      // from what our page is served on. This might happen if a CDN is used to
+      // serve assets; see https://github.com/facebook/create-react-app/issues/2374
+      return
+    }
+
+    window.addEventListener('load', () => {
+      const swUrl = `${process.env.PUBLIC_URL}/service-worker.js`
+
+      if (isLocalhost) {
+        // This is running on localhost. Let's check if a service worker still exists or not.
+        checkValidServiceWorker(swUrl, config)
+
+        // Add some additional logging to localhost, pointing developers to the
+        // service worker/PWA documentation.
+        navigator.serviceWorker.ready.then(() => {
+          console.log(
+            'This web app is being served cache-first by a service ' +
+              'worker. To learn more, visit https://bit.ly/CRA-PWA'
+          )
+        })
+      } else {
+        // Is not localhost. Just register service worker
+        registerValidSW(swUrl, config)
+      }
+    })
+  }
+}
+
+function registerValidSW(swUrl, config) {
+  navigator.serviceWorker
+    .register(swUrl)
+    .then((registration) => {
+      registration.onupdatefound = () => {
+        const installingWorker = registration.installing
+        if (installingWorker == null) {
+          return
+        }
+        installingWorker.onstatechange = () => {
+          if (installingWorker.state === 'installed') {
+            if (navigator.serviceWorker.controller) {
+              // At this point, the updated precached content has been fetched,
+              // but the previous service worker will still serve the older
+              // content until all client tabs are closed.
+              console.log(
+                'New content is available and will be used when all ' +
+                  'tabs for this page are closed. See https://bit.ly/CRA-PWA.'
+              )
+
+              // Execute callback
+              if (config && config.onUpdate) {
+                config.onUpdate(registration)
+              }
+            } else {
+              // At this point, everything has been precached.
+              // It's the perfect time to display a
+              // "Content is cached for offline use." message.
+              console.log('Content is cached for offline use.')
+
+              // Execute callback
+              if (config && config.onSuccess) {
+                config.onSuccess(registration)
+              }
+            }
+          }
+        }
+      }
+    })
+    .catch((error) => {
+      console.error('Error during service worker registration:', error)
+    })
+}
+
+function checkValidServiceWorker(swUrl, config) {
+  // Check if the service worker can be found. If it can't reload the page.
+  fetch(swUrl, {
+    headers: { 'Service-Worker': 'script' }
+  })
+    .then((response) => {
+      // Ensure service worker exists, and that we really are getting a JS file.
+      const contentType = response.headers.get('content-type')
+      if (
+        response.status === 404 ||
+        (contentType != null && contentType.indexOf('javascript') === -1)
+      ) {
+        // No service worker found. Probably a different app. Reload the page.
+        navigator.serviceWorker.ready.then((registration) => {
+          registration.unregister().then(() => {
+            window.location.reload()
+          })
+        })
+      } else {
+        // Service worker found. Proceed as normal.
+        registerValidSW(swUrl, config)
+      }
+    })
+    .catch(() => {
+      console.log(
+        'No internet connection found. App is running in offline mode.'
+      )
+    })
+}
+
+export function unregister() {
+  if ('serviceWorker' in navigator) {
+    navigator.serviceWorker.ready
+      .then((registration) => {
+        registration.unregister()
+      })
+      .catch((error) => {
+        console.error(error.message)
+      })
+  }
+}

sasjs-tests/src/setupTests.js

@@ -0,0 +1,5 @@
+// jest-dom adds custom jest matchers for asserting on DOM nodes.
+// allows you to do things like:
+// expect(element).toHaveTextContent(/react/i)
+// learn more: https://github.com/testing-library/jest-dom
+import '@testing-library/jest-dom/extend-expect'

sasjs-tests/src/testSuites/Basic.ts

@@ -1,8 +1,6 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-/* eslint-disable @typescript-eslint/no-explicit-any */
 import SASjs, { LoginMechanism, SASjsConfig } from '@sasjs/adapter'
+import { TestSuite } from '@sasjs/test-framework'
 import { ServerType } from '@sasjs/utils/types'
-import type { TestSuite } from '../types'
 
 const stringData: any = { table1: [{ col1: 'first col value' }] }
 
@@ -63,7 +61,7 @@ export const basicTests = (
         'Should fail on first attempt and should log the user in on second attempt',
       test: async () => {
         await adapter.logOut()
-        await adapter.logIn('invalid', 'invalid').catch((_err: any) => {})
+        await adapter.logIn('invalid', 'invalid').catch((err: any) => {})
         return await adapter.logIn(userName, password)
       },
       assertion: (response: any) =>
@@ -89,20 +87,6 @@ export const basicTests = (
         return response.table1[0][0] === stringData.table1[0].col1
       }
     },
-    {
-      title: 'Web request',
-      description: 'Should run the request with old web approach',
-      test: async () => {
-        const config: Partial<SASjsConfig> = {
-          useComputeApi: false
-        }
-
-        return await adapter.request('common/sendArr', stringData, config)
-      },
-      assertion: (response: any) => {
-        return response.table1[0][0] === stringData.table1[0].col1
-      }
-    },
     {
       title: 'Request with debug on',
       description:
@@ -175,6 +159,20 @@ export const basicTests = (
           sasjsConfig.debug === false
         )
       }
+    },
+    {
+      title: 'Web request',
+      description: 'Should run the request with old web approach',
+      test: async () => {
+        const config: Partial<SASjsConfig> = {
+          useComputeApi: false
+        }
+
+        return await adapter.request('common/sendArr', stringData, config)
+      },
+      assertion: (response: any) => {
+        return response.table1[0][0] === stringData.table1[0].col1
+      }
     }
   ]
 })

sasjs-tests/src/testSuites/Compute.ts

@@ -1,6 +1,5 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
 import SASjs from '@sasjs/adapter'
-import type { TestSuite } from '../types'
+import { TestSuite } from '@sasjs/test-framework'
 
 const stringData: any = { table1: [{ col1: 'first col value' }] }
 
@@ -49,7 +48,7 @@ export const computeTests = (adapter: SASjs, appLoc: string): TestSuite => ({
       test: () => {
         const data: any = { table1: [{ col1: 'first col value' }] }
         return adapter.startComputeJob(
-          `${appLoc}/common/sendArr`,
+          '/Public/app/adapter-tests/services/common/sendArr',
           data,
           {},
           undefined,

sasjs-tests/src/testSuites/FileUpload.ts

@@ -1,7 +1,5 @@
-/* eslint-disable prefer-const */
-/* eslint-disable @typescript-eslint/no-explicit-any */
 import SASjs from '@sasjs/adapter'
-import type { TestSuite } from '../types'
+import { TestSuite } from '@sasjs/test-framework'
 
 export const fileUploadTests = (adapter: SASjs): TestSuite => ({
   name: 'File Upload Tests',

sasjs-tests/src/testSuites/RequestData.ts

@@ -1,6 +1,5 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
 import SASjs from '@sasjs/adapter'
-import type { TestSuite } from '../types'
+import { TestSuite } from '@sasjs/test-framework'
 
 const stringData: any = { table1: [{ col1: 'first col value' }] }
 const numericData: any = { table1: [{ col1: 3.14159265 }] }

sasjs-tests/src/testSuites/SasjsRequests.ts

@@ -1,6 +1,5 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
 import SASjs from '@sasjs/adapter'
-import type { TestSuite } from '../types'
+import { TestSuite } from '@sasjs/test-framework'
 
 const data: any = { table1: [{ col1: 'first col value' }] }
 
@@ -21,30 +20,30 @@ export const sasjsRequestTests = (adapter: SASjs): TestSuite => ({
           return requests[0].SASWORK === null
         }
       }
+    },
+    {
+      title: 'Make error and capture log',
+      description:
+        'Should make an error and capture log, in the same time it is testing if debug override is working',
+      test: async () => {
+        return adapter
+          .request('common/makeErr', data, { debug: true })
+          .catch(() => {
+            const sasRequests = adapter.getSasRequests()
+            const makeErrRequest: any =
+              sasRequests.find((req) => req.serviceLink.includes('makeErr')) ||
+              null
+
+            if (!makeErrRequest) return false
+
+            return !!(
+              makeErrRequest.logFile && makeErrRequest.logFile.length > 0
+            )
+          })
+      },
+      assertion: (response) => {
+        return response
+      }
     }
-    // {
-    //   title: 'Make error and capture log',
-    //   description:
-    //     'Should make an error and capture log, in the same time it is testing if debug override is working',
-    //   test: async () => {
-    //     return adapter
-    //       .request('common/makeErr', data, { debug: true })
-    //       .catch(() => {
-    //         const sasRequests = adapter.getSasRequests()
-    //         const makeErrRequest: any =
-    //           sasRequests.find((req) => req.serviceLink.includes('makeErr')) ||
-    //           null
-
-    //         if (!makeErrRequest) return false
-
-    //         return !!(
-    //           makeErrRequest.logFile && makeErrRequest.logFile.length > 0
-    //         )
-    //       })
-    //   },
-    //   assertion: (response) => {
-    //     return response
-    //   }
-    // }
   ]
 })

sasjs-tests/src/testSuites/SpecialCases.ts

@@ -1,7 +1,5 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-/* eslint-disable @typescript-eslint/no-explicit-any */
 import SASjs from '@sasjs/adapter'
-import type { TestSuite } from '../types'
+import { TestSuite } from '@sasjs/test-framework'
 
 const specialCharData: any = {
   table1: [
@@ -136,20 +134,6 @@ export const specialCaseTests = (adapter: SASjs): TestSuite => ({
         return adapter.request('common/sendArr', moreSpecialCharData)
       },
       assertion: (res: any) => {
-        // If sas session is `latin9` or `wlatin1` we can't process the special characters,
-        // But it can happen that response is broken JSON, so we first need to check if
-        // it's object and then check accordingly
-
-        if (typeof res === 'object') {
-          // Valid JSON response
-          if (res.SYSENCODING === 'latin9' || res.SYSENCODING === 'wlatin1')
-            return true
-        } else {
-          // Since we got string response (broken JSON), we need to check with regex
-          const regex = /"SYSENCODING"\s*:\s*"(?:wlatin1|latin9)"/
-          if (regex.test(res)) return true
-        }
-
         return (
           res.table1[0][0] === moreSpecialCharData.table1[0].speech0 &&
           res.table1[0][1] === moreSpecialCharData.table1[0].pct &&
@@ -327,7 +311,7 @@ export const specialCaseTests = (adapter: SASjs): TestSuite => ({
         // We receive formats in response. We compare it with formats that we included in request to make sure they are equal
         const resVars = res[`$${testTable}`].vars
 
-        Object.keys(resVars).forEach((key: any, _i: number) => {
+        Object.keys(resVars).forEach((key: any, i: number) => {
           let formatValue =
             testTableWithSpecialNumeric[`$${testTable}`].formats[
               key.toLowerCase()
@@ -375,7 +359,7 @@ export const specialCaseTests = (adapter: SASjs): TestSuite => ({
         // We receive formats in response. We compare it with formats that we included in request to make sure they are equal
         const resVars = res[`$${testTable}`].vars
 
-        Object.keys(resVars).forEach((key: any, _i: number) => {
+        Object.keys(resVars).forEach((key: any, i: number) => {
           let formatValue =
             testTableWithSpecialNumeric[`$${testTable}`].formats[
               key.toLowerCase()
@@ -423,7 +407,7 @@ export const specialCaseTests = (adapter: SASjs): TestSuite => ({
         // We receive formats in response. We compare it with formats that we included in request to make sure they are equal
         const resVars = res[`$${testTable}`].vars
 
-        Object.keys(resVars).forEach((key: any, _i: number) => {
+        Object.keys(resVars).forEach((key: any, i: number) => {
           let formatValue =
             testTableWithSpecialNumericLowercase[`$${testTable}`].formats[
               key.toLowerCase()
@@ -480,7 +464,7 @@ export const specialCaseTests = (adapter: SASjs): TestSuite => ({
         // We receive formats in response. We compare it with formats that we included in request to make sure they are equal
         const resVars = res[`$${testTable}`].vars
 
-        Object.keys(resVars).forEach((key: any, _i: number) => {
+        Object.keys(resVars).forEach((key: any, i: number) => {
           let formatValue =
             testTableWithSpecialNumeric[`$${testTable}`].formats[
               key.toLowerCase()

sasjs-tests/src/types/context.ts

@@ -1,12 +0,0 @@
-import type SASjs from '@sasjs/adapter'
-import type { SASjsConfig } from '@sasjs/adapter'
-
-export interface AppConfig {
-  sasJsConfig: SASjsConfig
-}
-
-export interface AppState {
-  config: AppConfig | null
-  adapter: SASjs | null
-  isLoggedIn: boolean
-}

sasjs-tests/src/types/index.ts

@@ -1,2 +0,0 @@
-export * from './test'
-export * from './context'

sasjs-tests/src/types/test.ts

@@ -1,24 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-export interface Test {
-  title: string
-  description: string
-  beforeTest?: (...args: any) => Promise<any>
-  afterTest?: (...args: any) => Promise<any>
-  test: (context: any) => Promise<any>
-  assertion: (...args: any) => boolean
-}
-
-export interface TestSuite {
-  name: string
-  tests: Test[]
-  beforeAll?: (...args: any) => Promise<any>
-  afterAll?: (...args: any) => Promise<any>
-}
-
-export interface TestResult {
-  result: boolean
-  error: Error | null
-  executionTime: number
-}
-
-export type TestStatus = 'pending' | 'running' | 'passed' | 'failed'

sasjs-tests/src/utils/Assert.ts

@@ -0,0 +1,22 @@
+export const assert = (
+  expression: boolean | (() => boolean),
+  message = 'Assertion failed'
+) => {
+  let result
+  try {
+    if (typeof expression === 'boolean') {
+      result = expression
+    } else {
+      result = expression()
+    }
+  } catch (e: any) {
+    console.error(message)
+    throw new Error(message)
+  }
+  if (!!result) {
+    return
+  } else {
+    console.error(message)
+    throw new Error(message)
+  }
+}

sasjs-tests/tsconfig.json

@@ -1,26 +1,26 @@
 {
   "compilerOptions": {
-    "target": "ES2022",
-    "useDefineForClassFields": true,
-    "module": "ESNext",
-    "lib": ["ES2022", "DOM", "DOM.Iterable"],
-    "types": ["vite/client"],
+    "target": "es5",
+    "lib": [
+      "dom",
+      "dom.iterable",
+      "esnext"
+    ],
+    "allowJs": true,
     "skipLibCheck": true,
-
-    /* Bundler mode */
-    "moduleResolution": "bundler",
-    "allowImportingTsExtensions": true,
-    "verbatimModuleSyntax": true,
-    "moduleDetection": "force",
-    "noEmit": true,
-
-    /* Linting */
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
     "strict": true,
-    "noUnusedLocals": true,
-    "noUnusedParameters": true,
-    "erasableSyntaxOnly": true,
-    "noFallthroughCasesInSwitch": true,
-    "noUncheckedSideEffectImports": true
+    "forceConsistentCasingInFileNames": true,
+    "module": "esnext",
+    "moduleResolution": "node",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "jsx": "react-jsx",
+    "noFallthroughCasesInSwitch": true
   },
-  "include": ["src"]
+  "include": [
+    "src"
+  ]
 }

sasjs-tests/vite.config.js

@@ -1,8 +0,0 @@
-import { defineConfig } from 'vite'
-export default defineConfig({
-  build: {
-    assetsInlineLimit: 0,
-    assetsDir: ''
-  },
-  base: ''
-})

src/SAS9ApiClient.ts

@@ -1,6 +1,6 @@
 import * as https from 'https'
 import { generateTimestamp } from '@sasjs/utils/time'
-import NodeFormData from 'form-data'
+import * as NodeFormData from 'form-data'
 import { Sas9RequestClient } from './request/Sas9RequestClient'
 import { isUrl } from './utils'
 

src/SASViyaApiClient.ts

@@ -1,5 +1,5 @@
 import { isRelativePath, isUri, isUrl } from './utils'
-import NodeFormData from 'form-data'
+import * as NodeFormData from 'form-data'
 import {
   Job,
   Session,
@@ -25,70 +25,15 @@ import { prefixMessage } from '@sasjs/utils/error'
 import { pollJobState } from './api/viya/pollJobState'
 import { getTokens } from './auth/getTokens'
 import { uploadTables } from './api/viya/uploadTables'
-import { executeOnComputeApi } from './api/viya/executeOnComputeApi'
+import { executeScript } from './api/viya/executeScript'
 import { getAccessTokenForViya } from './auth/getAccessTokenForViya'
 import { refreshTokensForViya } from './auth/refreshTokensForViya'
-import { FileResource } from './types/FileResource'
 
 interface JobExecutionResult {
   result?: { result: object }
   log?: string
   error?: object
 }
-/* Viya /types/types?limit=999999 response structure */
-interface IViyaTypesResponse {
-  accept: string
-  count: number
-  items: IViyaTypesItem[]
-  limit: number
-  links: IViyaTypesLink[]
-  name: string
-  start: number
-  version: number
-}
-
-/* Item element within the Viya types response */
-interface IViyaTypesItem {
-  description?: string
-  extensions?: string[]
-  iconUri?: string
-  label: string
-  links: IViyaTypesLink[]
-  mappedTypes?: string[]
-  mediaType?: string
-  mediaTypes?: string[]
-  name?: string | undefined
-  pluralLabel?: string
-  properties?: IViyaTypesProperties
-  resourceUri?: string
-  serviceRootUri?: string
-  tags?: string[]
-  version: number
-}
-
-/**
- * Generic structure for a link
- * in the links array of a Viya
- * types/types api response
- */
-type IViyaTypesLink = Record<string, string>
-
-/**
- * Generic structure for a type's
- * 'properties' object from the Viya
- * types/types api response
- */
-type IViyaTypesProperties = Record<string, string>
-
-/**
- * Arbitrary interface for storing
- * sufficient additional detail to
- * create and patch a new file.
- */
-interface IViyaTypesExtensionInfo {
-  typeDefName: string | undefined
-  properties: IViyaTypesProperties | undefined
-}
 
 /**
  * A client for interfacing with the SAS Viya REST API.
@@ -115,9 +60,6 @@ export class SASViyaApiClient {
     this.requestClient
   )
   private folderMap = new Map<string, Job[]>()
-  private fileExtensionMap = new Map<string, IViyaTypesExtensionInfo>()
-  private boolExtensionMap = false // required in case the map has zero entries
-  // after an attempt to populate it.
 
   /**
    * A helper method used to call appendRequest method of RequestClient
@@ -351,7 +293,7 @@ export class SASViyaApiClient {
     printPid = false,
     variables?: MacroVar
   ): Promise<any> {
-    return executeOnComputeApi(
+    return executeScript(
       this.requestClient,
       this.sessionManager,
       this.rootFolderName,
@@ -369,84 +311,6 @@ export class SASViyaApiClient {
     )
   }
 
-  /**
-   * Fetches the file content for a file in the specified folder.
-   *
-   * @param folderPath - the full path to the folder containing the file. eg: /Public/folder1/folder2
-   * @param fileName - the name of the file in the `folderPath`
-   * @param accessToken - an access token for authorizing the request
-   */
-  public async getFileContent(
-    folderPath: string,
-    fileName: string,
-    accessToken?: string
-  ) {
-    const fileUri = await this.getFileUri(
-      folderPath,
-      fileName,
-      accessToken
-    ).catch((err) => {
-      throw prefixMessage(
-        err,
-        `Error while getting file URI for: ${fileName} in folder: ${folderPath}. `
-      )
-    })
-
-    return await this.requestClient
-      .get<string>(`${this.serverUrl}${fileUri}/content`, accessToken)
-      .then((res) => res.result)
-  }
-
-  /**
-   * Updates the file content for a file in the specified folder.
-   *
-   * @param folderPath - the full path to the folder containing the file. eg: /Public/folder1/folder2
-   * @param fileName - the name of the file in the `folderPath`
-   * @param content - the new content to be written to the file
-   * @param accessToken - an access token for authorizing the request
-   */
-  public async updateFileContent(
-    folderPath: string,
-    fileName: string,
-    content: string,
-    accessToken?: string
-  ) {
-    const fileUri = await this.getFileUri(
-      folderPath,
-      fileName,
-      accessToken
-    ).catch((err) => {
-      throw prefixMessage(
-        err,
-        `Error while getting file URI for: ${fileName} in folder: ${folderPath}. `
-      )
-    })
-
-    // Fetch the file resource details to get the Etag and content type
-    const { result: originalFileResource, etag } =
-      await this.requestClient.get<FileResource>(
-        `${this.serverUrl}${fileUri}`,
-        accessToken
-      )
-
-    if (!originalFileResource || !etag)
-      throw new Error(
-        `File ${fileName} does not have an ETag, or request failed.`
-      )
-
-    return await this.requestClient
-      .put<FileResource>(
-        `${this.serverUrl}${fileUri}/content`,
-        content,
-        accessToken,
-        {
-          'If-Match': etag,
-          'Content-Type': originalFileResource.contentType
-        }
-      )
-      .then((res) => res.result)
-  }
-
   /**
    * Fetches a folder. Path to the folder is required.
    * @param folderPath - the absolute path to the folder.
@@ -491,102 +355,15 @@ export class SASViyaApiClient {
     const formData = new NodeFormData()
     formData.append('file', contentBuffer, fileName)
 
-    /** Query Viya for file metadata based on extension type. */
-
-    // typeDefName - Viya accepts this property during the file creation
-    let typeDefName: string | undefined = undefined
-    // Additional properties are supplied by a patch.
-    let filePatch:
-      | {
-          name: string
-          properties: IViyaTypesProperties | undefined
-        }
-      | undefined = undefined
-
-    // The patching process requires properties related to the file-extension
-    const fileExtension: string | undefined = fileName
-      .split('.')
-      .pop()
-      ?.toLowerCase()
-
-    if (fileExtension) {
-      if (!this.boolExtensionMap) {
-        // Populate the file extension map
-        // 1. Get Viya's response to this api call
-        const typesQueryUrl = `/types/types?limit=999999`
-        const response = (
-          await this.requestClient.get(typesQueryUrl, accessToken)
-        ).result as IViyaTypesResponse
-        // 2. Filter the returned items that have file extensions into a map
-        //    using forEach as an item may relate to multiple file extensions.
-        response.items
-          .filter((e) => e.extensions)
-          .forEach((e) => {
-            e.extensions?.forEach((ext) => {
-              this.fileExtensionMap.set(ext, {
-                // `name` becomes the typeDefName value at file creation time.
-                // `name` is ignored here if it is not populated in the map, or
-                // has a blank/empty value.
-                typeDefName: e.name
-                  ? e.name.trim().length
-                    ? e.name.trim()
-                    : undefined
-                  : undefined,
-                properties: e.properties
-              })
-            })
-          })
-        // 3. Toggle the flag to avoid repeating this step
-        this.boolExtensionMap = true
-      }
-
-      // Query the map for the current file extension
-      const fileExtInfo = this.fileExtensionMap.get(fileExtension)
-      if (fileExtInfo) {
-        // If the extension was found in the map, record the typeDefName and
-        // create a patch if a properties object was returned.
-        typeDefName = fileExtInfo.typeDefName
-        if (fileExtInfo.properties)
-          filePatch = { name: fileName, properties: fileExtInfo.properties }
-      }
-    }
-
-    // Create the file
-    const createFileResponse = await this.requestClient.post<File>(
-      `/files/files?parentFolderUri=${parentFolderUri}&typeDefName=${
-        typeDefName ?? 'file'
-      }#rawUpload`,
-      formData,
-      accessToken,
-      'multipart/form-data; boundary=' + (formData as any)._boundary,
-      headers
-    )
-
-    // If a patch was created...
-    if (filePatch) {
-      try {
-        const patchHeaders = {
-          Accept: 'application/json',
-          'If-Match': '*'
-        }
-        // Get the URI of the newly created file
-        const fileUri = createFileResponse.result.links.filter(
-          (e) => e.method == 'PATCH' && e.rel == 'patch'
-        )[0].uri
-        // and apply the patch
-        return (
-          await this.requestClient.patch<File>(
-            `${fileUri}`,
-            filePatch,
-            accessToken,
-            patchHeaders
-          )
-        ).result
-      } catch (e: any) {
-        throw new Error(`Error patching file ${fileName}.\n${e.message}`)
-      }
-    }
-    return createFileResponse.result
+    return (
+      await this.requestClient.post<File>(
+        `/files/files?parentFolderUri=${parentFolderUri}&typeDefName=file#rawUpload`,
+        formData,
+        accessToken,
+        'multipart/form-data; boundary=' + (formData as any)._boundary,
+        headers
+      )
+    ).result
   }
 
   /**
@@ -1014,14 +791,14 @@ export class SASViyaApiClient {
       _webin_file_count: files.length,
       _OMITJSONLISTING: true,
       _OMITJSONLOG: true,
-      _omitSessionResults: false,
+      _OMITSESSIONRESULTS: true,
       _OMITTEXTLISTING: true,
       _OMITTEXTLOG: true
     }
 
     if (debug) {
       jobArguments['_OMITTEXTLOG'] = 'false'
-      jobArguments['_omitSessionResults'] = 'false'
+      jobArguments['_OMITSESSIONRESULTS'] = 'false'
       jobArguments['_DEBUG'] = 131
     }
 
@@ -1164,7 +941,6 @@ export class SASViyaApiClient {
       })
 
     if (!folder) return undefined
-
     return folder
   }
 
@@ -1176,30 +952,6 @@ export class SASViyaApiClient {
     return `/folders/folders/${folderDetails.id}`
   }
 
-  private async getFileUri(
-    folderPath: string,
-    fileName: string,
-    accessToken?: string
-  ): Promise<string> {
-    const folderMembers = await this.listFolder(folderPath, accessToken, 1000, {
-      returnDetails: true
-    }).catch((err) => {
-      throw prefixMessage(err, `Error while listing folder: ${folderPath}. `)
-    })
-
-    if (!folderMembers || !folderMembers.length)
-      throw new Error(`No members found in folder: ${folderPath}`)
-
-    const fileUri = folderMembers.find(
-      (member) => member.name === fileName
-    )?.uri
-
-    if (!fileUri)
-      throw new Error(`File ${fileName} not found in folder: ${folderPath}`)
-
-    return fileUri
-  }
-
   private async getRecycleBinUri(accessToken?: string) {
     const url = '/folders/folders/@myRecycleBin'
 
@@ -1247,19 +999,14 @@ export class SASViyaApiClient {
   }
 
   /**
-   * Lists children folders/files for given Viya folder.
+   * Lists children folders for given Viya folder.
    * @param sourceFolder - the full path (eg `/Public/example/myFolder`) or URI of the source folder listed. Providing URI instead of path will save one extra request.
    * @param accessToken - an access token for authorizing the request.
-   * @param {Object} [options] - Additional options.
-   * @param {boolean} [options.returnDetails=false] - when set to true, the function will return an array of objects with member details, otherwise it will return an array of member names.
    */
   public async listFolder(
     sourceFolder: string,
     accessToken?: string,
-    limit: number = 20,
-    options?: {
-      returnDetails?: boolean
-    }
+    limit: number = 20
   ) {
     // checks if 'sourceFolder' is already a URI
     const sourceFolderUri = isUri(sourceFolder)
@@ -1271,20 +1018,11 @@ export class SASViyaApiClient {
       accessToken
     )
 
-    let membersToReturn = []
-
     if (members && members.items) {
-      // If returnDetails is true, return full member details
-      if (options?.returnDetails) {
-        membersToReturn = members.items
-      } else {
-        // If returnDetails is false, return only member names
-        membersToReturn = members.items.map((item: any) => item.name)
-      }
+      return members.items.map((item: any) => item.name)
+    } else {
+      return []
     }
-
-    // Return members without Etag
-    return membersToReturn
   }
 
   /**

src/SASjs.ts

@@ -4,13 +4,7 @@ import {
   UploadFile,
   EditContextInput,
   PollOptions,
-  LoginMechanism,
-  VerboseMode,
-  ErrorResponse,
-  LoginOptions,
-  LoginResult,
-  ExecutionQuery,
-  Tables
+  LoginMechanism
 } from './types'
 import { SASViyaApiClient } from './SASViyaApiClient'
 import { SAS9ApiClient } from './SAS9ApiClient'
@@ -35,7 +29,8 @@ import {
   Sas9JobExecutor,
   FileUploader
 } from './job-execution'
-import { AxiosResponse, AxiosError } from 'axios'
+import { ErrorResponse } from './types/errors'
+import { LoginOptions, LoginResult } from './types/Login'
 
 interface ExecuteScriptParams {
   linesOfCode: string[]
@@ -162,23 +157,6 @@ export default class SASjs {
     }
   }
 
-  /**
-   * Executes job on SASJS server.
-   * @param query - an object containing job path and debug level.
-   * @param appLoc - an application path.
-   * @param authConfig - an object for authentication.
-   * @returns a promise that resolves into job execution result and log.
-   */
-  public async executeJob(
-    query: ExecutionQuery,
-    appLoc: string,
-    authConfig?: AuthConfig
-  ) {
-    this.isMethodSupported('executeScript', [ServerType.Sasjs])
-
-    return await this.sasJSApiClient?.executeJob(query, appLoc, authConfig)
-  }
-
   /**
    * Gets compute contexts.
    * @param accessToken - an access token for an authorised user.
@@ -412,51 +390,6 @@ export default class SASjs {
     )
   }
 
-  /**
-   * Fetches the file content for a file in the specified folder.
-   *
-   * @param folderPath - the full path to the folder containing the file. eg: /Public/folder1/folder2
-   * @param fileName - the name of the file in the `folderPath`
-   * @param accessToken - an access token for authorizing the request
-   */
-  public async getFileContent(
-    folderPath: string,
-    fileName: string,
-    accessToken?: string
-  ) {
-    this.isMethodSupported('getFileContent', [ServerType.SasViya])
-
-    return await this.sasViyaApiClient!.getFileContent(
-      folderPath,
-      fileName,
-      accessToken
-    )
-  }
-
-  /**
-   * Updates the file content for a file in the specified folder.
-   *
-   * @param folderPath - the full path to the folder containing the file. eg: /Public/folder1/folder2
-   * @param fileName - the name of the file in the `folderPath`
-   * @param content - the new content to be written to the file
-   * @param accessToken - an access token for authorizing the request
-   */
-  public async updateFileContent(
-    folderPath: string,
-    fileName: string,
-    content: string,
-    accessToken?: string
-  ) {
-    this.isMethodSupported('updateFileContent', [ServerType.SasViya])
-
-    return await this.sasViyaApiClient!.updateFileContent(
-      folderPath,
-      fileName,
-      content,
-      accessToken
-    )
-  }
-
   /**
    * Fetches a folder from the SAS file system.
    * @param folderPath - path of the folder to be fetched.
@@ -482,23 +415,18 @@ export default class SASjs {
    * Lists children folders for given Viya folder.
    * @param sourceFolder - the full path (eg `/Public/example/myFolder`) or URI of the source folder listed. Providing URI instead of path will save one extra request.
    * @param accessToken - an access token for authorizing the request.
-   * @param returnDetails - when set to true, the function will return an array of objects with member details, otherwise it will return an array of member names.
    */
   public async listFolder(
     sourceFolder: string,
     accessToken?: string,
-    limit?: number,
-    returnDetails = false
+    limit?: number
   ) {
     this.isMethodSupported('listFolder', [ServerType.SasViya])
 
     return await this.sasViyaApiClient?.listFolder(
       sourceFolder,
       accessToken,
-      limit,
-      {
-        returnDetails
-      }
+      limit
     )
   }
 
@@ -926,7 +854,6 @@ export default class SASjs {
    * @param pollOptions - an object that represents poll interval(milliseconds) and maximum amount of attempts. Object example: { maxPollCount: 24 * 60 * 60, pollInterval: 1000 }. More information available at src/api/viya/pollJobState.ts.
    * @param printPid - a boolean that indicates whether the function should print (PID) of the started job.
    * @param variables - an object that represents macro variables.
-   * @param verboseMode - boolean or a string equal to 'bleached' to enable verbose mode (log every HTTP response).
    */
   public async startComputeJob(
     sasJob: string,
@@ -936,8 +863,7 @@ export default class SASjs {
     waitForResult?: boolean,
     pollOptions?: PollOptions,
     printPid = false,
-    variables?: MacroVar,
-    verboseMode?: VerboseMode
+    variables?: MacroVar
   ) {
     config = {
       ...this.sasjsConfig,
@@ -951,11 +877,6 @@ export default class SASjs {
       )
     }
 
-    if (verboseMode) {
-      this.requestClient?.setVerboseMode(verboseMode)
-      this.requestClient?.enableVerboseMode()
-    } else if (verboseMode === false) this.requestClient?.disableVerboseMode()
-
     return this.sasViyaApiClient?.executeComputeJob(
       sasJob,
       config.contextName,
@@ -1049,8 +970,7 @@ export default class SASjs {
       this.requestClient = new RequestClientClass(
         this.sasjsConfig.serverUrl,
         this.sasjsConfig.httpsAgentOptions,
-        this.sasjsConfig.requestHistoryLimit,
-        this.sasjsConfig.verbose
+        this.sasjsConfig.requestHistoryLimit
       )
     } else {
       this.requestClient.setConfig(
@@ -1214,42 +1134,4 @@ export default class SASjs {
       )
     }
   }
-
-  /**
-   * Enables verbose mode that will log a summary of every HTTP response.
-   * @param successCallBack - function that should be triggered on every HTTP response with the status 2**.
-   * @param errorCallBack - function that should be triggered on every HTTP response with the status different from 2**.
-   */
-  public enableVerboseMode(
-    successCallBack?: (response: AxiosResponse) => AxiosResponse,
-    errorCallBack?: (response: AxiosError) => AxiosError
-  ) {
-    this.requestClient?.enableVerboseMode(successCallBack, errorCallBack)
-  }
-
-  /**
-   * Turns off verbose mode to log every HTTP response.
-   */
-  public disableVerboseMode() {
-    this.requestClient?.disableVerboseMode()
-  }
-
-  /**
-   * Sets verbose mode.
-   * @param verboseMode - value of the verbose mode, can be true, false or bleached(without extra colors).
-   */
-  public setVerboseMode = (verboseMode: VerboseMode) => {
-    this.requestClient?.setVerboseMode(verboseMode)
-  }
-
-  /**
-   * Create a tables class containing one or more tables to be sent to
-   * SAS.
-   * @param table - initial table data
-   * @param macroName - macro name
-   * @returns Tables class
-   */
-  Tables(table: Record<string, any>, macroName: string) {
-    return new Tables(table, macroName)
-  }
 }

src/SASjsApiClient.ts

@@ -1,4 +1,4 @@
-import NodeFormData from 'form-data'
+import * as NodeFormData from 'form-data'
 import { AuthConfig, ServerType, ServicePackSASjs } from '@sasjs/utils/types'
 import { prefixMessage } from '@sasjs/utils/error'
 import { ExecutionQuery } from './types'

src/SessionManager.ts

@@ -1,4 +1,4 @@
-import { Session, Context, SessionVariable, SessionState } from './types'
+import { Session, Context, SessionVariable } from './types'
 import { NoSessionStateError } from './types/errors'
 import { asyncForEach, isUrl } from './utils'
 import { prefixMessage } from '@sasjs/utils/error'
@@ -12,7 +12,6 @@ interface ApiErrorResponse {
 
 export class SessionManager {
   private loggedErrors: NoSessionStateError[] = []
-  private sessionStateLinkError = 'Error while getting session state link. '
 
   constructor(
     private serverUrl: string,
@@ -29,7 +28,7 @@ export class SessionManager {
   private _debug: boolean = false
   private printedSessionState = {
     printed: false,
-    state: SessionState.NoState
+    state: ''
   }
 
   public get debug() {
@@ -266,18 +265,6 @@ export class SessionManager {
         )
       })
 
-    // Add response etag to Session object.
-    createdSession.etag = etag
-
-    // Get session state link.
-    const stateLink = createdSession.links.find((link) => link.rel === 'state')
-
-    // Throw error if session state link is not present.
-    if (!stateLink) throw this.sessionStateLinkError
-
-    // Add session state link to Session object.
-    createdSession.stateUrl = stateLink.href
-
     await this.waitForSession(createdSession, etag, accessToken)
 
     this.sessions.push(createdSession)
@@ -340,30 +327,32 @@ export class SessionManager {
     etag: string | null,
     accessToken?: string
   ): Promise<string> {
-    let { state: sessionState } = session
-    const { stateUrl } = session
     const logger = process.logger || console
 
+    let sessionState = session.state
+
+    const stateLink = session.links.find((l: any) => l.rel === 'state')
+
     if (
-      sessionState === SessionState.Pending ||
-      sessionState === SessionState.Running ||
-      sessionState === SessionState.NoState
+      sessionState === 'pending' ||
+      sessionState === 'running' ||
+      sessionState === ''
     ) {
-      if (stateUrl) {
+      if (stateLink) {
         if (this.debug && !this.printedSessionState.printed) {
-          logger.info(`Polling: ${this.serverUrl + stateUrl}`)
+          logger.info(`Polling: ${this.serverUrl + stateLink.href}`)
 
           this.printedSessionState.printed = true
         }
 
-        const url = `${this.serverUrl}${stateUrl}?wait=30`
+        const url = `${this.serverUrl}${stateLink.href}?wait=30`
 
         const { result: state, responseStatus: responseStatus } =
           await this.getSessionState(url, etag!, accessToken).catch((err) => {
             throw prefixMessage(err, 'Error while waiting for session. ')
           })
 
-        sessionState = state.trim() as SessionState
+        sessionState = state.trim()
 
         if (this.debug && this.printedSessionState.state !== sessionState) {
           logger.info(`Current session state is '${sessionState}'`)
@@ -375,7 +364,7 @@ export class SessionManager {
         if (!sessionState) {
           const stateError = new NoSessionStateError(
             responseStatus,
-            this.serverUrl + stateUrl,
+            this.serverUrl + stateLink.href,
             session.links.find((l: any) => l.rel === 'log')?.href as string
           )
 
@@ -397,7 +386,7 @@ export class SessionManager {
 
         return sessionState
       } else {
-        throw this.sessionStateLinkError
+        throw 'Error while getting session state link. '
       }
     } else {
       this.loggedErrors = []
@@ -424,7 +413,7 @@ export class SessionManager {
     return await this.requestClient
       .get(url, accessToken, 'text/plain', { 'If-None-Match': etag })
       .then((res) => ({
-        result: res.result as SessionState,
+        result: res.result as string,
         responseStatus: res.status
       }))
       .catch((err) => {

src/api/viya/executeScript.ts

@@ -15,12 +15,8 @@ import { formatDataForRequest } from '../../utils/formatDataForRequest'
 import { pollJobState, JobState } from './pollJobState'
 import { uploadTables } from './uploadTables'
 
-interface JobRequestBody {
-  [key: string]: number | string | string[]
-}
-
 /**
- * Executes SAS program on the current SAS Viya server using Compute API.
+ * Executes code on the current SAS Viya server.
  * @param jobPath - the path to the file being submitted for execution.
  * @param linesOfCode - an array of code lines to execute.
  * @param contextName - the context to execute the code in.
@@ -33,7 +29,7 @@ interface JobRequestBody {
  * @param printPid - a boolean that indicates whether the function should print (PID) of the started job.
  * @param variables - an object that represents macro variables.
  */
-export async function executeOnComputeApi(
+export async function executeScript(
   requestClient: RequestClient,
   sessionManager: SessionManager,
   rootFolderName: string,
@@ -50,7 +46,6 @@ export async function executeOnComputeApi(
   variables?: MacroVar
 ): Promise<any> {
   let access_token = (authConfig || {}).access_token
-
   if (authConfig) {
     ;({ access_token } = await getTokens(requestClient, authConfig))
   }
@@ -83,13 +78,27 @@ export async function executeOnComputeApi(
         const logger = process.logger || console
 
         logger.info(
-          `Triggering '${relativeJobPath}' with PID ${
+          `Triggered '${relativeJobPath}' with PID ${
             jobIdVariable.value
           } at ${timestampToYYYYMMDDHHMMSS()}`
         )
       }
     }
 
+    const jobArguments: { [key: string]: any } = {
+      _contextName: contextName,
+      _OMITJSONLISTING: true,
+      _OMITJSONLOG: true,
+      _OMITSESSIONRESULTS: true,
+      _OMITTEXTLISTING: true,
+      _OMITTEXTLOG: true
+    }
+
+    if (debug) {
+      jobArguments['_OMITTEXTLOG'] = false
+      jobArguments['_OMITSESSIONRESULTS'] = false
+    }
+
     let fileName
 
     if (isRelativePath(jobPath)) {
@@ -98,7 +107,6 @@ export async function executeOnComputeApi(
       }`
     } else {
       const jobPathParts = jobPath.split('/')
-
       fileName = jobPathParts.pop()
     }
 
@@ -110,6 +118,7 @@ export async function executeOnComputeApi(
     }
 
     if (variables) jobVariables = { ...jobVariables, ...variables }
+
     if (debug) jobVariables = { ...jobVariables, _DEBUG: 131 }
 
     let files: any[] = []
@@ -136,12 +145,12 @@ export async function executeOnComputeApi(
     }
 
     // Execute job in session
-    const jobRequestBody: JobRequestBody = {
-      name: fileName || 'Default Job Name',
+    const jobRequestBody = {
+      name: fileName,
       description: 'Powered by SASjs',
       code: linesOfCode,
       variables: jobVariables,
-      version: 2
+      arguments: jobArguments
     }
 
     const { result: postedJob, etag } = await requestClient
@@ -170,21 +179,16 @@ export async function executeOnComputeApi(
       postedJob,
       debug,
       authConfig,
-      pollOptions,
-      {
-        session,
-        sessionManager
-      }
+      pollOptions
     ).catch(async (err) => {
       const error = err?.response?.data
       const result = /err=[0-9]*,/.exec(error)
-      const errorCode = '5113'
 
+      const errorCode = '5113'
       if (result?.[0]?.slice(4, -1) === errorCode) {
-        const logCount = 1000000
         const sessionLogUrl =
           postedJob.links.find((l: any) => l.rel === 'up')!.href + '/log'
-
+        const logCount = 1000000
         err.log = await fetchLogByChunks(
           requestClient,
           access_token!,
@@ -192,7 +196,6 @@ export async function executeOnComputeApi(
           logCount
         )
       }
-
       throw prefixMessage(err, 'Error while polling job status. ')
     })
 
@@ -211,12 +214,12 @@ export async function executeOnComputeApi(
 
     let jobResult
     let log = ''
+
     const logLink = currentJob.links.find((l) => l.rel === 'log')
 
     if (debug && logLink) {
       const logUrl = `${logLink.href}/content`
       const logCount = currentJob.logStatistics?.lineCount ?? 1000000
-
       log = await fetchLogByChunks(
         requestClient,
         access_token!,
@@ -229,7 +232,9 @@ export async function executeOnComputeApi(
       throw new ComputeJobExecutionError(currentJob, log)
     }
 
-    if (!expectWebout) return { job: currentJob, log }
+    if (!expectWebout) {
+      return { job: currentJob, log }
+    }
 
     const resultLink = `/compute/sessions/${executionSessionId}/filerefs/_webout/content`
 
@@ -240,7 +245,6 @@ export async function executeOnComputeApi(
           if (logLink) {
             const logUrl = `${logLink.href}/content`
             const logCount = currentJob.logStatistics?.lineCount ?? 1000000
-
             log = await fetchLogByChunks(
               requestClient,
               access_token!,
@@ -275,7 +279,7 @@ export async function executeOnComputeApi(
     const error = e as HttpError
 
     if (error.status === 404) {
-      return executeOnComputeApi(
+      return executeScript(
         requestClient,
         sessionManager,
         rootFolderName,

src/api/viya/pollJobState.ts

@@ -3,7 +3,7 @@ import { Job, PollOptions, PollStrategy } from '../..'
 import { getTokens } from '../../auth/getTokens'
 import { RequestClient } from '../../request/RequestClient'
 import { JobStatePollError } from '../../types/errors'
-import { Link, WriteStream, SessionState, JobSessionManager } from '../../types'
+import { Link, WriteStream } from '../../types'
 import { delay, isNode } from '../../utils'
 
 export enum JobState {
@@ -37,7 +37,6 @@ export enum JobState {
  *    { maxPollCount: 500, pollInterval: 30000 }, // approximately ~50.5 mins (including time to get response (~300ms))
  *    { maxPollCount: 3400, pollInterval: 60000 } // approximately ~3015 mins (~125 hours) (including time to get response (~300ms))
  * ]
- * @param jobSessionManager - job session object containing session object and an instance of Session Manager. Job session object is used to periodically (every 10th job state poll) check parent session state.
  * @returns - a promise which resolves with a job state
  */
 export async function pollJobState(
@@ -45,8 +44,7 @@ export async function pollJobState(
   postedJob: Job,
   debug: boolean,
   authConfig?: AuthConfig,
-  pollOptions?: PollOptions,
-  jobSessionManager?: JobSessionManager
+  pollOptions?: PollOptions
 ): Promise<JobState> {
   const logger = process.logger || console
 
@@ -129,8 +127,7 @@ export async function pollJobState(
     pollOptions,
     authConfig,
     streamLog,
-    logFileStream,
-    jobSessionManager
+    logFileStream
   )
 
   currentState = result.state
@@ -161,8 +158,7 @@ export async function pollJobState(
       defaultPollOptions,
       authConfig,
       streamLog,
-      logFileStream,
-      jobSessionManager
+      logFileStream
     )
 
     currentState = result.state
@@ -212,21 +208,7 @@ const needsRetry = (state: string) =>
   state === JobState.Pending ||
   state === JobState.Unavailable
 
-/**
- * Polls job state.
- * @param requestClient - the pre-configured HTTP request client.
- * @param postedJob - the relative or absolute path to the job.
- * @param currentState - current job state.
- * @param debug - sets the _debug flag in the job arguments.
- * @param pollCount - current poll count.
- * @param pollOptions - an object containing maxPollCount, pollInterval, streamLog and logFolderPath.
- * @param authConfig - an access token, refresh token, client and secret for an authorized user.
- * @param streamLog - indicates if job log should be streamed.
- * @param logStream - job log stream.
- * @param jobSessionManager - job session object containing session object and an instance of Session Manager. Job session object is used to periodically (every 10th job state poll) check parent session state. Session state is considered healthy if it is equal to 'running' or 'idle'.
- * @returns - a promise which resolves with a job state
- */
-export const doPoll = async (
+const doPoll = async (
   requestClient: RequestClient,
   postedJob: Job,
   currentState: JobState,
@@ -235,8 +217,7 @@ export const doPoll = async (
   pollOptions: PollOptions,
   authConfig?: AuthConfig,
   streamLog?: boolean,
-  logStream?: WriteStream,
-  jobSessionManager?: JobSessionManager
+  logStream?: WriteStream
 ): Promise<{ state: JobState; pollCount: number }> => {
   const { maxPollCount, pollInterval } = pollOptions
   const logger = process.logger || console
@@ -248,40 +229,6 @@ export const doPoll = async (
   let startLogLine = 0
 
   while (needsRetry(state) && pollCount <= maxPollCount) {
-    // Check parent session state on every 10th job state poll.
-    if (jobSessionManager && pollCount && pollCount % 10 === 0 && authConfig) {
-      const { session, sessionManager } = jobSessionManager
-      const { stateUrl, etag, id: sessionId } = session
-      const { access_token } = authConfig
-      const { id: jobId } = postedJob
-
-      // Get session state.
-      const { result: sessionState, responseStatus } = await sessionManager[
-        'getSessionState'
-      ](stateUrl, etag, access_token).catch((err) => {
-        // Handle error while getting session state.
-        throw new JobStatePollError(jobId, err)
-      })
-
-      // Checks if session state is equal to 'running' or 'idle'.
-      const isSessionStatesHealthy = (state: string) =>
-        [SessionState.Running, SessionState.Idle].includes(
-          state as SessionState
-        )
-
-      // Clear parent session and throw an error if session state is not
-      // 'running', 'idle' or response status is not 200.
-      if (!isSessionStatesHealthy(sessionState) || responseStatus !== 200) {
-        sessionManager.clearSession(sessionId, access_token)
-
-        const sessionError = isSessionStatesHealthy(sessionState)
-          ? `Session response status is not 200. Session response status is ${responseStatus}.`
-          : `Session state of the job is not 'running' or 'idle'. Session state is '${sessionState}'`
-
-        throw new JobStatePollError(jobId, new Error(sessionError))
-      }
-    }
-
     state = await getJobState(
       requestClient,
       postedJob,

src/api/viya/spec/executeScript.spec.ts

@@ -1,13 +1,13 @@
 import { RequestClient } from '../../../request/RequestClient'
 import { SessionManager } from '../../../SessionManager'
-import { executeOnComputeApi } from '../executeOnComputeApi'
+import { executeScript } from '../executeScript'
 import { mockSession, mockAuthConfig, mockJob } from './mockResponses'
 import * as pollJobStateModule from '../pollJobState'
 import * as uploadTablesModule from '../uploadTables'
 import * as getTokensModule from '../../../auth/getTokens'
 import * as formatDataModule from '../../../utils/formatDataForRequest'
 import * as fetchLogsModule from '../../../utils/fetchLogByChunks'
-import { PollOptions, JobSessionManager } from '../../../types'
+import { PollOptions } from '../../../types'
 import { ComputeJobExecutionError, NotFoundError } from '../../../types/errors'
 import { Logger, LogLevel } from '@sasjs/utils/logger'
 
@@ -25,7 +25,7 @@ describe('executeScript', () => {
   })
 
   it('should not try to get fresh tokens if an authConfig is not provided', async () => {
-    await executeOnComputeApi(
+    await executeScript(
       requestClient,
       sessionManager,
       'test',
@@ -38,7 +38,7 @@ describe('executeScript', () => {
   })
 
   it('should try to get fresh tokens if an authConfig is provided', async () => {
-    await executeOnComputeApi(
+    await executeScript(
       requestClient,
       sessionManager,
       'test',
@@ -55,7 +55,7 @@ describe('executeScript', () => {
   })
 
   it('should get a session from the session manager before executing', async () => {
-    await executeOnComputeApi(
+    await executeScript(
       requestClient,
       sessionManager,
       'test',
@@ -72,7 +72,7 @@ describe('executeScript', () => {
       .spyOn(sessionManager, 'getSession')
       .mockImplementation(() => Promise.reject('Test Error'))
 
-    const error = await executeOnComputeApi(
+    const error = await executeScript(
       requestClient,
       sessionManager,
       'test',
@@ -85,7 +85,7 @@ describe('executeScript', () => {
   })
 
   it('should fetch the PID when printPid is true', async () => {
-    await executeOnComputeApi(
+    await executeScript(
       requestClient,
       sessionManager,
       'test',
@@ -113,7 +113,7 @@ describe('executeScript', () => {
       .spyOn(sessionManager, 'getVariable')
       .mockImplementation(() => Promise.reject('Test Error'))
 
-    const error = await executeOnComputeApi(
+    const error = await executeScript(
       requestClient,
       sessionManager,
       'test',
@@ -139,7 +139,7 @@ describe('executeScript', () => {
         Promise.resolve([{ tableName: 'test', file: { id: 1 } }])
       )
 
-    await executeOnComputeApi(
+    await executeScript(
       requestClient,
       sessionManager,
       'test',
@@ -163,7 +163,7 @@ describe('executeScript', () => {
   })
 
   it('should format data as CSV when it does not contain semicolons', async () => {
-    await executeOnComputeApi(
+    await executeScript(
       requestClient,
       sessionManager,
       'test',
@@ -189,7 +189,7 @@ describe('executeScript', () => {
       .spyOn(formatDataModule, 'formatDataForRequest')
       .mockImplementation(() => ({ sasjs_tables: 'foo', sasjs0data: 'bar' }))
 
-    await executeOnComputeApi(
+    await executeScript(
       requestClient,
       sessionManager,
       'test',
@@ -217,7 +217,14 @@ describe('executeScript', () => {
           sasjs_tables: 'foo',
           sasjs0data: 'bar'
         },
-        version: 2
+        arguments: {
+          _contextName: 'test context',
+          _OMITJSONLISTING: true,
+          _OMITJSONLOG: true,
+          _OMITSESSIONRESULTS: true,
+          _OMITTEXTLISTING: true,
+          _OMITTEXTLOG: true
+        }
       },
       mockAuthConfig.access_token
     )
@@ -228,7 +235,7 @@ describe('executeScript', () => {
       .spyOn(formatDataModule, 'formatDataForRequest')
       .mockImplementation(() => ({ sasjs_tables: 'foo', sasjs0data: 'bar' }))
 
-    await executeOnComputeApi(
+    await executeScript(
       requestClient,
       sessionManager,
       'test',
@@ -257,7 +264,14 @@ describe('executeScript', () => {
           sasjs0data: 'bar',
           _DEBUG: 131
         },
-        version: 2
+        arguments: {
+          _contextName: 'test context',
+          _OMITJSONLISTING: true,
+          _OMITJSONLOG: true,
+          _OMITSESSIONRESULTS: false,
+          _OMITTEXTLISTING: true,
+          _OMITTEXTLOG: false
+        }
       },
       mockAuthConfig.access_token
     )
@@ -268,7 +282,7 @@ describe('executeScript', () => {
       .spyOn(requestClient, 'post')
       .mockImplementation(() => Promise.reject('Test Error'))
 
-    const error = await executeOnComputeApi(
+    const error = await executeScript(
       requestClient,
       sessionManager,
       'test',
@@ -288,7 +302,7 @@ describe('executeScript', () => {
   })
 
   it('should immediately return the session when waitForResult is false', async () => {
-    const result = await executeOnComputeApi(
+    const result = await executeScript(
       requestClient,
       sessionManager,
       'test',
@@ -308,12 +322,7 @@ describe('executeScript', () => {
   })
 
   it('should poll for job completion when waitForResult is true', async () => {
-    const jobSessionManager: JobSessionManager = {
-      session: mockSession,
-      sessionManager: sessionManager
-    }
-
-    await executeOnComputeApi(
+    await executeScript(
       requestClient,
       sessionManager,
       'test',
@@ -334,8 +343,7 @@ describe('executeScript', () => {
       mockJob,
       false,
       mockAuthConfig,
-      defaultPollOptions,
-      jobSessionManager
+      defaultPollOptions
     )
   })
 
@@ -344,7 +352,7 @@ describe('executeScript', () => {
       .spyOn(pollJobStateModule, 'pollJobState')
       .mockImplementation(() => Promise.reject('Poll Error'))
 
-    const error = await executeOnComputeApi(
+    const error = await executeScript(
       requestClient,
       sessionManager,
       'test',
@@ -370,7 +378,7 @@ describe('executeScript', () => {
         Promise.reject({ response: { data: 'err=5113,' } })
       )
 
-    const error = await executeOnComputeApi(
+    const error = await executeScript(
       requestClient,
       sessionManager,
       'test',
@@ -396,7 +404,7 @@ describe('executeScript', () => {
   })
 
   it('should fetch the logs for the job if debug is true and a log URL is available', async () => {
-    await executeOnComputeApi(
+    await executeScript(
       requestClient,
       sessionManager,
       'test',
@@ -421,7 +429,7 @@ describe('executeScript', () => {
   })
 
   it('should not fetch the logs for the job if debug is false', async () => {
-    await executeOnComputeApi(
+    await executeScript(
       requestClient,
       sessionManager,
       'test',
@@ -447,7 +455,7 @@ describe('executeScript', () => {
         Promise.resolve(pollJobStateModule.JobState.Failed)
       )
 
-    const error: ComputeJobExecutionError = await executeOnComputeApi(
+    const error: ComputeJobExecutionError = await executeScript(
       requestClient,
       sessionManager,
       'test',
@@ -482,7 +490,7 @@ describe('executeScript', () => {
         Promise.resolve(pollJobStateModule.JobState.Error)
       )
 
-    const error: ComputeJobExecutionError = await executeOnComputeApi(
+    const error: ComputeJobExecutionError = await executeScript(
       requestClient,
       sessionManager,
       'test',
@@ -511,7 +519,7 @@ describe('executeScript', () => {
   })
 
   it('should fetch the result if expectWebout is true', async () => {
-    await executeOnComputeApi(
+    await executeScript(
       requestClient,
       sessionManager,
       'test',
@@ -542,7 +550,7 @@ describe('executeScript', () => {
       return Promise.resolve({ result: mockJob, etag: '', status: 200 })
     })
 
-    const error = await executeOnComputeApi(
+    const error = await executeScript(
       requestClient,
       sessionManager,
       'test',
@@ -576,7 +584,7 @@ describe('executeScript', () => {
   })
 
   it('should clear the session after execution is complete', async () => {
-    await executeOnComputeApi(
+    await executeScript(
       requestClient,
       sessionManager,
       'test',
@@ -603,7 +611,7 @@ describe('executeScript', () => {
       .spyOn(sessionManager, 'clearSession')
       .mockImplementation(() => Promise.reject('Clear Session Error'))
 
-    const error = await executeOnComputeApi(
+    const error = await executeScript(
       requestClient,
       sessionManager,
       'test',

src/api/viya/spec/mockResponses.ts

@@ -1,16 +1,14 @@
 import { AuthConfig } from '@sasjs/utils/types'
-import { Job, Session, SessionState } from '../../../types'
+import { Job, Session } from '../../../types'
 
 export const mockSession: Session = {
   id: 's35510n',
-  state: SessionState.Idle,
-  stateUrl: '',
+  state: 'idle',
   links: [],
   attributes: {
     sessionInactiveTimeout: 1
   },
-  creationTimeStamp: new Date().valueOf().toString(),
-  etag: 'etag-string'
+  creationTimeStamp: new Date().valueOf().toString()
 }
 
 export const mockJob: Job = {

src/api/viya/spec/pollJobState.spec.ts

@@ -1,25 +1,17 @@
 import { Logger, LogLevel } from '@sasjs/utils/logger'
 import { RequestClient } from '../../../request/RequestClient'
 import { mockAuthConfig, mockJob } from './mockResponses'
-import { pollJobState, doPoll, JobState } from '../pollJobState'
+import { pollJobState } from '../pollJobState'
 import * as getTokensModule from '../../../auth/getTokens'
 import * as saveLogModule from '../saveLog'
 import * as getFileStreamModule from '../getFileStream'
 import * as isNodeModule from '../../../utils/isNode'
 import * as delayModule from '../../../utils/delay'
-import {
-  PollOptions,
-  PollStrategy,
-  SessionState,
-  JobSessionManager
-} from '../../../types'
+import { PollOptions, PollStrategy } from '../../../types'
 import { WriteStream } from 'fs'
-import { SessionManager } from '../../../SessionManager'
-import { JobStatePollError } from '../../../types'
 
 const baseUrl = 'http://localhost'
 const requestClient = new (<jest.Mock<RequestClient>>RequestClient)()
-const sessionManager = new (<jest.Mock<SessionManager>>SessionManager)()
 requestClient['httpClient'].defaults.baseURL = baseUrl
 
 const defaultStreamLog = false
@@ -284,76 +276,6 @@ describe('pollJobState', () => {
     expect(delays).toEqual([pollIntervals[0], ...pollIntervals])
   })
 
-  it('should change default poll strategies after completing provided poll options', async () => {
-    const delays: number[] = []
-
-    jest.spyOn(delayModule, 'delay').mockImplementation((ms: number) => {
-      delays.push(ms)
-
-      return Promise.resolve()
-    })
-
-    const customPollOptions: PollOptions = {
-      maxPollCount: 0,
-      pollInterval: 0
-    }
-
-    const requests = [
-      { maxPollCount: 202, pollInterval: 300 },
-      { maxPollCount: 300, pollInterval: 3000 },
-      { maxPollCount: 500, pollInterval: 30000 },
-      { maxPollCount: 3400, pollInterval: 60000 }
-    ]
-
-    // ~200 requests with delay 300ms
-    let request = requests.splice(0, 1)[0]
-    let { maxPollCount, pollInterval } = request
-
-    // should be only one interval because maxPollCount is equal to 0
-    const pollIntervals = [customPollOptions.pollInterval]
-
-    pollIntervals.push(...Array(maxPollCount - 2).fill(pollInterval))
-
-    // ~300 requests with delay 3000
-    request = requests.splice(0, 1)[0]
-    let newAmount = request.maxPollCount
-    pollInterval = request.pollInterval
-
-    pollIntervals.push(...Array(newAmount - maxPollCount).fill(pollInterval))
-    pollIntervals.push(...Array(2).fill(pollInterval))
-
-    // ~500 requests with delay 30000
-    request = requests.splice(0, 1)[0]
-
-    let oldAmount = newAmount
-    newAmount = request.maxPollCount
-    pollInterval = request.pollInterval
-
-    pollIntervals.push(...Array(newAmount - oldAmount - 2).fill(pollInterval))
-    pollIntervals.push(...Array(2).fill(pollInterval))
-
-    // ~3400 requests with delay 60000
-    request = requests.splice(0, 1)[0]
-
-    oldAmount = newAmount
-    newAmount = request.maxPollCount
-    pollInterval = request.pollInterval
-
-    mockSimplePoll(newAmount)
-
-    pollIntervals.push(...Array(newAmount - oldAmount - 2).fill(pollInterval))
-
-    await pollJobState(
-      requestClient,
-      mockJob,
-      false,
-      undefined,
-      customPollOptions
-    )
-
-    expect(delays).toEqual(pollIntervals)
-  })
-
   it('should throw an error if not valid poll strategies provided', async () => {
     // INFO: 'maxPollCount' has to be > 0
     let invalidPollStrategy = {
@@ -431,218 +353,6 @@ describe('pollJobState', () => {
   })
 })
 
-describe('doPoll', () => {
-  const sessionStateLink = '/compute/sessions/session-id-ses0000/state'
-  const jobSessionManager: JobSessionManager = {
-    sessionManager,
-    session: {
-      id: ['id', new Date().getTime(), Math.random()].join('-'),
-      state: SessionState.NoState,
-      links: [
-        {
-          href: sessionStateLink,
-          method: 'GET',
-          rel: 'state',
-          type: 'text/plain',
-          uri: sessionStateLink
-        }
-      ],
-      attributes: {
-        sessionInactiveTimeout: 900
-      },
-      creationTimeStamp: `${new Date(new Date().getTime()).toISOString()}`,
-      stateUrl: '',
-      etag: ''
-    }
-  }
-
-  beforeEach(() => {
-    setupMocks()
-  })
-
-  it('should check session state on every 10th job state poll', async () => {
-    const mockedGetSessionState = jest
-      .spyOn(sessionManager as any, 'getSessionState')
-      .mockImplementation(() => {
-        return Promise.resolve({
-          result: SessionState.Idle,
-          responseStatus: 200
-        })
-      })
-
-    let getSessionStateCount = 0
-    jest.spyOn(requestClient, 'get').mockImplementation(() => {
-      getSessionStateCount++
-
-      return Promise.resolve({
-        result:
-          getSessionStateCount < 20 ? JobState.Running : JobState.Completed,
-        etag: 'etag-string',
-        status: 200
-      })
-    })
-
-    await doPoll(
-      requestClient,
-      mockJob,
-      JobState.Running,
-      false,
-      1,
-      defaultPollStrategy,
-      mockAuthConfig,
-      undefined,
-      undefined,
-      jobSessionManager
-    )
-
-    expect(mockedGetSessionState).toHaveBeenCalledTimes(2)
-  })
-
-  it('should handle error while checking session state', async () => {
-    const sessionStateError = 'Error while getting session state.'
-
-    jest
-      .spyOn(sessionManager as any, 'getSessionState')
-      .mockImplementation(() => {
-        return Promise.reject(sessionStateError)
-      })
-
-    jest.spyOn(requestClient, 'get').mockImplementation(() => {
-      return Promise.resolve({
-        result: JobState.Running,
-        etag: 'etag-string',
-        status: 200
-      })
-    })
-
-    await expect(
-      doPoll(
-        requestClient,
-        mockJob,
-        JobState.Running,
-        false,
-        1,
-        defaultPollStrategy,
-        mockAuthConfig,
-        undefined,
-        undefined,
-        jobSessionManager
-      )
-    ).rejects.toEqual(
-      new JobStatePollError(mockJob.id, new Error(sessionStateError))
-    )
-  })
-
-  it('should throw an error if session state is not healthy', async () => {
-    const filteredSessionStates = Object.values(SessionState).filter(
-      (state) => state !== SessionState.Running && state !== SessionState.Idle
-    )
-    const randomSessionState =
-      filteredSessionStates[
-        Math.floor(Math.random() * filteredSessionStates.length)
-      ]
-
-    jest
-      .spyOn(sessionManager as any, 'getSessionState')
-      .mockImplementation(() => {
-        return Promise.resolve({
-          result: randomSessionState,
-          responseStatus: 200
-        })
-      })
-
-    jest.spyOn(requestClient, 'get').mockImplementation(() => {
-      return Promise.resolve({
-        result: JobState.Running,
-        etag: 'etag-string',
-        status: 200
-      })
-    })
-
-    const mockedClearSession = jest
-      .spyOn(sessionManager, 'clearSession')
-      .mockImplementation(() => Promise.resolve())
-
-    await expect(
-      doPoll(
-        requestClient,
-        mockJob,
-        JobState.Running,
-        false,
-        1,
-        defaultPollStrategy,
-        mockAuthConfig,
-        undefined,
-        undefined,
-        jobSessionManager
-      )
-    ).rejects.toEqual(
-      new JobStatePollError(
-        mockJob.id,
-        new Error(
-          `Session state of the job is not 'running' or 'idle'. Session state is '${randomSessionState}'`
-        )
-      )
-    )
-
-    expect(mockedClearSession).toHaveBeenCalledWith(
-      jobSessionManager.session.id,
-      mockAuthConfig.access_token
-    )
-  })
-
-  it('should handle throw an error if response status of session state is not 200', async () => {
-    const sessionStateResponseStatus = 500
-    jest
-      .spyOn(sessionManager as any, 'getSessionState')
-      .mockImplementation(() => {
-        return Promise.resolve({
-          result: SessionState.Running,
-          responseStatus: sessionStateResponseStatus
-        })
-      })
-
-    jest.spyOn(requestClient, 'get').mockImplementation(() => {
-      return Promise.resolve({
-        result: JobState.Running,
-        etag: 'etag-string',
-        status: 200
-      })
-    })
-
-    const mockedClearSession = jest
-      .spyOn(sessionManager, 'clearSession')
-      .mockImplementation(() => Promise.resolve())
-
-    await expect(
-      doPoll(
-        requestClient,
-        mockJob,
-        JobState.Running,
-        false,
-        1,
-        defaultPollStrategy,
-        mockAuthConfig,
-        undefined,
-        undefined,
-        jobSessionManager
-      )
-    ).rejects.toEqual(
-      new JobStatePollError(
-        mockJob.id,
-        new Error(
-          `Session response status is not 200. Session response status is ${sessionStateResponseStatus}.`
-        )
-      )
-    )
-
-    expect(mockedClearSession).toHaveBeenCalledWith(
-      jobSessionManager.session.id,
-      mockAuthConfig.access_token
-    )
-  })
-})
-
 const setupMocks = () => {
   jest.restoreAllMocks()
   jest.mock('../../../request/RequestClient')

src/api/viya/spec/saveLog.spec.ts

@@ -69,5 +69,5 @@ const setupMocks = () => {
     .mockImplementation(() => Promise.resolve('Test Log'))
   jest
     .spyOn(writeStreamModule, 'writeStream')
-    .mockImplementation(() => Promise.resolve(true))
+    .mockImplementation(() => Promise.resolve())
 }

src/api/viya/spec/writeStream.spec.ts

@@ -10,22 +10,12 @@ import {
 describe('writeStream', () => {
   const filename = 'test.txt'
   const content = 'test'
-
   let stream: WriteStream
 
   beforeAll(async () => {
     stream = await createWriteStream(filename)
   })
 
-  beforeEach(async () => {
-    await deleteFile(filename).catch(() => {}) // Ignore errors if the file doesn't exist
-    stream = await createWriteStream(filename)
-  })
-
-  afterEach(async () => {
-    await deleteFile(filename).catch(() => {}) // Ensure cleanup after test
-  })
-
   it('should resolve when the stream is written successfully', async () => {
     await expect(writeStream(stream, content)).toResolve()
     await expect(fileExists(filename)).resolves.toEqual(true)
@@ -35,30 +25,11 @@ describe('writeStream', () => {
   })
 
   it('should reject when the write errors out', async () => {
-    // Mock implementation of the write method
     jest
       .spyOn(stream, 'write')
-      .mockImplementation(
-        (
-          chunk: any,
-          encodingOrCb?:
-            | BufferEncoding
-            | ((error: Error | null | undefined) => void),
-          cb?: (error: Error | null | undefined) => void
-        ) => {
-          const callback =
-            typeof encodingOrCb === 'function' ? encodingOrCb : cb
-          if (callback) {
-            callback(new Error('Test Error')) // Simulate an error
-          }
-          return true // Simulate that the write operation was called
-        }
-      )
-
-    // Call the writeStream function and catch the error
+      .mockImplementation((_, callback) => callback(new Error('Test Error')))
     const error = await writeStream(stream, content).catch((e: any) => e)
 
-    // Assert that the error is correctly handled
     expect(error.message).toEqual('Test Error')
   })
 })

src/api/viya/writeStream.ts

@@ -3,14 +3,9 @@ import { WriteStream } from '../../types'
 export const writeStream = async (
   stream: WriteStream,
   content: string
-): Promise<boolean> => {
-  return new Promise((resolve, reject) => {
-    stream.write(content + '\n', (err: Error | null | undefined) => {
-      if (err) {
-        reject(err) // Reject on write error
-      } else {
-        resolve(true) // Resolve on successful write
-      }
-    })
+): Promise<void> =>
+  stream.write(content + '\n', (e: any) => {
+    if (e) return Promise.reject(e)
+
+    return Promise.resolve()
   })
-}

src/auth/AuthManager.ts

@@ -7,7 +7,6 @@ import { extractUserLongNameSas9 } from '../utils/sas9/extractUserLongNameSas9'
 import { openWebPage } from './openWebPage'
 import { verifySas9Login } from './verifySas9Login'
 import { verifySasViyaLogin } from './verifySasViyaLogin'
-import { isLogInSuccessHeaderPresent } from './'
 
 export class AuthManager {
   public userName = ''
@@ -15,7 +14,6 @@ export class AuthManager {
   private loginUrl: string
   private logoutUrl: string
   private redirectedLoginUrl = `/SASLogon` //SAS 9 M8 no longer redirects from `/SASLogon/home` to the login page. `/SASLogon` seems to be stable enough across SAS versions
-
   constructor(
     private serverUrl: string,
     private serverType: ServerType,
@@ -29,8 +27,6 @@ export class AuthManager {
         : this.serverType === ServerType.SasViya
         ? '/SASLogon/logout.do?'
         : '/SASLogon/logout'
-
-    this.redirectedLoginUrl = this.serverUrl + this.redirectedLoginUrl
   }
 
   /**
@@ -82,7 +78,16 @@ export class AuthManager {
 
     if (isLoggedIn) {
       if (this.serverType === ServerType.Sas9) {
-        await this.performCASSecurityCheck()
+        const casSecurityCheckResponse = await this.performCASSecurityCheck()
+
+        if (isPublicAccessDenied(casSecurityCheckResponse.result)) {
+          return {
+            isLoggedIn: false,
+            userName: this.userName || '',
+            userLongName: this.userLongName || '',
+            errorMessage: 'Public access has been denied.'
+          }
+        }
       }
 
       const { userName, userLongName } = await this.fetchUserName()
@@ -133,7 +138,7 @@ export class AuthManager {
 
     let loginResponse = await this.sendLoginRequest(loginForm, loginParams)
 
-    let isLoggedIn = isLogInSuccessHeaderPresent(this.serverType, loginResponse)
+    let isLoggedIn = isLogInSuccess(this.serverType, loginResponse)
 
     if (!isLoggedIn) {
       if (isCredentialsVerifyError(loginResponse)) {
@@ -153,7 +158,17 @@ export class AuthManager {
 
     if (isLoggedIn) {
       if (this.serverType === ServerType.Sas9) {
-        await this.performCASSecurityCheck()
+        const casSecurityCheckResponse = await this.performCASSecurityCheck()
+        if (isPublicAccessDenied(casSecurityCheckResponse.result)) {
+          isLoggedIn = false
+
+          return {
+            isLoggedIn,
+            userName: this.userName || '',
+            userLongName: this.userLongName || '',
+            errorMessage: 'Public access has been denied.'
+          }
+        }
       }
 
       this.loginCallback()
@@ -170,11 +185,15 @@ export class AuthManager {
   private async performCASSecurityCheck() {
     const casAuthenticationUrl = `${this.serverUrl}/SASStoredProcess/j_spring_cas_security_check`
 
-    await this.requestClient
+    return await this.requestClient
       .get<string>(`/SASLogon/login?service=${casAuthenticationUrl}`, undefined)
       .catch((err) => {
         // ignore if resource not found error
         if (!(err instanceof NotFoundError)) throw err
+
+        return {
+          result: ''
+        }
       })
   }
 
@@ -218,7 +237,7 @@ export class AuthManager {
    *  - a boolean `isLoggedIn`
    *  - a string `userName`,
    *  - a string `userFullName` and
-   *  - a form `loginForm` if not loggedIn.
+   *  - a form `loginForm` if not loggedin.
    */
   public async checkSession(): Promise<LoginResultInternal> {
     const { isLoggedIn, userName, userLongName } = await this.fetchUserName()
@@ -385,3 +404,13 @@ const isCredentialsVerifyError = (response: string): boolean =>
   /An error occurred while the system was verifying your credentials. Please enter your credentials again./gm.test(
     response
   )
+
+const isLogInSuccess = (serverType: ServerType, response: any): boolean => {
+  if (serverType === ServerType.Sasjs) return response?.loggedin
+
+  return /You have signed in/gm.test(response)
+}
+
+const isPublicAccessDenied = (response: any): boolean => {
+  return /Public access has been denied/gm.test(response)
+}

src/auth/index.ts

@@ -1,4 +1,3 @@
 export * from './AuthManager'
 export * from './isAuthorizeFormRequired'
 export * from './isLoginRequired'
-export * from './loginHeader'

src/auth/loginHeader.ts

@@ -1,97 +0,0 @@
-import { ServerType } from '@sasjs/utils/types'
-import { getUserLanguage } from '../utils'
-
-const enLoginSuccessHeader = 'You have signed in.'
-
-export const defaultSuccessHeaderKey = 'default'
-
-// The following headers provided by https://github.com/sasjs/adapter/issues/835#issuecomment-2177818601
-export const loginSuccessHeaders: { [key: string]: string } = {
-  es: `Ya se ha iniciado la sesi\u00f3n.`,
-  th: `\u0e04\u0e38\u0e13\u0e25\u0e07\u0e0a\u0e37\u0e48\u0e2d\u0e40\u0e02\u0e49\u0e32\u0e43\u0e0a\u0e49\u0e41\u0e25\u0e49\u0e27`,
-  ja: `\u30b5\u30a4\u30f3\u30a4\u30f3\u3057\u307e\u3057\u305f\u3002`,
-  nb: `Du har logget deg p\u00e5.`,
-  sl: `Prijavili ste se.`,
-  ar: `\u0644\u0642\u062f \u0642\u0645\u062a `,
-  sk: `Prihl\u00e1sili ste sa.`,
-  zh_HK: `\u60a8\u5df2\u767b\u5165\u3002`,
-  zh_CN: `\u60a8\u5df2\u767b\u5f55\u3002`,
-  it: `L'utente si \u00e8 connesso.`,
-  sv: `Du har loggat in.`,
-  he: `\u05e0\u05db\u05e0\u05e1\u05ea `,
-  nl: `U hebt zich aangemeld.`,
-  pl: `Zosta\u0142e\u015b zalogowany.`,
-  ko: `\ub85c\uadf8\uc778\ud588\uc2b5\ub2c8\ub2e4.`,
-  zh_TW: `\u60a8\u5df2\u767b\u5165\u3002`,
-  tr: `Oturum a\u00e7t\u0131n\u0131z.`,
-  iw: `\u05e0\u05db\u05e0\u05e1\u05ea `,
-  fr: `Vous \u00eates connect\u00e9.`,
-  uk: `\u0412\u0438 \u0432\u0432\u0456\u0439\u0448\u043b\u0438 \u0432 \u043e\u0431\u043b\u0456\u043a\u043e\u0432\u0438\u0439 \u0437\u0430\u043f\u0438\u0441.`,
-  pt_BR: `Voc\u00ea se conectou.`,
-  no: `Du har logget deg p\u00e5.`,
-  cs: `Jste p\u0159ihl\u00e1\u0161eni.`,
-  fi: `Olet kirjautunut sis\u00e4\u00e4n.`,
-  ru: `\u0412\u044b \u0432\u044b\u043f\u043e\u043b\u043d\u0438\u043b\u0438 \u0432\u0445\u043e\u0434 \u0432 \u0441\u0438\u0441\u0442\u0435\u043c\u0443.`,
-  el: `\u0388\u03c7\u03b5\u03c4\u03b5 \u03c3\u03c5\u03bd\u03b4\u03b5\u03b8\u03b5\u03af.`,
-  hr: `Prijavili ste se.`,
-  da: `Du er logget p\u00e5.`,
-  de: `Sie sind jetzt angemeldet.`,
-  sh: `Prijavljeni ste.`,
-  pt: `Iniciou sess\u00e3o.`,
-  hu: `Bejelentkezett.`,
-  sr: `Prijavljeni ste.`,
-  en: enLoginSuccessHeader,
-  [defaultSuccessHeaderKey]: enLoginSuccessHeader
-}
-
-/**
- * Provides expected login header based on language settings of the browser.
- * @returns - expected header as a string.
- */
-export const getExpectedLogInSuccessHeader = (): string => {
-  // get default success header
-  let successHeader = loginSuccessHeaders[defaultSuccessHeaderKey]
-
-  // get user language based on language settings of the browser
-  const userLang = getUserLanguage()
-
-  if (userLang) {
-    // get success header on exact match of the language code
-    let userLangSuccessHeader = loginSuccessHeaders[userLang]
-
-    // handle case when there is no exact match of the language code
-    if (!userLangSuccessHeader) {
-      // get all supported language codes
-      const headerLanguages = Object.keys(loginSuccessHeaders)
-
-      // find language code on partial match
-      const headerLanguage = headerLanguages.find((language) =>
-        new RegExp(language, 'i').test(userLang)
-      )
-
-      // reassign success header if partial match was found
-      if (headerLanguage) {
-        successHeader = loginSuccessHeaders[headerLanguage]
-      }
-    } else {
-      successHeader = userLangSuccessHeader
-    }
-  }
-
-  return successHeader
-}
-
-/**
- * Checks if Login success header is present in the response based on language settings of the browser.
- * @param serverType - server type.
- * @param response - response object.
- * @returns - boolean indicating if Login success header is present.
- */
-export const isLogInSuccessHeaderPresent = (
-  serverType: ServerType,
-  response: any
-): boolean => {
-  if (serverType === ServerType.Sasjs) return response?.loggedIn
-
-  return new RegExp(getExpectedLogInSuccessHeader(), 'gm').test(response)
-}

src/auth/refreshTokensForViya.ts

@@ -1,6 +1,6 @@
 import { SasAuthResponse, ServerType } from '@sasjs/utils/types'
 import { prefixMessage } from '@sasjs/utils/error'
-import NodeFormData from 'form-data'
+import * as NodeFormData from 'form-data'
 import { RequestClient } from '../request/RequestClient'
 import { isNode } from '../utils'
 import { getTokenRequestErrorPrefix } from './getTokenRequestErrorPrefix'

src/auth/spec/AuthManager.spec.ts

@@ -1,22 +1,18 @@
-/**
- * @jest-environment jsdom
- */
-
 import { AuthManager } from '../AuthManager'
 import * as dotenv from 'dotenv'
 import { ServerType } from '@sasjs/utils/types'
 import axios from 'axios'
 import {
   mockedCurrentUserApi,
-  mockLoginAuthoriseRequiredResponse
+  mockLoginAuthoriseRequiredResponse,
+  mockLoginPublicAccessDeniedResponse,
+  mockLoginSuccessResponse
 } from './mockResponses'
 import { serialize } from '../../utils'
 import * as openWebPageModule from '../openWebPage'
 import * as verifySasViyaLoginModule from '../verifySasViyaLogin'
 import * as verifySas9LoginModule from '../verifySas9Login'
 import { RequestClient } from '../../request/RequestClient'
-import { getExpectedLogInSuccessHeader } from '../'
-
 jest.mock('axios')
 const mockedAxios = axios as jest.Mocked<typeof axios>
 
@@ -130,7 +126,6 @@ describe('AuthManager', () => {
         requestClient,
         authCallback
       )
-
       jest.spyOn(authManager, 'checkSession').mockImplementation(() =>
         Promise.resolve({
           isLoggedIn: false,
@@ -139,9 +134,8 @@ describe('AuthManager', () => {
           loginForm: { name: 'test' }
         })
       )
-
       mockedAxios.post.mockImplementation(() =>
-        Promise.resolve({ data: getExpectedLogInSuccessHeader() })
+        Promise.resolve({ data: mockLoginSuccessResponse })
       )
 
       const loginResponse = await authManager.logIn(userName, password)
@@ -159,7 +153,7 @@ describe('AuthManager', () => {
         `/SASLogon/login`,
         loginParams,
         {
-          withXSRFToken: true,
+          withCredentials: true,
           headers: {
             'Content-Type': 'application/x-www-form-urlencoded',
             Accept: '*/*'
@@ -177,7 +171,6 @@ describe('AuthManager', () => {
         requestClient,
         authCallback
       )
-
       jest.spyOn(authManager, 'checkSession').mockImplementation(() =>
         Promise.resolve({
           isLoggedIn: false,
@@ -186,9 +179,8 @@ describe('AuthManager', () => {
           loginForm: { name: 'test' }
         })
       )
-
       mockedAxios.post.mockImplementation(() =>
-        Promise.resolve({ data: getExpectedLogInSuccessHeader() })
+        Promise.resolve({ data: mockLoginSuccessResponse })
       )
       mockedAxios.get.mockImplementation(() => Promise.resolve({ status: 200 }))
 
@@ -207,7 +199,7 @@ describe('AuthManager', () => {
         `/SASLogon/login`,
         loginParams,
         {
-          withXSRFToken: true,
+          withCredentials: true,
           headers: {
             'Content-Type': 'application/x-www-form-urlencoded',
             Accept: '*/*'
@@ -222,6 +214,61 @@ describe('AuthManager', () => {
       expect(authCallback).toHaveBeenCalledTimes(1)
     })
 
+    it('should post a login & a cas_security request to the SAS9 server when not logged in & get rejected due to public access denied', async () => {
+      const serverType = ServerType.Sas9
+      const authManager = new AuthManager(
+        serverUrl,
+        serverType,
+        requestClient,
+        authCallback
+      )
+      jest.spyOn(authManager, 'checkSession').mockImplementation(() =>
+        Promise.resolve({
+          isLoggedIn: false,
+          userName: '',
+          userLongName: '',
+          loginForm: { name: 'test' }
+        })
+      )
+      mockedAxios.post.mockImplementationOnce(() =>
+        Promise.resolve({ data: mockLoginSuccessResponse })
+      )
+      mockedAxios.get.mockImplementationOnce(() =>
+        Promise.resolve({ data: mockLoginPublicAccessDeniedResponse })
+      )
+
+      const loginResponse = await authManager.logIn(userName, password)
+
+      expect(loginResponse.isLoggedIn).toBeFalse()
+      expect(loginResponse.userName).toEqual('')
+      expect(loginResponse.errorMessage).toEqual(
+        'Public access has been denied.'
+      )
+
+      const loginParams = serialize({
+        _service: 'default',
+        username: userName,
+        password,
+        name: 'test'
+      })
+      expect(mockedAxios.post).toHaveBeenCalledWith(
+        `/SASLogon/login`,
+        loginParams,
+        {
+          withCredentials: true,
+          headers: {
+            'Content-Type': 'application/x-www-form-urlencoded',
+            Accept: '*/*'
+          }
+        }
+      )
+      const casAuthenticationUrl = `${serverUrl}/SASStoredProcess/j_spring_cas_security_check`
+      expect(mockedAxios.get).toHaveBeenCalledWith(
+        `/SASLogon/login?service=${casAuthenticationUrl}`,
+        getHeadersJson
+      )
+    })
+
     it('should return empty username if unable to logged in', async () => {
       const authManager = new AuthManager(
         serverUrl,
@@ -256,7 +303,7 @@ describe('AuthManager', () => {
         `/SASLogon/login`,
         loginParams,
         {
-          withXSRFToken: true,
+          withCredentials: true,
           headers: {
             'Content-Type': 'application/x-www-form-urlencoded',
             Accept: '*/*'
@@ -374,7 +421,7 @@ describe('AuthManager', () => {
       expect(loginResponse.userName).toEqual(userName)
 
       expect(openWebPageModule.openWebPage).toHaveBeenCalledWith(
-        `${serverUrl}/SASLogon`,
+        `/SASLogon`,
         'SASLogon',
         {
           width: 500,
@@ -418,7 +465,7 @@ describe('AuthManager', () => {
       expect(loginResponse.userName).toEqual(userName)
 
       expect(openWebPageModule.openWebPage).toHaveBeenCalledWith(
-        `${serverUrl}/SASLogon`,
+        `/SASLogon`,
         'SASLogon',
         {
           width: 500,
@@ -431,6 +478,53 @@ describe('AuthManager', () => {
       expect(authCallback).toHaveBeenCalledTimes(1)
     })
 
+    it('should return error if public account access is denied', async () => {
+      const serverType = ServerType.Sas9
+      const authManager = new AuthManager(
+        serverUrl,
+        serverType,
+        requestClient,
+        authCallback
+      )
+      jest
+        .spyOn<any, any>(authManager, 'fetchUserName')
+        .mockImplementationOnce(() =>
+          Promise.resolve({
+            isLoggedIn: false,
+            userName: ''
+          })
+        )
+        .mockImplementationOnce(() =>
+          Promise.resolve({
+            isLoggedIn: true,
+            userName
+          })
+        )
+      mockedAxios.get.mockImplementation(() =>
+        Promise.resolve({ data: mockLoginPublicAccessDeniedResponse })
+      )
+
+      const loginResponse = await authManager.redirectedLogIn({})
+
+      expect(loginResponse.isLoggedIn).toBeFalse()
+      expect(loginResponse.userName).toEqual('')
+      expect(loginResponse.errorMessage).toEqual(
+        'Public access has been denied.'
+      )
+
+      expect(openWebPageModule.openWebPage).toHaveBeenCalledWith(
+        `/SASLogon`,
+        'SASLogon',
+        {
+          width: 500,
+          height: 600
+        },
+        undefined
+      )
+      expect(authManager['fetchUserName']).toHaveBeenCalledTimes(1)
+      expect(verifySas9LoginModule.verifySas9Login).toHaveBeenCalledTimes(1)
+    })
+
     it('should return empty username if user unable to re-login via pop up', async () => {
       const authManager = new AuthManager(
         serverUrl,
@@ -462,7 +556,7 @@ describe('AuthManager', () => {
       expect(loginResponse.userName).toEqual('')
 
       expect(openWebPageModule.openWebPage).toHaveBeenCalledWith(
-        `${serverUrl}/SASLogon`,
+        `/SASLogon`,
         'SASLogon',
         {
           width: 500,
@@ -506,7 +600,7 @@ describe('AuthManager', () => {
       expect(loginResponse.userName).toEqual('')
 
       expect(openWebPageModule.openWebPage).toHaveBeenCalledWith(
-        `${serverUrl}/SASLogon`,
+        `/SASLogon`,
         'SASLogon',
         {
           width: 500,
@@ -539,7 +633,7 @@ describe('AuthManager', () => {
         1,
         `http://test-server.com/identities/users/@currentUser`,
         {
-          withXSRFToken: true,
+          withCredentials: true,
           responseType: 'text',
           transformResponse: undefined,
           headers: {
@@ -573,7 +667,7 @@ describe('AuthManager', () => {
         1,
         `http://test-server.com/SASStoredProcess`,
         {
-          withXSRFToken: true,
+          withCredentials: true,
           responseType: 'text',
           transformResponse: undefined,
           headers: {
@@ -602,7 +696,7 @@ describe('AuthManager', () => {
         1,
         `http://test-server.com/identities/users/@currentUser`,
         {
-          withXSRFToken: true,
+          withCredentials: true,
           responseType: 'text',
           transformResponse: undefined,
           headers: {
@@ -621,7 +715,7 @@ describe('AuthManager', () => {
 })
 
 const getHeadersJson = {
-  withXSRFToken: true,
+  withCredentials: true,
   headers: {
     'Content-Type': 'application/json',
     Accept: 'application/json'

src/auth/spec/getAccessTokenForViya.spec.ts

@@ -1,5 +1,5 @@
 import { AuthConfig } from '@sasjs/utils/types'
-import NodeFormData from 'form-data'
+import * as NodeFormData from 'form-data'
 import { generateToken, mockAuthResponse } from './mockResponses'
 import { RequestClient } from '../../request/RequestClient'
 import { getAccessTokenForViya } from '../getAccessTokenForViya'

src/auth/spec/loginHeader.spec.ts

@@ -1,82 +0,0 @@
-/**
- * @jest-environment jsdom
- */
-
-import { ServerType } from '@sasjs/utils/types'
-import {
-  loginSuccessHeaders,
-  isLogInSuccessHeaderPresent,
-  defaultSuccessHeaderKey
-} from '../'
-
-describe('isLogInSuccessHeaderPresent', () => {
-  let languageGetter: any
-
-  beforeEach(() => {
-    languageGetter = jest.spyOn(window.navigator, 'language', 'get')
-  })
-
-  it('should check SASVIYA and SAS9 login success header based on language preferences of the browser', () => {
-    // test SASVIYA server type
-    Object.keys(loginSuccessHeaders).forEach((key) => {
-      languageGetter.mockReturnValue(key)
-
-      expect(
-        isLogInSuccessHeaderPresent(
-          ServerType.SasViya,
-          loginSuccessHeaders[key]
-        )
-      ).toBeTruthy()
-    })
-
-    // test SAS9 server type
-    Object.keys(loginSuccessHeaders).forEach((key) => {
-      languageGetter.mockReturnValue(key)
-
-      expect(
-        isLogInSuccessHeaderPresent(ServerType.Sas9, loginSuccessHeaders[key])
-      ).toBeTruthy()
-    })
-
-    // test possible longer language codes
-    const possibleLanguageCodes = [
-      { short: 'en', long: 'en-US' },
-      { short: 'fr', long: 'fr-FR' },
-      { short: 'es', long: 'es-ES' }
-    ]
-
-    possibleLanguageCodes.forEach((key) => {
-      const { short, long } = key
-      languageGetter.mockReturnValue(long)
-
-      expect(
-        isLogInSuccessHeaderPresent(
-          ServerType.SasViya,
-          loginSuccessHeaders[short]
-        )
-      ).toBeTruthy()
-    })
-
-    // test falling back to default language code
-    languageGetter.mockReturnValue('WRONG-LANGUAGE')
-
-    expect(
-      isLogInSuccessHeaderPresent(
-        ServerType.Sas9,
-        loginSuccessHeaders[defaultSuccessHeaderKey]
-      )
-    ).toBeTruthy()
-  })
-
-  it('should check SASVJS login success header', () => {
-    expect(
-      isLogInSuccessHeaderPresent(ServerType.Sasjs, { loggedIn: true })
-    ).toBeTruthy()
-
-    expect(
-      isLogInSuccessHeaderPresent(ServerType.Sasjs, { loggedIn: false })
-    ).toBeFalsy()
-
-    expect(isLogInSuccessHeaderPresent(ServerType.Sasjs, undefined)).toBeFalsy()
-  })
-})

src/auth/spec/mockResponses.ts

@@ -1,6 +1,8 @@
 import { SasAuthResponse } from '@sasjs/utils/types'
 
 export const mockLoginAuthoriseRequiredResponse = `<form id="application_authorization" action="/SASLogon/oauth/authorize" method="POST"><input type="hidden" name="X-Uaa-Csrf" value="2nfuxIn6WaOURWL7tzTXCe"/>`
+export const mockLoginSuccessResponse = `You have signed in`
+export const mockLoginPublicAccessDeniedResponse = `Public access has been denied`
 
 export const mockAuthResponse: SasAuthResponse = {
   access_token: 'acc355',

src/auth/spec/refreshTokensForViya.spec.ts

@@ -1,5 +1,5 @@
 import { AuthConfig, ServerType } from '@sasjs/utils/types'
-import NodeFormData from 'form-data'
+import * as NodeFormData from 'form-data'
 import { generateToken, mockAuthResponse } from './mockResponses'
 import { RequestClient } from '../../request/RequestClient'
 import { refreshTokensForViya } from '../refreshTokensForViya'

src/auth/spec/verifySas9Login.spec.ts

@@ -3,7 +3,6 @@
  */
 import { verifySas9Login } from '../verifySas9Login'
 import * as delayModule from '../../utils/delay'
-import { getExpectedLogInSuccessHeader } from '../'
 
 describe('verifySas9Login', () => {
   const serverUrl = 'http://test-server.com'
@@ -19,9 +18,7 @@ describe('verifySas9Login', () => {
     const popup = {
       window: {
         location: { href: serverUrl + `/SASLogon` },
-        document: {
-          body: { innerText: `<h3>${getExpectedLogInSuccessHeader()}</h3>` }
-        }
+        document: { body: { innerText: '<h3>You have signed in.</h3>' } }
       }
     } as unknown as Window
 

src/auth/spec/verifySasViyaLogin.spec.ts

@@ -3,7 +3,6 @@
  */
 import { verifySasViyaLogin } from '../verifySasViyaLogin'
 import * as delayModule from '../../utils/delay'
-import { getExpectedLogInSuccessHeader } from '../'
 
 describe('verifySasViyaLogin', () => {
   const serverUrl = 'http://test-server.com'
@@ -20,9 +19,7 @@ describe('verifySasViyaLogin', () => {
     const popup = {
       window: {
         location: { href: serverUrl + `/SASLogon` },
-        document: {
-          body: { innerText: `<h3>${getExpectedLogInSuccessHeader()}</h3>` }
-        }
+        document: { body: { innerText: '<h3>You have signed in.</h3>' } }
       }
     } as unknown as Window
 

src/auth/verifySas9Login.ts

@@ -1,5 +1,4 @@
 import { delay } from '../utils'
-import { getExpectedLogInSuccessHeader } from './'
 
 export async function verifySas9Login(loginPopup: Window): Promise<{
   isLoggedIn: boolean
@@ -7,17 +6,13 @@ export async function verifySas9Login(loginPopup: Window): Promise<{
   let isLoggedIn = false
   let startTime = new Date()
   let elapsedSeconds = 0
-
   do {
     await delay(1000)
     if (loginPopup.closed) break
 
     isLoggedIn =
       loginPopup.window.location.href.includes('SASLogon') &&
-      loginPopup.window.document.body.innerText.includes(
-        getExpectedLogInSuccessHeader()
-      )
-
+      loginPopup.window.document.body.innerText.includes('You have signed in.')
     elapsedSeconds = (new Date().valueOf() - startTime.valueOf()) / 1000
   } while (!isLoggedIn && elapsedSeconds < 5 * 60)
 

src/auth/verifySasViyaLogin.ts

@@ -1,5 +1,4 @@
 import { delay } from '../utils'
-import { getExpectedLogInSuccessHeader } from './'
 
 export async function verifySasViyaLogin(loginPopup: Window): Promise<{
   isLoggedIn: boolean
@@ -7,32 +6,23 @@ export async function verifySasViyaLogin(loginPopup: Window): Promise<{
   let isLoggedIn = false
   let startTime = new Date()
   let elapsedSeconds = 0
-
   do {
     await delay(1000)
-
     if (loginPopup.closed) break
-
     isLoggedIn = isLoggedInSASVIYA()
-
     elapsedSeconds = (new Date().valueOf() - startTime.valueOf()) / 1000
   } while (!isLoggedIn && elapsedSeconds < 5 * 60)
 
   let isAuthorized = false
-
   startTime = new Date()
-
   do {
     await delay(1000)
-
     if (loginPopup.closed) break
-
     isAuthorized =
       loginPopup.window.location.href.includes('SASLogon') ||
       loginPopup.window.document.body?.innerText?.includes(
-        getExpectedLogInSuccessHeader()
+        'You have signed in.'
       )
-
     elapsedSeconds = (new Date().valueOf() - startTime.valueOf()) / 1000
   } while (!isAuthorized && elapsedSeconds < 5 * 60)
 

src/file/generateFileUploadForm.ts

@@ -1,4 +1,4 @@
-import NodeFormData from 'form-data'
+import * as NodeFormData from 'form-data'
 import { convertToCSV } from '../utils/convertToCsv'
 import { isNode } from '../utils'
 

src/file/generateTableUploadForm.ts

@@ -1,4 +1,4 @@
-import NodeFormData from 'form-data'
+import * as NodeFormData from 'form-data'
 import { convertToCSV, isFormatsTable } from '../utils/convertToCsv'
 import { splitChunks } from '../utils/splitChunks'
 

src/file/spec/generateFileUploadForm.spec.ts

@@ -1,6 +1,6 @@
 import { generateFileUploadForm } from '../generateFileUploadForm'
 import { convertToCSV } from '../../utils/convertToCsv'
-import NodeFormData from 'form-data'
+import * as NodeFormData from 'form-data'
 import * as isNodeModule from '../../utils/isNode'
 
 describe('generateFileUploadForm', () => {