sasjs/adapter
1
0
Fork 0
mirror of https://github.com/sasjs/adapter.git synced 2026-01-08 21:10:05 +00:00
Code Issues Projects Releases Wiki Activity

fix(csv-convert): fixed data convertion

Browse Source
This commit is contained in:
Yury Shkoda
2021-05-07 10:30:27 +03:00
parent 88f08e8864
commit b86658ef9b
16 changed files with 454 additions and 461 deletions
Download Patch File Download Diff File Expand all files Collapse all files

106
sasjs-tests/src/testSuites/Basic.ts
View File

@@ -1,102 +1,102 @@
import SASjs, { SASjsConfig } from "@sasjs/adapter";
import { TestSuite } from "@sasjs/test-framework";
import { ServerType } from "@sasjs/utils/types";
import SASjs, { SASjsConfig } from '@sasjs/adapter'
import { TestSuite } from '@sasjs/test-framework'
import { ServerType } from '@sasjs/utils/types'
const stringData: any = { table1: [{ col1: "first col value" }] };
const stringData: any = { table1: [{ col1: 'first col value' }] }
const defaultConfig: SASjsConfig = {
serverUrl: window.location.origin,
pathSAS9: "/SASStoredProcess/do",
pathSASViya: "/SASJobExecution",
appLoc: "/Public/seedapp",
pathSAS9: '/SASStoredProcess/do',
pathSASViya: '/SASJobExecution',
appLoc: '/Public/seedapp',
serverType: ServerType.SasViya,
debug: false,
contextName: "SAS Job Execution compute context",
contextName: 'SAS Job Execution compute context',
useComputeApi: false,
allowInsecureRequests: false
};
}
const customConfig = {
serverUrl: "http://url.com",
pathSAS9: "sas9",
pathSASViya: "viya",
appLoc: "/Public/seedapp",
serverUrl: 'http://url.com',
pathSAS9: 'sas9',
pathSASViya: 'viya',
appLoc: '/Public/seedapp',
serverType: ServerType.Sas9,
debug: false
};
}
export const basicTests = (
adapter: SASjs,
userName: string,
password: string
): TestSuite => ({
name: "Basic Tests",
name: 'Basic Tests',
tests: [
{
title: "Log in",
description: "Should log the user in",
title: 'Log in',
description: 'Should log the user in',
test: async () => {
return adapter.logIn(userName, password);
return adapter.logIn(userName, password)
},
assertion: (response: any) =>
response && response.isLoggedIn && response.userName === userName
},
{
title: "Multiple Log in attempts",
title: 'Multiple Log in attempts',
description:
"Should fail on first attempt and should log the user in on second attempt",
'Should fail on first attempt and should log the user in on second attempt',
test: async () => {
await adapter.logOut();
await adapter.logIn("invalid", "invalid");
return adapter.logIn(userName, password);
await adapter.logOut()
await adapter.logIn('invalid', 'invalid')
return adapter.logIn(userName, password)
},
assertion: (response: any) =>
response && response.isLoggedIn && response.userName === userName
},
{
title: "Trigger login callback",
title: 'Trigger login callback',
description:
"Should trigger required login callback and after successful login, it should finish the request",
'Should trigger required login callback and after successful login, it should finish the request',
test: async () => {
await adapter.logOut();
await adapter.logOut()
return await adapter.request(
"common/sendArr",
'common/sendArr',
stringData,
undefined,
() => {
adapter.logIn(userName, password);
adapter.logIn(userName, password)
}
);
)
},
assertion: (response: any) => {
return response.table1[0][0] === stringData.table1[0].col1;
return response.table1[0][0] === stringData.table1[0].col1
}
},
{
title: "Request with debug on",
title: 'Request with debug on',
description:
"Should complete successful request with debugging switched on",
'Should complete successful request with debugging switched on',
test: async () => {
const config = {
debug: true
};
}
return await adapter.request("common/sendArr", stringData, config);
return await adapter.request('common/sendArr', stringData, config)
},
assertion: (response: any) => {
return response.table1[0][0] === stringData.table1[0].col1;
return response.table1[0][0] === stringData.table1[0].col1
}
},
{
title: "Default config",
title: 'Default config',
description:
"Should instantiate with default config when none is provided",
'Should instantiate with default config when none is provided',
test: async () => {
return Promise.resolve(new SASjs());
return Promise.resolve(new SASjs())
},
assertion: (sasjsInstance: SASjs) => {
const sasjsConfig = sasjsInstance.getSasjsConfig();
const sasjsConfig = sasjsInstance.getSasjsConfig()
return (
sasjsConfig.serverUrl === defaultConfig.serverUrl &&
@@ -105,17 +105,17 @@ export const basicTests = (
sasjsConfig.appLoc === defaultConfig.appLoc &&
sasjsConfig.serverType === defaultConfig.serverType &&
sasjsConfig.debug === defaultConfig.debug
);
)
}
},
{
title: "Custom config",
description: "Should use fully custom config whenever supplied",
title: 'Custom config',
description: 'Should use fully custom config whenever supplied',
test: async () => {
return Promise.resolve(new SASjs(customConfig));
return Promise.resolve(new SASjs(customConfig))
},
assertion: (sasjsInstance: SASjs) => {
const sasjsConfig = sasjsInstance.getSasjsConfig();
const sasjsConfig = sasjsInstance.getSasjsConfig()
return (
sasjsConfig.serverUrl === customConfig.serverUrl &&
sasjsConfig.pathSAS9 === customConfig.pathSAS9 &&
@@ -123,28 +123,28 @@ export const basicTests = (
sasjsConfig.appLoc === customConfig.appLoc &&
sasjsConfig.serverType === customConfig.serverType &&
sasjsConfig.debug === customConfig.debug
);
)
}
},
{
title: "Config overrides",
description: "Should override default config with supplied properties",
title: 'Config overrides',
description: 'Should override default config with supplied properties',
test: async () => {
return Promise.resolve(
new SASjs({ serverUrl: "http://test.com", debug: false })
);
new SASjs({ serverUrl: 'http://test.com', debug: false })
)
},
assertion: (sasjsInstance: SASjs) => {
const sasjsConfig = sasjsInstance.getSasjsConfig();
const sasjsConfig = sasjsInstance.getSasjsConfig()
return (
sasjsConfig.serverUrl === "http://test.com" &&
sasjsConfig.serverUrl === 'http://test.com' &&
sasjsConfig.pathSAS9 === defaultConfig.pathSAS9 &&
sasjsConfig.pathSASViya === defaultConfig.pathSASViya &&
sasjsConfig.appLoc === defaultConfig.appLoc &&
sasjsConfig.serverType === defaultConfig.serverType &&
sasjsConfig.debug === false
);
)
}
}
]
});
})

96
sasjs-tests/src/testSuites/Compute.ts
View File

@@ -1,106 +1,100 @@
import SASjs from "@sasjs/adapter";
import { TestSuite } from "@sasjs/test-framework";
import SASjs from '@sasjs/adapter'
import { TestSuite } from '@sasjs/test-framework'
export const computeTests = (adapter: SASjs): TestSuite => ({
name: "Compute",
name: 'Compute',
tests: [
{
title: "Start Compute Job - not waiting for result",
description: "Should start a compute job and return the session",
title: 'Start Compute Job - not waiting for result',
description: 'Should start a compute job and return the session',
test: () => {
const data: any = { table1: [{ col1: "first col value" }] };
return adapter.startComputeJob("/Public/app/common/sendArr", data);
const data: any = { table1: [{ col1: 'first col value' }] }
return adapter.startComputeJob('/Public/app/common/sendArr', data)
},
assertion: (res: any) => {
const expectedProperties = ["id", "applicationName", "attributes"];
return validate(expectedProperties, res);
const expectedProperties = ['id', 'applicationName', 'attributes']
return validate(expectedProperties, res)
}
},
{
title: "Start Compute Job - waiting for result",
description: "Should start a compute job and return the job",
title: 'Start Compute Job - waiting for result',
description: 'Should start a compute job and return the job',
test: () => {
const data: any = { table1: [{ col1: "first col value" }] };
const data: any = { table1: [{ col1: 'first col value' }] }
return adapter.startComputeJob(
"/Public/app/common/sendArr",
'/Public/app/common/sendArr',
data,
{},
"",
'',
true
);
)
},
assertion: (res: any) => {
const expectedProperties = [
"id",
"state",
"creationTimeStamp",
"jobConditionCode"
];
return validate(expectedProperties, res.job);
'id',
'state',
'creationTimeStamp',
'jobConditionCode'
]
return validate(expectedProperties, res.job)
}
},
{
title: "Execute Script Viya - complete job",
description: "Should execute sas file and return log",
title: 'Execute Script Viya - complete job',
description: 'Should execute sas file and return log',
test: () => {
const fileLines = [
`data;`,
`do x=1 to 100;`,
`output;`,
`end;`,
`run;`
];
const fileLines = [`data;`, `do x=1 to 100;`, `output;`, `end;`, `run;`]
return adapter.executeScriptSASViya(
"sasCode.sas",
'sasCode.sas',
fileLines,
"SAS Studio compute context",
'SAS Studio compute context',
undefined,
true
);
)
},
assertion: (res: any) => {
const expectedLogContent = `1 data;\\n2 do x=1 to 100;\\n3 output;\\n4 end;\\n5 run;\\n\\n`;
const expectedLogContent = `1 data;\\n2 do x=1 to 100;\\n3 output;\\n4 end;\\n5 run;\\n\\n`
return validateLog(expectedLogContent, res.log);
return validateLog(expectedLogContent, res.log)
}
},
{
title: "Execute Script Viya - failed job",
description: "Should execute sas file and return log",
title: 'Execute Script Viya - failed job',
description: 'Should execute sas file and return log',
test: () => {
const fileLines = [`%abort;`];
const fileLines = [`%abort;`]
return adapter
.executeScriptSASViya(
"sasCode.sas",
'sasCode.sas',
fileLines,
"SAS Studio compute context",
'SAS Studio compute context',
undefined,
true
)
.catch((err: any) => err);
.catch((err: any) => err)
},
assertion: (res: any) => {
const expectedLogContent = `1 %abort;\\nERROR: The %ABORT statement is not valid in open code.\\n`;
const expectedLogContent = `1 %abort;\\nERROR: The %ABORT statement is not valid in open code.\\n`
return validateLog(expectedLogContent, res.log);
return validateLog(expectedLogContent, res.log)
}
}
]
});
})
const validateLog = (text: string, log: string): boolean => {
const isValid = JSON.stringify(log).includes(text);
const isValid = JSON.stringify(log).includes(text)
return isValid;
};
return isValid
}
const validate = (expectedProperties: string[], data: any): boolean => {
const actualProperties = Object.keys(data);
const actualProperties = Object.keys(data)
const isValid = expectedProperties.every((property) =>
actualProperties.includes(property)
);
return isValid;
};
)
return isValid
}

261
sasjs-tests/src/testSuites/RequestData.ts
View File

@@ -1,112 +1,112 @@
import SASjs from "@sasjs/adapter";
import { TestSuite } from "@sasjs/test-framework";
import SASjs from '@sasjs/adapter'
import { TestSuite } from '@sasjs/test-framework'
const stringData: any = { table1: [{ col1: "first col value" }] };
const numericData: any = { table1: [{ col1: 3.14159265 }] };
const stringData: any = { table1: [{ col1: 'first col value' }] }
const numericData: any = { table1: [{ col1: 3.14159265 }] }
const multiColumnData: any = {
table1: [{ col1: 42, col2: 1.618, col3: "x", col4: "x" }]
};
table1: [{ col1: 42, col2: 1.618, col3: 'x', col4: 'x' }]
}
const multipleRowsWithNulls: any = {
table1: [
{ col1: 42, col2: null, col3: "x", col4: "" },
{ col1: 42, col2: null, col3: "x", col4: "" },
{ col1: 42, col2: null, col3: "x", col4: "" },
{ col1: 42, col2: 1.62, col3: "x", col4: "x" },
{ col1: 42, col2: 1.62, col3: "x", col4: "x" }
{ col1: 42, col2: null, col3: 'x', col4: '' },
{ col1: 42, col2: null, col3: 'x', col4: '' },
{ col1: 42, col2: null, col3: 'x', col4: '' },
{ col1: 42, col2: 1.62, col3: 'x', col4: 'x' },
{ col1: 42, col2: 1.62, col3: 'x', col4: 'x' }
]
};
}
const multipleColumnsWithNulls: any = {
table1: [
{ col1: 42, col2: null, col3: "x", col4: null },
{ col1: 42, col2: null, col3: "x", col4: null },
{ col1: 42, col2: null, col3: "x", col4: null },
{ col1: 42, col2: null, col3: "x", col4: "" },
{ col1: 42, col2: null, col3: "x", col4: "" }
{ col1: 42, col2: null, col3: 'x', col4: null },
{ col1: 42, col2: null, col3: 'x', col4: null },
{ col1: 42, col2: null, col3: 'x', col4: null },
{ col1: 42, col2: null, col3: 'x', col4: '' },
{ col1: 42, col2: null, col3: 'x', col4: '' }
]
};
}
const getLongStringData = (length = 32764) => {
let x = "X";
let x = 'X'
for (let i = 1; i <= length; i++) {
x = x + "X";
x = x + 'X'
}
const data: any = { table1: [{ col1: x }] };
return data;
};
const data: any = { table1: [{ col1: x }] }
return data
}
const getLargeObjectData = () => {
const data = { table1: [{ big: "data" }] };
const data = { table1: [{ big: 'data' }] }
for (let i = 1; i < 10000; i++) {
data.table1.push(data.table1[0]);
data.table1.push(data.table1[0])
}
return data;
};
return data
}
export const sendArrTests = (adapter: SASjs): TestSuite => ({
name: "sendArr",
name: 'sendArr',
tests: [
{
title: "Absolute paths",
description: "Should work with absolute paths to SAS jobs",
title: 'Absolute paths',
description: 'Should work with absolute paths to SAS jobs',
test: () => {
return adapter.request("/Public/app/common/sendArr", stringData);
return adapter.request('/Public/app/common/sendArr', stringData)
},
assertion: (res: any) => {
return res.table1[0][0] === stringData.table1[0].col1;
return res.table1[0][0] === stringData.table1[0].col1
}
},
{
title: "Single string value",
description: "Should send an array with a single string value",
title: 'Single string value',
description: 'Should send an array with a single string value',
test: () => {
return adapter.request("common/sendArr", stringData);
return adapter.request('common/sendArr', stringData)
},
assertion: (res: any) => {
return res.table1[0][0] === stringData.table1[0].col1;
return res.table1[0][0] === stringData.table1[0].col1
}
},
{
title: "Long string value",
title: 'Long string value',
description:
"Should send an array with a long string value under 32765 characters",
'Should send an array with a long string value under 32765 characters',
test: () => {
return adapter.request("common/sendArr", getLongStringData());
return adapter.request('common/sendArr', getLongStringData())
},
assertion: (res: any) => {
const longStringData = getLongStringData();
return res.table1[0][0] === longStringData.table1[0].col1;
const longStringData = getLongStringData()
return res.table1[0][0] === longStringData.table1[0].col1
}
},
{
title: "Overly long string value",
title: 'Overly long string value',
description:
"Should error out with long string values over 32765 characters",
'Should error out with long string values over 32765 characters',
test: () => {
const data = getLongStringData(32767);
return adapter.request("common/sendArr", data).catch((e) => e);
const data = getLongStringData(32767)
return adapter.request('common/sendArr', data).catch((e) => e)
},
assertion: (error: any) => {
return !!error && !!error.error && !!error.error.message;
return !!error && !!error.error && !!error.error.message
}
},
{
title: "Single numeric value",
description: "Should send an array with a single numeric value",
title: 'Single numeric value',
description: 'Should send an array with a single numeric value',
test: () => {
return adapter.request("common/sendArr", numericData);
return adapter.request('common/sendArr', numericData)
},
assertion: (res: any) => {
return res.table1[0][0] === numericData.table1[0].col1;
return res.table1[0][0] === numericData.table1[0].col1
}
},
{
title: "Multiple columns",
description: "Should handle data with multiple columns",
title: 'Multiple columns',
description: 'Should handle data with multiple columns',
test: () => {
return adapter.request("common/sendArr", multiColumnData);
return adapter.request('common/sendArr', multiColumnData)
},
assertion: (res: any) => {
return (
@@ -114,144 +114,141 @@ export const sendArrTests = (adapter: SASjs): TestSuite => ({
res.table1[0][1] === multiColumnData.table1[0].col2 &&
res.table1[0][2] === multiColumnData.table1[0].col3 &&
res.table1[0][3] === multiColumnData.table1[0].col4
);
)
}
},
{
title: "Multiple rows with nulls",
description: "Should handle data with multiple rows with null values",
title: 'Multiple rows with nulls',
description: 'Should handle data with multiple rows with null values',
test: () => {
return adapter.request("common/sendArr", multipleRowsWithNulls);
return adapter.request('common/sendArr', multipleRowsWithNulls)
},
assertion: (res: any) => {
let result = true;
let result = true
multipleRowsWithNulls.table1.forEach((_: any, index: number) => {
result =
result &&
res.table1[index][0] === multipleRowsWithNulls.table1[index].col1;
res.table1[index][0] === multipleRowsWithNulls.table1[index].col1
result =
result &&
res.table1[index][1] === multipleRowsWithNulls.table1[index].col2;
res.table1[index][1] === multipleRowsWithNulls.table1[index].col2
result =
result &&
res.table1[index][2] === multipleRowsWithNulls.table1[index].col3;
res.table1[index][2] === multipleRowsWithNulls.table1[index].col3
result =
result &&
res.table1[index][3] ===
(multipleRowsWithNulls.table1[index].col4 || " ");
});
return result;
(multipleRowsWithNulls.table1[index].col4 || ' ')
})
return result
}
},
{
title: "Multiple columns with nulls",
description: "Should handle data with multiple columns with null values",
title: 'Multiple columns with nulls',
description: 'Should handle data with multiple columns with null values',
test: () => {
return adapter.request("common/sendArr", multipleColumnsWithNulls);
return adapter.request('common/sendArr', multipleColumnsWithNulls)
},
assertion: (res: any) => {
let result = true;
let result = true
multipleColumnsWithNulls.table1.forEach((_: any, index: number) => {
result =
result &&
res.table1[index][0] ===
multipleColumnsWithNulls.table1[index].col1;
res.table1[index][0] === multipleColumnsWithNulls.table1[index].col1
result =
result &&
res.table1[index][1] ===
multipleColumnsWithNulls.table1[index].col2;
res.table1[index][1] === multipleColumnsWithNulls.table1[index].col2
result =
result &&
res.table1[index][2] ===
multipleColumnsWithNulls.table1[index].col3;
res.table1[index][2] === multipleColumnsWithNulls.table1[index].col3
result =
result &&
res.table1[index][3] ===
(multipleColumnsWithNulls.table1[index].col4 || " ");
});
return result;
(multipleColumnsWithNulls.table1[index].col4 || ' ')
})
return result
}
}
]
});
})
export const sendObjTests = (adapter: SASjs): TestSuite => ({
name: "sendObj",
name: 'sendObj',
tests: [
{
title: "Invalid column name",
description: "Should throw an error",
title: 'Invalid column name',
description: 'Should throw an error',
test: async () => {
const invalidData: any = {
"1 invalid table": [{ col1: 42 }]
};
return adapter.request("common/sendObj", invalidData).catch((e) => e);
'1 invalid table': [{ col1: 42 }]
}
return adapter.request('common/sendObj', invalidData).catch((e) => e)
},
assertion: (error: any) =>
!!error && !!error.error && !!error.error.message
},
{
title: "Single string value",
description: "Should send an object with a single string value",
title: 'Single string value',
description: 'Should send an object with a single string value',
test: () => {
return adapter.request("common/sendObj", stringData);
return adapter.request('common/sendObj', stringData)
},
assertion: (res: any) => {
return res.table1[0].COL1 === stringData.table1[0].col1;
return res.table1[0].COL1 === stringData.table1[0].col1
}
},
{
title: "Long string value",
title: 'Long string value',
description:
"Should send an object with a long string value under 32765 characters",
'Should send an object with a long string value under 32765 characters',
test: () => {
return adapter.request("common/sendObj", getLongStringData());
return adapter.request('common/sendObj', getLongStringData())
},
assertion: (res: any) => {
const longStringData = getLongStringData();
return res.table1[0].COL1 === longStringData.table1[0].col1;
const longStringData = getLongStringData()
return res.table1[0].COL1 === longStringData.table1[0].col1
}
},
{
title: "Overly long string value",
title: 'Overly long string value',
description:
"Should error out with long string values over 32765 characters",
'Should error out with long string values over 32765 characters',
test: () => {
return adapter
.request("common/sendObj", getLongStringData(32767))
.catch((e) => e);
.request('common/sendObj', getLongStringData(32767))
.catch((e) => e)
},
assertion: (error: any) => {
return !!error && !!error.error && !!error.error.message;
return !!error && !!error.error && !!error.error.message
}
},
{
title: "Single numeric value",
description: "Should send an object with a single numeric value",
title: 'Single numeric value',
description: 'Should send an object with a single numeric value',
test: () => {
return adapter.request("common/sendObj", numericData);
return adapter.request('common/sendObj', numericData)
},
assertion: (res: any) => {
return res.table1[0].COL1 === numericData.table1[0].col1;
return res.table1[0].COL1 === numericData.table1[0].col1
}
},
{
title: "Large data volume",
description: "Should send an object with a large amount of data",
title: 'Large data volume',
description: 'Should send an object with a large amount of data',
test: () => {
return adapter.request("common/sendObj", getLargeObjectData());
return adapter.request('common/sendObj', getLargeObjectData())
},
assertion: (res: any) => {
const data = getLargeObjectData();
return res.table1[9000].BIG === data.table1[9000].big;
const data = getLargeObjectData()
return res.table1[9000].BIG === data.table1[9000].big
}
},
{
title: "Multiple columns",
description: "Should handle data with multiple columns",
title: 'Multiple columns',
description: 'Should handle data with multiple columns',
test: () => {
return adapter.request("common/sendObj", multiColumnData);
return adapter.request('common/sendObj', multiColumnData)
},
assertion: (res: any) => {
return (
@@ -259,63 +256,63 @@ export const sendObjTests = (adapter: SASjs): TestSuite => ({
res.table1[0].COL2 === multiColumnData.table1[0].col2 &&
res.table1[0].COL3 === multiColumnData.table1[0].col3 &&
res.table1[0].COL4 === multiColumnData.table1[0].col4
);
)
}
},
{
title: "Multiple rows with nulls",
description: "Should handle data with multiple rows with null values",
title: 'Multiple rows with nulls',
description: 'Should handle data with multiple rows with null values',
test: () => {
return adapter.request("common/sendObj", multipleRowsWithNulls);
return adapter.request('common/sendObj', multipleRowsWithNulls)
},
assertion: (res: any) => {
let result = true;
let result = true
multipleRowsWithNulls.table1.forEach((_: any, index: number) => {
result =
result &&
res.table1[index].COL1 === multipleRowsWithNulls.table1[index].col1;
res.table1[index].COL1 === multipleRowsWithNulls.table1[index].col1
result =
result &&
res.table1[index].COL2 === multipleRowsWithNulls.table1[index].col2;
res.table1[index].COL2 === multipleRowsWithNulls.table1[index].col2
result =
result &&
res.table1[index].COL3 === multipleRowsWithNulls.table1[index].col3;
res.table1[index].COL3 === multipleRowsWithNulls.table1[index].col3
result =
result &&
res.table1[index].COL4 ===
(multipleRowsWithNulls.table1[index].col4 || " ");
});
return result;
(multipleRowsWithNulls.table1[index].col4 || ' ')
})
return result
}
},
{
title: "Multiple columns with nulls",
description: "Should handle data with multiple columns with null values",
title: 'Multiple columns with nulls',
description: 'Should handle data with multiple columns with null values',
test: () => {
return adapter.request("common/sendObj", multipleColumnsWithNulls);
return adapter.request('common/sendObj', multipleColumnsWithNulls)
},
assertion: (res: any) => {
let result = true;
let result = true
multipleColumnsWithNulls.table1.forEach((_: any, index: number) => {
result =
result &&
res.table1[index].COL1 ===
multipleColumnsWithNulls.table1[index].col1;
multipleColumnsWithNulls.table1[index].col1
result =
result &&
res.table1[index].COL2 ===
multipleColumnsWithNulls.table1[index].col2;
multipleColumnsWithNulls.table1[index].col2
result =
result &&
res.table1[index].COL3 ===
multipleColumnsWithNulls.table1[index].col3;
multipleColumnsWithNulls.table1[index].col3
result =
result &&
res.table1[index].COL4 ===
(multipleColumnsWithNulls.table1[index].col4 || " ");
});
return result;
(multipleColumnsWithNulls.table1[index].col4 || ' ')
})
return result
}
}
]
});
})

42
sasjs-tests/src/testSuites/SasjsRequests.ts
View File

@@ -1,49 +1,49 @@
import SASjs from "@sasjs/adapter";
import { TestSuite } from "@sasjs/test-framework";
import SASjs from '@sasjs/adapter'
import { TestSuite } from '@sasjs/test-framework'
const data: any = { table1: [{ col1: "first col value" }] };
const data: any = { table1: [{ col1: 'first col value' }] }
export const sasjsRequestTests = (adapter: SASjs): TestSuite => ({
name: "SASjs Requests",
name: 'SASjs Requests',
tests: [
{
title: "WORK tables",
description: "Should get WORK tables after request",
title: 'WORK tables',
description: 'Should get WORK tables after request',
test: async () => {
return adapter.request("common/sendArr", data);
return adapter.request('common/sendArr', data)
},
assertion: () => {
const requests = adapter.getSasRequests();
const requests = adapter.getSasRequests()
if (adapter.getSasjsConfig().debug) {
return requests[0].SASWORK !== null;
return requests[0].SASWORK !== null
} else {
return requests[0].SASWORK === null;
return requests[0].SASWORK === null
}
}
},
{
title: "Make error and capture log",
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",
'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 })
.request('common/makeErr', data, { debug: true })
.catch(() => {
const sasRequests = adapter.getSasRequests();
const sasRequests = adapter.getSasRequests()
const makeErrRequest: any =
sasRequests.find((req) => req.serviceLink.includes("makeErr")) ||
null;
sasRequests.find((req) => req.serviceLink.includes('makeErr')) ||
null
if (!makeErrRequest) return false;
if (!makeErrRequest) return false
return !!(
makeErrRequest.logFile && makeErrRequest.logFile.length > 0
);
});
)
})
},
assertion: (response) => {
return response;
return response
}
}
]
});
})

186
sasjs-tests/src/testSuites/SpecialCases.ts
View File

@@ -1,91 +1,92 @@
import SASjs from "@sasjs/adapter";
import { TestSuite } from "@sasjs/test-framework";
import SASjs from '@sasjs/adapter'
import { TestSuite } from '@sasjs/test-framework'
const specialCharData: any = {
table1: [
{
tab: "\t",
lf: "\n",
cr: "\r",
semicolon: ";semi",
percent: "%",
tab: '\t',
lf: '\n',
cr: '\r',
semicolon: ';semi',
percent: '%',
singleQuote: "'",
doubleQuote: '"',
crlf: "\r\n",
euro: "€euro",
banghash: "!#banghash"
crlf: '\r\n',
euro: '€euro',
banghash: '!#banghash',
dot: '.'
}
]
};
}
const moreSpecialCharData: any = {
table1: [
{
speech0: '"speech',
pct: "%percent",
pct: '%percent',
speech: '"speech',
slash: "\\slash",
slashWithSpecial: "\\\tslash",
macvar: "&sysuserid",
chinese: "传/傳chinese",
sigma: "Σsigma",
at: "@at",
serbian: "Српски",
dollar: "$"
slash: '\\slash',
slashWithSpecial: '\\\tslash',
macvar: '&sysuserid',
chinese: '传/傳chinese',
sigma: 'Σsigma',
at: '@at',
serbian: 'Српски',
dollar: '$'
}
]
};
}
const getWideData = () => {
const cols: any = {};
const cols: any = {}
for (let i = 1; i <= 10000; i++) {
cols["col" + i] = "test" + i;
cols['col' + i] = 'test' + i
}
const data: any = {
table1: [cols]
};
}
return data;
};
return data
}
const getTables = () => {
const tables: any = {};
const tables: any = {}
for (let i = 1; i <= 100; i++) {
tables["table" + i] = [{ col1: "x", col2: "x", col3: "x", col4: "x" }];
tables['table' + i] = [{ col1: 'x', col2: 'x', col3: 'x', col4: 'x' }]
}
return tables;
};
return tables
}
const getLargeDataset = () => {
const rows: any = [];
const rows: any = []
const colData: string =
"xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'
for (let i = 1; i <= 10000; i++) {
rows.push({ col1: colData, col2: colData, col3: colData, col4: colData });
rows.push({ col1: colData, col2: colData, col3: colData, col4: colData })
}
const data: any = {
table1: rows
};
}
return data;
};
return data
}
const errorAndCsrfData: any = {
error: [{ col1: "q", col2: "w", col3: "e", col4: "r" }],
_csrf: [{ col1: "q", col2: "w", col3: "e", col4: "r" }]
};
error: [{ col1: 'q', col2: 'w', col3: 'e', col4: 'r' }],
_csrf: [{ col1: 'q', col2: 'w', col3: 'e', col4: 'r' }]
}
export const specialCaseTests = (adapter: SASjs): TestSuite => ({
name: "Special Cases",
name: 'Special Cases',
tests: [
{
title: "Common special characters",
description: "Should handle common special characters",
title: 'Common special characters',
description: 'Should handle common special characters',
test: () => {
return adapter.request("common/sendArr", specialCharData);
return adapter.request('common/sendArr', specialCharData)
},
assertion: (res: any) => {
return (
@@ -96,17 +97,18 @@ export const specialCaseTests = (adapter: SASjs): TestSuite => ({
res.table1[0][4] === specialCharData.table1[0].percent &&
res.table1[0][5] === specialCharData.table1[0].singleQuote &&
res.table1[0][6] === specialCharData.table1[0].doubleQuote &&
res.table1[0][7] === "\n" &&
res.table1[0][7] === '\n' &&
res.table1[0][8] === specialCharData.table1[0].euro &&
res.table1[0][9] === specialCharData.table1[0].banghash
);
res.table1[0][9] === specialCharData.table1[0].banghash &&
res.table1[0][10] === specialCharData.table1[0].dot
)
}
},
{
title: "Other special characters",
description: "Should handle other special characters",
title: 'Other special characters',
description: 'Should handle other special characters',
test: () => {
return adapter.request("common/sendArr", moreSpecialCharData);
return adapter.request('common/sendArr', moreSpecialCharData)
},
assertion: (res: any) => {
return (
@@ -121,50 +123,50 @@ export const specialCaseTests = (adapter: SASjs): TestSuite => ({
res.table1[0][8] === moreSpecialCharData.table1[0].at &&
res.table1[0][9] === moreSpecialCharData.table1[0].serbian &&
res.table1[0][10] === moreSpecialCharData.table1[0].dollar
);
)
}
},
{
title: "Wide table with sendArr",
description: "Should handle data with 10000 columns",
title: 'Wide table with sendArr',
description: 'Should handle data with 10000 columns',
test: () => {
return adapter.request("common/sendArr", getWideData());
return adapter.request('common/sendArr', getWideData())
},
assertion: (res: any) => {
const data = getWideData();
let result = true;
const data = getWideData()
let result = true
for (let i = 0; i <= 10; i++) {
result =
result && res.table1[0][i] === data.table1[0]["col" + (i + 1)];
result && res.table1[0][i] === data.table1[0]['col' + (i + 1)]
}
return result;
return result
}
},
{
title: "Wide table with sendObj",
description: "Should handle data with 10000 columns",
title: 'Wide table with sendObj',
description: 'Should handle data with 10000 columns',
test: () => {
return adapter.request("common/sendObj", getWideData());
return adapter.request('common/sendObj', getWideData())
},
assertion: (res: any) => {
const data = getWideData();
let result = true;
const data = getWideData()
let result = true
for (let i = 0; i <= 10; i++) {
result =
result &&
res.table1[0]["COL" + (i + 1)] === data.table1[0]["col" + (i + 1)];
res.table1[0]['COL' + (i + 1)] === data.table1[0]['col' + (i + 1)]
}
return result;
return result
}
},
{
title: "Multiple tables",
description: "Should handle data with 100 tables",
title: 'Multiple tables',
description: 'Should handle data with 100 tables',
test: () => {
return adapter.request("common/sendArr", getTables());
return adapter.request('common/sendArr', getTables())
},
assertion: (res: any) => {
const data = getTables();
const data = getTables()
return (
res.table1[0][0] === data.table1[0].col1 &&
res.table1[0][1] === data.table1[0].col2 &&
@@ -174,45 +176,45 @@ export const specialCaseTests = (adapter: SASjs): TestSuite => ({
res.table50[0][1] === data.table50[0].col2 &&
res.table50[0][2] === data.table50[0].col3 &&
res.table50[0][3] === data.table50[0].col4
);
)
}
},
{
title: "Large dataset with sendObj",
description: "Should handle 5mb of data",
title: 'Large dataset with sendObj',
description: 'Should handle 5mb of data',
test: () => {
return adapter.request("common/sendObj", getLargeDataset());
return adapter.request('common/sendObj', getLargeDataset())
},
assertion: (res: any) => {
const data = getLargeDataset();
let result = true;
const data = getLargeDataset()
let result = true
for (let i = 0; i <= 10; i++) {
result = result && res.table1[i][0] === data.table1[i][0];
result = result && res.table1[i][0] === data.table1[i][0]
}
return result;
return result
}
},
{
title: "Large dataset with sendArr",
description: "Should handle 5mb of data",
title: 'Large dataset with sendArr',
description: 'Should handle 5mb of data',
test: () => {
return adapter.request("common/sendArr", getLargeDataset());
return adapter.request('common/sendArr', getLargeDataset())
},
assertion: (res: any) => {
const data = getLargeDataset();
let result = true;
const data = getLargeDataset()
let result = true
for (let i = 0; i <= 10; i++) {
result =
result && res.table1[i][0] === Object.values(data.table1[i])[0];
result && res.table1[i][0] === Object.values(data.table1[i])[0]
}
return result;
return result
}
},
{
title: "Error and _csrf tables with sendArr",
description: "Should handle error and _csrf tables",
title: 'Error and _csrf tables with sendArr',
description: 'Should handle error and _csrf tables',
test: () => {
return adapter.request("common/sendArr", errorAndCsrfData);
return adapter.request('common/sendArr', errorAndCsrfData)
},
assertion: (res: any) => {
return (
@@ -224,14 +226,14 @@ export const specialCaseTests = (adapter: SASjs): TestSuite => ({
res._csrf[0][1] === errorAndCsrfData._csrf[0].col2 &&
res._csrf[0][2] === errorAndCsrfData._csrf[0].col3 &&
res._csrf[0][3] === errorAndCsrfData._csrf[0].col4
);
)
}
},
{
title: "Error and _csrf tables with sendObj",
description: "Should handle error and _csrf tables",
title: 'Error and _csrf tables with sendObj',
description: 'Should handle error and _csrf tables',
test: () => {
return adapter.request("common/sendObj", errorAndCsrfData);
return adapter.request('common/sendObj', errorAndCsrfData)
},
assertion: (res: any) => {
return (
@@ -243,8 +245,8 @@ export const specialCaseTests = (adapter: SASjs): TestSuite => ({
res._csrf[0].COL2 === errorAndCsrfData._csrf[0].col2 &&
res._csrf[0].COL3 === errorAndCsrfData._csrf[0].col3 &&
res._csrf[0].COL4 === errorAndCsrfData._csrf[0].col4
);
)
}
}
]
});
})